commit 265d54a4843f7b5d560d709f29b50afcc9afc627
Author: Ziver Koc <ziver@koc.se>
Date:   Thu Feb 25 23:31:31 2021 +0100

    Initial Commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6da39d2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,14 @@
+### Trader files
+trader.conf
+
+### virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### Intellij
+.idea/
+
+### Gradle
+build/
+bin/
+target/
+.gradle/
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..5e7d720
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,22 @@
+plugins {
+    id 'java'
+}
+
+group 'se.koc.trader'
+version '0.0-SNAPSHOT'
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    implementation("se.koc:zutil:1.0.0-SNAPSHOT")
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
+}
+
+test {
+    useJUnitPlatform()
+}
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..e708b1c
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..be52383
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100644
index 0000000..4f906e0
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..107acd3
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..671c16c
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,2 @@
+rootProject.name = 'Trader'
+
diff --git a/src/main/java/se/koc/trader/TraderContext.java b/src/main/java/se/koc/trader/TraderContext.java
new file mode 100644
index 0000000..e520811
--- /dev/null
+++ b/src/main/java/se/koc/trader/TraderContext.java
@@ -0,0 +1,210 @@
+package se.koc.trader;
+
+import zutil.ObjectUtil;
+import zutil.db.DBConnection;
+import zutil.db.DBUpgradeHandler;
+import zutil.db.SQLResultHandler;
+import zutil.db.handler.PropertiesSQLResult;
+import zutil.io.file.FileUtil;
+import zutil.log.LogUtil;
+import zutil.ui.UserMessageManager;
+
+import java.io.File;
+import java.io.FileReader;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.logging.Logger;
+
+/**
+ * Static context of the application
+ */
+public class TraderContext {
+    private static final Logger logger = LogUtil.getLogger();
+
+    private static final String CONF_FILE       = "trader.conf";
+    private static final String DB_FILE         = "trader.db";
+    private static final String DEFAULT_DB_FILE = "/resource/trader-default.db";
+
+    public static final String PROPERTY_DB_VERSION = "trader.db_version";
+    public static final String PROPERTY_HTTP_PORT  = "trader.http_port";
+
+    public static final String RESOURCE_ROOT;
+    static {
+        if (FileUtil.find("build/resources/") != null)
+            RESOURCE_ROOT = "build/resources";
+        else if (FileUtil.find("resource/resource/") != null)
+            RESOURCE_ROOT = "resource";
+        else
+            RESOURCE_ROOT = ".";
+    }
+    public static final String RESOURCE_WEB_ROOT = RESOURCE_ROOT + "/web";
+
+    private static DBConnection db;
+    private static UserMessageManager messageManager = new UserMessageManager();
+
+    private static Properties fileConf = new Properties();
+    private static Properties dbConf   = new Properties();
+
+
+
+    public static void initialize(){
+        try {
+            // Read conf
+            if (FileUtil.find(CONF_FILE) != null) {
+                FileReader in = new FileReader(CONF_FILE);
+                fileConf.load(in);
+                in.close();
+            } else {
+                logger.info("No hal.conf file found");
+            }
+
+            if (FileUtil.find(DEFAULT_DB_FILE) == null){
+                logger.severe("Unable to find default DB: " + DEFAULT_DB_FILE);
+                System.exit(1);
+            }
+
+            // Init DB
+            File dbFile = FileUtil.find(DB_FILE);
+            db = new DBConnection(DBConnection.DBMS.SQLite, DB_FILE);
+
+            if(dbFile == null){
+                logger.info("No database file found, creating new DB...");
+            } else {
+                dbConf = db.exec("SELECT * FROM conf", new PropertiesSQLResult());
+            }
+
+            // Upgrade DB needed?
+            DBConnection referenceDB = new DBConnection(DBConnection.DBMS.SQLite, DEFAULT_DB_FILE);
+            Properties defaultDBConf =
+                    referenceDB.exec("SELECT * FROM conf", new PropertiesSQLResult());
+
+            // Check DB version
+            final int defaultDBVersion = Integer.parseInt(defaultDBConf.getProperty(PROPERTY_DB_VERSION));
+            final int dbVersion = (dbConf.getProperty(PROPERTY_DB_VERSION) != null ?
+                    Integer.parseInt(dbConf.getProperty(PROPERTY_DB_VERSION)) :
+                    -1);
+            logger.info("DB version: "+ dbVersion);
+
+            if(defaultDBVersion > dbVersion ) {
+                logger.info("Starting DB upgrade from v" + dbVersion + " to v" + defaultDBVersion + "...");
+                if(dbFile != null){
+                    File backupDB = FileUtil.getNextFile(dbFile);
+                    logger.fine("Backing up DB to: "+ backupDB);
+                    FileUtil.copy(dbFile, backupDB);
+                }
+
+                logger.fine(String.format("Upgrading DB (from: v%s, to: v%s)...", dbVersion, defaultDBVersion));
+                final DBUpgradeHandler handler = new DBUpgradeHandler(referenceDB);
+                handler.addIgnoredTable("db_version_history");
+                handler.addIgnoredTable("sqlite_sequence");	// sqlite internal
+                handler.setTargetDB(db);
+
+                logger.fine("Performing pre-upgrade activities");
+
+                // Read upgrade path preferences from the reference database
+                referenceDB.exec("SELECT * FROM db_version_history"
+                                + " WHERE db_version <= " + defaultDBVersion
+                                + " AND db_version > " + dbVersion,
+                        new SQLResultHandler<Object>() {
+                            @Override
+                            public Object handleQueryResult(Statement stmt, ResultSet result) throws SQLException {
+                                while(result.next()){
+                                    if(result.getBoolean("force_upgrade")){
+                                        logger.fine("Forced upgrade enabled");
+                                        handler.setForcedDBUpgrade(true);	//set to true if any of the intermediate db version requires it.
+                                    }
+                                }
+                                return null;
+                            }
+                        });
+
+                handler.upgrade();
+
+                logger.info("DB upgrade done");
+                setProperty(PROPERTY_DB_VERSION, defaultDBConf.getProperty(PROPERTY_DB_VERSION));
+            }
+            referenceDB.close();
+        } catch (Exception e){
+            throw new RuntimeException(e);
+        }
+    }
+
+
+    public static Map<String,String> getProperties() {
+        HashMap map = new HashMap();
+        map.putAll(dbConf);
+        map.putAll(fileConf);
+        return map;
+
+    }
+
+    public static boolean containsProperty(String key) {
+        return !ObjectUtil.isEmpty(getStringProperty(key));
+    }
+    public static String getStringProperty(String key){
+        String value = null;
+        if (fileConf != null)
+            value = fileConf.getProperty(key);
+        if (dbConf != null && value == null)
+            value = dbConf.getProperty(key);
+        return value;
+    }
+    public static String getStringProperty(String key, String defaultValue){
+        if (!containsProperty(key))
+            return defaultValue;
+        return getStringProperty(key);
+    }
+
+    public static int getIntegerProperty(String key){
+        String value = getStringProperty(key);
+
+        if (getStringProperty(key) == null)
+            return 0;
+        return Integer.parseInt(value);
+    }
+    public static int getIntegerProperty(String key, int defaultValue){
+        if (!containsProperty(key))
+            return defaultValue;
+        return getIntegerProperty(key);
+    }
+
+    public static boolean getBooleanProperty(String key) {
+        return Boolean.parseBoolean(getStringProperty(key));
+    }
+    public static boolean getBooleanProperty(String key, boolean defaultValue) {
+        if (!containsProperty(key))
+            return defaultValue;
+        return getBooleanProperty(key);
+    }
+
+    public static void setProperty(String key, String value) throws SQLException {
+        PreparedStatement stmt = db.getPreparedStatement("REPLACE INTO conf (key, value) VALUES (?, ?)");
+        stmt.setObject(1, key);
+        stmt.setObject(2, value);
+        DBConnection.exec(stmt);
+        dbConf.setProperty(key, value);
+    }
+
+
+
+    public static DBConnection getDB(){
+        return db;
+    }
+
+    /**
+     * For testing purposes.
+     */
+    public static void setDB(DBConnection db){
+        db = db;
+    }
+
+
+    public static UserMessageManager getMessageManager() {
+        return messageManager;
+    }
+}
diff --git a/src/main/java/se/koc/trader/TraderServer.java b/src/main/java/se/koc/trader/TraderServer.java
new file mode 100644
index 0000000..71b65bd
--- /dev/null
+++ b/src/main/java/se/koc/trader/TraderServer.java
@@ -0,0 +1,96 @@
+package se.koc.trader;
+
+import se.koc.trader.api.AlertEndpoint;
+import se.koc.trader.struct.PluginConfig;
+import se.koc.trader.web.TraderPage;
+import zutil.db.DBConnection;
+import zutil.io.file.FileUtil;
+import zutil.log.LogUtil;
+import zutil.net.http.HttpServer;
+import zutil.net.http.page.HttpFilePage;
+import zutil.net.http.page.HttpRedirectPage;
+import zutil.plugin.PluginData;
+import zutil.plugin.PluginManager;
+
+import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Logger;
+
+
+public class TraderServer {
+    private static final Logger logger = LogUtil.getLogger();
+
+    private static PluginManager pluginManager;
+    private static ScheduledExecutorService daemonExecutor;
+    private static HttpServer http;
+
+
+    public static void main(String[] args) throws SQLException {
+        // init logging
+        LogUtil.readConfiguration("logging.properties");
+
+        // Init DB and other things
+        TraderContext.initialize();
+
+        logger.info("Working directory: " + FileUtil.find(".").getAbsolutePath());
+
+        // init variables
+        pluginManager = new PluginManager();
+        daemonExecutor = Executors.newScheduledThreadPool(1); // We set only one thread for easier troubleshooting
+        http = new HttpServer(TraderContext.getIntegerProperty(TraderContext.PROPERTY_HTTP_PORT));
+
+        DBConnection db = TraderContext.getDB();
+
+        // ------------------------------------
+        // Initialize Plugins
+        // ------------------------------------
+
+        logger.info("Looking for plugins.");
+
+        // Disable plugins based on settings
+        for (PluginData plugin : getAllPlugins()) {
+            PluginConfig pluginConfig = PluginConfig.getPluginConfig(db, plugin.getName());
+
+            if (pluginConfig != null && !pluginConfig.isEnabled() && !plugin.getName().equals("Hal-Core")) {
+                logger.info("Disabling plugin '" + plugin.getName() + "'.");
+                plugin.setEnabled(false);
+            }
+        }
+
+        // ------------------------------------
+        // Init http server
+        // ------------------------------------
+
+        logger.info("Initializing HTTP Server.");
+
+        TraderPage.getRootNav().createSubNav("Sensors");
+        TraderPage.getRootNav().createSubNav("Events").setWeight(100);
+        TraderPage.getRootNav().createSubNav("Settings").setWeight(200);
+
+        http.setDefaultPage(new HttpFilePage(FileUtil.find(TraderContext.RESOURCE_WEB_ROOT)));
+        http.setPage("/", new HttpRedirectPage("/map"));
+        http.setPage(AlertEndpoint.getInstance().getPath(), AlertEndpoint.getInstance());
+        for (Iterator<TraderPage> it = pluginManager.getSingletonIterator(TraderPage.class); it.hasNext(); )
+            registerPage(it.next());
+        for (Iterator<TraderPage> it = pluginManager.getSingletonIterator(TraderPage.class); it.hasNext(); )
+            registerPage(it.next());
+        http.start();
+    }
+
+
+    public static List<PluginData> getEnabledPlugins() {
+        return pluginManager.toArray();
+    }
+
+    public static List<PluginData> getAllPlugins() {
+        return pluginManager.toArrayAll();
+    }
+
+
+    public static void registerPage(TraderPage page){
+        http.setPage(page.getId(), page);
+    }
+}
diff --git a/src/main/java/se/koc/trader/api/AlertEndpoint.java b/src/main/java/se/koc/trader/api/AlertEndpoint.java
new file mode 100644
index 0000000..330c920
--- /dev/null
+++ b/src/main/java/se/koc/trader/api/AlertEndpoint.java
@@ -0,0 +1,29 @@
+package se.koc.trader.api;
+
+import zutil.parser.DataNode;
+
+import java.util.Map;
+
+public class AlertEndpoint extends TraderAPI {
+    private static final String API_PATH = "/api/alert";
+
+    private static AlertEndpoint instance;
+
+
+    private AlertEndpoint() {
+        super(API_PATH);
+    }
+
+
+    @Override
+    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
+        return null;
+    }
+
+
+    public static AlertEndpoint getInstance() {
+        if (instance == null)
+            instance = new AlertEndpoint();
+        return instance;
+    }
+}
diff --git a/src/main/java/se/koc/trader/api/BotEndpoint.java b/src/main/java/se/koc/trader/api/BotEndpoint.java
new file mode 100644
index 0000000..50e789e
--- /dev/null
+++ b/src/main/java/se/koc/trader/api/BotEndpoint.java
@@ -0,0 +1,22 @@
+package se.koc.trader.api;
+
+import se.koc.trader.TraderContext;
+import se.koc.trader.web.TraderPage;
+import zutil.parser.DataNode;
+import zutil.parser.Templator;
+
+import java.util.Map;
+
+public class BotEndpoint extends TraderAPI {
+    private static final String API_PATH = "/api/bot/.*";
+
+    public BotEndpoint() {
+        super(API_PATH);
+    }
+
+
+    @Override
+    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
+        return null;
+    }
+}
diff --git a/src/main/java/se/koc/trader/api/MarketEndpoint.java b/src/main/java/se/koc/trader/api/MarketEndpoint.java
new file mode 100644
index 0000000..ac8aec9
--- /dev/null
+++ b/src/main/java/se/koc/trader/api/MarketEndpoint.java
@@ -0,0 +1,18 @@
+package se.koc.trader.api;
+
+import zutil.parser.DataNode;
+
+import java.util.Map;
+
+public class MarketEndpoint extends TraderAPI {
+    private static final String API_PATH = "/api/market/.*";
+
+    public MarketEndpoint() {
+        super(API_PATH);
+    }
+
+    @Override
+    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
+        return null;
+    }
+}
diff --git a/src/main/java/se/koc/trader/api/TraderAPI.java b/src/main/java/se/koc/trader/api/TraderAPI.java
new file mode 100644
index 0000000..371490b
--- /dev/null
+++ b/src/main/java/se/koc/trader/api/TraderAPI.java
@@ -0,0 +1,64 @@
+package se.koc.trader.api;
+
+import zutil.log.LogUtil;
+import zutil.net.http.HttpHeader;
+import zutil.net.http.HttpPage;
+import zutil.net.http.HttpPrintStream;
+import zutil.parser.DataNode;
+import zutil.parser.Templator;
+import zutil.parser.json.JSONWriter;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A interface defining a Hal json endpoint
+ */
+public abstract class TraderAPI implements HttpPage {
+    private static final Logger logger = LogUtil.getLogger();
+
+    private String path;
+
+
+    public TraderAPI(String path) {
+        this.path = path;
+    }
+
+
+    public String getPath() {
+        return path;
+    }
+
+
+    @Override
+    public void respond(HttpPrintStream out,
+                        HttpHeader headers,
+                        Map<String, Object> session,
+                        Map<String, String> cookie,
+                        Map<String, String> request) throws IOException {
+
+        out.setHeader("Content-Type", "application/json");
+        out.setHeader("Access-Control-Allow-Origin", "*");
+        out.setHeader("Pragma", "no-cache");
+
+        JSONWriter writer = new JSONWriter(out);
+        try{
+            writer.write(
+                    jsonRespond(session, cookie, request));
+        } catch (Exception e){
+            logger.log(Level.SEVERE, null, e);
+            DataNode root = new DataNode(DataNode.DataType.Map);
+            root.set("error", e.getMessage());
+            writer.write(root);
+        }
+        writer.close();
+    }
+
+
+    protected abstract DataNode jsonRespond(
+            Map<String, Object> session,
+            Map<String, String> cookie,
+            Map<String, String> request) throws Exception;
+}
\ No newline at end of file
diff --git a/src/main/java/se/koc/trader/exchange/ExchangeMarket.java b/src/main/java/se/koc/trader/exchange/ExchangeMarket.java
new file mode 100644
index 0000000..150624c
--- /dev/null
+++ b/src/main/java/se/koc/trader/exchange/ExchangeMarket.java
@@ -0,0 +1,4 @@
+package se.koc.trader.exchange;
+
+public interface ExchangeMarket {
+}
diff --git a/src/main/java/se/koc/trader/exchange/ExchangeTrader.java b/src/main/java/se/koc/trader/exchange/ExchangeTrader.java
new file mode 100644
index 0000000..30b09aa
--- /dev/null
+++ b/src/main/java/se/koc/trader/exchange/ExchangeTrader.java
@@ -0,0 +1,4 @@
+package se.koc.trader.exchange;
+
+public interface ExchangeTrader {
+}
diff --git a/src/main/java/se/koc/trader/exchange/binance/BinanceMarketImpl.java b/src/main/java/se/koc/trader/exchange/binance/BinanceMarketImpl.java
new file mode 100644
index 0000000..adc2e1e
--- /dev/null
+++ b/src/main/java/se/koc/trader/exchange/binance/BinanceMarketImpl.java
@@ -0,0 +1,34 @@
+package se.koc.trader.exchange.binance;
+
+import se.koc.trader.exchange.ExchangeMarket;
+import se.koc.trader.struct.Symbol;
+import zutil.net.ws.rest.RESTClientFactory;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.List;
+
+public class BinanceMarketImpl implements ExchangeMarket {
+
+    private BinanceRestAPI rest;
+
+
+    public BinanceMarketImpl() {
+        try {
+            rest = RESTClientFactory.createClient(new URL("https://api.binance.com"), BinanceRestAPI.class);
+        } catch (MalformedURLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+
+
+    public List<Symbol> getSigns() {
+        return null; // /api/v3/ticker/price
+    }
+
+    public Symbol getSymbol(String symbol) {
+        return null; // /api/v3/ticker/price?symbol=xxx
+    }
+}
diff --git a/src/main/java/se/koc/trader/exchange/binance/BinanceRestAPI.java b/src/main/java/se/koc/trader/exchange/binance/BinanceRestAPI.java
new file mode 100644
index 0000000..cb6c7b7
--- /dev/null
+++ b/src/main/java/se/koc/trader/exchange/binance/BinanceRestAPI.java
@@ -0,0 +1,80 @@
+package se.koc.trader.exchange.binance;
+
+import zutil.net.ws.WSInterface;
+import zutil.parser.DataNode;
+
+/**
+ * @see <a href="https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md">Binance REST API sdocumentation</a>
+ */
+public interface BinanceRestAPI extends WSInterface {
+    enum CandlestickInterval {
+        Minute("1m"), Minute_x3("3m"), Minute_x5("5m"), Minute_x15("15m"), Minute_x30("30m"),
+        Hour("1h"), Hour_x2("2h"), Hour_x4("4h"), Hour_x6("6h"), Hour_x8("8h"), Hour_x12("12h"),
+        Day("1d"), Day_x3("3d"),
+        Week("1w"),
+        Month("1M");
+
+        String interval;
+
+        CandlestickInterval(String interval) {
+            this.interval = interval;
+        }
+
+        public String toString() {
+            return interval;
+        }
+    }
+
+
+    /**
+     * Test connectivity to the Rest API and get the current server time.
+     * <p></p><pre>GET /api/v3/time</pre>
+     *
+     * @return the current server time in EPOC
+     */
+    @WSPath("/api/v3/time")
+    long getServerTime();
+
+    /**
+     * Current exchange trading rules and symbol information.
+     * <p></p><pre>GET /api/v3/exchangeInfo</pre>
+     */
+    @WSPath("/api/v3/exchangeInfo")
+    DataNode getExchangeInfo();
+
+    /**
+     * Kline/candlestick bars for a symbol, method will return the latest data.
+     * Klines are uniquely identified by their open time.
+     * <p></p><pre>GET /api/v3/klines</pre>
+     *
+     * @param symbol    is the symbol identity
+     * @param interval  is the intervall of candlestick data
+     * @param limit     is the maximum amount of candlesticks to return, max is 1000
+     */
+    @WSPath("/api/v3/klines")
+    DataNode getCandlestickData(String symbol, CandlestickInterval interval, int limit);
+
+    /**
+     * Kline/candlestick bars for a symbol.
+     * Klines are uniquely identified by their open time.
+     * <p></p><pre>GET /api/v3/klines</pre>
+     *
+     * @param symbol    is the symbol identity
+     * @param interval  is the intervall of candlestick data
+     * @param startTime is the start of the time range of the data
+     * @param endTime   is the end of the time range for data
+     * @param limit     is the maximum amount of candlesticks to return, max is 1000
+     */
+    @WSPath("/api/v3/klines")
+    DataNode getCandlestickData(String symbol, CandlestickInterval interval, long startTime, long endTime, int limit);
+
+    /**
+     * Latest price for a symbol.
+     * <p></p><pre>GET /api/v3/ticker/price</pre>
+     *
+     * @param symbol    is the symbol identity
+     * @return JSON example => <pre>{"symbol": "LTCBTC", "price": "4.00000200"}</pre>
+     */
+    @WSPath("/api/v3/ticker/price")
+    DataNode getPrice(String symbol);
+}
diff --git a/src/main/java/se/koc/trader/exchange/binance/plugin.json b/src/main/java/se/koc/trader/exchange/binance/plugin.json
new file mode 100644
index 0000000..0f788bc
--- /dev/null
+++ b/src/main/java/se/koc/trader/exchange/binance/plugin.json
@@ -0,0 +1,8 @@
+{
+	"version": 0.1,
+	"name": "Exchange-Binance",
+	"description": "Plugin contains core logic for running Trader.",
+	"interfaces": [
+		{"se.koc.trader.exchange.ExchangeMarket": "se.koc.trader.exchange.binance.BinanceMarketImpl"}
+	]
+}
diff --git a/src/main/java/se/koc/trader/plugin.json b/src/main/java/se/koc/trader/plugin.json
new file mode 100644
index 0000000..629358d
--- /dev/null
+++ b/src/main/java/se/koc/trader/plugin.json
@@ -0,0 +1,9 @@
+{
+	"version": 0.1,
+	"name": "Trader-Core",
+	"description": "Plugin contains core logic for running Trader.",
+	"interfaces": [
+		{"se.koc.trader.api.TraderAPI": "se.hal.page.SensorOverviewWebPage"},
+		{"se.koc.trader.api.TraderAPI": "se.hal.page.SensorConfigWebPage"}
+	]
+}
diff --git a/src/main/java/se/koc/trader/struct/CandleStick.java b/src/main/java/se/koc/trader/struct/CandleStick.java
new file mode 100644
index 0000000..ebfe565
--- /dev/null
+++ b/src/main/java/se/koc/trader/struct/CandleStick.java
@@ -0,0 +1,76 @@
+package se.koc.trader.struct;
+
+import zutil.db.bean.DBBean;
+
+/**
+ * Data class containing information about a single candlestick.
+ */
+@DBBean.DBTable("candlestick")
+public class CandleStick {
+    private Symbol symbol;
+    private long timestampOpen;
+    private long timestampClosed;
+
+    private double bodyOpen;
+    private double bodyClose;
+    private double wickHigh;
+    private double wickLow;
+    private double volume;
+
+
+    public Symbol getSymbol() {
+        return symbol;
+    }
+    public void setSymbol(Symbol symbol) {
+        this.symbol = symbol;
+    }
+
+    public long getTimestampOpen() {
+        return timestampOpen;
+    }
+    public void setTimestampOpen(long timestampOpen) {
+        this.timestampOpen = timestampOpen;
+    }
+
+    public long getTimestampClosed() {
+        return timestampClosed;
+    }
+    public void setTimestampClosed(long timestampClosed) {
+        this.timestampClosed = timestampClosed;
+    }
+
+    public double getBodyOpen() {
+        return bodyOpen;
+    }
+    public void setBodyOpen(double bodyOpen) {
+        this.bodyOpen = bodyOpen;
+    }
+
+    public double getWickHigh() {
+        return wickHigh;
+    }
+    public void setWickHigh(double wickHigh) {
+        this.wickHigh = wickHigh;
+    }
+
+    public double getWickLow() {
+        return wickLow;
+    }
+    public void setWickLow(double wickLow) {
+        this.wickLow = wickLow;
+    }
+
+    public double getBodyClose() {
+        return bodyClose;
+    }
+    public void setBodyClose(double bodyClose) {
+        this.bodyClose = bodyClose;
+    }
+
+    public double getVolume() {
+        return volume;
+    }
+    public void setVolume(double volume) {
+        this.volume = volume;
+    }
+}
diff --git a/src/main/java/se/koc/trader/struct/PluginConfig.java b/src/main/java/se/koc/trader/struct/PluginConfig.java
new file mode 100644
index 0000000..f70fd05
--- /dev/null
+++ b/src/main/java/se/koc/trader/struct/PluginConfig.java
@@ -0,0 +1,68 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Ziver Koc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package se.koc.trader.struct;
+
+import zutil.db.DBConnection;
+import zutil.db.bean.DBBean;
+import zutil.db.bean.DBBeanSQLResultHandler;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+
+@DBBean.DBTable(value="plugin")
+public class PluginConfig extends DBBean {
+    private String name;
+    private boolean enabled;
+
+
+    /**
+     * @return a PluginConfig bean for the specific plugin name.
+     */
+    public static PluginConfig getPluginConfig(DBConnection db, String name) throws SQLException {
+        PreparedStatement stmt = db.getPreparedStatement( "SELECT plugin.* FROM plugin WHERE name == ?" );
+        stmt.setString(1, name);
+        return DBConnection.exec(stmt, DBBeanSQLResultHandler.create(PluginConfig.class, db) );
+    }
+
+
+    public PluginConfig() {}
+    public PluginConfig(String name) {
+        this.name = name;
+    }
+
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+}
diff --git a/src/main/java/se/koc/trader/struct/Symbol.java b/src/main/java/se/koc/trader/struct/Symbol.java
new file mode 100644
index 0000000..660d185
--- /dev/null
+++ b/src/main/java/se/koc/trader/struct/Symbol.java
@@ -0,0 +1,48 @@
+package se.koc.trader.struct;
+
+import zutil.db.bean.DBBean;
+
+/**
+ * A data class referencing a symbol
+ */
+@DBBean.DBTable("symbol")
+public class Symbol extends DBBean {
+    private String baseAsset;
+    private String quoteAsset;
+    private double price;
+    private long priceTimestamp;
+
+
+    public String getBaseAsset() {
+        return baseAsset;
+    }
+    public void setBaseAsset(String baseAsset) {
+        this.baseAsset = baseAsset;
+    }
+
+    public String getQuoteAsset() {
+        return quoteAsset;
+    }
+    public void setQuoteAsset(String quoteAsset) {
+        this.quoteAsset = quoteAsset;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+    public void setPrice(double price) {
+        this.price = price;
+    }
+
+    public long getPriceTimestamp() {
+        return priceTimestamp;
+    }
+    public void setPriceTimestamp(long priceTimestamp) {
+        this.priceTimestamp = priceTimestamp;
+    }
+
+
+    public String toString() {
+        return baseAsset + "/" +quoteAsset;
+    }
+}
diff --git a/src/main/java/se/koc/trader/web/TraderPage.java b/src/main/java/se/koc/trader/web/TraderPage.java
new file mode 100644
index 0000000..c9e3b2b
--- /dev/null
+++ b/src/main/java/se/koc/trader/web/TraderPage.java
@@ -0,0 +1,84 @@
+package se.koc.trader.web;
+
+import se.koc.trader.TraderContext;
+import zutil.io.file.FileUtil;
+import zutil.net.http.HttpHeader;
+import zutil.net.http.HttpPage;
+import zutil.net.http.HttpPrintStream;
+import zutil.parser.Templator;
+import zutil.ui.Navigation;
+import zutil.ui.UserMessageManager;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+public abstract class TraderPage implements HttpPage{
+    private static final String TEMPLATE = TraderContext.RESOURCE_WEB_ROOT + "/main_index.tmpl";
+    private static Navigation rootNav = Navigation.createRootNav();
+    private static Navigation userNav = Navigation.createRootNav();
+
+    private String pageId;
+    private boolean showSubNav;
+
+    public TraderPage(String id){
+        this.pageId = id;
+        this.showSubNav = true;
+    }
+
+    public String getId(){
+        return pageId;
+    }
+
+
+    @Override
+    public void respond(HttpPrintStream out, HttpHeader header,
+                        Map<String, Object> session, Map<String, String> cookie,
+                        Map<String, String> request) throws IOException {
+        try {
+            List<UserMessageManager.UserMessage> messages = TraderContext.getMessageManager().getMessages();
+            for (UserMessageManager.UserMessage msg : messages) {
+                msg.decreaseTTL();
+            }
+
+            Templator tmpl = new Templator(FileUtil.find(TEMPLATE));
+            tmpl.set("rootNav", rootNav.createPagedNavInstance(header).getSubNavs());
+            tmpl.set("userNav", userNav.createPagedNavInstance(header).getSubNavs());
+            tmpl.set("content", httpRespond(session, cookie, request));
+            tmpl.set("alerts", messages);
+
+            tmpl.set("showSubNav", showSubNav);
+            if (showSubNav) {
+                List<Navigation> breadcrumb = Navigation.getBreadcrumb(Navigation.getPagedNavigation(header));
+                if (!breadcrumb.isEmpty())
+                    tmpl.set("subNav", breadcrumb.get(1).createPagedNavInstance(header).getSubNavs());
+            }
+
+            out.print(tmpl.compile());
+        } catch (Exception e) {
+            throw new IOException(e);
+        }
+    }
+
+    /**
+     * Defines if the sub-navigation should be shown on the page
+     */
+    protected void showSubNav(boolean show) {
+        this.showSubNav = show;
+    }
+
+    public static Navigation getRootNav(){
+        return rootNav;
+    }
+    public static Navigation getUserNav(){
+        return userNav;
+    }
+
+
+    public abstract Templator httpRespond(
+            Map<String, Object> session,
+            Map<String, String> cookie,
+            Map<String, String> request)
+                throws Exception;
+
+}
\ No newline at end of file
diff --git a/src/main/resources/trader-default.db b/src/main/resources/trader-default.db
new file mode 100644
index 0000000..d69246d
Binary files /dev/null and b/src/main/resources/trader-default.db differ
diff --git a/src/main/resources/web/css/bootstrap.css b/src/main/resources/web/css/bootstrap.css
new file mode 100644
index 0000000..54ce4d8
--- /dev/null
+++ b/src/main/resources/web/css/bootstrap.css
@@ -0,0 +1,10724 @@
+@charset "UTF-8";
+/*!
+ * Bootstrap v5.0.0-beta2 (https://getbootstrap.com/)
+ * Copyright 2011-2021 The Bootstrap Authors
+ * Copyright 2011-2021 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */
+:root {
+  --bs-blue: #0d6efd;
+  --bs-indigo: #6610f2;
+  --bs-purple: #6f42c1;
+  --bs-pink: #d63384;
+  --bs-red: #dc3545;
+  --bs-orange: #fd7e14;
+  --bs-yellow: #ffc107;
+  --bs-green: #198754;
+  --bs-teal: #20c997;
+  --bs-cyan: #0dcaf0;
+  --bs-white: #fff;
+  --bs-gray: #6c757d;
+  --bs-gray-dark: #343a40;
+  --bs-primary: #0d6efd;
+  --bs-secondary: #6c757d;
+  --bs-success: #198754;
+  --bs-info: #0dcaf0;
+  --bs-warning: #ffc107;
+  --bs-danger: #dc3545;
+  --bs-light: #f8f9fa;
+  --bs-dark: #212529;
+  --bs-font-sans-serif: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  --bs-font-monospace: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  --bs-gradient: linear-gradient(180deg, rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0));
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  :root {
+    scroll-behavior: smooth;
+  }
+}
+
+body {
+  margin: 0;
+  font-family: var(--bs-font-sans-serif);
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  -webkit-text-size-adjust: 100%;
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+
+[tabindex="-1"]:focus:not(:focus-visible) {
+  outline: 0 !important;
+}
+
+hr {
+  margin: 1rem 0;
+  color: inherit;
+  background-color: currentColor;
+  border: 0;
+  opacity: 0.25;
+}
+
+hr:not([size]) {
+  height: 1px;
+}
+
+h6, .h6, h5, .h5, h4, .h4, h3, .h3, h2, .h2, h1, .h1 {
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+  font-weight: 500;
+  line-height: 1.2;
+}
+
+h1, .h1 {
+  font-size: calc(1.375rem + 1.5vw);
+}
+@media (min-width: 1200px) {
+  h1, .h1 {
+    font-size: 2.5rem;
+  }
+}
+
+h2, .h2 {
+  font-size: calc(1.325rem + 0.9vw);
+}
+@media (min-width: 1200px) {
+  h2, .h2 {
+    font-size: 2rem;
+  }
+}
+
+h3, .h3 {
+  font-size: calc(1.3rem + 0.6vw);
+}
+@media (min-width: 1200px) {
+  h3, .h3 {
+    font-size: 1.75rem;
+  }
+}
+
+h4, .h4 {
+  font-size: calc(1.275rem + 0.3vw);
+}
+@media (min-width: 1200px) {
+  h4, .h4 {
+    font-size: 1.5rem;
+  }
+}
+
+h5, .h5 {
+  font-size: 1.25rem;
+}
+
+h6, .h6 {
+  font-size: 1rem;
+}
+
+p {
+  margin-top: 0;
+  margin-bottom: 1rem;
+}
+
+abbr[title],
+abbr[data-bs-original-title] {
+  text-decoration: underline;
+  -webkit-text-decoration: underline dotted;
+  text-decoration: underline dotted;
+  cursor: help;
+  -webkit-text-decoration-skip-ink: none;
+  text-decoration-skip-ink: none;
+}
+
+address {
+  margin-bottom: 1rem;
+  font-style: normal;
+  line-height: inherit;
+}
+
+ol,
+ul {
+  padding-left: 2rem;
+}
+
+ol,
+ul,
+dl {
+  margin-top: 0;
+  margin-bottom: 1rem;
+}
+
+ol ol,
+ul ul,
+ol ul,
+ul ol {
+  margin-bottom: 0;
+}
+
+dt {
+  font-weight: 700;
+}
+
+dd {
+  margin-bottom: 0.5rem;
+  margin-left: 0;
+}
+
+blockquote {
+  margin: 0 0 1rem;
+}
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+small, .small {
+  font-size: 0.875em;
+}
+
+mark, .mark {
+  padding: 0.2em;
+  background-color: #fcf8e3;
+}
+
+sub,
+sup {
+  position: relative;
+  font-size: 0.75em;
+  line-height: 0;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+a {
+  color: #0d6efd;
+  text-decoration: underline;
+}
+a:hover {
+  color: #0a58ca;
+}
+
+a:not([href]):not([class]), a:not([href]):not([class]):hover {
+  color: inherit;
+  text-decoration: none;
+}
+
+pre,
+code,
+kbd,
+samp {
+  font-family: var(--bs-font-monospace);
+  font-size: 1em;
+  direction: ltr /* rtl:ignore */;
+  unicode-bidi: bidi-override;
+}
+
+pre {
+  display: block;
+  margin-top: 0;
+  margin-bottom: 1rem;
+  overflow: auto;
+  font-size: 0.875em;
+}
+pre code {
+  font-size: inherit;
+  color: inherit;
+  word-break: normal;
+}
+
+code {
+  font-size: 0.875em;
+  color: #d63384;
+  word-wrap: break-word;
+}
+a > code {
+  color: inherit;
+}
+
+kbd {
+  padding: 0.2rem 0.4rem;
+  font-size: 0.875em;
+  color: #fff;
+  background-color: #212529;
+  border-radius: 0.2rem;
+}
+kbd kbd {
+  padding: 0;
+  font-size: 1em;
+  font-weight: 700;
+}
+
+figure {
+  margin: 0 0 1rem;
+}
+
+img,
+svg {
+  vertical-align: middle;
+}
+
+table {
+  caption-side: bottom;
+  border-collapse: collapse;
+}
+
+caption {
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+  color: #6c757d;
+  text-align: left;
+}
+
+th {
+  text-align: inherit;
+  text-align: -webkit-match-parent;
+}
+
+thead,
+tbody,
+tfoot,
+tr,
+td,
+th {
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+}
+
+label {
+  display: inline-block;
+}
+
+button {
+  border-radius: 0;
+}
+
+button:focus:not(:focus-visible) {
+  outline: 0;
+}
+
+input,
+button,
+select,
+optgroup,
+textarea {
+  margin: 0;
+  font-family: inherit;
+  font-size: inherit;
+  line-height: inherit;
+}
+
+button,
+select {
+  text-transform: none;
+}
+
+[role=button] {
+  cursor: pointer;
+}
+
+select {
+  word-wrap: normal;
+}
+
+[list]::-webkit-calendar-picker-indicator {
+  display: none;
+}
+
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+button:not(:disabled),
+[type=button]:not(:disabled),
+[type=reset]:not(:disabled),
+[type=submit]:not(:disabled) {
+  cursor: pointer;
+}
+
+::-moz-focus-inner {
+  padding: 0;
+  border-style: none;
+}
+
+textarea {
+  resize: vertical;
+}
+
+fieldset {
+  min-width: 0;
+  padding: 0;
+  margin: 0;
+  border: 0;
+}
+
+legend {
+  float: left;
+  width: 100%;
+  padding: 0;
+  margin-bottom: 0.5rem;
+  font-size: calc(1.275rem + 0.3vw);
+  line-height: inherit;
+}
+@media (min-width: 1200px) {
+  legend {
+    font-size: 1.5rem;
+  }
+}
+legend + * {
+  clear: left;
+}
+
+::-webkit-datetime-edit-fields-wrapper,
+::-webkit-datetime-edit-text,
+::-webkit-datetime-edit-minute,
+::-webkit-datetime-edit-hour-field,
+::-webkit-datetime-edit-day-field,
+::-webkit-datetime-edit-month-field,
+::-webkit-datetime-edit-year-field {
+  padding: 0;
+}
+
+::-webkit-inner-spin-button {
+  height: auto;
+}
+
+[type=search] {
+  outline-offset: -2px;
+  -webkit-appearance: textfield;
+}
+
+/* rtl:raw:
+[type="tel"],
+[type="url"],
+[type="email"],
+[type="number"] {
+  direction: ltr;
+}
+*/
+::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+::-webkit-color-swatch-wrapper {
+  padding: 0;
+}
+
+::file-selector-button {
+  font: inherit;
+}
+
+::-webkit-file-upload-button {
+  font: inherit;
+  -webkit-appearance: button;
+}
+
+output {
+  display: inline-block;
+}
+
+iframe {
+  border: 0;
+}
+
+summary {
+  display: list-item;
+  cursor: pointer;
+}
+
+progress {
+  vertical-align: baseline;
+}
+
+[hidden] {
+  display: none !important;
+}
+
+.lead {
+  font-size: 1.25rem;
+  font-weight: 300;
+}
+
+.display-1 {
+  font-size: calc(1.625rem + 4.5vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-1 {
+    font-size: 5rem;
+  }
+}
+
+.display-2 {
+  font-size: calc(1.575rem + 3.9vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-2 {
+    font-size: 4.5rem;
+  }
+}
+
+.display-3 {
+  font-size: calc(1.525rem + 3.3vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-3 {
+    font-size: 4rem;
+  }
+}
+
+.display-4 {
+  font-size: calc(1.475rem + 2.7vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-4 {
+    font-size: 3.5rem;
+  }
+}
+
+.display-5 {
+  font-size: calc(1.425rem + 2.1vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-5 {
+    font-size: 3rem;
+  }
+}
+
+.display-6 {
+  font-size: calc(1.375rem + 1.5vw);
+  font-weight: 300;
+  line-height: 1.2;
+}
+@media (min-width: 1200px) {
+  .display-6 {
+    font-size: 2.5rem;
+  }
+}
+
+.list-unstyled {
+  padding-left: 0;
+  list-style: none;
+}
+
+.list-inline {
+  padding-left: 0;
+  list-style: none;
+}
+
+.list-inline-item {
+  display: inline-block;
+}
+.list-inline-item:not(:last-child) {
+  margin-right: 0.5rem;
+}
+
+.initialism {
+  font-size: 0.875em;
+  text-transform: uppercase;
+}
+
+.blockquote {
+  margin-bottom: 1rem;
+  font-size: 1.25rem;
+}
+.blockquote > :last-child {
+  margin-bottom: 0;
+}
+
+.blockquote-footer {
+  margin-top: -1rem;
+  margin-bottom: 1rem;
+  font-size: 0.875em;
+  color: #6c757d;
+}
+.blockquote-footer::before {
+  content: "— ";
+}
+
+.img-fluid {
+  max-width: 100%;
+  height: auto;
+}
+
+.img-thumbnail {
+  padding: 0.25rem;
+  background-color: #fff;
+  border: 1px solid #dee2e6;
+  border-radius: 0.25rem;
+  max-width: 100%;
+  height: auto;
+}
+
+.figure {
+  display: inline-block;
+}
+
+.figure-img {
+  margin-bottom: 0.5rem;
+  line-height: 1;
+}
+
+.figure-caption {
+  font-size: 0.875em;
+  color: #6c757d;
+}
+
+.container,
+.container-fluid,
+.container-xxl,
+.container-xl,
+.container-lg,
+.container-md,
+.container-sm {
+  width: 100%;
+  padding-right: var(--bs-gutter-x, 0.75rem);
+  padding-left: var(--bs-gutter-x, 0.75rem);
+  margin-right: auto;
+  margin-left: auto;
+}
+
+@media (min-width: 576px) {
+  .container-sm, .container {
+    max-width: 540px;
+  }
+}
+@media (min-width: 768px) {
+  .container-md, .container-sm, .container {
+    max-width: 720px;
+  }
+}
+@media (min-width: 992px) {
+  .container-lg, .container-md, .container-sm, .container {
+    max-width: 960px;
+  }
+}
+@media (min-width: 1200px) {
+  .container-xl, .container-lg, .container-md, .container-sm, .container {
+    max-width: 1140px;
+  }
+}
+@media (min-width: 1400px) {
+  .container-xxl, .container-xl, .container-lg, .container-md, .container-sm, .container {
+    max-width: 1320px;
+  }
+}
+.row {
+  --bs-gutter-x: 1.5rem;
+  --bs-gutter-y: 0;
+  display: flex;
+  flex-wrap: wrap;
+  margin-top: calc(var(--bs-gutter-y) * -1);
+  margin-right: calc(var(--bs-gutter-x) / -2);
+  margin-left: calc(var(--bs-gutter-x) / -2);
+}
+.row > * {
+  flex-shrink: 0;
+  width: 100%;
+  max-width: 100%;
+  padding-right: calc(var(--bs-gutter-x) / 2);
+  padding-left: calc(var(--bs-gutter-x) / 2);
+  margin-top: var(--bs-gutter-y);
+}
+
+.col {
+  flex: 1 0 0%;
+}
+
+.row-cols-auto > * {
+  flex: 0 0 auto;
+  width: auto;
+}
+
+.row-cols-1 > * {
+  flex: 0 0 auto;
+  width: 100%;
+}
+
+.row-cols-2 > * {
+  flex: 0 0 auto;
+  width: 50%;
+}
+
+.row-cols-3 > * {
+  flex: 0 0 auto;
+  width: 33.3333333333%;
+}
+
+.row-cols-4 > * {
+  flex: 0 0 auto;
+  width: 25%;
+}
+
+.row-cols-5 > * {
+  flex: 0 0 auto;
+  width: 20%;
+}
+
+.row-cols-6 > * {
+  flex: 0 0 auto;
+  width: 16.6666666667%;
+}
+
+.col-auto {
+  flex: 0 0 auto;
+  width: auto;
+}
+
+.col-1 {
+  flex: 0 0 auto;
+  width: 8.3333333333%;
+}
+
+.col-2 {
+  flex: 0 0 auto;
+  width: 16.6666666667%;
+}
+
+.col-3 {
+  flex: 0 0 auto;
+  width: 25%;
+}
+
+.col-4 {
+  flex: 0 0 auto;
+  width: 33.3333333333%;
+}
+
+.col-5 {
+  flex: 0 0 auto;
+  width: 41.6666666667%;
+}
+
+.col-6 {
+  flex: 0 0 auto;
+  width: 50%;
+}
+
+.col-7 {
+  flex: 0 0 auto;
+  width: 58.3333333333%;
+}
+
+.col-8 {
+  flex: 0 0 auto;
+  width: 66.6666666667%;
+}
+
+.col-9 {
+  flex: 0 0 auto;
+  width: 75%;
+}
+
+.col-10 {
+  flex: 0 0 auto;
+  width: 83.3333333333%;
+}
+
+.col-11 {
+  flex: 0 0 auto;
+  width: 91.6666666667%;
+}
+
+.col-12 {
+  flex: 0 0 auto;
+  width: 100%;
+}
+
+.offset-1 {
+  margin-left: 8.3333333333%;
+}
+
+.offset-2 {
+  margin-left: 16.6666666667%;
+}
+
+.offset-3 {
+  margin-left: 25%;
+}
+
+.offset-4 {
+  margin-left: 33.3333333333%;
+}
+
+.offset-5 {
+  margin-left: 41.6666666667%;
+}
+
+.offset-6 {
+  margin-left: 50%;
+}
+
+.offset-7 {
+  margin-left: 58.3333333333%;
+}
+
+.offset-8 {
+  margin-left: 66.6666666667%;
+}
+
+.offset-9 {
+  margin-left: 75%;
+}
+
+.offset-10 {
+  margin-left: 83.3333333333%;
+}
+
+.offset-11 {
+  margin-left: 91.6666666667%;
+}
+
+.g-0,
+.gx-0 {
+  --bs-gutter-x: 0;
+}
+
+.g-0,
+.gy-0 {
+  --bs-gutter-y: 0;
+}
+
+.g-1,
+.gx-1 {
+  --bs-gutter-x: 0.25rem;
+}
+
+.g-1,
+.gy-1 {
+  --bs-gutter-y: 0.25rem;
+}
+
+.g-2,
+.gx-2 {
+  --bs-gutter-x: 0.5rem;
+}
+
+.g-2,
+.gy-2 {
+  --bs-gutter-y: 0.5rem;
+}
+
+.g-3,
+.gx-3 {
+  --bs-gutter-x: 1rem;
+}
+
+.g-3,
+.gy-3 {
+  --bs-gutter-y: 1rem;
+}
+
+.g-4,
+.gx-4 {
+  --bs-gutter-x: 1.5rem;
+}
+
+.g-4,
+.gy-4 {
+  --bs-gutter-y: 1.5rem;
+}
+
+.g-5,
+.gx-5 {
+  --bs-gutter-x: 3rem;
+}
+
+.g-5,
+.gy-5 {
+  --bs-gutter-y: 3rem;
+}
+
+@media (min-width: 576px) {
+  .col-sm {
+    flex: 1 0 0%;
+  }
+
+  .row-cols-sm-auto > * {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .row-cols-sm-1 > * {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .row-cols-sm-2 > * {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .row-cols-sm-3 > * {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .row-cols-sm-4 > * {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .row-cols-sm-5 > * {
+    flex: 0 0 auto;
+    width: 20%;
+  }
+
+  .row-cols-sm-6 > * {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-sm-auto {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .col-sm-1 {
+    flex: 0 0 auto;
+    width: 8.3333333333%;
+  }
+
+  .col-sm-2 {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-sm-3 {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .col-sm-4 {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .col-sm-5 {
+    flex: 0 0 auto;
+    width: 41.6666666667%;
+  }
+
+  .col-sm-6 {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .col-sm-7 {
+    flex: 0 0 auto;
+    width: 58.3333333333%;
+  }
+
+  .col-sm-8 {
+    flex: 0 0 auto;
+    width: 66.6666666667%;
+  }
+
+  .col-sm-9 {
+    flex: 0 0 auto;
+    width: 75%;
+  }
+
+  .col-sm-10 {
+    flex: 0 0 auto;
+    width: 83.3333333333%;
+  }
+
+  .col-sm-11 {
+    flex: 0 0 auto;
+    width: 91.6666666667%;
+  }
+
+  .col-sm-12 {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .offset-sm-0 {
+    margin-left: 0;
+  }
+
+  .offset-sm-1 {
+    margin-left: 8.3333333333%;
+  }
+
+  .offset-sm-2 {
+    margin-left: 16.6666666667%;
+  }
+
+  .offset-sm-3 {
+    margin-left: 25%;
+  }
+
+  .offset-sm-4 {
+    margin-left: 33.3333333333%;
+  }
+
+  .offset-sm-5 {
+    margin-left: 41.6666666667%;
+  }
+
+  .offset-sm-6 {
+    margin-left: 50%;
+  }
+
+  .offset-sm-7 {
+    margin-left: 58.3333333333%;
+  }
+
+  .offset-sm-8 {
+    margin-left: 66.6666666667%;
+  }
+
+  .offset-sm-9 {
+    margin-left: 75%;
+  }
+
+  .offset-sm-10 {
+    margin-left: 83.3333333333%;
+  }
+
+  .offset-sm-11 {
+    margin-left: 91.6666666667%;
+  }
+
+  .g-sm-0,
+.gx-sm-0 {
+    --bs-gutter-x: 0;
+  }
+
+  .g-sm-0,
+.gy-sm-0 {
+    --bs-gutter-y: 0;
+  }
+
+  .g-sm-1,
+.gx-sm-1 {
+    --bs-gutter-x: 0.25rem;
+  }
+
+  .g-sm-1,
+.gy-sm-1 {
+    --bs-gutter-y: 0.25rem;
+  }
+
+  .g-sm-2,
+.gx-sm-2 {
+    --bs-gutter-x: 0.5rem;
+  }
+
+  .g-sm-2,
+.gy-sm-2 {
+    --bs-gutter-y: 0.5rem;
+  }
+
+  .g-sm-3,
+.gx-sm-3 {
+    --bs-gutter-x: 1rem;
+  }
+
+  .g-sm-3,
+.gy-sm-3 {
+    --bs-gutter-y: 1rem;
+  }
+
+  .g-sm-4,
+.gx-sm-4 {
+    --bs-gutter-x: 1.5rem;
+  }
+
+  .g-sm-4,
+.gy-sm-4 {
+    --bs-gutter-y: 1.5rem;
+  }
+
+  .g-sm-5,
+.gx-sm-5 {
+    --bs-gutter-x: 3rem;
+  }
+
+  .g-sm-5,
+.gy-sm-5 {
+    --bs-gutter-y: 3rem;
+  }
+}
+@media (min-width: 768px) {
+  .col-md {
+    flex: 1 0 0%;
+  }
+
+  .row-cols-md-auto > * {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .row-cols-md-1 > * {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .row-cols-md-2 > * {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .row-cols-md-3 > * {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .row-cols-md-4 > * {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .row-cols-md-5 > * {
+    flex: 0 0 auto;
+    width: 20%;
+  }
+
+  .row-cols-md-6 > * {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-md-auto {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .col-md-1 {
+    flex: 0 0 auto;
+    width: 8.3333333333%;
+  }
+
+  .col-md-2 {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-md-3 {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .col-md-4 {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .col-md-5 {
+    flex: 0 0 auto;
+    width: 41.6666666667%;
+  }
+
+  .col-md-6 {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .col-md-7 {
+    flex: 0 0 auto;
+    width: 58.3333333333%;
+  }
+
+  .col-md-8 {
+    flex: 0 0 auto;
+    width: 66.6666666667%;
+  }
+
+  .col-md-9 {
+    flex: 0 0 auto;
+    width: 75%;
+  }
+
+  .col-md-10 {
+    flex: 0 0 auto;
+    width: 83.3333333333%;
+  }
+
+  .col-md-11 {
+    flex: 0 0 auto;
+    width: 91.6666666667%;
+  }
+
+  .col-md-12 {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .offset-md-0 {
+    margin-left: 0;
+  }
+
+  .offset-md-1 {
+    margin-left: 8.3333333333%;
+  }
+
+  .offset-md-2 {
+    margin-left: 16.6666666667%;
+  }
+
+  .offset-md-3 {
+    margin-left: 25%;
+  }
+
+  .offset-md-4 {
+    margin-left: 33.3333333333%;
+  }
+
+  .offset-md-5 {
+    margin-left: 41.6666666667%;
+  }
+
+  .offset-md-6 {
+    margin-left: 50%;
+  }
+
+  .offset-md-7 {
+    margin-left: 58.3333333333%;
+  }
+
+  .offset-md-8 {
+    margin-left: 66.6666666667%;
+  }
+
+  .offset-md-9 {
+    margin-left: 75%;
+  }
+
+  .offset-md-10 {
+    margin-left: 83.3333333333%;
+  }
+
+  .offset-md-11 {
+    margin-left: 91.6666666667%;
+  }
+
+  .g-md-0,
+.gx-md-0 {
+    --bs-gutter-x: 0;
+  }
+
+  .g-md-0,
+.gy-md-0 {
+    --bs-gutter-y: 0;
+  }
+
+  .g-md-1,
+.gx-md-1 {
+    --bs-gutter-x: 0.25rem;
+  }
+
+  .g-md-1,
+.gy-md-1 {
+    --bs-gutter-y: 0.25rem;
+  }
+
+  .g-md-2,
+.gx-md-2 {
+    --bs-gutter-x: 0.5rem;
+  }
+
+  .g-md-2,
+.gy-md-2 {
+    --bs-gutter-y: 0.5rem;
+  }
+
+  .g-md-3,
+.gx-md-3 {
+    --bs-gutter-x: 1rem;
+  }
+
+  .g-md-3,
+.gy-md-3 {
+    --bs-gutter-y: 1rem;
+  }
+
+  .g-md-4,
+.gx-md-4 {
+    --bs-gutter-x: 1.5rem;
+  }
+
+  .g-md-4,
+.gy-md-4 {
+    --bs-gutter-y: 1.5rem;
+  }
+
+  .g-md-5,
+.gx-md-5 {
+    --bs-gutter-x: 3rem;
+  }
+
+  .g-md-5,
+.gy-md-5 {
+    --bs-gutter-y: 3rem;
+  }
+}
+@media (min-width: 992px) {
+  .col-lg {
+    flex: 1 0 0%;
+  }
+
+  .row-cols-lg-auto > * {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .row-cols-lg-1 > * {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .row-cols-lg-2 > * {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .row-cols-lg-3 > * {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .row-cols-lg-4 > * {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .row-cols-lg-5 > * {
+    flex: 0 0 auto;
+    width: 20%;
+  }
+
+  .row-cols-lg-6 > * {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-lg-auto {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .col-lg-1 {
+    flex: 0 0 auto;
+    width: 8.3333333333%;
+  }
+
+  .col-lg-2 {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-lg-3 {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .col-lg-4 {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .col-lg-5 {
+    flex: 0 0 auto;
+    width: 41.6666666667%;
+  }
+
+  .col-lg-6 {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .col-lg-7 {
+    flex: 0 0 auto;
+    width: 58.3333333333%;
+  }
+
+  .col-lg-8 {
+    flex: 0 0 auto;
+    width: 66.6666666667%;
+  }
+
+  .col-lg-9 {
+    flex: 0 0 auto;
+    width: 75%;
+  }
+
+  .col-lg-10 {
+    flex: 0 0 auto;
+    width: 83.3333333333%;
+  }
+
+  .col-lg-11 {
+    flex: 0 0 auto;
+    width: 91.6666666667%;
+  }
+
+  .col-lg-12 {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .offset-lg-0 {
+    margin-left: 0;
+  }
+
+  .offset-lg-1 {
+    margin-left: 8.3333333333%;
+  }
+
+  .offset-lg-2 {
+    margin-left: 16.6666666667%;
+  }
+
+  .offset-lg-3 {
+    margin-left: 25%;
+  }
+
+  .offset-lg-4 {
+    margin-left: 33.3333333333%;
+  }
+
+  .offset-lg-5 {
+    margin-left: 41.6666666667%;
+  }
+
+  .offset-lg-6 {
+    margin-left: 50%;
+  }
+
+  .offset-lg-7 {
+    margin-left: 58.3333333333%;
+  }
+
+  .offset-lg-8 {
+    margin-left: 66.6666666667%;
+  }
+
+  .offset-lg-9 {
+    margin-left: 75%;
+  }
+
+  .offset-lg-10 {
+    margin-left: 83.3333333333%;
+  }
+
+  .offset-lg-11 {
+    margin-left: 91.6666666667%;
+  }
+
+  .g-lg-0,
+.gx-lg-0 {
+    --bs-gutter-x: 0;
+  }
+
+  .g-lg-0,
+.gy-lg-0 {
+    --bs-gutter-y: 0;
+  }
+
+  .g-lg-1,
+.gx-lg-1 {
+    --bs-gutter-x: 0.25rem;
+  }
+
+  .g-lg-1,
+.gy-lg-1 {
+    --bs-gutter-y: 0.25rem;
+  }
+
+  .g-lg-2,
+.gx-lg-2 {
+    --bs-gutter-x: 0.5rem;
+  }
+
+  .g-lg-2,
+.gy-lg-2 {
+    --bs-gutter-y: 0.5rem;
+  }
+
+  .g-lg-3,
+.gx-lg-3 {
+    --bs-gutter-x: 1rem;
+  }
+
+  .g-lg-3,
+.gy-lg-3 {
+    --bs-gutter-y: 1rem;
+  }
+
+  .g-lg-4,
+.gx-lg-4 {
+    --bs-gutter-x: 1.5rem;
+  }
+
+  .g-lg-4,
+.gy-lg-4 {
+    --bs-gutter-y: 1.5rem;
+  }
+
+  .g-lg-5,
+.gx-lg-5 {
+    --bs-gutter-x: 3rem;
+  }
+
+  .g-lg-5,
+.gy-lg-5 {
+    --bs-gutter-y: 3rem;
+  }
+}
+@media (min-width: 1200px) {
+  .col-xl {
+    flex: 1 0 0%;
+  }
+
+  .row-cols-xl-auto > * {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .row-cols-xl-1 > * {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .row-cols-xl-2 > * {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .row-cols-xl-3 > * {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .row-cols-xl-4 > * {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .row-cols-xl-5 > * {
+    flex: 0 0 auto;
+    width: 20%;
+  }
+
+  .row-cols-xl-6 > * {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-xl-auto {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .col-xl-1 {
+    flex: 0 0 auto;
+    width: 8.3333333333%;
+  }
+
+  .col-xl-2 {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-xl-3 {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .col-xl-4 {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .col-xl-5 {
+    flex: 0 0 auto;
+    width: 41.6666666667%;
+  }
+
+  .col-xl-6 {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .col-xl-7 {
+    flex: 0 0 auto;
+    width: 58.3333333333%;
+  }
+
+  .col-xl-8 {
+    flex: 0 0 auto;
+    width: 66.6666666667%;
+  }
+
+  .col-xl-9 {
+    flex: 0 0 auto;
+    width: 75%;
+  }
+
+  .col-xl-10 {
+    flex: 0 0 auto;
+    width: 83.3333333333%;
+  }
+
+  .col-xl-11 {
+    flex: 0 0 auto;
+    width: 91.6666666667%;
+  }
+
+  .col-xl-12 {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .offset-xl-0 {
+    margin-left: 0;
+  }
+
+  .offset-xl-1 {
+    margin-left: 8.3333333333%;
+  }
+
+  .offset-xl-2 {
+    margin-left: 16.6666666667%;
+  }
+
+  .offset-xl-3 {
+    margin-left: 25%;
+  }
+
+  .offset-xl-4 {
+    margin-left: 33.3333333333%;
+  }
+
+  .offset-xl-5 {
+    margin-left: 41.6666666667%;
+  }
+
+  .offset-xl-6 {
+    margin-left: 50%;
+  }
+
+  .offset-xl-7 {
+    margin-left: 58.3333333333%;
+  }
+
+  .offset-xl-8 {
+    margin-left: 66.6666666667%;
+  }
+
+  .offset-xl-9 {
+    margin-left: 75%;
+  }
+
+  .offset-xl-10 {
+    margin-left: 83.3333333333%;
+  }
+
+  .offset-xl-11 {
+    margin-left: 91.6666666667%;
+  }
+
+  .g-xl-0,
+.gx-xl-0 {
+    --bs-gutter-x: 0;
+  }
+
+  .g-xl-0,
+.gy-xl-0 {
+    --bs-gutter-y: 0;
+  }
+
+  .g-xl-1,
+.gx-xl-1 {
+    --bs-gutter-x: 0.25rem;
+  }
+
+  .g-xl-1,
+.gy-xl-1 {
+    --bs-gutter-y: 0.25rem;
+  }
+
+  .g-xl-2,
+.gx-xl-2 {
+    --bs-gutter-x: 0.5rem;
+  }
+
+  .g-xl-2,
+.gy-xl-2 {
+    --bs-gutter-y: 0.5rem;
+  }
+
+  .g-xl-3,
+.gx-xl-3 {
+    --bs-gutter-x: 1rem;
+  }
+
+  .g-xl-3,
+.gy-xl-3 {
+    --bs-gutter-y: 1rem;
+  }
+
+  .g-xl-4,
+.gx-xl-4 {
+    --bs-gutter-x: 1.5rem;
+  }
+
+  .g-xl-4,
+.gy-xl-4 {
+    --bs-gutter-y: 1.5rem;
+  }
+
+  .g-xl-5,
+.gx-xl-5 {
+    --bs-gutter-x: 3rem;
+  }
+
+  .g-xl-5,
+.gy-xl-5 {
+    --bs-gutter-y: 3rem;
+  }
+}
+@media (min-width: 1400px) {
+  .col-xxl {
+    flex: 1 0 0%;
+  }
+
+  .row-cols-xxl-auto > * {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .row-cols-xxl-1 > * {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .row-cols-xxl-2 > * {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .row-cols-xxl-3 > * {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .row-cols-xxl-4 > * {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .row-cols-xxl-5 > * {
+    flex: 0 0 auto;
+    width: 20%;
+  }
+
+  .row-cols-xxl-6 > * {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-xxl-auto {
+    flex: 0 0 auto;
+    width: auto;
+  }
+
+  .col-xxl-1 {
+    flex: 0 0 auto;
+    width: 8.3333333333%;
+  }
+
+  .col-xxl-2 {
+    flex: 0 0 auto;
+    width: 16.6666666667%;
+  }
+
+  .col-xxl-3 {
+    flex: 0 0 auto;
+    width: 25%;
+  }
+
+  .col-xxl-4 {
+    flex: 0 0 auto;
+    width: 33.3333333333%;
+  }
+
+  .col-xxl-5 {
+    flex: 0 0 auto;
+    width: 41.6666666667%;
+  }
+
+  .col-xxl-6 {
+    flex: 0 0 auto;
+    width: 50%;
+  }
+
+  .col-xxl-7 {
+    flex: 0 0 auto;
+    width: 58.3333333333%;
+  }
+
+  .col-xxl-8 {
+    flex: 0 0 auto;
+    width: 66.6666666667%;
+  }
+
+  .col-xxl-9 {
+    flex: 0 0 auto;
+    width: 75%;
+  }
+
+  .col-xxl-10 {
+    flex: 0 0 auto;
+    width: 83.3333333333%;
+  }
+
+  .col-xxl-11 {
+    flex: 0 0 auto;
+    width: 91.6666666667%;
+  }
+
+  .col-xxl-12 {
+    flex: 0 0 auto;
+    width: 100%;
+  }
+
+  .offset-xxl-0 {
+    margin-left: 0;
+  }
+
+  .offset-xxl-1 {
+    margin-left: 8.3333333333%;
+  }
+
+  .offset-xxl-2 {
+    margin-left: 16.6666666667%;
+  }
+
+  .offset-xxl-3 {
+    margin-left: 25%;
+  }
+
+  .offset-xxl-4 {
+    margin-left: 33.3333333333%;
+  }
+
+  .offset-xxl-5 {
+    margin-left: 41.6666666667%;
+  }
+
+  .offset-xxl-6 {
+    margin-left: 50%;
+  }
+
+  .offset-xxl-7 {
+    margin-left: 58.3333333333%;
+  }
+
+  .offset-xxl-8 {
+    margin-left: 66.6666666667%;
+  }
+
+  .offset-xxl-9 {
+    margin-left: 75%;
+  }
+
+  .offset-xxl-10 {
+    margin-left: 83.3333333333%;
+  }
+
+  .offset-xxl-11 {
+    margin-left: 91.6666666667%;
+  }
+
+  .g-xxl-0,
+.gx-xxl-0 {
+    --bs-gutter-x: 0;
+  }
+
+  .g-xxl-0,
+.gy-xxl-0 {
+    --bs-gutter-y: 0;
+  }
+
+  .g-xxl-1,
+.gx-xxl-1 {
+    --bs-gutter-x: 0.25rem;
+  }
+
+  .g-xxl-1,
+.gy-xxl-1 {
+    --bs-gutter-y: 0.25rem;
+  }
+
+  .g-xxl-2,
+.gx-xxl-2 {
+    --bs-gutter-x: 0.5rem;
+  }
+
+  .g-xxl-2,
+.gy-xxl-2 {
+    --bs-gutter-y: 0.5rem;
+  }
+
+  .g-xxl-3,
+.gx-xxl-3 {
+    --bs-gutter-x: 1rem;
+  }
+
+  .g-xxl-3,
+.gy-xxl-3 {
+    --bs-gutter-y: 1rem;
+  }
+
+  .g-xxl-4,
+.gx-xxl-4 {
+    --bs-gutter-x: 1.5rem;
+  }
+
+  .g-xxl-4,
+.gy-xxl-4 {
+    --bs-gutter-y: 1.5rem;
+  }
+
+  .g-xxl-5,
+.gx-xxl-5 {
+    --bs-gutter-x: 3rem;
+  }
+
+  .g-xxl-5,
+.gy-xxl-5 {
+    --bs-gutter-y: 3rem;
+  }
+}
+.table {
+  --bs-table-bg: transparent;
+  --bs-table-striped-color: #212529;
+  --bs-table-striped-bg: rgba(0, 0, 0, 0.05);
+  --bs-table-active-color: #212529;
+  --bs-table-active-bg: rgba(0, 0, 0, 0.1);
+  --bs-table-hover-color: #212529;
+  --bs-table-hover-bg: rgba(0, 0, 0, 0.075);
+  width: 100%;
+  margin-bottom: 1rem;
+  color: #212529;
+  vertical-align: top;
+  border-color: #dee2e6;
+}
+.table > :not(caption) > * > * {
+  padding: 0.5rem 0.5rem;
+  background-color: var(--bs-table-bg);
+  border-bottom-width: 1px;
+  box-shadow: inset 0 0 0 9999px var(--bs-table-accent-bg);
+}
+.table > tbody {
+  vertical-align: inherit;
+}
+.table > thead {
+  vertical-align: bottom;
+}
+.table > :not(:last-child) > :last-child > * {
+  border-bottom-color: currentColor;
+}
+
+.caption-top {
+  caption-side: top;
+}
+
+.table-sm > :not(caption) > * > * {
+  padding: 0.25rem 0.25rem;
+}
+
+.table-bordered > :not(caption) > * {
+  border-width: 1px 0;
+}
+.table-bordered > :not(caption) > * > * {
+  border-width: 0 1px;
+}
+
+.table-borderless > :not(caption) > * > * {
+  border-bottom-width: 0;
+}
+
+.table-striped > tbody > tr:nth-of-type(odd) {
+  --bs-table-accent-bg: var(--bs-table-striped-bg);
+  color: var(--bs-table-striped-color);
+}
+
+.table-active {
+  --bs-table-accent-bg: var(--bs-table-active-bg);
+  color: var(--bs-table-active-color);
+}
+
+.table-hover > tbody > tr:hover {
+  --bs-table-accent-bg: var(--bs-table-hover-bg);
+  color: var(--bs-table-hover-color);
+}
+
+.table-primary {
+  --bs-table-bg: #cfe2ff;
+  --bs-table-striped-bg: #c5d7f2;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #bacbe6;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #bfd1ec;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #bacbe6;
+}
+
+.table-secondary {
+  --bs-table-bg: #e2e3e5;
+  --bs-table-striped-bg: #d7d8da;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #cbccce;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #d1d2d4;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #cbccce;
+}
+
+.table-success {
+  --bs-table-bg: #d1e7dd;
+  --bs-table-striped-bg: #c7dbd2;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #bcd0c7;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #c1d6cc;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #bcd0c7;
+}
+
+.table-info {
+  --bs-table-bg: #cff4fc;
+  --bs-table-striped-bg: #c5e8ef;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #badce3;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #bfe2e9;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #badce3;
+}
+
+.table-warning {
+  --bs-table-bg: #fff3cd;
+  --bs-table-striped-bg: #f2e7c3;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #e6dbb9;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #ece1be;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #e6dbb9;
+}
+
+.table-danger {
+  --bs-table-bg: #f8d7da;
+  --bs-table-striped-bg: #eccccf;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #dfc2c4;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #e5c7ca;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #dfc2c4;
+}
+
+.table-light {
+  --bs-table-bg: #f8f9fa;
+  --bs-table-striped-bg: #ecedee;
+  --bs-table-striped-color: #000;
+  --bs-table-active-bg: #dfe0e1;
+  --bs-table-active-color: #000;
+  --bs-table-hover-bg: #e5e6e7;
+  --bs-table-hover-color: #000;
+  color: #000;
+  border-color: #dfe0e1;
+}
+
+.table-dark {
+  --bs-table-bg: #212529;
+  --bs-table-striped-bg: #2c3034;
+  --bs-table-striped-color: #fff;
+  --bs-table-active-bg: #373b3e;
+  --bs-table-active-color: #fff;
+  --bs-table-hover-bg: #323539;
+  --bs-table-hover-color: #fff;
+  color: #fff;
+  border-color: #373b3e;
+}
+
+.table-responsive {
+  overflow-x: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+@media (max-width: 575.98px) {
+  .table-responsive-sm {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+}
+@media (max-width: 767.98px) {
+  .table-responsive-md {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+}
+@media (max-width: 991.98px) {
+  .table-responsive-lg {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+}
+@media (max-width: 1199.98px) {
+  .table-responsive-xl {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+}
+@media (max-width: 1399.98px) {
+  .table-responsive-xxl {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+}
+.form-label {
+  margin-bottom: 0.5rem;
+}
+
+.col-form-label {
+  padding-top: calc(0.375rem + 1px);
+  padding-bottom: calc(0.375rem + 1px);
+  margin-bottom: 0;
+  font-size: inherit;
+  line-height: 1.5;
+}
+
+.col-form-label-lg {
+  padding-top: calc(0.5rem + 1px);
+  padding-bottom: calc(0.5rem + 1px);
+  font-size: 1.25rem;
+}
+
+.col-form-label-sm {
+  padding-top: calc(0.25rem + 1px);
+  padding-bottom: calc(0.25rem + 1px);
+  font-size: 0.875rem;
+}
+
+.form-text {
+  margin-top: 0.25rem;
+  font-size: 0.875em;
+  color: #6c757d;
+}
+
+.form-control {
+  display: block;
+  width: 100%;
+  padding: 0.375rem 0.75rem;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 1px solid #ced4da;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  border-radius: 0.25rem;
+  transition: border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-control {
+    transition: none;
+  }
+}
+.form-control[type=file] {
+  overflow: hidden;
+}
+.form-control[type=file]:not(:disabled):not([readonly]) {
+  cursor: pointer;
+}
+.form-control:focus {
+  color: #212529;
+  background-color: #fff;
+  border-color: #86b7fe;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.form-control::-webkit-date-and-time-value {
+  height: 1.5em;
+}
+.form-control::-webkit-input-placeholder {
+  color: #6c757d;
+  opacity: 1;
+}
+.form-control::-moz-placeholder {
+  color: #6c757d;
+  opacity: 1;
+}
+.form-control::placeholder {
+  color: #6c757d;
+  opacity: 1;
+}
+.form-control:disabled, .form-control[readonly] {
+  background-color: #e9ecef;
+  opacity: 1;
+}
+.form-control::file-selector-button {
+  padding: 0.375rem 0.75rem;
+  margin: -0.375rem -0.75rem;
+  -webkit-margin-end: 0.75rem;
+  margin-inline-end: 0.75rem;
+  color: #212529;
+  background-color: #e9ecef;
+  pointer-events: none;
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+  border-inline-end-width: 1px;
+  border-radius: 0;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-control::file-selector-button {
+    transition: none;
+  }
+}
+.form-control:hover:not(:disabled):not([readonly])::file-selector-button {
+  background-color: #dde0e3;
+}
+.form-control::-webkit-file-upload-button {
+  padding: 0.375rem 0.75rem;
+  margin: -0.375rem -0.75rem;
+  -webkit-margin-end: 0.75rem;
+  margin-inline-end: 0.75rem;
+  color: #212529;
+  background-color: #e9ecef;
+  pointer-events: none;
+  border-color: inherit;
+  border-style: solid;
+  border-width: 0;
+  border-inline-end-width: 1px;
+  border-radius: 0;
+  -webkit-transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-control::-webkit-file-upload-button {
+    -webkit-transition: none;
+    transition: none;
+  }
+}
+.form-control:hover:not(:disabled):not([readonly])::-webkit-file-upload-button {
+  background-color: #dde0e3;
+}
+
+.form-control-plaintext {
+  display: block;
+  width: 100%;
+  padding: 0.375rem 0;
+  margin-bottom: 0;
+  line-height: 1.5;
+  color: #212529;
+  background-color: transparent;
+  border: solid transparent;
+  border-width: 1px 0;
+}
+.form-control-plaintext.form-control-sm, .form-control-plaintext.form-control-lg {
+  padding-right: 0;
+  padding-left: 0;
+}
+
+.form-control-sm {
+  min-height: calc(1.5em + 0.5rem + 2px);
+  padding: 0.25rem 0.5rem;
+  font-size: 0.875rem;
+  border-radius: 0.2rem;
+}
+.form-control-sm::file-selector-button {
+  padding: 0.25rem 0.5rem;
+  margin: -0.25rem -0.5rem;
+  -webkit-margin-end: 0.5rem;
+  margin-inline-end: 0.5rem;
+}
+.form-control-sm::-webkit-file-upload-button {
+  padding: 0.25rem 0.5rem;
+  margin: -0.25rem -0.5rem;
+  -webkit-margin-end: 0.5rem;
+  margin-inline-end: 0.5rem;
+}
+
+.form-control-lg {
+  min-height: calc(1.5em + 1rem + 2px);
+  padding: 0.5rem 1rem;
+  font-size: 1.25rem;
+  border-radius: 0.3rem;
+}
+.form-control-lg::file-selector-button {
+  padding: 0.5rem 1rem;
+  margin: -0.5rem -1rem;
+  -webkit-margin-end: 1rem;
+  margin-inline-end: 1rem;
+}
+.form-control-lg::-webkit-file-upload-button {
+  padding: 0.5rem 1rem;
+  margin: -0.5rem -1rem;
+  -webkit-margin-end: 1rem;
+  margin-inline-end: 1rem;
+}
+
+textarea.form-control {
+  min-height: calc(1.5em + 0.75rem + 2px);
+}
+textarea.form-control-sm {
+  min-height: calc(1.5em + 0.5rem + 2px);
+}
+textarea.form-control-lg {
+  min-height: calc(1.5em + 1rem + 2px);
+}
+
+.form-control-color {
+  max-width: 3rem;
+  height: auto;
+  padding: 0.375rem;
+}
+.form-control-color:not(:disabled):not([readonly]) {
+  cursor: pointer;
+}
+.form-control-color::-moz-color-swatch {
+  height: 1.5em;
+  border-radius: 0.25rem;
+}
+.form-control-color::-webkit-color-swatch {
+  height: 1.5em;
+  border-radius: 0.25rem;
+}
+
+.form-select {
+  display: block;
+  width: 100%;
+  padding: 0.375rem 2.25rem 0.375rem 0.75rem;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  background-color: #fff;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e");
+  background-repeat: no-repeat;
+  background-position: right 0.75rem center;
+  background-size: 16px 12px;
+  border: 1px solid #ced4da;
+  border-radius: 0.25rem;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+}
+.form-select:focus {
+  border-color: #86b7fe;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.form-select[multiple], .form-select[size]:not([size="1"]) {
+  padding-right: 0.75rem;
+  background-image: none;
+}
+.form-select:disabled {
+  color: #6c757d;
+  background-color: #e9ecef;
+}
+.form-select:-moz-focusring {
+  color: transparent;
+  text-shadow: 0 0 0 #212529;
+}
+
+.form-select-sm {
+  padding-top: 0.25rem;
+  padding-bottom: 0.25rem;
+  padding-left: 0.5rem;
+  font-size: 0.875rem;
+}
+
+.form-select-lg {
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+  padding-left: 1rem;
+  font-size: 1.25rem;
+}
+
+.form-check {
+  display: block;
+  min-height: 1.5rem;
+  padding-left: 1.5em;
+  margin-bottom: 0.125rem;
+}
+.form-check .form-check-input {
+  float: left;
+  margin-left: -1.5em;
+}
+
+.form-check-input {
+  width: 1em;
+  height: 1em;
+  margin-top: 0.25em;
+  vertical-align: top;
+  background-color: #fff;
+  background-repeat: no-repeat;
+  background-position: center;
+  background-size: contain;
+  border: 1px solid rgba(0, 0, 0, 0.25);
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  -webkit-print-color-adjust: exact;
+  color-adjust: exact;
+}
+.form-check-input[type=checkbox] {
+  border-radius: 0.25em;
+}
+.form-check-input[type=radio] {
+  border-radius: 50%;
+}
+.form-check-input:active {
+  filter: brightness(90%);
+}
+.form-check-input:focus {
+  border-color: #86b7fe;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.form-check-input:checked {
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.form-check-input:checked[type=checkbox] {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10l3 3l6-6'/%3e%3c/svg%3e");
+}
+.form-check-input:checked[type=radio] {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='2' fill='%23fff'/%3e%3c/svg%3e");
+}
+.form-check-input[type=checkbox]:indeterminate {
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10h8'/%3e%3c/svg%3e");
+}
+.form-check-input:disabled {
+  pointer-events: none;
+  filter: none;
+  opacity: 0.5;
+}
+.form-check-input[disabled] ~ .form-check-label, .form-check-input:disabled ~ .form-check-label {
+  opacity: 0.5;
+}
+
+.form-switch {
+  padding-left: 2.5em;
+}
+.form-switch .form-check-input {
+  width: 2em;
+  margin-left: -2.5em;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='rgba%280, 0, 0, 0.25%29'/%3e%3c/svg%3e");
+  background-position: left center;
+  border-radius: 2em;
+  transition: background-position 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-switch .form-check-input {
+    transition: none;
+  }
+}
+.form-switch .form-check-input:focus {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%2386b7fe'/%3e%3c/svg%3e");
+}
+.form-switch .form-check-input:checked {
+  background-position: right center;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%23fff'/%3e%3c/svg%3e");
+}
+
+.form-check-inline {
+  display: inline-block;
+  margin-right: 1rem;
+}
+
+.btn-check {
+  position: absolute;
+  clip: rect(0, 0, 0, 0);
+  pointer-events: none;
+}
+.btn-check[disabled] + .btn, .btn-check:disabled + .btn {
+  pointer-events: none;
+  filter: none;
+  opacity: 0.65;
+}
+
+.form-range {
+  width: 100%;
+  height: 1.5rem;
+  padding: 0;
+  background-color: transparent;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+}
+.form-range:focus {
+  outline: 0;
+}
+.form-range:focus::-webkit-slider-thumb {
+  box-shadow: 0 0 0 1px #fff, 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.form-range:focus::-moz-range-thumb {
+  box-shadow: 0 0 0 1px #fff, 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.form-range::-moz-focus-outer {
+  border: 0;
+}
+.form-range::-webkit-slider-thumb {
+  width: 1rem;
+  height: 1rem;
+  margin-top: -0.25rem;
+  background-color: #0d6efd;
+  border: 0;
+  border-radius: 1rem;
+  -webkit-transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  -webkit-appearance: none;
+  appearance: none;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-range::-webkit-slider-thumb {
+    -webkit-transition: none;
+    transition: none;
+  }
+}
+.form-range::-webkit-slider-thumb:active {
+  background-color: #b6d4fe;
+}
+.form-range::-webkit-slider-runnable-track {
+  width: 100%;
+  height: 0.5rem;
+  color: transparent;
+  cursor: pointer;
+  background-color: #dee2e6;
+  border-color: transparent;
+  border-radius: 1rem;
+}
+.form-range::-moz-range-thumb {
+  width: 1rem;
+  height: 1rem;
+  background-color: #0d6efd;
+  border: 0;
+  border-radius: 1rem;
+  -moz-transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  -moz-appearance: none;
+  appearance: none;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-range::-moz-range-thumb {
+    -moz-transition: none;
+    transition: none;
+  }
+}
+.form-range::-moz-range-thumb:active {
+  background-color: #b6d4fe;
+}
+.form-range::-moz-range-track {
+  width: 100%;
+  height: 0.5rem;
+  color: transparent;
+  cursor: pointer;
+  background-color: #dee2e6;
+  border-color: transparent;
+  border-radius: 1rem;
+}
+.form-range:disabled {
+  pointer-events: none;
+}
+.form-range:disabled::-webkit-slider-thumb {
+  background-color: #adb5bd;
+}
+.form-range:disabled::-moz-range-thumb {
+  background-color: #adb5bd;
+}
+
+.form-floating {
+  position: relative;
+}
+.form-floating > .form-control,
+.form-floating > .form-select {
+  height: calc(3.5rem + 2px);
+  padding: 1rem 0.75rem;
+}
+.form-floating > label {
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 100%;
+  padding: 1rem 0.75rem;
+  pointer-events: none;
+  border: 1px solid transparent;
+  transform-origin: 0 0;
+  transition: opacity 0.1s ease-in-out, transform 0.1s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .form-floating > label {
+    transition: none;
+  }
+}
+.form-floating > .form-control::-webkit-input-placeholder {
+  color: transparent;
+}
+.form-floating > .form-control::-moz-placeholder {
+  color: transparent;
+}
+.form-floating > .form-control::placeholder {
+  color: transparent;
+}
+.form-floating > .form-control:not(:-moz-placeholder-shown) {
+  padding-top: 1.625rem;
+  padding-bottom: 0.625rem;
+}
+.form-floating > .form-control:focus, .form-floating > .form-control:not(:placeholder-shown) {
+  padding-top: 1.625rem;
+  padding-bottom: 0.625rem;
+}
+.form-floating > .form-control:-webkit-autofill {
+  padding-top: 1.625rem;
+  padding-bottom: 0.625rem;
+}
+.form-floating > .form-select {
+  padding-top: 1.625rem;
+  padding-bottom: 0.625rem;
+}
+.form-floating > .form-control:not(:-moz-placeholder-shown) ~ label {
+  opacity: 0.65;
+  transform: scale(0.85) translateY(-0.5rem) translateX(0.15rem);
+}
+.form-floating > .form-control:focus ~ label,
+.form-floating > .form-control:not(:placeholder-shown) ~ label,
+.form-floating > .form-select ~ label {
+  opacity: 0.65;
+  transform: scale(0.85) translateY(-0.5rem) translateX(0.15rem);
+}
+.form-floating > .form-control:-webkit-autofill ~ label {
+  opacity: 0.65;
+  transform: scale(0.85) translateY(-0.5rem) translateX(0.15rem);
+}
+
+.input-group {
+  position: relative;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: stretch;
+  width: 100%;
+}
+.input-group > .form-control,
+.input-group > .form-select {
+  position: relative;
+  flex: 1 1 auto;
+  width: 1%;
+  min-width: 0;
+}
+.input-group > .form-control:focus,
+.input-group > .form-select:focus {
+  z-index: 3;
+}
+.input-group .btn {
+  position: relative;
+  z-index: 2;
+}
+.input-group .btn:focus {
+  z-index: 3;
+}
+
+.input-group-text {
+  display: flex;
+  align-items: center;
+  padding: 0.375rem 0.75rem;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  text-align: center;
+  white-space: nowrap;
+  background-color: #e9ecef;
+  border: 1px solid #ced4da;
+  border-radius: 0.25rem;
+}
+
+.input-group-lg > .form-control,
+.input-group-lg > .form-select,
+.input-group-lg > .input-group-text,
+.input-group-lg > .btn {
+  padding: 0.5rem 1rem;
+  font-size: 1.25rem;
+  border-radius: 0.3rem;
+}
+
+.input-group-sm > .form-control,
+.input-group-sm > .form-select,
+.input-group-sm > .input-group-text,
+.input-group-sm > .btn {
+  padding: 0.25rem 0.5rem;
+  font-size: 0.875rem;
+  border-radius: 0.2rem;
+}
+
+.input-group-lg > .form-select,
+.input-group-sm > .form-select {
+  padding-right: 3rem;
+}
+
+.input-group:not(.has-validation) > :not(:last-child):not(.dropdown-toggle):not(.dropdown-menu),
+.input-group:not(.has-validation) > .dropdown-toggle:nth-last-child(n+3) {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.input-group.has-validation > :nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu),
+.input-group.has-validation > .dropdown-toggle:nth-last-child(n+4) {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.input-group > :not(:first-child):not(.dropdown-menu):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback) {
+  margin-left: -1px;
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.valid-feedback {
+  display: none;
+  width: 100%;
+  margin-top: 0.25rem;
+  font-size: 0.875em;
+  color: #198754;
+}
+
+.valid-tooltip {
+  position: absolute;
+  top: 100%;
+  z-index: 5;
+  display: none;
+  max-width: 100%;
+  padding: 0.25rem 0.5rem;
+  margin-top: 0.1rem;
+  font-size: 0.875rem;
+  color: #fff;
+  background-color: rgba(25, 135, 84, 0.9);
+  border-radius: 0.25rem;
+}
+
+.was-validated :valid ~ .valid-feedback,
+.was-validated :valid ~ .valid-tooltip,
+.is-valid ~ .valid-feedback,
+.is-valid ~ .valid-tooltip {
+  display: block;
+}
+
+.was-validated .form-control:valid, .form-control.is-valid {
+  border-color: #198754;
+  padding-right: calc(1.5em + 0.75rem);
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");
+  background-repeat: no-repeat;
+  background-position: right calc(0.375em + 0.1875rem) center;
+  background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
+}
+.was-validated .form-control:valid:focus, .form-control.is-valid:focus {
+  border-color: #198754;
+  box-shadow: 0 0 0 0.25rem rgba(25, 135, 84, 0.25);
+}
+
+.was-validated textarea.form-control:valid, textarea.form-control.is-valid {
+  padding-right: calc(1.5em + 0.75rem);
+  background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem);
+}
+
+.was-validated .form-select:valid, .form-select.is-valid {
+  border-color: #198754;
+  padding-right: 4.125rem;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e"), url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");
+  background-position: right 0.75rem center, center right 2.25rem;
+  background-size: 16px 12px, calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
+}
+.was-validated .form-select:valid:focus, .form-select.is-valid:focus {
+  border-color: #198754;
+  box-shadow: 0 0 0 0.25rem rgba(25, 135, 84, 0.25);
+}
+
+.was-validated .form-check-input:valid, .form-check-input.is-valid {
+  border-color: #198754;
+}
+.was-validated .form-check-input:valid:checked, .form-check-input.is-valid:checked {
+  background-color: #198754;
+}
+.was-validated .form-check-input:valid:focus, .form-check-input.is-valid:focus {
+  box-shadow: 0 0 0 0.25rem rgba(25, 135, 84, 0.25);
+}
+.was-validated .form-check-input:valid ~ .form-check-label, .form-check-input.is-valid ~ .form-check-label {
+  color: #198754;
+}
+
+.form-check-inline .form-check-input ~ .valid-feedback {
+  margin-left: 0.5em;
+}
+
+.invalid-feedback {
+  display: none;
+  width: 100%;
+  margin-top: 0.25rem;
+  font-size: 0.875em;
+  color: #dc3545;
+}
+
+.invalid-tooltip {
+  position: absolute;
+  top: 100%;
+  z-index: 5;
+  display: none;
+  max-width: 100%;
+  padding: 0.25rem 0.5rem;
+  margin-top: 0.1rem;
+  font-size: 0.875rem;
+  color: #fff;
+  background-color: rgba(220, 53, 69, 0.9);
+  border-radius: 0.25rem;
+}
+
+.was-validated :invalid ~ .invalid-feedback,
+.was-validated :invalid ~ .invalid-tooltip,
+.is-invalid ~ .invalid-feedback,
+.is-invalid ~ .invalid-tooltip {
+  display: block;
+}
+
+.was-validated .form-control:invalid, .form-control.is-invalid {
+  border-color: #dc3545;
+  padding-right: calc(1.5em + 0.75rem);
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");
+  background-repeat: no-repeat;
+  background-position: right calc(0.375em + 0.1875rem) center;
+  background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
+}
+.was-validated .form-control:invalid:focus, .form-control.is-invalid:focus {
+  border-color: #dc3545;
+  box-shadow: 0 0 0 0.25rem rgba(220, 53, 69, 0.25);
+}
+
+.was-validated textarea.form-control:invalid, textarea.form-control.is-invalid {
+  padding-right: calc(1.5em + 0.75rem);
+  background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem);
+}
+
+.was-validated .form-select:invalid, .form-select.is-invalid {
+  border-color: #dc3545;
+  padding-right: 4.125rem;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e"), url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");
+  background-position: right 0.75rem center, center right 2.25rem;
+  background-size: 16px 12px, calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
+}
+.was-validated .form-select:invalid:focus, .form-select.is-invalid:focus {
+  border-color: #dc3545;
+  box-shadow: 0 0 0 0.25rem rgba(220, 53, 69, 0.25);
+}
+
+.was-validated .form-check-input:invalid, .form-check-input.is-invalid {
+  border-color: #dc3545;
+}
+.was-validated .form-check-input:invalid:checked, .form-check-input.is-invalid:checked {
+  background-color: #dc3545;
+}
+.was-validated .form-check-input:invalid:focus, .form-check-input.is-invalid:focus {
+  box-shadow: 0 0 0 0.25rem rgba(220, 53, 69, 0.25);
+}
+.was-validated .form-check-input:invalid ~ .form-check-label, .form-check-input.is-invalid ~ .form-check-label {
+  color: #dc3545;
+}
+
+.form-check-inline .form-check-input ~ .invalid-feedback {
+  margin-left: 0.5em;
+}
+
+.btn {
+  display: inline-block;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #212529;
+  text-align: center;
+  text-decoration: none;
+  vertical-align: middle;
+  cursor: pointer;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+  background-color: transparent;
+  border: 1px solid transparent;
+  padding: 0.375rem 0.75rem;
+  font-size: 1rem;
+  border-radius: 0.25rem;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .btn {
+    transition: none;
+  }
+}
+.btn:hover {
+  color: #212529;
+}
+.btn-check:focus + .btn, .btn:focus {
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+.btn:disabled, .btn.disabled, fieldset:disabled .btn {
+  pointer-events: none;
+  opacity: 0.65;
+}
+
+.btn-primary {
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.btn-primary:hover {
+  color: #fff;
+  background-color: #0b5ed7;
+  border-color: #0a58ca;
+}
+.btn-check:focus + .btn-primary, .btn-primary:focus {
+  color: #fff;
+  background-color: #0b5ed7;
+  border-color: #0a58ca;
+  box-shadow: 0 0 0 0.25rem rgba(49, 132, 253, 0.5);
+}
+.btn-check:checked + .btn-primary, .btn-check:active + .btn-primary, .btn-primary:active, .btn-primary.active, .show > .btn-primary.dropdown-toggle {
+  color: #fff;
+  background-color: #0a58ca;
+  border-color: #0a53be;
+}
+.btn-check:checked + .btn-primary:focus, .btn-check:active + .btn-primary:focus, .btn-primary:active:focus, .btn-primary.active:focus, .show > .btn-primary.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(49, 132, 253, 0.5);
+}
+.btn-primary:disabled, .btn-primary.disabled {
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+
+.btn-secondary {
+  color: #fff;
+  background-color: #6c757d;
+  border-color: #6c757d;
+}
+.btn-secondary:hover {
+  color: #fff;
+  background-color: #5c636a;
+  border-color: #565e64;
+}
+.btn-check:focus + .btn-secondary, .btn-secondary:focus {
+  color: #fff;
+  background-color: #5c636a;
+  border-color: #565e64;
+  box-shadow: 0 0 0 0.25rem rgba(130, 138, 145, 0.5);
+}
+.btn-check:checked + .btn-secondary, .btn-check:active + .btn-secondary, .btn-secondary:active, .btn-secondary.active, .show > .btn-secondary.dropdown-toggle {
+  color: #fff;
+  background-color: #565e64;
+  border-color: #51585e;
+}
+.btn-check:checked + .btn-secondary:focus, .btn-check:active + .btn-secondary:focus, .btn-secondary:active:focus, .btn-secondary.active:focus, .show > .btn-secondary.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(130, 138, 145, 0.5);
+}
+.btn-secondary:disabled, .btn-secondary.disabled {
+  color: #fff;
+  background-color: #6c757d;
+  border-color: #6c757d;
+}
+
+.btn-success {
+  color: #fff;
+  background-color: #198754;
+  border-color: #198754;
+}
+.btn-success:hover {
+  color: #fff;
+  background-color: #157347;
+  border-color: #146c43;
+}
+.btn-check:focus + .btn-success, .btn-success:focus {
+  color: #fff;
+  background-color: #157347;
+  border-color: #146c43;
+  box-shadow: 0 0 0 0.25rem rgba(60, 153, 110, 0.5);
+}
+.btn-check:checked + .btn-success, .btn-check:active + .btn-success, .btn-success:active, .btn-success.active, .show > .btn-success.dropdown-toggle {
+  color: #fff;
+  background-color: #146c43;
+  border-color: #13653f;
+}
+.btn-check:checked + .btn-success:focus, .btn-check:active + .btn-success:focus, .btn-success:active:focus, .btn-success.active:focus, .show > .btn-success.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(60, 153, 110, 0.5);
+}
+.btn-success:disabled, .btn-success.disabled {
+  color: #fff;
+  background-color: #198754;
+  border-color: #198754;
+}
+
+.btn-info {
+  color: #000;
+  background-color: #0dcaf0;
+  border-color: #0dcaf0;
+}
+.btn-info:hover {
+  color: #000;
+  background-color: #31d2f2;
+  border-color: #25cff2;
+}
+.btn-check:focus + .btn-info, .btn-info:focus {
+  color: #000;
+  background-color: #31d2f2;
+  border-color: #25cff2;
+  box-shadow: 0 0 0 0.25rem rgba(11, 172, 204, 0.5);
+}
+.btn-check:checked + .btn-info, .btn-check:active + .btn-info, .btn-info:active, .btn-info.active, .show > .btn-info.dropdown-toggle {
+  color: #000;
+  background-color: #3dd5f3;
+  border-color: #25cff2;
+}
+.btn-check:checked + .btn-info:focus, .btn-check:active + .btn-info:focus, .btn-info:active:focus, .btn-info.active:focus, .show > .btn-info.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(11, 172, 204, 0.5);
+}
+.btn-info:disabled, .btn-info.disabled {
+  color: #000;
+  background-color: #0dcaf0;
+  border-color: #0dcaf0;
+}
+
+.btn-warning {
+  color: #000;
+  background-color: #ffc107;
+  border-color: #ffc107;
+}
+.btn-warning:hover {
+  color: #000;
+  background-color: #ffca2c;
+  border-color: #ffc720;
+}
+.btn-check:focus + .btn-warning, .btn-warning:focus {
+  color: #000;
+  background-color: #ffca2c;
+  border-color: #ffc720;
+  box-shadow: 0 0 0 0.25rem rgba(217, 164, 6, 0.5);
+}
+.btn-check:checked + .btn-warning, .btn-check:active + .btn-warning, .btn-warning:active, .btn-warning.active, .show > .btn-warning.dropdown-toggle {
+  color: #000;
+  background-color: #ffcd39;
+  border-color: #ffc720;
+}
+.btn-check:checked + .btn-warning:focus, .btn-check:active + .btn-warning:focus, .btn-warning:active:focus, .btn-warning.active:focus, .show > .btn-warning.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(217, 164, 6, 0.5);
+}
+.btn-warning:disabled, .btn-warning.disabled {
+  color: #000;
+  background-color: #ffc107;
+  border-color: #ffc107;
+}
+
+.btn-danger {
+  color: #fff;
+  background-color: #dc3545;
+  border-color: #dc3545;
+}
+.btn-danger:hover {
+  color: #fff;
+  background-color: #bb2d3b;
+  border-color: #b02a37;
+}
+.btn-check:focus + .btn-danger, .btn-danger:focus {
+  color: #fff;
+  background-color: #bb2d3b;
+  border-color: #b02a37;
+  box-shadow: 0 0 0 0.25rem rgba(225, 83, 97, 0.5);
+}
+.btn-check:checked + .btn-danger, .btn-check:active + .btn-danger, .btn-danger:active, .btn-danger.active, .show > .btn-danger.dropdown-toggle {
+  color: #fff;
+  background-color: #b02a37;
+  border-color: #a52834;
+}
+.btn-check:checked + .btn-danger:focus, .btn-check:active + .btn-danger:focus, .btn-danger:active:focus, .btn-danger.active:focus, .show > .btn-danger.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(225, 83, 97, 0.5);
+}
+.btn-danger:disabled, .btn-danger.disabled {
+  color: #fff;
+  background-color: #dc3545;
+  border-color: #dc3545;
+}
+
+.btn-light {
+  color: #000;
+  background-color: #f8f9fa;
+  border-color: #f8f9fa;
+}
+.btn-light:hover {
+  color: #000;
+  background-color: #f9fafb;
+  border-color: #f9fafb;
+}
+.btn-check:focus + .btn-light, .btn-light:focus {
+  color: #000;
+  background-color: #f9fafb;
+  border-color: #f9fafb;
+  box-shadow: 0 0 0 0.25rem rgba(211, 212, 213, 0.5);
+}
+.btn-check:checked + .btn-light, .btn-check:active + .btn-light, .btn-light:active, .btn-light.active, .show > .btn-light.dropdown-toggle {
+  color: #000;
+  background-color: #f9fafb;
+  border-color: #f9fafb;
+}
+.btn-check:checked + .btn-light:focus, .btn-check:active + .btn-light:focus, .btn-light:active:focus, .btn-light.active:focus, .show > .btn-light.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(211, 212, 213, 0.5);
+}
+.btn-light:disabled, .btn-light.disabled {
+  color: #000;
+  background-color: #f8f9fa;
+  border-color: #f8f9fa;
+}
+
+.btn-dark {
+  color: #fff;
+  background-color: #212529;
+  border-color: #212529;
+}
+.btn-dark:hover {
+  color: #fff;
+  background-color: #1c1f23;
+  border-color: #1a1e21;
+}
+.btn-check:focus + .btn-dark, .btn-dark:focus {
+  color: #fff;
+  background-color: #1c1f23;
+  border-color: #1a1e21;
+  box-shadow: 0 0 0 0.25rem rgba(66, 70, 73, 0.5);
+}
+.btn-check:checked + .btn-dark, .btn-check:active + .btn-dark, .btn-dark:active, .btn-dark.active, .show > .btn-dark.dropdown-toggle {
+  color: #fff;
+  background-color: #1a1e21;
+  border-color: #191c1f;
+}
+.btn-check:checked + .btn-dark:focus, .btn-check:active + .btn-dark:focus, .btn-dark:active:focus, .btn-dark.active:focus, .show > .btn-dark.dropdown-toggle:focus {
+  box-shadow: 0 0 0 0.25rem rgba(66, 70, 73, 0.5);
+}
+.btn-dark:disabled, .btn-dark.disabled {
+  color: #fff;
+  background-color: #212529;
+  border-color: #212529;
+}
+
+.btn-outline-primary {
+  color: #0d6efd;
+  border-color: #0d6efd;
+}
+.btn-outline-primary:hover {
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.btn-check:focus + .btn-outline-primary, .btn-outline-primary:focus {
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.5);
+}
+.btn-check:checked + .btn-outline-primary, .btn-check:active + .btn-outline-primary, .btn-outline-primary:active, .btn-outline-primary.active, .btn-outline-primary.dropdown-toggle.show {
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.btn-check:checked + .btn-outline-primary:focus, .btn-check:active + .btn-outline-primary:focus, .btn-outline-primary:active:focus, .btn-outline-primary.active:focus, .btn-outline-primary.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.5);
+}
+.btn-outline-primary:disabled, .btn-outline-primary.disabled {
+  color: #0d6efd;
+  background-color: transparent;
+}
+
+.btn-outline-secondary {
+  color: #6c757d;
+  border-color: #6c757d;
+}
+.btn-outline-secondary:hover {
+  color: #fff;
+  background-color: #6c757d;
+  border-color: #6c757d;
+}
+.btn-check:focus + .btn-outline-secondary, .btn-outline-secondary:focus {
+  box-shadow: 0 0 0 0.25rem rgba(108, 117, 125, 0.5);
+}
+.btn-check:checked + .btn-outline-secondary, .btn-check:active + .btn-outline-secondary, .btn-outline-secondary:active, .btn-outline-secondary.active, .btn-outline-secondary.dropdown-toggle.show {
+  color: #fff;
+  background-color: #6c757d;
+  border-color: #6c757d;
+}
+.btn-check:checked + .btn-outline-secondary:focus, .btn-check:active + .btn-outline-secondary:focus, .btn-outline-secondary:active:focus, .btn-outline-secondary.active:focus, .btn-outline-secondary.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(108, 117, 125, 0.5);
+}
+.btn-outline-secondary:disabled, .btn-outline-secondary.disabled {
+  color: #6c757d;
+  background-color: transparent;
+}
+
+.btn-outline-success {
+  color: #198754;
+  border-color: #198754;
+}
+.btn-outline-success:hover {
+  color: #fff;
+  background-color: #198754;
+  border-color: #198754;
+}
+.btn-check:focus + .btn-outline-success, .btn-outline-success:focus {
+  box-shadow: 0 0 0 0.25rem rgba(25, 135, 84, 0.5);
+}
+.btn-check:checked + .btn-outline-success, .btn-check:active + .btn-outline-success, .btn-outline-success:active, .btn-outline-success.active, .btn-outline-success.dropdown-toggle.show {
+  color: #fff;
+  background-color: #198754;
+  border-color: #198754;
+}
+.btn-check:checked + .btn-outline-success:focus, .btn-check:active + .btn-outline-success:focus, .btn-outline-success:active:focus, .btn-outline-success.active:focus, .btn-outline-success.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(25, 135, 84, 0.5);
+}
+.btn-outline-success:disabled, .btn-outline-success.disabled {
+  color: #198754;
+  background-color: transparent;
+}
+
+.btn-outline-info {
+  color: #0dcaf0;
+  border-color: #0dcaf0;
+}
+.btn-outline-info:hover {
+  color: #000;
+  background-color: #0dcaf0;
+  border-color: #0dcaf0;
+}
+.btn-check:focus + .btn-outline-info, .btn-outline-info:focus {
+  box-shadow: 0 0 0 0.25rem rgba(13, 202, 240, 0.5);
+}
+.btn-check:checked + .btn-outline-info, .btn-check:active + .btn-outline-info, .btn-outline-info:active, .btn-outline-info.active, .btn-outline-info.dropdown-toggle.show {
+  color: #000;
+  background-color: #0dcaf0;
+  border-color: #0dcaf0;
+}
+.btn-check:checked + .btn-outline-info:focus, .btn-check:active + .btn-outline-info:focus, .btn-outline-info:active:focus, .btn-outline-info.active:focus, .btn-outline-info.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(13, 202, 240, 0.5);
+}
+.btn-outline-info:disabled, .btn-outline-info.disabled {
+  color: #0dcaf0;
+  background-color: transparent;
+}
+
+.btn-outline-warning {
+  color: #ffc107;
+  border-color: #ffc107;
+}
+.btn-outline-warning:hover {
+  color: #000;
+  background-color: #ffc107;
+  border-color: #ffc107;
+}
+.btn-check:focus + .btn-outline-warning, .btn-outline-warning:focus {
+  box-shadow: 0 0 0 0.25rem rgba(255, 193, 7, 0.5);
+}
+.btn-check:checked + .btn-outline-warning, .btn-check:active + .btn-outline-warning, .btn-outline-warning:active, .btn-outline-warning.active, .btn-outline-warning.dropdown-toggle.show {
+  color: #000;
+  background-color: #ffc107;
+  border-color: #ffc107;
+}
+.btn-check:checked + .btn-outline-warning:focus, .btn-check:active + .btn-outline-warning:focus, .btn-outline-warning:active:focus, .btn-outline-warning.active:focus, .btn-outline-warning.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(255, 193, 7, 0.5);
+}
+.btn-outline-warning:disabled, .btn-outline-warning.disabled {
+  color: #ffc107;
+  background-color: transparent;
+}
+
+.btn-outline-danger {
+  color: #dc3545;
+  border-color: #dc3545;
+}
+.btn-outline-danger:hover {
+  color: #fff;
+  background-color: #dc3545;
+  border-color: #dc3545;
+}
+.btn-check:focus + .btn-outline-danger, .btn-outline-danger:focus {
+  box-shadow: 0 0 0 0.25rem rgba(220, 53, 69, 0.5);
+}
+.btn-check:checked + .btn-outline-danger, .btn-check:active + .btn-outline-danger, .btn-outline-danger:active, .btn-outline-danger.active, .btn-outline-danger.dropdown-toggle.show {
+  color: #fff;
+  background-color: #dc3545;
+  border-color: #dc3545;
+}
+.btn-check:checked + .btn-outline-danger:focus, .btn-check:active + .btn-outline-danger:focus, .btn-outline-danger:active:focus, .btn-outline-danger.active:focus, .btn-outline-danger.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(220, 53, 69, 0.5);
+}
+.btn-outline-danger:disabled, .btn-outline-danger.disabled {
+  color: #dc3545;
+  background-color: transparent;
+}
+
+.btn-outline-light {
+  color: #f8f9fa;
+  border-color: #f8f9fa;
+}
+.btn-outline-light:hover {
+  color: #000;
+  background-color: #f8f9fa;
+  border-color: #f8f9fa;
+}
+.btn-check:focus + .btn-outline-light, .btn-outline-light:focus {
+  box-shadow: 0 0 0 0.25rem rgba(248, 249, 250, 0.5);
+}
+.btn-check:checked + .btn-outline-light, .btn-check:active + .btn-outline-light, .btn-outline-light:active, .btn-outline-light.active, .btn-outline-light.dropdown-toggle.show {
+  color: #000;
+  background-color: #f8f9fa;
+  border-color: #f8f9fa;
+}
+.btn-check:checked + .btn-outline-light:focus, .btn-check:active + .btn-outline-light:focus, .btn-outline-light:active:focus, .btn-outline-light.active:focus, .btn-outline-light.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(248, 249, 250, 0.5);
+}
+.btn-outline-light:disabled, .btn-outline-light.disabled {
+  color: #f8f9fa;
+  background-color: transparent;
+}
+
+.btn-outline-dark {
+  color: #212529;
+  border-color: #212529;
+}
+.btn-outline-dark:hover {
+  color: #fff;
+  background-color: #212529;
+  border-color: #212529;
+}
+.btn-check:focus + .btn-outline-dark, .btn-outline-dark:focus {
+  box-shadow: 0 0 0 0.25rem rgba(33, 37, 41, 0.5);
+}
+.btn-check:checked + .btn-outline-dark, .btn-check:active + .btn-outline-dark, .btn-outline-dark:active, .btn-outline-dark.active, .btn-outline-dark.dropdown-toggle.show {
+  color: #fff;
+  background-color: #212529;
+  border-color: #212529;
+}
+.btn-check:checked + .btn-outline-dark:focus, .btn-check:active + .btn-outline-dark:focus, .btn-outline-dark:active:focus, .btn-outline-dark.active:focus, .btn-outline-dark.dropdown-toggle.show:focus {
+  box-shadow: 0 0 0 0.25rem rgba(33, 37, 41, 0.5);
+}
+.btn-outline-dark:disabled, .btn-outline-dark.disabled {
+  color: #212529;
+  background-color: transparent;
+}
+
+.btn-link {
+  font-weight: 400;
+  color: #0d6efd;
+  text-decoration: underline;
+}
+.btn-link:hover {
+  color: #0a58ca;
+}
+.btn-link:disabled, .btn-link.disabled {
+  color: #6c757d;
+}
+
+.btn-lg, .btn-group-lg > .btn {
+  padding: 0.5rem 1rem;
+  font-size: 1.25rem;
+  border-radius: 0.3rem;
+}
+
+.btn-sm, .btn-group-sm > .btn {
+  padding: 0.25rem 0.5rem;
+  font-size: 0.875rem;
+  border-radius: 0.2rem;
+}
+
+.fade {
+  transition: opacity 0.15s linear;
+}
+@media (prefers-reduced-motion: reduce) {
+  .fade {
+    transition: none;
+  }
+}
+.fade:not(.show) {
+  opacity: 0;
+}
+
+.collapse:not(.show) {
+  display: none;
+}
+
+.collapsing {
+  height: 0;
+  overflow: hidden;
+  transition: height 0.35s ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  .collapsing {
+    transition: none;
+  }
+}
+
+.dropup,
+.dropend,
+.dropdown,
+.dropstart {
+  position: relative;
+}
+
+.dropdown-toggle {
+  white-space: nowrap;
+}
+.dropdown-toggle::after {
+  display: inline-block;
+  margin-left: 0.255em;
+  vertical-align: 0.255em;
+  content: "";
+  border-top: 0.3em solid;
+  border-right: 0.3em solid transparent;
+  border-bottom: 0;
+  border-left: 0.3em solid transparent;
+}
+.dropdown-toggle:empty::after {
+  margin-left: 0;
+}
+
+.dropdown-menu {
+  position: absolute;
+  top: 100%;
+  z-index: 1000;
+  display: none;
+  min-width: 10rem;
+  padding: 0.5rem 0;
+  margin: 0;
+  font-size: 1rem;
+  color: #212529;
+  text-align: left;
+  list-style: none;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  border-radius: 0.25rem;
+}
+.dropdown-menu[data-bs-popper] {
+  left: 0;
+  margin-top: 0.125rem;
+}
+
+.dropdown-menu-start {
+  --bs-position: start;
+}
+.dropdown-menu-start[data-bs-popper] {
+  right: auto /* rtl:ignore */;
+  left: 0 /* rtl:ignore */;
+}
+
+.dropdown-menu-end {
+  --bs-position: end;
+}
+.dropdown-menu-end[data-bs-popper] {
+  right: 0 /* rtl:ignore */;
+  left: auto /* rtl:ignore */;
+}
+
+@media (min-width: 576px) {
+  .dropdown-menu-sm-start {
+    --bs-position: start;
+  }
+  .dropdown-menu-sm-start[data-bs-popper] {
+    right: auto /* rtl:ignore */;
+    left: 0 /* rtl:ignore */;
+  }
+
+  .dropdown-menu-sm-end {
+    --bs-position: end;
+  }
+  .dropdown-menu-sm-end[data-bs-popper] {
+    right: 0 /* rtl:ignore */;
+    left: auto /* rtl:ignore */;
+  }
+}
+@media (min-width: 768px) {
+  .dropdown-menu-md-start {
+    --bs-position: start;
+  }
+  .dropdown-menu-md-start[data-bs-popper] {
+    right: auto /* rtl:ignore */;
+    left: 0 /* rtl:ignore */;
+  }
+
+  .dropdown-menu-md-end {
+    --bs-position: end;
+  }
+  .dropdown-menu-md-end[data-bs-popper] {
+    right: 0 /* rtl:ignore */;
+    left: auto /* rtl:ignore */;
+  }
+}
+@media (min-width: 992px) {
+  .dropdown-menu-lg-start {
+    --bs-position: start;
+  }
+  .dropdown-menu-lg-start[data-bs-popper] {
+    right: auto /* rtl:ignore */;
+    left: 0 /* rtl:ignore */;
+  }
+
+  .dropdown-menu-lg-end {
+    --bs-position: end;
+  }
+  .dropdown-menu-lg-end[data-bs-popper] {
+    right: 0 /* rtl:ignore */;
+    left: auto /* rtl:ignore */;
+  }
+}
+@media (min-width: 1200px) {
+  .dropdown-menu-xl-start {
+    --bs-position: start;
+  }
+  .dropdown-menu-xl-start[data-bs-popper] {
+    right: auto /* rtl:ignore */;
+    left: 0 /* rtl:ignore */;
+  }
+
+  .dropdown-menu-xl-end {
+    --bs-position: end;
+  }
+  .dropdown-menu-xl-end[data-bs-popper] {
+    right: 0 /* rtl:ignore */;
+    left: auto /* rtl:ignore */;
+  }
+}
+@media (min-width: 1400px) {
+  .dropdown-menu-xxl-start {
+    --bs-position: start;
+  }
+  .dropdown-menu-xxl-start[data-bs-popper] {
+    right: auto /* rtl:ignore */;
+    left: 0 /* rtl:ignore */;
+  }
+
+  .dropdown-menu-xxl-end {
+    --bs-position: end;
+  }
+  .dropdown-menu-xxl-end[data-bs-popper] {
+    right: 0 /* rtl:ignore */;
+    left: auto /* rtl:ignore */;
+  }
+}
+.dropup .dropdown-menu {
+  top: auto;
+  bottom: 100%;
+}
+.dropup .dropdown-menu[data-bs-popper] {
+  margin-top: 0;
+  margin-bottom: 0.125rem;
+}
+.dropup .dropdown-toggle::after {
+  display: inline-block;
+  margin-left: 0.255em;
+  vertical-align: 0.255em;
+  content: "";
+  border-top: 0;
+  border-right: 0.3em solid transparent;
+  border-bottom: 0.3em solid;
+  border-left: 0.3em solid transparent;
+}
+.dropup .dropdown-toggle:empty::after {
+  margin-left: 0;
+}
+
+.dropend .dropdown-menu {
+  top: 0;
+  right: auto;
+  left: 100%;
+}
+.dropend .dropdown-menu[data-bs-popper] {
+  margin-top: 0;
+  margin-left: 0.125rem;
+}
+.dropend .dropdown-toggle::after {
+  display: inline-block;
+  margin-left: 0.255em;
+  vertical-align: 0.255em;
+  content: "";
+  border-top: 0.3em solid transparent;
+  border-right: 0;
+  border-bottom: 0.3em solid transparent;
+  border-left: 0.3em solid;
+}
+.dropend .dropdown-toggle:empty::after {
+  margin-left: 0;
+}
+.dropend .dropdown-toggle::after {
+  vertical-align: 0;
+}
+
+.dropstart .dropdown-menu {
+  top: 0;
+  right: 100%;
+  left: auto;
+}
+.dropstart .dropdown-menu[data-bs-popper] {
+  margin-top: 0;
+  margin-right: 0.125rem;
+}
+.dropstart .dropdown-toggle::after {
+  display: inline-block;
+  margin-left: 0.255em;
+  vertical-align: 0.255em;
+  content: "";
+}
+.dropstart .dropdown-toggle::after {
+  display: none;
+}
+.dropstart .dropdown-toggle::before {
+  display: inline-block;
+  margin-right: 0.255em;
+  vertical-align: 0.255em;
+  content: "";
+  border-top: 0.3em solid transparent;
+  border-right: 0.3em solid;
+  border-bottom: 0.3em solid transparent;
+}
+.dropstart .dropdown-toggle:empty::after {
+  margin-left: 0;
+}
+.dropstart .dropdown-toggle::before {
+  vertical-align: 0;
+}
+
+.dropdown-divider {
+  height: 0;
+  margin: 0.5rem 0;
+  overflow: hidden;
+  border-top: 1px solid rgba(0, 0, 0, 0.15);
+}
+
+.dropdown-item {
+  display: block;
+  width: 100%;
+  padding: 0.25rem 1rem;
+  clear: both;
+  font-weight: 400;
+  color: #212529;
+  text-align: inherit;
+  text-decoration: none;
+  white-space: nowrap;
+  background-color: transparent;
+  border: 0;
+}
+.dropdown-item:hover, .dropdown-item:focus {
+  color: #1e2125;
+  background-color: #e9ecef;
+}
+.dropdown-item.active, .dropdown-item:active {
+  color: #fff;
+  text-decoration: none;
+  background-color: #0d6efd;
+}
+.dropdown-item.disabled, .dropdown-item:disabled {
+  color: #adb5bd;
+  pointer-events: none;
+  background-color: transparent;
+}
+
+.dropdown-menu.show {
+  display: block;
+}
+
+.dropdown-header {
+  display: block;
+  padding: 0.5rem 1rem;
+  margin-bottom: 0;
+  font-size: 0.875rem;
+  color: #6c757d;
+  white-space: nowrap;
+}
+
+.dropdown-item-text {
+  display: block;
+  padding: 0.25rem 1rem;
+  color: #212529;
+}
+
+.dropdown-menu-dark {
+  color: #dee2e6;
+  background-color: #343a40;
+  border-color: rgba(0, 0, 0, 0.15);
+}
+.dropdown-menu-dark .dropdown-item {
+  color: #dee2e6;
+}
+.dropdown-menu-dark .dropdown-item:hover, .dropdown-menu-dark .dropdown-item:focus {
+  color: #fff;
+  background-color: rgba(255, 255, 255, 0.15);
+}
+.dropdown-menu-dark .dropdown-item.active, .dropdown-menu-dark .dropdown-item:active {
+  color: #fff;
+  background-color: #0d6efd;
+}
+.dropdown-menu-dark .dropdown-item.disabled, .dropdown-menu-dark .dropdown-item:disabled {
+  color: #adb5bd;
+}
+.dropdown-menu-dark .dropdown-divider {
+  border-color: rgba(0, 0, 0, 0.15);
+}
+.dropdown-menu-dark .dropdown-item-text {
+  color: #dee2e6;
+}
+.dropdown-menu-dark .dropdown-header {
+  color: #adb5bd;
+}
+
+.btn-group,
+.btn-group-vertical {
+  position: relative;
+  display: inline-flex;
+  vertical-align: middle;
+}
+.btn-group > .btn,
+.btn-group-vertical > .btn {
+  position: relative;
+  flex: 1 1 auto;
+}
+.btn-group > .btn-check:checked + .btn,
+.btn-group > .btn-check:focus + .btn,
+.btn-group > .btn:hover,
+.btn-group > .btn:focus,
+.btn-group > .btn:active,
+.btn-group > .btn.active,
+.btn-group-vertical > .btn-check:checked + .btn,
+.btn-group-vertical > .btn-check:focus + .btn,
+.btn-group-vertical > .btn:hover,
+.btn-group-vertical > .btn:focus,
+.btn-group-vertical > .btn:active,
+.btn-group-vertical > .btn.active {
+  z-index: 1;
+}
+
+.btn-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-start;
+}
+.btn-toolbar .input-group {
+  width: auto;
+}
+
+.btn-group > .btn:not(:first-child),
+.btn-group > .btn-group:not(:first-child) {
+  margin-left: -1px;
+}
+.btn-group > .btn:not(:last-child):not(.dropdown-toggle),
+.btn-group > .btn-group:not(:last-child) > .btn {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.btn-group > .btn:nth-child(n+3),
+.btn-group > :not(.btn-check) + .btn,
+.btn-group > .btn-group:not(:first-child) > .btn {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.dropdown-toggle-split {
+  padding-right: 0.5625rem;
+  padding-left: 0.5625rem;
+}
+.dropdown-toggle-split::after, .dropup .dropdown-toggle-split::after, .dropend .dropdown-toggle-split::after {
+  margin-left: 0;
+}
+.dropstart .dropdown-toggle-split::before {
+  margin-right: 0;
+}
+
+.btn-sm + .dropdown-toggle-split, .btn-group-sm > .btn + .dropdown-toggle-split {
+  padding-right: 0.375rem;
+  padding-left: 0.375rem;
+}
+
+.btn-lg + .dropdown-toggle-split, .btn-group-lg > .btn + .dropdown-toggle-split {
+  padding-right: 0.75rem;
+  padding-left: 0.75rem;
+}
+
+.btn-group-vertical {
+  flex-direction: column;
+  align-items: flex-start;
+  justify-content: center;
+}
+.btn-group-vertical > .btn,
+.btn-group-vertical > .btn-group {
+  width: 100%;
+}
+.btn-group-vertical > .btn:not(:first-child),
+.btn-group-vertical > .btn-group:not(:first-child) {
+  margin-top: -1px;
+}
+.btn-group-vertical > .btn:not(:last-child):not(.dropdown-toggle),
+.btn-group-vertical > .btn-group:not(:last-child) > .btn {
+  border-bottom-right-radius: 0;
+  border-bottom-left-radius: 0;
+}
+.btn-group-vertical > .btn ~ .btn,
+.btn-group-vertical > .btn-group:not(:first-child) > .btn {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+
+.nav {
+  display: flex;
+  flex-wrap: wrap;
+  padding-left: 0;
+  margin-bottom: 0;
+  list-style: none;
+}
+
+.nav-link {
+  display: block;
+  padding: 0.5rem 1rem;
+  text-decoration: none;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .nav-link {
+    transition: none;
+  }
+}
+.nav-link.disabled {
+  color: #6c757d;
+  pointer-events: none;
+  cursor: default;
+}
+
+.nav-tabs {
+  border-bottom: 1px solid #dee2e6;
+}
+.nav-tabs .nav-link {
+  margin-bottom: -1px;
+  background: none;
+  border: 1px solid transparent;
+  border-top-left-radius: 0.25rem;
+  border-top-right-radius: 0.25rem;
+}
+.nav-tabs .nav-link:hover, .nav-tabs .nav-link:focus {
+  border-color: #e9ecef #e9ecef #dee2e6;
+  isolation: isolate;
+}
+.nav-tabs .nav-link.disabled {
+  color: #6c757d;
+  background-color: transparent;
+  border-color: transparent;
+}
+.nav-tabs .nav-link.active,
+.nav-tabs .nav-item.show .nav-link {
+  color: #495057;
+  background-color: #fff;
+  border-color: #dee2e6 #dee2e6 #fff;
+}
+.nav-tabs .dropdown-menu {
+  margin-top: -1px;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+
+.nav-pills .nav-link {
+  background: none;
+  border: 0;
+  border-radius: 0.25rem;
+}
+.nav-pills .nav-link.active,
+.nav-pills .show > .nav-link {
+  color: #fff;
+  background-color: #0d6efd;
+}
+
+.nav-fill > .nav-link,
+.nav-fill .nav-item {
+  flex: 1 1 auto;
+  text-align: center;
+}
+
+.nav-justified > .nav-link,
+.nav-justified .nav-item {
+  flex-basis: 0;
+  flex-grow: 1;
+  text-align: center;
+}
+
+.tab-content > .tab-pane {
+  display: none;
+}
+.tab-content > .active {
+  display: block;
+}
+
+.navbar {
+  position: relative;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+}
+.navbar > .container,
+.navbar > .container-fluid,
+.navbar > .container-sm,
+.navbar > .container-md,
+.navbar > .container-lg,
+.navbar > .container-xl,
+.navbar > .container-xxl {
+  display: flex;
+  flex-wrap: inherit;
+  align-items: center;
+  justify-content: space-between;
+}
+.navbar-brand {
+  padding-top: 0.3125rem;
+  padding-bottom: 0.3125rem;
+  margin-right: 1rem;
+  font-size: 1.25rem;
+  text-decoration: none;
+  white-space: nowrap;
+}
+.navbar-nav {
+  display: flex;
+  flex-direction: column;
+  padding-left: 0;
+  margin-bottom: 0;
+  list-style: none;
+}
+.navbar-nav .nav-link {
+  padding-right: 0;
+  padding-left: 0;
+}
+.navbar-nav .dropdown-menu {
+  position: static;
+}
+
+.navbar-text {
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+}
+
+.navbar-collapse {
+  flex-basis: 100%;
+  flex-grow: 1;
+  align-items: center;
+}
+
+.navbar-toggler {
+  padding: 0.25rem 0.75rem;
+  font-size: 1.25rem;
+  line-height: 1;
+  background-color: transparent;
+  border: 1px solid transparent;
+  border-radius: 0.25rem;
+  transition: box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .navbar-toggler {
+    transition: none;
+  }
+}
+.navbar-toggler:hover {
+  text-decoration: none;
+}
+.navbar-toggler:focus {
+  text-decoration: none;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem;
+}
+
+.navbar-toggler-icon {
+  display: inline-block;
+  width: 1.5em;
+  height: 1.5em;
+  vertical-align: middle;
+  background-repeat: no-repeat;
+  background-position: center;
+  background-size: 100%;
+}
+
+.navbar-nav-scroll {
+  max-height: var(--bs-scroll-height, 75vh);
+  overflow-y: auto;
+}
+
+@media (min-width: 576px) {
+  .navbar-expand-sm {
+    flex-wrap: nowrap;
+    justify-content: flex-start;
+  }
+  .navbar-expand-sm .navbar-nav {
+    flex-direction: row;
+  }
+  .navbar-expand-sm .navbar-nav .dropdown-menu {
+    position: absolute;
+  }
+  .navbar-expand-sm .navbar-nav .nav-link {
+    padding-right: 0.5rem;
+    padding-left: 0.5rem;
+  }
+  .navbar-expand-sm .navbar-nav-scroll {
+    overflow: visible;
+  }
+  .navbar-expand-sm .navbar-collapse {
+    display: flex !important;
+    flex-basis: auto;
+  }
+  .navbar-expand-sm .navbar-toggler {
+    display: none;
+  }
+}
+@media (min-width: 768px) {
+  .navbar-expand-md {
+    flex-wrap: nowrap;
+    justify-content: flex-start;
+  }
+  .navbar-expand-md .navbar-nav {
+    flex-direction: row;
+  }
+  .navbar-expand-md .navbar-nav .dropdown-menu {
+    position: absolute;
+  }
+  .navbar-expand-md .navbar-nav .nav-link {
+    padding-right: 0.5rem;
+    padding-left: 0.5rem;
+  }
+  .navbar-expand-md .navbar-nav-scroll {
+    overflow: visible;
+  }
+  .navbar-expand-md .navbar-collapse {
+    display: flex !important;
+    flex-basis: auto;
+  }
+  .navbar-expand-md .navbar-toggler {
+    display: none;
+  }
+}
+@media (min-width: 992px) {
+  .navbar-expand-lg {
+    flex-wrap: nowrap;
+    justify-content: flex-start;
+  }
+  .navbar-expand-lg .navbar-nav {
+    flex-direction: row;
+  }
+  .navbar-expand-lg .navbar-nav .dropdown-menu {
+    position: absolute;
+  }
+  .navbar-expand-lg .navbar-nav .nav-link {
+    padding-right: 0.5rem;
+    padding-left: 0.5rem;
+  }
+  .navbar-expand-lg .navbar-nav-scroll {
+    overflow: visible;
+  }
+  .navbar-expand-lg .navbar-collapse {
+    display: flex !important;
+    flex-basis: auto;
+  }
+  .navbar-expand-lg .navbar-toggler {
+    display: none;
+  }
+}
+@media (min-width: 1200px) {
+  .navbar-expand-xl {
+    flex-wrap: nowrap;
+    justify-content: flex-start;
+  }
+  .navbar-expand-xl .navbar-nav {
+    flex-direction: row;
+  }
+  .navbar-expand-xl .navbar-nav .dropdown-menu {
+    position: absolute;
+  }
+  .navbar-expand-xl .navbar-nav .nav-link {
+    padding-right: 0.5rem;
+    padding-left: 0.5rem;
+  }
+  .navbar-expand-xl .navbar-nav-scroll {
+    overflow: visible;
+  }
+  .navbar-expand-xl .navbar-collapse {
+    display: flex !important;
+    flex-basis: auto;
+  }
+  .navbar-expand-xl .navbar-toggler {
+    display: none;
+  }
+}
+@media (min-width: 1400px) {
+  .navbar-expand-xxl {
+    flex-wrap: nowrap;
+    justify-content: flex-start;
+  }
+  .navbar-expand-xxl .navbar-nav {
+    flex-direction: row;
+  }
+  .navbar-expand-xxl .navbar-nav .dropdown-menu {
+    position: absolute;
+  }
+  .navbar-expand-xxl .navbar-nav .nav-link {
+    padding-right: 0.5rem;
+    padding-left: 0.5rem;
+  }
+  .navbar-expand-xxl .navbar-nav-scroll {
+    overflow: visible;
+  }
+  .navbar-expand-xxl .navbar-collapse {
+    display: flex !important;
+    flex-basis: auto;
+  }
+  .navbar-expand-xxl .navbar-toggler {
+    display: none;
+  }
+}
+.navbar-expand {
+  flex-wrap: nowrap;
+  justify-content: flex-start;
+}
+.navbar-expand .navbar-nav {
+  flex-direction: row;
+}
+.navbar-expand .navbar-nav .dropdown-menu {
+  position: absolute;
+}
+.navbar-expand .navbar-nav .nav-link {
+  padding-right: 0.5rem;
+  padding-left: 0.5rem;
+}
+.navbar-expand .navbar-nav-scroll {
+  overflow: visible;
+}
+.navbar-expand .navbar-collapse {
+  display: flex !important;
+  flex-basis: auto;
+}
+.navbar-expand .navbar-toggler {
+  display: none;
+}
+
+.navbar-light .navbar-brand {
+  color: rgba(0, 0, 0, 0.9);
+}
+.navbar-light .navbar-brand:hover, .navbar-light .navbar-brand:focus {
+  color: rgba(0, 0, 0, 0.9);
+}
+.navbar-light .navbar-nav .nav-link {
+  color: rgba(0, 0, 0, 0.55);
+}
+.navbar-light .navbar-nav .nav-link:hover, .navbar-light .navbar-nav .nav-link:focus {
+  color: rgba(0, 0, 0, 0.7);
+}
+.navbar-light .navbar-nav .nav-link.disabled {
+  color: rgba(0, 0, 0, 0.3);
+}
+.navbar-light .navbar-nav .show > .nav-link,
+.navbar-light .navbar-nav .nav-link.active {
+  color: rgba(0, 0, 0, 0.9);
+}
+.navbar-light .navbar-toggler {
+  color: rgba(0, 0, 0, 0.55);
+  border-color: rgba(0, 0, 0, 0.1);
+}
+.navbar-light .navbar-toggler-icon {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%280, 0, 0, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e");
+}
+.navbar-light .navbar-text {
+  color: rgba(0, 0, 0, 0.55);
+}
+.navbar-light .navbar-text a,
+.navbar-light .navbar-text a:hover,
+.navbar-light .navbar-text a:focus {
+  color: rgba(0, 0, 0, 0.9);
+}
+
+.navbar-dark .navbar-brand {
+  color: #fff;
+}
+.navbar-dark .navbar-brand:hover, .navbar-dark .navbar-brand:focus {
+  color: #fff;
+}
+.navbar-dark .navbar-nav .nav-link {
+  color: rgba(255, 255, 255, 0.55);
+}
+.navbar-dark .navbar-nav .nav-link:hover, .navbar-dark .navbar-nav .nav-link:focus {
+  color: rgba(255, 255, 255, 0.75);
+}
+.navbar-dark .navbar-nav .nav-link.disabled {
+  color: rgba(255, 255, 255, 0.25);
+}
+.navbar-dark .navbar-nav .show > .nav-link,
+.navbar-dark .navbar-nav .nav-link.active {
+  color: #fff;
+}
+.navbar-dark .navbar-toggler {
+  color: rgba(255, 255, 255, 0.55);
+  border-color: rgba(255, 255, 255, 0.1);
+}
+.navbar-dark .navbar-toggler-icon {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e");
+}
+.navbar-dark .navbar-text {
+  color: rgba(255, 255, 255, 0.55);
+}
+.navbar-dark .navbar-text a,
+.navbar-dark .navbar-text a:hover,
+.navbar-dark .navbar-text a:focus {
+  color: #fff;
+}
+
+.card {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  word-wrap: break-word;
+  background-color: #fff;
+  background-clip: border-box;
+  border: 1px solid rgba(0, 0, 0, 0.125);
+  border-radius: 0.25rem;
+}
+.card > hr {
+  margin-right: 0;
+  margin-left: 0;
+}
+.card > .list-group {
+  border-top: inherit;
+  border-bottom: inherit;
+}
+.card > .list-group:first-child {
+  border-top-width: 0;
+  border-top-left-radius: calc(0.25rem - 1px);
+  border-top-right-radius: calc(0.25rem - 1px);
+}
+.card > .list-group:last-child {
+  border-bottom-width: 0;
+  border-bottom-right-radius: calc(0.25rem - 1px);
+  border-bottom-left-radius: calc(0.25rem - 1px);
+}
+.card > .card-header + .list-group,
+.card > .list-group + .card-footer {
+  border-top: 0;
+}
+
+.card-body {
+  flex: 1 1 auto;
+  padding: 1rem 1rem;
+}
+
+.card-title {
+  margin-bottom: 0.5rem;
+}
+
+.card-subtitle {
+  margin-top: -0.25rem;
+  margin-bottom: 0;
+}
+
+.card-text:last-child {
+  margin-bottom: 0;
+}
+
+.card-link:hover {
+  text-decoration: none;
+}
+.card-link + .card-link {
+  margin-left: 1rem /* rtl:ignore */;
+}
+
+.card-header {
+  padding: 0.5rem 1rem;
+  margin-bottom: 0;
+  background-color: rgba(0, 0, 0, 0.03);
+  border-bottom: 1px solid rgba(0, 0, 0, 0.125);
+}
+.card-header:first-child {
+  border-radius: calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0;
+}
+
+.card-footer {
+  padding: 0.5rem 1rem;
+  background-color: rgba(0, 0, 0, 0.03);
+  border-top: 1px solid rgba(0, 0, 0, 0.125);
+}
+.card-footer:last-child {
+  border-radius: 0 0 calc(0.25rem - 1px) calc(0.25rem - 1px);
+}
+
+.card-header-tabs {
+  margin-right: -0.5rem;
+  margin-bottom: -0.5rem;
+  margin-left: -0.5rem;
+  border-bottom: 0;
+}
+
+.card-header-pills {
+  margin-right: -0.5rem;
+  margin-left: -0.5rem;
+}
+
+.card-img-overlay {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  padding: 1rem;
+  border-radius: calc(0.25rem - 1px);
+}
+
+.card-img,
+.card-img-top,
+.card-img-bottom {
+  width: 100%;
+}
+
+.card-img,
+.card-img-top {
+  border-top-left-radius: calc(0.25rem - 1px);
+  border-top-right-radius: calc(0.25rem - 1px);
+}
+
+.card-img,
+.card-img-bottom {
+  border-bottom-right-radius: calc(0.25rem - 1px);
+  border-bottom-left-radius: calc(0.25rem - 1px);
+}
+
+.card-group > .card {
+  margin-bottom: 0.75rem;
+}
+@media (min-width: 576px) {
+  .card-group {
+    display: flex;
+    flex-flow: row wrap;
+  }
+  .card-group > .card {
+    flex: 1 0 0%;
+    margin-bottom: 0;
+  }
+  .card-group > .card + .card {
+    margin-left: 0;
+    border-left: 0;
+  }
+  .card-group > .card:not(:last-child) {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+  .card-group > .card:not(:last-child) .card-img-top,
+.card-group > .card:not(:last-child) .card-header {
+    border-top-right-radius: 0;
+  }
+  .card-group > .card:not(:last-child) .card-img-bottom,
+.card-group > .card:not(:last-child) .card-footer {
+    border-bottom-right-radius: 0;
+  }
+  .card-group > .card:not(:first-child) {
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+  }
+  .card-group > .card:not(:first-child) .card-img-top,
+.card-group > .card:not(:first-child) .card-header {
+    border-top-left-radius: 0;
+  }
+  .card-group > .card:not(:first-child) .card-img-bottom,
+.card-group > .card:not(:first-child) .card-footer {
+    border-bottom-left-radius: 0;
+  }
+}
+
+.accordion-button {
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+  padding: 1rem 1.25rem;
+  font-size: 1rem;
+  color: #212529;
+  text-align: left;
+  background-color: transparent;
+  border: 1px solid rgba(0, 0, 0, 0.125);
+  border-radius: 0;
+  overflow-anchor: none;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out, border-radius 0.15s ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  .accordion-button {
+    transition: none;
+  }
+}
+.accordion-button.collapsed {
+  border-bottom-width: 0;
+}
+.accordion-button:not(.collapsed) {
+  color: #0c63e4;
+  background-color: #e7f1ff;
+}
+.accordion-button:not(.collapsed)::after {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%230c63e4'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");
+  transform: rotate(180deg);
+}
+.accordion-button::after {
+  flex-shrink: 0;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin-left: auto;
+  content: "";
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23212529'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");
+  background-repeat: no-repeat;
+  background-size: 1.25rem;
+  transition: transform 0.2s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .accordion-button::after {
+    transition: none;
+  }
+}
+.accordion-button:hover {
+  z-index: 2;
+}
+.accordion-button:focus {
+  z-index: 3;
+  border-color: #86b7fe;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+
+.accordion-header {
+  margin-bottom: 0;
+}
+
+.accordion-item:first-of-type .accordion-button {
+  border-top-left-radius: 0.25rem;
+  border-top-right-radius: 0.25rem;
+}
+.accordion-item:last-of-type .accordion-button.collapsed {
+  border-bottom-width: 1px;
+  border-bottom-right-radius: 0.25rem;
+  border-bottom-left-radius: 0.25rem;
+}
+.accordion-item:last-of-type .accordion-collapse {
+  border-bottom-width: 1px;
+  border-bottom-right-radius: 0.25rem;
+  border-bottom-left-radius: 0.25rem;
+}
+
+.accordion-collapse {
+  border: solid rgba(0, 0, 0, 0.125);
+  border-width: 0 1px;
+}
+
+.accordion-body {
+  padding: 1rem 1.25rem;
+}
+
+.accordion-flush .accordion-button {
+  border-right: 0;
+  border-left: 0;
+  border-radius: 0;
+}
+.accordion-flush .accordion-collapse {
+  border-width: 0;
+}
+.accordion-flush .accordion-item:first-of-type .accordion-button {
+  border-top-width: 0;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+.accordion-flush .accordion-item:last-of-type .accordion-button.collapsed {
+  border-bottom-width: 0;
+  border-bottom-right-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.breadcrumb {
+  display: flex;
+  flex-wrap: wrap;
+  padding: 0 0;
+  margin-bottom: 1rem;
+  list-style: none;
+}
+
+.breadcrumb-item + .breadcrumb-item {
+  padding-left: 0.5rem;
+}
+.breadcrumb-item + .breadcrumb-item::before {
+  float: left;
+  padding-right: 0.5rem;
+  color: #6c757d;
+  content: var(--bs-breadcrumb-divider, "/") /* rtl: var(--bs-breadcrumb-divider, "/") */;
+}
+.breadcrumb-item.active {
+  color: #6c757d;
+}
+
+.pagination {
+  display: flex;
+  padding-left: 0;
+  list-style: none;
+}
+
+.page-link {
+  position: relative;
+  display: block;
+  color: #0d6efd;
+  text-decoration: none;
+  background-color: #fff;
+  border: 1px solid #dee2e6;
+  transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .page-link {
+    transition: none;
+  }
+}
+.page-link:hover {
+  z-index: 2;
+  color: #0a58ca;
+  background-color: #e9ecef;
+  border-color: #dee2e6;
+}
+.page-link:focus {
+  z-index: 3;
+  color: #0a58ca;
+  background-color: #e9ecef;
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+
+.page-item:not(:first-child) .page-link {
+  margin-left: -1px;
+}
+.page-item.active .page-link {
+  z-index: 3;
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.page-item.disabled .page-link {
+  color: #6c757d;
+  pointer-events: none;
+  background-color: #fff;
+  border-color: #dee2e6;
+}
+
+.page-link {
+  padding: 0.375rem 0.75rem;
+}
+
+.page-item:first-child .page-link {
+  border-top-left-radius: 0.25rem;
+  border-bottom-left-radius: 0.25rem;
+}
+.page-item:last-child .page-link {
+  border-top-right-radius: 0.25rem;
+  border-bottom-right-radius: 0.25rem;
+}
+
+.pagination-lg .page-link {
+  padding: 0.75rem 1.5rem;
+  font-size: 1.25rem;
+}
+.pagination-lg .page-item:first-child .page-link {
+  border-top-left-radius: 0.3rem;
+  border-bottom-left-radius: 0.3rem;
+}
+.pagination-lg .page-item:last-child .page-link {
+  border-top-right-radius: 0.3rem;
+  border-bottom-right-radius: 0.3rem;
+}
+
+.pagination-sm .page-link {
+  padding: 0.25rem 0.5rem;
+  font-size: 0.875rem;
+}
+.pagination-sm .page-item:first-child .page-link {
+  border-top-left-radius: 0.2rem;
+  border-bottom-left-radius: 0.2rem;
+}
+.pagination-sm .page-item:last-child .page-link {
+  border-top-right-radius: 0.2rem;
+  border-bottom-right-radius: 0.2rem;
+}
+
+.badge {
+  display: inline-block;
+  padding: 0.35em 0.65em;
+  font-size: 0.75em;
+  font-weight: 700;
+  line-height: 1;
+  color: #fff;
+  text-align: center;
+  white-space: nowrap;
+  vertical-align: baseline;
+  border-radius: 0.25rem;
+}
+.badge:empty {
+  display: none;
+}
+
+.btn .badge {
+  position: relative;
+  top: -1px;
+}
+
+.alert {
+  position: relative;
+  padding: 1rem 1rem;
+  margin-bottom: 1rem;
+  border: 1px solid transparent;
+  border-radius: 0.25rem;
+}
+
+.alert-heading {
+  color: inherit;
+}
+
+.alert-link {
+  font-weight: 700;
+}
+
+.alert-dismissible {
+  padding-right: 3rem;
+}
+.alert-dismissible .btn-close {
+  position: absolute;
+  top: 0;
+  right: 0;
+  z-index: 2;
+  padding: 1.25rem 1rem;
+}
+
+.alert-primary {
+  color: #084298;
+  background-color: #cfe2ff;
+  border-color: #b6d4fe;
+}
+.alert-primary .alert-link {
+  color: #06357a;
+}
+
+.alert-secondary {
+  color: #41464b;
+  background-color: #e2e3e5;
+  border-color: #d3d6d8;
+}
+.alert-secondary .alert-link {
+  color: #34383c;
+}
+
+.alert-success {
+  color: #0f5132;
+  background-color: #d1e7dd;
+  border-color: #badbcc;
+}
+.alert-success .alert-link {
+  color: #0c4128;
+}
+
+.alert-info {
+  color: #055160;
+  background-color: #cff4fc;
+  border-color: #b6effb;
+}
+.alert-info .alert-link {
+  color: #04414d;
+}
+
+.alert-warning {
+  color: #664d03;
+  background-color: #fff3cd;
+  border-color: #ffecb5;
+}
+.alert-warning .alert-link {
+  color: #523e02;
+}
+
+.alert-danger {
+  color: #842029;
+  background-color: #f8d7da;
+  border-color: #f5c2c7;
+}
+.alert-danger .alert-link {
+  color: #6a1a21;
+}
+
+.alert-light {
+  color: #636464;
+  background-color: #fefefe;
+  border-color: #fdfdfe;
+}
+.alert-light .alert-link {
+  color: #4f5050;
+}
+
+.alert-dark {
+  color: #141619;
+  background-color: #d3d3d4;
+  border-color: #bcbebf;
+}
+.alert-dark .alert-link {
+  color: #101214;
+}
+
+@-webkit-keyframes progress-bar-stripes {
+  0% {
+    background-position-x: 1rem;
+  }
+}
+
+@keyframes progress-bar-stripes {
+  0% {
+    background-position-x: 1rem;
+  }
+}
+.progress {
+  display: flex;
+  height: 1rem;
+  overflow: hidden;
+  font-size: 0.75rem;
+  background-color: #e9ecef;
+  border-radius: 0.25rem;
+}
+
+.progress-bar {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  overflow: hidden;
+  color: #fff;
+  text-align: center;
+  white-space: nowrap;
+  background-color: #0d6efd;
+  transition: width 0.6s ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  .progress-bar {
+    transition: none;
+  }
+}
+
+.progress-bar-striped {
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-size: 1rem 1rem;
+}
+
+.progress-bar-animated {
+  -webkit-animation: 1s linear infinite progress-bar-stripes;
+  animation: 1s linear infinite progress-bar-stripes;
+}
+@media (prefers-reduced-motion: reduce) {
+  .progress-bar-animated {
+    -webkit-animation: none;
+    animation: none;
+  }
+}
+
+.list-group {
+  display: flex;
+  flex-direction: column;
+  padding-left: 0;
+  margin-bottom: 0;
+  border-radius: 0.25rem;
+}
+
+.list-group-item-action {
+  width: 100%;
+  color: #495057;
+  text-align: inherit;
+}
+.list-group-item-action:hover, .list-group-item-action:focus {
+  z-index: 1;
+  color: #495057;
+  text-decoration: none;
+  background-color: #f8f9fa;
+}
+.list-group-item-action:active {
+  color: #212529;
+  background-color: #e9ecef;
+}
+
+.list-group-item {
+  position: relative;
+  display: block;
+  padding: 0.5rem 1rem;
+  text-decoration: none;
+  background-color: #fff;
+  border: 1px solid rgba(0, 0, 0, 0.125);
+}
+.list-group-item:first-child {
+  border-top-left-radius: inherit;
+  border-top-right-radius: inherit;
+}
+.list-group-item:last-child {
+  border-bottom-right-radius: inherit;
+  border-bottom-left-radius: inherit;
+}
+.list-group-item.disabled, .list-group-item:disabled {
+  color: #6c757d;
+  pointer-events: none;
+  background-color: #fff;
+}
+.list-group-item.active {
+  z-index: 2;
+  color: #fff;
+  background-color: #0d6efd;
+  border-color: #0d6efd;
+}
+.list-group-item + .list-group-item {
+  border-top-width: 0;
+}
+.list-group-item + .list-group-item.active {
+  margin-top: -1px;
+  border-top-width: 1px;
+}
+
+.list-group-horizontal {
+  flex-direction: row;
+}
+.list-group-horizontal > .list-group-item:first-child {
+  border-bottom-left-radius: 0.25rem;
+  border-top-right-radius: 0;
+}
+.list-group-horizontal > .list-group-item:last-child {
+  border-top-right-radius: 0.25rem;
+  border-bottom-left-radius: 0;
+}
+.list-group-horizontal > .list-group-item.active {
+  margin-top: 0;
+}
+.list-group-horizontal > .list-group-item + .list-group-item {
+  border-top-width: 1px;
+  border-left-width: 0;
+}
+.list-group-horizontal > .list-group-item + .list-group-item.active {
+  margin-left: -1px;
+  border-left-width: 1px;
+}
+
+@media (min-width: 576px) {
+  .list-group-horizontal-sm {
+    flex-direction: row;
+  }
+  .list-group-horizontal-sm > .list-group-item:first-child {
+    border-bottom-left-radius: 0.25rem;
+    border-top-right-radius: 0;
+  }
+  .list-group-horizontal-sm > .list-group-item:last-child {
+    border-top-right-radius: 0.25rem;
+    border-bottom-left-radius: 0;
+  }
+  .list-group-horizontal-sm > .list-group-item.active {
+    margin-top: 0;
+  }
+  .list-group-horizontal-sm > .list-group-item + .list-group-item {
+    border-top-width: 1px;
+    border-left-width: 0;
+  }
+  .list-group-horizontal-sm > .list-group-item + .list-group-item.active {
+    margin-left: -1px;
+    border-left-width: 1px;
+  }
+}
+@media (min-width: 768px) {
+  .list-group-horizontal-md {
+    flex-direction: row;
+  }
+  .list-group-horizontal-md > .list-group-item:first-child {
+    border-bottom-left-radius: 0.25rem;
+    border-top-right-radius: 0;
+  }
+  .list-group-horizontal-md > .list-group-item:last-child {
+    border-top-right-radius: 0.25rem;
+    border-bottom-left-radius: 0;
+  }
+  .list-group-horizontal-md > .list-group-item.active {
+    margin-top: 0;
+  }
+  .list-group-horizontal-md > .list-group-item + .list-group-item {
+    border-top-width: 1px;
+    border-left-width: 0;
+  }
+  .list-group-horizontal-md > .list-group-item + .list-group-item.active {
+    margin-left: -1px;
+    border-left-width: 1px;
+  }
+}
+@media (min-width: 992px) {
+  .list-group-horizontal-lg {
+    flex-direction: row;
+  }
+  .list-group-horizontal-lg > .list-group-item:first-child {
+    border-bottom-left-radius: 0.25rem;
+    border-top-right-radius: 0;
+  }
+  .list-group-horizontal-lg > .list-group-item:last-child {
+    border-top-right-radius: 0.25rem;
+    border-bottom-left-radius: 0;
+  }
+  .list-group-horizontal-lg > .list-group-item.active {
+    margin-top: 0;
+  }
+  .list-group-horizontal-lg > .list-group-item + .list-group-item {
+    border-top-width: 1px;
+    border-left-width: 0;
+  }
+  .list-group-horizontal-lg > .list-group-item + .list-group-item.active {
+    margin-left: -1px;
+    border-left-width: 1px;
+  }
+}
+@media (min-width: 1200px) {
+  .list-group-horizontal-xl {
+    flex-direction: row;
+  }
+  .list-group-horizontal-xl > .list-group-item:first-child {
+    border-bottom-left-radius: 0.25rem;
+    border-top-right-radius: 0;
+  }
+  .list-group-horizontal-xl > .list-group-item:last-child {
+    border-top-right-radius: 0.25rem;
+    border-bottom-left-radius: 0;
+  }
+  .list-group-horizontal-xl > .list-group-item.active {
+    margin-top: 0;
+  }
+  .list-group-horizontal-xl > .list-group-item + .list-group-item {
+    border-top-width: 1px;
+    border-left-width: 0;
+  }
+  .list-group-horizontal-xl > .list-group-item + .list-group-item.active {
+    margin-left: -1px;
+    border-left-width: 1px;
+  }
+}
+@media (min-width: 1400px) {
+  .list-group-horizontal-xxl {
+    flex-direction: row;
+  }
+  .list-group-horizontal-xxl > .list-group-item:first-child {
+    border-bottom-left-radius: 0.25rem;
+    border-top-right-radius: 0;
+  }
+  .list-group-horizontal-xxl > .list-group-item:last-child {
+    border-top-right-radius: 0.25rem;
+    border-bottom-left-radius: 0;
+  }
+  .list-group-horizontal-xxl > .list-group-item.active {
+    margin-top: 0;
+  }
+  .list-group-horizontal-xxl > .list-group-item + .list-group-item {
+    border-top-width: 1px;
+    border-left-width: 0;
+  }
+  .list-group-horizontal-xxl > .list-group-item + .list-group-item.active {
+    margin-left: -1px;
+    border-left-width: 1px;
+  }
+}
+.list-group-flush {
+  border-radius: 0;
+}
+.list-group-flush > .list-group-item {
+  border-width: 0 0 1px;
+}
+.list-group-flush > .list-group-item:last-child {
+  border-bottom-width: 0;
+}
+
+.list-group-item-primary {
+  color: #084298;
+  background-color: #cfe2ff;
+}
+.list-group-item-primary.list-group-item-action:hover, .list-group-item-primary.list-group-item-action:focus {
+  color: #084298;
+  background-color: #bacbe6;
+}
+.list-group-item-primary.list-group-item-action.active {
+  color: #fff;
+  background-color: #084298;
+  border-color: #084298;
+}
+
+.list-group-item-secondary {
+  color: #41464b;
+  background-color: #e2e3e5;
+}
+.list-group-item-secondary.list-group-item-action:hover, .list-group-item-secondary.list-group-item-action:focus {
+  color: #41464b;
+  background-color: #cbccce;
+}
+.list-group-item-secondary.list-group-item-action.active {
+  color: #fff;
+  background-color: #41464b;
+  border-color: #41464b;
+}
+
+.list-group-item-success {
+  color: #0f5132;
+  background-color: #d1e7dd;
+}
+.list-group-item-success.list-group-item-action:hover, .list-group-item-success.list-group-item-action:focus {
+  color: #0f5132;
+  background-color: #bcd0c7;
+}
+.list-group-item-success.list-group-item-action.active {
+  color: #fff;
+  background-color: #0f5132;
+  border-color: #0f5132;
+}
+
+.list-group-item-info {
+  color: #055160;
+  background-color: #cff4fc;
+}
+.list-group-item-info.list-group-item-action:hover, .list-group-item-info.list-group-item-action:focus {
+  color: #055160;
+  background-color: #badce3;
+}
+.list-group-item-info.list-group-item-action.active {
+  color: #fff;
+  background-color: #055160;
+  border-color: #055160;
+}
+
+.list-group-item-warning {
+  color: #664d03;
+  background-color: #fff3cd;
+}
+.list-group-item-warning.list-group-item-action:hover, .list-group-item-warning.list-group-item-action:focus {
+  color: #664d03;
+  background-color: #e6dbb9;
+}
+.list-group-item-warning.list-group-item-action.active {
+  color: #fff;
+  background-color: #664d03;
+  border-color: #664d03;
+}
+
+.list-group-item-danger {
+  color: #842029;
+  background-color: #f8d7da;
+}
+.list-group-item-danger.list-group-item-action:hover, .list-group-item-danger.list-group-item-action:focus {
+  color: #842029;
+  background-color: #dfc2c4;
+}
+.list-group-item-danger.list-group-item-action.active {
+  color: #fff;
+  background-color: #842029;
+  border-color: #842029;
+}
+
+.list-group-item-light {
+  color: #636464;
+  background-color: #fefefe;
+}
+.list-group-item-light.list-group-item-action:hover, .list-group-item-light.list-group-item-action:focus {
+  color: #636464;
+  background-color: #e5e5e5;
+}
+.list-group-item-light.list-group-item-action.active {
+  color: #fff;
+  background-color: #636464;
+  border-color: #636464;
+}
+
+.list-group-item-dark {
+  color: #141619;
+  background-color: #d3d3d4;
+}
+.list-group-item-dark.list-group-item-action:hover, .list-group-item-dark.list-group-item-action:focus {
+  color: #141619;
+  background-color: #bebebf;
+}
+.list-group-item-dark.list-group-item-action.active {
+  color: #fff;
+  background-color: #141619;
+  border-color: #141619;
+}
+
+.btn-close {
+  box-sizing: content-box;
+  width: 1em;
+  height: 1em;
+  padding: 0.25em 0.25em;
+  color: #000;
+  background: transparent url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23000'%3e%3cpath d='M.293.293a1 1 0 011.414 0L8 6.586 14.293.293a1 1 0 111.414 1.414L9.414 8l6.293 6.293a1 1 0 01-1.414 1.414L8 9.414l-6.293 6.293a1 1 0 01-1.414-1.414L6.586 8 .293 1.707a1 1 0 010-1.414z'/%3e%3c/svg%3e") center/1em auto no-repeat;
+  border: 0;
+  border-radius: 0.25rem;
+  opacity: 0.5;
+}
+.btn-close:hover {
+  color: #000;
+  text-decoration: none;
+  opacity: 0.75;
+}
+.btn-close:focus {
+  outline: 0;
+  box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+  opacity: 1;
+}
+.btn-close:disabled, .btn-close.disabled {
+  pointer-events: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+  opacity: 0.25;
+}
+
+.btn-close-white {
+  filter: invert(1) grayscale(100%) brightness(200%);
+}
+
+.toast {
+  width: 350px;
+  max-width: 100%;
+  font-size: 0.875rem;
+  pointer-events: auto;
+  background-color: rgba(255, 255, 255, 0.85);
+  background-clip: padding-box;
+  border: 1px solid rgba(0, 0, 0, 0.1);
+  box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+  border-radius: 0.25rem;
+}
+.toast:not(.showing):not(.show) {
+  opacity: 0;
+}
+.toast.hide {
+  display: none;
+}
+
+.toast-container {
+  width: -webkit-max-content;
+  width: -moz-max-content;
+  width: max-content;
+  max-width: 100%;
+  pointer-events: none;
+}
+.toast-container > :not(:last-child) {
+  margin-bottom: 0.75rem;
+}
+
+.toast-header {
+  display: flex;
+  align-items: center;
+  padding: 0.5rem 0.75rem;
+  color: #6c757d;
+  background-color: rgba(255, 255, 255, 0.85);
+  background-clip: padding-box;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+  border-top-left-radius: calc(0.25rem - 1px);
+  border-top-right-radius: calc(0.25rem - 1px);
+}
+.toast-header .btn-close {
+  margin-right: -0.375rem;
+  margin-left: 0.75rem;
+}
+
+.toast-body {
+  padding: 0.75rem;
+  word-wrap: break-word;
+}
+
+.modal-open {
+  overflow: hidden;
+}
+.modal-open .modal {
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+
+.modal {
+  position: fixed;
+  top: 0;
+  left: 0;
+  z-index: 1050;
+  display: none;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  outline: 0;
+}
+
+.modal-dialog {
+  position: relative;
+  width: auto;
+  margin: 0.5rem;
+  pointer-events: none;
+}
+.modal.fade .modal-dialog {
+  transition: transform 0.3s ease-out;
+  transform: translate(0, -50px);
+}
+@media (prefers-reduced-motion: reduce) {
+  .modal.fade .modal-dialog {
+    transition: none;
+  }
+}
+.modal.show .modal-dialog {
+  transform: none;
+}
+.modal.modal-static .modal-dialog {
+  transform: scale(1.02);
+}
+
+.modal-dialog-scrollable {
+  height: calc(100% - 1rem);
+}
+.modal-dialog-scrollable .modal-content {
+  max-height: 100%;
+  overflow: hidden;
+}
+.modal-dialog-scrollable .modal-body {
+  overflow-y: auto;
+}
+
+.modal-dialog-centered {
+  display: flex;
+  align-items: center;
+  min-height: calc(100% - 1rem);
+}
+
+.modal-content {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  pointer-events: auto;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  border-radius: 0.3rem;
+  outline: 0;
+}
+
+.modal-backdrop {
+  position: fixed;
+  top: 0;
+  left: 0;
+  z-index: 1040;
+  width: 100vw;
+  height: 100vh;
+  background-color: #000;
+}
+.modal-backdrop.fade {
+  opacity: 0;
+}
+.modal-backdrop.show {
+  opacity: 0.5;
+}
+
+.modal-header {
+  display: flex;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem 1rem;
+  border-bottom: 1px solid #dee2e6;
+  border-top-left-radius: calc(0.3rem - 1px);
+  border-top-right-radius: calc(0.3rem - 1px);
+}
+.modal-header .btn-close {
+  padding: 0.5rem 0.5rem;
+  margin: -0.5rem -0.5rem -0.5rem auto;
+}
+
+.modal-title {
+  margin-bottom: 0;
+  line-height: 1.5;
+}
+
+.modal-body {
+  position: relative;
+  flex: 1 1 auto;
+  padding: 1rem;
+}
+
+.modal-footer {
+  display: flex;
+  flex-wrap: wrap;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: flex-end;
+  padding: 0.75rem;
+  border-top: 1px solid #dee2e6;
+  border-bottom-right-radius: calc(0.3rem - 1px);
+  border-bottom-left-radius: calc(0.3rem - 1px);
+}
+.modal-footer > * {
+  margin: 0.25rem;
+}
+
+.modal-scrollbar-measure {
+  position: absolute;
+  top: -9999px;
+  width: 50px;
+  height: 50px;
+  overflow: scroll;
+}
+
+@media (min-width: 576px) {
+  .modal-dialog {
+    max-width: 500px;
+    margin: 1.75rem auto;
+  }
+
+  .modal-dialog-scrollable {
+    height: calc(100% - 3.5rem);
+  }
+
+  .modal-dialog-centered {
+    min-height: calc(100% - 3.5rem);
+  }
+
+  .modal-sm {
+    max-width: 300px;
+  }
+}
+@media (min-width: 992px) {
+  .modal-lg,
+.modal-xl {
+    max-width: 800px;
+  }
+}
+@media (min-width: 1200px) {
+  .modal-xl {
+    max-width: 1140px;
+  }
+}
+.modal-fullscreen {
+  width: 100vw;
+  max-width: none;
+  height: 100%;
+  margin: 0;
+}
+.modal-fullscreen .modal-content {
+  height: 100%;
+  border: 0;
+  border-radius: 0;
+}
+.modal-fullscreen .modal-header {
+  border-radius: 0;
+}
+.modal-fullscreen .modal-body {
+  overflow-y: auto;
+}
+.modal-fullscreen .modal-footer {
+  border-radius: 0;
+}
+
+@media (max-width: 575.98px) {
+  .modal-fullscreen-sm-down {
+    width: 100vw;
+    max-width: none;
+    height: 100%;
+    margin: 0;
+  }
+  .modal-fullscreen-sm-down .modal-content {
+    height: 100%;
+    border: 0;
+    border-radius: 0;
+  }
+  .modal-fullscreen-sm-down .modal-header {
+    border-radius: 0;
+  }
+  .modal-fullscreen-sm-down .modal-body {
+    overflow-y: auto;
+  }
+  .modal-fullscreen-sm-down .modal-footer {
+    border-radius: 0;
+  }
+}
+@media (max-width: 767.98px) {
+  .modal-fullscreen-md-down {
+    width: 100vw;
+    max-width: none;
+    height: 100%;
+    margin: 0;
+  }
+  .modal-fullscreen-md-down .modal-content {
+    height: 100%;
+    border: 0;
+    border-radius: 0;
+  }
+  .modal-fullscreen-md-down .modal-header {
+    border-radius: 0;
+  }
+  .modal-fullscreen-md-down .modal-body {
+    overflow-y: auto;
+  }
+  .modal-fullscreen-md-down .modal-footer {
+    border-radius: 0;
+  }
+}
+@media (max-width: 991.98px) {
+  .modal-fullscreen-lg-down {
+    width: 100vw;
+    max-width: none;
+    height: 100%;
+    margin: 0;
+  }
+  .modal-fullscreen-lg-down .modal-content {
+    height: 100%;
+    border: 0;
+    border-radius: 0;
+  }
+  .modal-fullscreen-lg-down .modal-header {
+    border-radius: 0;
+  }
+  .modal-fullscreen-lg-down .modal-body {
+    overflow-y: auto;
+  }
+  .modal-fullscreen-lg-down .modal-footer {
+    border-radius: 0;
+  }
+}
+@media (max-width: 1199.98px) {
+  .modal-fullscreen-xl-down {
+    width: 100vw;
+    max-width: none;
+    height: 100%;
+    margin: 0;
+  }
+  .modal-fullscreen-xl-down .modal-content {
+    height: 100%;
+    border: 0;
+    border-radius: 0;
+  }
+  .modal-fullscreen-xl-down .modal-header {
+    border-radius: 0;
+  }
+  .modal-fullscreen-xl-down .modal-body {
+    overflow-y: auto;
+  }
+  .modal-fullscreen-xl-down .modal-footer {
+    border-radius: 0;
+  }
+}
+@media (max-width: 1399.98px) {
+  .modal-fullscreen-xxl-down {
+    width: 100vw;
+    max-width: none;
+    height: 100%;
+    margin: 0;
+  }
+  .modal-fullscreen-xxl-down .modal-content {
+    height: 100%;
+    border: 0;
+    border-radius: 0;
+  }
+  .modal-fullscreen-xxl-down .modal-header {
+    border-radius: 0;
+  }
+  .modal-fullscreen-xxl-down .modal-body {
+    overflow-y: auto;
+  }
+  .modal-fullscreen-xxl-down .modal-footer {
+    border-radius: 0;
+  }
+}
+.tooltip {
+  position: absolute;
+  z-index: 1070;
+  display: block;
+  margin: 0;
+  font-family: var(--bs-font-sans-serif);
+  font-style: normal;
+  font-weight: 400;
+  line-height: 1.5;
+  text-align: left;
+  text-align: start;
+  text-decoration: none;
+  text-shadow: none;
+  text-transform: none;
+  letter-spacing: normal;
+  word-break: normal;
+  word-spacing: normal;
+  white-space: normal;
+  line-break: auto;
+  font-size: 0.875rem;
+  word-wrap: break-word;
+  opacity: 0;
+}
+.tooltip.show {
+  opacity: 0.9;
+}
+.tooltip .tooltip-arrow {
+  position: absolute;
+  display: block;
+  width: 0.8rem;
+  height: 0.4rem;
+}
+.tooltip .tooltip-arrow::before {
+  position: absolute;
+  content: "";
+  border-color: transparent;
+  border-style: solid;
+}
+
+.bs-tooltip-top, .bs-tooltip-auto[data-popper-placement^=top] {
+  padding: 0.4rem 0;
+}
+.bs-tooltip-top .tooltip-arrow, .bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow {
+  bottom: 0;
+}
+.bs-tooltip-top .tooltip-arrow::before, .bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow::before {
+  top: -1px;
+  border-width: 0.4rem 0.4rem 0;
+  border-top-color: #000;
+}
+
+.bs-tooltip-end, .bs-tooltip-auto[data-popper-placement^=right] {
+  padding: 0 0.4rem;
+}
+.bs-tooltip-end .tooltip-arrow, .bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow {
+  left: 0;
+  width: 0.4rem;
+  height: 0.8rem;
+}
+.bs-tooltip-end .tooltip-arrow::before, .bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow::before {
+  right: -1px;
+  border-width: 0.4rem 0.4rem 0.4rem 0;
+  border-right-color: #000;
+}
+
+.bs-tooltip-bottom, .bs-tooltip-auto[data-popper-placement^=bottom] {
+  padding: 0.4rem 0;
+}
+.bs-tooltip-bottom .tooltip-arrow, .bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow {
+  top: 0;
+}
+.bs-tooltip-bottom .tooltip-arrow::before, .bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow::before {
+  bottom: -1px;
+  border-width: 0 0.4rem 0.4rem;
+  border-bottom-color: #000;
+}
+
+.bs-tooltip-start, .bs-tooltip-auto[data-popper-placement^=left] {
+  padding: 0 0.4rem;
+}
+.bs-tooltip-start .tooltip-arrow, .bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow {
+  right: 0;
+  width: 0.4rem;
+  height: 0.8rem;
+}
+.bs-tooltip-start .tooltip-arrow::before, .bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow::before {
+  left: -1px;
+  border-width: 0.4rem 0 0.4rem 0.4rem;
+  border-left-color: #000;
+}
+
+.tooltip-inner {
+  max-width: 200px;
+  padding: 0.25rem 0.5rem;
+  color: #fff;
+  text-align: center;
+  background-color: #000;
+  border-radius: 0.25rem;
+}
+
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0 /* rtl:ignore */;
+  z-index: 1060;
+  display: block;
+  max-width: 276px;
+  font-family: var(--bs-font-sans-serif);
+  font-style: normal;
+  font-weight: 400;
+  line-height: 1.5;
+  text-align: left;
+  text-align: start;
+  text-decoration: none;
+  text-shadow: none;
+  text-transform: none;
+  letter-spacing: normal;
+  word-break: normal;
+  word-spacing: normal;
+  white-space: normal;
+  line-break: auto;
+  font-size: 0.875rem;
+  word-wrap: break-word;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  border-radius: 0.3rem;
+}
+.popover .popover-arrow {
+  position: absolute;
+  display: block;
+  width: 1rem;
+  height: 0.5rem;
+}
+.popover .popover-arrow::before, .popover .popover-arrow::after {
+  position: absolute;
+  display: block;
+  content: "";
+  border-color: transparent;
+  border-style: solid;
+}
+
+.bs-popover-top > .popover-arrow, .bs-popover-auto[data-popper-placement^=top] > .popover-arrow {
+  bottom: calc(-0.5rem - 1px);
+}
+.bs-popover-top > .popover-arrow::before, .bs-popover-auto[data-popper-placement^=top] > .popover-arrow::before {
+  bottom: 0;
+  border-width: 0.5rem 0.5rem 0;
+  border-top-color: rgba(0, 0, 0, 0.25);
+}
+.bs-popover-top > .popover-arrow::after, .bs-popover-auto[data-popper-placement^=top] > .popover-arrow::after {
+  bottom: 1px;
+  border-width: 0.5rem 0.5rem 0;
+  border-top-color: #fff;
+}
+
+.bs-popover-end > .popover-arrow, .bs-popover-auto[data-popper-placement^=right] > .popover-arrow {
+  left: calc(-0.5rem - 1px);
+  width: 0.5rem;
+  height: 1rem;
+}
+.bs-popover-end > .popover-arrow::before, .bs-popover-auto[data-popper-placement^=right] > .popover-arrow::before {
+  left: 0;
+  border-width: 0.5rem 0.5rem 0.5rem 0;
+  border-right-color: rgba(0, 0, 0, 0.25);
+}
+.bs-popover-end > .popover-arrow::after, .bs-popover-auto[data-popper-placement^=right] > .popover-arrow::after {
+  left: 1px;
+  border-width: 0.5rem 0.5rem 0.5rem 0;
+  border-right-color: #fff;
+}
+
+.bs-popover-bottom > .popover-arrow, .bs-popover-auto[data-popper-placement^=bottom] > .popover-arrow {
+  top: calc(-0.5rem - 1px);
+}
+.bs-popover-bottom > .popover-arrow::before, .bs-popover-auto[data-popper-placement^=bottom] > .popover-arrow::before {
+  top: 0;
+  border-width: 0 0.5rem 0.5rem 0.5rem;
+  border-bottom-color: rgba(0, 0, 0, 0.25);
+}
+.bs-popover-bottom > .popover-arrow::after, .bs-popover-auto[data-popper-placement^=bottom] > .popover-arrow::after {
+  top: 1px;
+  border-width: 0 0.5rem 0.5rem 0.5rem;
+  border-bottom-color: #fff;
+}
+.bs-popover-bottom .popover-header::before, .bs-popover-auto[data-popper-placement^=bottom] .popover-header::before {
+  position: absolute;
+  top: 0;
+  left: 50%;
+  display: block;
+  width: 1rem;
+  margin-left: -0.5rem;
+  content: "";
+  border-bottom: 1px solid #f0f0f0;
+}
+
+.bs-popover-start > .popover-arrow, .bs-popover-auto[data-popper-placement^=left] > .popover-arrow {
+  right: calc(-0.5rem - 1px);
+  width: 0.5rem;
+  height: 1rem;
+}
+.bs-popover-start > .popover-arrow::before, .bs-popover-auto[data-popper-placement^=left] > .popover-arrow::before {
+  right: 0;
+  border-width: 0.5rem 0 0.5rem 0.5rem;
+  border-left-color: rgba(0, 0, 0, 0.25);
+}
+.bs-popover-start > .popover-arrow::after, .bs-popover-auto[data-popper-placement^=left] > .popover-arrow::after {
+  right: 1px;
+  border-width: 0.5rem 0 0.5rem 0.5rem;
+  border-left-color: #fff;
+}
+
+.popover-header {
+  padding: 0.5rem 1rem;
+  margin-bottom: 0;
+  font-size: 1rem;
+  background-color: #f0f0f0;
+  border-bottom: 1px solid #d8d8d8;
+  border-top-left-radius: calc(0.3rem - 1px);
+  border-top-right-radius: calc(0.3rem - 1px);
+}
+.popover-header:empty {
+  display: none;
+}
+
+.popover-body {
+  padding: 1rem 1rem;
+  color: #212529;
+}
+
+.carousel {
+  position: relative;
+}
+
+.carousel.pointer-event {
+  touch-action: pan-y;
+}
+
+.carousel-inner {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+}
+.carousel-inner::after {
+  display: block;
+  clear: both;
+  content: "";
+}
+
+.carousel-item {
+  position: relative;
+  display: none;
+  float: left;
+  width: 100%;
+  margin-right: -100%;
+  -webkit-backface-visibility: hidden;
+  backface-visibility: hidden;
+  transition: transform 0.6s ease-in-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .carousel-item {
+    transition: none;
+  }
+}
+
+.carousel-item.active,
+.carousel-item-next,
+.carousel-item-prev {
+  display: block;
+}
+
+/* rtl:begin:ignore */
+.carousel-item-next:not(.carousel-item-start),
+.active.carousel-item-end {
+  transform: translateX(100%);
+}
+
+.carousel-item-prev:not(.carousel-item-end),
+.active.carousel-item-start {
+  transform: translateX(-100%);
+}
+
+/* rtl:end:ignore */
+.carousel-fade .carousel-item {
+  opacity: 0;
+  transition-property: opacity;
+  transform: none;
+}
+.carousel-fade .carousel-item.active,
+.carousel-fade .carousel-item-next.carousel-item-start,
+.carousel-fade .carousel-item-prev.carousel-item-end {
+  z-index: 1;
+  opacity: 1;
+}
+.carousel-fade .active.carousel-item-start,
+.carousel-fade .active.carousel-item-end {
+  z-index: 0;
+  opacity: 0;
+  transition: opacity 0s 0.6s;
+}
+@media (prefers-reduced-motion: reduce) {
+  .carousel-fade .active.carousel-item-start,
+.carousel-fade .active.carousel-item-end {
+    transition: none;
+  }
+}
+
+.carousel-control-prev,
+.carousel-control-next {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  z-index: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 15%;
+  padding: 0;
+  color: #fff;
+  text-align: center;
+  background: none;
+  border: 0;
+  opacity: 0.5;
+  transition: opacity 0.15s ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  .carousel-control-prev,
+.carousel-control-next {
+    transition: none;
+  }
+}
+.carousel-control-prev:hover, .carousel-control-prev:focus,
+.carousel-control-next:hover,
+.carousel-control-next:focus {
+  color: #fff;
+  text-decoration: none;
+  outline: 0;
+  opacity: 0.9;
+}
+
+.carousel-control-prev {
+  left: 0;
+}
+
+.carousel-control-next {
+  right: 0;
+}
+
+.carousel-control-prev-icon,
+.carousel-control-next-icon {
+  display: inline-block;
+  width: 2rem;
+  height: 2rem;
+  background-repeat: no-repeat;
+  background-position: 50%;
+  background-size: 100% 100%;
+}
+
+/* rtl:options: {
+  "autoRename": true,
+  "stringMap":[ {
+    "name"    : "prev-next",
+    "search"  : "prev",
+    "replace" : "next"
+  } ]
+} */
+.carousel-control-prev-icon {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0z'/%3e%3c/svg%3e");
+}
+
+.carousel-control-next-icon {
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");
+}
+
+.carousel-indicators {
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 2;
+  display: flex;
+  justify-content: center;
+  padding: 0;
+  margin-right: 15%;
+  margin-bottom: 1rem;
+  margin-left: 15%;
+  list-style: none;
+}
+.carousel-indicators [data-bs-target] {
+  box-sizing: content-box;
+  flex: 0 1 auto;
+  width: 30px;
+  height: 3px;
+  padding: 0;
+  margin-right: 3px;
+  margin-left: 3px;
+  text-indent: -999px;
+  cursor: pointer;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 0;
+  border-top: 10px solid transparent;
+  border-bottom: 10px solid transparent;
+  opacity: 0.5;
+  transition: opacity 0.6s ease;
+}
+@media (prefers-reduced-motion: reduce) {
+  .carousel-indicators [data-bs-target] {
+    transition: none;
+  }
+}
+.carousel-indicators .active {
+  opacity: 1;
+}
+
+.carousel-caption {
+  position: absolute;
+  right: 15%;
+  bottom: 1.25rem;
+  left: 15%;
+  padding-top: 1.25rem;
+  padding-bottom: 1.25rem;
+  color: #fff;
+  text-align: center;
+}
+
+.carousel-dark .carousel-control-prev-icon,
+.carousel-dark .carousel-control-next-icon {
+  filter: invert(1) grayscale(100);
+}
+.carousel-dark .carousel-indicators [data-bs-target] {
+  background-color: #000;
+}
+.carousel-dark .carousel-caption {
+  color: #000;
+}
+
+@-webkit-keyframes spinner-border {
+  to {
+    transform: rotate(360deg) /* rtl:ignore */;
+  }
+}
+
+@keyframes spinner-border {
+  to {
+    transform: rotate(360deg) /* rtl:ignore */;
+  }
+}
+.spinner-border {
+  display: inline-block;
+  width: 2rem;
+  height: 2rem;
+  vertical-align: text-bottom;
+  border: 0.25em solid currentColor;
+  border-right-color: transparent;
+  border-radius: 50%;
+  -webkit-animation: 0.75s linear infinite spinner-border;
+  animation: 0.75s linear infinite spinner-border;
+}
+
+.spinner-border-sm {
+  width: 1rem;
+  height: 1rem;
+  border-width: 0.2em;
+}
+
+@-webkit-keyframes spinner-grow {
+  0% {
+    transform: scale(0);
+  }
+  50% {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+@keyframes spinner-grow {
+  0% {
+    transform: scale(0);
+  }
+  50% {
+    opacity: 1;
+    transform: none;
+  }
+}
+.spinner-grow {
+  display: inline-block;
+  width: 2rem;
+  height: 2rem;
+  vertical-align: text-bottom;
+  background-color: currentColor;
+  border-radius: 50%;
+  opacity: 0;
+  -webkit-animation: 0.75s linear infinite spinner-grow;
+  animation: 0.75s linear infinite spinner-grow;
+}
+
+.spinner-grow-sm {
+  width: 1rem;
+  height: 1rem;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .spinner-border,
+.spinner-grow {
+    -webkit-animation-duration: 1.5s;
+    animation-duration: 1.5s;
+  }
+}
+.clearfix::after {
+  display: block;
+  clear: both;
+  content: "";
+}
+
+.link-primary {
+  color: #0d6efd;
+}
+.link-primary:hover, .link-primary:focus {
+  color: #0a58ca;
+}
+
+.link-secondary {
+  color: #6c757d;
+}
+.link-secondary:hover, .link-secondary:focus {
+  color: #565e64;
+}
+
+.link-success {
+  color: #198754;
+}
+.link-success:hover, .link-success:focus {
+  color: #146c43;
+}
+
+.link-info {
+  color: #0dcaf0;
+}
+.link-info:hover, .link-info:focus {
+  color: #3dd5f3;
+}
+
+.link-warning {
+  color: #ffc107;
+}
+.link-warning:hover, .link-warning:focus {
+  color: #ffcd39;
+}
+
+.link-danger {
+  color: #dc3545;
+}
+.link-danger:hover, .link-danger:focus {
+  color: #b02a37;
+}
+
+.link-light {
+  color: #f8f9fa;
+}
+.link-light:hover, .link-light:focus {
+  color: #f9fafb;
+}
+
+.link-dark {
+  color: #212529;
+}
+.link-dark:hover, .link-dark:focus {
+  color: #1a1e21;
+}
+
+.ratio {
+  position: relative;
+  width: 100%;
+}
+.ratio::before {
+  display: block;
+  padding-top: var(--bs-aspect-ratio);
+  content: "";
+}
+.ratio > * {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.ratio-1x1 {
+  --bs-aspect-ratio: 100%;
+}
+
+.ratio-4x3 {
+  --bs-aspect-ratio: calc(3 / 4 * 100%);
+}
+
+.ratio-16x9 {
+  --bs-aspect-ratio: calc(9 / 16 * 100%);
+}
+
+.ratio-21x9 {
+  --bs-aspect-ratio: calc(9 / 21 * 100%);
+}
+
+.fixed-top {
+  position: fixed;
+  top: 0;
+  right: 0;
+  left: 0;
+  z-index: 1030;
+}
+
+.fixed-bottom {
+  position: fixed;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1030;
+}
+
+.sticky-top {
+  position: -webkit-sticky;
+  position: sticky;
+  top: 0;
+  z-index: 1020;
+}
+
+@media (min-width: 576px) {
+  .sticky-sm-top {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+    z-index: 1020;
+  }
+}
+@media (min-width: 768px) {
+  .sticky-md-top {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+    z-index: 1020;
+  }
+}
+@media (min-width: 992px) {
+  .sticky-lg-top {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+    z-index: 1020;
+  }
+}
+@media (min-width: 1200px) {
+  .sticky-xl-top {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+    z-index: 1020;
+  }
+}
+@media (min-width: 1400px) {
+  .sticky-xxl-top {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+    z-index: 1020;
+  }
+}
+.visually-hidden,
+.visually-hidden-focusable:not(:focus):not(:focus-within) {
+  position: absolute !important;
+  width: 1px !important;
+  height: 1px !important;
+  padding: 0 !important;
+  margin: -1px !important;
+  overflow: hidden !important;
+  clip: rect(0, 0, 0, 0) !important;
+  white-space: nowrap !important;
+  border: 0 !important;
+}
+
+.stretched-link::after {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1;
+  content: "";
+}
+
+.text-truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.align-baseline {
+  vertical-align: baseline !important;
+}
+
+.align-top {
+  vertical-align: top !important;
+}
+
+.align-middle {
+  vertical-align: middle !important;
+}
+
+.align-bottom {
+  vertical-align: bottom !important;
+}
+
+.align-text-bottom {
+  vertical-align: text-bottom !important;
+}
+
+.align-text-top {
+  vertical-align: text-top !important;
+}
+
+.float-start {
+  float: left !important;
+}
+
+.float-end {
+  float: right !important;
+}
+
+.float-none {
+  float: none !important;
+}
+
+.overflow-auto {
+  overflow: auto !important;
+}
+
+.overflow-hidden {
+  overflow: hidden !important;
+}
+
+.overflow-visible {
+  overflow: visible !important;
+}
+
+.overflow-scroll {
+  overflow: scroll !important;
+}
+
+.d-inline {
+  display: inline !important;
+}
+
+.d-inline-block {
+  display: inline-block !important;
+}
+
+.d-block {
+  display: block !important;
+}
+
+.d-grid {
+  display: grid !important;
+}
+
+.d-table {
+  display: table !important;
+}
+
+.d-table-row {
+  display: table-row !important;
+}
+
+.d-table-cell {
+  display: table-cell !important;
+}
+
+.d-flex {
+  display: flex !important;
+}
+
+.d-inline-flex {
+  display: inline-flex !important;
+}
+
+.d-none {
+  display: none !important;
+}
+
+.shadow {
+  box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15) !important;
+}
+
+.shadow-sm {
+  box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075) !important;
+}
+
+.shadow-lg {
+  box-shadow: 0 1rem 3rem rgba(0, 0, 0, 0.175) !important;
+}
+
+.shadow-none {
+  box-shadow: none !important;
+}
+
+.position-static {
+  position: static !important;
+}
+
+.position-relative {
+  position: relative !important;
+}
+
+.position-absolute {
+  position: absolute !important;
+}
+
+.position-fixed {
+  position: fixed !important;
+}
+
+.position-sticky {
+  position: -webkit-sticky !important;
+  position: sticky !important;
+}
+
+.top-0 {
+  top: 0 !important;
+}
+
+.top-50 {
+  top: 50% !important;
+}
+
+.top-100 {
+  top: 100% !important;
+}
+
+.bottom-0 {
+  bottom: 0 !important;
+}
+
+.bottom-50 {
+  bottom: 50% !important;
+}
+
+.bottom-100 {
+  bottom: 100% !important;
+}
+
+.start-0 {
+  left: 0 !important;
+}
+
+.start-50 {
+  left: 50% !important;
+}
+
+.start-100 {
+  left: 100% !important;
+}
+
+.end-0 {
+  right: 0 !important;
+}
+
+.end-50 {
+  right: 50% !important;
+}
+
+.end-100 {
+  right: 100% !important;
+}
+
+.translate-middle {
+  transform: translate(-50%, -50%) !important;
+}
+
+.translate-middle-x {
+  transform: translateX(-50%) !important;
+}
+
+.translate-middle-y {
+  transform: translateY(-50%) !important;
+}
+
+.border {
+  border: 1px solid #dee2e6 !important;
+}
+
+.border-0 {
+  border: 0 !important;
+}
+
+.border-top {
+  border-top: 1px solid #dee2e6 !important;
+}
+
+.border-top-0 {
+  border-top: 0 !important;
+}
+
+.border-end {
+  border-right: 1px solid #dee2e6 !important;
+}
+
+.border-end-0 {
+  border-right: 0 !important;
+}
+
+.border-bottom {
+  border-bottom: 1px solid #dee2e6 !important;
+}
+
+.border-bottom-0 {
+  border-bottom: 0 !important;
+}
+
+.border-start {
+  border-left: 1px solid #dee2e6 !important;
+}
+
+.border-start-0 {
+  border-left: 0 !important;
+}
+
+.border-primary {
+  border-color: #0d6efd !important;
+}
+
+.border-secondary {
+  border-color: #6c757d !important;
+}
+
+.border-success {
+  border-color: #198754 !important;
+}
+
+.border-info {
+  border-color: #0dcaf0 !important;
+}
+
+.border-warning {
+  border-color: #ffc107 !important;
+}
+
+.border-danger {
+  border-color: #dc3545 !important;
+}
+
+.border-light {
+  border-color: #f8f9fa !important;
+}
+
+.border-dark {
+  border-color: #212529 !important;
+}
+
+.border-white {
+  border-color: #fff !important;
+}
+
+.border-0 {
+  border-width: 0 !important;
+}
+
+.border-1 {
+  border-width: 1px !important;
+}
+
+.border-2 {
+  border-width: 2px !important;
+}
+
+.border-3 {
+  border-width: 3px !important;
+}
+
+.border-4 {
+  border-width: 4px !important;
+}
+
+.border-5 {
+  border-width: 5px !important;
+}
+
+.w-25 {
+  width: 25% !important;
+}
+
+.w-50 {
+  width: 50% !important;
+}
+
+.w-75 {
+  width: 75% !important;
+}
+
+.w-100 {
+  width: 100% !important;
+}
+
+.w-auto {
+  width: auto !important;
+}
+
+.mw-100 {
+  max-width: 100% !important;
+}
+
+.vw-100 {
+  width: 100vw !important;
+}
+
+.min-vw-100 {
+  min-width: 100vw !important;
+}
+
+.h-25 {
+  height: 25% !important;
+}
+
+.h-50 {
+  height: 50% !important;
+}
+
+.h-75 {
+  height: 75% !important;
+}
+
+.h-100 {
+  height: 100% !important;
+}
+
+.h-auto {
+  height: auto !important;
+}
+
+.mh-100 {
+  max-height: 100% !important;
+}
+
+.vh-100 {
+  height: 100vh !important;
+}
+
+.min-vh-100 {
+  min-height: 100vh !important;
+}
+
+.flex-fill {
+  flex: 1 1 auto !important;
+}
+
+.flex-row {
+  flex-direction: row !important;
+}
+
+.flex-column {
+  flex-direction: column !important;
+}
+
+.flex-row-reverse {
+  flex-direction: row-reverse !important;
+}
+
+.flex-column-reverse {
+  flex-direction: column-reverse !important;
+}
+
+.flex-grow-0 {
+  flex-grow: 0 !important;
+}
+
+.flex-grow-1 {
+  flex-grow: 1 !important;
+}
+
+.flex-shrink-0 {
+  flex-shrink: 0 !important;
+}
+
+.flex-shrink-1 {
+  flex-shrink: 1 !important;
+}
+
+.flex-wrap {
+  flex-wrap: wrap !important;
+}
+
+.flex-nowrap {
+  flex-wrap: nowrap !important;
+}
+
+.flex-wrap-reverse {
+  flex-wrap: wrap-reverse !important;
+}
+
+.gap-0 {
+  gap: 0 !important;
+}
+
+.gap-1 {
+  gap: 0.25rem !important;
+}
+
+.gap-2 {
+  gap: 0.5rem !important;
+}
+
+.gap-3 {
+  gap: 1rem !important;
+}
+
+.gap-4 {
+  gap: 1.5rem !important;
+}
+
+.gap-5 {
+  gap: 3rem !important;
+}
+
+.justify-content-start {
+  justify-content: flex-start !important;
+}
+
+.justify-content-end {
+  justify-content: flex-end !important;
+}
+
+.justify-content-center {
+  justify-content: center !important;
+}
+
+.justify-content-between {
+  justify-content: space-between !important;
+}
+
+.justify-content-around {
+  justify-content: space-around !important;
+}
+
+.justify-content-evenly {
+  justify-content: space-evenly !important;
+}
+
+.align-items-start {
+  align-items: flex-start !important;
+}
+
+.align-items-end {
+  align-items: flex-end !important;
+}
+
+.align-items-center {
+  align-items: center !important;
+}
+
+.align-items-baseline {
+  align-items: baseline !important;
+}
+
+.align-items-stretch {
+  align-items: stretch !important;
+}
+
+.align-content-start {
+  align-content: flex-start !important;
+}
+
+.align-content-end {
+  align-content: flex-end !important;
+}
+
+.align-content-center {
+  align-content: center !important;
+}
+
+.align-content-between {
+  align-content: space-between !important;
+}
+
+.align-content-around {
+  align-content: space-around !important;
+}
+
+.align-content-stretch {
+  align-content: stretch !important;
+}
+
+.align-self-auto {
+  align-self: auto !important;
+}
+
+.align-self-start {
+  align-self: flex-start !important;
+}
+
+.align-self-end {
+  align-self: flex-end !important;
+}
+
+.align-self-center {
+  align-self: center !important;
+}
+
+.align-self-baseline {
+  align-self: baseline !important;
+}
+
+.align-self-stretch {
+  align-self: stretch !important;
+}
+
+.order-first {
+  order: -1 !important;
+}
+
+.order-0 {
+  order: 0 !important;
+}
+
+.order-1 {
+  order: 1 !important;
+}
+
+.order-2 {
+  order: 2 !important;
+}
+
+.order-3 {
+  order: 3 !important;
+}
+
+.order-4 {
+  order: 4 !important;
+}
+
+.order-5 {
+  order: 5 !important;
+}
+
+.order-last {
+  order: 6 !important;
+}
+
+.m-0 {
+  margin: 0 !important;
+}
+
+.m-1 {
+  margin: 0.25rem !important;
+}
+
+.m-2 {
+  margin: 0.5rem !important;
+}
+
+.m-3 {
+  margin: 1rem !important;
+}
+
+.m-4 {
+  margin: 1.5rem !important;
+}
+
+.m-5 {
+  margin: 3rem !important;
+}
+
+.m-auto {
+  margin: auto !important;
+}
+
+.mx-0 {
+  margin-right: 0 !important;
+  margin-left: 0 !important;
+}
+
+.mx-1 {
+  margin-right: 0.25rem !important;
+  margin-left: 0.25rem !important;
+}
+
+.mx-2 {
+  margin-right: 0.5rem !important;
+  margin-left: 0.5rem !important;
+}
+
+.mx-3 {
+  margin-right: 1rem !important;
+  margin-left: 1rem !important;
+}
+
+.mx-4 {
+  margin-right: 1.5rem !important;
+  margin-left: 1.5rem !important;
+}
+
+.mx-5 {
+  margin-right: 3rem !important;
+  margin-left: 3rem !important;
+}
+
+.mx-auto {
+  margin-right: auto !important;
+  margin-left: auto !important;
+}
+
+.my-0 {
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+
+.my-1 {
+  margin-top: 0.25rem !important;
+  margin-bottom: 0.25rem !important;
+}
+
+.my-2 {
+  margin-top: 0.5rem !important;
+  margin-bottom: 0.5rem !important;
+}
+
+.my-3 {
+  margin-top: 1rem !important;
+  margin-bottom: 1rem !important;
+}
+
+.my-4 {
+  margin-top: 1.5rem !important;
+  margin-bottom: 1.5rem !important;
+}
+
+.my-5 {
+  margin-top: 3rem !important;
+  margin-bottom: 3rem !important;
+}
+
+.my-auto {
+  margin-top: auto !important;
+  margin-bottom: auto !important;
+}
+
+.mt-0 {
+  margin-top: 0 !important;
+}
+
+.mt-1 {
+  margin-top: 0.25rem !important;
+}
+
+.mt-2 {
+  margin-top: 0.5rem !important;
+}
+
+.mt-3 {
+  margin-top: 1rem !important;
+}
+
+.mt-4 {
+  margin-top: 1.5rem !important;
+}
+
+.mt-5 {
+  margin-top: 3rem !important;
+}
+
+.mt-auto {
+  margin-top: auto !important;
+}
+
+.me-0 {
+  margin-right: 0 !important;
+}
+
+.me-1 {
+  margin-right: 0.25rem !important;
+}
+
+.me-2 {
+  margin-right: 0.5rem !important;
+}
+
+.me-3 {
+  margin-right: 1rem !important;
+}
+
+.me-4 {
+  margin-right: 1.5rem !important;
+}
+
+.me-5 {
+  margin-right: 3rem !important;
+}
+
+.me-auto {
+  margin-right: auto !important;
+}
+
+.mb-0 {
+  margin-bottom: 0 !important;
+}
+
+.mb-1 {
+  margin-bottom: 0.25rem !important;
+}
+
+.mb-2 {
+  margin-bottom: 0.5rem !important;
+}
+
+.mb-3 {
+  margin-bottom: 1rem !important;
+}
+
+.mb-4 {
+  margin-bottom: 1.5rem !important;
+}
+
+.mb-5 {
+  margin-bottom: 3rem !important;
+}
+
+.mb-auto {
+  margin-bottom: auto !important;
+}
+
+.ms-0 {
+  margin-left: 0 !important;
+}
+
+.ms-1 {
+  margin-left: 0.25rem !important;
+}
+
+.ms-2 {
+  margin-left: 0.5rem !important;
+}
+
+.ms-3 {
+  margin-left: 1rem !important;
+}
+
+.ms-4 {
+  margin-left: 1.5rem !important;
+}
+
+.ms-5 {
+  margin-left: 3rem !important;
+}
+
+.ms-auto {
+  margin-left: auto !important;
+}
+
+.p-0 {
+  padding: 0 !important;
+}
+
+.p-1 {
+  padding: 0.25rem !important;
+}
+
+.p-2 {
+  padding: 0.5rem !important;
+}
+
+.p-3 {
+  padding: 1rem !important;
+}
+
+.p-4 {
+  padding: 1.5rem !important;
+}
+
+.p-5 {
+  padding: 3rem !important;
+}
+
+.px-0 {
+  padding-right: 0 !important;
+  padding-left: 0 !important;
+}
+
+.px-1 {
+  padding-right: 0.25rem !important;
+  padding-left: 0.25rem !important;
+}
+
+.px-2 {
+  padding-right: 0.5rem !important;
+  padding-left: 0.5rem !important;
+}
+
+.px-3 {
+  padding-right: 1rem !important;
+  padding-left: 1rem !important;
+}
+
+.px-4 {
+  padding-right: 1.5rem !important;
+  padding-left: 1.5rem !important;
+}
+
+.px-5 {
+  padding-right: 3rem !important;
+  padding-left: 3rem !important;
+}
+
+.py-0 {
+  padding-top: 0 !important;
+  padding-bottom: 0 !important;
+}
+
+.py-1 {
+  padding-top: 0.25rem !important;
+  padding-bottom: 0.25rem !important;
+}
+
+.py-2 {
+  padding-top: 0.5rem !important;
+  padding-bottom: 0.5rem !important;
+}
+
+.py-3 {
+  padding-top: 1rem !important;
+  padding-bottom: 1rem !important;
+}
+
+.py-4 {
+  padding-top: 1.5rem !important;
+  padding-bottom: 1.5rem !important;
+}
+
+.py-5 {
+  padding-top: 3rem !important;
+  padding-bottom: 3rem !important;
+}
+
+.pt-0 {
+  padding-top: 0 !important;
+}
+
+.pt-1 {
+  padding-top: 0.25rem !important;
+}
+
+.pt-2 {
+  padding-top: 0.5rem !important;
+}
+
+.pt-3 {
+  padding-top: 1rem !important;
+}
+
+.pt-4 {
+  padding-top: 1.5rem !important;
+}
+
+.pt-5 {
+  padding-top: 3rem !important;
+}
+
+.pe-0 {
+  padding-right: 0 !important;
+}
+
+.pe-1 {
+  padding-right: 0.25rem !important;
+}
+
+.pe-2 {
+  padding-right: 0.5rem !important;
+}
+
+.pe-3 {
+  padding-right: 1rem !important;
+}
+
+.pe-4 {
+  padding-right: 1.5rem !important;
+}
+
+.pe-5 {
+  padding-right: 3rem !important;
+}
+
+.pb-0 {
+  padding-bottom: 0 !important;
+}
+
+.pb-1 {
+  padding-bottom: 0.25rem !important;
+}
+
+.pb-2 {
+  padding-bottom: 0.5rem !important;
+}
+
+.pb-3 {
+  padding-bottom: 1rem !important;
+}
+
+.pb-4 {
+  padding-bottom: 1.5rem !important;
+}
+
+.pb-5 {
+  padding-bottom: 3rem !important;
+}
+
+.ps-0 {
+  padding-left: 0 !important;
+}
+
+.ps-1 {
+  padding-left: 0.25rem !important;
+}
+
+.ps-2 {
+  padding-left: 0.5rem !important;
+}
+
+.ps-3 {
+  padding-left: 1rem !important;
+}
+
+.ps-4 {
+  padding-left: 1.5rem !important;
+}
+
+.ps-5 {
+  padding-left: 3rem !important;
+}
+
+.fs-1 {
+  font-size: calc(1.375rem + 1.5vw) !important;
+}
+
+.fs-2 {
+  font-size: calc(1.325rem + 0.9vw) !important;
+}
+
+.fs-3 {
+  font-size: calc(1.3rem + 0.6vw) !important;
+}
+
+.fs-4 {
+  font-size: calc(1.275rem + 0.3vw) !important;
+}
+
+.fs-5 {
+  font-size: 1.25rem !important;
+}
+
+.fs-6 {
+  font-size: 1rem !important;
+}
+
+.fst-italic {
+  font-style: italic !important;
+}
+
+.fst-normal {
+  font-style: normal !important;
+}
+
+.fw-light {
+  font-weight: 300 !important;
+}
+
+.fw-lighter {
+  font-weight: lighter !important;
+}
+
+.fw-normal {
+  font-weight: 400 !important;
+}
+
+.fw-bold {
+  font-weight: 700 !important;
+}
+
+.fw-bolder {
+  font-weight: bolder !important;
+}
+
+.text-lowercase {
+  text-transform: lowercase !important;
+}
+
+.text-uppercase {
+  text-transform: uppercase !important;
+}
+
+.text-capitalize {
+  text-transform: capitalize !important;
+}
+
+.text-start {
+  text-align: left !important;
+}
+
+.text-end {
+  text-align: right !important;
+}
+
+.text-center {
+  text-align: center !important;
+}
+
+.text-primary {
+  color: #0d6efd !important;
+}
+
+.text-secondary {
+  color: #6c757d !important;
+}
+
+.text-success {
+  color: #198754 !important;
+}
+
+.text-info {
+  color: #0dcaf0 !important;
+}
+
+.text-warning {
+  color: #ffc107 !important;
+}
+
+.text-danger {
+  color: #dc3545 !important;
+}
+
+.text-light {
+  color: #f8f9fa !important;
+}
+
+.text-dark {
+  color: #212529 !important;
+}
+
+.text-white {
+  color: #fff !important;
+}
+
+.text-body {
+  color: #212529 !important;
+}
+
+.text-muted {
+  color: #6c757d !important;
+}
+
+.text-black-50 {
+  color: rgba(0, 0, 0, 0.5) !important;
+}
+
+.text-white-50 {
+  color: rgba(255, 255, 255, 0.5) !important;
+}
+
+.text-reset {
+  color: inherit !important;
+}
+
+.lh-1 {
+  line-height: 1 !important;
+}
+
+.lh-sm {
+  line-height: 1.25 !important;
+}
+
+.lh-base {
+  line-height: 1.5 !important;
+}
+
+.lh-lg {
+  line-height: 2 !important;
+}
+
+.bg-primary {
+  background-color: #0d6efd !important;
+}
+
+.bg-secondary {
+  background-color: #6c757d !important;
+}
+
+.bg-success {
+  background-color: #198754 !important;
+}
+
+.bg-info {
+  background-color: #0dcaf0 !important;
+}
+
+.bg-warning {
+  background-color: #ffc107 !important;
+}
+
+.bg-danger {
+  background-color: #dc3545 !important;
+}
+
+.bg-light {
+  background-color: #f8f9fa !important;
+}
+
+.bg-dark {
+  background-color: #212529 !important;
+}
+
+.bg-body {
+  background-color: #fff !important;
+}
+
+.bg-white {
+  background-color: #fff !important;
+}
+
+.bg-transparent {
+  background-color: transparent !important;
+}
+
+.bg-gradient {
+  background-image: var(--bs-gradient) !important;
+}
+
+.text-wrap {
+  white-space: normal !important;
+}
+
+.text-nowrap {
+  white-space: nowrap !important;
+}
+
+.text-decoration-none {
+  text-decoration: none !important;
+}
+
+.text-decoration-underline {
+  text-decoration: underline !important;
+}
+
+.text-decoration-line-through {
+  text-decoration: line-through !important;
+}
+
+/* rtl:begin:remove */
+.text-break {
+  word-wrap: break-word !important;
+  word-break: break-word !important;
+}
+
+/* rtl:end:remove */
+.font-monospace {
+  font-family: var(--bs-font-monospace) !important;
+}
+
+.user-select-all {
+  -webkit-user-select: all !important;
+  -moz-user-select: all !important;
+  user-select: all !important;
+}
+
+.user-select-auto {
+  -webkit-user-select: auto !important;
+  -moz-user-select: auto !important;
+  user-select: auto !important;
+}
+
+.user-select-none {
+  -webkit-user-select: none !important;
+  -moz-user-select: none !important;
+  user-select: none !important;
+}
+
+.pe-none {
+  pointer-events: none !important;
+}
+
+.pe-auto {
+  pointer-events: auto !important;
+}
+
+.rounded {
+  border-radius: 0.25rem !important;
+}
+
+.rounded-0 {
+  border-radius: 0 !important;
+}
+
+.rounded-1 {
+  border-radius: 0.2rem !important;
+}
+
+.rounded-2 {
+  border-radius: 0.25rem !important;
+}
+
+.rounded-3 {
+  border-radius: 0.3rem !important;
+}
+
+.rounded-circle {
+  border-radius: 50% !important;
+}
+
+.rounded-pill {
+  border-radius: 50rem !important;
+}
+
+.rounded-top {
+  border-top-left-radius: 0.25rem !important;
+  border-top-right-radius: 0.25rem !important;
+}
+
+.rounded-end {
+  border-top-right-radius: 0.25rem !important;
+  border-bottom-right-radius: 0.25rem !important;
+}
+
+.rounded-bottom {
+  border-bottom-right-radius: 0.25rem !important;
+  border-bottom-left-radius: 0.25rem !important;
+}
+
+.rounded-start {
+  border-bottom-left-radius: 0.25rem !important;
+  border-top-left-radius: 0.25rem !important;
+}
+
+.visible {
+  visibility: visible !important;
+}
+
+.invisible {
+  visibility: hidden !important;
+}
+
+@media (min-width: 576px) {
+  .float-sm-start {
+    float: left !important;
+  }
+
+  .float-sm-end {
+    float: right !important;
+  }
+
+  .float-sm-none {
+    float: none !important;
+  }
+
+  .d-sm-inline {
+    display: inline !important;
+  }
+
+  .d-sm-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-sm-block {
+    display: block !important;
+  }
+
+  .d-sm-grid {
+    display: grid !important;
+  }
+
+  .d-sm-table {
+    display: table !important;
+  }
+
+  .d-sm-table-row {
+    display: table-row !important;
+  }
+
+  .d-sm-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-sm-flex {
+    display: flex !important;
+  }
+
+  .d-sm-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-sm-none {
+    display: none !important;
+  }
+
+  .flex-sm-fill {
+    flex: 1 1 auto !important;
+  }
+
+  .flex-sm-row {
+    flex-direction: row !important;
+  }
+
+  .flex-sm-column {
+    flex-direction: column !important;
+  }
+
+  .flex-sm-row-reverse {
+    flex-direction: row-reverse !important;
+  }
+
+  .flex-sm-column-reverse {
+    flex-direction: column-reverse !important;
+  }
+
+  .flex-sm-grow-0 {
+    flex-grow: 0 !important;
+  }
+
+  .flex-sm-grow-1 {
+    flex-grow: 1 !important;
+  }
+
+  .flex-sm-shrink-0 {
+    flex-shrink: 0 !important;
+  }
+
+  .flex-sm-shrink-1 {
+    flex-shrink: 1 !important;
+  }
+
+  .flex-sm-wrap {
+    flex-wrap: wrap !important;
+  }
+
+  .flex-sm-nowrap {
+    flex-wrap: nowrap !important;
+  }
+
+  .flex-sm-wrap-reverse {
+    flex-wrap: wrap-reverse !important;
+  }
+
+  .gap-sm-0 {
+    gap: 0 !important;
+  }
+
+  .gap-sm-1 {
+    gap: 0.25rem !important;
+  }
+
+  .gap-sm-2 {
+    gap: 0.5rem !important;
+  }
+
+  .gap-sm-3 {
+    gap: 1rem !important;
+  }
+
+  .gap-sm-4 {
+    gap: 1.5rem !important;
+  }
+
+  .gap-sm-5 {
+    gap: 3rem !important;
+  }
+
+  .justify-content-sm-start {
+    justify-content: flex-start !important;
+  }
+
+  .justify-content-sm-end {
+    justify-content: flex-end !important;
+  }
+
+  .justify-content-sm-center {
+    justify-content: center !important;
+  }
+
+  .justify-content-sm-between {
+    justify-content: space-between !important;
+  }
+
+  .justify-content-sm-around {
+    justify-content: space-around !important;
+  }
+
+  .justify-content-sm-evenly {
+    justify-content: space-evenly !important;
+  }
+
+  .align-items-sm-start {
+    align-items: flex-start !important;
+  }
+
+  .align-items-sm-end {
+    align-items: flex-end !important;
+  }
+
+  .align-items-sm-center {
+    align-items: center !important;
+  }
+
+  .align-items-sm-baseline {
+    align-items: baseline !important;
+  }
+
+  .align-items-sm-stretch {
+    align-items: stretch !important;
+  }
+
+  .align-content-sm-start {
+    align-content: flex-start !important;
+  }
+
+  .align-content-sm-end {
+    align-content: flex-end !important;
+  }
+
+  .align-content-sm-center {
+    align-content: center !important;
+  }
+
+  .align-content-sm-between {
+    align-content: space-between !important;
+  }
+
+  .align-content-sm-around {
+    align-content: space-around !important;
+  }
+
+  .align-content-sm-stretch {
+    align-content: stretch !important;
+  }
+
+  .align-self-sm-auto {
+    align-self: auto !important;
+  }
+
+  .align-self-sm-start {
+    align-self: flex-start !important;
+  }
+
+  .align-self-sm-end {
+    align-self: flex-end !important;
+  }
+
+  .align-self-sm-center {
+    align-self: center !important;
+  }
+
+  .align-self-sm-baseline {
+    align-self: baseline !important;
+  }
+
+  .align-self-sm-stretch {
+    align-self: stretch !important;
+  }
+
+  .order-sm-first {
+    order: -1 !important;
+  }
+
+  .order-sm-0 {
+    order: 0 !important;
+  }
+
+  .order-sm-1 {
+    order: 1 !important;
+  }
+
+  .order-sm-2 {
+    order: 2 !important;
+  }
+
+  .order-sm-3 {
+    order: 3 !important;
+  }
+
+  .order-sm-4 {
+    order: 4 !important;
+  }
+
+  .order-sm-5 {
+    order: 5 !important;
+  }
+
+  .order-sm-last {
+    order: 6 !important;
+  }
+
+  .m-sm-0 {
+    margin: 0 !important;
+  }
+
+  .m-sm-1 {
+    margin: 0.25rem !important;
+  }
+
+  .m-sm-2 {
+    margin: 0.5rem !important;
+  }
+
+  .m-sm-3 {
+    margin: 1rem !important;
+  }
+
+  .m-sm-4 {
+    margin: 1.5rem !important;
+  }
+
+  .m-sm-5 {
+    margin: 3rem !important;
+  }
+
+  .m-sm-auto {
+    margin: auto !important;
+  }
+
+  .mx-sm-0 {
+    margin-right: 0 !important;
+    margin-left: 0 !important;
+  }
+
+  .mx-sm-1 {
+    margin-right: 0.25rem !important;
+    margin-left: 0.25rem !important;
+  }
+
+  .mx-sm-2 {
+    margin-right: 0.5rem !important;
+    margin-left: 0.5rem !important;
+  }
+
+  .mx-sm-3 {
+    margin-right: 1rem !important;
+    margin-left: 1rem !important;
+  }
+
+  .mx-sm-4 {
+    margin-right: 1.5rem !important;
+    margin-left: 1.5rem !important;
+  }
+
+  .mx-sm-5 {
+    margin-right: 3rem !important;
+    margin-left: 3rem !important;
+  }
+
+  .mx-sm-auto {
+    margin-right: auto !important;
+    margin-left: auto !important;
+  }
+
+  .my-sm-0 {
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+  }
+
+  .my-sm-1 {
+    margin-top: 0.25rem !important;
+    margin-bottom: 0.25rem !important;
+  }
+
+  .my-sm-2 {
+    margin-top: 0.5rem !important;
+    margin-bottom: 0.5rem !important;
+  }
+
+  .my-sm-3 {
+    margin-top: 1rem !important;
+    margin-bottom: 1rem !important;
+  }
+
+  .my-sm-4 {
+    margin-top: 1.5rem !important;
+    margin-bottom: 1.5rem !important;
+  }
+
+  .my-sm-5 {
+    margin-top: 3rem !important;
+    margin-bottom: 3rem !important;
+  }
+
+  .my-sm-auto {
+    margin-top: auto !important;
+    margin-bottom: auto !important;
+  }
+
+  .mt-sm-0 {
+    margin-top: 0 !important;
+  }
+
+  .mt-sm-1 {
+    margin-top: 0.25rem !important;
+  }
+
+  .mt-sm-2 {
+    margin-top: 0.5rem !important;
+  }
+
+  .mt-sm-3 {
+    margin-top: 1rem !important;
+  }
+
+  .mt-sm-4 {
+    margin-top: 1.5rem !important;
+  }
+
+  .mt-sm-5 {
+    margin-top: 3rem !important;
+  }
+
+  .mt-sm-auto {
+    margin-top: auto !important;
+  }
+
+  .me-sm-0 {
+    margin-right: 0 !important;
+  }
+
+  .me-sm-1 {
+    margin-right: 0.25rem !important;
+  }
+
+  .me-sm-2 {
+    margin-right: 0.5rem !important;
+  }
+
+  .me-sm-3 {
+    margin-right: 1rem !important;
+  }
+
+  .me-sm-4 {
+    margin-right: 1.5rem !important;
+  }
+
+  .me-sm-5 {
+    margin-right: 3rem !important;
+  }
+
+  .me-sm-auto {
+    margin-right: auto !important;
+  }
+
+  .mb-sm-0 {
+    margin-bottom: 0 !important;
+  }
+
+  .mb-sm-1 {
+    margin-bottom: 0.25rem !important;
+  }
+
+  .mb-sm-2 {
+    margin-bottom: 0.5rem !important;
+  }
+
+  .mb-sm-3 {
+    margin-bottom: 1rem !important;
+  }
+
+  .mb-sm-4 {
+    margin-bottom: 1.5rem !important;
+  }
+
+  .mb-sm-5 {
+    margin-bottom: 3rem !important;
+  }
+
+  .mb-sm-auto {
+    margin-bottom: auto !important;
+  }
+
+  .ms-sm-0 {
+    margin-left: 0 !important;
+  }
+
+  .ms-sm-1 {
+    margin-left: 0.25rem !important;
+  }
+
+  .ms-sm-2 {
+    margin-left: 0.5rem !important;
+  }
+
+  .ms-sm-3 {
+    margin-left: 1rem !important;
+  }
+
+  .ms-sm-4 {
+    margin-left: 1.5rem !important;
+  }
+
+  .ms-sm-5 {
+    margin-left: 3rem !important;
+  }
+
+  .ms-sm-auto {
+    margin-left: auto !important;
+  }
+
+  .p-sm-0 {
+    padding: 0 !important;
+  }
+
+  .p-sm-1 {
+    padding: 0.25rem !important;
+  }
+
+  .p-sm-2 {
+    padding: 0.5rem !important;
+  }
+
+  .p-sm-3 {
+    padding: 1rem !important;
+  }
+
+  .p-sm-4 {
+    padding: 1.5rem !important;
+  }
+
+  .p-sm-5 {
+    padding: 3rem !important;
+  }
+
+  .px-sm-0 {
+    padding-right: 0 !important;
+    padding-left: 0 !important;
+  }
+
+  .px-sm-1 {
+    padding-right: 0.25rem !important;
+    padding-left: 0.25rem !important;
+  }
+
+  .px-sm-2 {
+    padding-right: 0.5rem !important;
+    padding-left: 0.5rem !important;
+  }
+
+  .px-sm-3 {
+    padding-right: 1rem !important;
+    padding-left: 1rem !important;
+  }
+
+  .px-sm-4 {
+    padding-right: 1.5rem !important;
+    padding-left: 1.5rem !important;
+  }
+
+  .px-sm-5 {
+    padding-right: 3rem !important;
+    padding-left: 3rem !important;
+  }
+
+  .py-sm-0 {
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+  }
+
+  .py-sm-1 {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+  }
+
+  .py-sm-2 {
+    padding-top: 0.5rem !important;
+    padding-bottom: 0.5rem !important;
+  }
+
+  .py-sm-3 {
+    padding-top: 1rem !important;
+    padding-bottom: 1rem !important;
+  }
+
+  .py-sm-4 {
+    padding-top: 1.5rem !important;
+    padding-bottom: 1.5rem !important;
+  }
+
+  .py-sm-5 {
+    padding-top: 3rem !important;
+    padding-bottom: 3rem !important;
+  }
+
+  .pt-sm-0 {
+    padding-top: 0 !important;
+  }
+
+  .pt-sm-1 {
+    padding-top: 0.25rem !important;
+  }
+
+  .pt-sm-2 {
+    padding-top: 0.5rem !important;
+  }
+
+  .pt-sm-3 {
+    padding-top: 1rem !important;
+  }
+
+  .pt-sm-4 {
+    padding-top: 1.5rem !important;
+  }
+
+  .pt-sm-5 {
+    padding-top: 3rem !important;
+  }
+
+  .pe-sm-0 {
+    padding-right: 0 !important;
+  }
+
+  .pe-sm-1 {
+    padding-right: 0.25rem !important;
+  }
+
+  .pe-sm-2 {
+    padding-right: 0.5rem !important;
+  }
+
+  .pe-sm-3 {
+    padding-right: 1rem !important;
+  }
+
+  .pe-sm-4 {
+    padding-right: 1.5rem !important;
+  }
+
+  .pe-sm-5 {
+    padding-right: 3rem !important;
+  }
+
+  .pb-sm-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .pb-sm-1 {
+    padding-bottom: 0.25rem !important;
+  }
+
+  .pb-sm-2 {
+    padding-bottom: 0.5rem !important;
+  }
+
+  .pb-sm-3 {
+    padding-bottom: 1rem !important;
+  }
+
+  .pb-sm-4 {
+    padding-bottom: 1.5rem !important;
+  }
+
+  .pb-sm-5 {
+    padding-bottom: 3rem !important;
+  }
+
+  .ps-sm-0 {
+    padding-left: 0 !important;
+  }
+
+  .ps-sm-1 {
+    padding-left: 0.25rem !important;
+  }
+
+  .ps-sm-2 {
+    padding-left: 0.5rem !important;
+  }
+
+  .ps-sm-3 {
+    padding-left: 1rem !important;
+  }
+
+  .ps-sm-4 {
+    padding-left: 1.5rem !important;
+  }
+
+  .ps-sm-5 {
+    padding-left: 3rem !important;
+  }
+
+  .text-sm-start {
+    text-align: left !important;
+  }
+
+  .text-sm-end {
+    text-align: right !important;
+  }
+
+  .text-sm-center {
+    text-align: center !important;
+  }
+}
+@media (min-width: 768px) {
+  .float-md-start {
+    float: left !important;
+  }
+
+  .float-md-end {
+    float: right !important;
+  }
+
+  .float-md-none {
+    float: none !important;
+  }
+
+  .d-md-inline {
+    display: inline !important;
+  }
+
+  .d-md-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-md-block {
+    display: block !important;
+  }
+
+  .d-md-grid {
+    display: grid !important;
+  }
+
+  .d-md-table {
+    display: table !important;
+  }
+
+  .d-md-table-row {
+    display: table-row !important;
+  }
+
+  .d-md-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-md-flex {
+    display: flex !important;
+  }
+
+  .d-md-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-md-none {
+    display: none !important;
+  }
+
+  .flex-md-fill {
+    flex: 1 1 auto !important;
+  }
+
+  .flex-md-row {
+    flex-direction: row !important;
+  }
+
+  .flex-md-column {
+    flex-direction: column !important;
+  }
+
+  .flex-md-row-reverse {
+    flex-direction: row-reverse !important;
+  }
+
+  .flex-md-column-reverse {
+    flex-direction: column-reverse !important;
+  }
+
+  .flex-md-grow-0 {
+    flex-grow: 0 !important;
+  }
+
+  .flex-md-grow-1 {
+    flex-grow: 1 !important;
+  }
+
+  .flex-md-shrink-0 {
+    flex-shrink: 0 !important;
+  }
+
+  .flex-md-shrink-1 {
+    flex-shrink: 1 !important;
+  }
+
+  .flex-md-wrap {
+    flex-wrap: wrap !important;
+  }
+
+  .flex-md-nowrap {
+    flex-wrap: nowrap !important;
+  }
+
+  .flex-md-wrap-reverse {
+    flex-wrap: wrap-reverse !important;
+  }
+
+  .gap-md-0 {
+    gap: 0 !important;
+  }
+
+  .gap-md-1 {
+    gap: 0.25rem !important;
+  }
+
+  .gap-md-2 {
+    gap: 0.5rem !important;
+  }
+
+  .gap-md-3 {
+    gap: 1rem !important;
+  }
+
+  .gap-md-4 {
+    gap: 1.5rem !important;
+  }
+
+  .gap-md-5 {
+    gap: 3rem !important;
+  }
+
+  .justify-content-md-start {
+    justify-content: flex-start !important;
+  }
+
+  .justify-content-md-end {
+    justify-content: flex-end !important;
+  }
+
+  .justify-content-md-center {
+    justify-content: center !important;
+  }
+
+  .justify-content-md-between {
+    justify-content: space-between !important;
+  }
+
+  .justify-content-md-around {
+    justify-content: space-around !important;
+  }
+
+  .justify-content-md-evenly {
+    justify-content: space-evenly !important;
+  }
+
+  .align-items-md-start {
+    align-items: flex-start !important;
+  }
+
+  .align-items-md-end {
+    align-items: flex-end !important;
+  }
+
+  .align-items-md-center {
+    align-items: center !important;
+  }
+
+  .align-items-md-baseline {
+    align-items: baseline !important;
+  }
+
+  .align-items-md-stretch {
+    align-items: stretch !important;
+  }
+
+  .align-content-md-start {
+    align-content: flex-start !important;
+  }
+
+  .align-content-md-end {
+    align-content: flex-end !important;
+  }
+
+  .align-content-md-center {
+    align-content: center !important;
+  }
+
+  .align-content-md-between {
+    align-content: space-between !important;
+  }
+
+  .align-content-md-around {
+    align-content: space-around !important;
+  }
+
+  .align-content-md-stretch {
+    align-content: stretch !important;
+  }
+
+  .align-self-md-auto {
+    align-self: auto !important;
+  }
+
+  .align-self-md-start {
+    align-self: flex-start !important;
+  }
+
+  .align-self-md-end {
+    align-self: flex-end !important;
+  }
+
+  .align-self-md-center {
+    align-self: center !important;
+  }
+
+  .align-self-md-baseline {
+    align-self: baseline !important;
+  }
+
+  .align-self-md-stretch {
+    align-self: stretch !important;
+  }
+
+  .order-md-first {
+    order: -1 !important;
+  }
+
+  .order-md-0 {
+    order: 0 !important;
+  }
+
+  .order-md-1 {
+    order: 1 !important;
+  }
+
+  .order-md-2 {
+    order: 2 !important;
+  }
+
+  .order-md-3 {
+    order: 3 !important;
+  }
+
+  .order-md-4 {
+    order: 4 !important;
+  }
+
+  .order-md-5 {
+    order: 5 !important;
+  }
+
+  .order-md-last {
+    order: 6 !important;
+  }
+
+  .m-md-0 {
+    margin: 0 !important;
+  }
+
+  .m-md-1 {
+    margin: 0.25rem !important;
+  }
+
+  .m-md-2 {
+    margin: 0.5rem !important;
+  }
+
+  .m-md-3 {
+    margin: 1rem !important;
+  }
+
+  .m-md-4 {
+    margin: 1.5rem !important;
+  }
+
+  .m-md-5 {
+    margin: 3rem !important;
+  }
+
+  .m-md-auto {
+    margin: auto !important;
+  }
+
+  .mx-md-0 {
+    margin-right: 0 !important;
+    margin-left: 0 !important;
+  }
+
+  .mx-md-1 {
+    margin-right: 0.25rem !important;
+    margin-left: 0.25rem !important;
+  }
+
+  .mx-md-2 {
+    margin-right: 0.5rem !important;
+    margin-left: 0.5rem !important;
+  }
+
+  .mx-md-3 {
+    margin-right: 1rem !important;
+    margin-left: 1rem !important;
+  }
+
+  .mx-md-4 {
+    margin-right: 1.5rem !important;
+    margin-left: 1.5rem !important;
+  }
+
+  .mx-md-5 {
+    margin-right: 3rem !important;
+    margin-left: 3rem !important;
+  }
+
+  .mx-md-auto {
+    margin-right: auto !important;
+    margin-left: auto !important;
+  }
+
+  .my-md-0 {
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+  }
+
+  .my-md-1 {
+    margin-top: 0.25rem !important;
+    margin-bottom: 0.25rem !important;
+  }
+
+  .my-md-2 {
+    margin-top: 0.5rem !important;
+    margin-bottom: 0.5rem !important;
+  }
+
+  .my-md-3 {
+    margin-top: 1rem !important;
+    margin-bottom: 1rem !important;
+  }
+
+  .my-md-4 {
+    margin-top: 1.5rem !important;
+    margin-bottom: 1.5rem !important;
+  }
+
+  .my-md-5 {
+    margin-top: 3rem !important;
+    margin-bottom: 3rem !important;
+  }
+
+  .my-md-auto {
+    margin-top: auto !important;
+    margin-bottom: auto !important;
+  }
+
+  .mt-md-0 {
+    margin-top: 0 !important;
+  }
+
+  .mt-md-1 {
+    margin-top: 0.25rem !important;
+  }
+
+  .mt-md-2 {
+    margin-top: 0.5rem !important;
+  }
+
+  .mt-md-3 {
+    margin-top: 1rem !important;
+  }
+
+  .mt-md-4 {
+    margin-top: 1.5rem !important;
+  }
+
+  .mt-md-5 {
+    margin-top: 3rem !important;
+  }
+
+  .mt-md-auto {
+    margin-top: auto !important;
+  }
+
+  .me-md-0 {
+    margin-right: 0 !important;
+  }
+
+  .me-md-1 {
+    margin-right: 0.25rem !important;
+  }
+
+  .me-md-2 {
+    margin-right: 0.5rem !important;
+  }
+
+  .me-md-3 {
+    margin-right: 1rem !important;
+  }
+
+  .me-md-4 {
+    margin-right: 1.5rem !important;
+  }
+
+  .me-md-5 {
+    margin-right: 3rem !important;
+  }
+
+  .me-md-auto {
+    margin-right: auto !important;
+  }
+
+  .mb-md-0 {
+    margin-bottom: 0 !important;
+  }
+
+  .mb-md-1 {
+    margin-bottom: 0.25rem !important;
+  }
+
+  .mb-md-2 {
+    margin-bottom: 0.5rem !important;
+  }
+
+  .mb-md-3 {
+    margin-bottom: 1rem !important;
+  }
+
+  .mb-md-4 {
+    margin-bottom: 1.5rem !important;
+  }
+
+  .mb-md-5 {
+    margin-bottom: 3rem !important;
+  }
+
+  .mb-md-auto {
+    margin-bottom: auto !important;
+  }
+
+  .ms-md-0 {
+    margin-left: 0 !important;
+  }
+
+  .ms-md-1 {
+    margin-left: 0.25rem !important;
+  }
+
+  .ms-md-2 {
+    margin-left: 0.5rem !important;
+  }
+
+  .ms-md-3 {
+    margin-left: 1rem !important;
+  }
+
+  .ms-md-4 {
+    margin-left: 1.5rem !important;
+  }
+
+  .ms-md-5 {
+    margin-left: 3rem !important;
+  }
+
+  .ms-md-auto {
+    margin-left: auto !important;
+  }
+
+  .p-md-0 {
+    padding: 0 !important;
+  }
+
+  .p-md-1 {
+    padding: 0.25rem !important;
+  }
+
+  .p-md-2 {
+    padding: 0.5rem !important;
+  }
+
+  .p-md-3 {
+    padding: 1rem !important;
+  }
+
+  .p-md-4 {
+    padding: 1.5rem !important;
+  }
+
+  .p-md-5 {
+    padding: 3rem !important;
+  }
+
+  .px-md-0 {
+    padding-right: 0 !important;
+    padding-left: 0 !important;
+  }
+
+  .px-md-1 {
+    padding-right: 0.25rem !important;
+    padding-left: 0.25rem !important;
+  }
+
+  .px-md-2 {
+    padding-right: 0.5rem !important;
+    padding-left: 0.5rem !important;
+  }
+
+  .px-md-3 {
+    padding-right: 1rem !important;
+    padding-left: 1rem !important;
+  }
+
+  .px-md-4 {
+    padding-right: 1.5rem !important;
+    padding-left: 1.5rem !important;
+  }
+
+  .px-md-5 {
+    padding-right: 3rem !important;
+    padding-left: 3rem !important;
+  }
+
+  .py-md-0 {
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+  }
+
+  .py-md-1 {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+  }
+
+  .py-md-2 {
+    padding-top: 0.5rem !important;
+    padding-bottom: 0.5rem !important;
+  }
+
+  .py-md-3 {
+    padding-top: 1rem !important;
+    padding-bottom: 1rem !important;
+  }
+
+  .py-md-4 {
+    padding-top: 1.5rem !important;
+    padding-bottom: 1.5rem !important;
+  }
+
+  .py-md-5 {
+    padding-top: 3rem !important;
+    padding-bottom: 3rem !important;
+  }
+
+  .pt-md-0 {
+    padding-top: 0 !important;
+  }
+
+  .pt-md-1 {
+    padding-top: 0.25rem !important;
+  }
+
+  .pt-md-2 {
+    padding-top: 0.5rem !important;
+  }
+
+  .pt-md-3 {
+    padding-top: 1rem !important;
+  }
+
+  .pt-md-4 {
+    padding-top: 1.5rem !important;
+  }
+
+  .pt-md-5 {
+    padding-top: 3rem !important;
+  }
+
+  .pe-md-0 {
+    padding-right: 0 !important;
+  }
+
+  .pe-md-1 {
+    padding-right: 0.25rem !important;
+  }
+
+  .pe-md-2 {
+    padding-right: 0.5rem !important;
+  }
+
+  .pe-md-3 {
+    padding-right: 1rem !important;
+  }
+
+  .pe-md-4 {
+    padding-right: 1.5rem !important;
+  }
+
+  .pe-md-5 {
+    padding-right: 3rem !important;
+  }
+
+  .pb-md-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .pb-md-1 {
+    padding-bottom: 0.25rem !important;
+  }
+
+  .pb-md-2 {
+    padding-bottom: 0.5rem !important;
+  }
+
+  .pb-md-3 {
+    padding-bottom: 1rem !important;
+  }
+
+  .pb-md-4 {
+    padding-bottom: 1.5rem !important;
+  }
+
+  .pb-md-5 {
+    padding-bottom: 3rem !important;
+  }
+
+  .ps-md-0 {
+    padding-left: 0 !important;
+  }
+
+  .ps-md-1 {
+    padding-left: 0.25rem !important;
+  }
+
+  .ps-md-2 {
+    padding-left: 0.5rem !important;
+  }
+
+  .ps-md-3 {
+    padding-left: 1rem !important;
+  }
+
+  .ps-md-4 {
+    padding-left: 1.5rem !important;
+  }
+
+  .ps-md-5 {
+    padding-left: 3rem !important;
+  }
+
+  .text-md-start {
+    text-align: left !important;
+  }
+
+  .text-md-end {
+    text-align: right !important;
+  }
+
+  .text-md-center {
+    text-align: center !important;
+  }
+}
+@media (min-width: 992px) {
+  .float-lg-start {
+    float: left !important;
+  }
+
+  .float-lg-end {
+    float: right !important;
+  }
+
+  .float-lg-none {
+    float: none !important;
+  }
+
+  .d-lg-inline {
+    display: inline !important;
+  }
+
+  .d-lg-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-lg-block {
+    display: block !important;
+  }
+
+  .d-lg-grid {
+    display: grid !important;
+  }
+
+  .d-lg-table {
+    display: table !important;
+  }
+
+  .d-lg-table-row {
+    display: table-row !important;
+  }
+
+  .d-lg-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-lg-flex {
+    display: flex !important;
+  }
+
+  .d-lg-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-lg-none {
+    display: none !important;
+  }
+
+  .flex-lg-fill {
+    flex: 1 1 auto !important;
+  }
+
+  .flex-lg-row {
+    flex-direction: row !important;
+  }
+
+  .flex-lg-column {
+    flex-direction: column !important;
+  }
+
+  .flex-lg-row-reverse {
+    flex-direction: row-reverse !important;
+  }
+
+  .flex-lg-column-reverse {
+    flex-direction: column-reverse !important;
+  }
+
+  .flex-lg-grow-0 {
+    flex-grow: 0 !important;
+  }
+
+  .flex-lg-grow-1 {
+    flex-grow: 1 !important;
+  }
+
+  .flex-lg-shrink-0 {
+    flex-shrink: 0 !important;
+  }
+
+  .flex-lg-shrink-1 {
+    flex-shrink: 1 !important;
+  }
+
+  .flex-lg-wrap {
+    flex-wrap: wrap !important;
+  }
+
+  .flex-lg-nowrap {
+    flex-wrap: nowrap !important;
+  }
+
+  .flex-lg-wrap-reverse {
+    flex-wrap: wrap-reverse !important;
+  }
+
+  .gap-lg-0 {
+    gap: 0 !important;
+  }
+
+  .gap-lg-1 {
+    gap: 0.25rem !important;
+  }
+
+  .gap-lg-2 {
+    gap: 0.5rem !important;
+  }
+
+  .gap-lg-3 {
+    gap: 1rem !important;
+  }
+
+  .gap-lg-4 {
+    gap: 1.5rem !important;
+  }
+
+  .gap-lg-5 {
+    gap: 3rem !important;
+  }
+
+  .justify-content-lg-start {
+    justify-content: flex-start !important;
+  }
+
+  .justify-content-lg-end {
+    justify-content: flex-end !important;
+  }
+
+  .justify-content-lg-center {
+    justify-content: center !important;
+  }
+
+  .justify-content-lg-between {
+    justify-content: space-between !important;
+  }
+
+  .justify-content-lg-around {
+    justify-content: space-around !important;
+  }
+
+  .justify-content-lg-evenly {
+    justify-content: space-evenly !important;
+  }
+
+  .align-items-lg-start {
+    align-items: flex-start !important;
+  }
+
+  .align-items-lg-end {
+    align-items: flex-end !important;
+  }
+
+  .align-items-lg-center {
+    align-items: center !important;
+  }
+
+  .align-items-lg-baseline {
+    align-items: baseline !important;
+  }
+
+  .align-items-lg-stretch {
+    align-items: stretch !important;
+  }
+
+  .align-content-lg-start {
+    align-content: flex-start !important;
+  }
+
+  .align-content-lg-end {
+    align-content: flex-end !important;
+  }
+
+  .align-content-lg-center {
+    align-content: center !important;
+  }
+
+  .align-content-lg-between {
+    align-content: space-between !important;
+  }
+
+  .align-content-lg-around {
+    align-content: space-around !important;
+  }
+
+  .align-content-lg-stretch {
+    align-content: stretch !important;
+  }
+
+  .align-self-lg-auto {
+    align-self: auto !important;
+  }
+
+  .align-self-lg-start {
+    align-self: flex-start !important;
+  }
+
+  .align-self-lg-end {
+    align-self: flex-end !important;
+  }
+
+  .align-self-lg-center {
+    align-self: center !important;
+  }
+
+  .align-self-lg-baseline {
+    align-self: baseline !important;
+  }
+
+  .align-self-lg-stretch {
+    align-self: stretch !important;
+  }
+
+  .order-lg-first {
+    order: -1 !important;
+  }
+
+  .order-lg-0 {
+    order: 0 !important;
+  }
+
+  .order-lg-1 {
+    order: 1 !important;
+  }
+
+  .order-lg-2 {
+    order: 2 !important;
+  }
+
+  .order-lg-3 {
+    order: 3 !important;
+  }
+
+  .order-lg-4 {
+    order: 4 !important;
+  }
+
+  .order-lg-5 {
+    order: 5 !important;
+  }
+
+  .order-lg-last {
+    order: 6 !important;
+  }
+
+  .m-lg-0 {
+    margin: 0 !important;
+  }
+
+  .m-lg-1 {
+    margin: 0.25rem !important;
+  }
+
+  .m-lg-2 {
+    margin: 0.5rem !important;
+  }
+
+  .m-lg-3 {
+    margin: 1rem !important;
+  }
+
+  .m-lg-4 {
+    margin: 1.5rem !important;
+  }
+
+  .m-lg-5 {
+    margin: 3rem !important;
+  }
+
+  .m-lg-auto {
+    margin: auto !important;
+  }
+
+  .mx-lg-0 {
+    margin-right: 0 !important;
+    margin-left: 0 !important;
+  }
+
+  .mx-lg-1 {
+    margin-right: 0.25rem !important;
+    margin-left: 0.25rem !important;
+  }
+
+  .mx-lg-2 {
+    margin-right: 0.5rem !important;
+    margin-left: 0.5rem !important;
+  }
+
+  .mx-lg-3 {
+    margin-right: 1rem !important;
+    margin-left: 1rem !important;
+  }
+
+  .mx-lg-4 {
+    margin-right: 1.5rem !important;
+    margin-left: 1.5rem !important;
+  }
+
+  .mx-lg-5 {
+    margin-right: 3rem !important;
+    margin-left: 3rem !important;
+  }
+
+  .mx-lg-auto {
+    margin-right: auto !important;
+    margin-left: auto !important;
+  }
+
+  .my-lg-0 {
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+  }
+
+  .my-lg-1 {
+    margin-top: 0.25rem !important;
+    margin-bottom: 0.25rem !important;
+  }
+
+  .my-lg-2 {
+    margin-top: 0.5rem !important;
+    margin-bottom: 0.5rem !important;
+  }
+
+  .my-lg-3 {
+    margin-top: 1rem !important;
+    margin-bottom: 1rem !important;
+  }
+
+  .my-lg-4 {
+    margin-top: 1.5rem !important;
+    margin-bottom: 1.5rem !important;
+  }
+
+  .my-lg-5 {
+    margin-top: 3rem !important;
+    margin-bottom: 3rem !important;
+  }
+
+  .my-lg-auto {
+    margin-top: auto !important;
+    margin-bottom: auto !important;
+  }
+
+  .mt-lg-0 {
+    margin-top: 0 !important;
+  }
+
+  .mt-lg-1 {
+    margin-top: 0.25rem !important;
+  }
+
+  .mt-lg-2 {
+    margin-top: 0.5rem !important;
+  }
+
+  .mt-lg-3 {
+    margin-top: 1rem !important;
+  }
+
+  .mt-lg-4 {
+    margin-top: 1.5rem !important;
+  }
+
+  .mt-lg-5 {
+    margin-top: 3rem !important;
+  }
+
+  .mt-lg-auto {
+    margin-top: auto !important;
+  }
+
+  .me-lg-0 {
+    margin-right: 0 !important;
+  }
+
+  .me-lg-1 {
+    margin-right: 0.25rem !important;
+  }
+
+  .me-lg-2 {
+    margin-right: 0.5rem !important;
+  }
+
+  .me-lg-3 {
+    margin-right: 1rem !important;
+  }
+
+  .me-lg-4 {
+    margin-right: 1.5rem !important;
+  }
+
+  .me-lg-5 {
+    margin-right: 3rem !important;
+  }
+
+  .me-lg-auto {
+    margin-right: auto !important;
+  }
+
+  .mb-lg-0 {
+    margin-bottom: 0 !important;
+  }
+
+  .mb-lg-1 {
+    margin-bottom: 0.25rem !important;
+  }
+
+  .mb-lg-2 {
+    margin-bottom: 0.5rem !important;
+  }
+
+  .mb-lg-3 {
+    margin-bottom: 1rem !important;
+  }
+
+  .mb-lg-4 {
+    margin-bottom: 1.5rem !important;
+  }
+
+  .mb-lg-5 {
+    margin-bottom: 3rem !important;
+  }
+
+  .mb-lg-auto {
+    margin-bottom: auto !important;
+  }
+
+  .ms-lg-0 {
+    margin-left: 0 !important;
+  }
+
+  .ms-lg-1 {
+    margin-left: 0.25rem !important;
+  }
+
+  .ms-lg-2 {
+    margin-left: 0.5rem !important;
+  }
+
+  .ms-lg-3 {
+    margin-left: 1rem !important;
+  }
+
+  .ms-lg-4 {
+    margin-left: 1.5rem !important;
+  }
+
+  .ms-lg-5 {
+    margin-left: 3rem !important;
+  }
+
+  .ms-lg-auto {
+    margin-left: auto !important;
+  }
+
+  .p-lg-0 {
+    padding: 0 !important;
+  }
+
+  .p-lg-1 {
+    padding: 0.25rem !important;
+  }
+
+  .p-lg-2 {
+    padding: 0.5rem !important;
+  }
+
+  .p-lg-3 {
+    padding: 1rem !important;
+  }
+
+  .p-lg-4 {
+    padding: 1.5rem !important;
+  }
+
+  .p-lg-5 {
+    padding: 3rem !important;
+  }
+
+  .px-lg-0 {
+    padding-right: 0 !important;
+    padding-left: 0 !important;
+  }
+
+  .px-lg-1 {
+    padding-right: 0.25rem !important;
+    padding-left: 0.25rem !important;
+  }
+
+  .px-lg-2 {
+    padding-right: 0.5rem !important;
+    padding-left: 0.5rem !important;
+  }
+
+  .px-lg-3 {
+    padding-right: 1rem !important;
+    padding-left: 1rem !important;
+  }
+
+  .px-lg-4 {
+    padding-right: 1.5rem !important;
+    padding-left: 1.5rem !important;
+  }
+
+  .px-lg-5 {
+    padding-right: 3rem !important;
+    padding-left: 3rem !important;
+  }
+
+  .py-lg-0 {
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+  }
+
+  .py-lg-1 {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+  }
+
+  .py-lg-2 {
+    padding-top: 0.5rem !important;
+    padding-bottom: 0.5rem !important;
+  }
+
+  .py-lg-3 {
+    padding-top: 1rem !important;
+    padding-bottom: 1rem !important;
+  }
+
+  .py-lg-4 {
+    padding-top: 1.5rem !important;
+    padding-bottom: 1.5rem !important;
+  }
+
+  .py-lg-5 {
+    padding-top: 3rem !important;
+    padding-bottom: 3rem !important;
+  }
+
+  .pt-lg-0 {
+    padding-top: 0 !important;
+  }
+
+  .pt-lg-1 {
+    padding-top: 0.25rem !important;
+  }
+
+  .pt-lg-2 {
+    padding-top: 0.5rem !important;
+  }
+
+  .pt-lg-3 {
+    padding-top: 1rem !important;
+  }
+
+  .pt-lg-4 {
+    padding-top: 1.5rem !important;
+  }
+
+  .pt-lg-5 {
+    padding-top: 3rem !important;
+  }
+
+  .pe-lg-0 {
+    padding-right: 0 !important;
+  }
+
+  .pe-lg-1 {
+    padding-right: 0.25rem !important;
+  }
+
+  .pe-lg-2 {
+    padding-right: 0.5rem !important;
+  }
+
+  .pe-lg-3 {
+    padding-right: 1rem !important;
+  }
+
+  .pe-lg-4 {
+    padding-right: 1.5rem !important;
+  }
+
+  .pe-lg-5 {
+    padding-right: 3rem !important;
+  }
+
+  .pb-lg-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .pb-lg-1 {
+    padding-bottom: 0.25rem !important;
+  }
+
+  .pb-lg-2 {
+    padding-bottom: 0.5rem !important;
+  }
+
+  .pb-lg-3 {
+    padding-bottom: 1rem !important;
+  }
+
+  .pb-lg-4 {
+    padding-bottom: 1.5rem !important;
+  }
+
+  .pb-lg-5 {
+    padding-bottom: 3rem !important;
+  }
+
+  .ps-lg-0 {
+    padding-left: 0 !important;
+  }
+
+  .ps-lg-1 {
+    padding-left: 0.25rem !important;
+  }
+
+  .ps-lg-2 {
+    padding-left: 0.5rem !important;
+  }
+
+  .ps-lg-3 {
+    padding-left: 1rem !important;
+  }
+
+  .ps-lg-4 {
+    padding-left: 1.5rem !important;
+  }
+
+  .ps-lg-5 {
+    padding-left: 3rem !important;
+  }
+
+  .text-lg-start {
+    text-align: left !important;
+  }
+
+  .text-lg-end {
+    text-align: right !important;
+  }
+
+  .text-lg-center {
+    text-align: center !important;
+  }
+}
+@media (min-width: 1200px) {
+  .float-xl-start {
+    float: left !important;
+  }
+
+  .float-xl-end {
+    float: right !important;
+  }
+
+  .float-xl-none {
+    float: none !important;
+  }
+
+  .d-xl-inline {
+    display: inline !important;
+  }
+
+  .d-xl-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-xl-block {
+    display: block !important;
+  }
+
+  .d-xl-grid {
+    display: grid !important;
+  }
+
+  .d-xl-table {
+    display: table !important;
+  }
+
+  .d-xl-table-row {
+    display: table-row !important;
+  }
+
+  .d-xl-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-xl-flex {
+    display: flex !important;
+  }
+
+  .d-xl-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-xl-none {
+    display: none !important;
+  }
+
+  .flex-xl-fill {
+    flex: 1 1 auto !important;
+  }
+
+  .flex-xl-row {
+    flex-direction: row !important;
+  }
+
+  .flex-xl-column {
+    flex-direction: column !important;
+  }
+
+  .flex-xl-row-reverse {
+    flex-direction: row-reverse !important;
+  }
+
+  .flex-xl-column-reverse {
+    flex-direction: column-reverse !important;
+  }
+
+  .flex-xl-grow-0 {
+    flex-grow: 0 !important;
+  }
+
+  .flex-xl-grow-1 {
+    flex-grow: 1 !important;
+  }
+
+  .flex-xl-shrink-0 {
+    flex-shrink: 0 !important;
+  }
+
+  .flex-xl-shrink-1 {
+    flex-shrink: 1 !important;
+  }
+
+  .flex-xl-wrap {
+    flex-wrap: wrap !important;
+  }
+
+  .flex-xl-nowrap {
+    flex-wrap: nowrap !important;
+  }
+
+  .flex-xl-wrap-reverse {
+    flex-wrap: wrap-reverse !important;
+  }
+
+  .gap-xl-0 {
+    gap: 0 !important;
+  }
+
+  .gap-xl-1 {
+    gap: 0.25rem !important;
+  }
+
+  .gap-xl-2 {
+    gap: 0.5rem !important;
+  }
+
+  .gap-xl-3 {
+    gap: 1rem !important;
+  }
+
+  .gap-xl-4 {
+    gap: 1.5rem !important;
+  }
+
+  .gap-xl-5 {
+    gap: 3rem !important;
+  }
+
+  .justify-content-xl-start {
+    justify-content: flex-start !important;
+  }
+
+  .justify-content-xl-end {
+    justify-content: flex-end !important;
+  }
+
+  .justify-content-xl-center {
+    justify-content: center !important;
+  }
+
+  .justify-content-xl-between {
+    justify-content: space-between !important;
+  }
+
+  .justify-content-xl-around {
+    justify-content: space-around !important;
+  }
+
+  .justify-content-xl-evenly {
+    justify-content: space-evenly !important;
+  }
+
+  .align-items-xl-start {
+    align-items: flex-start !important;
+  }
+
+  .align-items-xl-end {
+    align-items: flex-end !important;
+  }
+
+  .align-items-xl-center {
+    align-items: center !important;
+  }
+
+  .align-items-xl-baseline {
+    align-items: baseline !important;
+  }
+
+  .align-items-xl-stretch {
+    align-items: stretch !important;
+  }
+
+  .align-content-xl-start {
+    align-content: flex-start !important;
+  }
+
+  .align-content-xl-end {
+    align-content: flex-end !important;
+  }
+
+  .align-content-xl-center {
+    align-content: center !important;
+  }
+
+  .align-content-xl-between {
+    align-content: space-between !important;
+  }
+
+  .align-content-xl-around {
+    align-content: space-around !important;
+  }
+
+  .align-content-xl-stretch {
+    align-content: stretch !important;
+  }
+
+  .align-self-xl-auto {
+    align-self: auto !important;
+  }
+
+  .align-self-xl-start {
+    align-self: flex-start !important;
+  }
+
+  .align-self-xl-end {
+    align-self: flex-end !important;
+  }
+
+  .align-self-xl-center {
+    align-self: center !important;
+  }
+
+  .align-self-xl-baseline {
+    align-self: baseline !important;
+  }
+
+  .align-self-xl-stretch {
+    align-self: stretch !important;
+  }
+
+  .order-xl-first {
+    order: -1 !important;
+  }
+
+  .order-xl-0 {
+    order: 0 !important;
+  }
+
+  .order-xl-1 {
+    order: 1 !important;
+  }
+
+  .order-xl-2 {
+    order: 2 !important;
+  }
+
+  .order-xl-3 {
+    order: 3 !important;
+  }
+
+  .order-xl-4 {
+    order: 4 !important;
+  }
+
+  .order-xl-5 {
+    order: 5 !important;
+  }
+
+  .order-xl-last {
+    order: 6 !important;
+  }
+
+  .m-xl-0 {
+    margin: 0 !important;
+  }
+
+  .m-xl-1 {
+    margin: 0.25rem !important;
+  }
+
+  .m-xl-2 {
+    margin: 0.5rem !important;
+  }
+
+  .m-xl-3 {
+    margin: 1rem !important;
+  }
+
+  .m-xl-4 {
+    margin: 1.5rem !important;
+  }
+
+  .m-xl-5 {
+    margin: 3rem !important;
+  }
+
+  .m-xl-auto {
+    margin: auto !important;
+  }
+
+  .mx-xl-0 {
+    margin-right: 0 !important;
+    margin-left: 0 !important;
+  }
+
+  .mx-xl-1 {
+    margin-right: 0.25rem !important;
+    margin-left: 0.25rem !important;
+  }
+
+  .mx-xl-2 {
+    margin-right: 0.5rem !important;
+    margin-left: 0.5rem !important;
+  }
+
+  .mx-xl-3 {
+    margin-right: 1rem !important;
+    margin-left: 1rem !important;
+  }
+
+  .mx-xl-4 {
+    margin-right: 1.5rem !important;
+    margin-left: 1.5rem !important;
+  }
+
+  .mx-xl-5 {
+    margin-right: 3rem !important;
+    margin-left: 3rem !important;
+  }
+
+  .mx-xl-auto {
+    margin-right: auto !important;
+    margin-left: auto !important;
+  }
+
+  .my-xl-0 {
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+  }
+
+  .my-xl-1 {
+    margin-top: 0.25rem !important;
+    margin-bottom: 0.25rem !important;
+  }
+
+  .my-xl-2 {
+    margin-top: 0.5rem !important;
+    margin-bottom: 0.5rem !important;
+  }
+
+  .my-xl-3 {
+    margin-top: 1rem !important;
+    margin-bottom: 1rem !important;
+  }
+
+  .my-xl-4 {
+    margin-top: 1.5rem !important;
+    margin-bottom: 1.5rem !important;
+  }
+
+  .my-xl-5 {
+    margin-top: 3rem !important;
+    margin-bottom: 3rem !important;
+  }
+
+  .my-xl-auto {
+    margin-top: auto !important;
+    margin-bottom: auto !important;
+  }
+
+  .mt-xl-0 {
+    margin-top: 0 !important;
+  }
+
+  .mt-xl-1 {
+    margin-top: 0.25rem !important;
+  }
+
+  .mt-xl-2 {
+    margin-top: 0.5rem !important;
+  }
+
+  .mt-xl-3 {
+    margin-top: 1rem !important;
+  }
+
+  .mt-xl-4 {
+    margin-top: 1.5rem !important;
+  }
+
+  .mt-xl-5 {
+    margin-top: 3rem !important;
+  }
+
+  .mt-xl-auto {
+    margin-top: auto !important;
+  }
+
+  .me-xl-0 {
+    margin-right: 0 !important;
+  }
+
+  .me-xl-1 {
+    margin-right: 0.25rem !important;
+  }
+
+  .me-xl-2 {
+    margin-right: 0.5rem !important;
+  }
+
+  .me-xl-3 {
+    margin-right: 1rem !important;
+  }
+
+  .me-xl-4 {
+    margin-right: 1.5rem !important;
+  }
+
+  .me-xl-5 {
+    margin-right: 3rem !important;
+  }
+
+  .me-xl-auto {
+    margin-right: auto !important;
+  }
+
+  .mb-xl-0 {
+    margin-bottom: 0 !important;
+  }
+
+  .mb-xl-1 {
+    margin-bottom: 0.25rem !important;
+  }
+
+  .mb-xl-2 {
+    margin-bottom: 0.5rem !important;
+  }
+
+  .mb-xl-3 {
+    margin-bottom: 1rem !important;
+  }
+
+  .mb-xl-4 {
+    margin-bottom: 1.5rem !important;
+  }
+
+  .mb-xl-5 {
+    margin-bottom: 3rem !important;
+  }
+
+  .mb-xl-auto {
+    margin-bottom: auto !important;
+  }
+
+  .ms-xl-0 {
+    margin-left: 0 !important;
+  }
+
+  .ms-xl-1 {
+    margin-left: 0.25rem !important;
+  }
+
+  .ms-xl-2 {
+    margin-left: 0.5rem !important;
+  }
+
+  .ms-xl-3 {
+    margin-left: 1rem !important;
+  }
+
+  .ms-xl-4 {
+    margin-left: 1.5rem !important;
+  }
+
+  .ms-xl-5 {
+    margin-left: 3rem !important;
+  }
+
+  .ms-xl-auto {
+    margin-left: auto !important;
+  }
+
+  .p-xl-0 {
+    padding: 0 !important;
+  }
+
+  .p-xl-1 {
+    padding: 0.25rem !important;
+  }
+
+  .p-xl-2 {
+    padding: 0.5rem !important;
+  }
+
+  .p-xl-3 {
+    padding: 1rem !important;
+  }
+
+  .p-xl-4 {
+    padding: 1.5rem !important;
+  }
+
+  .p-xl-5 {
+    padding: 3rem !important;
+  }
+
+  .px-xl-0 {
+    padding-right: 0 !important;
+    padding-left: 0 !important;
+  }
+
+  .px-xl-1 {
+    padding-right: 0.25rem !important;
+    padding-left: 0.25rem !important;
+  }
+
+  .px-xl-2 {
+    padding-right: 0.5rem !important;
+    padding-left: 0.5rem !important;
+  }
+
+  .px-xl-3 {
+    padding-right: 1rem !important;
+    padding-left: 1rem !important;
+  }
+
+  .px-xl-4 {
+    padding-right: 1.5rem !important;
+    padding-left: 1.5rem !important;
+  }
+
+  .px-xl-5 {
+    padding-right: 3rem !important;
+    padding-left: 3rem !important;
+  }
+
+  .py-xl-0 {
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+  }
+
+  .py-xl-1 {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+  }
+
+  .py-xl-2 {
+    padding-top: 0.5rem !important;
+    padding-bottom: 0.5rem !important;
+  }
+
+  .py-xl-3 {
+    padding-top: 1rem !important;
+    padding-bottom: 1rem !important;
+  }
+
+  .py-xl-4 {
+    padding-top: 1.5rem !important;
+    padding-bottom: 1.5rem !important;
+  }
+
+  .py-xl-5 {
+    padding-top: 3rem !important;
+    padding-bottom: 3rem !important;
+  }
+
+  .pt-xl-0 {
+    padding-top: 0 !important;
+  }
+
+  .pt-xl-1 {
+    padding-top: 0.25rem !important;
+  }
+
+  .pt-xl-2 {
+    padding-top: 0.5rem !important;
+  }
+
+  .pt-xl-3 {
+    padding-top: 1rem !important;
+  }
+
+  .pt-xl-4 {
+    padding-top: 1.5rem !important;
+  }
+
+  .pt-xl-5 {
+    padding-top: 3rem !important;
+  }
+
+  .pe-xl-0 {
+    padding-right: 0 !important;
+  }
+
+  .pe-xl-1 {
+    padding-right: 0.25rem !important;
+  }
+
+  .pe-xl-2 {
+    padding-right: 0.5rem !important;
+  }
+
+  .pe-xl-3 {
+    padding-right: 1rem !important;
+  }
+
+  .pe-xl-4 {
+    padding-right: 1.5rem !important;
+  }
+
+  .pe-xl-5 {
+    padding-right: 3rem !important;
+  }
+
+  .pb-xl-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .pb-xl-1 {
+    padding-bottom: 0.25rem !important;
+  }
+
+  .pb-xl-2 {
+    padding-bottom: 0.5rem !important;
+  }
+
+  .pb-xl-3 {
+    padding-bottom: 1rem !important;
+  }
+
+  .pb-xl-4 {
+    padding-bottom: 1.5rem !important;
+  }
+
+  .pb-xl-5 {
+    padding-bottom: 3rem !important;
+  }
+
+  .ps-xl-0 {
+    padding-left: 0 !important;
+  }
+
+  .ps-xl-1 {
+    padding-left: 0.25rem !important;
+  }
+
+  .ps-xl-2 {
+    padding-left: 0.5rem !important;
+  }
+
+  .ps-xl-3 {
+    padding-left: 1rem !important;
+  }
+
+  .ps-xl-4 {
+    padding-left: 1.5rem !important;
+  }
+
+  .ps-xl-5 {
+    padding-left: 3rem !important;
+  }
+
+  .text-xl-start {
+    text-align: left !important;
+  }
+
+  .text-xl-end {
+    text-align: right !important;
+  }
+
+  .text-xl-center {
+    text-align: center !important;
+  }
+}
+@media (min-width: 1400px) {
+  .float-xxl-start {
+    float: left !important;
+  }
+
+  .float-xxl-end {
+    float: right !important;
+  }
+
+  .float-xxl-none {
+    float: none !important;
+  }
+
+  .d-xxl-inline {
+    display: inline !important;
+  }
+
+  .d-xxl-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-xxl-block {
+    display: block !important;
+  }
+
+  .d-xxl-grid {
+    display: grid !important;
+  }
+
+  .d-xxl-table {
+    display: table !important;
+  }
+
+  .d-xxl-table-row {
+    display: table-row !important;
+  }
+
+  .d-xxl-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-xxl-flex {
+    display: flex !important;
+  }
+
+  .d-xxl-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-xxl-none {
+    display: none !important;
+  }
+
+  .flex-xxl-fill {
+    flex: 1 1 auto !important;
+  }
+
+  .flex-xxl-row {
+    flex-direction: row !important;
+  }
+
+  .flex-xxl-column {
+    flex-direction: column !important;
+  }
+
+  .flex-xxl-row-reverse {
+    flex-direction: row-reverse !important;
+  }
+
+  .flex-xxl-column-reverse {
+    flex-direction: column-reverse !important;
+  }
+
+  .flex-xxl-grow-0 {
+    flex-grow: 0 !important;
+  }
+
+  .flex-xxl-grow-1 {
+    flex-grow: 1 !important;
+  }
+
+  .flex-xxl-shrink-0 {
+    flex-shrink: 0 !important;
+  }
+
+  .flex-xxl-shrink-1 {
+    flex-shrink: 1 !important;
+  }
+
+  .flex-xxl-wrap {
+    flex-wrap: wrap !important;
+  }
+
+  .flex-xxl-nowrap {
+    flex-wrap: nowrap !important;
+  }
+
+  .flex-xxl-wrap-reverse {
+    flex-wrap: wrap-reverse !important;
+  }
+
+  .gap-xxl-0 {
+    gap: 0 !important;
+  }
+
+  .gap-xxl-1 {
+    gap: 0.25rem !important;
+  }
+
+  .gap-xxl-2 {
+    gap: 0.5rem !important;
+  }
+
+  .gap-xxl-3 {
+    gap: 1rem !important;
+  }
+
+  .gap-xxl-4 {
+    gap: 1.5rem !important;
+  }
+
+  .gap-xxl-5 {
+    gap: 3rem !important;
+  }
+
+  .justify-content-xxl-start {
+    justify-content: flex-start !important;
+  }
+
+  .justify-content-xxl-end {
+    justify-content: flex-end !important;
+  }
+
+  .justify-content-xxl-center {
+    justify-content: center !important;
+  }
+
+  .justify-content-xxl-between {
+    justify-content: space-between !important;
+  }
+
+  .justify-content-xxl-around {
+    justify-content: space-around !important;
+  }
+
+  .justify-content-xxl-evenly {
+    justify-content: space-evenly !important;
+  }
+
+  .align-items-xxl-start {
+    align-items: flex-start !important;
+  }
+
+  .align-items-xxl-end {
+    align-items: flex-end !important;
+  }
+
+  .align-items-xxl-center {
+    align-items: center !important;
+  }
+
+  .align-items-xxl-baseline {
+    align-items: baseline !important;
+  }
+
+  .align-items-xxl-stretch {
+    align-items: stretch !important;
+  }
+
+  .align-content-xxl-start {
+    align-content: flex-start !important;
+  }
+
+  .align-content-xxl-end {
+    align-content: flex-end !important;
+  }
+
+  .align-content-xxl-center {
+    align-content: center !important;
+  }
+
+  .align-content-xxl-between {
+    align-content: space-between !important;
+  }
+
+  .align-content-xxl-around {
+    align-content: space-around !important;
+  }
+
+  .align-content-xxl-stretch {
+    align-content: stretch !important;
+  }
+
+  .align-self-xxl-auto {
+    align-self: auto !important;
+  }
+
+  .align-self-xxl-start {
+    align-self: flex-start !important;
+  }
+
+  .align-self-xxl-end {
+    align-self: flex-end !important;
+  }
+
+  .align-self-xxl-center {
+    align-self: center !important;
+  }
+
+  .align-self-xxl-baseline {
+    align-self: baseline !important;
+  }
+
+  .align-self-xxl-stretch {
+    align-self: stretch !important;
+  }
+
+  .order-xxl-first {
+    order: -1 !important;
+  }
+
+  .order-xxl-0 {
+    order: 0 !important;
+  }
+
+  .order-xxl-1 {
+    order: 1 !important;
+  }
+
+  .order-xxl-2 {
+    order: 2 !important;
+  }
+
+  .order-xxl-3 {
+    order: 3 !important;
+  }
+
+  .order-xxl-4 {
+    order: 4 !important;
+  }
+
+  .order-xxl-5 {
+    order: 5 !important;
+  }
+
+  .order-xxl-last {
+    order: 6 !important;
+  }
+
+  .m-xxl-0 {
+    margin: 0 !important;
+  }
+
+  .m-xxl-1 {
+    margin: 0.25rem !important;
+  }
+
+  .m-xxl-2 {
+    margin: 0.5rem !important;
+  }
+
+  .m-xxl-3 {
+    margin: 1rem !important;
+  }
+
+  .m-xxl-4 {
+    margin: 1.5rem !important;
+  }
+
+  .m-xxl-5 {
+    margin: 3rem !important;
+  }
+
+  .m-xxl-auto {
+    margin: auto !important;
+  }
+
+  .mx-xxl-0 {
+    margin-right: 0 !important;
+    margin-left: 0 !important;
+  }
+
+  .mx-xxl-1 {
+    margin-right: 0.25rem !important;
+    margin-left: 0.25rem !important;
+  }
+
+  .mx-xxl-2 {
+    margin-right: 0.5rem !important;
+    margin-left: 0.5rem !important;
+  }
+
+  .mx-xxl-3 {
+    margin-right: 1rem !important;
+    margin-left: 1rem !important;
+  }
+
+  .mx-xxl-4 {
+    margin-right: 1.5rem !important;
+    margin-left: 1.5rem !important;
+  }
+
+  .mx-xxl-5 {
+    margin-right: 3rem !important;
+    margin-left: 3rem !important;
+  }
+
+  .mx-xxl-auto {
+    margin-right: auto !important;
+    margin-left: auto !important;
+  }
+
+  .my-xxl-0 {
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+  }
+
+  .my-xxl-1 {
+    margin-top: 0.25rem !important;
+    margin-bottom: 0.25rem !important;
+  }
+
+  .my-xxl-2 {
+    margin-top: 0.5rem !important;
+    margin-bottom: 0.5rem !important;
+  }
+
+  .my-xxl-3 {
+    margin-top: 1rem !important;
+    margin-bottom: 1rem !important;
+  }
+
+  .my-xxl-4 {
+    margin-top: 1.5rem !important;
+    margin-bottom: 1.5rem !important;
+  }
+
+  .my-xxl-5 {
+    margin-top: 3rem !important;
+    margin-bottom: 3rem !important;
+  }
+
+  .my-xxl-auto {
+    margin-top: auto !important;
+    margin-bottom: auto !important;
+  }
+
+  .mt-xxl-0 {
+    margin-top: 0 !important;
+  }
+
+  .mt-xxl-1 {
+    margin-top: 0.25rem !important;
+  }
+
+  .mt-xxl-2 {
+    margin-top: 0.5rem !important;
+  }
+
+  .mt-xxl-3 {
+    margin-top: 1rem !important;
+  }
+
+  .mt-xxl-4 {
+    margin-top: 1.5rem !important;
+  }
+
+  .mt-xxl-5 {
+    margin-top: 3rem !important;
+  }
+
+  .mt-xxl-auto {
+    margin-top: auto !important;
+  }
+
+  .me-xxl-0 {
+    margin-right: 0 !important;
+  }
+
+  .me-xxl-1 {
+    margin-right: 0.25rem !important;
+  }
+
+  .me-xxl-2 {
+    margin-right: 0.5rem !important;
+  }
+
+  .me-xxl-3 {
+    margin-right: 1rem !important;
+  }
+
+  .me-xxl-4 {
+    margin-right: 1.5rem !important;
+  }
+
+  .me-xxl-5 {
+    margin-right: 3rem !important;
+  }
+
+  .me-xxl-auto {
+    margin-right: auto !important;
+  }
+
+  .mb-xxl-0 {
+    margin-bottom: 0 !important;
+  }
+
+  .mb-xxl-1 {
+    margin-bottom: 0.25rem !important;
+  }
+
+  .mb-xxl-2 {
+    margin-bottom: 0.5rem !important;
+  }
+
+  .mb-xxl-3 {
+    margin-bottom: 1rem !important;
+  }
+
+  .mb-xxl-4 {
+    margin-bottom: 1.5rem !important;
+  }
+
+  .mb-xxl-5 {
+    margin-bottom: 3rem !important;
+  }
+
+  .mb-xxl-auto {
+    margin-bottom: auto !important;
+  }
+
+  .ms-xxl-0 {
+    margin-left: 0 !important;
+  }
+
+  .ms-xxl-1 {
+    margin-left: 0.25rem !important;
+  }
+
+  .ms-xxl-2 {
+    margin-left: 0.5rem !important;
+  }
+
+  .ms-xxl-3 {
+    margin-left: 1rem !important;
+  }
+
+  .ms-xxl-4 {
+    margin-left: 1.5rem !important;
+  }
+
+  .ms-xxl-5 {
+    margin-left: 3rem !important;
+  }
+
+  .ms-xxl-auto {
+    margin-left: auto !important;
+  }
+
+  .p-xxl-0 {
+    padding: 0 !important;
+  }
+
+  .p-xxl-1 {
+    padding: 0.25rem !important;
+  }
+
+  .p-xxl-2 {
+    padding: 0.5rem !important;
+  }
+
+  .p-xxl-3 {
+    padding: 1rem !important;
+  }
+
+  .p-xxl-4 {
+    padding: 1.5rem !important;
+  }
+
+  .p-xxl-5 {
+    padding: 3rem !important;
+  }
+
+  .px-xxl-0 {
+    padding-right: 0 !important;
+    padding-left: 0 !important;
+  }
+
+  .px-xxl-1 {
+    padding-right: 0.25rem !important;
+    padding-left: 0.25rem !important;
+  }
+
+  .px-xxl-2 {
+    padding-right: 0.5rem !important;
+    padding-left: 0.5rem !important;
+  }
+
+  .px-xxl-3 {
+    padding-right: 1rem !important;
+    padding-left: 1rem !important;
+  }
+
+  .px-xxl-4 {
+    padding-right: 1.5rem !important;
+    padding-left: 1.5rem !important;
+  }
+
+  .px-xxl-5 {
+    padding-right: 3rem !important;
+    padding-left: 3rem !important;
+  }
+
+  .py-xxl-0 {
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+  }
+
+  .py-xxl-1 {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+  }
+
+  .py-xxl-2 {
+    padding-top: 0.5rem !important;
+    padding-bottom: 0.5rem !important;
+  }
+
+  .py-xxl-3 {
+    padding-top: 1rem !important;
+    padding-bottom: 1rem !important;
+  }
+
+  .py-xxl-4 {
+    padding-top: 1.5rem !important;
+    padding-bottom: 1.5rem !important;
+  }
+
+  .py-xxl-5 {
+    padding-top: 3rem !important;
+    padding-bottom: 3rem !important;
+  }
+
+  .pt-xxl-0 {
+    padding-top: 0 !important;
+  }
+
+  .pt-xxl-1 {
+    padding-top: 0.25rem !important;
+  }
+
+  .pt-xxl-2 {
+    padding-top: 0.5rem !important;
+  }
+
+  .pt-xxl-3 {
+    padding-top: 1rem !important;
+  }
+
+  .pt-xxl-4 {
+    padding-top: 1.5rem !important;
+  }
+
+  .pt-xxl-5 {
+    padding-top: 3rem !important;
+  }
+
+  .pe-xxl-0 {
+    padding-right: 0 !important;
+  }
+
+  .pe-xxl-1 {
+    padding-right: 0.25rem !important;
+  }
+
+  .pe-xxl-2 {
+    padding-right: 0.5rem !important;
+  }
+
+  .pe-xxl-3 {
+    padding-right: 1rem !important;
+  }
+
+  .pe-xxl-4 {
+    padding-right: 1.5rem !important;
+  }
+
+  .pe-xxl-5 {
+    padding-right: 3rem !important;
+  }
+
+  .pb-xxl-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .pb-xxl-1 {
+    padding-bottom: 0.25rem !important;
+  }
+
+  .pb-xxl-2 {
+    padding-bottom: 0.5rem !important;
+  }
+
+  .pb-xxl-3 {
+    padding-bottom: 1rem !important;
+  }
+
+  .pb-xxl-4 {
+    padding-bottom: 1.5rem !important;
+  }
+
+  .pb-xxl-5 {
+    padding-bottom: 3rem !important;
+  }
+
+  .ps-xxl-0 {
+    padding-left: 0 !important;
+  }
+
+  .ps-xxl-1 {
+    padding-left: 0.25rem !important;
+  }
+
+  .ps-xxl-2 {
+    padding-left: 0.5rem !important;
+  }
+
+  .ps-xxl-3 {
+    padding-left: 1rem !important;
+  }
+
+  .ps-xxl-4 {
+    padding-left: 1.5rem !important;
+  }
+
+  .ps-xxl-5 {
+    padding-left: 3rem !important;
+  }
+
+  .text-xxl-start {
+    text-align: left !important;
+  }
+
+  .text-xxl-end {
+    text-align: right !important;
+  }
+
+  .text-xxl-center {
+    text-align: center !important;
+  }
+}
+@media (min-width: 1200px) {
+  .fs-1 {
+    font-size: 2.5rem !important;
+  }
+
+  .fs-2 {
+    font-size: 2rem !important;
+  }
+
+  .fs-3 {
+    font-size: 1.75rem !important;
+  }
+
+  .fs-4 {
+    font-size: 1.5rem !important;
+  }
+}
+@media print {
+  .d-print-inline {
+    display: inline !important;
+  }
+
+  .d-print-inline-block {
+    display: inline-block !important;
+  }
+
+  .d-print-block {
+    display: block !important;
+  }
+
+  .d-print-grid {
+    display: grid !important;
+  }
+
+  .d-print-table {
+    display: table !important;
+  }
+
+  .d-print-table-row {
+    display: table-row !important;
+  }
+
+  .d-print-table-cell {
+    display: table-cell !important;
+  }
+
+  .d-print-flex {
+    display: flex !important;
+  }
+
+  .d-print-inline-flex {
+    display: inline-flex !important;
+  }
+
+  .d-print-none {
+    display: none !important;
+  }
+}
+
+/*# sourceMappingURL=bootstrap.css.map */
\ No newline at end of file
diff --git a/src/main/resources/web/css/bootstrap.min.css b/src/main/resources/web/css/bootstrap.min.css
new file mode 100644
index 0000000..33edb05
--- /dev/null
+++ b/src/main/resources/web/css/bootstrap.min.css
@@ -0,0 +1,7 @@
+@charset "UTF-8";/*!
+ * Bootstrap v5.0.0-beta2 (https://getbootstrap.com/)
+ * Copyright 2011-2021 The Bootstrap Authors
+ * Copyright 2011-2021 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */:root{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-primary:#0d6efd;--bs-secondary:#6c757d;--bs-success:#198754;--bs-info:#0dcaf0;--bs-warning:#ffc107;--bs-danger:#dc3545;--bs-light:#f8f9fa;--bs-dark:#212529;--bs-font-sans-serif:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans","Liberation Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--bs-font-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--bs-gradient:linear-gradient(180deg, rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0))}*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-font-sans-serif);font-size:1rem;font-weight:400;line-height:1.5;color:#212529;background-color:#fff;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}[tabindex="-1"]:focus:not(:focus-visible){outline:0!important}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}.h1,h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){.h1,h1{font-size:2.5rem}}.h2,h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){.h2,h2{font-size:2rem}}.h3,h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){.h3,h3{font-size:1.75rem}}.h4,h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){.h4,h4{font-size:1.5rem}}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-left:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}.small,small{font-size:.875em}.mark,mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:var(--bs-font-monospace);font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:left;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:calc(1.625rem + 4.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-1{font-size:5rem}}.display-2{font-size:calc(1.575rem + 3.9vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-2{font-size:4.5rem}}.display-3{font-size:calc(1.525rem + 3.3vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-3{font-size:4rem}}.display-4{font-size:calc(1.475rem + 2.7vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-4{font-size:3.5rem}}.display-5{font-size:calc(1.425rem + 2.1vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-5{font-size:3rem}}.display-6{font-size:calc(1.375rem + 1.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-6{font-size:2.5rem}}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:.875em;text-transform:uppercase}.blockquote{margin-bottom:1rem;font-size:1.25rem}.blockquote>:last-child{margin-bottom:0}.blockquote-footer{margin-top:-1rem;margin-bottom:1rem;font-size:.875em;color:#6c757d}.blockquote-footer::before{content:"— "}.img-fluid{max-width:100%;height:auto}.img-thumbnail{padding:.25rem;background-color:#fff;border:1px solid #dee2e6;border-radius:.25rem;max-width:100%;height:auto}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{font-size:.875em;color:#6c757d}.container,.container-fluid,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{width:100%;padding-right:var(--bs-gutter-x,.75rem);padding-left:var(--bs-gutter-x,.75rem);margin-right:auto;margin-left:auto}@media (min-width:576px){.container,.container-sm{max-width:540px}}@media (min-width:768px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:992px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1140px}}@media (min-width:1400px){.container,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{max-width:1320px}}.row{--bs-gutter-x:1.5rem;--bs-gutter-y:0;display:flex;flex-wrap:wrap;margin-top:calc(var(--bs-gutter-y) * -1);margin-right:calc(var(--bs-gutter-x)/ -2);margin-left:calc(var(--bs-gutter-x)/ -2)}.row>*{flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--bs-gutter-x)/ 2);padding-left:calc(var(--bs-gutter-x)/ 2);margin-top:var(--bs-gutter-y)}.col{flex:1 0 0%}.row-cols-auto>*{flex:0 0 auto;width:auto}.row-cols-1>*{flex:0 0 auto;width:100%}.row-cols-2>*{flex:0 0 auto;width:50%}.row-cols-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-4>*{flex:0 0 auto;width:25%}.row-cols-5>*{flex:0 0 auto;width:20%}.row-cols-6>*{flex:0 0 auto;width:16.6666666667%}.col-auto{flex:0 0 auto;width:auto}.col-1{flex:0 0 auto;width:8.3333333333%}.col-2{flex:0 0 auto;width:16.6666666667%}.col-3{flex:0 0 auto;width:25%}.col-4{flex:0 0 auto;width:33.3333333333%}.col-5{flex:0 0 auto;width:41.6666666667%}.col-6{flex:0 0 auto;width:50%}.col-7{flex:0 0 auto;width:58.3333333333%}.col-8{flex:0 0 auto;width:66.6666666667%}.col-9{flex:0 0 auto;width:75%}.col-10{flex:0 0 auto;width:83.3333333333%}.col-11{flex:0 0 auto;width:91.6666666667%}.col-12{flex:0 0 auto;width:100%}.offset-1{margin-left:8.3333333333%}.offset-2{margin-left:16.6666666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.3333333333%}.offset-5{margin-left:41.6666666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.3333333333%}.offset-8{margin-left:66.6666666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.3333333333%}.offset-11{margin-left:91.6666666667%}.g-0,.gx-0{--bs-gutter-x:0}.g-0,.gy-0{--bs-gutter-y:0}.g-1,.gx-1{--bs-gutter-x:0.25rem}.g-1,.gy-1{--bs-gutter-y:0.25rem}.g-2,.gx-2{--bs-gutter-x:0.5rem}.g-2,.gy-2{--bs-gutter-y:0.5rem}.g-3,.gx-3{--bs-gutter-x:1rem}.g-3,.gy-3{--bs-gutter-y:1rem}.g-4,.gx-4{--bs-gutter-x:1.5rem}.g-4,.gy-4{--bs-gutter-y:1.5rem}.g-5,.gx-5{--bs-gutter-x:3rem}.g-5,.gy-5{--bs-gutter-y:3rem}@media (min-width:576px){.col-sm{flex:1 0 0%}.row-cols-sm-auto>*{flex:0 0 auto;width:auto}.row-cols-sm-1>*{flex:0 0 auto;width:100%}.row-cols-sm-2>*{flex:0 0 auto;width:50%}.row-cols-sm-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-sm-4>*{flex:0 0 auto;width:25%}.row-cols-sm-5>*{flex:0 0 auto;width:20%}.row-cols-sm-6>*{flex:0 0 auto;width:16.6666666667%}.col-sm-auto{flex:0 0 auto;width:auto}.col-sm-1{flex:0 0 auto;width:8.3333333333%}.col-sm-2{flex:0 0 auto;width:16.6666666667%}.col-sm-3{flex:0 0 auto;width:25%}.col-sm-4{flex:0 0 auto;width:33.3333333333%}.col-sm-5{flex:0 0 auto;width:41.6666666667%}.col-sm-6{flex:0 0 auto;width:50%}.col-sm-7{flex:0 0 auto;width:58.3333333333%}.col-sm-8{flex:0 0 auto;width:66.6666666667%}.col-sm-9{flex:0 0 auto;width:75%}.col-sm-10{flex:0 0 auto;width:83.3333333333%}.col-sm-11{flex:0 0 auto;width:91.6666666667%}.col-sm-12{flex:0 0 auto;width:100%}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.3333333333%}.offset-sm-2{margin-left:16.6666666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.3333333333%}.offset-sm-5{margin-left:41.6666666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.3333333333%}.offset-sm-8{margin-left:66.6666666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.3333333333%}.offset-sm-11{margin-left:91.6666666667%}.g-sm-0,.gx-sm-0{--bs-gutter-x:0}.g-sm-0,.gy-sm-0{--bs-gutter-y:0}.g-sm-1,.gx-sm-1{--bs-gutter-x:0.25rem}.g-sm-1,.gy-sm-1{--bs-gutter-y:0.25rem}.g-sm-2,.gx-sm-2{--bs-gutter-x:0.5rem}.g-sm-2,.gy-sm-2{--bs-gutter-y:0.5rem}.g-sm-3,.gx-sm-3{--bs-gutter-x:1rem}.g-sm-3,.gy-sm-3{--bs-gutter-y:1rem}.g-sm-4,.gx-sm-4{--bs-gutter-x:1.5rem}.g-sm-4,.gy-sm-4{--bs-gutter-y:1.5rem}.g-sm-5,.gx-sm-5{--bs-gutter-x:3rem}.g-sm-5,.gy-sm-5{--bs-gutter-y:3rem}}@media (min-width:768px){.col-md{flex:1 0 0%}.row-cols-md-auto>*{flex:0 0 auto;width:auto}.row-cols-md-1>*{flex:0 0 auto;width:100%}.row-cols-md-2>*{flex:0 0 auto;width:50%}.row-cols-md-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-md-4>*{flex:0 0 auto;width:25%}.row-cols-md-5>*{flex:0 0 auto;width:20%}.row-cols-md-6>*{flex:0 0 auto;width:16.6666666667%}.col-md-auto{flex:0 0 auto;width:auto}.col-md-1{flex:0 0 auto;width:8.3333333333%}.col-md-2{flex:0 0 auto;width:16.6666666667%}.col-md-3{flex:0 0 auto;width:25%}.col-md-4{flex:0 0 auto;width:33.3333333333%}.col-md-5{flex:0 0 auto;width:41.6666666667%}.col-md-6{flex:0 0 auto;width:50%}.col-md-7{flex:0 0 auto;width:58.3333333333%}.col-md-8{flex:0 0 auto;width:66.6666666667%}.col-md-9{flex:0 0 auto;width:75%}.col-md-10{flex:0 0 auto;width:83.3333333333%}.col-md-11{flex:0 0 auto;width:91.6666666667%}.col-md-12{flex:0 0 auto;width:100%}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.3333333333%}.offset-md-2{margin-left:16.6666666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.3333333333%}.offset-md-5{margin-left:41.6666666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.3333333333%}.offset-md-8{margin-left:66.6666666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.3333333333%}.offset-md-11{margin-left:91.6666666667%}.g-md-0,.gx-md-0{--bs-gutter-x:0}.g-md-0,.gy-md-0{--bs-gutter-y:0}.g-md-1,.gx-md-1{--bs-gutter-x:0.25rem}.g-md-1,.gy-md-1{--bs-gutter-y:0.25rem}.g-md-2,.gx-md-2{--bs-gutter-x:0.5rem}.g-md-2,.gy-md-2{--bs-gutter-y:0.5rem}.g-md-3,.gx-md-3{--bs-gutter-x:1rem}.g-md-3,.gy-md-3{--bs-gutter-y:1rem}.g-md-4,.gx-md-4{--bs-gutter-x:1.5rem}.g-md-4,.gy-md-4{--bs-gutter-y:1.5rem}.g-md-5,.gx-md-5{--bs-gutter-x:3rem}.g-md-5,.gy-md-5{--bs-gutter-y:3rem}}@media (min-width:992px){.col-lg{flex:1 0 0%}.row-cols-lg-auto>*{flex:0 0 auto;width:auto}.row-cols-lg-1>*{flex:0 0 auto;width:100%}.row-cols-lg-2>*{flex:0 0 auto;width:50%}.row-cols-lg-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-lg-4>*{flex:0 0 auto;width:25%}.row-cols-lg-5>*{flex:0 0 auto;width:20%}.row-cols-lg-6>*{flex:0 0 auto;width:16.6666666667%}.col-lg-auto{flex:0 0 auto;width:auto}.col-lg-1{flex:0 0 auto;width:8.3333333333%}.col-lg-2{flex:0 0 auto;width:16.6666666667%}.col-lg-3{flex:0 0 auto;width:25%}.col-lg-4{flex:0 0 auto;width:33.3333333333%}.col-lg-5{flex:0 0 auto;width:41.6666666667%}.col-lg-6{flex:0 0 auto;width:50%}.col-lg-7{flex:0 0 auto;width:58.3333333333%}.col-lg-8{flex:0 0 auto;width:66.6666666667%}.col-lg-9{flex:0 0 auto;width:75%}.col-lg-10{flex:0 0 auto;width:83.3333333333%}.col-lg-11{flex:0 0 auto;width:91.6666666667%}.col-lg-12{flex:0 0 auto;width:100%}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.3333333333%}.offset-lg-2{margin-left:16.6666666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.3333333333%}.offset-lg-5{margin-left:41.6666666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.3333333333%}.offset-lg-8{margin-left:66.6666666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.3333333333%}.offset-lg-11{margin-left:91.6666666667%}.g-lg-0,.gx-lg-0{--bs-gutter-x:0}.g-lg-0,.gy-lg-0{--bs-gutter-y:0}.g-lg-1,.gx-lg-1{--bs-gutter-x:0.25rem}.g-lg-1,.gy-lg-1{--bs-gutter-y:0.25rem}.g-lg-2,.gx-lg-2{--bs-gutter-x:0.5rem}.g-lg-2,.gy-lg-2{--bs-gutter-y:0.5rem}.g-lg-3,.gx-lg-3{--bs-gutter-x:1rem}.g-lg-3,.gy-lg-3{--bs-gutter-y:1rem}.g-lg-4,.gx-lg-4{--bs-gutter-x:1.5rem}.g-lg-4,.gy-lg-4{--bs-gutter-y:1.5rem}.g-lg-5,.gx-lg-5{--bs-gutter-x:3rem}.g-lg-5,.gy-lg-5{--bs-gutter-y:3rem}}@media (min-width:1200px){.col-xl{flex:1 0 0%}.row-cols-xl-auto>*{flex:0 0 auto;width:auto}.row-cols-xl-1>*{flex:0 0 auto;width:100%}.row-cols-xl-2>*{flex:0 0 auto;width:50%}.row-cols-xl-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-xl-4>*{flex:0 0 auto;width:25%}.row-cols-xl-5>*{flex:0 0 auto;width:20%}.row-cols-xl-6>*{flex:0 0 auto;width:16.6666666667%}.col-xl-auto{flex:0 0 auto;width:auto}.col-xl-1{flex:0 0 auto;width:8.3333333333%}.col-xl-2{flex:0 0 auto;width:16.6666666667%}.col-xl-3{flex:0 0 auto;width:25%}.col-xl-4{flex:0 0 auto;width:33.3333333333%}.col-xl-5{flex:0 0 auto;width:41.6666666667%}.col-xl-6{flex:0 0 auto;width:50%}.col-xl-7{flex:0 0 auto;width:58.3333333333%}.col-xl-8{flex:0 0 auto;width:66.6666666667%}.col-xl-9{flex:0 0 auto;width:75%}.col-xl-10{flex:0 0 auto;width:83.3333333333%}.col-xl-11{flex:0 0 auto;width:91.6666666667%}.col-xl-12{flex:0 0 auto;width:100%}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.3333333333%}.offset-xl-2{margin-left:16.6666666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.3333333333%}.offset-xl-5{margin-left:41.6666666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.3333333333%}.offset-xl-8{margin-left:66.6666666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.3333333333%}.offset-xl-11{margin-left:91.6666666667%}.g-xl-0,.gx-xl-0{--bs-gutter-x:0}.g-xl-0,.gy-xl-0{--bs-gutter-y:0}.g-xl-1,.gx-xl-1{--bs-gutter-x:0.25rem}.g-xl-1,.gy-xl-1{--bs-gutter-y:0.25rem}.g-xl-2,.gx-xl-2{--bs-gutter-x:0.5rem}.g-xl-2,.gy-xl-2{--bs-gutter-y:0.5rem}.g-xl-3,.gx-xl-3{--bs-gutter-x:1rem}.g-xl-3,.gy-xl-3{--bs-gutter-y:1rem}.g-xl-4,.gx-xl-4{--bs-gutter-x:1.5rem}.g-xl-4,.gy-xl-4{--bs-gutter-y:1.5rem}.g-xl-5,.gx-xl-5{--bs-gutter-x:3rem}.g-xl-5,.gy-xl-5{--bs-gutter-y:3rem}}@media (min-width:1400px){.col-xxl{flex:1 0 0%}.row-cols-xxl-auto>*{flex:0 0 auto;width:auto}.row-cols-xxl-1>*{flex:0 0 auto;width:100%}.row-cols-xxl-2>*{flex:0 0 auto;width:50%}.row-cols-xxl-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-xxl-4>*{flex:0 0 auto;width:25%}.row-cols-xxl-5>*{flex:0 0 auto;width:20%}.row-cols-xxl-6>*{flex:0 0 auto;width:16.6666666667%}.col-xxl-auto{flex:0 0 auto;width:auto}.col-xxl-1{flex:0 0 auto;width:8.3333333333%}.col-xxl-2{flex:0 0 auto;width:16.6666666667%}.col-xxl-3{flex:0 0 auto;width:25%}.col-xxl-4{flex:0 0 auto;width:33.3333333333%}.col-xxl-5{flex:0 0 auto;width:41.6666666667%}.col-xxl-6{flex:0 0 auto;width:50%}.col-xxl-7{flex:0 0 auto;width:58.3333333333%}.col-xxl-8{flex:0 0 auto;width:66.6666666667%}.col-xxl-9{flex:0 0 auto;width:75%}.col-xxl-10{flex:0 0 auto;width:83.3333333333%}.col-xxl-11{flex:0 0 auto;width:91.6666666667%}.col-xxl-12{flex:0 0 auto;width:100%}.offset-xxl-0{margin-left:0}.offset-xxl-1{margin-left:8.3333333333%}.offset-xxl-2{margin-left:16.6666666667%}.offset-xxl-3{margin-left:25%}.offset-xxl-4{margin-left:33.3333333333%}.offset-xxl-5{margin-left:41.6666666667%}.offset-xxl-6{margin-left:50%}.offset-xxl-7{margin-left:58.3333333333%}.offset-xxl-8{margin-left:66.6666666667%}.offset-xxl-9{margin-left:75%}.offset-xxl-10{margin-left:83.3333333333%}.offset-xxl-11{margin-left:91.6666666667%}.g-xxl-0,.gx-xxl-0{--bs-gutter-x:0}.g-xxl-0,.gy-xxl-0{--bs-gutter-y:0}.g-xxl-1,.gx-xxl-1{--bs-gutter-x:0.25rem}.g-xxl-1,.gy-xxl-1{--bs-gutter-y:0.25rem}.g-xxl-2,.gx-xxl-2{--bs-gutter-x:0.5rem}.g-xxl-2,.gy-xxl-2{--bs-gutter-y:0.5rem}.g-xxl-3,.gx-xxl-3{--bs-gutter-x:1rem}.g-xxl-3,.gy-xxl-3{--bs-gutter-y:1rem}.g-xxl-4,.gx-xxl-4{--bs-gutter-x:1.5rem}.g-xxl-4,.gy-xxl-4{--bs-gutter-y:1.5rem}.g-xxl-5,.gx-xxl-5{--bs-gutter-x:3rem}.g-xxl-5,.gy-xxl-5{--bs-gutter-y:3rem}}.table{--bs-table-bg:transparent;--bs-table-striped-color:#212529;--bs-table-striped-bg:rgba(0, 0, 0, 0.05);--bs-table-active-color:#212529;--bs-table-active-bg:rgba(0, 0, 0, 0.1);--bs-table-hover-color:#212529;--bs-table-hover-bg:rgba(0, 0, 0, 0.075);width:100%;margin-bottom:1rem;color:#212529;vertical-align:top;border-color:#dee2e6}.table>:not(caption)>*>*{padding:.5rem .5rem;background-color:var(--bs-table-bg);border-bottom-width:1px;box-shadow:inset 0 0 0 9999px var(--bs-table-accent-bg)}.table>tbody{vertical-align:inherit}.table>thead{vertical-align:bottom}.table>:not(:last-child)>:last-child>*{border-bottom-color:currentColor}.caption-top{caption-side:top}.table-sm>:not(caption)>*>*{padding:.25rem .25rem}.table-bordered>:not(caption)>*{border-width:1px 0}.table-bordered>:not(caption)>*>*{border-width:0 1px}.table-borderless>:not(caption)>*>*{border-bottom-width:0}.table-striped>tbody>tr:nth-of-type(odd){--bs-table-accent-bg:var(--bs-table-striped-bg);color:var(--bs-table-striped-color)}.table-active{--bs-table-accent-bg:var(--bs-table-active-bg);color:var(--bs-table-active-color)}.table-hover>tbody>tr:hover{--bs-table-accent-bg:var(--bs-table-hover-bg);color:var(--bs-table-hover-color)}.table-primary{--bs-table-bg:#cfe2ff;--bs-table-striped-bg:#c5d7f2;--bs-table-striped-color:#000;--bs-table-active-bg:#bacbe6;--bs-table-active-color:#000;--bs-table-hover-bg:#bfd1ec;--bs-table-hover-color:#000;color:#000;border-color:#bacbe6}.table-secondary{--bs-table-bg:#e2e3e5;--bs-table-striped-bg:#d7d8da;--bs-table-striped-color:#000;--bs-table-active-bg:#cbccce;--bs-table-active-color:#000;--bs-table-hover-bg:#d1d2d4;--bs-table-hover-color:#000;color:#000;border-color:#cbccce}.table-success{--bs-table-bg:#d1e7dd;--bs-table-striped-bg:#c7dbd2;--bs-table-striped-color:#000;--bs-table-active-bg:#bcd0c7;--bs-table-active-color:#000;--bs-table-hover-bg:#c1d6cc;--bs-table-hover-color:#000;color:#000;border-color:#bcd0c7}.table-info{--bs-table-bg:#cff4fc;--bs-table-striped-bg:#c5e8ef;--bs-table-striped-color:#000;--bs-table-active-bg:#badce3;--bs-table-active-color:#000;--bs-table-hover-bg:#bfe2e9;--bs-table-hover-color:#000;color:#000;border-color:#badce3}.table-warning{--bs-table-bg:#fff3cd;--bs-table-striped-bg:#f2e7c3;--bs-table-striped-color:#000;--bs-table-active-bg:#e6dbb9;--bs-table-active-color:#000;--bs-table-hover-bg:#ece1be;--bs-table-hover-color:#000;color:#000;border-color:#e6dbb9}.table-danger{--bs-table-bg:#f8d7da;--bs-table-striped-bg:#eccccf;--bs-table-striped-color:#000;--bs-table-active-bg:#dfc2c4;--bs-table-active-color:#000;--bs-table-hover-bg:#e5c7ca;--bs-table-hover-color:#000;color:#000;border-color:#dfc2c4}.table-light{--bs-table-bg:#f8f9fa;--bs-table-striped-bg:#ecedee;--bs-table-striped-color:#000;--bs-table-active-bg:#dfe0e1;--bs-table-active-color:#000;--bs-table-hover-bg:#e5e6e7;--bs-table-hover-color:#000;color:#000;border-color:#dfe0e1}.table-dark{--bs-table-bg:#212529;--bs-table-striped-bg:#2c3034;--bs-table-striped-color:#fff;--bs-table-active-bg:#373b3e;--bs-table-active-color:#fff;--bs-table-hover-bg:#323539;--bs-table-hover-color:#fff;color:#fff;border-color:#373b3e}.table-responsive{overflow-x:auto;-webkit-overflow-scrolling:touch}@media (max-width:575.98px){.table-responsive-sm{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:767.98px){.table-responsive-md{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:991.98px){.table-responsive-lg{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:1199.98px){.table-responsive-xl{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:1399.98px){.table-responsive-xxl{overflow-x:auto;-webkit-overflow-scrolling:touch}}.form-label{margin-bottom:.5rem}.col-form-label{padding-top:calc(.375rem + 1px);padding-bottom:calc(.375rem + 1px);margin-bottom:0;font-size:inherit;line-height:1.5}.col-form-label-lg{padding-top:calc(.5rem + 1px);padding-bottom:calc(.5rem + 1px);font-size:1.25rem}.col-form-label-sm{padding-top:calc(.25rem + 1px);padding-bottom:calc(.25rem + 1px);font-size:.875rem}.form-text{margin-top:.25rem;font-size:.875em;color:#6c757d}.form-control{display:block;width:100%;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#212529;background-color:#fff;background-clip:padding-box;border:1px solid #ced4da;-webkit-appearance:none;-moz-appearance:none;appearance:none;border-radius:.25rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control[type=file]{overflow:hidden}.form-control[type=file]:not(:disabled):not([readonly]){cursor:pointer}.form-control:focus{color:#212529;background-color:#fff;border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-control::-webkit-date-and-time-value{height:1.5em}.form-control::-webkit-input-placeholder{color:#6c757d;opacity:1}.form-control::-moz-placeholder{color:#6c757d;opacity:1}.form-control::placeholder{color:#6c757d;opacity:1}.form-control:disabled,.form-control[readonly]{background-color:#e9ecef;opacity:1}.form-control::file-selector-button{padding:.375rem .75rem;margin:-.375rem -.75rem;-webkit-margin-end:.75rem;margin-inline-end:.75rem;color:#212529;background-color:#e9ecef;pointer-events:none;border-color:inherit;border-style:solid;border-width:0;border-inline-end-width:1px;border-radius:0;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control::file-selector-button{transition:none}}.form-control:hover:not(:disabled):not([readonly])::file-selector-button{background-color:#dde0e3}.form-control::-webkit-file-upload-button{padding:.375rem .75rem;margin:-.375rem -.75rem;-webkit-margin-end:.75rem;margin-inline-end:.75rem;color:#212529;background-color:#e9ecef;pointer-events:none;border-color:inherit;border-style:solid;border-width:0;border-inline-end-width:1px;border-radius:0;-webkit-transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control::-webkit-file-upload-button{-webkit-transition:none;transition:none}}.form-control:hover:not(:disabled):not([readonly])::-webkit-file-upload-button{background-color:#dde0e3}.form-control-plaintext{display:block;width:100%;padding:.375rem 0;margin-bottom:0;line-height:1.5;color:#212529;background-color:transparent;border:solid transparent;border-width:1px 0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-right:0;padding-left:0}.form-control-sm{min-height:calc(1.5em + .5rem + 2px);padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.form-control-sm::file-selector-button{padding:.25rem .5rem;margin:-.25rem -.5rem;-webkit-margin-end:.5rem;margin-inline-end:.5rem}.form-control-sm::-webkit-file-upload-button{padding:.25rem .5rem;margin:-.25rem -.5rem;-webkit-margin-end:.5rem;margin-inline-end:.5rem}.form-control-lg{min-height:calc(1.5em + 1rem + 2px);padding:.5rem 1rem;font-size:1.25rem;border-radius:.3rem}.form-control-lg::file-selector-button{padding:.5rem 1rem;margin:-.5rem -1rem;-webkit-margin-end:1rem;margin-inline-end:1rem}.form-control-lg::-webkit-file-upload-button{padding:.5rem 1rem;margin:-.5rem -1rem;-webkit-margin-end:1rem;margin-inline-end:1rem}textarea.form-control{min-height:calc(1.5em + .75rem + 2px)}textarea.form-control-sm{min-height:calc(1.5em + .5rem + 2px)}textarea.form-control-lg{min-height:calc(1.5em + 1rem + 2px)}.form-control-color{max-width:3rem;height:auto;padding:.375rem}.form-control-color:not(:disabled):not([readonly]){cursor:pointer}.form-control-color::-moz-color-swatch{height:1.5em;border-radius:.25rem}.form-control-color::-webkit-color-swatch{height:1.5em;border-radius:.25rem}.form-select{display:block;width:100%;padding:.375rem 2.25rem .375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#212529;background-color:#fff;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right .75rem center;background-size:16px 12px;border:1px solid #ced4da;border-radius:.25rem;-webkit-appearance:none;-moz-appearance:none;appearance:none}.form-select:focus{border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-select[multiple],.form-select[size]:not([size="1"]){padding-right:.75rem;background-image:none}.form-select:disabled{color:#6c757d;background-color:#e9ecef}.form-select:-moz-focusring{color:transparent;text-shadow:0 0 0 #212529}.form-select-sm{padding-top:.25rem;padding-bottom:.25rem;padding-left:.5rem;font-size:.875rem}.form-select-lg{padding-top:.5rem;padding-bottom:.5rem;padding-left:1rem;font-size:1.25rem}.form-check{display:block;min-height:1.5rem;padding-left:1.5em;margin-bottom:.125rem}.form-check .form-check-input{float:left;margin-left:-1.5em}.form-check-input{width:1em;height:1em;margin-top:.25em;vertical-align:top;background-color:#fff;background-repeat:no-repeat;background-position:center;background-size:contain;border:1px solid rgba(0,0,0,.25);-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-print-color-adjust:exact;color-adjust:exact}.form-check-input[type=checkbox]{border-radius:.25em}.form-check-input[type=radio]{border-radius:50%}.form-check-input:active{filter:brightness(90%)}.form-check-input:focus{border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-check-input:checked{background-color:#0d6efd;border-color:#0d6efd}.form-check-input:checked[type=checkbox]{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10l3 3l6-6'/%3e%3c/svg%3e")}.form-check-input:checked[type=radio]{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='2' fill='%23fff'/%3e%3c/svg%3e")}.form-check-input[type=checkbox]:indeterminate{background-color:#0d6efd;border-color:#0d6efd;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10h8'/%3e%3c/svg%3e")}.form-check-input:disabled{pointer-events:none;filter:none;opacity:.5}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{opacity:.5}.form-switch{padding-left:2.5em}.form-switch .form-check-input{width:2em;margin-left:-2.5em;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='rgba%280, 0, 0, 0.25%29'/%3e%3c/svg%3e");background-position:left center;border-radius:2em;transition:background-position .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-switch .form-check-input{transition:none}}.form-switch .form-check-input:focus{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%2386b7fe'/%3e%3c/svg%3e")}.form-switch .form-check-input:checked{background-position:right center;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%23fff'/%3e%3c/svg%3e")}.form-check-inline{display:inline-block;margin-right:1rem}.btn-check{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.btn-check:disabled+.btn,.btn-check[disabled]+.btn{pointer-events:none;filter:none;opacity:.65}.form-range{width:100%;height:1.5rem;padding:0;background-color:transparent;-webkit-appearance:none;-moz-appearance:none;appearance:none}.form-range:focus{outline:0}.form-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range::-moz-focus-outer{border:0}.form-range::-webkit-slider-thumb{width:1rem;height:1rem;margin-top:-.25rem;background-color:#0d6efd;border:0;border-radius:1rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.form-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.form-range::-webkit-slider-thumb:active{background-color:#b6d4fe}.form-range::-webkit-slider-runnable-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.form-range::-moz-range-thumb{width:1rem;height:1rem;background-color:#0d6efd;border:0;border-radius:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-moz-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.form-range::-moz-range-thumb{-moz-transition:none;transition:none}}.form-range::-moz-range-thumb:active{background-color:#b6d4fe}.form-range::-moz-range-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.form-range:disabled{pointer-events:none}.form-range:disabled::-webkit-slider-thumb{background-color:#adb5bd}.form-range:disabled::-moz-range-thumb{background-color:#adb5bd}.form-floating{position:relative}.form-floating>.form-control,.form-floating>.form-select{height:calc(3.5rem + 2px);padding:1rem .75rem}.form-floating>label{position:absolute;top:0;left:0;height:100%;padding:1rem .75rem;pointer-events:none;border:1px solid transparent;transform-origin:0 0;transition:opacity .1s ease-in-out,transform .1s ease-in-out}@media (prefers-reduced-motion:reduce){.form-floating>label{transition:none}}.form-floating>.form-control::-webkit-input-placeholder{color:transparent}.form-floating>.form-control::-moz-placeholder{color:transparent}.form-floating>.form-control::placeholder{color:transparent}.form-floating>.form-control:not(:-moz-placeholder-shown){padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control:focus,.form-floating>.form-control:not(:placeholder-shown){padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control:-webkit-autofill{padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-select{padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control:not(:-moz-placeholder-shown)~label{opacity:.65;transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control:focus~label,.form-floating>.form-control:not(:placeholder-shown)~label,.form-floating>.form-select~label{opacity:.65;transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control:-webkit-autofill~label{opacity:.65;transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.input-group{position:relative;display:flex;flex-wrap:wrap;align-items:stretch;width:100%}.input-group>.form-control,.input-group>.form-select{position:relative;flex:1 1 auto;width:1%;min-width:0}.input-group>.form-control:focus,.input-group>.form-select:focus{z-index:3}.input-group .btn{position:relative;z-index:2}.input-group .btn:focus{z-index:3}.input-group-text{display:flex;align-items:center;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#212529;text-align:center;white-space:nowrap;background-color:#e9ecef;border:1px solid #ced4da;border-radius:.25rem}.input-group-lg>.btn,.input-group-lg>.form-control,.input-group-lg>.form-select,.input-group-lg>.input-group-text{padding:.5rem 1rem;font-size:1.25rem;border-radius:.3rem}.input-group-sm>.btn,.input-group-sm>.form-control,.input-group-sm>.form-select,.input-group-sm>.input-group-text{padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.input-group-lg>.form-select,.input-group-sm>.form-select{padding-right:3rem}.input-group:not(.has-validation)>.dropdown-toggle:nth-last-child(n+3),.input-group:not(.has-validation)>:not(:last-child):not(.dropdown-toggle):not(.dropdown-menu){border-top-right-radius:0;border-bottom-right-radius:0}.input-group.has-validation>.dropdown-toggle:nth-last-child(n+4),.input-group.has-validation>:nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu){border-top-right-radius:0;border-bottom-right-radius:0}.input-group>:not(:first-child):not(.dropdown-menu):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback){margin-left:-1px;border-top-left-radius:0;border-bottom-left-radius:0}.valid-feedback{display:none;width:100%;margin-top:.25rem;font-size:.875em;color:#198754}.valid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;color:#fff;background-color:rgba(25,135,84,.9);border-radius:.25rem}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{border-color:#198754;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:#198754;box-shadow:0 0 0 .25rem rgba(25,135,84,.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.form-select.is-valid,.was-validated .form-select:valid{border-color:#198754;padding-right:4.125rem;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e"),url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem)}.form-select.is-valid:focus,.was-validated .form-select:valid:focus{border-color:#198754;box-shadow:0 0 0 .25rem rgba(25,135,84,.25)}.form-check-input.is-valid,.was-validated .form-check-input:valid{border-color:#198754}.form-check-input.is-valid:checked,.was-validated .form-check-input:valid:checked{background-color:#198754}.form-check-input.is-valid:focus,.was-validated .form-check-input:valid:focus{box-shadow:0 0 0 .25rem rgba(25,135,84,.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:#198754}.form-check-inline .form-check-input~.valid-feedback{margin-left:.5em}.invalid-feedback{display:none;width:100%;margin-top:.25rem;font-size:.875em;color:#dc3545}.invalid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;color:#fff;background-color:rgba(220,53,69,.9);border-radius:.25rem}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{border-color:#dc3545;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .25rem rgba(220,53,69,.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.form-select.is-invalid,.was-validated .form-select:invalid{border-color:#dc3545;padding-right:4.125rem;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e"),url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem)}.form-select.is-invalid:focus,.was-validated .form-select:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .25rem rgba(220,53,69,.25)}.form-check-input.is-invalid,.was-validated .form-check-input:invalid{border-color:#dc3545}.form-check-input.is-invalid:checked,.was-validated .form-check-input:invalid:checked{background-color:#dc3545}.form-check-input.is-invalid:focus,.was-validated .form-check-input:invalid:focus{box-shadow:0 0 0 .25rem rgba(220,53,69,.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:#dc3545}.form-check-inline .form-check-input~.invalid-feedback{margin-left:.5em}.btn{display:inline-block;font-weight:400;line-height:1.5;color:#212529;text-align:center;text-decoration:none;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;background-color:transparent;border:1px solid transparent;padding:.375rem .75rem;font-size:1rem;border-radius:.25rem;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{color:#212529}.btn-check:focus+.btn,.btn:focus{outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.btn.disabled,.btn:disabled,fieldset:disabled .btn{pointer-events:none;opacity:.65}.btn-primary{color:#fff;background-color:#0d6efd;border-color:#0d6efd}.btn-primary:hover{color:#fff;background-color:#0b5ed7;border-color:#0a58ca}.btn-check:focus+.btn-primary,.btn-primary:focus{color:#fff;background-color:#0b5ed7;border-color:#0a58ca;box-shadow:0 0 0 .25rem rgba(49,132,253,.5)}.btn-check:active+.btn-primary,.btn-check:checked+.btn-primary,.btn-primary.active,.btn-primary:active,.show>.btn-primary.dropdown-toggle{color:#fff;background-color:#0a58ca;border-color:#0a53be}.btn-check:active+.btn-primary:focus,.btn-check:checked+.btn-primary:focus,.btn-primary.active:focus,.btn-primary:active:focus,.show>.btn-primary.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(49,132,253,.5)}.btn-primary.disabled,.btn-primary:disabled{color:#fff;background-color:#0d6efd;border-color:#0d6efd}.btn-secondary{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:hover{color:#fff;background-color:#5c636a;border-color:#565e64}.btn-check:focus+.btn-secondary,.btn-secondary:focus{color:#fff;background-color:#5c636a;border-color:#565e64;box-shadow:0 0 0 .25rem rgba(130,138,145,.5)}.btn-check:active+.btn-secondary,.btn-check:checked+.btn-secondary,.btn-secondary.active,.btn-secondary:active,.show>.btn-secondary.dropdown-toggle{color:#fff;background-color:#565e64;border-color:#51585e}.btn-check:active+.btn-secondary:focus,.btn-check:checked+.btn-secondary:focus,.btn-secondary.active:focus,.btn-secondary:active:focus,.show>.btn-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(130,138,145,.5)}.btn-secondary.disabled,.btn-secondary:disabled{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-success{color:#fff;background-color:#198754;border-color:#198754}.btn-success:hover{color:#fff;background-color:#157347;border-color:#146c43}.btn-check:focus+.btn-success,.btn-success:focus{color:#fff;background-color:#157347;border-color:#146c43;box-shadow:0 0 0 .25rem rgba(60,153,110,.5)}.btn-check:active+.btn-success,.btn-check:checked+.btn-success,.btn-success.active,.btn-success:active,.show>.btn-success.dropdown-toggle{color:#fff;background-color:#146c43;border-color:#13653f}.btn-check:active+.btn-success:focus,.btn-check:checked+.btn-success:focus,.btn-success.active:focus,.btn-success:active:focus,.show>.btn-success.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(60,153,110,.5)}.btn-success.disabled,.btn-success:disabled{color:#fff;background-color:#198754;border-color:#198754}.btn-info{color:#000;background-color:#0dcaf0;border-color:#0dcaf0}.btn-info:hover{color:#000;background-color:#31d2f2;border-color:#25cff2}.btn-check:focus+.btn-info,.btn-info:focus{color:#000;background-color:#31d2f2;border-color:#25cff2;box-shadow:0 0 0 .25rem rgba(11,172,204,.5)}.btn-check:active+.btn-info,.btn-check:checked+.btn-info,.btn-info.active,.btn-info:active,.show>.btn-info.dropdown-toggle{color:#000;background-color:#3dd5f3;border-color:#25cff2}.btn-check:active+.btn-info:focus,.btn-check:checked+.btn-info:focus,.btn-info.active:focus,.btn-info:active:focus,.show>.btn-info.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(11,172,204,.5)}.btn-info.disabled,.btn-info:disabled{color:#000;background-color:#0dcaf0;border-color:#0dcaf0}.btn-warning{color:#000;background-color:#ffc107;border-color:#ffc107}.btn-warning:hover{color:#000;background-color:#ffca2c;border-color:#ffc720}.btn-check:focus+.btn-warning,.btn-warning:focus{color:#000;background-color:#ffca2c;border-color:#ffc720;box-shadow:0 0 0 .25rem rgba(217,164,6,.5)}.btn-check:active+.btn-warning,.btn-check:checked+.btn-warning,.btn-warning.active,.btn-warning:active,.show>.btn-warning.dropdown-toggle{color:#000;background-color:#ffcd39;border-color:#ffc720}.btn-check:active+.btn-warning:focus,.btn-check:checked+.btn-warning:focus,.btn-warning.active:focus,.btn-warning:active:focus,.show>.btn-warning.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(217,164,6,.5)}.btn-warning.disabled,.btn-warning:disabled{color:#000;background-color:#ffc107;border-color:#ffc107}.btn-danger{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:hover{color:#fff;background-color:#bb2d3b;border-color:#b02a37}.btn-check:focus+.btn-danger,.btn-danger:focus{color:#fff;background-color:#bb2d3b;border-color:#b02a37;box-shadow:0 0 0 .25rem rgba(225,83,97,.5)}.btn-check:active+.btn-danger,.btn-check:checked+.btn-danger,.btn-danger.active,.btn-danger:active,.show>.btn-danger.dropdown-toggle{color:#fff;background-color:#b02a37;border-color:#a52834}.btn-check:active+.btn-danger:focus,.btn-check:checked+.btn-danger:focus,.btn-danger.active:focus,.btn-danger:active:focus,.show>.btn-danger.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(225,83,97,.5)}.btn-danger.disabled,.btn-danger:disabled{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-light{color:#000;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:hover{color:#000;background-color:#f9fafb;border-color:#f9fafb}.btn-check:focus+.btn-light,.btn-light:focus{color:#000;background-color:#f9fafb;border-color:#f9fafb;box-shadow:0 0 0 .25rem rgba(211,212,213,.5)}.btn-check:active+.btn-light,.btn-check:checked+.btn-light,.btn-light.active,.btn-light:active,.show>.btn-light.dropdown-toggle{color:#000;background-color:#f9fafb;border-color:#f9fafb}.btn-check:active+.btn-light:focus,.btn-check:checked+.btn-light:focus,.btn-light.active:focus,.btn-light:active:focus,.show>.btn-light.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(211,212,213,.5)}.btn-light.disabled,.btn-light:disabled{color:#000;background-color:#f8f9fa;border-color:#f8f9fa}.btn-dark{color:#fff;background-color:#212529;border-color:#212529}.btn-dark:hover{color:#fff;background-color:#1c1f23;border-color:#1a1e21}.btn-check:focus+.btn-dark,.btn-dark:focus{color:#fff;background-color:#1c1f23;border-color:#1a1e21;box-shadow:0 0 0 .25rem rgba(66,70,73,.5)}.btn-check:active+.btn-dark,.btn-check:checked+.btn-dark,.btn-dark.active,.btn-dark:active,.show>.btn-dark.dropdown-toggle{color:#fff;background-color:#1a1e21;border-color:#191c1f}.btn-check:active+.btn-dark:focus,.btn-check:checked+.btn-dark:focus,.btn-dark.active:focus,.btn-dark:active:focus,.show>.btn-dark.dropdown-toggle:focus{box-shadow:0 0 0 .25rem rgba(66,70,73,.5)}.btn-dark.disabled,.btn-dark:disabled{color:#fff;background-color:#212529;border-color:#212529}.btn-outline-primary{color:#0d6efd;border-color:#0d6efd}.btn-outline-primary:hover{color:#fff;background-color:#0d6efd;border-color:#0d6efd}.btn-check:focus+.btn-outline-primary,.btn-outline-primary:focus{box-shadow:0 0 0 .25rem rgba(13,110,253,.5)}.btn-check:active+.btn-outline-primary,.btn-check:checked+.btn-outline-primary,.btn-outline-primary.active,.btn-outline-primary.dropdown-toggle.show,.btn-outline-primary:active{color:#fff;background-color:#0d6efd;border-color:#0d6efd}.btn-check:active+.btn-outline-primary:focus,.btn-check:checked+.btn-outline-primary:focus,.btn-outline-primary.active:focus,.btn-outline-primary.dropdown-toggle.show:focus,.btn-outline-primary:active:focus{box-shadow:0 0 0 .25rem rgba(13,110,253,.5)}.btn-outline-primary.disabled,.btn-outline-primary:disabled{color:#0d6efd;background-color:transparent}.btn-outline-secondary{color:#6c757d;border-color:#6c757d}.btn-outline-secondary:hover{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-check:focus+.btn-outline-secondary,.btn-outline-secondary:focus{box-shadow:0 0 0 .25rem rgba(108,117,125,.5)}.btn-check:active+.btn-outline-secondary,.btn-check:checked+.btn-outline-secondary,.btn-outline-secondary.active,.btn-outline-secondary.dropdown-toggle.show,.btn-outline-secondary:active{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-check:active+.btn-outline-secondary:focus,.btn-check:checked+.btn-outline-secondary:focus,.btn-outline-secondary.active:focus,.btn-outline-secondary.dropdown-toggle.show:focus,.btn-outline-secondary:active:focus{box-shadow:0 0 0 .25rem rgba(108,117,125,.5)}.btn-outline-secondary.disabled,.btn-outline-secondary:disabled{color:#6c757d;background-color:transparent}.btn-outline-success{color:#198754;border-color:#198754}.btn-outline-success:hover{color:#fff;background-color:#198754;border-color:#198754}.btn-check:focus+.btn-outline-success,.btn-outline-success:focus{box-shadow:0 0 0 .25rem rgba(25,135,84,.5)}.btn-check:active+.btn-outline-success,.btn-check:checked+.btn-outline-success,.btn-outline-success.active,.btn-outline-success.dropdown-toggle.show,.btn-outline-success:active{color:#fff;background-color:#198754;border-color:#198754}.btn-check:active+.btn-outline-success:focus,.btn-check:checked+.btn-outline-success:focus,.btn-outline-success.active:focus,.btn-outline-success.dropdown-toggle.show:focus,.btn-outline-success:active:focus{box-shadow:0 0 0 .25rem rgba(25,135,84,.5)}.btn-outline-success.disabled,.btn-outline-success:disabled{color:#198754;background-color:transparent}.btn-outline-info{color:#0dcaf0;border-color:#0dcaf0}.btn-outline-info:hover{color:#000;background-color:#0dcaf0;border-color:#0dcaf0}.btn-check:focus+.btn-outline-info,.btn-outline-info:focus{box-shadow:0 0 0 .25rem rgba(13,202,240,.5)}.btn-check:active+.btn-outline-info,.btn-check:checked+.btn-outline-info,.btn-outline-info.active,.btn-outline-info.dropdown-toggle.show,.btn-outline-info:active{color:#000;background-color:#0dcaf0;border-color:#0dcaf0}.btn-check:active+.btn-outline-info:focus,.btn-check:checked+.btn-outline-info:focus,.btn-outline-info.active:focus,.btn-outline-info.dropdown-toggle.show:focus,.btn-outline-info:active:focus{box-shadow:0 0 0 .25rem rgba(13,202,240,.5)}.btn-outline-info.disabled,.btn-outline-info:disabled{color:#0dcaf0;background-color:transparent}.btn-outline-warning{color:#ffc107;border-color:#ffc107}.btn-outline-warning:hover{color:#000;background-color:#ffc107;border-color:#ffc107}.btn-check:focus+.btn-outline-warning,.btn-outline-warning:focus{box-shadow:0 0 0 .25rem rgba(255,193,7,.5)}.btn-check:active+.btn-outline-warning,.btn-check:checked+.btn-outline-warning,.btn-outline-warning.active,.btn-outline-warning.dropdown-toggle.show,.btn-outline-warning:active{color:#000;background-color:#ffc107;border-color:#ffc107}.btn-check:active+.btn-outline-warning:focus,.btn-check:checked+.btn-outline-warning:focus,.btn-outline-warning.active:focus,.btn-outline-warning.dropdown-toggle.show:focus,.btn-outline-warning:active:focus{box-shadow:0 0 0 .25rem rgba(255,193,7,.5)}.btn-outline-warning.disabled,.btn-outline-warning:disabled{color:#ffc107;background-color:transparent}.btn-outline-danger{color:#dc3545;border-color:#dc3545}.btn-outline-danger:hover{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-check:focus+.btn-outline-danger,.btn-outline-danger:focus{box-shadow:0 0 0 .25rem rgba(220,53,69,.5)}.btn-check:active+.btn-outline-danger,.btn-check:checked+.btn-outline-danger,.btn-outline-danger.active,.btn-outline-danger.dropdown-toggle.show,.btn-outline-danger:active{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-check:active+.btn-outline-danger:focus,.btn-check:checked+.btn-outline-danger:focus,.btn-outline-danger.active:focus,.btn-outline-danger.dropdown-toggle.show:focus,.btn-outline-danger:active:focus{box-shadow:0 0 0 .25rem rgba(220,53,69,.5)}.btn-outline-danger.disabled,.btn-outline-danger:disabled{color:#dc3545;background-color:transparent}.btn-outline-light{color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:hover{color:#000;background-color:#f8f9fa;border-color:#f8f9fa}.btn-check:focus+.btn-outline-light,.btn-outline-light:focus{box-shadow:0 0 0 .25rem rgba(248,249,250,.5)}.btn-check:active+.btn-outline-light,.btn-check:checked+.btn-outline-light,.btn-outline-light.active,.btn-outline-light.dropdown-toggle.show,.btn-outline-light:active{color:#000;background-color:#f8f9fa;border-color:#f8f9fa}.btn-check:active+.btn-outline-light:focus,.btn-check:checked+.btn-outline-light:focus,.btn-outline-light.active:focus,.btn-outline-light.dropdown-toggle.show:focus,.btn-outline-light:active:focus{box-shadow:0 0 0 .25rem rgba(248,249,250,.5)}.btn-outline-light.disabled,.btn-outline-light:disabled{color:#f8f9fa;background-color:transparent}.btn-outline-dark{color:#212529;border-color:#212529}.btn-outline-dark:hover{color:#fff;background-color:#212529;border-color:#212529}.btn-check:focus+.btn-outline-dark,.btn-outline-dark:focus{box-shadow:0 0 0 .25rem rgba(33,37,41,.5)}.btn-check:active+.btn-outline-dark,.btn-check:checked+.btn-outline-dark,.btn-outline-dark.active,.btn-outline-dark.dropdown-toggle.show,.btn-outline-dark:active{color:#fff;background-color:#212529;border-color:#212529}.btn-check:active+.btn-outline-dark:focus,.btn-check:checked+.btn-outline-dark:focus,.btn-outline-dark.active:focus,.btn-outline-dark.dropdown-toggle.show:focus,.btn-outline-dark:active:focus{box-shadow:0 0 0 .25rem rgba(33,37,41,.5)}.btn-outline-dark.disabled,.btn-outline-dark:disabled{color:#212529;background-color:transparent}.btn-link{font-weight:400;color:#0d6efd;text-decoration:underline}.btn-link:hover{color:#0a58ca}.btn-link.disabled,.btn-link:disabled{color:#6c757d}.btn-group-lg>.btn,.btn-lg{padding:.5rem 1rem;font-size:1.25rem;border-radius:.3rem}.btn-group-sm>.btn,.btn-sm{padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.dropdown,.dropend,.dropstart,.dropup{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid;border-right:.3em solid transparent;border-bottom:0;border-left:.3em solid transparent}.dropdown-toggle:empty::after{margin-left:0}.dropdown-menu{position:absolute;top:100%;z-index:1000;display:none;min-width:10rem;padding:.5rem 0;margin:0;font-size:1rem;color:#212529;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.dropdown-menu[data-bs-popper]{left:0;margin-top:.125rem}.dropdown-menu-start{--bs-position:start}.dropdown-menu-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-end{--bs-position:end}.dropdown-menu-end[data-bs-popper]{right:0;left:auto}@media (min-width:576px){.dropdown-menu-sm-start{--bs-position:start}.dropdown-menu-sm-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-sm-end{--bs-position:end}.dropdown-menu-sm-end[data-bs-popper]{right:0;left:auto}}@media (min-width:768px){.dropdown-menu-md-start{--bs-position:start}.dropdown-menu-md-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-md-end{--bs-position:end}.dropdown-menu-md-end[data-bs-popper]{right:0;left:auto}}@media (min-width:992px){.dropdown-menu-lg-start{--bs-position:start}.dropdown-menu-lg-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-lg-end{--bs-position:end}.dropdown-menu-lg-end[data-bs-popper]{right:0;left:auto}}@media (min-width:1200px){.dropdown-menu-xl-start{--bs-position:start}.dropdown-menu-xl-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-xl-end{--bs-position:end}.dropdown-menu-xl-end[data-bs-popper]{right:0;left:auto}}@media (min-width:1400px){.dropdown-menu-xxl-start{--bs-position:start}.dropdown-menu-xxl-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-xxl-end{--bs-position:end}.dropdown-menu-xxl-end[data-bs-popper]{right:0;left:auto}}.dropup .dropdown-menu{top:auto;bottom:100%}.dropup .dropdown-menu[data-bs-popper]{margin-top:0;margin-bottom:.125rem}.dropup .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:0;border-right:.3em solid transparent;border-bottom:.3em solid;border-left:.3em solid transparent}.dropup .dropdown-toggle:empty::after{margin-left:0}.dropend .dropdown-menu{top:0;right:auto;left:100%}.dropend .dropdown-menu[data-bs-popper]{margin-top:0;margin-left:.125rem}.dropend .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:0;border-bottom:.3em solid transparent;border-left:.3em solid}.dropend .dropdown-toggle:empty::after{margin-left:0}.dropend .dropdown-toggle::after{vertical-align:0}.dropstart .dropdown-menu{top:0;right:100%;left:auto}.dropstart .dropdown-menu[data-bs-popper]{margin-top:0;margin-right:.125rem}.dropstart .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:""}.dropstart .dropdown-toggle::after{display:none}.dropstart .dropdown-toggle::before{display:inline-block;margin-right:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:.3em solid;border-bottom:.3em solid transparent}.dropstart .dropdown-toggle:empty::after{margin-left:0}.dropstart .dropdown-toggle::before{vertical-align:0}.dropdown-divider{height:0;margin:.5rem 0;overflow:hidden;border-top:1px solid rgba(0,0,0,.15)}.dropdown-item{display:block;width:100%;padding:.25rem 1rem;clear:both;font-weight:400;color:#212529;text-align:inherit;text-decoration:none;white-space:nowrap;background-color:transparent;border:0}.dropdown-item:focus,.dropdown-item:hover{color:#1e2125;background-color:#e9ecef}.dropdown-item.active,.dropdown-item:active{color:#fff;text-decoration:none;background-color:#0d6efd}.dropdown-item.disabled,.dropdown-item:disabled{color:#adb5bd;pointer-events:none;background-color:transparent}.dropdown-menu.show{display:block}.dropdown-header{display:block;padding:.5rem 1rem;margin-bottom:0;font-size:.875rem;color:#6c757d;white-space:nowrap}.dropdown-item-text{display:block;padding:.25rem 1rem;color:#212529}.dropdown-menu-dark{color:#dee2e6;background-color:#343a40;border-color:rgba(0,0,0,.15)}.dropdown-menu-dark .dropdown-item{color:#dee2e6}.dropdown-menu-dark .dropdown-item:focus,.dropdown-menu-dark .dropdown-item:hover{color:#fff;background-color:rgba(255,255,255,.15)}.dropdown-menu-dark .dropdown-item.active,.dropdown-menu-dark .dropdown-item:active{color:#fff;background-color:#0d6efd}.dropdown-menu-dark .dropdown-item.disabled,.dropdown-menu-dark .dropdown-item:disabled{color:#adb5bd}.dropdown-menu-dark .dropdown-divider{border-color:rgba(0,0,0,.15)}.dropdown-menu-dark .dropdown-item-text{color:#dee2e6}.dropdown-menu-dark .dropdown-header{color:#adb5bd}.btn-group,.btn-group-vertical{position:relative;display:inline-flex;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;flex:1 1 auto}.btn-group-vertical>.btn-check:checked+.btn,.btn-group-vertical>.btn-check:focus+.btn,.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn-check:checked+.btn,.btn-group>.btn-check:focus+.btn,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:1}.btn-toolbar{display:flex;flex-wrap:wrap;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group>.btn-group:not(:first-child),.btn-group>.btn:not(:first-child){margin-left:-1px}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:nth-child(n+3),.btn-group>:not(.btn-check)+.btn{border-top-left-radius:0;border-bottom-left-radius:0}.dropdown-toggle-split{padding-right:.5625rem;padding-left:.5625rem}.dropdown-toggle-split::after,.dropend .dropdown-toggle-split::after,.dropup .dropdown-toggle-split::after{margin-left:0}.dropstart .dropdown-toggle-split::before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-right:.375rem;padding-left:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-right:.75rem;padding-left:.75rem}.btn-group-vertical{flex-direction:column;align-items:flex-start;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:-1px}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn~.btn{border-top-left-radius:0;border-top-right-radius:0}.nav{display:flex;flex-wrap:wrap;padding-left:0;margin-bottom:0;list-style:none}.nav-link{display:block;padding:.5rem 1rem;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out}@media (prefers-reduced-motion:reduce){.nav-link{transition:none}}.nav-link.disabled{color:#6c757d;pointer-events:none;cursor:default}.nav-tabs{border-bottom:1px solid #dee2e6}.nav-tabs .nav-link{margin-bottom:-1px;background:0 0;border:1px solid transparent;border-top-left-radius:.25rem;border-top-right-radius:.25rem}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:#e9ecef #e9ecef #dee2e6;isolation:isolate}.nav-tabs .nav-link.disabled{color:#6c757d;background-color:transparent;border-color:transparent}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{color:#495057;background-color:#fff;border-color:#dee2e6 #dee2e6 #fff}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.nav-pills .nav-link{background:0 0;border:0;border-radius:.25rem}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{color:#fff;background-color:#0d6efd}.nav-fill .nav-item,.nav-fill>.nav-link{flex:1 1 auto;text-align:center}.nav-justified .nav-item,.nav-justified>.nav-link{flex-basis:0;flex-grow:1;text-align:center}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{position:relative;display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;padding-top:.5rem;padding-bottom:.5rem}.navbar>.container,.navbar>.container-fluid,.navbar>.container-lg,.navbar>.container-md,.navbar>.container-sm,.navbar>.container-xl,.navbar>.container-xxl{display:flex;flex-wrap:inherit;align-items:center;justify-content:space-between}.navbar-brand{padding-top:.3125rem;padding-bottom:.3125rem;margin-right:1rem;font-size:1.25rem;text-decoration:none;white-space:nowrap}.navbar-nav{display:flex;flex-direction:column;padding-left:0;margin-bottom:0;list-style:none}.navbar-nav .nav-link{padding-right:0;padding-left:0}.navbar-nav .dropdown-menu{position:static}.navbar-text{padding-top:.5rem;padding-bottom:.5rem}.navbar-collapse{flex-basis:100%;flex-grow:1;align-items:center}.navbar-toggler{padding:.25rem .75rem;font-size:1.25rem;line-height:1;background-color:transparent;border:1px solid transparent;border-radius:.25rem;transition:box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.navbar-toggler{transition:none}}.navbar-toggler:hover{text-decoration:none}.navbar-toggler:focus{text-decoration:none;outline:0;box-shadow:0 0 0 .25rem}.navbar-toggler-icon{display:inline-block;width:1.5em;height:1.5em;vertical-align:middle;background-repeat:no-repeat;background-position:center;background-size:100%}.navbar-nav-scroll{max-height:var(--bs-scroll-height,75vh);overflow-y:auto}@media (min-width:576px){.navbar-expand-sm{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-sm .navbar-nav{flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-sm .navbar-nav-scroll{overflow:visible}.navbar-expand-sm .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}}@media (min-width:768px){.navbar-expand-md{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-md .navbar-nav{flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-md .navbar-nav-scroll{overflow:visible}.navbar-expand-md .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}}@media (min-width:992px){.navbar-expand-lg{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-lg .navbar-nav{flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-lg .navbar-nav-scroll{overflow:visible}.navbar-expand-lg .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}}@media (min-width:1200px){.navbar-expand-xl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xl .navbar-nav{flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-xl .navbar-nav-scroll{overflow:visible}.navbar-expand-xl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}}@media (min-width:1400px){.navbar-expand-xxl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xxl .navbar-nav{flex-direction:row}.navbar-expand-xxl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xxl .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-xxl .navbar-nav-scroll{overflow:visible}.navbar-expand-xxl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xxl .navbar-toggler{display:none}}.navbar-expand{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand .navbar-nav{flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand .navbar-nav-scroll{overflow:visible}.navbar-expand .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-light .navbar-brand{color:rgba(0,0,0,.9)}.navbar-light .navbar-brand:focus,.navbar-light .navbar-brand:hover{color:rgba(0,0,0,.9)}.navbar-light .navbar-nav .nav-link{color:rgba(0,0,0,.55)}.navbar-light .navbar-nav .nav-link:focus,.navbar-light .navbar-nav .nav-link:hover{color:rgba(0,0,0,.7)}.navbar-light .navbar-nav .nav-link.disabled{color:rgba(0,0,0,.3)}.navbar-light .navbar-nav .nav-link.active,.navbar-light .navbar-nav .show>.nav-link{color:rgba(0,0,0,.9)}.navbar-light .navbar-toggler{color:rgba(0,0,0,.55);border-color:rgba(0,0,0,.1)}.navbar-light .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%280, 0, 0, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-light .navbar-text{color:rgba(0,0,0,.55)}.navbar-light .navbar-text a,.navbar-light .navbar-text a:focus,.navbar-light .navbar-text a:hover{color:rgba(0,0,0,.9)}.navbar-dark .navbar-brand{color:#fff}.navbar-dark .navbar-brand:focus,.navbar-dark .navbar-brand:hover{color:#fff}.navbar-dark .navbar-nav .nav-link{color:rgba(255,255,255,.55)}.navbar-dark .navbar-nav .nav-link:focus,.navbar-dark .navbar-nav .nav-link:hover{color:rgba(255,255,255,.75)}.navbar-dark .navbar-nav .nav-link.disabled{color:rgba(255,255,255,.25)}.navbar-dark .navbar-nav .nav-link.active,.navbar-dark .navbar-nav .show>.nav-link{color:#fff}.navbar-dark .navbar-toggler{color:rgba(255,255,255,.55);border-color:rgba(255,255,255,.1)}.navbar-dark .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-dark .navbar-text{color:rgba(255,255,255,.55)}.navbar-dark .navbar-text a,.navbar-dark .navbar-text a:focus,.navbar-dark .navbar-text a:hover{color:#fff}.card{position:relative;display:flex;flex-direction:column;min-width:0;word-wrap:break-word;background-color:#fff;background-clip:border-box;border:1px solid rgba(0,0,0,.125);border-radius:.25rem}.card>hr{margin-right:0;margin-left:0}.card>.list-group{border-top:inherit;border-bottom:inherit}.card>.list-group:first-child{border-top-width:0;border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card>.list-group:last-child{border-bottom-width:0;border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card>.card-header+.list-group,.card>.list-group+.card-footer{border-top:0}.card-body{flex:1 1 auto;padding:1rem 1rem}.card-title{margin-bottom:.5rem}.card-subtitle{margin-top:-.25rem;margin-bottom:0}.card-text:last-child{margin-bottom:0}.card-link:hover{text-decoration:none}.card-link+.card-link{margin-left:1rem}.card-header{padding:.5rem 1rem;margin-bottom:0;background-color:rgba(0,0,0,.03);border-bottom:1px solid rgba(0,0,0,.125)}.card-header:first-child{border-radius:calc(.25rem - 1px) calc(.25rem - 1px) 0 0}.card-footer{padding:.5rem 1rem;background-color:rgba(0,0,0,.03);border-top:1px solid rgba(0,0,0,.125)}.card-footer:last-child{border-radius:0 0 calc(.25rem - 1px) calc(.25rem - 1px)}.card-header-tabs{margin-right:-.5rem;margin-bottom:-.5rem;margin-left:-.5rem;border-bottom:0}.card-header-pills{margin-right:-.5rem;margin-left:-.5rem}.card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(.25rem - 1px)}.card-img,.card-img-bottom,.card-img-top{width:100%}.card-img,.card-img-top{border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card-img,.card-img-bottom{border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card-group>.card{margin-bottom:.75rem}@media (min-width:576px){.card-group{display:flex;flex-flow:row wrap}.card-group>.card{flex:1 0 0%;margin-bottom:0}.card-group>.card+.card{margin-left:0;border-left:0}.card-group>.card:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.accordion-button{position:relative;display:flex;align-items:center;width:100%;padding:1rem 1.25rem;font-size:1rem;color:#212529;text-align:left;background-color:transparent;border:1px solid rgba(0,0,0,.125);border-radius:0;overflow-anchor:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out,border-radius .15s ease}@media (prefers-reduced-motion:reduce){.accordion-button{transition:none}}.accordion-button.collapsed{border-bottom-width:0}.accordion-button:not(.collapsed){color:#0c63e4;background-color:#e7f1ff}.accordion-button:not(.collapsed)::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%230c63e4'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");transform:rotate(180deg)}.accordion-button::after{flex-shrink:0;width:1.25rem;height:1.25rem;margin-left:auto;content:"";background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23212529'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");background-repeat:no-repeat;background-size:1.25rem;transition:transform .2s ease-in-out}@media (prefers-reduced-motion:reduce){.accordion-button::after{transition:none}}.accordion-button:hover{z-index:2}.accordion-button:focus{z-index:3;border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.accordion-header{margin-bottom:0}.accordion-item:first-of-type .accordion-button{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.accordion-item:last-of-type .accordion-button.collapsed{border-bottom-width:1px;border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.accordion-item:last-of-type .accordion-collapse{border-bottom-width:1px;border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.accordion-collapse{border:solid rgba(0,0,0,.125);border-width:0 1px}.accordion-body{padding:1rem 1.25rem}.accordion-flush .accordion-button{border-right:0;border-left:0;border-radius:0}.accordion-flush .accordion-collapse{border-width:0}.accordion-flush .accordion-item:first-of-type .accordion-button{border-top-width:0;border-top-left-radius:0;border-top-right-radius:0}.accordion-flush .accordion-item:last-of-type .accordion-button.collapsed{border-bottom-width:0;border-bottom-right-radius:0;border-bottom-left-radius:0}.breadcrumb{display:flex;flex-wrap:wrap;padding:0 0;margin-bottom:1rem;list-style:none}.breadcrumb-item+.breadcrumb-item{padding-left:.5rem}.breadcrumb-item+.breadcrumb-item::before{float:left;padding-right:.5rem;color:#6c757d;content:var(--bs-breadcrumb-divider, "/")}.breadcrumb-item.active{color:#6c757d}.pagination{display:flex;padding-left:0;list-style:none}.page-link{position:relative;display:block;color:#0d6efd;text-decoration:none;background-color:#fff;border:1px solid #dee2e6;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.page-link{transition:none}}.page-link:hover{z-index:2;color:#0a58ca;background-color:#e9ecef;border-color:#dee2e6}.page-link:focus{z-index:3;color:#0a58ca;background-color:#e9ecef;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.page-item:not(:first-child) .page-link{margin-left:-1px}.page-item.active .page-link{z-index:3;color:#fff;background-color:#0d6efd;border-color:#0d6efd}.page-item.disabled .page-link{color:#6c757d;pointer-events:none;background-color:#fff;border-color:#dee2e6}.page-link{padding:.375rem .75rem}.page-item:first-child .page-link{border-top-left-radius:.25rem;border-bottom-left-radius:.25rem}.page-item:last-child .page-link{border-top-right-radius:.25rem;border-bottom-right-radius:.25rem}.pagination-lg .page-link{padding:.75rem 1.5rem;font-size:1.25rem}.pagination-lg .page-item:first-child .page-link{border-top-left-radius:.3rem;border-bottom-left-radius:.3rem}.pagination-lg .page-item:last-child .page-link{border-top-right-radius:.3rem;border-bottom-right-radius:.3rem}.pagination-sm .page-link{padding:.25rem .5rem;font-size:.875rem}.pagination-sm .page-item:first-child .page-link{border-top-left-radius:.2rem;border-bottom-left-radius:.2rem}.pagination-sm .page-item:last-child .page-link{border-top-right-radius:.2rem;border-bottom-right-radius:.2rem}.badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.alert{position:relative;padding:1rem 1rem;margin-bottom:1rem;border:1px solid transparent;border-radius:.25rem}.alert-heading{color:inherit}.alert-link{font-weight:700}.alert-dismissible{padding-right:3rem}.alert-dismissible .btn-close{position:absolute;top:0;right:0;z-index:2;padding:1.25rem 1rem}.alert-primary{color:#084298;background-color:#cfe2ff;border-color:#b6d4fe}.alert-primary .alert-link{color:#06357a}.alert-secondary{color:#41464b;background-color:#e2e3e5;border-color:#d3d6d8}.alert-secondary .alert-link{color:#34383c}.alert-success{color:#0f5132;background-color:#d1e7dd;border-color:#badbcc}.alert-success .alert-link{color:#0c4128}.alert-info{color:#055160;background-color:#cff4fc;border-color:#b6effb}.alert-info .alert-link{color:#04414d}.alert-warning{color:#664d03;background-color:#fff3cd;border-color:#ffecb5}.alert-warning .alert-link{color:#523e02}.alert-danger{color:#842029;background-color:#f8d7da;border-color:#f5c2c7}.alert-danger .alert-link{color:#6a1a21}.alert-light{color:#636464;background-color:#fefefe;border-color:#fdfdfe}.alert-light .alert-link{color:#4f5050}.alert-dark{color:#141619;background-color:#d3d3d4;border-color:#bcbebf}.alert-dark .alert-link{color:#101214}@-webkit-keyframes progress-bar-stripes{0%{background-position-x:1rem}}@keyframes progress-bar-stripes{0%{background-position-x:1rem}}.progress{display:flex;height:1rem;overflow:hidden;font-size:.75rem;background-color:#e9ecef;border-radius:.25rem}.progress-bar{display:flex;flex-direction:column;justify-content:center;overflow:hidden;color:#fff;text-align:center;white-space:nowrap;background-color:#0d6efd;transition:width .6s ease}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-size:1rem 1rem}.progress-bar-animated{-webkit-animation:1s linear infinite progress-bar-stripes;animation:1s linear infinite progress-bar-stripes}@media (prefers-reduced-motion:reduce){.progress-bar-animated{-webkit-animation:none;animation:none}}.list-group{display:flex;flex-direction:column;padding-left:0;margin-bottom:0;border-radius:.25rem}.list-group-item-action{width:100%;color:#495057;text-align:inherit}.list-group-item-action:focus,.list-group-item-action:hover{z-index:1;color:#495057;text-decoration:none;background-color:#f8f9fa}.list-group-item-action:active{color:#212529;background-color:#e9ecef}.list-group-item{position:relative;display:block;padding:.5rem 1rem;text-decoration:none;background-color:#fff;border:1px solid rgba(0,0,0,.125)}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-right-radius:inherit;border-bottom-left-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{color:#6c757d;pointer-events:none;background-color:#fff}.list-group-item.active{z-index:2;color:#fff;background-color:#0d6efd;border-color:#0d6efd}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{margin-top:-1px;border-top-width:1px}.list-group-horizontal{flex-direction:row}.list-group-horizontal>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}@media (min-width:576px){.list-group-horizontal-sm{flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-sm>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:768px){.list-group-horizontal-md{flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-md>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-md>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:992px){.list-group-horizontal-lg{flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-lg>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:1200px){.list-group-horizontal-xl{flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-xl>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:1400px){.list-group-horizontal-xxl{flex-direction:row}.list-group-horizontal-xxl>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-xxl>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-xxl>.list-group-item.active{margin-top:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 1px}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{color:#084298;background-color:#cfe2ff}.list-group-item-primary.list-group-item-action:focus,.list-group-item-primary.list-group-item-action:hover{color:#084298;background-color:#bacbe6}.list-group-item-primary.list-group-item-action.active{color:#fff;background-color:#084298;border-color:#084298}.list-group-item-secondary{color:#41464b;background-color:#e2e3e5}.list-group-item-secondary.list-group-item-action:focus,.list-group-item-secondary.list-group-item-action:hover{color:#41464b;background-color:#cbccce}.list-group-item-secondary.list-group-item-action.active{color:#fff;background-color:#41464b;border-color:#41464b}.list-group-item-success{color:#0f5132;background-color:#d1e7dd}.list-group-item-success.list-group-item-action:focus,.list-group-item-success.list-group-item-action:hover{color:#0f5132;background-color:#bcd0c7}.list-group-item-success.list-group-item-action.active{color:#fff;background-color:#0f5132;border-color:#0f5132}.list-group-item-info{color:#055160;background-color:#cff4fc}.list-group-item-info.list-group-item-action:focus,.list-group-item-info.list-group-item-action:hover{color:#055160;background-color:#badce3}.list-group-item-info.list-group-item-action.active{color:#fff;background-color:#055160;border-color:#055160}.list-group-item-warning{color:#664d03;background-color:#fff3cd}.list-group-item-warning.list-group-item-action:focus,.list-group-item-warning.list-group-item-action:hover{color:#664d03;background-color:#e6dbb9}.list-group-item-warning.list-group-item-action.active{color:#fff;background-color:#664d03;border-color:#664d03}.list-group-item-danger{color:#842029;background-color:#f8d7da}.list-group-item-danger.list-group-item-action:focus,.list-group-item-danger.list-group-item-action:hover{color:#842029;background-color:#dfc2c4}.list-group-item-danger.list-group-item-action.active{color:#fff;background-color:#842029;border-color:#842029}.list-group-item-light{color:#636464;background-color:#fefefe}.list-group-item-light.list-group-item-action:focus,.list-group-item-light.list-group-item-action:hover{color:#636464;background-color:#e5e5e5}.list-group-item-light.list-group-item-action.active{color:#fff;background-color:#636464;border-color:#636464}.list-group-item-dark{color:#141619;background-color:#d3d3d4}.list-group-item-dark.list-group-item-action:focus,.list-group-item-dark.list-group-item-action:hover{color:#141619;background-color:#bebebf}.list-group-item-dark.list-group-item-action.active{color:#fff;background-color:#141619;border-color:#141619}.btn-close{box-sizing:content-box;width:1em;height:1em;padding:.25em .25em;color:#000;background:transparent url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23000'%3e%3cpath d='M.293.293a1 1 0 011.414 0L8 6.586 14.293.293a1 1 0 111.414 1.414L9.414 8l6.293 6.293a1 1 0 01-1.414 1.414L8 9.414l-6.293 6.293a1 1 0 01-1.414-1.414L6.586 8 .293 1.707a1 1 0 010-1.414z'/%3e%3c/svg%3e") center/1em auto no-repeat;border:0;border-radius:.25rem;opacity:.5}.btn-close:hover{color:#000;text-decoration:none;opacity:.75}.btn-close:focus{outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);opacity:1}.btn-close.disabled,.btn-close:disabled{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;opacity:.25}.btn-close-white{filter:invert(1) grayscale(100%) brightness(200%)}.toast{width:350px;max-width:100%;font-size:.875rem;pointer-events:auto;background-color:rgba(255,255,255,.85);background-clip:padding-box;border:1px solid rgba(0,0,0,.1);box-shadow:0 .5rem 1rem rgba(0,0,0,.15);border-radius:.25rem}.toast:not(.showing):not(.show){opacity:0}.toast.hide{display:none}.toast-container{width:-webkit-max-content;width:-moz-max-content;width:max-content;max-width:100%;pointer-events:none}.toast-container>:not(:last-child){margin-bottom:.75rem}.toast-header{display:flex;align-items:center;padding:.5rem .75rem;color:#6c757d;background-color:rgba(255,255,255,.85);background-clip:padding-box;border-bottom:1px solid rgba(0,0,0,.05);border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.toast-header .btn-close{margin-right:-.375rem;margin-left:.75rem}.toast-body{padding:.75rem;word-wrap:break-word}.modal-open{overflow:hidden}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal{position:fixed;top:0;left:0;z-index:1050;display:none;width:100%;height:100%;overflow:hidden;outline:0}.modal-dialog{position:relative;width:auto;margin:.5rem;pointer-events:none}.modal.fade .modal-dialog{transition:transform .3s ease-out;transform:translate(0,-50px)}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{transform:none}.modal.modal-static .modal-dialog{transform:scale(1.02)}.modal-dialog-scrollable{height:calc(100% - 1rem)}.modal-dialog-scrollable .modal-content{max-height:100%;overflow:hidden}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{display:flex;align-items:center;min-height:calc(100% - 1rem)}.modal-content{position:relative;display:flex;flex-direction:column;width:100%;pointer-events:auto;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem;outline:0}.modal-backdrop{position:fixed;top:0;left:0;z-index:1040;width:100vw;height:100vh;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:.5}.modal-header{display:flex;flex-shrink:0;align-items:center;justify-content:space-between;padding:1rem 1rem;border-bottom:1px solid #dee2e6;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.modal-header .btn-close{padding:.5rem .5rem;margin:-.5rem -.5rem -.5rem auto}.modal-title{margin-bottom:0;line-height:1.5}.modal-body{position:relative;flex:1 1 auto;padding:1rem}.modal-footer{display:flex;flex-wrap:wrap;flex-shrink:0;align-items:center;justify-content:flex-end;padding:.75rem;border-top:1px solid #dee2e6;border-bottom-right-radius:calc(.3rem - 1px);border-bottom-left-radius:calc(.3rem - 1px)}.modal-footer>*{margin:.25rem}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:576px){.modal-dialog{max-width:500px;margin:1.75rem auto}.modal-dialog-scrollable{height:calc(100% - 3.5rem)}.modal-dialog-centered{min-height:calc(100% - 3.5rem)}.modal-sm{max-width:300px}}@media (min-width:992px){.modal-lg,.modal-xl{max-width:800px}}@media (min-width:1200px){.modal-xl{max-width:1140px}}.modal-fullscreen{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen .modal-header{border-radius:0}.modal-fullscreen .modal-body{overflow-y:auto}.modal-fullscreen .modal-footer{border-radius:0}@media (max-width:575.98px){.modal-fullscreen-sm-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-sm-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-sm-down .modal-header{border-radius:0}.modal-fullscreen-sm-down .modal-body{overflow-y:auto}.modal-fullscreen-sm-down .modal-footer{border-radius:0}}@media (max-width:767.98px){.modal-fullscreen-md-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-md-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-md-down .modal-header{border-radius:0}.modal-fullscreen-md-down .modal-body{overflow-y:auto}.modal-fullscreen-md-down .modal-footer{border-radius:0}}@media (max-width:991.98px){.modal-fullscreen-lg-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-lg-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-lg-down .modal-header{border-radius:0}.modal-fullscreen-lg-down .modal-body{overflow-y:auto}.modal-fullscreen-lg-down .modal-footer{border-radius:0}}@media (max-width:1199.98px){.modal-fullscreen-xl-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-xl-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-xl-down .modal-header{border-radius:0}.modal-fullscreen-xl-down .modal-body{overflow-y:auto}.modal-fullscreen-xl-down .modal-footer{border-radius:0}}@media (max-width:1399.98px){.modal-fullscreen-xxl-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-xxl-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-xxl-down .modal-header{border-radius:0}.modal-fullscreen-xxl-down .modal-body{overflow-y:auto}.modal-fullscreen-xxl-down .modal-footer{border-radius:0}}.tooltip{position:absolute;z-index:1070;display:block;margin:0;font-family:var(--bs-font-sans-serif);font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;opacity:0}.tooltip.show{opacity:.9}.tooltip .tooltip-arrow{position:absolute;display:block;width:.8rem;height:.4rem}.tooltip .tooltip-arrow::before{position:absolute;content:"";border-color:transparent;border-style:solid}.bs-tooltip-auto[data-popper-placement^=top],.bs-tooltip-top{padding:.4rem 0}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow,.bs-tooltip-top .tooltip-arrow{bottom:0}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow::before,.bs-tooltip-top .tooltip-arrow::before{top:-1px;border-width:.4rem .4rem 0;border-top-color:#000}.bs-tooltip-auto[data-popper-placement^=right],.bs-tooltip-end{padding:0 .4rem}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow,.bs-tooltip-end .tooltip-arrow{left:0;width:.4rem;height:.8rem}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow::before,.bs-tooltip-end .tooltip-arrow::before{right:-1px;border-width:.4rem .4rem .4rem 0;border-right-color:#000}.bs-tooltip-auto[data-popper-placement^=bottom],.bs-tooltip-bottom{padding:.4rem 0}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow,.bs-tooltip-bottom .tooltip-arrow{top:0}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow::before,.bs-tooltip-bottom .tooltip-arrow::before{bottom:-1px;border-width:0 .4rem .4rem;border-bottom-color:#000}.bs-tooltip-auto[data-popper-placement^=left],.bs-tooltip-start{padding:0 .4rem}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow,.bs-tooltip-start .tooltip-arrow{right:0;width:.4rem;height:.8rem}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow::before,.bs-tooltip-start .tooltip-arrow::before{left:-1px;border-width:.4rem 0 .4rem .4rem;border-left-color:#000}.tooltip-inner{max-width:200px;padding:.25rem .5rem;color:#fff;text-align:center;background-color:#000;border-radius:.25rem}.popover{position:absolute;top:0;left:0;z-index:1060;display:block;max-width:276px;font-family:var(--bs-font-sans-serif);font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem}.popover .popover-arrow{position:absolute;display:block;width:1rem;height:.5rem}.popover .popover-arrow::after,.popover .popover-arrow::before{position:absolute;display:block;content:"";border-color:transparent;border-style:solid}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow,.bs-popover-top>.popover-arrow{bottom:calc(-.5rem - 1px)}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::before,.bs-popover-top>.popover-arrow::before{bottom:0;border-width:.5rem .5rem 0;border-top-color:rgba(0,0,0,.25)}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::after,.bs-popover-top>.popover-arrow::after{bottom:1px;border-width:.5rem .5rem 0;border-top-color:#fff}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow,.bs-popover-end>.popover-arrow{left:calc(-.5rem - 1px);width:.5rem;height:1rem}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::before,.bs-popover-end>.popover-arrow::before{left:0;border-width:.5rem .5rem .5rem 0;border-right-color:rgba(0,0,0,.25)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::after,.bs-popover-end>.popover-arrow::after{left:1px;border-width:.5rem .5rem .5rem 0;border-right-color:#fff}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow,.bs-popover-bottom>.popover-arrow{top:calc(-.5rem - 1px)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::before,.bs-popover-bottom>.popover-arrow::before{top:0;border-width:0 .5rem .5rem .5rem;border-bottom-color:rgba(0,0,0,.25)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::after,.bs-popover-bottom>.popover-arrow::after{top:1px;border-width:0 .5rem .5rem .5rem;border-bottom-color:#fff}.bs-popover-auto[data-popper-placement^=bottom] .popover-header::before,.bs-popover-bottom .popover-header::before{position:absolute;top:0;left:50%;display:block;width:1rem;margin-left:-.5rem;content:"";border-bottom:1px solid #f0f0f0}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow,.bs-popover-start>.popover-arrow{right:calc(-.5rem - 1px);width:.5rem;height:1rem}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::before,.bs-popover-start>.popover-arrow::before{right:0;border-width:.5rem 0 .5rem .5rem;border-left-color:rgba(0,0,0,.25)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::after,.bs-popover-start>.popover-arrow::after{right:1px;border-width:.5rem 0 .5rem .5rem;border-left-color:#fff}.popover-header{padding:.5rem 1rem;margin-bottom:0;font-size:1rem;background-color:#f0f0f0;border-bottom:1px solid #d8d8d8;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.popover-header:empty{display:none}.popover-body{padding:1rem 1rem;color:#212529}.carousel{position:relative}.carousel.pointer-event{touch-action:pan-y}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner::after{display:block;clear:both;content:""}.carousel-item{position:relative;display:none;float:left;width:100%;margin-right:-100%;-webkit-backface-visibility:hidden;backface-visibility:hidden;transition:transform .6s ease-in-out}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-end,.carousel-item-next:not(.carousel-item-start){transform:translateX(100%)}.active.carousel-item-start,.carousel-item-prev:not(.carousel-item-end){transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;transition-property:opacity;transform:none}.carousel-fade .carousel-item-next.carousel-item-start,.carousel-fade .carousel-item-prev.carousel-item-end,.carousel-fade .carousel-item.active{z-index:1;opacity:1}.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{z-index:0;opacity:0;transition:opacity 0s .6s}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{transition:none}}.carousel-control-next,.carousel-control-prev{position:absolute;top:0;bottom:0;z-index:1;display:flex;align-items:center;justify-content:center;width:15%;padding:0;color:#fff;text-align:center;background:0 0;border:0;opacity:.5;transition:opacity .15s ease}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;text-decoration:none;outline:0;opacity:.9}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{display:inline-block;width:2rem;height:2rem;background-repeat:no-repeat;background-position:50%;background-size:100% 100%}.carousel-control-prev-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0z'/%3e%3c/svg%3e")}.carousel-control-next-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e")}.carousel-indicators{position:absolute;right:0;bottom:0;left:0;z-index:2;display:flex;justify-content:center;padding:0;margin-right:15%;margin-bottom:1rem;margin-left:15%;list-style:none}.carousel-indicators [data-bs-target]{box-sizing:content-box;flex:0 1 auto;width:30px;height:3px;padding:0;margin-right:3px;margin-left:3px;text-indent:-999px;cursor:pointer;background-color:#fff;background-clip:padding-box;border:0;border-top:10px solid transparent;border-bottom:10px solid transparent;opacity:.5;transition:opacity .6s ease}@media (prefers-reduced-motion:reduce){.carousel-indicators [data-bs-target]{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{position:absolute;right:15%;bottom:1.25rem;left:15%;padding-top:1.25rem;padding-bottom:1.25rem;color:#fff;text-align:center}.carousel-dark .carousel-control-next-icon,.carousel-dark .carousel-control-prev-icon{filter:invert(1) grayscale(100)}.carousel-dark .carousel-indicators [data-bs-target]{background-color:#000}.carousel-dark .carousel-caption{color:#000}@-webkit-keyframes spinner-border{to{transform:rotate(360deg)}}@keyframes spinner-border{to{transform:rotate(360deg)}}.spinner-border{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;border:.25em solid currentColor;border-right-color:transparent;border-radius:50%;-webkit-animation:.75s linear infinite spinner-border;animation:.75s linear infinite spinner-border}.spinner-border-sm{width:1rem;height:1rem;border-width:.2em}@-webkit-keyframes spinner-grow{0%{transform:scale(0)}50%{opacity:1;transform:none}}@keyframes spinner-grow{0%{transform:scale(0)}50%{opacity:1;transform:none}}.spinner-grow{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;background-color:currentColor;border-radius:50%;opacity:0;-webkit-animation:.75s linear infinite spinner-grow;animation:.75s linear infinite spinner-grow}.spinner-grow-sm{width:1rem;height:1rem}@media (prefers-reduced-motion:reduce){.spinner-border,.spinner-grow{-webkit-animation-duration:1.5s;animation-duration:1.5s}}.clearfix::after{display:block;clear:both;content:""}.link-primary{color:#0d6efd}.link-primary:focus,.link-primary:hover{color:#0a58ca}.link-secondary{color:#6c757d}.link-secondary:focus,.link-secondary:hover{color:#565e64}.link-success{color:#198754}.link-success:focus,.link-success:hover{color:#146c43}.link-info{color:#0dcaf0}.link-info:focus,.link-info:hover{color:#3dd5f3}.link-warning{color:#ffc107}.link-warning:focus,.link-warning:hover{color:#ffcd39}.link-danger{color:#dc3545}.link-danger:focus,.link-danger:hover{color:#b02a37}.link-light{color:#f8f9fa}.link-light:focus,.link-light:hover{color:#f9fafb}.link-dark{color:#212529}.link-dark:focus,.link-dark:hover{color:#1a1e21}.ratio{position:relative;width:100%}.ratio::before{display:block;padding-top:var(--bs-aspect-ratio);content:""}.ratio>*{position:absolute;top:0;left:0;width:100%;height:100%}.ratio-1x1{--bs-aspect-ratio:100%}.ratio-4x3{--bs-aspect-ratio:calc(3 / 4 * 100%)}.ratio-16x9{--bs-aspect-ratio:calc(9 / 16 * 100%)}.ratio-21x9{--bs-aspect-ratio:calc(9 / 21 * 100%)}.fixed-top{position:fixed;top:0;right:0;left:0;z-index:1030}.fixed-bottom{position:fixed;right:0;bottom:0;left:0;z-index:1030}.sticky-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}@media (min-width:576px){.sticky-sm-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}@media (min-width:768px){.sticky-md-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}@media (min-width:992px){.sticky-lg-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}@media (min-width:1200px){.sticky-xl-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}@media (min-width:1400px){.sticky-xxl-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}.visually-hidden,.visually-hidden-focusable:not(:focus):not(:focus-within){position:absolute!important;width:1px!important;height:1px!important;padding:0!important;margin:-1px!important;overflow:hidden!important;clip:rect(0,0,0,0)!important;white-space:nowrap!important;border:0!important}.stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.float-start{float:left!important}.float-end{float:right!important}.float-none{float:none!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.overflow-visible{overflow:visible!important}.overflow-scroll{overflow:scroll!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-grid{display:grid!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:flex!important}.d-inline-flex{display:inline-flex!important}.d-none{display:none!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important}.shadow-none{box-shadow:none!important}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.top-0{top:0!important}.top-50{top:50%!important}.top-100{top:100%!important}.bottom-0{bottom:0!important}.bottom-50{bottom:50%!important}.bottom-100{bottom:100%!important}.start-0{left:0!important}.start-50{left:50%!important}.start-100{left:100%!important}.end-0{right:0!important}.end-50{right:50%!important}.end-100{right:100%!important}.translate-middle{transform:translate(-50%,-50%)!important}.translate-middle-x{transform:translateX(-50%)!important}.translate-middle-y{transform:translateY(-50%)!important}.border{border:1px solid #dee2e6!important}.border-0{border:0!important}.border-top{border-top:1px solid #dee2e6!important}.border-top-0{border-top:0!important}.border-end{border-right:1px solid #dee2e6!important}.border-end-0{border-right:0!important}.border-bottom{border-bottom:1px solid #dee2e6!important}.border-bottom-0{border-bottom:0!important}.border-start{border-left:1px solid #dee2e6!important}.border-start-0{border-left:0!important}.border-primary{border-color:#0d6efd!important}.border-secondary{border-color:#6c757d!important}.border-success{border-color:#198754!important}.border-info{border-color:#0dcaf0!important}.border-warning{border-color:#ffc107!important}.border-danger{border-color:#dc3545!important}.border-light{border-color:#f8f9fa!important}.border-dark{border-color:#212529!important}.border-white{border-color:#fff!important}.border-0{border-width:0!important}.border-1{border-width:1px!important}.border-2{border-width:2px!important}.border-3{border-width:3px!important}.border-4{border-width:4px!important}.border-5{border-width:5px!important}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.mw-100{max-width:100%!important}.vw-100{width:100vw!important}.min-vw-100{min-width:100vw!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mh-100{max-height:100%!important}.vh-100{height:100vh!important}.min-vh-100{min-height:100vh!important}.flex-fill{flex:1 1 auto!important}.flex-row{flex-direction:row!important}.flex-column{flex-direction:column!important}.flex-row-reverse{flex-direction:row-reverse!important}.flex-column-reverse{flex-direction:column-reverse!important}.flex-grow-0{flex-grow:0!important}.flex-grow-1{flex-grow:1!important}.flex-shrink-0{flex-shrink:0!important}.flex-shrink-1{flex-shrink:1!important}.flex-wrap{flex-wrap:wrap!important}.flex-nowrap{flex-wrap:nowrap!important}.flex-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-0{gap:0!important}.gap-1{gap:.25rem!important}.gap-2{gap:.5rem!important}.gap-3{gap:1rem!important}.gap-4{gap:1.5rem!important}.gap-5{gap:3rem!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.justify-content-evenly{justify-content:space-evenly!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}.order-first{order:-1!important}.order-0{order:0!important}.order-1{order:1!important}.order-2{order:2!important}.order-3{order:3!important}.order-4{order:4!important}.order-5{order:5!important}.order-last{order:6!important}.m-0{margin:0!important}.m-1{margin:.25rem!important}.m-2{margin:.5rem!important}.m-3{margin:1rem!important}.m-4{margin:1.5rem!important}.m-5{margin:3rem!important}.m-auto{margin:auto!important}.mx-0{margin-right:0!important;margin-left:0!important}.mx-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-3{margin-right:1rem!important;margin-left:1rem!important}.mx-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-5{margin-right:3rem!important;margin-left:3rem!important}.mx-auto{margin-right:auto!important;margin-left:auto!important}.my-0{margin-top:0!important;margin-bottom:0!important}.my-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-0{margin-top:0!important}.mt-1{margin-top:.25rem!important}.mt-2{margin-top:.5rem!important}.mt-3{margin-top:1rem!important}.mt-4{margin-top:1.5rem!important}.mt-5{margin-top:3rem!important}.mt-auto{margin-top:auto!important}.me-0{margin-right:0!important}.me-1{margin-right:.25rem!important}.me-2{margin-right:.5rem!important}.me-3{margin-right:1rem!important}.me-4{margin-right:1.5rem!important}.me-5{margin-right:3rem!important}.me-auto{margin-right:auto!important}.mb-0{margin-bottom:0!important}.mb-1{margin-bottom:.25rem!important}.mb-2{margin-bottom:.5rem!important}.mb-3{margin-bottom:1rem!important}.mb-4{margin-bottom:1.5rem!important}.mb-5{margin-bottom:3rem!important}.mb-auto{margin-bottom:auto!important}.ms-0{margin-left:0!important}.ms-1{margin-left:.25rem!important}.ms-2{margin-left:.5rem!important}.ms-3{margin-left:1rem!important}.ms-4{margin-left:1.5rem!important}.ms-5{margin-left:3rem!important}.ms-auto{margin-left:auto!important}.p-0{padding:0!important}.p-1{padding:.25rem!important}.p-2{padding:.5rem!important}.p-3{padding:1rem!important}.p-4{padding:1.5rem!important}.p-5{padding:3rem!important}.px-0{padding-right:0!important;padding-left:0!important}.px-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-3{padding-right:1rem!important;padding-left:1rem!important}.px-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-5{padding-right:3rem!important;padding-left:3rem!important}.py-0{padding-top:0!important;padding-bottom:0!important}.py-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-0{padding-top:0!important}.pt-1{padding-top:.25rem!important}.pt-2{padding-top:.5rem!important}.pt-3{padding-top:1rem!important}.pt-4{padding-top:1.5rem!important}.pt-5{padding-top:3rem!important}.pe-0{padding-right:0!important}.pe-1{padding-right:.25rem!important}.pe-2{padding-right:.5rem!important}.pe-3{padding-right:1rem!important}.pe-4{padding-right:1.5rem!important}.pe-5{padding-right:3rem!important}.pb-0{padding-bottom:0!important}.pb-1{padding-bottom:.25rem!important}.pb-2{padding-bottom:.5rem!important}.pb-3{padding-bottom:1rem!important}.pb-4{padding-bottom:1.5rem!important}.pb-5{padding-bottom:3rem!important}.ps-0{padding-left:0!important}.ps-1{padding-left:.25rem!important}.ps-2{padding-left:.5rem!important}.ps-3{padding-left:1rem!important}.ps-4{padding-left:1.5rem!important}.ps-5{padding-left:3rem!important}.fs-1{font-size:calc(1.375rem + 1.5vw)!important}.fs-2{font-size:calc(1.325rem + .9vw)!important}.fs-3{font-size:calc(1.3rem + .6vw)!important}.fs-4{font-size:calc(1.275rem + .3vw)!important}.fs-5{font-size:1.25rem!important}.fs-6{font-size:1rem!important}.fst-italic{font-style:italic!important}.fst-normal{font-style:normal!important}.fw-light{font-weight:300!important}.fw-lighter{font-weight:lighter!important}.fw-normal{font-weight:400!important}.fw-bold{font-weight:700!important}.fw-bolder{font-weight:bolder!important}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.text-start{text-align:left!important}.text-end{text-align:right!important}.text-center{text-align:center!important}.text-primary{color:#0d6efd!important}.text-secondary{color:#6c757d!important}.text-success{color:#198754!important}.text-info{color:#0dcaf0!important}.text-warning{color:#ffc107!important}.text-danger{color:#dc3545!important}.text-light{color:#f8f9fa!important}.text-dark{color:#212529!important}.text-white{color:#fff!important}.text-body{color:#212529!important}.text-muted{color:#6c757d!important}.text-black-50{color:rgba(0,0,0,.5)!important}.text-white-50{color:rgba(255,255,255,.5)!important}.text-reset{color:inherit!important}.lh-1{line-height:1!important}.lh-sm{line-height:1.25!important}.lh-base{line-height:1.5!important}.lh-lg{line-height:2!important}.bg-primary{background-color:#0d6efd!important}.bg-secondary{background-color:#6c757d!important}.bg-success{background-color:#198754!important}.bg-info{background-color:#0dcaf0!important}.bg-warning{background-color:#ffc107!important}.bg-danger{background-color:#dc3545!important}.bg-light{background-color:#f8f9fa!important}.bg-dark{background-color:#212529!important}.bg-body{background-color:#fff!important}.bg-white{background-color:#fff!important}.bg-transparent{background-color:transparent!important}.bg-gradient{background-image:var(--bs-gradient)!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-decoration-none{text-decoration:none!important}.text-decoration-underline{text-decoration:underline!important}.text-decoration-line-through{text-decoration:line-through!important}.text-break{word-wrap:break-word!important;word-break:break-word!important}.font-monospace{font-family:var(--bs-font-monospace)!important}.user-select-all{-webkit-user-select:all!important;-moz-user-select:all!important;user-select:all!important}.user-select-auto{-webkit-user-select:auto!important;-moz-user-select:auto!important;user-select:auto!important}.user-select-none{-webkit-user-select:none!important;-moz-user-select:none!important;user-select:none!important}.pe-none{pointer-events:none!important}.pe-auto{pointer-events:auto!important}.rounded{border-radius:.25rem!important}.rounded-0{border-radius:0!important}.rounded-1{border-radius:.2rem!important}.rounded-2{border-radius:.25rem!important}.rounded-3{border-radius:.3rem!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important}.rounded-top{border-top-left-radius:.25rem!important;border-top-right-radius:.25rem!important}.rounded-end{border-top-right-radius:.25rem!important;border-bottom-right-radius:.25rem!important}.rounded-bottom{border-bottom-right-radius:.25rem!important;border-bottom-left-radius:.25rem!important}.rounded-start{border-bottom-left-radius:.25rem!important;border-top-left-radius:.25rem!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}@media (min-width:576px){.float-sm-start{float:left!important}.float-sm-end{float:right!important}.float-sm-none{float:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-grid{display:grid!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:flex!important}.d-sm-inline-flex{display:inline-flex!important}.d-sm-none{display:none!important}.flex-sm-fill{flex:1 1 auto!important}.flex-sm-row{flex-direction:row!important}.flex-sm-column{flex-direction:column!important}.flex-sm-row-reverse{flex-direction:row-reverse!important}.flex-sm-column-reverse{flex-direction:column-reverse!important}.flex-sm-grow-0{flex-grow:0!important}.flex-sm-grow-1{flex-grow:1!important}.flex-sm-shrink-0{flex-shrink:0!important}.flex-sm-shrink-1{flex-shrink:1!important}.flex-sm-wrap{flex-wrap:wrap!important}.flex-sm-nowrap{flex-wrap:nowrap!important}.flex-sm-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-sm-0{gap:0!important}.gap-sm-1{gap:.25rem!important}.gap-sm-2{gap:.5rem!important}.gap-sm-3{gap:1rem!important}.gap-sm-4{gap:1.5rem!important}.gap-sm-5{gap:3rem!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.justify-content-sm-evenly{justify-content:space-evenly!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}.order-sm-first{order:-1!important}.order-sm-0{order:0!important}.order-sm-1{order:1!important}.order-sm-2{order:2!important}.order-sm-3{order:3!important}.order-sm-4{order:4!important}.order-sm-5{order:5!important}.order-sm-last{order:6!important}.m-sm-0{margin:0!important}.m-sm-1{margin:.25rem!important}.m-sm-2{margin:.5rem!important}.m-sm-3{margin:1rem!important}.m-sm-4{margin:1.5rem!important}.m-sm-5{margin:3rem!important}.m-sm-auto{margin:auto!important}.mx-sm-0{margin-right:0!important;margin-left:0!important}.mx-sm-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-sm-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-sm-3{margin-right:1rem!important;margin-left:1rem!important}.mx-sm-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-sm-5{margin-right:3rem!important;margin-left:3rem!important}.mx-sm-auto{margin-right:auto!important;margin-left:auto!important}.my-sm-0{margin-top:0!important;margin-bottom:0!important}.my-sm-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-sm-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-sm-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-sm-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-sm-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-sm-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-sm-0{margin-top:0!important}.mt-sm-1{margin-top:.25rem!important}.mt-sm-2{margin-top:.5rem!important}.mt-sm-3{margin-top:1rem!important}.mt-sm-4{margin-top:1.5rem!important}.mt-sm-5{margin-top:3rem!important}.mt-sm-auto{margin-top:auto!important}.me-sm-0{margin-right:0!important}.me-sm-1{margin-right:.25rem!important}.me-sm-2{margin-right:.5rem!important}.me-sm-3{margin-right:1rem!important}.me-sm-4{margin-right:1.5rem!important}.me-sm-5{margin-right:3rem!important}.me-sm-auto{margin-right:auto!important}.mb-sm-0{margin-bottom:0!important}.mb-sm-1{margin-bottom:.25rem!important}.mb-sm-2{margin-bottom:.5rem!important}.mb-sm-3{margin-bottom:1rem!important}.mb-sm-4{margin-bottom:1.5rem!important}.mb-sm-5{margin-bottom:3rem!important}.mb-sm-auto{margin-bottom:auto!important}.ms-sm-0{margin-left:0!important}.ms-sm-1{margin-left:.25rem!important}.ms-sm-2{margin-left:.5rem!important}.ms-sm-3{margin-left:1rem!important}.ms-sm-4{margin-left:1.5rem!important}.ms-sm-5{margin-left:3rem!important}.ms-sm-auto{margin-left:auto!important}.p-sm-0{padding:0!important}.p-sm-1{padding:.25rem!important}.p-sm-2{padding:.5rem!important}.p-sm-3{padding:1rem!important}.p-sm-4{padding:1.5rem!important}.p-sm-5{padding:3rem!important}.px-sm-0{padding-right:0!important;padding-left:0!important}.px-sm-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-sm-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-sm-3{padding-right:1rem!important;padding-left:1rem!important}.px-sm-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-sm-5{padding-right:3rem!important;padding-left:3rem!important}.py-sm-0{padding-top:0!important;padding-bottom:0!important}.py-sm-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-sm-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-sm-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-sm-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-sm-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-sm-0{padding-top:0!important}.pt-sm-1{padding-top:.25rem!important}.pt-sm-2{padding-top:.5rem!important}.pt-sm-3{padding-top:1rem!important}.pt-sm-4{padding-top:1.5rem!important}.pt-sm-5{padding-top:3rem!important}.pe-sm-0{padding-right:0!important}.pe-sm-1{padding-right:.25rem!important}.pe-sm-2{padding-right:.5rem!important}.pe-sm-3{padding-right:1rem!important}.pe-sm-4{padding-right:1.5rem!important}.pe-sm-5{padding-right:3rem!important}.pb-sm-0{padding-bottom:0!important}.pb-sm-1{padding-bottom:.25rem!important}.pb-sm-2{padding-bottom:.5rem!important}.pb-sm-3{padding-bottom:1rem!important}.pb-sm-4{padding-bottom:1.5rem!important}.pb-sm-5{padding-bottom:3rem!important}.ps-sm-0{padding-left:0!important}.ps-sm-1{padding-left:.25rem!important}.ps-sm-2{padding-left:.5rem!important}.ps-sm-3{padding-left:1rem!important}.ps-sm-4{padding-left:1.5rem!important}.ps-sm-5{padding-left:3rem!important}.text-sm-start{text-align:left!important}.text-sm-end{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.float-md-start{float:left!important}.float-md-end{float:right!important}.float-md-none{float:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-grid{display:grid!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:flex!important}.d-md-inline-flex{display:inline-flex!important}.d-md-none{display:none!important}.flex-md-fill{flex:1 1 auto!important}.flex-md-row{flex-direction:row!important}.flex-md-column{flex-direction:column!important}.flex-md-row-reverse{flex-direction:row-reverse!important}.flex-md-column-reverse{flex-direction:column-reverse!important}.flex-md-grow-0{flex-grow:0!important}.flex-md-grow-1{flex-grow:1!important}.flex-md-shrink-0{flex-shrink:0!important}.flex-md-shrink-1{flex-shrink:1!important}.flex-md-wrap{flex-wrap:wrap!important}.flex-md-nowrap{flex-wrap:nowrap!important}.flex-md-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-md-0{gap:0!important}.gap-md-1{gap:.25rem!important}.gap-md-2{gap:.5rem!important}.gap-md-3{gap:1rem!important}.gap-md-4{gap:1.5rem!important}.gap-md-5{gap:3rem!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.justify-content-md-evenly{justify-content:space-evenly!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}.order-md-first{order:-1!important}.order-md-0{order:0!important}.order-md-1{order:1!important}.order-md-2{order:2!important}.order-md-3{order:3!important}.order-md-4{order:4!important}.order-md-5{order:5!important}.order-md-last{order:6!important}.m-md-0{margin:0!important}.m-md-1{margin:.25rem!important}.m-md-2{margin:.5rem!important}.m-md-3{margin:1rem!important}.m-md-4{margin:1.5rem!important}.m-md-5{margin:3rem!important}.m-md-auto{margin:auto!important}.mx-md-0{margin-right:0!important;margin-left:0!important}.mx-md-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-md-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-md-3{margin-right:1rem!important;margin-left:1rem!important}.mx-md-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-md-5{margin-right:3rem!important;margin-left:3rem!important}.mx-md-auto{margin-right:auto!important;margin-left:auto!important}.my-md-0{margin-top:0!important;margin-bottom:0!important}.my-md-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-md-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-md-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-md-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-md-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-md-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-md-0{margin-top:0!important}.mt-md-1{margin-top:.25rem!important}.mt-md-2{margin-top:.5rem!important}.mt-md-3{margin-top:1rem!important}.mt-md-4{margin-top:1.5rem!important}.mt-md-5{margin-top:3rem!important}.mt-md-auto{margin-top:auto!important}.me-md-0{margin-right:0!important}.me-md-1{margin-right:.25rem!important}.me-md-2{margin-right:.5rem!important}.me-md-3{margin-right:1rem!important}.me-md-4{margin-right:1.5rem!important}.me-md-5{margin-right:3rem!important}.me-md-auto{margin-right:auto!important}.mb-md-0{margin-bottom:0!important}.mb-md-1{margin-bottom:.25rem!important}.mb-md-2{margin-bottom:.5rem!important}.mb-md-3{margin-bottom:1rem!important}.mb-md-4{margin-bottom:1.5rem!important}.mb-md-5{margin-bottom:3rem!important}.mb-md-auto{margin-bottom:auto!important}.ms-md-0{margin-left:0!important}.ms-md-1{margin-left:.25rem!important}.ms-md-2{margin-left:.5rem!important}.ms-md-3{margin-left:1rem!important}.ms-md-4{margin-left:1.5rem!important}.ms-md-5{margin-left:3rem!important}.ms-md-auto{margin-left:auto!important}.p-md-0{padding:0!important}.p-md-1{padding:.25rem!important}.p-md-2{padding:.5rem!important}.p-md-3{padding:1rem!important}.p-md-4{padding:1.5rem!important}.p-md-5{padding:3rem!important}.px-md-0{padding-right:0!important;padding-left:0!important}.px-md-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-md-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-md-3{padding-right:1rem!important;padding-left:1rem!important}.px-md-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-md-5{padding-right:3rem!important;padding-left:3rem!important}.py-md-0{padding-top:0!important;padding-bottom:0!important}.py-md-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-md-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-md-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-md-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-md-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-md-0{padding-top:0!important}.pt-md-1{padding-top:.25rem!important}.pt-md-2{padding-top:.5rem!important}.pt-md-3{padding-top:1rem!important}.pt-md-4{padding-top:1.5rem!important}.pt-md-5{padding-top:3rem!important}.pe-md-0{padding-right:0!important}.pe-md-1{padding-right:.25rem!important}.pe-md-2{padding-right:.5rem!important}.pe-md-3{padding-right:1rem!important}.pe-md-4{padding-right:1.5rem!important}.pe-md-5{padding-right:3rem!important}.pb-md-0{padding-bottom:0!important}.pb-md-1{padding-bottom:.25rem!important}.pb-md-2{padding-bottom:.5rem!important}.pb-md-3{padding-bottom:1rem!important}.pb-md-4{padding-bottom:1.5rem!important}.pb-md-5{padding-bottom:3rem!important}.ps-md-0{padding-left:0!important}.ps-md-1{padding-left:.25rem!important}.ps-md-2{padding-left:.5rem!important}.ps-md-3{padding-left:1rem!important}.ps-md-4{padding-left:1.5rem!important}.ps-md-5{padding-left:3rem!important}.text-md-start{text-align:left!important}.text-md-end{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.float-lg-start{float:left!important}.float-lg-end{float:right!important}.float-lg-none{float:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-grid{display:grid!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:flex!important}.d-lg-inline-flex{display:inline-flex!important}.d-lg-none{display:none!important}.flex-lg-fill{flex:1 1 auto!important}.flex-lg-row{flex-direction:row!important}.flex-lg-column{flex-direction:column!important}.flex-lg-row-reverse{flex-direction:row-reverse!important}.flex-lg-column-reverse{flex-direction:column-reverse!important}.flex-lg-grow-0{flex-grow:0!important}.flex-lg-grow-1{flex-grow:1!important}.flex-lg-shrink-0{flex-shrink:0!important}.flex-lg-shrink-1{flex-shrink:1!important}.flex-lg-wrap{flex-wrap:wrap!important}.flex-lg-nowrap{flex-wrap:nowrap!important}.flex-lg-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-lg-0{gap:0!important}.gap-lg-1{gap:.25rem!important}.gap-lg-2{gap:.5rem!important}.gap-lg-3{gap:1rem!important}.gap-lg-4{gap:1.5rem!important}.gap-lg-5{gap:3rem!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.justify-content-lg-evenly{justify-content:space-evenly!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}.order-lg-first{order:-1!important}.order-lg-0{order:0!important}.order-lg-1{order:1!important}.order-lg-2{order:2!important}.order-lg-3{order:3!important}.order-lg-4{order:4!important}.order-lg-5{order:5!important}.order-lg-last{order:6!important}.m-lg-0{margin:0!important}.m-lg-1{margin:.25rem!important}.m-lg-2{margin:.5rem!important}.m-lg-3{margin:1rem!important}.m-lg-4{margin:1.5rem!important}.m-lg-5{margin:3rem!important}.m-lg-auto{margin:auto!important}.mx-lg-0{margin-right:0!important;margin-left:0!important}.mx-lg-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-lg-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-lg-3{margin-right:1rem!important;margin-left:1rem!important}.mx-lg-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-lg-5{margin-right:3rem!important;margin-left:3rem!important}.mx-lg-auto{margin-right:auto!important;margin-left:auto!important}.my-lg-0{margin-top:0!important;margin-bottom:0!important}.my-lg-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-lg-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-lg-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-lg-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-lg-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-lg-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-lg-0{margin-top:0!important}.mt-lg-1{margin-top:.25rem!important}.mt-lg-2{margin-top:.5rem!important}.mt-lg-3{margin-top:1rem!important}.mt-lg-4{margin-top:1.5rem!important}.mt-lg-5{margin-top:3rem!important}.mt-lg-auto{margin-top:auto!important}.me-lg-0{margin-right:0!important}.me-lg-1{margin-right:.25rem!important}.me-lg-2{margin-right:.5rem!important}.me-lg-3{margin-right:1rem!important}.me-lg-4{margin-right:1.5rem!important}.me-lg-5{margin-right:3rem!important}.me-lg-auto{margin-right:auto!important}.mb-lg-0{margin-bottom:0!important}.mb-lg-1{margin-bottom:.25rem!important}.mb-lg-2{margin-bottom:.5rem!important}.mb-lg-3{margin-bottom:1rem!important}.mb-lg-4{margin-bottom:1.5rem!important}.mb-lg-5{margin-bottom:3rem!important}.mb-lg-auto{margin-bottom:auto!important}.ms-lg-0{margin-left:0!important}.ms-lg-1{margin-left:.25rem!important}.ms-lg-2{margin-left:.5rem!important}.ms-lg-3{margin-left:1rem!important}.ms-lg-4{margin-left:1.5rem!important}.ms-lg-5{margin-left:3rem!important}.ms-lg-auto{margin-left:auto!important}.p-lg-0{padding:0!important}.p-lg-1{padding:.25rem!important}.p-lg-2{padding:.5rem!important}.p-lg-3{padding:1rem!important}.p-lg-4{padding:1.5rem!important}.p-lg-5{padding:3rem!important}.px-lg-0{padding-right:0!important;padding-left:0!important}.px-lg-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-lg-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-lg-3{padding-right:1rem!important;padding-left:1rem!important}.px-lg-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-lg-5{padding-right:3rem!important;padding-left:3rem!important}.py-lg-0{padding-top:0!important;padding-bottom:0!important}.py-lg-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-lg-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-lg-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-lg-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-lg-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-lg-0{padding-top:0!important}.pt-lg-1{padding-top:.25rem!important}.pt-lg-2{padding-top:.5rem!important}.pt-lg-3{padding-top:1rem!important}.pt-lg-4{padding-top:1.5rem!important}.pt-lg-5{padding-top:3rem!important}.pe-lg-0{padding-right:0!important}.pe-lg-1{padding-right:.25rem!important}.pe-lg-2{padding-right:.5rem!important}.pe-lg-3{padding-right:1rem!important}.pe-lg-4{padding-right:1.5rem!important}.pe-lg-5{padding-right:3rem!important}.pb-lg-0{padding-bottom:0!important}.pb-lg-1{padding-bottom:.25rem!important}.pb-lg-2{padding-bottom:.5rem!important}.pb-lg-3{padding-bottom:1rem!important}.pb-lg-4{padding-bottom:1.5rem!important}.pb-lg-5{padding-bottom:3rem!important}.ps-lg-0{padding-left:0!important}.ps-lg-1{padding-left:.25rem!important}.ps-lg-2{padding-left:.5rem!important}.ps-lg-3{padding-left:1rem!important}.ps-lg-4{padding-left:1.5rem!important}.ps-lg-5{padding-left:3rem!important}.text-lg-start{text-align:left!important}.text-lg-end{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.float-xl-start{float:left!important}.float-xl-end{float:right!important}.float-xl-none{float:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-grid{display:grid!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:flex!important}.d-xl-inline-flex{display:inline-flex!important}.d-xl-none{display:none!important}.flex-xl-fill{flex:1 1 auto!important}.flex-xl-row{flex-direction:row!important}.flex-xl-column{flex-direction:column!important}.flex-xl-row-reverse{flex-direction:row-reverse!important}.flex-xl-column-reverse{flex-direction:column-reverse!important}.flex-xl-grow-0{flex-grow:0!important}.flex-xl-grow-1{flex-grow:1!important}.flex-xl-shrink-0{flex-shrink:0!important}.flex-xl-shrink-1{flex-shrink:1!important}.flex-xl-wrap{flex-wrap:wrap!important}.flex-xl-nowrap{flex-wrap:nowrap!important}.flex-xl-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-xl-0{gap:0!important}.gap-xl-1{gap:.25rem!important}.gap-xl-2{gap:.5rem!important}.gap-xl-3{gap:1rem!important}.gap-xl-4{gap:1.5rem!important}.gap-xl-5{gap:3rem!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.justify-content-xl-evenly{justify-content:space-evenly!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}.order-xl-first{order:-1!important}.order-xl-0{order:0!important}.order-xl-1{order:1!important}.order-xl-2{order:2!important}.order-xl-3{order:3!important}.order-xl-4{order:4!important}.order-xl-5{order:5!important}.order-xl-last{order:6!important}.m-xl-0{margin:0!important}.m-xl-1{margin:.25rem!important}.m-xl-2{margin:.5rem!important}.m-xl-3{margin:1rem!important}.m-xl-4{margin:1.5rem!important}.m-xl-5{margin:3rem!important}.m-xl-auto{margin:auto!important}.mx-xl-0{margin-right:0!important;margin-left:0!important}.mx-xl-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-xl-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-xl-3{margin-right:1rem!important;margin-left:1rem!important}.mx-xl-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-xl-5{margin-right:3rem!important;margin-left:3rem!important}.mx-xl-auto{margin-right:auto!important;margin-left:auto!important}.my-xl-0{margin-top:0!important;margin-bottom:0!important}.my-xl-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-xl-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-xl-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-xl-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-xl-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-xl-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-xl-0{margin-top:0!important}.mt-xl-1{margin-top:.25rem!important}.mt-xl-2{margin-top:.5rem!important}.mt-xl-3{margin-top:1rem!important}.mt-xl-4{margin-top:1.5rem!important}.mt-xl-5{margin-top:3rem!important}.mt-xl-auto{margin-top:auto!important}.me-xl-0{margin-right:0!important}.me-xl-1{margin-right:.25rem!important}.me-xl-2{margin-right:.5rem!important}.me-xl-3{margin-right:1rem!important}.me-xl-4{margin-right:1.5rem!important}.me-xl-5{margin-right:3rem!important}.me-xl-auto{margin-right:auto!important}.mb-xl-0{margin-bottom:0!important}.mb-xl-1{margin-bottom:.25rem!important}.mb-xl-2{margin-bottom:.5rem!important}.mb-xl-3{margin-bottom:1rem!important}.mb-xl-4{margin-bottom:1.5rem!important}.mb-xl-5{margin-bottom:3rem!important}.mb-xl-auto{margin-bottom:auto!important}.ms-xl-0{margin-left:0!important}.ms-xl-1{margin-left:.25rem!important}.ms-xl-2{margin-left:.5rem!important}.ms-xl-3{margin-left:1rem!important}.ms-xl-4{margin-left:1.5rem!important}.ms-xl-5{margin-left:3rem!important}.ms-xl-auto{margin-left:auto!important}.p-xl-0{padding:0!important}.p-xl-1{padding:.25rem!important}.p-xl-2{padding:.5rem!important}.p-xl-3{padding:1rem!important}.p-xl-4{padding:1.5rem!important}.p-xl-5{padding:3rem!important}.px-xl-0{padding-right:0!important;padding-left:0!important}.px-xl-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-xl-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-xl-3{padding-right:1rem!important;padding-left:1rem!important}.px-xl-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-xl-5{padding-right:3rem!important;padding-left:3rem!important}.py-xl-0{padding-top:0!important;padding-bottom:0!important}.py-xl-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-xl-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-xl-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-xl-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-xl-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-xl-0{padding-top:0!important}.pt-xl-1{padding-top:.25rem!important}.pt-xl-2{padding-top:.5rem!important}.pt-xl-3{padding-top:1rem!important}.pt-xl-4{padding-top:1.5rem!important}.pt-xl-5{padding-top:3rem!important}.pe-xl-0{padding-right:0!important}.pe-xl-1{padding-right:.25rem!important}.pe-xl-2{padding-right:.5rem!important}.pe-xl-3{padding-right:1rem!important}.pe-xl-4{padding-right:1.5rem!important}.pe-xl-5{padding-right:3rem!important}.pb-xl-0{padding-bottom:0!important}.pb-xl-1{padding-bottom:.25rem!important}.pb-xl-2{padding-bottom:.5rem!important}.pb-xl-3{padding-bottom:1rem!important}.pb-xl-4{padding-bottom:1.5rem!important}.pb-xl-5{padding-bottom:3rem!important}.ps-xl-0{padding-left:0!important}.ps-xl-1{padding-left:.25rem!important}.ps-xl-2{padding-left:.5rem!important}.ps-xl-3{padding-left:1rem!important}.ps-xl-4{padding-left:1.5rem!important}.ps-xl-5{padding-left:3rem!important}.text-xl-start{text-align:left!important}.text-xl-end{text-align:right!important}.text-xl-center{text-align:center!important}}@media (min-width:1400px){.float-xxl-start{float:left!important}.float-xxl-end{float:right!important}.float-xxl-none{float:none!important}.d-xxl-inline{display:inline!important}.d-xxl-inline-block{display:inline-block!important}.d-xxl-block{display:block!important}.d-xxl-grid{display:grid!important}.d-xxl-table{display:table!important}.d-xxl-table-row{display:table-row!important}.d-xxl-table-cell{display:table-cell!important}.d-xxl-flex{display:flex!important}.d-xxl-inline-flex{display:inline-flex!important}.d-xxl-none{display:none!important}.flex-xxl-fill{flex:1 1 auto!important}.flex-xxl-row{flex-direction:row!important}.flex-xxl-column{flex-direction:column!important}.flex-xxl-row-reverse{flex-direction:row-reverse!important}.flex-xxl-column-reverse{flex-direction:column-reverse!important}.flex-xxl-grow-0{flex-grow:0!important}.flex-xxl-grow-1{flex-grow:1!important}.flex-xxl-shrink-0{flex-shrink:0!important}.flex-xxl-shrink-1{flex-shrink:1!important}.flex-xxl-wrap{flex-wrap:wrap!important}.flex-xxl-nowrap{flex-wrap:nowrap!important}.flex-xxl-wrap-reverse{flex-wrap:wrap-reverse!important}.gap-xxl-0{gap:0!important}.gap-xxl-1{gap:.25rem!important}.gap-xxl-2{gap:.5rem!important}.gap-xxl-3{gap:1rem!important}.gap-xxl-4{gap:1.5rem!important}.gap-xxl-5{gap:3rem!important}.justify-content-xxl-start{justify-content:flex-start!important}.justify-content-xxl-end{justify-content:flex-end!important}.justify-content-xxl-center{justify-content:center!important}.justify-content-xxl-between{justify-content:space-between!important}.justify-content-xxl-around{justify-content:space-around!important}.justify-content-xxl-evenly{justify-content:space-evenly!important}.align-items-xxl-start{align-items:flex-start!important}.align-items-xxl-end{align-items:flex-end!important}.align-items-xxl-center{align-items:center!important}.align-items-xxl-baseline{align-items:baseline!important}.align-items-xxl-stretch{align-items:stretch!important}.align-content-xxl-start{align-content:flex-start!important}.align-content-xxl-end{align-content:flex-end!important}.align-content-xxl-center{align-content:center!important}.align-content-xxl-between{align-content:space-between!important}.align-content-xxl-around{align-content:space-around!important}.align-content-xxl-stretch{align-content:stretch!important}.align-self-xxl-auto{align-self:auto!important}.align-self-xxl-start{align-self:flex-start!important}.align-self-xxl-end{align-self:flex-end!important}.align-self-xxl-center{align-self:center!important}.align-self-xxl-baseline{align-self:baseline!important}.align-self-xxl-stretch{align-self:stretch!important}.order-xxl-first{order:-1!important}.order-xxl-0{order:0!important}.order-xxl-1{order:1!important}.order-xxl-2{order:2!important}.order-xxl-3{order:3!important}.order-xxl-4{order:4!important}.order-xxl-5{order:5!important}.order-xxl-last{order:6!important}.m-xxl-0{margin:0!important}.m-xxl-1{margin:.25rem!important}.m-xxl-2{margin:.5rem!important}.m-xxl-3{margin:1rem!important}.m-xxl-4{margin:1.5rem!important}.m-xxl-5{margin:3rem!important}.m-xxl-auto{margin:auto!important}.mx-xxl-0{margin-right:0!important;margin-left:0!important}.mx-xxl-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-xxl-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-xxl-3{margin-right:1rem!important;margin-left:1rem!important}.mx-xxl-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-xxl-5{margin-right:3rem!important;margin-left:3rem!important}.mx-xxl-auto{margin-right:auto!important;margin-left:auto!important}.my-xxl-0{margin-top:0!important;margin-bottom:0!important}.my-xxl-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-xxl-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-xxl-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-xxl-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-xxl-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-xxl-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-xxl-0{margin-top:0!important}.mt-xxl-1{margin-top:.25rem!important}.mt-xxl-2{margin-top:.5rem!important}.mt-xxl-3{margin-top:1rem!important}.mt-xxl-4{margin-top:1.5rem!important}.mt-xxl-5{margin-top:3rem!important}.mt-xxl-auto{margin-top:auto!important}.me-xxl-0{margin-right:0!important}.me-xxl-1{margin-right:.25rem!important}.me-xxl-2{margin-right:.5rem!important}.me-xxl-3{margin-right:1rem!important}.me-xxl-4{margin-right:1.5rem!important}.me-xxl-5{margin-right:3rem!important}.me-xxl-auto{margin-right:auto!important}.mb-xxl-0{margin-bottom:0!important}.mb-xxl-1{margin-bottom:.25rem!important}.mb-xxl-2{margin-bottom:.5rem!important}.mb-xxl-3{margin-bottom:1rem!important}.mb-xxl-4{margin-bottom:1.5rem!important}.mb-xxl-5{margin-bottom:3rem!important}.mb-xxl-auto{margin-bottom:auto!important}.ms-xxl-0{margin-left:0!important}.ms-xxl-1{margin-left:.25rem!important}.ms-xxl-2{margin-left:.5rem!important}.ms-xxl-3{margin-left:1rem!important}.ms-xxl-4{margin-left:1.5rem!important}.ms-xxl-5{margin-left:3rem!important}.ms-xxl-auto{margin-left:auto!important}.p-xxl-0{padding:0!important}.p-xxl-1{padding:.25rem!important}.p-xxl-2{padding:.5rem!important}.p-xxl-3{padding:1rem!important}.p-xxl-4{padding:1.5rem!important}.p-xxl-5{padding:3rem!important}.px-xxl-0{padding-right:0!important;padding-left:0!important}.px-xxl-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-xxl-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-xxl-3{padding-right:1rem!important;padding-left:1rem!important}.px-xxl-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-xxl-5{padding-right:3rem!important;padding-left:3rem!important}.py-xxl-0{padding-top:0!important;padding-bottom:0!important}.py-xxl-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-xxl-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-xxl-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-xxl-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-xxl-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-xxl-0{padding-top:0!important}.pt-xxl-1{padding-top:.25rem!important}.pt-xxl-2{padding-top:.5rem!important}.pt-xxl-3{padding-top:1rem!important}.pt-xxl-4{padding-top:1.5rem!important}.pt-xxl-5{padding-top:3rem!important}.pe-xxl-0{padding-right:0!important}.pe-xxl-1{padding-right:.25rem!important}.pe-xxl-2{padding-right:.5rem!important}.pe-xxl-3{padding-right:1rem!important}.pe-xxl-4{padding-right:1.5rem!important}.pe-xxl-5{padding-right:3rem!important}.pb-xxl-0{padding-bottom:0!important}.pb-xxl-1{padding-bottom:.25rem!important}.pb-xxl-2{padding-bottom:.5rem!important}.pb-xxl-3{padding-bottom:1rem!important}.pb-xxl-4{padding-bottom:1.5rem!important}.pb-xxl-5{padding-bottom:3rem!important}.ps-xxl-0{padding-left:0!important}.ps-xxl-1{padding-left:.25rem!important}.ps-xxl-2{padding-left:.5rem!important}.ps-xxl-3{padding-left:1rem!important}.ps-xxl-4{padding-left:1.5rem!important}.ps-xxl-5{padding-left:3rem!important}.text-xxl-start{text-align:left!important}.text-xxl-end{text-align:right!important}.text-xxl-center{text-align:center!important}}@media (min-width:1200px){.fs-1{font-size:2.5rem!important}.fs-2{font-size:2rem!important}.fs-3{font-size:1.75rem!important}.fs-4{font-size:1.5rem!important}}@media print{.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-grid{display:grid!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:flex!important}.d-print-inline-flex{display:inline-flex!important}.d-print-none{display:none!important}}
+/*# sourceMappingURL=bootstrap.min.css.map */
\ No newline at end of file
diff --git a/src/main/resources/web/index.tmpl b/src/main/resources/web/index.tmpl
new file mode 100644
index 0000000..6123bd4
--- /dev/null
+++ b/src/main/resources/web/index.tmpl
@@ -0,0 +1,78 @@
+
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="description" content="">
+    <title>Trader</title>
+
+    <!-- Bootstrap core CSS -->
+    <link href="css/bootstrap.min.js">
+
+    <!-- Favicons -->
+    <link rel="apple-touch-icon" href="/docs/5.0/assets/img/favicons/apple-touch-icon.png" sizes="180x180">
+    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon-32x32.png" sizes="32x32" type="image/png">
+    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon-16x16.png" sizes="16x16" type="image/png">
+    <link rel="manifest" href="/docs/5.0/assets/img/favicons/manifest.json">
+    <link rel="mask-icon" href="/docs/5.0/assets/img/favicons/safari-pinned-tab.svg" color="#7952b3">
+    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon.ico">
+</head>
+
+<body>
+    <header class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0 shadow">
+        <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="#">Company name</a>
+        <button class="navbar-toggler position-absolute d-md-none collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#sidebarMenu" aria-controls="sidebarMenu" aria-expanded="false" aria-label="Toggle navigation">
+            <span class="navbar-toggler-icon"></span>
+        </button>
+        <input class="form-control form-control-dark w-100" type="text" placeholder="Search" aria-label="Search">
+        <ul class="navbar-nav px-3">
+            <li class="nav-item text-nowrap">
+                <a class="nav-link" href="#">Sign out</a>
+            </li>
+        </ul>
+    </header>
+
+    <div class="container-fluid">
+        <div class="row">
+            <nav id="sidebarMenu" class="col-md-3 col-lg-2 d-md-block bg-light sidebar collapse">
+                <div class="position-sticky pt-3">
+                    <ul class="nav flex-column">
+                        <li class="nav-item">
+                            <a class="nav-link active" aria-current="page" href="#">
+                                <span data-feather="home"></span>
+                                Dashboard
+                            </a>
+                        </li>
+                        <li class="nav-item">
+                            <a class="nav-link" href="#">
+                                <span data-feather="file"></span>
+                                Orders
+                            </a>
+                        </li>
+                    </ul>
+
+                    <h6 class="sidebar-heading d-flex justify-content-between align-items-center px-3 mt-4 mb-1 text-muted">
+                        <span>Saved reports</span>
+                        <a class="link-secondary" href="#" aria-label="Add a new report">
+                            <span data-feather="plus-circle"></span>
+                        </a>
+                    </h6>
+                    <ul class="nav flex-column mb-2">
+                        <li class="nav-item">
+                            <a class="nav-link" href="#">
+                                <span data-feather="file-text"></span>
+                                Current month
+                            </a>
+                        </li>
+                    </ul>
+                </div>
+            </nav>
+
+            <main class="col-md-9 ms-sm-auto col-lg-10 px-md-4">
+                {{content}}
+            </main>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/src/main/resources/web/js/bootstrap.bundle.js b/src/main/resources/web/js/bootstrap.bundle.js
new file mode 100644
index 0000000..1678cd2
--- /dev/null
+++ b/src/main/resources/web/js/bootstrap.bundle.js
@@ -0,0 +1,6650 @@
+/*!
+  * Bootstrap v5.0.0-beta2 (https://getbootstrap.com/)
+  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+  */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory());
+}(this, (function () { 'use strict';
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+
+    _setPrototypeOf(subClass, superClass);
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): util/index.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+  var MAX_UID = 1000000;
+  var MILLISECONDS_MULTIPLIER = 1000;
+  var TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
+
+  var toType = function toType(obj) {
+    if (obj === null || obj === undefined) {
+      return "" + obj;
+    }
+
+    return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
+  };
+  /**
+   * --------------------------------------------------------------------------
+   * Public Util Api
+   * --------------------------------------------------------------------------
+   */
+
+
+  var getUID = function getUID(prefix) {
+    do {
+      prefix += Math.floor(Math.random() * MAX_UID);
+    } while (document.getElementById(prefix));
+
+    return prefix;
+  };
+
+  var getSelector = function getSelector(element) {
+    var selector = element.getAttribute('data-bs-target');
+
+    if (!selector || selector === '#') {
+      var hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
+      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
+      // `document.querySelector` will rightfully complain it is invalid.
+      // See https://github.com/twbs/bootstrap/issues/32273
+
+      if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {
+        return null;
+      } // Just in case some CMS puts out a full URL with the anchor appended
+
+
+      if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
+        hrefAttr = '#' + hrefAttr.split('#')[1];
+      }
+
+      selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
+    }
+
+    return selector;
+  };
+
+  var getSelectorFromElement = function getSelectorFromElement(element) {
+    var selector = getSelector(element);
+
+    if (selector) {
+      return document.querySelector(selector) ? selector : null;
+    }
+
+    return null;
+  };
+
+  var getElementFromSelector = function getElementFromSelector(element) {
+    var selector = getSelector(element);
+    return selector ? document.querySelector(selector) : null;
+  };
+
+  var getTransitionDurationFromElement = function getTransitionDurationFromElement(element) {
+    if (!element) {
+      return 0;
+    } // Get transition-duration of the element
+
+
+    var _window$getComputedSt = window.getComputedStyle(element),
+        transitionDuration = _window$getComputedSt.transitionDuration,
+        transitionDelay = _window$getComputedSt.transitionDelay;
+
+    var floatTransitionDuration = Number.parseFloat(transitionDuration);
+    var floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
+
+    if (!floatTransitionDuration && !floatTransitionDelay) {
+      return 0;
+    } // If multiple durations are defined, take the first
+
+
+    transitionDuration = transitionDuration.split(',')[0];
+    transitionDelay = transitionDelay.split(',')[0];
+    return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
+  };
+
+  var triggerTransitionEnd = function triggerTransitionEnd(element) {
+    element.dispatchEvent(new Event(TRANSITION_END));
+  };
+
+  var isElement = function isElement(obj) {
+    return (obj[0] || obj).nodeType;
+  };
+
+  var emulateTransitionEnd = function emulateTransitionEnd(element, duration) {
+    var called = false;
+    var durationPadding = 5;
+    var emulatedDuration = duration + durationPadding;
+
+    function listener() {
+      called = true;
+      element.removeEventListener(TRANSITION_END, listener);
+    }
+
+    element.addEventListener(TRANSITION_END, listener);
+    setTimeout(function () {
+      if (!called) {
+        triggerTransitionEnd(element);
+      }
+    }, emulatedDuration);
+  };
+
+  var typeCheckConfig = function typeCheckConfig(componentName, config, configTypes) {
+    Object.keys(configTypes).forEach(function (property) {
+      var expectedTypes = configTypes[property];
+      var value = config[property];
+      var valueType = value && isElement(value) ? 'element' : toType(value);
+
+      if (!new RegExp(expectedTypes).test(valueType)) {
+        throw new TypeError(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
+      }
+    });
+  };
+
+  var isVisible = function isVisible(element) {
+    if (!element) {
+      return false;
+    }
+
+    if (element.style && element.parentNode && element.parentNode.style) {
+      var elementStyle = getComputedStyle(element);
+      var parentNodeStyle = getComputedStyle(element.parentNode);
+      return elementStyle.display !== 'none' && parentNodeStyle.display !== 'none' && elementStyle.visibility !== 'hidden';
+    }
+
+    return false;
+  };
+
+  var findShadowRoot = function findShadowRoot(element) {
+    if (!document.documentElement.attachShadow) {
+      return null;
+    } // Can find the shadow root otherwise it'll return the document
+
+
+    if (typeof element.getRootNode === 'function') {
+      var root = element.getRootNode();
+      return root instanceof ShadowRoot ? root : null;
+    }
+
+    if (element instanceof ShadowRoot) {
+      return element;
+    } // when we don't find a shadow root
+
+
+    if (!element.parentNode) {
+      return null;
+    }
+
+    return findShadowRoot(element.parentNode);
+  };
+
+  var noop = function noop() {
+    return function () {};
+  };
+
+  var reflow = function reflow(element) {
+    return element.offsetHeight;
+  };
+
+  var getjQuery = function getjQuery() {
+    var _window = window,
+        jQuery = _window.jQuery;
+
+    if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
+      return jQuery;
+    }
+
+    return null;
+  };
+
+  var onDOMContentLoaded = function onDOMContentLoaded(callback) {
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', callback);
+    } else {
+      callback();
+    }
+  };
+
+  var isRTL = document.documentElement.dir === 'rtl';
+
+  var defineJQueryPlugin = function defineJQueryPlugin(name, plugin) {
+    onDOMContentLoaded(function () {
+      var $ = getjQuery();
+      /* istanbul ignore if */
+
+      if ($) {
+        var JQUERY_NO_CONFLICT = $.fn[name];
+        $.fn[name] = plugin.jQueryInterface;
+        $.fn[name].Constructor = plugin;
+
+        $.fn[name].noConflict = function () {
+          $.fn[name] = JQUERY_NO_CONFLICT;
+          return plugin.jQueryInterface;
+        };
+      }
+    });
+  };
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): dom/data.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+  var mapData = function () {
+    var storeData = {};
+    var id = 1;
+    return {
+      set: function set(element, key, data) {
+        if (typeof element.bsKey === 'undefined') {
+          element.bsKey = {
+            key: key,
+            id: id
+          };
+          id++;
+        }
+
+        storeData[element.bsKey.id] = data;
+      },
+      get: function get(element, key) {
+        if (!element || typeof element.bsKey === 'undefined') {
+          return null;
+        }
+
+        var keyProperties = element.bsKey;
+
+        if (keyProperties.key === key) {
+          return storeData[keyProperties.id];
+        }
+
+        return null;
+      },
+      delete: function _delete(element, key) {
+        if (typeof element.bsKey === 'undefined') {
+          return;
+        }
+
+        var keyProperties = element.bsKey;
+
+        if (keyProperties.key === key) {
+          delete storeData[keyProperties.id];
+          delete element.bsKey;
+        }
+      }
+    };
+  }();
+
+  var Data = {
+    setData: function setData(instance, key, data) {
+      mapData.set(instance, key, data);
+    },
+    getData: function getData(instance, key) {
+      return mapData.get(instance, key);
+    },
+    removeData: function removeData(instance, key) {
+      mapData.delete(instance, key);
+    }
+  };
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): dom/event-handler.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var namespaceRegex = /[^.]*(?=\..*)\.|.*/;
+  var stripNameRegex = /\..*/;
+  var stripUidRegex = /::\d+$/;
+  var eventRegistry = {}; // Events storage
+
+  var uidEvent = 1;
+  var customEvents = {
+    mouseenter: 'mouseover',
+    mouseleave: 'mouseout'
+  };
+  var nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
+  /**
+   * ------------------------------------------------------------------------
+   * Private methods
+   * ------------------------------------------------------------------------
+   */
+
+  function getUidEvent(element, uid) {
+    return uid && uid + "::" + uidEvent++ || element.uidEvent || uidEvent++;
+  }
+
+  function getEvent(element) {
+    var uid = getUidEvent(element);
+    element.uidEvent = uid;
+    eventRegistry[uid] = eventRegistry[uid] || {};
+    return eventRegistry[uid];
+  }
+
+  function bootstrapHandler(element, fn) {
+    return function handler(event) {
+      event.delegateTarget = element;
+
+      if (handler.oneOff) {
+        EventHandler.off(element, event.type, fn);
+      }
+
+      return fn.apply(element, [event]);
+    };
+  }
+
+  function bootstrapDelegationHandler(element, selector, fn) {
+    return function handler(event) {
+      var domElements = element.querySelectorAll(selector);
+
+      for (var target = event.target; target && target !== this; target = target.parentNode) {
+        for (var i = domElements.length; i--;) {
+          if (domElements[i] === target) {
+            event.delegateTarget = target;
+
+            if (handler.oneOff) {
+              // eslint-disable-next-line unicorn/consistent-destructuring
+              EventHandler.off(element, event.type, fn);
+            }
+
+            return fn.apply(target, [event]);
+          }
+        }
+      } // To please ESLint
+
+
+      return null;
+    };
+  }
+
+  function findHandler(events, handler, delegationSelector) {
+    if (delegationSelector === void 0) {
+      delegationSelector = null;
+    }
+
+    var uidEventList = Object.keys(events);
+
+    for (var i = 0, len = uidEventList.length; i < len; i++) {
+      var event = events[uidEventList[i]];
+
+      if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
+        return event;
+      }
+    }
+
+    return null;
+  }
+
+  function normalizeParams(originalTypeEvent, handler, delegationFn) {
+    var delegation = typeof handler === 'string';
+    var originalHandler = delegation ? delegationFn : handler; // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
+
+    var typeEvent = originalTypeEvent.replace(stripNameRegex, '');
+    var custom = customEvents[typeEvent];
+
+    if (custom) {
+      typeEvent = custom;
+    }
+
+    var isNative = nativeEvents.has(typeEvent);
+
+    if (!isNative) {
+      typeEvent = originalTypeEvent;
+    }
+
+    return [delegation, originalHandler, typeEvent];
+  }
+
+  function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
+    if (typeof originalTypeEvent !== 'string' || !element) {
+      return;
+    }
+
+    if (!handler) {
+      handler = delegationFn;
+      delegationFn = null;
+    }
+
+    var _normalizeParams = normalizeParams(originalTypeEvent, handler, delegationFn),
+        delegation = _normalizeParams[0],
+        originalHandler = _normalizeParams[1],
+        typeEvent = _normalizeParams[2];
+
+    var events = getEvent(element);
+    var handlers = events[typeEvent] || (events[typeEvent] = {});
+    var previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
+
+    if (previousFn) {
+      previousFn.oneOff = previousFn.oneOff && oneOff;
+      return;
+    }
+
+    var uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
+    var fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
+    fn.delegationSelector = delegation ? handler : null;
+    fn.originalHandler = originalHandler;
+    fn.oneOff = oneOff;
+    fn.uidEvent = uid;
+    handlers[uid] = fn;
+    element.addEventListener(typeEvent, fn, delegation);
+  }
+
+  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
+    var fn = findHandler(events[typeEvent], handler, delegationSelector);
+
+    if (!fn) {
+      return;
+    }
+
+    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
+    delete events[typeEvent][fn.uidEvent];
+  }
+
+  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
+    var storeElementEvent = events[typeEvent] || {};
+    Object.keys(storeElementEvent).forEach(function (handlerKey) {
+      if (handlerKey.includes(namespace)) {
+        var event = storeElementEvent[handlerKey];
+        removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
+      }
+    });
+  }
+
+  var EventHandler = {
+    on: function on(element, event, handler, delegationFn) {
+      addHandler(element, event, handler, delegationFn, false);
+    },
+    one: function one(element, event, handler, delegationFn) {
+      addHandler(element, event, handler, delegationFn, true);
+    },
+    off: function off(element, originalTypeEvent, handler, delegationFn) {
+      if (typeof originalTypeEvent !== 'string' || !element) {
+        return;
+      }
+
+      var _normalizeParams2 = normalizeParams(originalTypeEvent, handler, delegationFn),
+          delegation = _normalizeParams2[0],
+          originalHandler = _normalizeParams2[1],
+          typeEvent = _normalizeParams2[2];
+
+      var inNamespace = typeEvent !== originalTypeEvent;
+      var events = getEvent(element);
+      var isNamespace = originalTypeEvent.startsWith('.');
+
+      if (typeof originalHandler !== 'undefined') {
+        // Simplest case: handler is passed, remove that listener ONLY.
+        if (!events || !events[typeEvent]) {
+          return;
+        }
+
+        removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
+        return;
+      }
+
+      if (isNamespace) {
+        Object.keys(events).forEach(function (elementEvent) {
+          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
+        });
+      }
+
+      var storeElementEvent = events[typeEvent] || {};
+      Object.keys(storeElementEvent).forEach(function (keyHandlers) {
+        var handlerKey = keyHandlers.replace(stripUidRegex, '');
+
+        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
+          var event = storeElementEvent[keyHandlers];
+          removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
+        }
+      });
+    },
+    trigger: function trigger(element, event, args) {
+      if (typeof event !== 'string' || !element) {
+        return null;
+      }
+
+      var $ = getjQuery();
+      var typeEvent = event.replace(stripNameRegex, '');
+      var inNamespace = event !== typeEvent;
+      var isNative = nativeEvents.has(typeEvent);
+      var jQueryEvent;
+      var bubbles = true;
+      var nativeDispatch = true;
+      var defaultPrevented = false;
+      var evt = null;
+
+      if (inNamespace && $) {
+        jQueryEvent = $.Event(event, args);
+        $(element).trigger(jQueryEvent);
+        bubbles = !jQueryEvent.isPropagationStopped();
+        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
+        defaultPrevented = jQueryEvent.isDefaultPrevented();
+      }
+
+      if (isNative) {
+        evt = document.createEvent('HTMLEvents');
+        evt.initEvent(typeEvent, bubbles, true);
+      } else {
+        evt = new CustomEvent(event, {
+          bubbles: bubbles,
+          cancelable: true
+        });
+      } // merge custom information in our event
+
+
+      if (typeof args !== 'undefined') {
+        Object.keys(args).forEach(function (key) {
+          Object.defineProperty(evt, key, {
+            get: function get() {
+              return args[key];
+            }
+          });
+        });
+      }
+
+      if (defaultPrevented) {
+        evt.preventDefault();
+      }
+
+      if (nativeDispatch) {
+        element.dispatchEvent(evt);
+      }
+
+      if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
+        jQueryEvent.preventDefault();
+      }
+
+      return evt;
+    }
+  };
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var VERSION = '5.0.0-beta2';
+
+  var BaseComponent = /*#__PURE__*/function () {
+    function BaseComponent(element) {
+      if (!element) {
+        return;
+      }
+
+      this._element = element;
+      Data.setData(element, this.constructor.DATA_KEY, this);
+    }
+
+    var _proto = BaseComponent.prototype;
+
+    _proto.dispose = function dispose() {
+      Data.removeData(this._element, this.constructor.DATA_KEY);
+      this._element = null;
+    }
+    /** Static */
+    ;
+
+    BaseComponent.getInstance = function getInstance(element) {
+      return Data.getData(element, this.DATA_KEY);
+    };
+
+    _createClass(BaseComponent, null, [{
+      key: "VERSION",
+      get: function get() {
+        return VERSION;
+      }
+    }]);
+
+    return BaseComponent;
+  }();
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME = 'alert';
+  var DATA_KEY = 'bs.alert';
+  var EVENT_KEY = "." + DATA_KEY;
+  var DATA_API_KEY = '.data-api';
+  var SELECTOR_DISMISS = '[data-bs-dismiss="alert"]';
+  var EVENT_CLOSE = "close" + EVENT_KEY;
+  var EVENT_CLOSED = "closed" + EVENT_KEY;
+  var EVENT_CLICK_DATA_API = "click" + EVENT_KEY + DATA_API_KEY;
+  var CLASS_NAME_ALERT = 'alert';
+  var CLASS_NAME_FADE = 'fade';
+  var CLASS_NAME_SHOW = 'show';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Alert = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Alert, _BaseComponent);
+
+    function Alert() {
+      return _BaseComponent.apply(this, arguments) || this;
+    }
+
+    var _proto = Alert.prototype;
+
+    // Public
+    _proto.close = function close(element) {
+      var rootElement = element ? this._getRootElement(element) : this._element;
+
+      var customEvent = this._triggerCloseEvent(rootElement);
+
+      if (customEvent === null || customEvent.defaultPrevented) {
+        return;
+      }
+
+      this._removeElement(rootElement);
+    } // Private
+    ;
+
+    _proto._getRootElement = function _getRootElement(element) {
+      return getElementFromSelector(element) || element.closest("." + CLASS_NAME_ALERT);
+    };
+
+    _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
+      return EventHandler.trigger(element, EVENT_CLOSE);
+    };
+
+    _proto._removeElement = function _removeElement(element) {
+      var _this = this;
+
+      element.classList.remove(CLASS_NAME_SHOW);
+
+      if (!element.classList.contains(CLASS_NAME_FADE)) {
+        this._destroyElement(element);
+
+        return;
+      }
+
+      var transitionDuration = getTransitionDurationFromElement(element);
+      EventHandler.one(element, 'transitionend', function () {
+        return _this._destroyElement(element);
+      });
+      emulateTransitionEnd(element, transitionDuration);
+    };
+
+    _proto._destroyElement = function _destroyElement(element) {
+      if (element.parentNode) {
+        element.parentNode.removeChild(element);
+      }
+
+      EventHandler.trigger(element, EVENT_CLOSED);
+    } // Static
+    ;
+
+    Alert.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY);
+
+        if (!data) {
+          data = new Alert(this);
+        }
+
+        if (config === 'close') {
+          data[config](this);
+        }
+      });
+    };
+
+    Alert.handleDismiss = function handleDismiss(alertInstance) {
+      return function (event) {
+        if (event) {
+          event.preventDefault();
+        }
+
+        alertInstance.close(this);
+      };
+    };
+
+    _createClass(Alert, null, [{
+      key: "DATA_KEY",
+      get: // Getters
+      function get() {
+        return DATA_KEY;
+      }
+    }]);
+
+    return Alert;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DISMISS, Alert.handleDismiss(new Alert()));
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Alert to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME, Alert);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$1 = 'button';
+  var DATA_KEY$1 = 'bs.button';
+  var EVENT_KEY$1 = "." + DATA_KEY$1;
+  var DATA_API_KEY$1 = '.data-api';
+  var CLASS_NAME_ACTIVE = 'active';
+  var SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]';
+  var EVENT_CLICK_DATA_API$1 = "click" + EVENT_KEY$1 + DATA_API_KEY$1;
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Button = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Button, _BaseComponent);
+
+    function Button() {
+      return _BaseComponent.apply(this, arguments) || this;
+    }
+
+    var _proto = Button.prototype;
+
+    // Public
+    _proto.toggle = function toggle() {
+      // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
+      this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE));
+    } // Static
+    ;
+
+    Button.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$1);
+
+        if (!data) {
+          data = new Button(this);
+        }
+
+        if (config === 'toggle') {
+          data[config]();
+        }
+      });
+    };
+
+    _createClass(Button, null, [{
+      key: "DATA_KEY",
+      get: // Getters
+      function get() {
+        return DATA_KEY$1;
+      }
+    }]);
+
+    return Button;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE, function (event) {
+    event.preventDefault();
+    var button = event.target.closest(SELECTOR_DATA_TOGGLE);
+    var data = Data.getData(button, DATA_KEY$1);
+
+    if (!data) {
+      data = new Button(button);
+    }
+
+    data.toggle();
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Button to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$1, Button);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): dom/manipulator.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+  function normalizeData(val) {
+    if (val === 'true') {
+      return true;
+    }
+
+    if (val === 'false') {
+      return false;
+    }
+
+    if (val === Number(val).toString()) {
+      return Number(val);
+    }
+
+    if (val === '' || val === 'null') {
+      return null;
+    }
+
+    return val;
+  }
+
+  function normalizeDataKey(key) {
+    return key.replace(/[A-Z]/g, function (chr) {
+      return "-" + chr.toLowerCase();
+    });
+  }
+
+  var Manipulator = {
+    setDataAttribute: function setDataAttribute(element, key, value) {
+      element.setAttribute("data-bs-" + normalizeDataKey(key), value);
+    },
+    removeDataAttribute: function removeDataAttribute(element, key) {
+      element.removeAttribute("data-bs-" + normalizeDataKey(key));
+    },
+    getDataAttributes: function getDataAttributes(element) {
+      if (!element) {
+        return {};
+      }
+
+      var attributes = {};
+      Object.keys(element.dataset).filter(function (key) {
+        return key.startsWith('bs');
+      }).forEach(function (key) {
+        var pureKey = key.replace(/^bs/, '');
+        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
+        attributes[pureKey] = normalizeData(element.dataset[key]);
+      });
+      return attributes;
+    },
+    getDataAttribute: function getDataAttribute(element, key) {
+      return normalizeData(element.getAttribute("data-bs-" + normalizeDataKey(key)));
+    },
+    offset: function offset(element) {
+      var rect = element.getBoundingClientRect();
+      return {
+        top: rect.top + document.body.scrollTop,
+        left: rect.left + document.body.scrollLeft
+      };
+    },
+    position: function position(element) {
+      return {
+        top: element.offsetTop,
+        left: element.offsetLeft
+      };
+    }
+  };
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): dom/selector-engine.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+  var NODE_TEXT = 3;
+  var SelectorEngine = {
+    find: function find(selector, element) {
+      var _ref;
+
+      if (element === void 0) {
+        element = document.documentElement;
+      }
+
+      return (_ref = []).concat.apply(_ref, Element.prototype.querySelectorAll.call(element, selector));
+    },
+    findOne: function findOne(selector, element) {
+      if (element === void 0) {
+        element = document.documentElement;
+      }
+
+      return Element.prototype.querySelector.call(element, selector);
+    },
+    children: function children(element, selector) {
+      var _ref2;
+
+      return (_ref2 = []).concat.apply(_ref2, element.children).filter(function (child) {
+        return child.matches(selector);
+      });
+    },
+    parents: function parents(element, selector) {
+      var parents = [];
+      var ancestor = element.parentNode;
+
+      while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
+        if (ancestor.matches(selector)) {
+          parents.push(ancestor);
+        }
+
+        ancestor = ancestor.parentNode;
+      }
+
+      return parents;
+    },
+    prev: function prev(element, selector) {
+      var previous = element.previousElementSibling;
+
+      while (previous) {
+        if (previous.matches(selector)) {
+          return [previous];
+        }
+
+        previous = previous.previousElementSibling;
+      }
+
+      return [];
+    },
+    next: function next(element, selector) {
+      var next = element.nextElementSibling;
+
+      while (next) {
+        if (next.matches(selector)) {
+          return [next];
+        }
+
+        next = next.nextElementSibling;
+      }
+
+      return [];
+    }
+  };
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$2 = 'carousel';
+  var DATA_KEY$2 = 'bs.carousel';
+  var EVENT_KEY$2 = "." + DATA_KEY$2;
+  var DATA_API_KEY$2 = '.data-api';
+  var ARROW_LEFT_KEY = 'ArrowLeft';
+  var ARROW_RIGHT_KEY = 'ArrowRight';
+  var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
+
+  var SWIPE_THRESHOLD = 40;
+  var Default = {
+    interval: 5000,
+    keyboard: true,
+    slide: false,
+    pause: 'hover',
+    wrap: true,
+    touch: true
+  };
+  var DefaultType = {
+    interval: '(number|boolean)',
+    keyboard: 'boolean',
+    slide: '(boolean|string)',
+    pause: '(string|boolean)',
+    wrap: 'boolean',
+    touch: 'boolean'
+  };
+  var DIRECTION_NEXT = 'next';
+  var DIRECTION_PREV = 'prev';
+  var DIRECTION_LEFT = 'left';
+  var DIRECTION_RIGHT = 'right';
+  var EVENT_SLIDE = "slide" + EVENT_KEY$2;
+  var EVENT_SLID = "slid" + EVENT_KEY$2;
+  var EVENT_KEYDOWN = "keydown" + EVENT_KEY$2;
+  var EVENT_MOUSEENTER = "mouseenter" + EVENT_KEY$2;
+  var EVENT_MOUSELEAVE = "mouseleave" + EVENT_KEY$2;
+  var EVENT_TOUCHSTART = "touchstart" + EVENT_KEY$2;
+  var EVENT_TOUCHMOVE = "touchmove" + EVENT_KEY$2;
+  var EVENT_TOUCHEND = "touchend" + EVENT_KEY$2;
+  var EVENT_POINTERDOWN = "pointerdown" + EVENT_KEY$2;
+  var EVENT_POINTERUP = "pointerup" + EVENT_KEY$2;
+  var EVENT_DRAG_START = "dragstart" + EVENT_KEY$2;
+  var EVENT_LOAD_DATA_API = "load" + EVENT_KEY$2 + DATA_API_KEY$2;
+  var EVENT_CLICK_DATA_API$2 = "click" + EVENT_KEY$2 + DATA_API_KEY$2;
+  var CLASS_NAME_CAROUSEL = 'carousel';
+  var CLASS_NAME_ACTIVE$1 = 'active';
+  var CLASS_NAME_SLIDE = 'slide';
+  var CLASS_NAME_END = 'carousel-item-end';
+  var CLASS_NAME_START = 'carousel-item-start';
+  var CLASS_NAME_NEXT = 'carousel-item-next';
+  var CLASS_NAME_PREV = 'carousel-item-prev';
+  var CLASS_NAME_POINTER_EVENT = 'pointer-event';
+  var SELECTOR_ACTIVE = '.active';
+  var SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
+  var SELECTOR_ITEM = '.carousel-item';
+  var SELECTOR_ITEM_IMG = '.carousel-item img';
+  var SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev';
+  var SELECTOR_INDICATORS = '.carousel-indicators';
+  var SELECTOR_INDICATOR = '[data-bs-target]';
+  var SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
+  var SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
+  var POINTER_TYPE_TOUCH = 'touch';
+  var POINTER_TYPE_PEN = 'pen';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Carousel = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Carousel, _BaseComponent);
+
+    function Carousel(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._items = null;
+      _this._interval = null;
+      _this._activeElement = null;
+      _this._isPaused = false;
+      _this._isSliding = false;
+      _this.touchTimeout = null;
+      _this.touchStartX = 0;
+      _this.touchDeltaX = 0;
+      _this._config = _this._getConfig(config);
+      _this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, _this._element);
+      _this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
+      _this._pointerEvent = Boolean(window.PointerEvent);
+
+      _this._addEventListeners();
+
+      return _this;
+    } // Getters
+
+
+    var _proto = Carousel.prototype;
+
+    // Public
+    _proto.next = function next() {
+      if (!this._isSliding) {
+        this._slide(DIRECTION_NEXT);
+      }
+    };
+
+    _proto.nextWhenVisible = function nextWhenVisible() {
+      // Don't call next when the page isn't visible
+      // or the carousel or its parent isn't visible
+      if (!document.hidden && isVisible(this._element)) {
+        this.next();
+      }
+    };
+
+    _proto.prev = function prev() {
+      if (!this._isSliding) {
+        this._slide(DIRECTION_PREV);
+      }
+    };
+
+    _proto.pause = function pause(event) {
+      if (!event) {
+        this._isPaused = true;
+      }
+
+      if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
+        triggerTransitionEnd(this._element);
+        this.cycle(true);
+      }
+
+      clearInterval(this._interval);
+      this._interval = null;
+    };
+
+    _proto.cycle = function cycle(event) {
+      if (!event) {
+        this._isPaused = false;
+      }
+
+      if (this._interval) {
+        clearInterval(this._interval);
+        this._interval = null;
+      }
+
+      if (this._config && this._config.interval && !this._isPaused) {
+        this._updateInterval();
+
+        this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
+      }
+    };
+
+    _proto.to = function to(index) {
+      var _this2 = this;
+
+      this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
+
+      var activeIndex = this._getItemIndex(this._activeElement);
+
+      if (index > this._items.length - 1 || index < 0) {
+        return;
+      }
+
+      if (this._isSliding) {
+        EventHandler.one(this._element, EVENT_SLID, function () {
+          return _this2.to(index);
+        });
+        return;
+      }
+
+      if (activeIndex === index) {
+        this.pause();
+        this.cycle();
+        return;
+      }
+
+      var direction = index > activeIndex ? DIRECTION_NEXT : DIRECTION_PREV;
+
+      this._slide(direction, this._items[index]);
+    };
+
+    _proto.dispose = function dispose() {
+      _BaseComponent.prototype.dispose.call(this);
+
+      EventHandler.off(this._element, EVENT_KEY$2);
+      this._items = null;
+      this._config = null;
+      this._interval = null;
+      this._isPaused = null;
+      this._isSliding = null;
+      this._activeElement = null;
+      this._indicatorsElement = null;
+    } // Private
+    ;
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, Default, config);
+      typeCheckConfig(NAME$2, config, DefaultType);
+      return config;
+    };
+
+    _proto._handleSwipe = function _handleSwipe() {
+      var absDeltax = Math.abs(this.touchDeltaX);
+
+      if (absDeltax <= SWIPE_THRESHOLD) {
+        return;
+      }
+
+      var direction = absDeltax / this.touchDeltaX;
+      this.touchDeltaX = 0; // swipe left
+
+      if (direction > 0) {
+        if (isRTL) {
+          this.next();
+        } else {
+          this.prev();
+        }
+      } // swipe right
+
+
+      if (direction < 0) {
+        if (isRTL) {
+          this.prev();
+        } else {
+          this.next();
+        }
+      }
+    };
+
+    _proto._addEventListeners = function _addEventListeners() {
+      var _this3 = this;
+
+      if (this._config.keyboard) {
+        EventHandler.on(this._element, EVENT_KEYDOWN, function (event) {
+          return _this3._keydown(event);
+        });
+      }
+
+      if (this._config.pause === 'hover') {
+        EventHandler.on(this._element, EVENT_MOUSEENTER, function (event) {
+          return _this3.pause(event);
+        });
+        EventHandler.on(this._element, EVENT_MOUSELEAVE, function (event) {
+          return _this3.cycle(event);
+        });
+      }
+
+      if (this._config.touch && this._touchSupported) {
+        this._addTouchEventListeners();
+      }
+    };
+
+    _proto._addTouchEventListeners = function _addTouchEventListeners() {
+      var _this4 = this;
+
+      var start = function start(event) {
+        if (_this4._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+          _this4.touchStartX = event.clientX;
+        } else if (!_this4._pointerEvent) {
+          _this4.touchStartX = event.touches[0].clientX;
+        }
+      };
+
+      var move = function move(event) {
+        // ensure swiping with one touch and not pinching
+        if (event.touches && event.touches.length > 1) {
+          _this4.touchDeltaX = 0;
+        } else {
+          _this4.touchDeltaX = event.touches[0].clientX - _this4.touchStartX;
+        }
+      };
+
+      var end = function end(event) {
+        if (_this4._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+          _this4.touchDeltaX = event.clientX - _this4.touchStartX;
+        }
+
+        _this4._handleSwipe();
+
+        if (_this4._config.pause === 'hover') {
+          // If it's a touch-enabled device, mouseenter/leave are fired as
+          // part of the mouse compatibility events on first tap - the carousel
+          // would stop cycling until user tapped out of it;
+          // here, we listen for touchend, explicitly pause the carousel
+          // (as if it's the second time we tap on it, mouseenter compat event
+          // is NOT fired) and after a timeout (to allow for mouse compatibility
+          // events to fire) we explicitly restart cycling
+          _this4.pause();
+
+          if (_this4.touchTimeout) {
+            clearTimeout(_this4.touchTimeout);
+          }
+
+          _this4.touchTimeout = setTimeout(function (event) {
+            return _this4.cycle(event);
+          }, TOUCHEVENT_COMPAT_WAIT + _this4._config.interval);
+        }
+      };
+
+      SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(function (itemImg) {
+        EventHandler.on(itemImg, EVENT_DRAG_START, function (e) {
+          return e.preventDefault();
+        });
+      });
+
+      if (this._pointerEvent) {
+        EventHandler.on(this._element, EVENT_POINTERDOWN, function (event) {
+          return start(event);
+        });
+        EventHandler.on(this._element, EVENT_POINTERUP, function (event) {
+          return end(event);
+        });
+
+        this._element.classList.add(CLASS_NAME_POINTER_EVENT);
+      } else {
+        EventHandler.on(this._element, EVENT_TOUCHSTART, function (event) {
+          return start(event);
+        });
+        EventHandler.on(this._element, EVENT_TOUCHMOVE, function (event) {
+          return move(event);
+        });
+        EventHandler.on(this._element, EVENT_TOUCHEND, function (event) {
+          return end(event);
+        });
+      }
+    };
+
+    _proto._keydown = function _keydown(event) {
+      if (/input|textarea/i.test(event.target.tagName)) {
+        return;
+      }
+
+      if (event.key === ARROW_LEFT_KEY) {
+        event.preventDefault();
+
+        if (isRTL) {
+          this.next();
+        } else {
+          this.prev();
+        }
+      } else if (event.key === ARROW_RIGHT_KEY) {
+        event.preventDefault();
+
+        if (isRTL) {
+          this.prev();
+        } else {
+          this.next();
+        }
+      }
+    };
+
+    _proto._getItemIndex = function _getItemIndex(element) {
+      this._items = element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
+      return this._items.indexOf(element);
+    };
+
+    _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
+      var isNextDirection = direction === DIRECTION_NEXT;
+      var isPrevDirection = direction === DIRECTION_PREV;
+
+      var activeIndex = this._getItemIndex(activeElement);
+
+      var lastItemIndex = this._items.length - 1;
+      var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
+
+      if (isGoingToWrap && !this._config.wrap) {
+        return activeElement;
+      }
+
+      var delta = direction === DIRECTION_PREV ? -1 : 1;
+      var itemIndex = (activeIndex + delta) % this._items.length;
+      return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
+    };
+
+    _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
+      var targetIndex = this._getItemIndex(relatedTarget);
+
+      var fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element));
+
+      return EventHandler.trigger(this._element, EVENT_SLIDE, {
+        relatedTarget: relatedTarget,
+        direction: eventDirectionName,
+        from: fromIndex,
+        to: targetIndex
+      });
+    };
+
+    _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
+      if (this._indicatorsElement) {
+        var activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
+        activeIndicator.classList.remove(CLASS_NAME_ACTIVE$1);
+        activeIndicator.removeAttribute('aria-current');
+        var indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
+
+        for (var i = 0; i < indicators.length; i++) {
+          if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
+            indicators[i].classList.add(CLASS_NAME_ACTIVE$1);
+            indicators[i].setAttribute('aria-current', 'true');
+            break;
+          }
+        }
+      }
+    };
+
+    _proto._updateInterval = function _updateInterval() {
+      var element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
+
+      if (!element) {
+        return;
+      }
+
+      var elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
+
+      if (elementInterval) {
+        this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
+        this._config.interval = elementInterval;
+      } else {
+        this._config.interval = this._config.defaultInterval || this._config.interval;
+      }
+    };
+
+    _proto._slide = function _slide(direction, element) {
+      var _this5 = this;
+
+      var activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
+
+      var activeElementIndex = this._getItemIndex(activeElement);
+
+      var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
+
+      var nextElementIndex = this._getItemIndex(nextElement);
+
+      var isCycling = Boolean(this._interval);
+      var directionalClassName = direction === DIRECTION_NEXT ? CLASS_NAME_START : CLASS_NAME_END;
+      var orderClassName = direction === DIRECTION_NEXT ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
+      var eventDirectionName = direction === DIRECTION_NEXT ? DIRECTION_LEFT : DIRECTION_RIGHT;
+
+      if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$1)) {
+        this._isSliding = false;
+        return;
+      }
+
+      var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
+
+      if (slideEvent.defaultPrevented) {
+        return;
+      }
+
+      if (!activeElement || !nextElement) {
+        // Some weirdness is happening, so we bail
+        return;
+      }
+
+      this._isSliding = true;
+
+      if (isCycling) {
+        this.pause();
+      }
+
+      this._setActiveIndicatorElement(nextElement);
+
+      this._activeElement = nextElement;
+
+      if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
+        nextElement.classList.add(orderClassName);
+        reflow(nextElement);
+        activeElement.classList.add(directionalClassName);
+        nextElement.classList.add(directionalClassName);
+        var transitionDuration = getTransitionDurationFromElement(activeElement);
+        EventHandler.one(activeElement, 'transitionend', function () {
+          nextElement.classList.remove(directionalClassName, orderClassName);
+          nextElement.classList.add(CLASS_NAME_ACTIVE$1);
+          activeElement.classList.remove(CLASS_NAME_ACTIVE$1, orderClassName, directionalClassName);
+          _this5._isSliding = false;
+          setTimeout(function () {
+            EventHandler.trigger(_this5._element, EVENT_SLID, {
+              relatedTarget: nextElement,
+              direction: eventDirectionName,
+              from: activeElementIndex,
+              to: nextElementIndex
+            });
+          }, 0);
+        });
+        emulateTransitionEnd(activeElement, transitionDuration);
+      } else {
+        activeElement.classList.remove(CLASS_NAME_ACTIVE$1);
+        nextElement.classList.add(CLASS_NAME_ACTIVE$1);
+        this._isSliding = false;
+        EventHandler.trigger(this._element, EVENT_SLID, {
+          relatedTarget: nextElement,
+          direction: eventDirectionName,
+          from: activeElementIndex,
+          to: nextElementIndex
+        });
+      }
+
+      if (isCycling) {
+        this.cycle();
+      }
+    } // Static
+    ;
+
+    Carousel.carouselInterface = function carouselInterface(element, config) {
+      var data = Data.getData(element, DATA_KEY$2);
+
+      var _config = _extends({}, Default, Manipulator.getDataAttributes(element));
+
+      if (typeof config === 'object') {
+        _config = _extends({}, _config, config);
+      }
+
+      var action = typeof config === 'string' ? config : _config.slide;
+
+      if (!data) {
+        data = new Carousel(element, _config);
+      }
+
+      if (typeof config === 'number') {
+        data.to(config);
+      } else if (typeof action === 'string') {
+        if (typeof data[action] === 'undefined') {
+          throw new TypeError("No method named \"" + action + "\"");
+        }
+
+        data[action]();
+      } else if (_config.interval && _config.ride) {
+        data.pause();
+        data.cycle();
+      }
+    };
+
+    Carousel.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        Carousel.carouselInterface(this, config);
+      });
+    };
+
+    Carousel.dataApiClickHandler = function dataApiClickHandler(event) {
+      var target = getElementFromSelector(this);
+
+      if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
+        return;
+      }
+
+      var config = _extends({}, Manipulator.getDataAttributes(target), Manipulator.getDataAttributes(this));
+
+      var slideIndex = this.getAttribute('data-bs-slide-to');
+
+      if (slideIndex) {
+        config.interval = false;
+      }
+
+      Carousel.carouselInterface(target, config);
+
+      if (slideIndex) {
+        Data.getData(target, DATA_KEY$2).to(slideIndex);
+      }
+
+      event.preventDefault();
+    };
+
+    _createClass(Carousel, null, [{
+      key: "Default",
+      get: function get() {
+        return Default;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$2;
+      }
+    }]);
+
+    return Carousel;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
+  EventHandler.on(window, EVENT_LOAD_DATA_API, function () {
+    var carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
+
+    for (var i = 0, len = carousels.length; i < len; i++) {
+      Carousel.carouselInterface(carousels[i], Data.getData(carousels[i], DATA_KEY$2));
+    }
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Carousel to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$2, Carousel);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$3 = 'collapse';
+  var DATA_KEY$3 = 'bs.collapse';
+  var EVENT_KEY$3 = "." + DATA_KEY$3;
+  var DATA_API_KEY$3 = '.data-api';
+  var Default$1 = {
+    toggle: true,
+    parent: ''
+  };
+  var DefaultType$1 = {
+    toggle: 'boolean',
+    parent: '(string|element)'
+  };
+  var EVENT_SHOW = "show" + EVENT_KEY$3;
+  var EVENT_SHOWN = "shown" + EVENT_KEY$3;
+  var EVENT_HIDE = "hide" + EVENT_KEY$3;
+  var EVENT_HIDDEN = "hidden" + EVENT_KEY$3;
+  var EVENT_CLICK_DATA_API$3 = "click" + EVENT_KEY$3 + DATA_API_KEY$3;
+  var CLASS_NAME_SHOW$1 = 'show';
+  var CLASS_NAME_COLLAPSE = 'collapse';
+  var CLASS_NAME_COLLAPSING = 'collapsing';
+  var CLASS_NAME_COLLAPSED = 'collapsed';
+  var WIDTH = 'width';
+  var HEIGHT = 'height';
+  var SELECTOR_ACTIVES = '.show, .collapsing';
+  var SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="collapse"]';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Collapse = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Collapse, _BaseComponent);
+
+    function Collapse(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._isTransitioning = false;
+      _this._config = _this._getConfig(config);
+      _this._triggerArray = SelectorEngine.find(SELECTOR_DATA_TOGGLE$1 + "[href=\"#" + element.id + "\"]," + (SELECTOR_DATA_TOGGLE$1 + "[data-bs-target=\"#" + element.id + "\"]"));
+      var toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$1);
+
+      for (var i = 0, len = toggleList.length; i < len; i++) {
+        var elem = toggleList[i];
+        var selector = getSelectorFromElement(elem);
+        var filterElement = SelectorEngine.find(selector).filter(function (foundElem) {
+          return foundElem === element;
+        });
+
+        if (selector !== null && filterElement.length) {
+          _this._selector = selector;
+
+          _this._triggerArray.push(elem);
+        }
+      }
+
+      _this._parent = _this._config.parent ? _this._getParent() : null;
+
+      if (!_this._config.parent) {
+        _this._addAriaAndCollapsedClass(_this._element, _this._triggerArray);
+      }
+
+      if (_this._config.toggle) {
+        _this.toggle();
+      }
+
+      return _this;
+    } // Getters
+
+
+    var _proto = Collapse.prototype;
+
+    // Public
+    _proto.toggle = function toggle() {
+      if (this._element.classList.contains(CLASS_NAME_SHOW$1)) {
+        this.hide();
+      } else {
+        this.show();
+      }
+    };
+
+    _proto.show = function show() {
+      var _this2 = this;
+
+      if (this._isTransitioning || this._element.classList.contains(CLASS_NAME_SHOW$1)) {
+        return;
+      }
+
+      var actives;
+      var activesData;
+
+      if (this._parent) {
+        actives = SelectorEngine.find(SELECTOR_ACTIVES, this._parent).filter(function (elem) {
+          if (typeof _this2._config.parent === 'string') {
+            return elem.getAttribute('data-bs-parent') === _this2._config.parent;
+          }
+
+          return elem.classList.contains(CLASS_NAME_COLLAPSE);
+        });
+
+        if (actives.length === 0) {
+          actives = null;
+        }
+      }
+
+      var container = SelectorEngine.findOne(this._selector);
+
+      if (actives) {
+        var tempActiveData = actives.find(function (elem) {
+          return container !== elem;
+        });
+        activesData = tempActiveData ? Data.getData(tempActiveData, DATA_KEY$3) : null;
+
+        if (activesData && activesData._isTransitioning) {
+          return;
+        }
+      }
+
+      var startEvent = EventHandler.trigger(this._element, EVENT_SHOW);
+
+      if (startEvent.defaultPrevented) {
+        return;
+      }
+
+      if (actives) {
+        actives.forEach(function (elemActive) {
+          if (container !== elemActive) {
+            Collapse.collapseInterface(elemActive, 'hide');
+          }
+
+          if (!activesData) {
+            Data.setData(elemActive, DATA_KEY$3, null);
+          }
+        });
+      }
+
+      var dimension = this._getDimension();
+
+      this._element.classList.remove(CLASS_NAME_COLLAPSE);
+
+      this._element.classList.add(CLASS_NAME_COLLAPSING);
+
+      this._element.style[dimension] = 0;
+
+      if (this._triggerArray.length) {
+        this._triggerArray.forEach(function (element) {
+          element.classList.remove(CLASS_NAME_COLLAPSED);
+          element.setAttribute('aria-expanded', true);
+        });
+      }
+
+      this.setTransitioning(true);
+
+      var complete = function complete() {
+        _this2._element.classList.remove(CLASS_NAME_COLLAPSING);
+
+        _this2._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$1);
+
+        _this2._element.style[dimension] = '';
+
+        _this2.setTransitioning(false);
+
+        EventHandler.trigger(_this2._element, EVENT_SHOWN);
+      };
+
+      var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
+      var scrollSize = "scroll" + capitalizedDimension;
+      var transitionDuration = getTransitionDurationFromElement(this._element);
+      EventHandler.one(this._element, 'transitionend', complete);
+      emulateTransitionEnd(this._element, transitionDuration);
+      this._element.style[dimension] = this._element[scrollSize] + "px";
+    };
+
+    _proto.hide = function hide() {
+      var _this3 = this;
+
+      if (this._isTransitioning || !this._element.classList.contains(CLASS_NAME_SHOW$1)) {
+        return;
+      }
+
+      var startEvent = EventHandler.trigger(this._element, EVENT_HIDE);
+
+      if (startEvent.defaultPrevented) {
+        return;
+      }
+
+      var dimension = this._getDimension();
+
+      this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
+      reflow(this._element);
+
+      this._element.classList.add(CLASS_NAME_COLLAPSING);
+
+      this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$1);
+
+      var triggerArrayLength = this._triggerArray.length;
+
+      if (triggerArrayLength > 0) {
+        for (var i = 0; i < triggerArrayLength; i++) {
+          var trigger = this._triggerArray[i];
+          var elem = getElementFromSelector(trigger);
+
+          if (elem && !elem.classList.contains(CLASS_NAME_SHOW$1)) {
+            trigger.classList.add(CLASS_NAME_COLLAPSED);
+            trigger.setAttribute('aria-expanded', false);
+          }
+        }
+      }
+
+      this.setTransitioning(true);
+
+      var complete = function complete() {
+        _this3.setTransitioning(false);
+
+        _this3._element.classList.remove(CLASS_NAME_COLLAPSING);
+
+        _this3._element.classList.add(CLASS_NAME_COLLAPSE);
+
+        EventHandler.trigger(_this3._element, EVENT_HIDDEN);
+      };
+
+      this._element.style[dimension] = '';
+      var transitionDuration = getTransitionDurationFromElement(this._element);
+      EventHandler.one(this._element, 'transitionend', complete);
+      emulateTransitionEnd(this._element, transitionDuration);
+    };
+
+    _proto.setTransitioning = function setTransitioning(isTransitioning) {
+      this._isTransitioning = isTransitioning;
+    };
+
+    _proto.dispose = function dispose() {
+      _BaseComponent.prototype.dispose.call(this);
+
+      this._config = null;
+      this._parent = null;
+      this._triggerArray = null;
+      this._isTransitioning = null;
+    } // Private
+    ;
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, Default$1, config);
+      config.toggle = Boolean(config.toggle); // Coerce string values
+
+      typeCheckConfig(NAME$3, config, DefaultType$1);
+      return config;
+    };
+
+    _proto._getDimension = function _getDimension() {
+      return this._element.classList.contains(WIDTH) ? WIDTH : HEIGHT;
+    };
+
+    _proto._getParent = function _getParent() {
+      var _this4 = this;
+
+      var parent = this._config.parent;
+
+      if (isElement(parent)) {
+        // it's a jQuery object
+        if (typeof parent.jquery !== 'undefined' || typeof parent[0] !== 'undefined') {
+          parent = parent[0];
+        }
+      } else {
+        parent = SelectorEngine.findOne(parent);
+      }
+
+      var selector = SELECTOR_DATA_TOGGLE$1 + "[data-bs-parent=\"" + parent + "\"]";
+      SelectorEngine.find(selector, parent).forEach(function (element) {
+        var selected = getElementFromSelector(element);
+
+        _this4._addAriaAndCollapsedClass(selected, [element]);
+      });
+      return parent;
+    };
+
+    _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
+      if (!element || !triggerArray.length) {
+        return;
+      }
+
+      var isOpen = element.classList.contains(CLASS_NAME_SHOW$1);
+      triggerArray.forEach(function (elem) {
+        if (isOpen) {
+          elem.classList.remove(CLASS_NAME_COLLAPSED);
+        } else {
+          elem.classList.add(CLASS_NAME_COLLAPSED);
+        }
+
+        elem.setAttribute('aria-expanded', isOpen);
+      });
+    } // Static
+    ;
+
+    Collapse.collapseInterface = function collapseInterface(element, config) {
+      var data = Data.getData(element, DATA_KEY$3);
+
+      var _config = _extends({}, Default$1, Manipulator.getDataAttributes(element), typeof config === 'object' && config ? config : {});
+
+      if (!data && _config.toggle && typeof config === 'string' && /show|hide/.test(config)) {
+        _config.toggle = false;
+      }
+
+      if (!data) {
+        data = new Collapse(element, _config);
+      }
+
+      if (typeof config === 'string') {
+        if (typeof data[config] === 'undefined') {
+          throw new TypeError("No method named \"" + config + "\"");
+        }
+
+        data[config]();
+      }
+    };
+
+    Collapse.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        Collapse.collapseInterface(this, config);
+      });
+    };
+
+    _createClass(Collapse, null, [{
+      key: "Default",
+      get: function get() {
+        return Default$1;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$3;
+      }
+    }]);
+
+    return Collapse;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$1, function (event) {
+    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
+    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
+      event.preventDefault();
+    }
+
+    var triggerData = Manipulator.getDataAttributes(this);
+    var selector = getSelectorFromElement(this);
+    var selectorElements = SelectorEngine.find(selector);
+    selectorElements.forEach(function (element) {
+      var data = Data.getData(element, DATA_KEY$3);
+      var config;
+
+      if (data) {
+        // update parent attribute
+        if (data._parent === null && typeof triggerData.parent === 'string') {
+          data._config.parent = triggerData.parent;
+          data._parent = data._getParent();
+        }
+
+        config = 'toggle';
+      } else {
+        config = triggerData;
+      }
+
+      Collapse.collapseInterface(element, config);
+    });
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Collapse to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$3, Collapse);
+
+  var top = 'top';
+  var bottom = 'bottom';
+  var right = 'right';
+  var left = 'left';
+  var auto = 'auto';
+  var basePlacements = [top, bottom, right, left];
+  var start = 'start';
+  var end = 'end';
+  var clippingParents = 'clippingParents';
+  var viewport = 'viewport';
+  var popper = 'popper';
+  var reference = 'reference';
+  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
+    return acc.concat([placement + "-" + start, placement + "-" + end]);
+  }, []);
+  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
+    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
+  }, []); // modifiers that need to read the DOM
+
+  var beforeRead = 'beforeRead';
+  var read = 'read';
+  var afterRead = 'afterRead'; // pure-logic modifiers
+
+  var beforeMain = 'beforeMain';
+  var main = 'main';
+  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
+
+  var beforeWrite = 'beforeWrite';
+  var write = 'write';
+  var afterWrite = 'afterWrite';
+  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
+
+  function getNodeName(element) {
+    return element ? (element.nodeName || '').toLowerCase() : null;
+  }
+
+  /*:: import type { Window } from '../types'; */
+
+  /*:: declare function getWindow(node: Node | Window): Window; */
+  function getWindow(node) {
+    if (node.toString() !== '[object Window]') {
+      var ownerDocument = node.ownerDocument;
+      return ownerDocument ? ownerDocument.defaultView || window : window;
+    }
+
+    return node;
+  }
+
+  /*:: declare function isElement(node: mixed): boolean %checks(node instanceof
+    Element); */
+
+  function isElement$1(node) {
+    var OwnElement = getWindow(node).Element;
+    return node instanceof OwnElement || node instanceof Element;
+  }
+  /*:: declare function isHTMLElement(node: mixed): boolean %checks(node instanceof
+    HTMLElement); */
+
+
+  function isHTMLElement(node) {
+    var OwnElement = getWindow(node).HTMLElement;
+    return node instanceof OwnElement || node instanceof HTMLElement;
+  }
+  /*:: declare function isShadowRoot(node: mixed): boolean %checks(node instanceof
+    ShadowRoot); */
+
+
+  function isShadowRoot(node) {
+    var OwnElement = getWindow(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
+  }
+
+  // and applies them to the HTMLElements such as popper and arrow
+
+  function applyStyles(_ref) {
+    var state = _ref.state;
+    Object.keys(state.elements).forEach(function (name) {
+      var style = state.styles[name] || {};
+      var attributes = state.attributes[name] || {};
+      var element = state.elements[name]; // arrow is optional + virtual elements
+
+      if (!isHTMLElement(element) || !getNodeName(element)) {
+        return;
+      } // Flow doesn't support to extend this property, but it's the most
+      // effective way to apply styles to an HTMLElement
+      // $FlowFixMe[cannot-write]
+
+
+      Object.assign(element.style, style);
+      Object.keys(attributes).forEach(function (name) {
+        var value = attributes[name];
+
+        if (value === false) {
+          element.removeAttribute(name);
+        } else {
+          element.setAttribute(name, value === true ? '' : value);
+        }
+      });
+    });
+  }
+
+  function effect(_ref2) {
+    var state = _ref2.state;
+    var initialStyles = {
+      popper: {
+        position: state.options.strategy,
+        left: '0',
+        top: '0',
+        margin: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      },
+      reference: {}
+    };
+    Object.assign(state.elements.popper.style, initialStyles.popper);
+
+    if (state.elements.arrow) {
+      Object.assign(state.elements.arrow.style, initialStyles.arrow);
+    }
+
+    return function () {
+      Object.keys(state.elements).forEach(function (name) {
+        var element = state.elements[name];
+        var attributes = state.attributes[name] || {};
+        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
+
+        var style = styleProperties.reduce(function (style, property) {
+          style[property] = '';
+          return style;
+        }, {}); // arrow is optional + virtual elements
+
+        if (!isHTMLElement(element) || !getNodeName(element)) {
+          return;
+        }
+
+        Object.assign(element.style, style);
+        Object.keys(attributes).forEach(function (attribute) {
+          element.removeAttribute(attribute);
+        });
+      });
+    };
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var applyStyles$1 = {
+    name: 'applyStyles',
+    enabled: true,
+    phase: 'write',
+    fn: applyStyles,
+    effect: effect,
+    requires: ['computeStyles']
+  };
+
+  function getBasePlacement(placement) {
+    return placement.split('-')[0];
+  }
+
+  // Returns the layout rect of an element relative to its offsetParent. Layout
+  // means it doesn't take into account transforms.
+  function getLayoutRect(element) {
+    return {
+      x: element.offsetLeft,
+      y: element.offsetTop,
+      width: element.offsetWidth,
+      height: element.offsetHeight
+    };
+  }
+
+  function contains(parent, child) {
+    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
+
+    if (parent.contains(child)) {
+      return true;
+    } // then fallback to custom implementation with Shadow DOM support
+    else if (rootNode && isShadowRoot(rootNode)) {
+        var next = child;
+
+        do {
+          if (next && parent.isSameNode(next)) {
+            return true;
+          } // $FlowFixMe[prop-missing]: need a better way to handle this...
+
+
+          next = next.parentNode || next.host;
+        } while (next);
+      } // Give up, the result is false
+
+
+    return false;
+  }
+
+  function getComputedStyle$1(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
+  }
+
+  function getDocumentElement(element) {
+    // $FlowFixMe[incompatible-return]: assume body is always available
+    return ((isElement$1(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
+    element.document) || window.document).documentElement;
+  }
+
+  function getParentNode(element) {
+    if (getNodeName(element) === 'html') {
+      return element;
+    }
+
+    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
+      // $FlowFixMe[incompatible-return]
+      // $FlowFixMe[prop-missing]
+      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+      element.parentNode || // DOM Element detected
+      // $FlowFixMe[incompatible-return]: need a better way to handle this...
+      element.host || // ShadowRoot detected
+      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
+      getDocumentElement(element) // fallback
+
+    );
+  }
+
+  function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
+    getComputedStyle$1(element).position === 'fixed') {
+      return null;
+    }
+
+    var offsetParent = element.offsetParent;
+
+    if (offsetParent) {
+      var html = getDocumentElement(offsetParent);
+
+      if (getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && getComputedStyle$1(html).position !== 'static') {
+        return html;
+      }
+    }
+
+    return offsetParent;
+  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
+  // return the containing block
+
+
+  function getContainingBlock(element) {
+    var currentNode = getParentNode(element);
+
+    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
+      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
+      // create a containing block.
+
+      if (css.transform !== 'none' || css.perspective !== 'none' || css.willChange && css.willChange !== 'auto') {
+        return currentNode;
+      } else {
+        currentNode = currentNode.parentNode;
+      }
+    }
+
+    return null;
+  } // Gets the closest ancestor positioned element. Handles some edge cases,
+  // such as table ancestors and cross browser bugs.
+
+
+  function getOffsetParent(element) {
+    var window = getWindow(element);
+    var offsetParent = getTrueOffsetParent(element);
+
+    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
+      offsetParent = getTrueOffsetParent(offsetParent);
+    }
+
+    if (offsetParent && getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static') {
+      return window;
+    }
+
+    return offsetParent || getContainingBlock(element) || window;
+  }
+
+  function getMainAxisFromPlacement(placement) {
+    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
+  }
+
+  function within(min, value, max) {
+    return Math.max(min, Math.min(value, max));
+  }
+
+  function getFreshSideObject() {
+    return {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0
+    };
+  }
+
+  function mergePaddingObject(paddingObject) {
+    return Object.assign(Object.assign({}, getFreshSideObject()), paddingObject);
+  }
+
+  function expandToHashMap(value, keys) {
+    return keys.reduce(function (hashMap, key) {
+      hashMap[key] = value;
+      return hashMap;
+    }, {});
+  }
+
+  function arrow(_ref) {
+    var _state$modifiersData$;
+
+    var state = _ref.state,
+        name = _ref.name;
+    var arrowElement = state.elements.arrow;
+    var popperOffsets = state.modifiersData.popperOffsets;
+    var basePlacement = getBasePlacement(state.placement);
+    var axis = getMainAxisFromPlacement(basePlacement);
+    var isVertical = [left, right].indexOf(basePlacement) >= 0;
+    var len = isVertical ? 'height' : 'width';
+
+    if (!arrowElement || !popperOffsets) {
+      return;
+    }
+
+    var paddingObject = state.modifiersData[name + "#persistent"].padding;
+    var arrowRect = getLayoutRect(arrowElement);
+    var minProp = axis === 'y' ? top : left;
+    var maxProp = axis === 'y' ? bottom : right;
+    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
+    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
+    var arrowOffsetParent = getOffsetParent(arrowElement);
+    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
+    // outside of the popper bounds
+
+    var min = paddingObject[minProp];
+    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
+    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
+    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
+
+    var axisProp = axis;
+    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
+  }
+
+  function effect$1(_ref2) {
+    var state = _ref2.state,
+        options = _ref2.options,
+        name = _ref2.name;
+    var _options$element = options.element,
+        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element,
+        _options$padding = options.padding,
+        padding = _options$padding === void 0 ? 0 : _options$padding;
+
+    if (arrowElement == null) {
+      return;
+    } // CSS selector
+
+
+    if (typeof arrowElement === 'string') {
+      arrowElement = state.elements.popper.querySelector(arrowElement);
+
+      if (!arrowElement) {
+        return;
+      }
+    }
+
+    if (!contains(state.elements.popper, arrowElement)) {
+
+      return;
+    }
+
+    state.elements.arrow = arrowElement;
+    state.modifiersData[name + "#persistent"] = {
+      padding: mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements))
+    };
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var arrow$1 = {
+    name: 'arrow',
+    enabled: true,
+    phase: 'main',
+    fn: arrow,
+    effect: effect$1,
+    requires: ['popperOffsets'],
+    requiresIfExists: ['preventOverflow']
+  };
+
+  var unsetSides = {
+    top: 'auto',
+    right: 'auto',
+    bottom: 'auto',
+    left: 'auto'
+  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
+  // Zooming can change the DPR, but it seems to report a value that will
+  // cleanly divide the values into the appropriate subpixels.
+
+  function roundOffsetsByDPR(_ref) {
+    var x = _ref.x,
+        y = _ref.y;
+    var win = window;
+    var dpr = win.devicePixelRatio || 1;
+    return {
+      x: Math.round(x * dpr) / dpr || 0,
+      y: Math.round(y * dpr) / dpr || 0
+    };
+  }
+
+  function mapToStyles(_ref2) {
+    var _Object$assign2;
+
+    var popper = _ref2.popper,
+        popperRect = _ref2.popperRect,
+        placement = _ref2.placement,
+        offsets = _ref2.offsets,
+        position = _ref2.position,
+        gpuAcceleration = _ref2.gpuAcceleration,
+        adaptive = _ref2.adaptive,
+        roundOffsets = _ref2.roundOffsets;
+
+    var _ref3 = roundOffsets ? roundOffsetsByDPR(offsets) : offsets,
+        _ref3$x = _ref3.x,
+        x = _ref3$x === void 0 ? 0 : _ref3$x,
+        _ref3$y = _ref3.y,
+        y = _ref3$y === void 0 ? 0 : _ref3$y;
+
+    var hasX = offsets.hasOwnProperty('x');
+    var hasY = offsets.hasOwnProperty('y');
+    var sideX = left;
+    var sideY = top;
+    var win = window;
+
+    if (adaptive) {
+      var offsetParent = getOffsetParent(popper);
+
+      if (offsetParent === getWindow(popper)) {
+        offsetParent = getDocumentElement(popper);
+      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
+
+      /*:: offsetParent = (offsetParent: Element); */
+
+
+      if (placement === top) {
+        sideY = bottom;
+        y -= offsetParent.clientHeight - popperRect.height;
+        y *= gpuAcceleration ? 1 : -1;
+      }
+
+      if (placement === left) {
+        sideX = right;
+        x -= offsetParent.clientWidth - popperRect.width;
+        x *= gpuAcceleration ? 1 : -1;
+      }
+    }
+
+    var commonStyles = Object.assign({
+      position: position
+    }, adaptive && unsetSides);
+
+    if (gpuAcceleration) {
+      var _Object$assign;
+
+      return Object.assign(Object.assign({}, commonStyles), {}, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
+    }
+
+    return Object.assign(Object.assign({}, commonStyles), {}, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
+  }
+
+  function computeStyles(_ref4) {
+    var state = _ref4.state,
+        options = _ref4.options;
+    var _options$gpuAccelerat = options.gpuAcceleration,
+        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
+        _options$adaptive = options.adaptive,
+        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
+        _options$roundOffsets = options.roundOffsets,
+        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
+
+    var commonStyles = {
+      placement: getBasePlacement(state.placement),
+      popper: state.elements.popper,
+      popperRect: state.rects.popper,
+      gpuAcceleration: gpuAcceleration
+    };
+
+    if (state.modifiersData.popperOffsets != null) {
+      state.styles.popper = Object.assign(Object.assign({}, state.styles.popper), mapToStyles(Object.assign(Object.assign({}, commonStyles), {}, {
+        offsets: state.modifiersData.popperOffsets,
+        position: state.options.strategy,
+        adaptive: adaptive,
+        roundOffsets: roundOffsets
+      })));
+    }
+
+    if (state.modifiersData.arrow != null) {
+      state.styles.arrow = Object.assign(Object.assign({}, state.styles.arrow), mapToStyles(Object.assign(Object.assign({}, commonStyles), {}, {
+        offsets: state.modifiersData.arrow,
+        position: 'absolute',
+        adaptive: false,
+        roundOffsets: roundOffsets
+      })));
+    }
+
+    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), {}, {
+      'data-popper-placement': state.placement
+    });
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var computeStyles$1 = {
+    name: 'computeStyles',
+    enabled: true,
+    phase: 'beforeWrite',
+    fn: computeStyles,
+    data: {}
+  };
+
+  var passive = {
+    passive: true
+  };
+
+  function effect$2(_ref) {
+    var state = _ref.state,
+        instance = _ref.instance,
+        options = _ref.options;
+    var _options$scroll = options.scroll,
+        scroll = _options$scroll === void 0 ? true : _options$scroll,
+        _options$resize = options.resize,
+        resize = _options$resize === void 0 ? true : _options$resize;
+    var window = getWindow(state.elements.popper);
+    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
+
+    if (scroll) {
+      scrollParents.forEach(function (scrollParent) {
+        scrollParent.addEventListener('scroll', instance.update, passive);
+      });
+    }
+
+    if (resize) {
+      window.addEventListener('resize', instance.update, passive);
+    }
+
+    return function () {
+      if (scroll) {
+        scrollParents.forEach(function (scrollParent) {
+          scrollParent.removeEventListener('scroll', instance.update, passive);
+        });
+      }
+
+      if (resize) {
+        window.removeEventListener('resize', instance.update, passive);
+      }
+    };
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var eventListeners = {
+    name: 'eventListeners',
+    enabled: true,
+    phase: 'write',
+    fn: function fn() {},
+    effect: effect$2,
+    data: {}
+  };
+
+  var hash = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+  };
+  function getOppositePlacement(placement) {
+    return placement.replace(/left|right|bottom|top/g, function (matched) {
+      return hash[matched];
+    });
+  }
+
+  var hash$1 = {
+    start: 'end',
+    end: 'start'
+  };
+  function getOppositeVariationPlacement(placement) {
+    return placement.replace(/start|end/g, function (matched) {
+      return hash$1[matched];
+    });
+  }
+
+  function getBoundingClientRect(element) {
+    var rect = element.getBoundingClientRect();
+    return {
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      right: rect.right,
+      bottom: rect.bottom,
+      left: rect.left,
+      x: rect.left,
+      y: rect.top
+    };
+  }
+
+  function getWindowScroll(node) {
+    var win = getWindow(node);
+    var scrollLeft = win.pageXOffset;
+    var scrollTop = win.pageYOffset;
+    return {
+      scrollLeft: scrollLeft,
+      scrollTop: scrollTop
+    };
+  }
+
+  function getWindowScrollBarX(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    // Popper 1 is broken in this case and never had a bug report so let's assume
+    // it's not an issue. I don't think anyone ever specifies width on <html>
+    // anyway.
+    // Browsers where the left scrollbar doesn't cause an issue report `0` for
+    // this (e.g. Edge 2019, IE11, Safari)
+    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+  }
+
+  function getViewportRect(element) {
+    var win = getWindow(element);
+    var html = getDocumentElement(element);
+    var visualViewport = win.visualViewport;
+    var width = html.clientWidth;
+    var height = html.clientHeight;
+    var x = 0;
+    var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
+    // can be obscured underneath it.
+    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
+    // if it isn't open, so if this isn't available, the popper will be detected
+    // to overflow the bottom of the screen too early.
+
+    if (visualViewport) {
+      width = visualViewport.width;
+      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
+      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
+      // errors due to floating point numbers, so we need to check precision.
+      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
+      // Feature detection fails in mobile emulation mode in Chrome.
+      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
+      // 0.001
+      // Fallback here: "Not Safari" userAgent
+
+      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
+    }
+
+    return {
+      width: width,
+      height: height,
+      x: x + getWindowScrollBarX(element),
+      y: y
+    };
+  }
+
+  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
+
+  function getDocumentRect(element) {
+    var html = getDocumentElement(element);
+    var winScroll = getWindowScroll(element);
+    var body = element.ownerDocument.body;
+    var width = Math.max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    var height = Math.max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
+    var y = -winScroll.scrollTop;
+
+    if (getComputedStyle$1(body || html).direction === 'rtl') {
+      x += Math.max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+
+    return {
+      width: width,
+      height: height,
+      x: x,
+      y: y
+    };
+  }
+
+  function isScrollParent(element) {
+    // Firefox wants us to check `-x` and `-y` variations as well
+    var _getComputedStyle = getComputedStyle$1(element),
+        overflow = _getComputedStyle.overflow,
+        overflowX = _getComputedStyle.overflowX,
+        overflowY = _getComputedStyle.overflowY;
+
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+  }
+
+  function getScrollParent(node) {
+    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
+      // $FlowFixMe[incompatible-return]: assume body is always available
+      return node.ownerDocument.body;
+    }
+
+    if (isHTMLElement(node) && isScrollParent(node)) {
+      return node;
+    }
+
+    return getScrollParent(getParentNode(node));
+  }
+
+  /*
+  given a DOM element, return the list of all scroll parents, up the list of ancesors
+  until we get to the top window object. This list is what we attach scroll listeners
+  to, because if any of these parent elements scroll, we'll need to re-calculate the
+  reference element's position.
+  */
+
+  function listScrollParents(element, list) {
+    if (list === void 0) {
+      list = [];
+    }
+
+    var scrollParent = getScrollParent(element);
+    var isBody = getNodeName(scrollParent) === 'body';
+    var win = getWindow(scrollParent);
+    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+    var updatedList = list.concat(target);
+    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
+    updatedList.concat(listScrollParents(getParentNode(target)));
+  }
+
+  function rectToClientRect(rect) {
+    return Object.assign(Object.assign({}, rect), {}, {
+      left: rect.x,
+      top: rect.y,
+      right: rect.x + rect.width,
+      bottom: rect.y + rect.height
+    });
+  }
+
+  function getInnerBoundingClientRect(element) {
+    var rect = getBoundingClientRect(element);
+    rect.top = rect.top + element.clientTop;
+    rect.left = rect.left + element.clientLeft;
+    rect.bottom = rect.top + element.clientHeight;
+    rect.right = rect.left + element.clientWidth;
+    rect.width = element.clientWidth;
+    rect.height = element.clientHeight;
+    rect.x = rect.left;
+    rect.y = rect.top;
+    return rect;
+  }
+
+  function getClientRectFromMixedType(element, clippingParent) {
+    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
+  } // A "clipping parent" is an overflowable container with the characteristic of
+  // clipping (or hiding) overflowing elements with a position different from
+  // `initial`
+
+
+  function getClippingParents(element) {
+    var clippingParents = listScrollParents(getParentNode(element));
+    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
+    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+
+    if (!isElement$1(clipperElement)) {
+      return [];
+    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
+
+
+    return clippingParents.filter(function (clippingParent) {
+      return isElement$1(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
+    });
+  } // Gets the maximum area that the element is visible in due to any number of
+  // clipping parents
+
+
+  function getClippingRect(element, boundary, rootBoundary) {
+    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
+    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
+    var firstClippingParent = clippingParents[0];
+    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
+      var rect = getClientRectFromMixedType(element, clippingParent);
+      accRect.top = Math.max(rect.top, accRect.top);
+      accRect.right = Math.min(rect.right, accRect.right);
+      accRect.bottom = Math.min(rect.bottom, accRect.bottom);
+      accRect.left = Math.max(rect.left, accRect.left);
+      return accRect;
+    }, getClientRectFromMixedType(element, firstClippingParent));
+    clippingRect.width = clippingRect.right - clippingRect.left;
+    clippingRect.height = clippingRect.bottom - clippingRect.top;
+    clippingRect.x = clippingRect.left;
+    clippingRect.y = clippingRect.top;
+    return clippingRect;
+  }
+
+  function getVariation(placement) {
+    return placement.split('-')[1];
+  }
+
+  function computeOffsets(_ref) {
+    var reference = _ref.reference,
+        element = _ref.element,
+        placement = _ref.placement;
+    var basePlacement = placement ? getBasePlacement(placement) : null;
+    var variation = placement ? getVariation(placement) : null;
+    var commonX = reference.x + reference.width / 2 - element.width / 2;
+    var commonY = reference.y + reference.height / 2 - element.height / 2;
+    var offsets;
+
+    switch (basePlacement) {
+      case top:
+        offsets = {
+          x: commonX,
+          y: reference.y - element.height
+        };
+        break;
+
+      case bottom:
+        offsets = {
+          x: commonX,
+          y: reference.y + reference.height
+        };
+        break;
+
+      case right:
+        offsets = {
+          x: reference.x + reference.width,
+          y: commonY
+        };
+        break;
+
+      case left:
+        offsets = {
+          x: reference.x - element.width,
+          y: commonY
+        };
+        break;
+
+      default:
+        offsets = {
+          x: reference.x,
+          y: reference.y
+        };
+    }
+
+    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+
+    if (mainAxis != null) {
+      var len = mainAxis === 'y' ? 'height' : 'width';
+
+      switch (variation) {
+        case start:
+          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+          break;
+
+        case end:
+          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+          break;
+      }
+    }
+
+    return offsets;
+  }
+
+  function detectOverflow(state, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var _options = options,
+        _options$placement = _options.placement,
+        placement = _options$placement === void 0 ? state.placement : _options$placement,
+        _options$boundary = _options.boundary,
+        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
+        _options$rootBoundary = _options.rootBoundary,
+        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
+        _options$elementConte = _options.elementContext,
+        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
+        _options$altBoundary = _options.altBoundary,
+        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
+        _options$padding = _options.padding,
+        padding = _options$padding === void 0 ? 0 : _options$padding;
+    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
+    var altContext = elementContext === popper ? reference : popper;
+    var referenceElement = state.elements.reference;
+    var popperRect = state.rects.popper;
+    var element = state.elements[altBoundary ? altContext : elementContext];
+    var clippingClientRect = getClippingRect(isElement$1(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
+    var referenceClientRect = getBoundingClientRect(referenceElement);
+    var popperOffsets = computeOffsets({
+      reference: referenceClientRect,
+      element: popperRect,
+      strategy: 'absolute',
+      placement: placement
+    });
+    var popperClientRect = rectToClientRect(Object.assign(Object.assign({}, popperRect), popperOffsets));
+    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
+    // 0 or negative = within the clipping rect
+
+    var overflowOffsets = {
+      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+    };
+    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
+
+    if (elementContext === popper && offsetData) {
+      var offset = offsetData[placement];
+      Object.keys(overflowOffsets).forEach(function (key) {
+        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
+        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
+        overflowOffsets[key] += offset[axis] * multiply;
+      });
+    }
+
+    return overflowOffsets;
+  }
+
+  /*:: type OverflowsMap = { [ComputedPlacement]: number }; */
+
+  /*;; type OverflowsMap = { [key in ComputedPlacement]: number }; */
+  function computeAutoPlacement(state, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var _options = options,
+        placement = _options.placement,
+        boundary = _options.boundary,
+        rootBoundary = _options.rootBoundary,
+        padding = _options.padding,
+        flipVariations = _options.flipVariations,
+        _options$allowedAutoP = _options.allowedAutoPlacements,
+        allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
+    var variation = getVariation(placement);
+    var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
+      return getVariation(placement) === variation;
+    }) : basePlacements;
+    var allowedPlacements = placements$1.filter(function (placement) {
+      return allowedAutoPlacements.indexOf(placement) >= 0;
+    });
+
+    if (allowedPlacements.length === 0) {
+      allowedPlacements = placements$1;
+    } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
+
+
+    var overflows = allowedPlacements.reduce(function (acc, placement) {
+      acc[placement] = detectOverflow(state, {
+        placement: placement,
+        boundary: boundary,
+        rootBoundary: rootBoundary,
+        padding: padding
+      })[getBasePlacement(placement)];
+      return acc;
+    }, {});
+    return Object.keys(overflows).sort(function (a, b) {
+      return overflows[a] - overflows[b];
+    });
+  }
+
+  function getExpandedFallbackPlacements(placement) {
+    if (getBasePlacement(placement) === auto) {
+      return [];
+    }
+
+    var oppositePlacement = getOppositePlacement(placement);
+    return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
+  }
+
+  function flip(_ref) {
+    var state = _ref.state,
+        options = _ref.options,
+        name = _ref.name;
+
+    if (state.modifiersData[name]._skip) {
+      return;
+    }
+
+    var _options$mainAxis = options.mainAxis,
+        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
+        _options$altAxis = options.altAxis,
+        checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
+        specifiedFallbackPlacements = options.fallbackPlacements,
+        padding = options.padding,
+        boundary = options.boundary,
+        rootBoundary = options.rootBoundary,
+        altBoundary = options.altBoundary,
+        _options$flipVariatio = options.flipVariations,
+        flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
+        allowedAutoPlacements = options.allowedAutoPlacements;
+    var preferredPlacement = state.options.placement;
+    var basePlacement = getBasePlacement(preferredPlacement);
+    var isBasePlacement = basePlacement === preferredPlacement;
+    var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
+    var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
+      return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
+        placement: placement,
+        boundary: boundary,
+        rootBoundary: rootBoundary,
+        padding: padding,
+        flipVariations: flipVariations,
+        allowedAutoPlacements: allowedAutoPlacements
+      }) : placement);
+    }, []);
+    var referenceRect = state.rects.reference;
+    var popperRect = state.rects.popper;
+    var checksMap = new Map();
+    var makeFallbackChecks = true;
+    var firstFittingPlacement = placements[0];
+
+    for (var i = 0; i < placements.length; i++) {
+      var placement = placements[i];
+
+      var _basePlacement = getBasePlacement(placement);
+
+      var isStartVariation = getVariation(placement) === start;
+      var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
+      var len = isVertical ? 'width' : 'height';
+      var overflow = detectOverflow(state, {
+        placement: placement,
+        boundary: boundary,
+        rootBoundary: rootBoundary,
+        altBoundary: altBoundary,
+        padding: padding
+      });
+      var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
+
+      if (referenceRect[len] > popperRect[len]) {
+        mainVariationSide = getOppositePlacement(mainVariationSide);
+      }
+
+      var altVariationSide = getOppositePlacement(mainVariationSide);
+      var checks = [];
+
+      if (checkMainAxis) {
+        checks.push(overflow[_basePlacement] <= 0);
+      }
+
+      if (checkAltAxis) {
+        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
+      }
+
+      if (checks.every(function (check) {
+        return check;
+      })) {
+        firstFittingPlacement = placement;
+        makeFallbackChecks = false;
+        break;
+      }
+
+      checksMap.set(placement, checks);
+    }
+
+    if (makeFallbackChecks) {
+      // `2` may be desired in some cases – research later
+      var numberOfChecks = flipVariations ? 3 : 1;
+
+      var _loop = function _loop(_i) {
+        var fittingPlacement = placements.find(function (placement) {
+          var checks = checksMap.get(placement);
+
+          if (checks) {
+            return checks.slice(0, _i).every(function (check) {
+              return check;
+            });
+          }
+        });
+
+        if (fittingPlacement) {
+          firstFittingPlacement = fittingPlacement;
+          return "break";
+        }
+      };
+
+      for (var _i = numberOfChecks; _i > 0; _i--) {
+        var _ret = _loop(_i);
+
+        if (_ret === "break") break;
+      }
+    }
+
+    if (state.placement !== firstFittingPlacement) {
+      state.modifiersData[name]._skip = true;
+      state.placement = firstFittingPlacement;
+      state.reset = true;
+    }
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var flip$1 = {
+    name: 'flip',
+    enabled: true,
+    phase: 'main',
+    fn: flip,
+    requiresIfExists: ['offset'],
+    data: {
+      _skip: false
+    }
+  };
+
+  function getSideOffsets(overflow, rect, preventedOffsets) {
+    if (preventedOffsets === void 0) {
+      preventedOffsets = {
+        x: 0,
+        y: 0
+      };
+    }
+
+    return {
+      top: overflow.top - rect.height - preventedOffsets.y,
+      right: overflow.right - rect.width + preventedOffsets.x,
+      bottom: overflow.bottom - rect.height + preventedOffsets.y,
+      left: overflow.left - rect.width - preventedOffsets.x
+    };
+  }
+
+  function isAnySideFullyClipped(overflow) {
+    return [top, right, bottom, left].some(function (side) {
+      return overflow[side] >= 0;
+    });
+  }
+
+  function hide(_ref) {
+    var state = _ref.state,
+        name = _ref.name;
+    var referenceRect = state.rects.reference;
+    var popperRect = state.rects.popper;
+    var preventedOffsets = state.modifiersData.preventOverflow;
+    var referenceOverflow = detectOverflow(state, {
+      elementContext: 'reference'
+    });
+    var popperAltOverflow = detectOverflow(state, {
+      altBoundary: true
+    });
+    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
+    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
+    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
+    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
+    state.modifiersData[name] = {
+      referenceClippingOffsets: referenceClippingOffsets,
+      popperEscapeOffsets: popperEscapeOffsets,
+      isReferenceHidden: isReferenceHidden,
+      hasPopperEscaped: hasPopperEscaped
+    };
+    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), {}, {
+      'data-popper-reference-hidden': isReferenceHidden,
+      'data-popper-escaped': hasPopperEscaped
+    });
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var hide$1 = {
+    name: 'hide',
+    enabled: true,
+    phase: 'main',
+    requiresIfExists: ['preventOverflow'],
+    fn: hide
+  };
+
+  function distanceAndSkiddingToXY(placement, rects, offset) {
+    var basePlacement = getBasePlacement(placement);
+    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
+
+    var _ref = typeof offset === 'function' ? offset(Object.assign(Object.assign({}, rects), {}, {
+      placement: placement
+    })) : offset,
+        skidding = _ref[0],
+        distance = _ref[1];
+
+    skidding = skidding || 0;
+    distance = (distance || 0) * invertDistance;
+    return [left, right].indexOf(basePlacement) >= 0 ? {
+      x: distance,
+      y: skidding
+    } : {
+      x: skidding,
+      y: distance
+    };
+  }
+
+  function offset(_ref2) {
+    var state = _ref2.state,
+        options = _ref2.options,
+        name = _ref2.name;
+    var _options$offset = options.offset,
+        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
+    var data = placements.reduce(function (acc, placement) {
+      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
+      return acc;
+    }, {});
+    var _data$state$placement = data[state.placement],
+        x = _data$state$placement.x,
+        y = _data$state$placement.y;
+
+    if (state.modifiersData.popperOffsets != null) {
+      state.modifiersData.popperOffsets.x += x;
+      state.modifiersData.popperOffsets.y += y;
+    }
+
+    state.modifiersData[name] = data;
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var offset$1 = {
+    name: 'offset',
+    enabled: true,
+    phase: 'main',
+    requires: ['popperOffsets'],
+    fn: offset
+  };
+
+  function popperOffsets(_ref) {
+    var state = _ref.state,
+        name = _ref.name;
+    // Offsets are the actual position the popper needs to have to be
+    // properly positioned near its reference element
+    // This is the most basic placement, and will be adjusted by
+    // the modifiers in the next step
+    state.modifiersData[name] = computeOffsets({
+      reference: state.rects.reference,
+      element: state.rects.popper,
+      strategy: 'absolute',
+      placement: state.placement
+    });
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var popperOffsets$1 = {
+    name: 'popperOffsets',
+    enabled: true,
+    phase: 'read',
+    fn: popperOffsets,
+    data: {}
+  };
+
+  function getAltAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+  }
+
+  function preventOverflow(_ref) {
+    var state = _ref.state,
+        options = _ref.options,
+        name = _ref.name;
+    var _options$mainAxis = options.mainAxis,
+        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
+        _options$altAxis = options.altAxis,
+        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
+        boundary = options.boundary,
+        rootBoundary = options.rootBoundary,
+        altBoundary = options.altBoundary,
+        padding = options.padding,
+        _options$tether = options.tether,
+        tether = _options$tether === void 0 ? true : _options$tether,
+        _options$tetherOffset = options.tetherOffset,
+        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
+    var overflow = detectOverflow(state, {
+      boundary: boundary,
+      rootBoundary: rootBoundary,
+      padding: padding,
+      altBoundary: altBoundary
+    });
+    var basePlacement = getBasePlacement(state.placement);
+    var variation = getVariation(state.placement);
+    var isBasePlacement = !variation;
+    var mainAxis = getMainAxisFromPlacement(basePlacement);
+    var altAxis = getAltAxis(mainAxis);
+    var popperOffsets = state.modifiersData.popperOffsets;
+    var referenceRect = state.rects.reference;
+    var popperRect = state.rects.popper;
+    var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign(Object.assign({}, state.rects), {}, {
+      placement: state.placement
+    })) : tetherOffset;
+    var data = {
+      x: 0,
+      y: 0
+    };
+
+    if (!popperOffsets) {
+      return;
+    }
+
+    if (checkMainAxis) {
+      var mainSide = mainAxis === 'y' ? top : left;
+      var altSide = mainAxis === 'y' ? bottom : right;
+      var len = mainAxis === 'y' ? 'height' : 'width';
+      var offset = popperOffsets[mainAxis];
+      var min = popperOffsets[mainAxis] + overflow[mainSide];
+      var max = popperOffsets[mainAxis] - overflow[altSide];
+      var additive = tether ? -popperRect[len] / 2 : 0;
+      var minLen = variation === start ? referenceRect[len] : popperRect[len];
+      var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
+      // outside the reference bounds
+
+      var arrowElement = state.elements.arrow;
+      var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
+        width: 0,
+        height: 0
+      };
+      var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
+      var arrowPaddingMin = arrowPaddingObject[mainSide];
+      var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
+      // to include its full size in the calculation. If the reference is small
+      // and near the edge of a boundary, the popper can overflow even if the
+      // reference is not overflowing as well (e.g. virtual elements with no
+      // width or height)
+
+      var arrowLen = within(0, referenceRect[len], arrowRect[len]);
+      var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;
+      var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;
+      var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
+      var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
+      var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0;
+      var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset;
+      var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;
+      var preventedOffset = within(tether ? Math.min(min, tetherMin) : min, offset, tether ? Math.max(max, tetherMax) : max);
+      popperOffsets[mainAxis] = preventedOffset;
+      data[mainAxis] = preventedOffset - offset;
+    }
+
+    if (checkAltAxis) {
+      var _mainSide = mainAxis === 'x' ? top : left;
+
+      var _altSide = mainAxis === 'x' ? bottom : right;
+
+      var _offset = popperOffsets[altAxis];
+
+      var _min = _offset + overflow[_mainSide];
+
+      var _max = _offset - overflow[_altSide];
+
+      var _preventedOffset = within(_min, _offset, _max);
+
+      popperOffsets[altAxis] = _preventedOffset;
+      data[altAxis] = _preventedOffset - _offset;
+    }
+
+    state.modifiersData[name] = data;
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var preventOverflow$1 = {
+    name: 'preventOverflow',
+    enabled: true,
+    phase: 'main',
+    fn: preventOverflow,
+    requiresIfExists: ['offset']
+  };
+
+  function getHTMLElementScroll(element) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+
+  function getNodeScroll(node) {
+    if (node === getWindow(node) || !isHTMLElement(node)) {
+      return getWindowScroll(node);
+    } else {
+      return getHTMLElementScroll(node);
+    }
+  }
+
+  // Composite means it takes into account transforms as well as layout.
+
+  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+    if (isFixed === void 0) {
+      isFixed = false;
+    }
+
+    var documentElement = getDocumentElement(offsetParent);
+    var rect = getBoundingClientRect(elementOrVirtualElement);
+    var isOffsetParentAnElement = isHTMLElement(offsetParent);
+    var scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    var offsets = {
+      x: 0,
+      y: 0
+    };
+
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
+      isScrollParent(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+
+      if (isHTMLElement(offsetParent)) {
+        offsets = getBoundingClientRect(offsetParent);
+        offsets.x += offsetParent.clientLeft;
+        offsets.y += offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX(documentElement);
+      }
+    }
+
+    return {
+      x: rect.left + scroll.scrollLeft - offsets.x,
+      y: rect.top + scroll.scrollTop - offsets.y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  function order(modifiers) {
+    var map = new Map();
+    var visited = new Set();
+    var result = [];
+    modifiers.forEach(function (modifier) {
+      map.set(modifier.name, modifier);
+    }); // On visiting object, check for its dependencies and visit them recursively
+
+    function sort(modifier) {
+      visited.add(modifier.name);
+      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
+      requires.forEach(function (dep) {
+        if (!visited.has(dep)) {
+          var depModifier = map.get(dep);
+
+          if (depModifier) {
+            sort(depModifier);
+          }
+        }
+      });
+      result.push(modifier);
+    }
+
+    modifiers.forEach(function (modifier) {
+      if (!visited.has(modifier.name)) {
+        // check for visited object
+        sort(modifier);
+      }
+    });
+    return result;
+  }
+
+  function orderModifiers(modifiers) {
+    // order based on dependencies
+    var orderedModifiers = order(modifiers); // order based on phase
+
+    return modifierPhases.reduce(function (acc, phase) {
+      return acc.concat(orderedModifiers.filter(function (modifier) {
+        return modifier.phase === phase;
+      }));
+    }, []);
+  }
+
+  function debounce(fn) {
+    var pending;
+    return function () {
+      if (!pending) {
+        pending = new Promise(function (resolve) {
+          Promise.resolve().then(function () {
+            pending = undefined;
+            resolve(fn());
+          });
+        });
+      }
+
+      return pending;
+    };
+  }
+
+  function mergeByName(modifiers) {
+    var merged = modifiers.reduce(function (merged, current) {
+      var existing = merged[current.name];
+      merged[current.name] = existing ? Object.assign(Object.assign(Object.assign({}, existing), current), {}, {
+        options: Object.assign(Object.assign({}, existing.options), current.options),
+        data: Object.assign(Object.assign({}, existing.data), current.data)
+      }) : current;
+      return merged;
+    }, {}); // IE11 does not support Object.values
+
+    return Object.keys(merged).map(function (key) {
+      return merged[key];
+    });
+  }
+
+  var DEFAULT_OPTIONS = {
+    placement: 'bottom',
+    modifiers: [],
+    strategy: 'absolute'
+  };
+
+  function areValidElements() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return !args.some(function (element) {
+      return !(element && typeof element.getBoundingClientRect === 'function');
+    });
+  }
+
+  function popperGenerator(generatorOptions) {
+    if (generatorOptions === void 0) {
+      generatorOptions = {};
+    }
+
+    var _generatorOptions = generatorOptions,
+        _generatorOptions$def = _generatorOptions.defaultModifiers,
+        defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
+        _generatorOptions$def2 = _generatorOptions.defaultOptions,
+        defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
+    return function createPopper(reference, popper, options) {
+      if (options === void 0) {
+        options = defaultOptions;
+      }
+
+      var state = {
+        placement: 'bottom',
+        orderedModifiers: [],
+        options: Object.assign(Object.assign({}, DEFAULT_OPTIONS), defaultOptions),
+        modifiersData: {},
+        elements: {
+          reference: reference,
+          popper: popper
+        },
+        attributes: {},
+        styles: {}
+      };
+      var effectCleanupFns = [];
+      var isDestroyed = false;
+      var instance = {
+        state: state,
+        setOptions: function setOptions(options) {
+          cleanupModifierEffects();
+          state.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), state.options), options);
+          state.scrollParents = {
+            reference: isElement$1(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
+            popper: listScrollParents(popper)
+          }; // Orders the modifiers based on their dependencies and `phase`
+          // properties
+
+          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
+
+          state.orderedModifiers = orderedModifiers.filter(function (m) {
+            return m.enabled;
+          }); // Validate the provided modifiers so that the consumer will get warned
+
+          runModifierEffects();
+          return instance.update();
+        },
+        // Sync update – it will always be executed, even if not necessary. This
+        // is useful for low frequency updates where sync behavior simplifies the
+        // logic.
+        // For high frequency updates (e.g. `resize` and `scroll` events), always
+        // prefer the async Popper#update method
+        forceUpdate: function forceUpdate() {
+          if (isDestroyed) {
+            return;
+          }
+
+          var _state$elements = state.elements,
+              reference = _state$elements.reference,
+              popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
+          // anymore
+
+          if (!areValidElements(reference, popper)) {
+
+            return;
+          } // Store the reference and popper rects to be read by modifiers
+
+
+          state.rects = {
+            reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
+            popper: getLayoutRect(popper)
+          }; // Modifiers have the ability to reset the current update cycle. The
+          // most common use case for this is the `flip` modifier changing the
+          // placement, which then needs to re-run all the modifiers, because the
+          // logic was previously ran for the previous placement and is therefore
+          // stale/incorrect
+
+          state.reset = false;
+          state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
+          // is filled with the initial data specified by the modifier. This means
+          // it doesn't persist and is fresh on each update.
+          // To ensure persistent data, use `${name}#persistent`
+
+          state.orderedModifiers.forEach(function (modifier) {
+            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
+          });
+
+          for (var index = 0; index < state.orderedModifiers.length; index++) {
+
+            if (state.reset === true) {
+              state.reset = false;
+              index = -1;
+              continue;
+            }
+
+            var _state$orderedModifie = state.orderedModifiers[index],
+                fn = _state$orderedModifie.fn,
+                _state$orderedModifie2 = _state$orderedModifie.options,
+                _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
+                name = _state$orderedModifie.name;
+
+            if (typeof fn === 'function') {
+              state = fn({
+                state: state,
+                options: _options,
+                name: name,
+                instance: instance
+              }) || state;
+            }
+          }
+        },
+        // Async and optimistically optimized update – it will not be executed if
+        // not necessary (debounced to run at most once-per-tick)
+        update: debounce(function () {
+          return new Promise(function (resolve) {
+            instance.forceUpdate();
+            resolve(state);
+          });
+        }),
+        destroy: function destroy() {
+          cleanupModifierEffects();
+          isDestroyed = true;
+        }
+      };
+
+      if (!areValidElements(reference, popper)) {
+
+        return instance;
+      }
+
+      instance.setOptions(options).then(function (state) {
+        if (!isDestroyed && options.onFirstUpdate) {
+          options.onFirstUpdate(state);
+        }
+      }); // Modifiers have the ability to execute arbitrary code before the first
+      // update cycle runs. They will be executed in the same order as the update
+      // cycle. This is useful when a modifier adds some persistent data that
+      // other modifiers need to use, but the modifier is run after the dependent
+      // one.
+
+      function runModifierEffects() {
+        state.orderedModifiers.forEach(function (_ref3) {
+          var name = _ref3.name,
+              _ref3$options = _ref3.options,
+              options = _ref3$options === void 0 ? {} : _ref3$options,
+              effect = _ref3.effect;
+
+          if (typeof effect === 'function') {
+            var cleanupFn = effect({
+              state: state,
+              name: name,
+              instance: instance,
+              options: options
+            });
+
+            var noopFn = function noopFn() {};
+
+            effectCleanupFns.push(cleanupFn || noopFn);
+          }
+        });
+      }
+
+      function cleanupModifierEffects() {
+        effectCleanupFns.forEach(function (fn) {
+          return fn();
+        });
+        effectCleanupFns = [];
+      }
+
+      return instance;
+    };
+  }
+  var createPopper = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules
+
+  var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
+  var createPopper$1 = /*#__PURE__*/popperGenerator({
+    defaultModifiers: defaultModifiers
+  }); // eslint-disable-next-line import/no-unused-modules
+
+  var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
+  var createPopper$2 = /*#__PURE__*/popperGenerator({
+    defaultModifiers: defaultModifiers$1
+  }); // eslint-disable-next-line import/no-unused-modules
+
+  var Popper = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    popperGenerator: popperGenerator,
+    detectOverflow: detectOverflow,
+    createPopperBase: createPopper,
+    createPopper: createPopper$2,
+    createPopperLite: createPopper$1,
+    top: top,
+    bottom: bottom,
+    right: right,
+    left: left,
+    auto: auto,
+    basePlacements: basePlacements,
+    start: start,
+    end: end,
+    clippingParents: clippingParents,
+    viewport: viewport,
+    popper: popper,
+    reference: reference,
+    variationPlacements: variationPlacements,
+    placements: placements,
+    beforeRead: beforeRead,
+    read: read,
+    afterRead: afterRead,
+    beforeMain: beforeMain,
+    main: main,
+    afterMain: afterMain,
+    beforeWrite: beforeWrite,
+    write: write,
+    afterWrite: afterWrite,
+    modifierPhases: modifierPhases,
+    applyStyles: applyStyles$1,
+    arrow: arrow$1,
+    computeStyles: computeStyles$1,
+    eventListeners: eventListeners,
+    flip: flip$1,
+    hide: hide$1,
+    offset: offset$1,
+    popperOffsets: popperOffsets$1,
+    preventOverflow: preventOverflow$1
+  });
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$4 = 'dropdown';
+  var DATA_KEY$4 = 'bs.dropdown';
+  var EVENT_KEY$4 = "." + DATA_KEY$4;
+  var DATA_API_KEY$4 = '.data-api';
+  var ESCAPE_KEY = 'Escape';
+  var SPACE_KEY = 'Space';
+  var TAB_KEY = 'Tab';
+  var ARROW_UP_KEY = 'ArrowUp';
+  var ARROW_DOWN_KEY = 'ArrowDown';
+  var RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
+
+  var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEY + "|" + ARROW_DOWN_KEY + "|" + ESCAPE_KEY);
+  var EVENT_HIDE$1 = "hide" + EVENT_KEY$4;
+  var EVENT_HIDDEN$1 = "hidden" + EVENT_KEY$4;
+  var EVENT_SHOW$1 = "show" + EVENT_KEY$4;
+  var EVENT_SHOWN$1 = "shown" + EVENT_KEY$4;
+  var EVENT_CLICK = "click" + EVENT_KEY$4;
+  var EVENT_CLICK_DATA_API$4 = "click" + EVENT_KEY$4 + DATA_API_KEY$4;
+  var EVENT_KEYDOWN_DATA_API = "keydown" + EVENT_KEY$4 + DATA_API_KEY$4;
+  var EVENT_KEYUP_DATA_API = "keyup" + EVENT_KEY$4 + DATA_API_KEY$4;
+  var CLASS_NAME_DISABLED = 'disabled';
+  var CLASS_NAME_SHOW$2 = 'show';
+  var CLASS_NAME_DROPUP = 'dropup';
+  var CLASS_NAME_DROPEND = 'dropend';
+  var CLASS_NAME_DROPSTART = 'dropstart';
+  var CLASS_NAME_NAVBAR = 'navbar';
+  var SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="dropdown"]';
+  var SELECTOR_FORM_CHILD = '.dropdown form';
+  var SELECTOR_MENU = '.dropdown-menu';
+  var SELECTOR_NAVBAR_NAV = '.navbar-nav';
+  var SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
+  var PLACEMENT_TOP = isRTL ? 'top-end' : 'top-start';
+  var PLACEMENT_TOPEND = isRTL ? 'top-start' : 'top-end';
+  var PLACEMENT_BOTTOM = isRTL ? 'bottom-end' : 'bottom-start';
+  var PLACEMENT_BOTTOMEND = isRTL ? 'bottom-start' : 'bottom-end';
+  var PLACEMENT_RIGHT = isRTL ? 'left-start' : 'right-start';
+  var PLACEMENT_LEFT = isRTL ? 'right-start' : 'left-start';
+  var Default$2 = {
+    offset: [0, 2],
+    flip: true,
+    boundary: 'clippingParents',
+    reference: 'toggle',
+    display: 'dynamic',
+    popperConfig: null
+  };
+  var DefaultType$2 = {
+    offset: '(array|string|function)',
+    flip: 'boolean',
+    boundary: '(string|element)',
+    reference: '(string|element|object)',
+    display: 'string',
+    popperConfig: '(null|object|function)'
+  };
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Dropdown = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Dropdown, _BaseComponent);
+
+    function Dropdown(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._popper = null;
+      _this._config = _this._getConfig(config);
+      _this._menu = _this._getMenuElement();
+      _this._inNavbar = _this._detectNavbar();
+
+      _this._addEventListeners();
+
+      return _this;
+    } // Getters
+
+
+    var _proto = Dropdown.prototype;
+
+    // Public
+    _proto.toggle = function toggle() {
+      if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED)) {
+        return;
+      }
+
+      var isActive = this._element.classList.contains(CLASS_NAME_SHOW$2);
+
+      Dropdown.clearMenus();
+
+      if (isActive) {
+        return;
+      }
+
+      this.show();
+    };
+
+    _proto.show = function show() {
+      if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || this._menu.classList.contains(CLASS_NAME_SHOW$2)) {
+        return;
+      }
+
+      var parent = Dropdown.getParentFromElement(this._element);
+      var relatedTarget = {
+        relatedTarget: this._element
+      };
+      var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, relatedTarget);
+
+      if (showEvent.defaultPrevented) {
+        return;
+      } // Totally disable Popper for Dropdowns in Navbar
+
+
+      if (this._inNavbar) {
+        Manipulator.setDataAttribute(this._menu, 'popper', 'none');
+      } else {
+        if (typeof Popper === 'undefined') {
+          throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
+        }
+
+        var referenceElement = this._element;
+
+        if (this._config.reference === 'parent') {
+          referenceElement = parent;
+        } else if (isElement(this._config.reference)) {
+          referenceElement = this._config.reference; // Check if it's jQuery element
+
+          if (typeof this._config.reference.jquery !== 'undefined') {
+            referenceElement = this._config.reference[0];
+          }
+        } else if (typeof this._config.reference === 'object') {
+          referenceElement = this._config.reference;
+        }
+
+        var popperConfig = this._getPopperConfig();
+
+        var isDisplayStatic = popperConfig.modifiers.find(function (modifier) {
+          return modifier.name === 'applyStyles' && modifier.enabled === false;
+        });
+        this._popper = createPopper$2(referenceElement, this._menu, popperConfig);
+
+        if (isDisplayStatic) {
+          Manipulator.setDataAttribute(this._menu, 'popper', 'static');
+        }
+      } // If this is a touch-enabled device we add extra
+      // empty mouseover listeners to the body's immediate children;
+      // only needed because of broken event delegation on iOS
+      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
+
+
+      if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) {
+        var _ref;
+
+        (_ref = []).concat.apply(_ref, document.body.children).forEach(function (elem) {
+          return EventHandler.on(elem, 'mouseover', null, noop());
+        });
+      }
+
+      this._element.focus();
+
+      this._element.setAttribute('aria-expanded', true);
+
+      this._menu.classList.toggle(CLASS_NAME_SHOW$2);
+
+      this._element.classList.toggle(CLASS_NAME_SHOW$2);
+
+      EventHandler.trigger(this._element, EVENT_SHOWN$1, relatedTarget);
+    };
+
+    _proto.hide = function hide() {
+      if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || !this._menu.classList.contains(CLASS_NAME_SHOW$2)) {
+        return;
+      }
+
+      var relatedTarget = {
+        relatedTarget: this._element
+      };
+      var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$1, relatedTarget);
+
+      if (hideEvent.defaultPrevented) {
+        return;
+      }
+
+      if (this._popper) {
+        this._popper.destroy();
+      }
+
+      this._menu.classList.toggle(CLASS_NAME_SHOW$2);
+
+      this._element.classList.toggle(CLASS_NAME_SHOW$2);
+
+      Manipulator.removeDataAttribute(this._menu, 'popper');
+      EventHandler.trigger(this._element, EVENT_HIDDEN$1, relatedTarget);
+    };
+
+    _proto.dispose = function dispose() {
+      _BaseComponent.prototype.dispose.call(this);
+
+      EventHandler.off(this._element, EVENT_KEY$4);
+      this._menu = null;
+
+      if (this._popper) {
+        this._popper.destroy();
+
+        this._popper = null;
+      }
+    };
+
+    _proto.update = function update() {
+      this._inNavbar = this._detectNavbar();
+
+      if (this._popper) {
+        this._popper.update();
+      }
+    } // Private
+    ;
+
+    _proto._addEventListeners = function _addEventListeners() {
+      var _this2 = this;
+
+      EventHandler.on(this._element, EVENT_CLICK, function (event) {
+        event.preventDefault();
+        event.stopPropagation();
+
+        _this2.toggle();
+      });
+    };
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, this.constructor.Default, Manipulator.getDataAttributes(this._element), config);
+      typeCheckConfig(NAME$4, config, this.constructor.DefaultType);
+
+      if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
+        // Popper virtual elements require a getBoundingClientRect method
+        throw new TypeError(NAME$4.toUpperCase() + ": Option \"reference\" provided type \"object\" without a required \"getBoundingClientRect\" method.");
+      }
+
+      return config;
+    };
+
+    _proto._getMenuElement = function _getMenuElement() {
+      return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
+    };
+
+    _proto._getPlacement = function _getPlacement() {
+      var parentDropdown = this._element.parentNode;
+
+      if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
+        return PLACEMENT_RIGHT;
+      }
+
+      if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
+        return PLACEMENT_LEFT;
+      } // We need to trim the value because custom properties can also include spaces
+
+
+      var isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
+
+      if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
+        return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
+      }
+
+      return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
+    };
+
+    _proto._detectNavbar = function _detectNavbar() {
+      return this._element.closest("." + CLASS_NAME_NAVBAR) !== null;
+    };
+
+    _proto._getOffset = function _getOffset() {
+      var _this3 = this;
+
+      var offset = this._config.offset;
+
+      if (typeof offset === 'string') {
+        return offset.split(',').map(function (val) {
+          return Number.parseInt(val, 10);
+        });
+      }
+
+      if (typeof offset === 'function') {
+        return function (popperData) {
+          return offset(popperData, _this3._element);
+        };
+      }
+
+      return offset;
+    };
+
+    _proto._getPopperConfig = function _getPopperConfig() {
+      var defaultBsPopperConfig = {
+        placement: this._getPlacement(),
+        modifiers: [{
+          name: 'preventOverflow',
+          options: {
+            altBoundary: this._config.flip,
+            boundary: this._config.boundary
+          }
+        }, {
+          name: 'offset',
+          options: {
+            offset: this._getOffset()
+          }
+        }]
+      }; // Disable Popper if we have a static display
+
+      if (this._config.display === 'static') {
+        defaultBsPopperConfig.modifiers = [{
+          name: 'applyStyles',
+          enabled: false
+        }];
+      }
+
+      return _extends({}, defaultBsPopperConfig, typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig);
+    } // Static
+    ;
+
+    Dropdown.dropdownInterface = function dropdownInterface(element, config) {
+      var data = Data.getData(element, DATA_KEY$4);
+
+      var _config = typeof config === 'object' ? config : null;
+
+      if (!data) {
+        data = new Dropdown(element, _config);
+      }
+
+      if (typeof config === 'string') {
+        if (typeof data[config] === 'undefined') {
+          throw new TypeError("No method named \"" + config + "\"");
+        }
+
+        data[config]();
+      }
+    };
+
+    Dropdown.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        Dropdown.dropdownInterface(this, config);
+      });
+    };
+
+    Dropdown.clearMenus = function clearMenus(event) {
+      if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY)) {
+        return;
+      }
+
+      var toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$2);
+
+      for (var i = 0, len = toggles.length; i < len; i++) {
+        var context = Data.getData(toggles[i], DATA_KEY$4);
+        var relatedTarget = {
+          relatedTarget: toggles[i]
+        };
+
+        if (event && event.type === 'click') {
+          relatedTarget.clickEvent = event;
+        }
+
+        if (!context) {
+          continue;
+        }
+
+        var dropdownMenu = context._menu;
+
+        if (!toggles[i].classList.contains(CLASS_NAME_SHOW$2)) {
+          continue;
+        }
+
+        if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.key === TAB_KEY) && dropdownMenu.contains(event.target)) {
+          continue;
+        }
+
+        var hideEvent = EventHandler.trigger(toggles[i], EVENT_HIDE$1, relatedTarget);
+
+        if (hideEvent.defaultPrevented) {
+          continue;
+        } // If this is a touch-enabled device we remove the extra
+        // empty mouseover listeners we added for iOS support
+
+
+        if ('ontouchstart' in document.documentElement) {
+          var _ref2;
+
+          (_ref2 = []).concat.apply(_ref2, document.body.children).forEach(function (elem) {
+            return EventHandler.off(elem, 'mouseover', null, noop());
+          });
+        }
+
+        toggles[i].setAttribute('aria-expanded', 'false');
+
+        if (context._popper) {
+          context._popper.destroy();
+        }
+
+        dropdownMenu.classList.remove(CLASS_NAME_SHOW$2);
+        toggles[i].classList.remove(CLASS_NAME_SHOW$2);
+        Manipulator.removeDataAttribute(dropdownMenu, 'popper');
+        EventHandler.trigger(toggles[i], EVENT_HIDDEN$1, relatedTarget);
+      }
+    };
+
+    Dropdown.getParentFromElement = function getParentFromElement(element) {
+      return getElementFromSelector(element) || element.parentNode;
+    };
+
+    Dropdown.dataApiKeydownHandler = function dataApiKeydownHandler(event) {
+      // If not input/textarea:
+      //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
+      // If input/textarea:
+      //  - If space key => not a dropdown command
+      //  - If key is other than escape
+      //    - If key is not up or down => not a dropdown command
+      //    - If trigger inside the menu => not a dropdown command
+      if (/input|textarea/i.test(event.target.tagName) ? event.key === SPACE_KEY || event.key !== ESCAPE_KEY && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) {
+        return;
+      }
+
+      event.preventDefault();
+      event.stopPropagation();
+
+      if (this.disabled || this.classList.contains(CLASS_NAME_DISABLED)) {
+        return;
+      }
+
+      var parent = Dropdown.getParentFromElement(this);
+      var isActive = this.classList.contains(CLASS_NAME_SHOW$2);
+
+      if (event.key === ESCAPE_KEY) {
+        var button = this.matches(SELECTOR_DATA_TOGGLE$2) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$2)[0];
+        button.focus();
+        Dropdown.clearMenus();
+        return;
+      }
+
+      if (!isActive && (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY)) {
+        var _button = this.matches(SELECTOR_DATA_TOGGLE$2) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$2)[0];
+
+        _button.click();
+
+        return;
+      }
+
+      if (!isActive || event.key === SPACE_KEY) {
+        Dropdown.clearMenus();
+        return;
+      }
+
+      var items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, parent).filter(isVisible);
+
+      if (!items.length) {
+        return;
+      }
+
+      var index = items.indexOf(event.target); // Up
+
+      if (event.key === ARROW_UP_KEY && index > 0) {
+        index--;
+      } // Down
+
+
+      if (event.key === ARROW_DOWN_KEY && index < items.length - 1) {
+        index++;
+      } // index is -1 if the first keydown is an ArrowUp
+
+
+      index = index === -1 ? 0 : index;
+      items[index].focus();
+    };
+
+    _createClass(Dropdown, null, [{
+      key: "Default",
+      get: function get() {
+        return Default$2;
+      }
+    }, {
+      key: "DefaultType",
+      get: function get() {
+        return DefaultType$2;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$4;
+      }
+    }]);
+
+    return Dropdown;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$2, Dropdown.dataApiKeydownHandler);
+  EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
+  EventHandler.on(document, EVENT_CLICK_DATA_API$4, Dropdown.clearMenus);
+  EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
+  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$2, function (event) {
+    event.preventDefault();
+    event.stopPropagation();
+    Dropdown.dropdownInterface(this, 'toggle');
+  });
+  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_FORM_CHILD, function (e) {
+    return e.stopPropagation();
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Dropdown to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$4, Dropdown);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$5 = 'modal';
+  var DATA_KEY$5 = 'bs.modal';
+  var EVENT_KEY$5 = "." + DATA_KEY$5;
+  var DATA_API_KEY$5 = '.data-api';
+  var ESCAPE_KEY$1 = 'Escape';
+  var Default$3 = {
+    backdrop: true,
+    keyboard: true,
+    focus: true
+  };
+  var DefaultType$3 = {
+    backdrop: '(boolean|string)',
+    keyboard: 'boolean',
+    focus: 'boolean'
+  };
+  var EVENT_HIDE$2 = "hide" + EVENT_KEY$5;
+  var EVENT_HIDE_PREVENTED = "hidePrevented" + EVENT_KEY$5;
+  var EVENT_HIDDEN$2 = "hidden" + EVENT_KEY$5;
+  var EVENT_SHOW$2 = "show" + EVENT_KEY$5;
+  var EVENT_SHOWN$2 = "shown" + EVENT_KEY$5;
+  var EVENT_FOCUSIN = "focusin" + EVENT_KEY$5;
+  var EVENT_RESIZE = "resize" + EVENT_KEY$5;
+  var EVENT_CLICK_DISMISS = "click.dismiss" + EVENT_KEY$5;
+  var EVENT_KEYDOWN_DISMISS = "keydown.dismiss" + EVENT_KEY$5;
+  var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss" + EVENT_KEY$5;
+  var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss" + EVENT_KEY$5;
+  var EVENT_CLICK_DATA_API$5 = "click" + EVENT_KEY$5 + DATA_API_KEY$5;
+  var CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure';
+  var CLASS_NAME_BACKDROP = 'modal-backdrop';
+  var CLASS_NAME_OPEN = 'modal-open';
+  var CLASS_NAME_FADE$1 = 'fade';
+  var CLASS_NAME_SHOW$3 = 'show';
+  var CLASS_NAME_STATIC = 'modal-static';
+  var SELECTOR_DIALOG = '.modal-dialog';
+  var SELECTOR_MODAL_BODY = '.modal-body';
+  var SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="modal"]';
+  var SELECTOR_DATA_DISMISS = '[data-bs-dismiss="modal"]';
+  var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
+  var SELECTOR_STICKY_CONTENT = '.sticky-top';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Modal = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Modal, _BaseComponent);
+
+    function Modal(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._config = _this._getConfig(config);
+      _this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, element);
+      _this._backdrop = null;
+      _this._isShown = false;
+      _this._isBodyOverflowing = false;
+      _this._ignoreBackdropClick = false;
+      _this._isTransitioning = false;
+      _this._scrollbarWidth = 0;
+      return _this;
+    } // Getters
+
+
+    var _proto = Modal.prototype;
+
+    // Public
+    _proto.toggle = function toggle(relatedTarget) {
+      return this._isShown ? this.hide() : this.show(relatedTarget);
+    };
+
+    _proto.show = function show(relatedTarget) {
+      var _this2 = this;
+
+      if (this._isShown || this._isTransitioning) {
+        return;
+      }
+
+      if (this._element.classList.contains(CLASS_NAME_FADE$1)) {
+        this._isTransitioning = true;
+      }
+
+      var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, {
+        relatedTarget: relatedTarget
+      });
+
+      if (this._isShown || showEvent.defaultPrevented) {
+        return;
+      }
+
+      this._isShown = true;
+
+      this._checkScrollbar();
+
+      this._setScrollbar();
+
+      this._adjustDialog();
+
+      this._setEscapeEvent();
+
+      this._setResizeEvent();
+
+      EventHandler.on(this._element, EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function (event) {
+        return _this2.hide(event);
+      });
+      EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, function () {
+        EventHandler.one(_this2._element, EVENT_MOUSEUP_DISMISS, function (event) {
+          if (event.target === _this2._element) {
+            _this2._ignoreBackdropClick = true;
+          }
+        });
+      });
+
+      this._showBackdrop(function () {
+        return _this2._showElement(relatedTarget);
+      });
+    };
+
+    _proto.hide = function hide(event) {
+      var _this3 = this;
+
+      if (event) {
+        event.preventDefault();
+      }
+
+      if (!this._isShown || this._isTransitioning) {
+        return;
+      }
+
+      var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2);
+
+      if (hideEvent.defaultPrevented) {
+        return;
+      }
+
+      this._isShown = false;
+
+      var transition = this._element.classList.contains(CLASS_NAME_FADE$1);
+
+      if (transition) {
+        this._isTransitioning = true;
+      }
+
+      this._setEscapeEvent();
+
+      this._setResizeEvent();
+
+      EventHandler.off(document, EVENT_FOCUSIN);
+
+      this._element.classList.remove(CLASS_NAME_SHOW$3);
+
+      EventHandler.off(this._element, EVENT_CLICK_DISMISS);
+      EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
+
+      if (transition) {
+        var transitionDuration = getTransitionDurationFromElement(this._element);
+        EventHandler.one(this._element, 'transitionend', function (event) {
+          return _this3._hideModal(event);
+        });
+        emulateTransitionEnd(this._element, transitionDuration);
+      } else {
+        this._hideModal();
+      }
+    };
+
+    _proto.dispose = function dispose() {
+      [window, this._element, this._dialog].forEach(function (htmlElement) {
+        return EventHandler.off(htmlElement, EVENT_KEY$5);
+      });
+
+      _BaseComponent.prototype.dispose.call(this);
+      /**
+       * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API`
+       * Do not move `document` in `htmlElements` array
+       * It will remove `EVENT_CLICK_DATA_API` event that should remain
+       */
+
+
+      EventHandler.off(document, EVENT_FOCUSIN);
+      this._config = null;
+      this._dialog = null;
+      this._backdrop = null;
+      this._isShown = null;
+      this._isBodyOverflowing = null;
+      this._ignoreBackdropClick = null;
+      this._isTransitioning = null;
+      this._scrollbarWidth = null;
+    };
+
+    _proto.handleUpdate = function handleUpdate() {
+      this._adjustDialog();
+    } // Private
+    ;
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, Default$3, config);
+      typeCheckConfig(NAME$5, config, DefaultType$3);
+      return config;
+    };
+
+    _proto._showElement = function _showElement(relatedTarget) {
+      var _this4 = this;
+
+      var transition = this._element.classList.contains(CLASS_NAME_FADE$1);
+
+      var modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
+
+      if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
+        // Don't move modal's DOM position
+        document.body.appendChild(this._element);
+      }
+
+      this._element.style.display = 'block';
+
+      this._element.removeAttribute('aria-hidden');
+
+      this._element.setAttribute('aria-modal', true);
+
+      this._element.setAttribute('role', 'dialog');
+
+      this._element.scrollTop = 0;
+
+      if (modalBody) {
+        modalBody.scrollTop = 0;
+      }
+
+      if (transition) {
+        reflow(this._element);
+      }
+
+      this._element.classList.add(CLASS_NAME_SHOW$3);
+
+      if (this._config.focus) {
+        this._enforceFocus();
+      }
+
+      var transitionComplete = function transitionComplete() {
+        if (_this4._config.focus) {
+          _this4._element.focus();
+        }
+
+        _this4._isTransitioning = false;
+        EventHandler.trigger(_this4._element, EVENT_SHOWN$2, {
+          relatedTarget: relatedTarget
+        });
+      };
+
+      if (transition) {
+        var transitionDuration = getTransitionDurationFromElement(this._dialog);
+        EventHandler.one(this._dialog, 'transitionend', transitionComplete);
+        emulateTransitionEnd(this._dialog, transitionDuration);
+      } else {
+        transitionComplete();
+      }
+    };
+
+    _proto._enforceFocus = function _enforceFocus() {
+      var _this5 = this;
+
+      EventHandler.off(document, EVENT_FOCUSIN); // guard against infinite focus loop
+
+      EventHandler.on(document, EVENT_FOCUSIN, function (event) {
+        if (document !== event.target && _this5._element !== event.target && !_this5._element.contains(event.target)) {
+          _this5._element.focus();
+        }
+      });
+    };
+
+    _proto._setEscapeEvent = function _setEscapeEvent() {
+      var _this6 = this;
+
+      if (this._isShown) {
+        EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, function (event) {
+          if (_this6._config.keyboard && event.key === ESCAPE_KEY$1) {
+            event.preventDefault();
+
+            _this6.hide();
+          } else if (!_this6._config.keyboard && event.key === ESCAPE_KEY$1) {
+            _this6._triggerBackdropTransition();
+          }
+        });
+      } else {
+        EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS);
+      }
+    };
+
+    _proto._setResizeEvent = function _setResizeEvent() {
+      var _this7 = this;
+
+      if (this._isShown) {
+        EventHandler.on(window, EVENT_RESIZE, function () {
+          return _this7._adjustDialog();
+        });
+      } else {
+        EventHandler.off(window, EVENT_RESIZE);
+      }
+    };
+
+    _proto._hideModal = function _hideModal() {
+      var _this8 = this;
+
+      this._element.style.display = 'none';
+
+      this._element.setAttribute('aria-hidden', true);
+
+      this._element.removeAttribute('aria-modal');
+
+      this._element.removeAttribute('role');
+
+      this._isTransitioning = false;
+
+      this._showBackdrop(function () {
+        document.body.classList.remove(CLASS_NAME_OPEN);
+
+        _this8._resetAdjustments();
+
+        _this8._resetScrollbar();
+
+        EventHandler.trigger(_this8._element, EVENT_HIDDEN$2);
+      });
+    };
+
+    _proto._removeBackdrop = function _removeBackdrop() {
+      this._backdrop.parentNode.removeChild(this._backdrop);
+
+      this._backdrop = null;
+    };
+
+    _proto._showBackdrop = function _showBackdrop(callback) {
+      var _this9 = this;
+
+      var animate = this._element.classList.contains(CLASS_NAME_FADE$1) ? CLASS_NAME_FADE$1 : '';
+
+      if (this._isShown && this._config.backdrop) {
+        this._backdrop = document.createElement('div');
+        this._backdrop.className = CLASS_NAME_BACKDROP;
+
+        if (animate) {
+          this._backdrop.classList.add(animate);
+        }
+
+        document.body.appendChild(this._backdrop);
+        EventHandler.on(this._element, EVENT_CLICK_DISMISS, function (event) {
+          if (_this9._ignoreBackdropClick) {
+            _this9._ignoreBackdropClick = false;
+            return;
+          }
+
+          if (event.target !== event.currentTarget) {
+            return;
+          }
+
+          if (_this9._config.backdrop === 'static') {
+            _this9._triggerBackdropTransition();
+          } else {
+            _this9.hide();
+          }
+        });
+
+        if (animate) {
+          reflow(this._backdrop);
+        }
+
+        this._backdrop.classList.add(CLASS_NAME_SHOW$3);
+
+        if (!animate) {
+          callback();
+          return;
+        }
+
+        var backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop);
+        EventHandler.one(this._backdrop, 'transitionend', callback);
+        emulateTransitionEnd(this._backdrop, backdropTransitionDuration);
+      } else if (!this._isShown && this._backdrop) {
+        this._backdrop.classList.remove(CLASS_NAME_SHOW$3);
+
+        var callbackRemove = function callbackRemove() {
+          _this9._removeBackdrop();
+
+          callback();
+        };
+
+        if (this._element.classList.contains(CLASS_NAME_FADE$1)) {
+          var _backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop);
+
+          EventHandler.one(this._backdrop, 'transitionend', callbackRemove);
+          emulateTransitionEnd(this._backdrop, _backdropTransitionDuration);
+        } else {
+          callbackRemove();
+        }
+      } else {
+        callback();
+      }
+    };
+
+    _proto._triggerBackdropTransition = function _triggerBackdropTransition() {
+      var _this10 = this;
+
+      var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
+
+      if (hideEvent.defaultPrevented) {
+        return;
+      }
+
+      var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
+
+      if (!isModalOverflowing) {
+        this._element.style.overflowY = 'hidden';
+      }
+
+      this._element.classList.add(CLASS_NAME_STATIC);
+
+      var modalTransitionDuration = getTransitionDurationFromElement(this._dialog);
+      EventHandler.off(this._element, 'transitionend');
+      EventHandler.one(this._element, 'transitionend', function () {
+        _this10._element.classList.remove(CLASS_NAME_STATIC);
+
+        if (!isModalOverflowing) {
+          EventHandler.one(_this10._element, 'transitionend', function () {
+            _this10._element.style.overflowY = '';
+          });
+          emulateTransitionEnd(_this10._element, modalTransitionDuration);
+        }
+      });
+      emulateTransitionEnd(this._element, modalTransitionDuration);
+
+      this._element.focus();
+    } // ----------------------------------------------------------------------
+    // the following methods are used to handle overflowing modals
+    // ----------------------------------------------------------------------
+    ;
+
+    _proto._adjustDialog = function _adjustDialog() {
+      var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
+
+      if (!this._isBodyOverflowing && isModalOverflowing && !isRTL || this._isBodyOverflowing && !isModalOverflowing && isRTL) {
+        this._element.style.paddingLeft = this._scrollbarWidth + "px";
+      }
+
+      if (this._isBodyOverflowing && !isModalOverflowing && !isRTL || !this._isBodyOverflowing && isModalOverflowing && isRTL) {
+        this._element.style.paddingRight = this._scrollbarWidth + "px";
+      }
+    };
+
+    _proto._resetAdjustments = function _resetAdjustments() {
+      this._element.style.paddingLeft = '';
+      this._element.style.paddingRight = '';
+    };
+
+    _proto._checkScrollbar = function _checkScrollbar() {
+      var rect = document.body.getBoundingClientRect();
+      this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth;
+      this._scrollbarWidth = this._getScrollbarWidth();
+    };
+
+    _proto._setScrollbar = function _setScrollbar() {
+      var _this11 = this;
+
+      if (this._isBodyOverflowing) {
+        this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', function (calculatedValue) {
+          return calculatedValue + _this11._scrollbarWidth;
+        });
+
+        this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', function (calculatedValue) {
+          return calculatedValue - _this11._scrollbarWidth;
+        });
+
+        this._setElementAttributes('body', 'paddingRight', function (calculatedValue) {
+          return calculatedValue + _this11._scrollbarWidth;
+        });
+      }
+
+      document.body.classList.add(CLASS_NAME_OPEN);
+    };
+
+    _proto._setElementAttributes = function _setElementAttributes(selector, styleProp, callback) {
+      SelectorEngine.find(selector).forEach(function (element) {
+        var actualValue = element.style[styleProp];
+        var calculatedValue = window.getComputedStyle(element)[styleProp];
+        Manipulator.setDataAttribute(element, styleProp, actualValue);
+        element.style[styleProp] = callback(Number.parseFloat(calculatedValue)) + 'px';
+      });
+    };
+
+    _proto._resetScrollbar = function _resetScrollbar() {
+      this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
+
+      this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
+
+      this._resetElementAttributes('body', 'paddingRight');
+    };
+
+    _proto._resetElementAttributes = function _resetElementAttributes(selector, styleProp) {
+      SelectorEngine.find(selector).forEach(function (element) {
+        var value = Manipulator.getDataAttribute(element, styleProp);
+
+        if (typeof value === 'undefined' && element === document.body) {
+          element.style[styleProp] = '';
+        } else {
+          Manipulator.removeDataAttribute(element, styleProp);
+          element.style[styleProp] = value;
+        }
+      });
+    };
+
+    _proto._getScrollbarWidth = function _getScrollbarWidth() {
+      // thx d.walsh
+      var scrollDiv = document.createElement('div');
+      scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER;
+      document.body.appendChild(scrollDiv);
+      var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
+      document.body.removeChild(scrollDiv);
+      return scrollbarWidth;
+    } // Static
+    ;
+
+    Modal.jQueryInterface = function jQueryInterface(config, relatedTarget) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$5);
+
+        var _config = _extends({}, Default$3, Manipulator.getDataAttributes(this), typeof config === 'object' && config ? config : {});
+
+        if (!data) {
+          data = new Modal(this, _config);
+        }
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config](relatedTarget);
+        }
+      });
+    };
+
+    _createClass(Modal, null, [{
+      key: "Default",
+      get: function get() {
+        return Default$3;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$5;
+      }
+    }]);
+
+    return Modal;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_TOGGLE$3, function (event) {
+    var _this12 = this;
+
+    var target = getElementFromSelector(this);
+
+    if (this.tagName === 'A' || this.tagName === 'AREA') {
+      event.preventDefault();
+    }
+
+    EventHandler.one(target, EVENT_SHOW$2, function (showEvent) {
+      if (showEvent.defaultPrevented) {
+        // only register focus restorer if modal will actually get shown
+        return;
+      }
+
+      EventHandler.one(target, EVENT_HIDDEN$2, function () {
+        if (isVisible(_this12)) {
+          _this12.focus();
+        }
+      });
+    });
+    var data = Data.getData(target, DATA_KEY$5);
+
+    if (!data) {
+      var config = _extends({}, Manipulator.getDataAttributes(target), Manipulator.getDataAttributes(this));
+
+      data = new Modal(target, config);
+    }
+
+    data.toggle(this);
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Modal to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$5, Modal);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): util/sanitizer.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+  var uriAttrs = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
+  var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
+  /**
+   * A pattern that recognizes a commonly useful subset of URLs that are safe.
+   *
+   * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
+   */
+
+  var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/gi;
+  /**
+   * A pattern that matches safe data URLs. Only matches image, video and audio types.
+   *
+   * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
+   */
+
+  var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;
+
+  var allowedAttribute = function allowedAttribute(attr, allowedAttributeList) {
+    var attrName = attr.nodeName.toLowerCase();
+
+    if (allowedAttributeList.includes(attrName)) {
+      if (uriAttrs.has(attrName)) {
+        return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue));
+      }
+
+      return true;
+    }
+
+    var regExp = allowedAttributeList.filter(function (attrRegex) {
+      return attrRegex instanceof RegExp;
+    }); // Check if a regular expression validates the attribute.
+
+    for (var i = 0, len = regExp.length; i < len; i++) {
+      if (regExp[i].test(attrName)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  var DefaultAllowlist = {
+    // Global attributes allowed on any supplied element below.
+    '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
+    a: ['target', 'href', 'title', 'rel'],
+    area: [],
+    b: [],
+    br: [],
+    col: [],
+    code: [],
+    div: [],
+    em: [],
+    hr: [],
+    h1: [],
+    h2: [],
+    h3: [],
+    h4: [],
+    h5: [],
+    h6: [],
+    i: [],
+    img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
+    li: [],
+    ol: [],
+    p: [],
+    pre: [],
+    s: [],
+    small: [],
+    span: [],
+    sub: [],
+    sup: [],
+    strong: [],
+    u: [],
+    ul: []
+  };
+  function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
+    var _ref;
+
+    if (!unsafeHtml.length) {
+      return unsafeHtml;
+    }
+
+    if (sanitizeFn && typeof sanitizeFn === 'function') {
+      return sanitizeFn(unsafeHtml);
+    }
+
+    var domParser = new window.DOMParser();
+    var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
+    var allowlistKeys = Object.keys(allowList);
+
+    var elements = (_ref = []).concat.apply(_ref, createdDocument.body.querySelectorAll('*'));
+
+    var _loop = function _loop(i, len) {
+      var _ref2;
+
+      var el = elements[i];
+      var elName = el.nodeName.toLowerCase();
+
+      if (!allowlistKeys.includes(elName)) {
+        el.parentNode.removeChild(el);
+        return "continue";
+      }
+
+      var attributeList = (_ref2 = []).concat.apply(_ref2, el.attributes);
+
+      var allowedAttributes = [].concat(allowList['*'] || [], allowList[elName] || []);
+      attributeList.forEach(function (attr) {
+        if (!allowedAttribute(attr, allowedAttributes)) {
+          el.removeAttribute(attr.nodeName);
+        }
+      });
+    };
+
+    for (var i = 0, len = elements.length; i < len; i++) {
+      var _ret = _loop(i);
+
+      if (_ret === "continue") continue;
+    }
+
+    return createdDocument.body.innerHTML;
+  }
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$6 = 'tooltip';
+  var DATA_KEY$6 = 'bs.tooltip';
+  var EVENT_KEY$6 = "." + DATA_KEY$6;
+  var CLASS_PREFIX = 'bs-tooltip';
+  var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
+  var DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
+  var DefaultType$4 = {
+    animation: 'boolean',
+    template: 'string',
+    title: '(string|element|function)',
+    trigger: 'string',
+    delay: '(number|object)',
+    html: 'boolean',
+    selector: '(string|boolean)',
+    placement: '(string|function)',
+    offset: '(array|string|function)',
+    container: '(string|element|boolean)',
+    fallbackPlacements: 'array',
+    boundary: '(string|element)',
+    customClass: '(string|function)',
+    sanitize: 'boolean',
+    sanitizeFn: '(null|function)',
+    allowList: 'object',
+    popperConfig: '(null|object|function)'
+  };
+  var AttachmentMap = {
+    AUTO: 'auto',
+    TOP: 'top',
+    RIGHT: isRTL ? 'left' : 'right',
+    BOTTOM: 'bottom',
+    LEFT: isRTL ? 'right' : 'left'
+  };
+  var Default$4 = {
+    animation: true,
+    template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
+    trigger: 'hover focus',
+    title: '',
+    delay: 0,
+    html: false,
+    selector: false,
+    placement: 'top',
+    offset: [0, 0],
+    container: false,
+    fallbackPlacements: ['top', 'right', 'bottom', 'left'],
+    boundary: 'clippingParents',
+    customClass: '',
+    sanitize: true,
+    sanitizeFn: null,
+    allowList: DefaultAllowlist,
+    popperConfig: null
+  };
+  var Event$1 = {
+    HIDE: "hide" + EVENT_KEY$6,
+    HIDDEN: "hidden" + EVENT_KEY$6,
+    SHOW: "show" + EVENT_KEY$6,
+    SHOWN: "shown" + EVENT_KEY$6,
+    INSERTED: "inserted" + EVENT_KEY$6,
+    CLICK: "click" + EVENT_KEY$6,
+    FOCUSIN: "focusin" + EVENT_KEY$6,
+    FOCUSOUT: "focusout" + EVENT_KEY$6,
+    MOUSEENTER: "mouseenter" + EVENT_KEY$6,
+    MOUSELEAVE: "mouseleave" + EVENT_KEY$6
+  };
+  var CLASS_NAME_FADE$2 = 'fade';
+  var CLASS_NAME_MODAL = 'modal';
+  var CLASS_NAME_SHOW$4 = 'show';
+  var HOVER_STATE_SHOW = 'show';
+  var HOVER_STATE_OUT = 'out';
+  var SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
+  var TRIGGER_HOVER = 'hover';
+  var TRIGGER_FOCUS = 'focus';
+  var TRIGGER_CLICK = 'click';
+  var TRIGGER_MANUAL = 'manual';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Tooltip = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Tooltip, _BaseComponent);
+
+    function Tooltip(element, config) {
+      var _this;
+
+      if (typeof Popper === 'undefined') {
+        throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
+      }
+
+      _this = _BaseComponent.call(this, element) || this; // private
+
+      _this._isEnabled = true;
+      _this._timeout = 0;
+      _this._hoverState = '';
+      _this._activeTrigger = {};
+      _this._popper = null; // Protected
+
+      _this.config = _this._getConfig(config);
+      _this.tip = null;
+
+      _this._setListeners();
+
+      return _this;
+    } // Getters
+
+
+    var _proto = Tooltip.prototype;
+
+    // Public
+    _proto.enable = function enable() {
+      this._isEnabled = true;
+    };
+
+    _proto.disable = function disable() {
+      this._isEnabled = false;
+    };
+
+    _proto.toggleEnabled = function toggleEnabled() {
+      this._isEnabled = !this._isEnabled;
+    };
+
+    _proto.toggle = function toggle(event) {
+      if (!this._isEnabled) {
+        return;
+      }
+
+      if (event) {
+        var context = this._initializeOnDelegatedTarget(event);
+
+        context._activeTrigger.click = !context._activeTrigger.click;
+
+        if (context._isWithActiveTrigger()) {
+          context._enter(null, context);
+        } else {
+          context._leave(null, context);
+        }
+      } else {
+        if (this.getTipElement().classList.contains(CLASS_NAME_SHOW$4)) {
+          this._leave(null, this);
+
+          return;
+        }
+
+        this._enter(null, this);
+      }
+    };
+
+    _proto.dispose = function dispose() {
+      clearTimeout(this._timeout);
+      EventHandler.off(this._element, this.constructor.EVENT_KEY);
+      EventHandler.off(this._element.closest("." + CLASS_NAME_MODAL), 'hide.bs.modal', this._hideModalHandler);
+
+      if (this.tip && this.tip.parentNode) {
+        this.tip.parentNode.removeChild(this.tip);
+      }
+
+      this._isEnabled = null;
+      this._timeout = null;
+      this._hoverState = null;
+      this._activeTrigger = null;
+
+      if (this._popper) {
+        this._popper.destroy();
+      }
+
+      this._popper = null;
+      this.config = null;
+      this.tip = null;
+
+      _BaseComponent.prototype.dispose.call(this);
+    };
+
+    _proto.show = function show() {
+      var _this2 = this;
+
+      if (this._element.style.display === 'none') {
+        throw new Error('Please use show on visible elements');
+      }
+
+      if (!(this.isWithContent() && this._isEnabled)) {
+        return;
+      }
+
+      var showEvent = EventHandler.trigger(this._element, this.constructor.Event.SHOW);
+      var shadowRoot = findShadowRoot(this._element);
+      var isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element);
+
+      if (showEvent.defaultPrevented || !isInTheDom) {
+        return;
+      }
+
+      var tip = this.getTipElement();
+      var tipId = getUID(this.constructor.NAME);
+      tip.setAttribute('id', tipId);
+
+      this._element.setAttribute('aria-describedby', tipId);
+
+      this.setContent();
+
+      if (this.config.animation) {
+        tip.classList.add(CLASS_NAME_FADE$2);
+      }
+
+      var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this._element) : this.config.placement;
+
+      var attachment = this._getAttachment(placement);
+
+      this._addAttachmentClass(attachment);
+
+      var container = this._getContainer();
+
+      Data.setData(tip, this.constructor.DATA_KEY, this);
+
+      if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
+        container.appendChild(tip);
+      }
+
+      EventHandler.trigger(this._element, this.constructor.Event.INSERTED);
+      this._popper = createPopper$2(this._element, tip, this._getPopperConfig(attachment));
+      tip.classList.add(CLASS_NAME_SHOW$4);
+      var customClass = typeof this.config.customClass === 'function' ? this.config.customClass() : this.config.customClass;
+
+      if (customClass) {
+        var _tip$classList;
+
+        (_tip$classList = tip.classList).add.apply(_tip$classList, customClass.split(' '));
+      } // If this is a touch-enabled device we add extra
+      // empty mouseover listeners to the body's immediate children;
+      // only needed because of broken event delegation on iOS
+      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
+
+
+      if ('ontouchstart' in document.documentElement) {
+        var _ref;
+
+        (_ref = []).concat.apply(_ref, document.body.children).forEach(function (element) {
+          EventHandler.on(element, 'mouseover', noop());
+        });
+      }
+
+      var complete = function complete() {
+        var prevHoverState = _this2._hoverState;
+        _this2._hoverState = null;
+        EventHandler.trigger(_this2._element, _this2.constructor.Event.SHOWN);
+
+        if (prevHoverState === HOVER_STATE_OUT) {
+          _this2._leave(null, _this2);
+        }
+      };
+
+      if (this.tip.classList.contains(CLASS_NAME_FADE$2)) {
+        var transitionDuration = getTransitionDurationFromElement(this.tip);
+        EventHandler.one(this.tip, 'transitionend', complete);
+        emulateTransitionEnd(this.tip, transitionDuration);
+      } else {
+        complete();
+      }
+    };
+
+    _proto.hide = function hide() {
+      var _this3 = this;
+
+      if (!this._popper) {
+        return;
+      }
+
+      var tip = this.getTipElement();
+
+      var complete = function complete() {
+        if (_this3._hoverState !== HOVER_STATE_SHOW && tip.parentNode) {
+          tip.parentNode.removeChild(tip);
+        }
+
+        _this3._cleanTipClass();
+
+        _this3._element.removeAttribute('aria-describedby');
+
+        EventHandler.trigger(_this3._element, _this3.constructor.Event.HIDDEN);
+
+        if (_this3._popper) {
+          _this3._popper.destroy();
+
+          _this3._popper = null;
+        }
+      };
+
+      var hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE);
+
+      if (hideEvent.defaultPrevented) {
+        return;
+      }
+
+      tip.classList.remove(CLASS_NAME_SHOW$4); // If this is a touch-enabled device we remove the extra
+      // empty mouseover listeners we added for iOS support
+
+      if ('ontouchstart' in document.documentElement) {
+        var _ref2;
+
+        (_ref2 = []).concat.apply(_ref2, document.body.children).forEach(function (element) {
+          return EventHandler.off(element, 'mouseover', noop);
+        });
+      }
+
+      this._activeTrigger[TRIGGER_CLICK] = false;
+      this._activeTrigger[TRIGGER_FOCUS] = false;
+      this._activeTrigger[TRIGGER_HOVER] = false;
+
+      if (this.tip.classList.contains(CLASS_NAME_FADE$2)) {
+        var transitionDuration = getTransitionDurationFromElement(tip);
+        EventHandler.one(tip, 'transitionend', complete);
+        emulateTransitionEnd(tip, transitionDuration);
+      } else {
+        complete();
+      }
+
+      this._hoverState = '';
+    };
+
+    _proto.update = function update() {
+      if (this._popper !== null) {
+        this._popper.update();
+      }
+    } // Protected
+    ;
+
+    _proto.isWithContent = function isWithContent() {
+      return Boolean(this.getTitle());
+    };
+
+    _proto.getTipElement = function getTipElement() {
+      if (this.tip) {
+        return this.tip;
+      }
+
+      var element = document.createElement('div');
+      element.innerHTML = this.config.template;
+      this.tip = element.children[0];
+      return this.tip;
+    };
+
+    _proto.setContent = function setContent() {
+      var tip = this.getTipElement();
+      this.setElementContent(SelectorEngine.findOne(SELECTOR_TOOLTIP_INNER, tip), this.getTitle());
+      tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$4);
+    };
+
+    _proto.setElementContent = function setElementContent(element, content) {
+      if (element === null) {
+        return;
+      }
+
+      if (typeof content === 'object' && isElement(content)) {
+        if (content.jquery) {
+          content = content[0];
+        } // content is a DOM node or a jQuery
+
+
+        if (this.config.html) {
+          if (content.parentNode !== element) {
+            element.innerHTML = '';
+            element.appendChild(content);
+          }
+        } else {
+          element.textContent = content.textContent;
+        }
+
+        return;
+      }
+
+      if (this.config.html) {
+        if (this.config.sanitize) {
+          content = sanitizeHtml(content, this.config.allowList, this.config.sanitizeFn);
+        }
+
+        element.innerHTML = content;
+      } else {
+        element.textContent = content;
+      }
+    };
+
+    _proto.getTitle = function getTitle() {
+      var title = this._element.getAttribute('data-bs-original-title');
+
+      if (!title) {
+        title = typeof this.config.title === 'function' ? this.config.title.call(this._element) : this.config.title;
+      }
+
+      return title;
+    };
+
+    _proto.updateAttachment = function updateAttachment(attachment) {
+      if (attachment === 'right') {
+        return 'end';
+      }
+
+      if (attachment === 'left') {
+        return 'start';
+      }
+
+      return attachment;
+    } // Private
+    ;
+
+    _proto._initializeOnDelegatedTarget = function _initializeOnDelegatedTarget(event, context) {
+      var dataKey = this.constructor.DATA_KEY;
+      context = context || Data.getData(event.delegateTarget, dataKey);
+
+      if (!context) {
+        context = new this.constructor(event.delegateTarget, this._getDelegateConfig());
+        Data.setData(event.delegateTarget, dataKey, context);
+      }
+
+      return context;
+    };
+
+    _proto._getOffset = function _getOffset() {
+      var _this4 = this;
+
+      var offset = this.config.offset;
+
+      if (typeof offset === 'string') {
+        return offset.split(',').map(function (val) {
+          return Number.parseInt(val, 10);
+        });
+      }
+
+      if (typeof offset === 'function') {
+        return function (popperData) {
+          return offset(popperData, _this4._element);
+        };
+      }
+
+      return offset;
+    };
+
+    _proto._getPopperConfig = function _getPopperConfig(attachment) {
+      var _this5 = this;
+
+      var defaultBsPopperConfig = {
+        placement: attachment,
+        modifiers: [{
+          name: 'flip',
+          options: {
+            altBoundary: true,
+            fallbackPlacements: this.config.fallbackPlacements
+          }
+        }, {
+          name: 'offset',
+          options: {
+            offset: this._getOffset()
+          }
+        }, {
+          name: 'preventOverflow',
+          options: {
+            boundary: this.config.boundary
+          }
+        }, {
+          name: 'arrow',
+          options: {
+            element: "." + this.constructor.NAME + "-arrow"
+          }
+        }, {
+          name: 'onChange',
+          enabled: true,
+          phase: 'afterWrite',
+          fn: function fn(data) {
+            return _this5._handlePopperPlacementChange(data);
+          }
+        }],
+        onFirstUpdate: function onFirstUpdate(data) {
+          if (data.options.placement !== data.placement) {
+            _this5._handlePopperPlacementChange(data);
+          }
+        }
+      };
+      return _extends({}, defaultBsPopperConfig, typeof this.config.popperConfig === 'function' ? this.config.popperConfig(defaultBsPopperConfig) : this.config.popperConfig);
+    };
+
+    _proto._addAttachmentClass = function _addAttachmentClass(attachment) {
+      this.getTipElement().classList.add(CLASS_PREFIX + "-" + this.updateAttachment(attachment));
+    };
+
+    _proto._getContainer = function _getContainer() {
+      if (this.config.container === false) {
+        return document.body;
+      }
+
+      if (isElement(this.config.container)) {
+        return this.config.container;
+      }
+
+      return SelectorEngine.findOne(this.config.container);
+    };
+
+    _proto._getAttachment = function _getAttachment(placement) {
+      return AttachmentMap[placement.toUpperCase()];
+    };
+
+    _proto._setListeners = function _setListeners() {
+      var _this6 = this;
+
+      var triggers = this.config.trigger.split(' ');
+      triggers.forEach(function (trigger) {
+        if (trigger === 'click') {
+          EventHandler.on(_this6._element, _this6.constructor.Event.CLICK, _this6.config.selector, function (event) {
+            return _this6.toggle(event);
+          });
+        } else if (trigger !== TRIGGER_MANUAL) {
+          var eventIn = trigger === TRIGGER_HOVER ? _this6.constructor.Event.MOUSEENTER : _this6.constructor.Event.FOCUSIN;
+          var eventOut = trigger === TRIGGER_HOVER ? _this6.constructor.Event.MOUSELEAVE : _this6.constructor.Event.FOCUSOUT;
+          EventHandler.on(_this6._element, eventIn, _this6.config.selector, function (event) {
+            return _this6._enter(event);
+          });
+          EventHandler.on(_this6._element, eventOut, _this6.config.selector, function (event) {
+            return _this6._leave(event);
+          });
+        }
+      });
+
+      this._hideModalHandler = function () {
+        if (_this6._element) {
+          _this6.hide();
+        }
+      };
+
+      EventHandler.on(this._element.closest("." + CLASS_NAME_MODAL), 'hide.bs.modal', this._hideModalHandler);
+
+      if (this.config.selector) {
+        this.config = _extends({}, this.config, {
+          trigger: 'manual',
+          selector: ''
+        });
+      } else {
+        this._fixTitle();
+      }
+    };
+
+    _proto._fixTitle = function _fixTitle() {
+      var title = this._element.getAttribute('title');
+
+      var originalTitleType = typeof this._element.getAttribute('data-bs-original-title');
+
+      if (title || originalTitleType !== 'string') {
+        this._element.setAttribute('data-bs-original-title', title || '');
+
+        if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) {
+          this._element.setAttribute('aria-label', title);
+        }
+
+        this._element.setAttribute('title', '');
+      }
+    };
+
+    _proto._enter = function _enter(event, context) {
+      context = this._initializeOnDelegatedTarget(event, context);
+
+      if (event) {
+        context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
+      }
+
+      if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$4) || context._hoverState === HOVER_STATE_SHOW) {
+        context._hoverState = HOVER_STATE_SHOW;
+        return;
+      }
+
+      clearTimeout(context._timeout);
+      context._hoverState = HOVER_STATE_SHOW;
+
+      if (!context.config.delay || !context.config.delay.show) {
+        context.show();
+        return;
+      }
+
+      context._timeout = setTimeout(function () {
+        if (context._hoverState === HOVER_STATE_SHOW) {
+          context.show();
+        }
+      }, context.config.delay.show);
+    };
+
+    _proto._leave = function _leave(event, context) {
+      context = this._initializeOnDelegatedTarget(event, context);
+
+      if (event) {
+        context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false;
+      }
+
+      if (context._isWithActiveTrigger()) {
+        return;
+      }
+
+      clearTimeout(context._timeout);
+      context._hoverState = HOVER_STATE_OUT;
+
+      if (!context.config.delay || !context.config.delay.hide) {
+        context.hide();
+        return;
+      }
+
+      context._timeout = setTimeout(function () {
+        if (context._hoverState === HOVER_STATE_OUT) {
+          context.hide();
+        }
+      }, context.config.delay.hide);
+    };
+
+    _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
+      for (var trigger in this._activeTrigger) {
+        if (this._activeTrigger[trigger]) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    _proto._getConfig = function _getConfig(config) {
+      var dataAttributes = Manipulator.getDataAttributes(this._element);
+      Object.keys(dataAttributes).forEach(function (dataAttr) {
+        if (DISALLOWED_ATTRIBUTES.has(dataAttr)) {
+          delete dataAttributes[dataAttr];
+        }
+      });
+
+      if (config && typeof config.container === 'object' && config.container.jquery) {
+        config.container = config.container[0];
+      }
+
+      config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {});
+
+      if (typeof config.delay === 'number') {
+        config.delay = {
+          show: config.delay,
+          hide: config.delay
+        };
+      }
+
+      if (typeof config.title === 'number') {
+        config.title = config.title.toString();
+      }
+
+      if (typeof config.content === 'number') {
+        config.content = config.content.toString();
+      }
+
+      typeCheckConfig(NAME$6, config, this.constructor.DefaultType);
+
+      if (config.sanitize) {
+        config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn);
+      }
+
+      return config;
+    };
+
+    _proto._getDelegateConfig = function _getDelegateConfig() {
+      var config = {};
+
+      if (this.config) {
+        for (var key in this.config) {
+          if (this.constructor.Default[key] !== this.config[key]) {
+            config[key] = this.config[key];
+          }
+        }
+      }
+
+      return config;
+    };
+
+    _proto._cleanTipClass = function _cleanTipClass() {
+      var tip = this.getTipElement();
+      var tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX);
+
+      if (tabClass !== null && tabClass.length > 0) {
+        tabClass.map(function (token) {
+          return token.trim();
+        }).forEach(function (tClass) {
+          return tip.classList.remove(tClass);
+        });
+      }
+    };
+
+    _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
+      var state = popperData.state;
+
+      if (!state) {
+        return;
+      }
+
+      this.tip = state.elements.popper;
+
+      this._cleanTipClass();
+
+      this._addAttachmentClass(this._getAttachment(state.placement));
+    } // Static
+    ;
+
+    Tooltip.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$6);
+
+        var _config = typeof config === 'object' && config;
+
+        if (!data && /dispose|hide/.test(config)) {
+          return;
+        }
+
+        if (!data) {
+          data = new Tooltip(this, _config);
+        }
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config]();
+        }
+      });
+    };
+
+    _createClass(Tooltip, null, [{
+      key: "Default",
+      get: function get() {
+        return Default$4;
+      }
+    }, {
+      key: "NAME",
+      get: function get() {
+        return NAME$6;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$6;
+      }
+    }, {
+      key: "Event",
+      get: function get() {
+        return Event$1;
+      }
+    }, {
+      key: "EVENT_KEY",
+      get: function get() {
+        return EVENT_KEY$6;
+      }
+    }, {
+      key: "DefaultType",
+      get: function get() {
+        return DefaultType$4;
+      }
+    }]);
+
+    return Tooltip;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Tooltip to jQuery only if jQuery is present
+   */
+
+
+  defineJQueryPlugin(NAME$6, Tooltip);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$7 = 'popover';
+  var DATA_KEY$7 = 'bs.popover';
+  var EVENT_KEY$7 = "." + DATA_KEY$7;
+  var CLASS_PREFIX$1 = 'bs-popover';
+  var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g');
+
+  var Default$5 = _extends({}, Tooltip.Default, {
+    placement: 'right',
+    offset: [0, 8],
+    trigger: 'click',
+    content: '',
+    template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>'
+  });
+
+  var DefaultType$5 = _extends({}, Tooltip.DefaultType, {
+    content: '(string|element|function)'
+  });
+
+  var Event$2 = {
+    HIDE: "hide" + EVENT_KEY$7,
+    HIDDEN: "hidden" + EVENT_KEY$7,
+    SHOW: "show" + EVENT_KEY$7,
+    SHOWN: "shown" + EVENT_KEY$7,
+    INSERTED: "inserted" + EVENT_KEY$7,
+    CLICK: "click" + EVENT_KEY$7,
+    FOCUSIN: "focusin" + EVENT_KEY$7,
+    FOCUSOUT: "focusout" + EVENT_KEY$7,
+    MOUSEENTER: "mouseenter" + EVENT_KEY$7,
+    MOUSELEAVE: "mouseleave" + EVENT_KEY$7
+  };
+  var CLASS_NAME_FADE$3 = 'fade';
+  var CLASS_NAME_SHOW$5 = 'show';
+  var SELECTOR_TITLE = '.popover-header';
+  var SELECTOR_CONTENT = '.popover-body';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Popover = /*#__PURE__*/function (_Tooltip) {
+    _inheritsLoose(Popover, _Tooltip);
+
+    function Popover() {
+      return _Tooltip.apply(this, arguments) || this;
+    }
+
+    var _proto = Popover.prototype;
+
+    // Overrides
+    _proto.isWithContent = function isWithContent() {
+      return this.getTitle() || this._getContent();
+    };
+
+    _proto.setContent = function setContent() {
+      var tip = this.getTipElement(); // we use append for html objects to maintain js events
+
+      this.setElementContent(SelectorEngine.findOne(SELECTOR_TITLE, tip), this.getTitle());
+
+      var content = this._getContent();
+
+      if (typeof content === 'function') {
+        content = content.call(this._element);
+      }
+
+      this.setElementContent(SelectorEngine.findOne(SELECTOR_CONTENT, tip), content);
+      tip.classList.remove(CLASS_NAME_FADE$3, CLASS_NAME_SHOW$5);
+    } // Private
+    ;
+
+    _proto._addAttachmentClass = function _addAttachmentClass(attachment) {
+      this.getTipElement().classList.add(CLASS_PREFIX$1 + "-" + this.updateAttachment(attachment));
+    };
+
+    _proto._getContent = function _getContent() {
+      return this._element.getAttribute('data-bs-content') || this.config.content;
+    };
+
+    _proto._cleanTipClass = function _cleanTipClass() {
+      var tip = this.getTipElement();
+      var tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX$1);
+
+      if (tabClass !== null && tabClass.length > 0) {
+        tabClass.map(function (token) {
+          return token.trim();
+        }).forEach(function (tClass) {
+          return tip.classList.remove(tClass);
+        });
+      }
+    } // Static
+    ;
+
+    Popover.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$7);
+
+        var _config = typeof config === 'object' ? config : null;
+
+        if (!data && /dispose|hide/.test(config)) {
+          return;
+        }
+
+        if (!data) {
+          data = new Popover(this, _config);
+          Data.setData(this, DATA_KEY$7, data);
+        }
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config]();
+        }
+      });
+    };
+
+    _createClass(Popover, null, [{
+      key: "Default",
+      get: // Getters
+      function get() {
+        return Default$5;
+      }
+    }, {
+      key: "NAME",
+      get: function get() {
+        return NAME$7;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$7;
+      }
+    }, {
+      key: "Event",
+      get: function get() {
+        return Event$2;
+      }
+    }, {
+      key: "EVENT_KEY",
+      get: function get() {
+        return EVENT_KEY$7;
+      }
+    }, {
+      key: "DefaultType",
+      get: function get() {
+        return DefaultType$5;
+      }
+    }]);
+
+    return Popover;
+  }(Tooltip);
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Popover to jQuery only if jQuery is present
+   */
+
+
+  defineJQueryPlugin(NAME$7, Popover);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$8 = 'scrollspy';
+  var DATA_KEY$8 = 'bs.scrollspy';
+  var EVENT_KEY$8 = "." + DATA_KEY$8;
+  var DATA_API_KEY$6 = '.data-api';
+  var Default$6 = {
+    offset: 10,
+    method: 'auto',
+    target: ''
+  };
+  var DefaultType$6 = {
+    offset: 'number',
+    method: 'string',
+    target: '(string|element)'
+  };
+  var EVENT_ACTIVATE = "activate" + EVENT_KEY$8;
+  var EVENT_SCROLL = "scroll" + EVENT_KEY$8;
+  var EVENT_LOAD_DATA_API$1 = "load" + EVENT_KEY$8 + DATA_API_KEY$6;
+  var CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
+  var CLASS_NAME_ACTIVE$2 = 'active';
+  var SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
+  var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
+  var SELECTOR_NAV_LINKS = '.nav-link';
+  var SELECTOR_NAV_ITEMS = '.nav-item';
+  var SELECTOR_LIST_ITEMS = '.list-group-item';
+  var SELECTOR_DROPDOWN = '.dropdown';
+  var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
+  var METHOD_OFFSET = 'offset';
+  var METHOD_POSITION = 'position';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var ScrollSpy = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(ScrollSpy, _BaseComponent);
+
+    function ScrollSpy(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._scrollElement = element.tagName === 'BODY' ? window : element;
+      _this._config = _this._getConfig(config);
+      _this._selector = _this._config.target + " " + SELECTOR_NAV_LINKS + ", " + _this._config.target + " " + SELECTOR_LIST_ITEMS + ", " + _this._config.target + " ." + CLASS_NAME_DROPDOWN_ITEM;
+      _this._offsets = [];
+      _this._targets = [];
+      _this._activeTarget = null;
+      _this._scrollHeight = 0;
+      EventHandler.on(_this._scrollElement, EVENT_SCROLL, function () {
+        return _this._process();
+      });
+
+      _this.refresh();
+
+      _this._process();
+
+      return _this;
+    } // Getters
+
+
+    var _proto = ScrollSpy.prototype;
+
+    // Public
+    _proto.refresh = function refresh() {
+      var _this2 = this;
+
+      var autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
+      var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
+      var offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
+      this._offsets = [];
+      this._targets = [];
+      this._scrollHeight = this._getScrollHeight();
+      var targets = SelectorEngine.find(this._selector);
+      targets.map(function (element) {
+        var targetSelector = getSelectorFromElement(element);
+        var target = targetSelector ? SelectorEngine.findOne(targetSelector) : null;
+
+        if (target) {
+          var targetBCR = target.getBoundingClientRect();
+
+          if (targetBCR.width || targetBCR.height) {
+            return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector];
+          }
+        }
+
+        return null;
+      }).filter(function (item) {
+        return item;
+      }).sort(function (a, b) {
+        return a[0] - b[0];
+      }).forEach(function (item) {
+        _this2._offsets.push(item[0]);
+
+        _this2._targets.push(item[1]);
+      });
+    };
+
+    _proto.dispose = function dispose() {
+      _BaseComponent.prototype.dispose.call(this);
+
+      EventHandler.off(this._scrollElement, EVENT_KEY$8);
+      this._scrollElement = null;
+      this._config = null;
+      this._selector = null;
+      this._offsets = null;
+      this._targets = null;
+      this._activeTarget = null;
+      this._scrollHeight = null;
+    } // Private
+    ;
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, Default$6, typeof config === 'object' && config ? config : {});
+
+      if (typeof config.target !== 'string' && isElement(config.target)) {
+        var id = config.target.id;
+
+        if (!id) {
+          id = getUID(NAME$8);
+          config.target.id = id;
+        }
+
+        config.target = "#" + id;
+      }
+
+      typeCheckConfig(NAME$8, config, DefaultType$6);
+      return config;
+    };
+
+    _proto._getScrollTop = function _getScrollTop() {
+      return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
+    };
+
+    _proto._getScrollHeight = function _getScrollHeight() {
+      return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
+    };
+
+    _proto._getOffsetHeight = function _getOffsetHeight() {
+      return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
+    };
+
+    _proto._process = function _process() {
+      var scrollTop = this._getScrollTop() + this._config.offset;
+
+      var scrollHeight = this._getScrollHeight();
+
+      var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
+
+      if (this._scrollHeight !== scrollHeight) {
+        this.refresh();
+      }
+
+      if (scrollTop >= maxScroll) {
+        var target = this._targets[this._targets.length - 1];
+
+        if (this._activeTarget !== target) {
+          this._activate(target);
+        }
+
+        return;
+      }
+
+      if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
+        this._activeTarget = null;
+
+        this._clear();
+
+        return;
+      }
+
+      for (var i = this._offsets.length; i--;) {
+        var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
+
+        if (isActiveTarget) {
+          this._activate(this._targets[i]);
+        }
+      }
+    };
+
+    _proto._activate = function _activate(target) {
+      this._activeTarget = target;
+
+      this._clear();
+
+      var queries = this._selector.split(',').map(function (selector) {
+        return selector + "[data-bs-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]";
+      });
+
+      var link = SelectorEngine.findOne(queries.join(','));
+
+      if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
+        SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE, link.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$2);
+        link.classList.add(CLASS_NAME_ACTIVE$2);
+      } else {
+        // Set triggered link as active
+        link.classList.add(CLASS_NAME_ACTIVE$2);
+        SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP).forEach(function (listGroup) {
+          // Set triggered links parents as active
+          // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
+          SelectorEngine.prev(listGroup, SELECTOR_NAV_LINKS + ", " + SELECTOR_LIST_ITEMS).forEach(function (item) {
+            return item.classList.add(CLASS_NAME_ACTIVE$2);
+          }); // Handle special case when .nav-link is inside .nav-item
+
+          SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(function (navItem) {
+            SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach(function (item) {
+              return item.classList.add(CLASS_NAME_ACTIVE$2);
+            });
+          });
+        });
+      }
+
+      EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, {
+        relatedTarget: target
+      });
+    };
+
+    _proto._clear = function _clear() {
+      SelectorEngine.find(this._selector).filter(function (node) {
+        return node.classList.contains(CLASS_NAME_ACTIVE$2);
+      }).forEach(function (node) {
+        return node.classList.remove(CLASS_NAME_ACTIVE$2);
+      });
+    } // Static
+    ;
+
+    ScrollSpy.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$8);
+
+        var _config = typeof config === 'object' && config;
+
+        if (!data) {
+          data = new ScrollSpy(this, _config);
+        }
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config]();
+        }
+      });
+    };
+
+    _createClass(ScrollSpy, null, [{
+      key: "Default",
+      get: function get() {
+        return Default$6;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$8;
+      }
+    }]);
+
+    return ScrollSpy;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(window, EVENT_LOAD_DATA_API$1, function () {
+    SelectorEngine.find(SELECTOR_DATA_SPY).forEach(function (spy) {
+      return new ScrollSpy(spy, Manipulator.getDataAttributes(spy));
+    });
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .ScrollSpy to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$8, ScrollSpy);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$9 = 'tab';
+  var DATA_KEY$9 = 'bs.tab';
+  var EVENT_KEY$9 = "." + DATA_KEY$9;
+  var DATA_API_KEY$7 = '.data-api';
+  var EVENT_HIDE$3 = "hide" + EVENT_KEY$9;
+  var EVENT_HIDDEN$3 = "hidden" + EVENT_KEY$9;
+  var EVENT_SHOW$3 = "show" + EVENT_KEY$9;
+  var EVENT_SHOWN$3 = "shown" + EVENT_KEY$9;
+  var EVENT_CLICK_DATA_API$6 = "click" + EVENT_KEY$9 + DATA_API_KEY$7;
+  var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
+  var CLASS_NAME_ACTIVE$3 = 'active';
+  var CLASS_NAME_DISABLED$1 = 'disabled';
+  var CLASS_NAME_FADE$4 = 'fade';
+  var CLASS_NAME_SHOW$6 = 'show';
+  var SELECTOR_DROPDOWN$1 = '.dropdown';
+  var SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group';
+  var SELECTOR_ACTIVE$1 = '.active';
+  var SELECTOR_ACTIVE_UL = ':scope > li > .active';
+  var SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
+  var SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
+  var SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Tab = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Tab, _BaseComponent);
+
+    function Tab() {
+      return _BaseComponent.apply(this, arguments) || this;
+    }
+
+    var _proto = Tab.prototype;
+
+    // Public
+    _proto.show = function show() {
+      var _this = this;
+
+      if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE$3) || this._element.classList.contains(CLASS_NAME_DISABLED$1)) {
+        return;
+      }
+
+      var previous;
+      var target = getElementFromSelector(this._element);
+
+      var listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP$1);
+
+      if (listElement) {
+        var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE$1;
+        previous = SelectorEngine.find(itemSelector, listElement);
+        previous = previous[previous.length - 1];
+      }
+
+      var hideEvent = previous ? EventHandler.trigger(previous, EVENT_HIDE$3, {
+        relatedTarget: this._element
+      }) : null;
+      var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
+        relatedTarget: previous
+      });
+
+      if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) {
+        return;
+      }
+
+      this._activate(this._element, listElement);
+
+      var complete = function complete() {
+        EventHandler.trigger(previous, EVENT_HIDDEN$3, {
+          relatedTarget: _this._element
+        });
+        EventHandler.trigger(_this._element, EVENT_SHOWN$3, {
+          relatedTarget: previous
+        });
+      };
+
+      if (target) {
+        this._activate(target, target.parentNode, complete);
+      } else {
+        complete();
+      }
+    } // Private
+    ;
+
+    _proto._activate = function _activate(element, container, callback) {
+      var _this2 = this;
+
+      var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine.children(container, SELECTOR_ACTIVE$1);
+      var active = activeElements[0];
+      var isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE$4);
+
+      var complete = function complete() {
+        return _this2._transitionComplete(element, active, callback);
+      };
+
+      if (active && isTransitioning) {
+        var transitionDuration = getTransitionDurationFromElement(active);
+        active.classList.remove(CLASS_NAME_SHOW$6);
+        EventHandler.one(active, 'transitionend', complete);
+        emulateTransitionEnd(active, transitionDuration);
+      } else {
+        complete();
+      }
+    };
+
+    _proto._transitionComplete = function _transitionComplete(element, active, callback) {
+      if (active) {
+        active.classList.remove(CLASS_NAME_ACTIVE$3);
+        var dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode);
+
+        if (dropdownChild) {
+          dropdownChild.classList.remove(CLASS_NAME_ACTIVE$3);
+        }
+
+        if (active.getAttribute('role') === 'tab') {
+          active.setAttribute('aria-selected', false);
+        }
+      }
+
+      element.classList.add(CLASS_NAME_ACTIVE$3);
+
+      if (element.getAttribute('role') === 'tab') {
+        element.setAttribute('aria-selected', true);
+      }
+
+      reflow(element);
+
+      if (element.classList.contains(CLASS_NAME_FADE$4)) {
+        element.classList.add(CLASS_NAME_SHOW$6);
+      }
+
+      if (element.parentNode && element.parentNode.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
+        var dropdownElement = element.closest(SELECTOR_DROPDOWN$1);
+
+        if (dropdownElement) {
+          SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE$1).forEach(function (dropdown) {
+            return dropdown.classList.add(CLASS_NAME_ACTIVE$3);
+          });
+        }
+
+        element.setAttribute('aria-expanded', true);
+      }
+
+      if (callback) {
+        callback();
+      }
+    } // Static
+    ;
+
+    Tab.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$9) || new Tab(this);
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config]();
+        }
+      });
+    };
+
+    _createClass(Tab, null, [{
+      key: "DATA_KEY",
+      get: // Getters
+      function get() {
+        return DATA_KEY$9;
+      }
+    }]);
+
+    return Tab;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * Data Api implementation
+   * ------------------------------------------------------------------------
+   */
+
+
+  EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$4, function (event) {
+    event.preventDefault();
+    var data = Data.getData(this, DATA_KEY$9) || new Tab(this);
+    data.show();
+  });
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Tab to jQuery only if jQuery is present
+   */
+
+  defineJQueryPlugin(NAME$9, Tab);
+
+  /**
+   * ------------------------------------------------------------------------
+   * Constants
+   * ------------------------------------------------------------------------
+   */
+
+  var NAME$a = 'toast';
+  var DATA_KEY$a = 'bs.toast';
+  var EVENT_KEY$a = "." + DATA_KEY$a;
+  var EVENT_CLICK_DISMISS$1 = "click.dismiss" + EVENT_KEY$a;
+  var EVENT_HIDE$4 = "hide" + EVENT_KEY$a;
+  var EVENT_HIDDEN$4 = "hidden" + EVENT_KEY$a;
+  var EVENT_SHOW$4 = "show" + EVENT_KEY$a;
+  var EVENT_SHOWN$4 = "shown" + EVENT_KEY$a;
+  var CLASS_NAME_FADE$5 = 'fade';
+  var CLASS_NAME_HIDE = 'hide';
+  var CLASS_NAME_SHOW$7 = 'show';
+  var CLASS_NAME_SHOWING = 'showing';
+  var DefaultType$7 = {
+    animation: 'boolean',
+    autohide: 'boolean',
+    delay: 'number'
+  };
+  var Default$7 = {
+    animation: true,
+    autohide: true,
+    delay: 5000
+  };
+  var SELECTOR_DATA_DISMISS$1 = '[data-bs-dismiss="toast"]';
+  /**
+   * ------------------------------------------------------------------------
+   * Class Definition
+   * ------------------------------------------------------------------------
+   */
+
+  var Toast = /*#__PURE__*/function (_BaseComponent) {
+    _inheritsLoose(Toast, _BaseComponent);
+
+    function Toast(element, config) {
+      var _this;
+
+      _this = _BaseComponent.call(this, element) || this;
+      _this._config = _this._getConfig(config);
+      _this._timeout = null;
+
+      _this._setListeners();
+
+      return _this;
+    } // Getters
+
+
+    var _proto = Toast.prototype;
+
+    // Public
+    _proto.show = function show() {
+      var _this2 = this;
+
+      var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4);
+
+      if (showEvent.defaultPrevented) {
+        return;
+      }
+
+      this._clearTimeout();
+
+      if (this._config.animation) {
+        this._element.classList.add(CLASS_NAME_FADE$5);
+      }
+
+      var complete = function complete() {
+        _this2._element.classList.remove(CLASS_NAME_SHOWING);
+
+        _this2._element.classList.add(CLASS_NAME_SHOW$7);
+
+        EventHandler.trigger(_this2._element, EVENT_SHOWN$4);
+
+        if (_this2._config.autohide) {
+          _this2._timeout = setTimeout(function () {
+            _this2.hide();
+          }, _this2._config.delay);
+        }
+      };
+
+      this._element.classList.remove(CLASS_NAME_HIDE);
+
+      reflow(this._element);
+
+      this._element.classList.add(CLASS_NAME_SHOWING);
+
+      if (this._config.animation) {
+        var transitionDuration = getTransitionDurationFromElement(this._element);
+        EventHandler.one(this._element, 'transitionend', complete);
+        emulateTransitionEnd(this._element, transitionDuration);
+      } else {
+        complete();
+      }
+    };
+
+    _proto.hide = function hide() {
+      var _this3 = this;
+
+      if (!this._element.classList.contains(CLASS_NAME_SHOW$7)) {
+        return;
+      }
+
+      var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
+
+      if (hideEvent.defaultPrevented) {
+        return;
+      }
+
+      var complete = function complete() {
+        _this3._element.classList.add(CLASS_NAME_HIDE);
+
+        EventHandler.trigger(_this3._element, EVENT_HIDDEN$4);
+      };
+
+      this._element.classList.remove(CLASS_NAME_SHOW$7);
+
+      if (this._config.animation) {
+        var transitionDuration = getTransitionDurationFromElement(this._element);
+        EventHandler.one(this._element, 'transitionend', complete);
+        emulateTransitionEnd(this._element, transitionDuration);
+      } else {
+        complete();
+      }
+    };
+
+    _proto.dispose = function dispose() {
+      this._clearTimeout();
+
+      if (this._element.classList.contains(CLASS_NAME_SHOW$7)) {
+        this._element.classList.remove(CLASS_NAME_SHOW$7);
+      }
+
+      EventHandler.off(this._element, EVENT_CLICK_DISMISS$1);
+
+      _BaseComponent.prototype.dispose.call(this);
+
+      this._config = null;
+    } // Private
+    ;
+
+    _proto._getConfig = function _getConfig(config) {
+      config = _extends({}, Default$7, Manipulator.getDataAttributes(this._element), typeof config === 'object' && config ? config : {});
+      typeCheckConfig(NAME$a, config, this.constructor.DefaultType);
+      return config;
+    };
+
+    _proto._setListeners = function _setListeners() {
+      var _this4 = this;
+
+      EventHandler.on(this._element, EVENT_CLICK_DISMISS$1, SELECTOR_DATA_DISMISS$1, function () {
+        return _this4.hide();
+      });
+    };
+
+    _proto._clearTimeout = function _clearTimeout() {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    } // Static
+    ;
+
+    Toast.jQueryInterface = function jQueryInterface(config) {
+      return this.each(function () {
+        var data = Data.getData(this, DATA_KEY$a);
+
+        var _config = typeof config === 'object' && config;
+
+        if (!data) {
+          data = new Toast(this, _config);
+        }
+
+        if (typeof config === 'string') {
+          if (typeof data[config] === 'undefined') {
+            throw new TypeError("No method named \"" + config + "\"");
+          }
+
+          data[config](this);
+        }
+      });
+    };
+
+    _createClass(Toast, null, [{
+      key: "DefaultType",
+      get: function get() {
+        return DefaultType$7;
+      }
+    }, {
+      key: "Default",
+      get: function get() {
+        return Default$7;
+      }
+    }, {
+      key: "DATA_KEY",
+      get: function get() {
+        return DATA_KEY$a;
+      }
+    }]);
+
+    return Toast;
+  }(BaseComponent);
+  /**
+   * ------------------------------------------------------------------------
+   * jQuery
+   * ------------------------------------------------------------------------
+   * add .Toast to jQuery only if jQuery is present
+   */
+
+
+  defineJQueryPlugin(NAME$a, Toast);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v5.0.0-beta2): index.umd.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+  var index_umd = {
+    Alert: Alert,
+    Button: Button,
+    Carousel: Carousel,
+    Collapse: Collapse,
+    Dropdown: Dropdown,
+    Modal: Modal,
+    Popover: Popover,
+    ScrollSpy: ScrollSpy,
+    Tab: Tab,
+    Toast: Toast,
+    Tooltip: Tooltip
+  };
+
+  return index_umd;
+
+})));
+//# sourceMappingURL=bootstrap.bundle.js.map
diff --git a/src/main/resources/web/js/bootstrap.bundle.min.js b/src/main/resources/web/js/bootstrap.bundle.min.js
new file mode 100644
index 0000000..c682e1b
--- /dev/null
+++ b/src/main/resources/web/js/bootstrap.bundle.min.js
@@ -0,0 +1,7 @@
+/*!
+  * Bootstrap v5.0.0-beta2 (https://getbootstrap.com/)
+  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+  */
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).bootstrap=e()}(this,(function(){"use strict";function t(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function e(e,n,i){return n&&t(e.prototype,n),i&&t(e,i),e}function n(){return(n=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var i in n)Object.prototype.hasOwnProperty.call(n,i)&&(t[i]=n[i])}return t}).apply(this,arguments)}function i(t,e){var n,i;t.prototype=Object.create(e.prototype),t.prototype.constructor=t,n=t,i=e,(Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(n,i)}var o,r,s=function(t){do{t+=Math.floor(1e6*Math.random())}while(document.getElementById(t));return t},a=function(t){var e=t.getAttribute("data-bs-target");if(!e||"#"===e){var n=t.getAttribute("href");if(!n||!n.includes("#")&&!n.startsWith("."))return null;n.includes("#")&&!n.startsWith("#")&&(n="#"+n.split("#")[1]),e=n&&"#"!==n?n.trim():null}return e},l=function(t){var e=a(t);return e&&document.querySelector(e)?e:null},c=function(t){var e=a(t);return e?document.querySelector(e):null},u=function(t){if(!t)return 0;var e=window.getComputedStyle(t),n=e.transitionDuration,i=e.transitionDelay,o=Number.parseFloat(n),r=Number.parseFloat(i);return o||r?(n=n.split(",")[0],i=i.split(",")[0],1e3*(Number.parseFloat(n)+Number.parseFloat(i))):0},f=function(t){t.dispatchEvent(new Event("transitionend"))},d=function(t){return(t[0]||t).nodeType},h=function(t,e){var n=!1,i=e+5;t.addEventListener("transitionend",(function e(){n=!0,t.removeEventListener("transitionend",e)})),setTimeout((function(){n||f(t)}),i)},p=function(t,e,n){Object.keys(n).forEach((function(i){var o,r=n[i],s=e[i],a=s&&d(s)?"element":null==(o=s)?""+o:{}.toString.call(o).match(/\s([a-z]+)/i)[1].toLowerCase();if(!new RegExp(r).test(a))throw new TypeError(t.toUpperCase()+': Option "'+i+'" provided type "'+a+'" but expected type "'+r+'".')}))},g=function(t){if(!t)return!1;if(t.style&&t.parentNode&&t.parentNode.style){var e=getComputedStyle(t),n=getComputedStyle(t.parentNode);return"none"!==e.display&&"none"!==n.display&&"hidden"!==e.visibility}return!1},m=function(){return function(){}},v=function(t){return t.offsetHeight},_=function(){var t=window.jQuery;return t&&!document.body.hasAttribute("data-bs-no-jquery")?t:null},b="rtl"===document.documentElement.dir,y=function(t,e){var n;n=function(){var n=_();if(n){var i=n.fn[t];n.fn[t]=e.jQueryInterface,n.fn[t].Constructor=e,n.fn[t].noConflict=function(){return n.fn[t]=i,e.jQueryInterface}}},"loading"===document.readyState?document.addEventListener("DOMContentLoaded",n):n()},w=(o={},r=1,{set:function(t,e,n){void 0===t.bsKey&&(t.bsKey={key:e,id:r},r++),o[t.bsKey.id]=n},get:function(t,e){if(!t||void 0===t.bsKey)return null;var n=t.bsKey;return n.key===e?o[n.id]:null},delete:function(t,e){if(void 0!==t.bsKey){var n=t.bsKey;n.key===e&&(delete o[n.id],delete t.bsKey)}}}),E=function(t,e,n){w.set(t,e,n)},T=function(t,e){return w.get(t,e)},k=/[^.]*(?=\..*)\.|.*/,A=/\..*/,L=/::\d+$/,O={},D=1,x={mouseenter:"mouseover",mouseleave:"mouseout"},C=new Set(["click","dblclick","mouseup","mousedown","contextmenu","mousewheel","DOMMouseScroll","mouseover","mouseout","mousemove","selectstart","selectend","keydown","keypress","keyup","orientationchange","touchstart","touchmove","touchend","touchcancel","pointerdown","pointermove","pointerup","pointerleave","pointercancel","gesturestart","gesturechange","gestureend","focus","blur","change","reset","select","submit","focusin","focusout","load","unload","beforeunload","resize","move","DOMContentLoaded","readystatechange","error","abort","scroll"]);function S(t,e){return e&&e+"::"+D++||t.uidEvent||D++}function j(t){var e=S(t);return t.uidEvent=e,O[e]=O[e]||{},O[e]}function N(t,e,n){void 0===n&&(n=null);for(var i=Object.keys(t),o=0,r=i.length;o<r;o++){var s=t[i[o]];if(s.originalHandler===e&&s.delegationSelector===n)return s}return null}function P(t,e,n){var i="string"==typeof e,o=i?n:e,r=t.replace(A,""),s=x[r];return s&&(r=s),C.has(r)||(r=t),[i,o,r]}function I(t,e,n,i,o){if("string"==typeof e&&t){n||(n=i,i=null);var r=P(e,n,i),s=r[0],a=r[1],l=r[2],c=j(t),u=c[l]||(c[l]={}),f=N(u,a,s?n:null);if(f)f.oneOff=f.oneOff&&o;else{var d=S(a,e.replace(k,"")),h=s?function(t,e,n){return function i(o){for(var r=t.querySelectorAll(e),s=o.target;s&&s!==this;s=s.parentNode)for(var a=r.length;a--;)if(r[a]===s)return o.delegateTarget=s,i.oneOff&&B.off(t,o.type,n),n.apply(s,[o]);return null}}(t,n,i):function(t,e){return function n(i){return i.delegateTarget=t,n.oneOff&&B.off(t,i.type,e),e.apply(t,[i])}}(t,n);h.delegationSelector=s?n:null,h.originalHandler=a,h.oneOff=o,h.uidEvent=d,u[d]=h,t.addEventListener(l,h,s)}}}function M(t,e,n,i,o){var r=N(e[n],i,o);r&&(t.removeEventListener(n,r,Boolean(o)),delete e[n][r.uidEvent])}var B={on:function(t,e,n,i){I(t,e,n,i,!1)},one:function(t,e,n,i){I(t,e,n,i,!0)},off:function(t,e,n,i){if("string"==typeof e&&t){var o=P(e,n,i),r=o[0],s=o[1],a=o[2],l=a!==e,c=j(t),u=e.startsWith(".");if(void 0===s){u&&Object.keys(c).forEach((function(n){!function(t,e,n,i){var o=e[n]||{};Object.keys(o).forEach((function(r){if(r.includes(i)){var s=o[r];M(t,e,n,s.originalHandler,s.delegationSelector)}}))}(t,c,n,e.slice(1))}));var f=c[a]||{};Object.keys(f).forEach((function(n){var i=n.replace(L,"");if(!l||e.includes(i)){var o=f[n];M(t,c,a,o.originalHandler,o.delegationSelector)}}))}else{if(!c||!c[a])return;M(t,c,a,s,r?n:null)}}},trigger:function(t,e,n){if("string"!=typeof e||!t)return null;var i,o=_(),r=e.replace(A,""),s=e!==r,a=C.has(r),l=!0,c=!0,u=!1,f=null;return s&&o&&(i=o.Event(e,n),o(t).trigger(i),l=!i.isPropagationStopped(),c=!i.isImmediatePropagationStopped(),u=i.isDefaultPrevented()),a?(f=document.createEvent("HTMLEvents")).initEvent(r,l,!0):f=new CustomEvent(e,{bubbles:l,cancelable:!0}),void 0!==n&&Object.keys(n).forEach((function(t){Object.defineProperty(f,t,{get:function(){return n[t]}})})),u&&f.preventDefault(),c&&t.dispatchEvent(f),f.defaultPrevented&&void 0!==i&&i.preventDefault(),f}},H=function(){function t(t){t&&(this._element=t,E(t,this.constructor.DATA_KEY,this))}return t.prototype.dispose=function(){var t,e;t=this._element,e=this.constructor.DATA_KEY,w.delete(t,e),this._element=null},t.getInstance=function(t){return T(t,this.DATA_KEY)},e(t,null,[{key:"VERSION",get:function(){return"5.0.0-beta2"}}]),t}(),R=function(t){function n(){return t.apply(this,arguments)||this}i(n,t);var o=n.prototype;return o.close=function(t){var e=t?this._getRootElement(t):this._element,n=this._triggerCloseEvent(e);null===n||n.defaultPrevented||this._removeElement(e)},o._getRootElement=function(t){return c(t)||t.closest(".alert")},o._triggerCloseEvent=function(t){return B.trigger(t,"close.bs.alert")},o._removeElement=function(t){var e=this;if(t.classList.remove("show"),t.classList.contains("fade")){var n=u(t);B.one(t,"transitionend",(function(){return e._destroyElement(t)})),h(t,n)}else this._destroyElement(t)},o._destroyElement=function(t){t.parentNode&&t.parentNode.removeChild(t),B.trigger(t,"closed.bs.alert")},n.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.alert");e||(e=new n(this)),"close"===t&&e[t](this)}))},n.handleDismiss=function(t){return function(e){e&&e.preventDefault(),t.close(this)}},e(n,null,[{key:"DATA_KEY",get:function(){return"bs.alert"}}]),n}(H);B.on(document,"click.bs.alert.data-api",'[data-bs-dismiss="alert"]',R.handleDismiss(new R)),y("alert",R);var W=function(t){function n(){return t.apply(this,arguments)||this}return i(n,t),n.prototype.toggle=function(){this._element.setAttribute("aria-pressed",this._element.classList.toggle("active"))},n.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.button");e||(e=new n(this)),"toggle"===t&&e[t]()}))},e(n,null,[{key:"DATA_KEY",get:function(){return"bs.button"}}]),n}(H);function K(t){return"true"===t||"false"!==t&&(t===Number(t).toString()?Number(t):""===t||"null"===t?null:t)}function U(t){return t.replace(/[A-Z]/g,(function(t){return"-"+t.toLowerCase()}))}B.on(document,"click.bs.button.data-api",'[data-bs-toggle="button"]',(function(t){t.preventDefault();var e=t.target.closest('[data-bs-toggle="button"]'),n=T(e,"bs.button");n||(n=new W(e)),n.toggle()})),y("button",W);var z={setDataAttribute:function(t,e,n){t.setAttribute("data-bs-"+U(e),n)},removeDataAttribute:function(t,e){t.removeAttribute("data-bs-"+U(e))},getDataAttributes:function(t){if(!t)return{};var e={};return Object.keys(t.dataset).filter((function(t){return t.startsWith("bs")})).forEach((function(n){var i=n.replace(/^bs/,"");i=i.charAt(0).toLowerCase()+i.slice(1,i.length),e[i]=K(t.dataset[n])})),e},getDataAttribute:function(t,e){return K(t.getAttribute("data-bs-"+U(e)))},offset:function(t){var e=t.getBoundingClientRect();return{top:e.top+document.body.scrollTop,left:e.left+document.body.scrollLeft}},position:function(t){return{top:t.offsetTop,left:t.offsetLeft}}},F=function(t,e){var n;return void 0===e&&(e=document.documentElement),(n=[]).concat.apply(n,Element.prototype.querySelectorAll.call(e,t))},Y=function(t,e){return void 0===e&&(e=document.documentElement),Element.prototype.querySelector.call(e,t)},q=function(t,e){var n;return(n=[]).concat.apply(n,t.children).filter((function(t){return t.matches(e)}))},V=function(t,e){for(var n=t.previousElementSibling;n;){if(n.matches(e))return[n];n=n.previousElementSibling}return[]},X={interval:5e3,keyboard:!0,slide:!1,pause:"hover",wrap:!0,touch:!0},Q={interval:"(number|boolean)",keyboard:"boolean",slide:"(boolean|string)",pause:"(string|boolean)",wrap:"boolean",touch:"boolean"},$=function(t){function o(e,n){var i;return(i=t.call(this,e)||this)._items=null,i._interval=null,i._activeElement=null,i._isPaused=!1,i._isSliding=!1,i.touchTimeout=null,i.touchStartX=0,i.touchDeltaX=0,i._config=i._getConfig(n),i._indicatorsElement=Y(".carousel-indicators",i._element),i._touchSupported="ontouchstart"in document.documentElement||navigator.maxTouchPoints>0,i._pointerEvent=Boolean(window.PointerEvent),i._addEventListeners(),i}i(o,t);var r=o.prototype;return r.next=function(){this._isSliding||this._slide("next")},r.nextWhenVisible=function(){!document.hidden&&g(this._element)&&this.next()},r.prev=function(){this._isSliding||this._slide("prev")},r.pause=function(t){t||(this._isPaused=!0),Y(".carousel-item-next, .carousel-item-prev",this._element)&&(f(this._element),this.cycle(!0)),clearInterval(this._interval),this._interval=null},r.cycle=function(t){t||(this._isPaused=!1),this._interval&&(clearInterval(this._interval),this._interval=null),this._config&&this._config.interval&&!this._isPaused&&(this._updateInterval(),this._interval=setInterval((document.visibilityState?this.nextWhenVisible:this.next).bind(this),this._config.interval))},r.to=function(t){var e=this;this._activeElement=Y(".active.carousel-item",this._element);var n=this._getItemIndex(this._activeElement);if(!(t>this._items.length-1||t<0))if(this._isSliding)B.one(this._element,"slid.bs.carousel",(function(){return e.to(t)}));else{if(n===t)return this.pause(),void this.cycle();var i=t>n?"next":"prev";this._slide(i,this._items[t])}},r.dispose=function(){t.prototype.dispose.call(this),B.off(this._element,".bs.carousel"),this._items=null,this._config=null,this._interval=null,this._isPaused=null,this._isSliding=null,this._activeElement=null,this._indicatorsElement=null},r._getConfig=function(t){return t=n({},X,t),p("carousel",t,Q),t},r._handleSwipe=function(){var t=Math.abs(this.touchDeltaX);if(!(t<=40)){var e=t/this.touchDeltaX;this.touchDeltaX=0,e>0&&(b?this.next():this.prev()),e<0&&(b?this.prev():this.next())}},r._addEventListeners=function(){var t=this;this._config.keyboard&&B.on(this._element,"keydown.bs.carousel",(function(e){return t._keydown(e)})),"hover"===this._config.pause&&(B.on(this._element,"mouseenter.bs.carousel",(function(e){return t.pause(e)})),B.on(this._element,"mouseleave.bs.carousel",(function(e){return t.cycle(e)}))),this._config.touch&&this._touchSupported&&this._addTouchEventListeners()},r._addTouchEventListeners=function(){var t=this,e=function(e){!t._pointerEvent||"pen"!==e.pointerType&&"touch"!==e.pointerType?t._pointerEvent||(t.touchStartX=e.touches[0].clientX):t.touchStartX=e.clientX},n=function(e){!t._pointerEvent||"pen"!==e.pointerType&&"touch"!==e.pointerType||(t.touchDeltaX=e.clientX-t.touchStartX),t._handleSwipe(),"hover"===t._config.pause&&(t.pause(),t.touchTimeout&&clearTimeout(t.touchTimeout),t.touchTimeout=setTimeout((function(e){return t.cycle(e)}),500+t._config.interval))};F(".carousel-item img",this._element).forEach((function(t){B.on(t,"dragstart.bs.carousel",(function(t){return t.preventDefault()}))})),this._pointerEvent?(B.on(this._element,"pointerdown.bs.carousel",(function(t){return e(t)})),B.on(this._element,"pointerup.bs.carousel",(function(t){return n(t)})),this._element.classList.add("pointer-event")):(B.on(this._element,"touchstart.bs.carousel",(function(t){return e(t)})),B.on(this._element,"touchmove.bs.carousel",(function(e){return function(e){e.touches&&e.touches.length>1?t.touchDeltaX=0:t.touchDeltaX=e.touches[0].clientX-t.touchStartX}(e)})),B.on(this._element,"touchend.bs.carousel",(function(t){return n(t)})))},r._keydown=function(t){/input|textarea/i.test(t.target.tagName)||("ArrowLeft"===t.key?(t.preventDefault(),b?this.next():this.prev()):"ArrowRight"===t.key&&(t.preventDefault(),b?this.prev():this.next()))},r._getItemIndex=function(t){return this._items=t&&t.parentNode?F(".carousel-item",t.parentNode):[],this._items.indexOf(t)},r._getItemByDirection=function(t,e){var n="next"===t,i="prev"===t,o=this._getItemIndex(e),r=this._items.length-1;if((i&&0===o||n&&o===r)&&!this._config.wrap)return e;var s=(o+("prev"===t?-1:1))%this._items.length;return-1===s?this._items[this._items.length-1]:this._items[s]},r._triggerSlideEvent=function(t,e){var n=this._getItemIndex(t),i=this._getItemIndex(Y(".active.carousel-item",this._element));return B.trigger(this._element,"slide.bs.carousel",{relatedTarget:t,direction:e,from:i,to:n})},r._setActiveIndicatorElement=function(t){if(this._indicatorsElement){var e=Y(".active",this._indicatorsElement);e.classList.remove("active"),e.removeAttribute("aria-current");for(var n=F("[data-bs-target]",this._indicatorsElement),i=0;i<n.length;i++)if(Number.parseInt(n[i].getAttribute("data-bs-slide-to"),10)===this._getItemIndex(t)){n[i].classList.add("active"),n[i].setAttribute("aria-current","true");break}}},r._updateInterval=function(){var t=this._activeElement||Y(".active.carousel-item",this._element);if(t){var e=Number.parseInt(t.getAttribute("data-bs-interval"),10);e?(this._config.defaultInterval=this._config.defaultInterval||this._config.interval,this._config.interval=e):this._config.interval=this._config.defaultInterval||this._config.interval}},r._slide=function(t,e){var n=this,i=Y(".active.carousel-item",this._element),o=this._getItemIndex(i),r=e||i&&this._getItemByDirection(t,i),s=this._getItemIndex(r),a=Boolean(this._interval),l="next"===t?"carousel-item-start":"carousel-item-end",c="next"===t?"carousel-item-next":"carousel-item-prev",f="next"===t?"left":"right";if(r&&r.classList.contains("active"))this._isSliding=!1;else if(!this._triggerSlideEvent(r,f).defaultPrevented&&i&&r){if(this._isSliding=!0,a&&this.pause(),this._setActiveIndicatorElement(r),this._activeElement=r,this._element.classList.contains("slide")){r.classList.add(c),v(r),i.classList.add(l),r.classList.add(l);var d=u(i);B.one(i,"transitionend",(function(){r.classList.remove(l,c),r.classList.add("active"),i.classList.remove("active",c,l),n._isSliding=!1,setTimeout((function(){B.trigger(n._element,"slid.bs.carousel",{relatedTarget:r,direction:f,from:o,to:s})}),0)})),h(i,d)}else i.classList.remove("active"),r.classList.add("active"),this._isSliding=!1,B.trigger(this._element,"slid.bs.carousel",{relatedTarget:r,direction:f,from:o,to:s});a&&this.cycle()}},o.carouselInterface=function(t,e){var i=T(t,"bs.carousel"),r=n({},X,z.getDataAttributes(t));"object"==typeof e&&(r=n({},r,e));var s="string"==typeof e?e:r.slide;if(i||(i=new o(t,r)),"number"==typeof e)i.to(e);else if("string"==typeof s){if(void 0===i[s])throw new TypeError('No method named "'+s+'"');i[s]()}else r.interval&&r.ride&&(i.pause(),i.cycle())},o.jQueryInterface=function(t){return this.each((function(){o.carouselInterface(this,t)}))},o.dataApiClickHandler=function(t){var e=c(this);if(e&&e.classList.contains("carousel")){var i=n({},z.getDataAttributes(e),z.getDataAttributes(this)),r=this.getAttribute("data-bs-slide-to");r&&(i.interval=!1),o.carouselInterface(e,i),r&&T(e,"bs.carousel").to(r),t.preventDefault()}},e(o,null,[{key:"Default",get:function(){return X}},{key:"DATA_KEY",get:function(){return"bs.carousel"}}]),o}(H);B.on(document,"click.bs.carousel.data-api","[data-bs-slide], [data-bs-slide-to]",$.dataApiClickHandler),B.on(window,"load.bs.carousel.data-api",(function(){for(var t=F('[data-bs-ride="carousel"]'),e=0,n=t.length;e<n;e++)$.carouselInterface(t[e],T(t[e],"bs.carousel"))})),y("carousel",$);var G={toggle:!0,parent:""},Z={toggle:"boolean",parent:"(string|element)"},J=function(t){function o(e,n){var i;(i=t.call(this,e)||this)._isTransitioning=!1,i._config=i._getConfig(n),i._triggerArray=F('[data-bs-toggle="collapse"][href="#'+e.id+'"],[data-bs-toggle="collapse"][data-bs-target="#'+e.id+'"]');for(var o=F('[data-bs-toggle="collapse"]'),r=0,s=o.length;r<s;r++){var a=o[r],c=l(a),u=F(c).filter((function(t){return t===e}));null!==c&&u.length&&(i._selector=c,i._triggerArray.push(a))}return i._parent=i._config.parent?i._getParent():null,i._config.parent||i._addAriaAndCollapsedClass(i._element,i._triggerArray),i._config.toggle&&i.toggle(),i}i(o,t);var r=o.prototype;return r.toggle=function(){this._element.classList.contains("show")?this.hide():this.show()},r.show=function(){var t=this;if(!this._isTransitioning&&!this._element.classList.contains("show")){var e,n;this._parent&&0===(e=F(".show, .collapsing",this._parent).filter((function(e){return"string"==typeof t._config.parent?e.getAttribute("data-bs-parent")===t._config.parent:e.classList.contains("collapse")}))).length&&(e=null);var i=Y(this._selector);if(e){var r=e.find((function(t){return i!==t}));if((n=r?T(r,"bs.collapse"):null)&&n._isTransitioning)return}if(!B.trigger(this._element,"show.bs.collapse").defaultPrevented){e&&e.forEach((function(t){i!==t&&o.collapseInterface(t,"hide"),n||E(t,"bs.collapse",null)}));var s=this._getDimension();this._element.classList.remove("collapse"),this._element.classList.add("collapsing"),this._element.style[s]=0,this._triggerArray.length&&this._triggerArray.forEach((function(t){t.classList.remove("collapsed"),t.setAttribute("aria-expanded",!0)})),this.setTransitioning(!0);var a="scroll"+(s[0].toUpperCase()+s.slice(1)),l=u(this._element);B.one(this._element,"transitionend",(function(){t._element.classList.remove("collapsing"),t._element.classList.add("collapse","show"),t._element.style[s]="",t.setTransitioning(!1),B.trigger(t._element,"shown.bs.collapse")})),h(this._element,l),this._element.style[s]=this._element[a]+"px"}}},r.hide=function(){var t=this;if(!this._isTransitioning&&this._element.classList.contains("show")&&!B.trigger(this._element,"hide.bs.collapse").defaultPrevented){var e=this._getDimension();this._element.style[e]=this._element.getBoundingClientRect()[e]+"px",v(this._element),this._element.classList.add("collapsing"),this._element.classList.remove("collapse","show");var n=this._triggerArray.length;if(n>0)for(var i=0;i<n;i++){var o=this._triggerArray[i],r=c(o);r&&!r.classList.contains("show")&&(o.classList.add("collapsed"),o.setAttribute("aria-expanded",!1))}this.setTransitioning(!0),this._element.style[e]="";var s=u(this._element);B.one(this._element,"transitionend",(function(){t.setTransitioning(!1),t._element.classList.remove("collapsing"),t._element.classList.add("collapse"),B.trigger(t._element,"hidden.bs.collapse")})),h(this._element,s)}},r.setTransitioning=function(t){this._isTransitioning=t},r.dispose=function(){t.prototype.dispose.call(this),this._config=null,this._parent=null,this._triggerArray=null,this._isTransitioning=null},r._getConfig=function(t){return(t=n({},G,t)).toggle=Boolean(t.toggle),p("collapse",t,Z),t},r._getDimension=function(){return this._element.classList.contains("width")?"width":"height"},r._getParent=function(){var t=this,e=this._config.parent;return d(e)?void 0===e.jquery&&void 0===e[0]||(e=e[0]):e=Y(e),F('[data-bs-toggle="collapse"][data-bs-parent="'+e+'"]',e).forEach((function(e){var n=c(e);t._addAriaAndCollapsedClass(n,[e])})),e},r._addAriaAndCollapsedClass=function(t,e){if(t&&e.length){var n=t.classList.contains("show");e.forEach((function(t){n?t.classList.remove("collapsed"):t.classList.add("collapsed"),t.setAttribute("aria-expanded",n)}))}},o.collapseInterface=function(t,e){var i=T(t,"bs.collapse"),r=n({},G,z.getDataAttributes(t),"object"==typeof e&&e?e:{});if(!i&&r.toggle&&"string"==typeof e&&/show|hide/.test(e)&&(r.toggle=!1),i||(i=new o(t,r)),"string"==typeof e){if(void 0===i[e])throw new TypeError('No method named "'+e+'"');i[e]()}},o.jQueryInterface=function(t){return this.each((function(){o.collapseInterface(this,t)}))},e(o,null,[{key:"Default",get:function(){return G}},{key:"DATA_KEY",get:function(){return"bs.collapse"}}]),o}(H);B.on(document,"click.bs.collapse.data-api",'[data-bs-toggle="collapse"]',(function(t){("A"===t.target.tagName||t.delegateTarget&&"A"===t.delegateTarget.tagName)&&t.preventDefault();var e=z.getDataAttributes(this),n=l(this);F(n).forEach((function(t){var n,i=T(t,"bs.collapse");i?(null===i._parent&&"string"==typeof e.parent&&(i._config.parent=e.parent,i._parent=i._getParent()),n="toggle"):n=e,J.collapseInterface(t,n)}))})),y("collapse",J);var tt="top",et="bottom",nt="right",it="left",ot=[tt,et,nt,it],rt=ot.reduce((function(t,e){return t.concat([e+"-start",e+"-end"])}),[]),st=[].concat(ot,["auto"]).reduce((function(t,e){return t.concat([e,e+"-start",e+"-end"])}),[]),at=["beforeRead","read","afterRead","beforeMain","main","afterMain","beforeWrite","write","afterWrite"];function lt(t){return t?(t.nodeName||"").toLowerCase():null}function ct(t){if("[object Window]"!==t.toString()){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function ut(t){return t instanceof ct(t).Element||t instanceof Element}function ft(t){return t instanceof ct(t).HTMLElement||t instanceof HTMLElement}var dt={name:"applyStyles",enabled:!0,phase:"write",fn:function(t){var e=t.state;Object.keys(e.elements).forEach((function(t){var n=e.styles[t]||{},i=e.attributes[t]||{},o=e.elements[t];ft(o)&&lt(o)&&(Object.assign(o.style,n),Object.keys(i).forEach((function(t){var e=i[t];!1===e?o.removeAttribute(t):o.setAttribute(t,!0===e?"":e)})))}))},effect:function(t){var e=t.state,n={popper:{position:e.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};return Object.assign(e.elements.popper.style,n.popper),e.elements.arrow&&Object.assign(e.elements.arrow.style,n.arrow),function(){Object.keys(e.elements).forEach((function(t){var i=e.elements[t],o=e.attributes[t]||{},r=Object.keys(e.styles.hasOwnProperty(t)?e.styles[t]:n[t]).reduce((function(t,e){return t[e]="",t}),{});ft(i)&&lt(i)&&(Object.assign(i.style,r),Object.keys(o).forEach((function(t){i.removeAttribute(t)})))}))}},requires:["computeStyles"]};function ht(t){return t.split("-")[0]}function pt(t){return{x:t.offsetLeft,y:t.offsetTop,width:t.offsetWidth,height:t.offsetHeight}}function gt(t,e){var n,i=e.getRootNode&&e.getRootNode();if(t.contains(e))return!0;if(i&&((n=i)instanceof ct(n).ShadowRoot||n instanceof ShadowRoot)){var o=e;do{if(o&&t.isSameNode(o))return!0;o=o.parentNode||o.host}while(o)}return!1}function mt(t){return ct(t).getComputedStyle(t)}function vt(t){return["table","td","th"].indexOf(lt(t))>=0}function _t(t){return((ut(t)?t.ownerDocument:t.document)||window.document).documentElement}function bt(t){return"html"===lt(t)?t:t.assignedSlot||t.parentNode||t.host||_t(t)}function yt(t){if(!ft(t)||"fixed"===mt(t).position)return null;var e=t.offsetParent;if(e){var n=_t(e);if("body"===lt(e)&&"static"===mt(e).position&&"static"!==mt(n).position)return n}return e}function wt(t){for(var e=ct(t),n=yt(t);n&&vt(n)&&"static"===mt(n).position;)n=yt(n);return n&&"body"===lt(n)&&"static"===mt(n).position?e:n||function(t){for(var e=bt(t);ft(e)&&["html","body"].indexOf(lt(e))<0;){var n=mt(e);if("none"!==n.transform||"none"!==n.perspective||n.willChange&&"auto"!==n.willChange)return e;e=e.parentNode}return null}(t)||e}function Et(t){return["top","bottom"].indexOf(t)>=0?"x":"y"}function Tt(t,e,n){return Math.max(t,Math.min(e,n))}function kt(t){return Object.assign(Object.assign({},{top:0,right:0,bottom:0,left:0}),t)}function At(t,e){return e.reduce((function(e,n){return e[n]=t,e}),{})}var Lt={name:"arrow",enabled:!0,phase:"main",fn:function(t){var e,n=t.state,i=t.name,o=n.elements.arrow,r=n.modifiersData.popperOffsets,s=ht(n.placement),a=Et(s),l=[it,nt].indexOf(s)>=0?"height":"width";if(o&&r){var c=n.modifiersData[i+"#persistent"].padding,u=pt(o),f="y"===a?tt:it,d="y"===a?et:nt,h=n.rects.reference[l]+n.rects.reference[a]-r[a]-n.rects.popper[l],p=r[a]-n.rects.reference[a],g=wt(o),m=g?"y"===a?g.clientHeight||0:g.clientWidth||0:0,v=h/2-p/2,_=c[f],b=m-u[l]-c[d],y=m/2-u[l]/2+v,w=Tt(_,y,b),E=a;n.modifiersData[i]=((e={})[E]=w,e.centerOffset=w-y,e)}},effect:function(t){var e=t.state,n=t.options,i=t.name,o=n.element,r=void 0===o?"[data-popper-arrow]":o,s=n.padding,a=void 0===s?0:s;null!=r&&("string"!=typeof r||(r=e.elements.popper.querySelector(r)))&&gt(e.elements.popper,r)&&(e.elements.arrow=r,e.modifiersData[i+"#persistent"]={padding:kt("number"!=typeof a?a:At(a,ot))})},requires:["popperOffsets"],requiresIfExists:["preventOverflow"]},Ot={top:"auto",right:"auto",bottom:"auto",left:"auto"};function Dt(t){var e,n=t.popper,i=t.popperRect,o=t.placement,r=t.offsets,s=t.position,a=t.gpuAcceleration,l=t.adaptive,c=t.roundOffsets?function(t){var e=t.x,n=t.y,i=window.devicePixelRatio||1;return{x:Math.round(e*i)/i||0,y:Math.round(n*i)/i||0}}(r):r,u=c.x,f=void 0===u?0:u,d=c.y,h=void 0===d?0:d,p=r.hasOwnProperty("x"),g=r.hasOwnProperty("y"),m=it,v=tt,_=window;if(l){var b=wt(n);b===ct(n)&&(b=_t(n)),o===tt&&(v=et,h-=b.clientHeight-i.height,h*=a?1:-1),o===it&&(m=nt,f-=b.clientWidth-i.width,f*=a?1:-1)}var y,w=Object.assign({position:s},l&&Ot);return a?Object.assign(Object.assign({},w),{},((y={})[v]=g?"0":"",y[m]=p?"0":"",y.transform=(_.devicePixelRatio||1)<2?"translate("+f+"px, "+h+"px)":"translate3d("+f+"px, "+h+"px, 0)",y)):Object.assign(Object.assign({},w),{},((e={})[v]=g?h+"px":"",e[m]=p?f+"px":"",e.transform="",e))}var xt={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:function(t){var e=t.state,n=t.options,i=n.gpuAcceleration,o=void 0===i||i,r=n.adaptive,s=void 0===r||r,a=n.roundOffsets,l=void 0===a||a,c={placement:ht(e.placement),popper:e.elements.popper,popperRect:e.rects.popper,gpuAcceleration:o};null!=e.modifiersData.popperOffsets&&(e.styles.popper=Object.assign(Object.assign({},e.styles.popper),Dt(Object.assign(Object.assign({},c),{},{offsets:e.modifiersData.popperOffsets,position:e.options.strategy,adaptive:s,roundOffsets:l})))),null!=e.modifiersData.arrow&&(e.styles.arrow=Object.assign(Object.assign({},e.styles.arrow),Dt(Object.assign(Object.assign({},c),{},{offsets:e.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:l})))),e.attributes.popper=Object.assign(Object.assign({},e.attributes.popper),{},{"data-popper-placement":e.placement})},data:{}},Ct={passive:!0},St={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:function(t){var e=t.state,n=t.instance,i=t.options,o=i.scroll,r=void 0===o||o,s=i.resize,a=void 0===s||s,l=ct(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return r&&c.forEach((function(t){t.addEventListener("scroll",n.update,Ct)})),a&&l.addEventListener("resize",n.update,Ct),function(){r&&c.forEach((function(t){t.removeEventListener("scroll",n.update,Ct)})),a&&l.removeEventListener("resize",n.update,Ct)}},data:{}},jt={left:"right",right:"left",bottom:"top",top:"bottom"};function Nt(t){return t.replace(/left|right|bottom|top/g,(function(t){return jt[t]}))}var Pt={start:"end",end:"start"};function It(t){return t.replace(/start|end/g,(function(t){return Pt[t]}))}function Mt(t){var e=t.getBoundingClientRect();return{width:e.width,height:e.height,top:e.top,right:e.right,bottom:e.bottom,left:e.left,x:e.left,y:e.top}}function Bt(t){var e=ct(t);return{scrollLeft:e.pageXOffset,scrollTop:e.pageYOffset}}function Ht(t){return Mt(_t(t)).left+Bt(t).scrollLeft}function Rt(t){var e=mt(t),n=e.overflow,i=e.overflowX,o=e.overflowY;return/auto|scroll|overlay|hidden/.test(n+o+i)}function Wt(t,e){void 0===e&&(e=[]);var n=function t(e){return["html","body","#document"].indexOf(lt(e))>=0?e.ownerDocument.body:ft(e)&&Rt(e)?e:t(bt(e))}(t),i="body"===lt(n),o=ct(n),r=i?[o].concat(o.visualViewport||[],Rt(n)?n:[]):n,s=e.concat(r);return i?s:s.concat(Wt(bt(r)))}function Kt(t){return Object.assign(Object.assign({},t),{},{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function Ut(t,e){return"viewport"===e?Kt(function(t){var e=ct(t),n=_t(t),i=e.visualViewport,o=n.clientWidth,r=n.clientHeight,s=0,a=0;return i&&(o=i.width,r=i.height,/^((?!chrome|android).)*safari/i.test(navigator.userAgent)||(s=i.offsetLeft,a=i.offsetTop)),{width:o,height:r,x:s+Ht(t),y:a}}(t)):ft(e)?function(t){var e=Mt(t);return e.top=e.top+t.clientTop,e.left=e.left+t.clientLeft,e.bottom=e.top+t.clientHeight,e.right=e.left+t.clientWidth,e.width=t.clientWidth,e.height=t.clientHeight,e.x=e.left,e.y=e.top,e}(e):Kt(function(t){var e=_t(t),n=Bt(t),i=t.ownerDocument.body,o=Math.max(e.scrollWidth,e.clientWidth,i?i.scrollWidth:0,i?i.clientWidth:0),r=Math.max(e.scrollHeight,e.clientHeight,i?i.scrollHeight:0,i?i.clientHeight:0),s=-n.scrollLeft+Ht(t),a=-n.scrollTop;return"rtl"===mt(i||e).direction&&(s+=Math.max(e.clientWidth,i?i.clientWidth:0)-o),{width:o,height:r,x:s,y:a}}(_t(t)))}function zt(t){return t.split("-")[1]}function Ft(t){var e,n=t.reference,i=t.element,o=t.placement,r=o?ht(o):null,s=o?zt(o):null,a=n.x+n.width/2-i.width/2,l=n.y+n.height/2-i.height/2;switch(r){case tt:e={x:a,y:n.y-i.height};break;case et:e={x:a,y:n.y+n.height};break;case nt:e={x:n.x+n.width,y:l};break;case it:e={x:n.x-i.width,y:l};break;default:e={x:n.x,y:n.y}}var c=r?Et(r):null;if(null!=c){var u="y"===c?"height":"width";switch(s){case"start":e[c]=e[c]-(n[u]/2-i[u]/2);break;case"end":e[c]=e[c]+(n[u]/2-i[u]/2)}}return e}function Yt(t,e){void 0===e&&(e={});var n=e,i=n.placement,o=void 0===i?t.placement:i,r=n.boundary,s=void 0===r?"clippingParents":r,a=n.rootBoundary,l=void 0===a?"viewport":a,c=n.elementContext,u=void 0===c?"popper":c,f=n.altBoundary,d=void 0!==f&&f,h=n.padding,p=void 0===h?0:h,g=kt("number"!=typeof p?p:At(p,ot)),m="popper"===u?"reference":"popper",v=t.elements.reference,_=t.rects.popper,b=t.elements[d?m:u],y=function(t,e,n){var i="clippingParents"===e?function(t){var e=Wt(bt(t)),n=["absolute","fixed"].indexOf(mt(t).position)>=0&&ft(t)?wt(t):t;return ut(n)?e.filter((function(t){return ut(t)&&gt(t,n)&&"body"!==lt(t)})):[]}(t):[].concat(e),o=[].concat(i,[n]),r=o[0],s=o.reduce((function(e,n){var i=Ut(t,n);return e.top=Math.max(i.top,e.top),e.right=Math.min(i.right,e.right),e.bottom=Math.min(i.bottom,e.bottom),e.left=Math.max(i.left,e.left),e}),Ut(t,r));return s.width=s.right-s.left,s.height=s.bottom-s.top,s.x=s.left,s.y=s.top,s}(ut(b)?b:b.contextElement||_t(t.elements.popper),s,l),w=Mt(v),E=Ft({reference:w,element:_,strategy:"absolute",placement:o}),T=Kt(Object.assign(Object.assign({},_),E)),k="popper"===u?T:w,A={top:y.top-k.top+g.top,bottom:k.bottom-y.bottom+g.bottom,left:y.left-k.left+g.left,right:k.right-y.right+g.right},L=t.modifiersData.offset;if("popper"===u&&L){var O=L[o];Object.keys(A).forEach((function(t){var e=[nt,et].indexOf(t)>=0?1:-1,n=[tt,et].indexOf(t)>=0?"y":"x";A[t]+=O[n]*e}))}return A}function qt(t,e){void 0===e&&(e={});var n=e,i=n.placement,o=n.boundary,r=n.rootBoundary,s=n.padding,a=n.flipVariations,l=n.allowedAutoPlacements,c=void 0===l?st:l,u=zt(i),f=u?a?rt:rt.filter((function(t){return zt(t)===u})):ot,d=f.filter((function(t){return c.indexOf(t)>=0}));0===d.length&&(d=f);var h=d.reduce((function(e,n){return e[n]=Yt(t,{placement:n,boundary:o,rootBoundary:r,padding:s})[ht(n)],e}),{});return Object.keys(h).sort((function(t,e){return h[t]-h[e]}))}var Vt={name:"flip",enabled:!0,phase:"main",fn:function(t){var e=t.state,n=t.options,i=t.name;if(!e.modifiersData[i]._skip){for(var o=n.mainAxis,r=void 0===o||o,s=n.altAxis,a=void 0===s||s,l=n.fallbackPlacements,c=n.padding,u=n.boundary,f=n.rootBoundary,d=n.altBoundary,h=n.flipVariations,p=void 0===h||h,g=n.allowedAutoPlacements,m=e.options.placement,v=ht(m),_=l||(v!==m&&p?function(t){if("auto"===ht(t))return[];var e=Nt(t);return[It(t),e,It(e)]}(m):[Nt(m)]),b=[m].concat(_).reduce((function(t,n){return t.concat("auto"===ht(n)?qt(e,{placement:n,boundary:u,rootBoundary:f,padding:c,flipVariations:p,allowedAutoPlacements:g}):n)}),[]),y=e.rects.reference,w=e.rects.popper,E=new Map,T=!0,k=b[0],A=0;A<b.length;A++){var L=b[A],O=ht(L),D="start"===zt(L),x=[tt,et].indexOf(O)>=0,C=x?"width":"height",S=Yt(e,{placement:L,boundary:u,rootBoundary:f,altBoundary:d,padding:c}),j=x?D?nt:it:D?et:tt;y[C]>w[C]&&(j=Nt(j));var N=Nt(j),P=[];if(r&&P.push(S[O]<=0),a&&P.push(S[j]<=0,S[N]<=0),P.every((function(t){return t}))){k=L,T=!1;break}E.set(L,P)}if(T)for(var I=function(t){var e=b.find((function(e){var n=E.get(e);if(n)return n.slice(0,t).every((function(t){return t}))}));if(e)return k=e,"break"},M=p?3:1;M>0&&"break"!==I(M);M--);e.placement!==k&&(e.modifiersData[i]._skip=!0,e.placement=k,e.reset=!0)}},requiresIfExists:["offset"],data:{_skip:!1}};function Xt(t,e,n){return void 0===n&&(n={x:0,y:0}),{top:t.top-e.height-n.y,right:t.right-e.width+n.x,bottom:t.bottom-e.height+n.y,left:t.left-e.width-n.x}}function Qt(t){return[tt,nt,et,it].some((function(e){return t[e]>=0}))}var $t={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:function(t){var e=t.state,n=t.name,i=e.rects.reference,o=e.rects.popper,r=e.modifiersData.preventOverflow,s=Yt(e,{elementContext:"reference"}),a=Yt(e,{altBoundary:!0}),l=Xt(s,i),c=Xt(a,o,r),u=Qt(l),f=Qt(c);e.modifiersData[n]={referenceClippingOffsets:l,popperEscapeOffsets:c,isReferenceHidden:u,hasPopperEscaped:f},e.attributes.popper=Object.assign(Object.assign({},e.attributes.popper),{},{"data-popper-reference-hidden":u,"data-popper-escaped":f})}},Gt={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:function(t){var e=t.state,n=t.options,i=t.name,o=n.offset,r=void 0===o?[0,0]:o,s=st.reduce((function(t,n){return t[n]=function(t,e,n){var i=ht(t),o=[it,tt].indexOf(i)>=0?-1:1,r="function"==typeof n?n(Object.assign(Object.assign({},e),{},{placement:t})):n,s=r[0],a=r[1];return s=s||0,a=(a||0)*o,[it,nt].indexOf(i)>=0?{x:a,y:s}:{x:s,y:a}}(n,e.rects,r),t}),{}),a=s[e.placement],l=a.x,c=a.y;null!=e.modifiersData.popperOffsets&&(e.modifiersData.popperOffsets.x+=l,e.modifiersData.popperOffsets.y+=c),e.modifiersData[i]=s}},Zt={name:"popperOffsets",enabled:!0,phase:"read",fn:function(t){var e=t.state,n=t.name;e.modifiersData[n]=Ft({reference:e.rects.reference,element:e.rects.popper,strategy:"absolute",placement:e.placement})},data:{}},Jt={name:"preventOverflow",enabled:!0,phase:"main",fn:function(t){var e=t.state,n=t.options,i=t.name,o=n.mainAxis,r=void 0===o||o,s=n.altAxis,a=void 0!==s&&s,l=n.boundary,c=n.rootBoundary,u=n.altBoundary,f=n.padding,d=n.tether,h=void 0===d||d,p=n.tetherOffset,g=void 0===p?0:p,m=Yt(e,{boundary:l,rootBoundary:c,padding:f,altBoundary:u}),v=ht(e.placement),_=zt(e.placement),b=!_,y=Et(v),w="x"===y?"y":"x",E=e.modifiersData.popperOffsets,T=e.rects.reference,k=e.rects.popper,A="function"==typeof g?g(Object.assign(Object.assign({},e.rects),{},{placement:e.placement})):g,L={x:0,y:0};if(E){if(r){var O="y"===y?tt:it,D="y"===y?et:nt,x="y"===y?"height":"width",C=E[y],S=E[y]+m[O],j=E[y]-m[D],N=h?-k[x]/2:0,P="start"===_?T[x]:k[x],I="start"===_?-k[x]:-T[x],M=e.elements.arrow,B=h&&M?pt(M):{width:0,height:0},H=e.modifiersData["arrow#persistent"]?e.modifiersData["arrow#persistent"].padding:{top:0,right:0,bottom:0,left:0},R=H[O],W=H[D],K=Tt(0,T[x],B[x]),U=b?T[x]/2-N-K-R-A:P-K-R-A,z=b?-T[x]/2+N+K+W+A:I+K+W+A,F=e.elements.arrow&&wt(e.elements.arrow),Y=F?"y"===y?F.clientTop||0:F.clientLeft||0:0,q=e.modifiersData.offset?e.modifiersData.offset[e.placement][y]:0,V=E[y]+U-q-Y,X=E[y]+z-q,Q=Tt(h?Math.min(S,V):S,C,h?Math.max(j,X):j);E[y]=Q,L[y]=Q-C}if(a){var $="x"===y?tt:it,G="x"===y?et:nt,Z=E[w],J=Tt(Z+m[$],Z,Z-m[G]);E[w]=J,L[w]=J-Z}e.modifiersData[i]=L}},requiresIfExists:["offset"]};function te(t,e,n){void 0===n&&(n=!1);var i,o,r=_t(e),s=Mt(t),a=ft(e),l={scrollLeft:0,scrollTop:0},c={x:0,y:0};return(a||!a&&!n)&&(("body"!==lt(e)||Rt(r))&&(l=(i=e)!==ct(i)&&ft(i)?{scrollLeft:(o=i).scrollLeft,scrollTop:o.scrollTop}:Bt(i)),ft(e)?((c=Mt(e)).x+=e.clientLeft,c.y+=e.clientTop):r&&(c.x=Ht(r))),{x:s.left+l.scrollLeft-c.x,y:s.top+l.scrollTop-c.y,width:s.width,height:s.height}}var ee={placement:"bottom",modifiers:[],strategy:"absolute"};function ne(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return!e.some((function(t){return!(t&&"function"==typeof t.getBoundingClientRect)}))}function ie(t){void 0===t&&(t={});var e=t,n=e.defaultModifiers,i=void 0===n?[]:n,o=e.defaultOptions,r=void 0===o?ee:o;return function(t,e,n){void 0===n&&(n=r);var o,s,a={placement:"bottom",orderedModifiers:[],options:Object.assign(Object.assign({},ee),r),modifiersData:{},elements:{reference:t,popper:e},attributes:{},styles:{}},l=[],c=!1,u={state:a,setOptions:function(n){f(),a.options=Object.assign(Object.assign(Object.assign({},r),a.options),n),a.scrollParents={reference:ut(t)?Wt(t):t.contextElement?Wt(t.contextElement):[],popper:Wt(e)};var o,s,c=function(t){var e=function(t){var e=new Map,n=new Set,i=[];return t.forEach((function(t){e.set(t.name,t)})),t.forEach((function(t){n.has(t.name)||function t(o){n.add(o.name),[].concat(o.requires||[],o.requiresIfExists||[]).forEach((function(i){if(!n.has(i)){var o=e.get(i);o&&t(o)}})),i.push(o)}(t)})),i}(t);return at.reduce((function(t,n){return t.concat(e.filter((function(t){return t.phase===n})))}),[])}((o=[].concat(i,a.options.modifiers),s=o.reduce((function(t,e){var n=t[e.name];return t[e.name]=n?Object.assign(Object.assign(Object.assign({},n),e),{},{options:Object.assign(Object.assign({},n.options),e.options),data:Object.assign(Object.assign({},n.data),e.data)}):e,t}),{}),Object.keys(s).map((function(t){return s[t]}))));return a.orderedModifiers=c.filter((function(t){return t.enabled})),a.orderedModifiers.forEach((function(t){var e=t.name,n=t.options,i=void 0===n?{}:n,o=t.effect;if("function"==typeof o){var r=o({state:a,name:e,instance:u,options:i});l.push(r||function(){})}})),u.update()},forceUpdate:function(){if(!c){var t=a.elements,e=t.reference,n=t.popper;if(ne(e,n)){a.rects={reference:te(e,wt(n),"fixed"===a.options.strategy),popper:pt(n)},a.reset=!1,a.placement=a.options.placement,a.orderedModifiers.forEach((function(t){return a.modifiersData[t.name]=Object.assign({},t.data)}));for(var i=0;i<a.orderedModifiers.length;i++)if(!0!==a.reset){var o=a.orderedModifiers[i],r=o.fn,s=o.options,l=void 0===s?{}:s,f=o.name;"function"==typeof r&&(a=r({state:a,options:l,name:f,instance:u})||a)}else a.reset=!1,i=-1}}},update:(o=function(){return new Promise((function(t){u.forceUpdate(),t(a)}))},function(){return s||(s=new Promise((function(t){Promise.resolve().then((function(){s=void 0,t(o())}))}))),s}),destroy:function(){f(),c=!0}};if(!ne(t,e))return u;function f(){l.forEach((function(t){return t()})),l=[]}return u.setOptions(n).then((function(t){!c&&n.onFirstUpdate&&n.onFirstUpdate(t)})),u}}var oe=ie(),re=ie({defaultModifiers:[St,Zt,xt,dt]}),se=ie({defaultModifiers:[St,Zt,xt,dt,Gt,Vt,Jt,Lt,$t]}),ae=Object.freeze({__proto__:null,popperGenerator:ie,detectOverflow:Yt,createPopperBase:oe,createPopper:se,createPopperLite:re,top:tt,bottom:et,right:nt,left:it,auto:"auto",basePlacements:ot,start:"start",end:"end",clippingParents:"clippingParents",viewport:"viewport",popper:"popper",reference:"reference",variationPlacements:rt,placements:st,beforeRead:"beforeRead",read:"read",afterRead:"afterRead",beforeMain:"beforeMain",main:"main",afterMain:"afterMain",beforeWrite:"beforeWrite",write:"write",afterWrite:"afterWrite",modifierPhases:at,applyStyles:dt,arrow:Lt,computeStyles:xt,eventListeners:St,flip:Vt,hide:$t,offset:Gt,popperOffsets:Zt,preventOverflow:Jt}),le=new RegExp("ArrowUp|ArrowDown|Escape"),ce=b?"top-end":"top-start",ue=b?"top-start":"top-end",fe=b?"bottom-end":"bottom-start",de=b?"bottom-start":"bottom-end",he=b?"left-start":"right-start",pe=b?"right-start":"left-start",ge={offset:[0,2],flip:!0,boundary:"clippingParents",reference:"toggle",display:"dynamic",popperConfig:null},me={offset:"(array|string|function)",flip:"boolean",boundary:"(string|element)",reference:"(string|element|object)",display:"string",popperConfig:"(null|object|function)"},ve=function(t){function o(e,n){var i;return(i=t.call(this,e)||this)._popper=null,i._config=i._getConfig(n),i._menu=i._getMenuElement(),i._inNavbar=i._detectNavbar(),i._addEventListeners(),i}i(o,t);var r=o.prototype;return r.toggle=function(){if(!this._element.disabled&&!this._element.classList.contains("disabled")){var t=this._element.classList.contains("show");o.clearMenus(),t||this.show()}},r.show=function(){if(!(this._element.disabled||this._element.classList.contains("disabled")||this._menu.classList.contains("show"))){var t=o.getParentFromElement(this._element),e={relatedTarget:this._element};if(!B.trigger(this._element,"show.bs.dropdown",e).defaultPrevented){if(this._inNavbar)z.setDataAttribute(this._menu,"popper","none");else{if(void 0===ae)throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");var n=this._element;"parent"===this._config.reference?n=t:d(this._config.reference)?(n=this._config.reference,void 0!==this._config.reference.jquery&&(n=this._config.reference[0])):"object"==typeof this._config.reference&&(n=this._config.reference);var i=this._getPopperConfig(),r=i.modifiers.find((function(t){return"applyStyles"===t.name&&!1===t.enabled}));this._popper=se(n,this._menu,i),r&&z.setDataAttribute(this._menu,"popper","static")}var s;"ontouchstart"in document.documentElement&&!t.closest(".navbar-nav")&&(s=[]).concat.apply(s,document.body.children).forEach((function(t){return B.on(t,"mouseover",null,(function(){}))})),this._element.focus(),this._element.setAttribute("aria-expanded",!0),this._menu.classList.toggle("show"),this._element.classList.toggle("show"),B.trigger(this._element,"shown.bs.dropdown",e)}}},r.hide=function(){if(!this._element.disabled&&!this._element.classList.contains("disabled")&&this._menu.classList.contains("show")){var t={relatedTarget:this._element};B.trigger(this._element,"hide.bs.dropdown",t).defaultPrevented||(this._popper&&this._popper.destroy(),this._menu.classList.toggle("show"),this._element.classList.toggle("show"),z.removeDataAttribute(this._menu,"popper"),B.trigger(this._element,"hidden.bs.dropdown",t))}},r.dispose=function(){t.prototype.dispose.call(this),B.off(this._element,".bs.dropdown"),this._menu=null,this._popper&&(this._popper.destroy(),this._popper=null)},r.update=function(){this._inNavbar=this._detectNavbar(),this._popper&&this._popper.update()},r._addEventListeners=function(){var t=this;B.on(this._element,"click.bs.dropdown",(function(e){e.preventDefault(),e.stopPropagation(),t.toggle()}))},r._getConfig=function(t){if(t=n({},this.constructor.Default,z.getDataAttributes(this._element),t),p("dropdown",t,this.constructor.DefaultType),"object"==typeof t.reference&&!d(t.reference)&&"function"!=typeof t.reference.getBoundingClientRect)throw new TypeError("dropdown".toUpperCase()+': Option "reference" provided type "object" without a required "getBoundingClientRect" method.');return t},r._getMenuElement=function(){return function(t,e){for(var n=t.nextElementSibling;n;){if(n.matches(e))return[n];n=n.nextElementSibling}return[]}(this._element,".dropdown-menu")[0]},r._getPlacement=function(){var t=this._element.parentNode;if(t.classList.contains("dropend"))return he;if(t.classList.contains("dropstart"))return pe;var e="end"===getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();return t.classList.contains("dropup")?e?ue:ce:e?de:fe},r._detectNavbar=function(){return null!==this._element.closest(".navbar")},r._getOffset=function(){var t=this,e=this._config.offset;return"string"==typeof e?e.split(",").map((function(t){return Number.parseInt(t,10)})):"function"==typeof e?function(n){return e(n,t._element)}:e},r._getPopperConfig=function(){var t={placement:this._getPlacement(),modifiers:[{name:"preventOverflow",options:{altBoundary:this._config.flip,boundary:this._config.boundary}},{name:"offset",options:{offset:this._getOffset()}}]};return"static"===this._config.display&&(t.modifiers=[{name:"applyStyles",enabled:!1}]),n({},t,"function"==typeof this._config.popperConfig?this._config.popperConfig(t):this._config.popperConfig)},o.dropdownInterface=function(t,e){var n=T(t,"bs.dropdown");if(n||(n=new o(t,"object"==typeof e?e:null)),"string"==typeof e){if(void 0===n[e])throw new TypeError('No method named "'+e+'"');n[e]()}},o.jQueryInterface=function(t){return this.each((function(){o.dropdownInterface(this,t)}))},o.clearMenus=function(t){if(!t||2!==t.button&&("keyup"!==t.type||"Tab"===t.key))for(var e=F('[data-bs-toggle="dropdown"]'),n=0,i=e.length;n<i;n++){var o=T(e[n],"bs.dropdown"),r={relatedTarget:e[n]};if(t&&"click"===t.type&&(r.clickEvent=t),o){var s,a=o._menu;if(e[n].classList.contains("show")&&!(t&&("click"===t.type&&/input|textarea/i.test(t.target.tagName)||"keyup"===t.type&&"Tab"===t.key)&&a.contains(t.target)||B.trigger(e[n],"hide.bs.dropdown",r).defaultPrevented))"ontouchstart"in document.documentElement&&(s=[]).concat.apply(s,document.body.children).forEach((function(t){return B.off(t,"mouseover",null,(function(){}))})),e[n].setAttribute("aria-expanded","false"),o._popper&&o._popper.destroy(),a.classList.remove("show"),e[n].classList.remove("show"),z.removeDataAttribute(a,"popper"),B.trigger(e[n],"hidden.bs.dropdown",r)}}},o.getParentFromElement=function(t){return c(t)||t.parentNode},o.dataApiKeydownHandler=function(t){if(!(/input|textarea/i.test(t.target.tagName)?"Space"===t.key||"Escape"!==t.key&&("ArrowDown"!==t.key&&"ArrowUp"!==t.key||t.target.closest(".dropdown-menu")):!le.test(t.key))&&(t.preventDefault(),t.stopPropagation(),!this.disabled&&!this.classList.contains("disabled"))){var e=o.getParentFromElement(this),n=this.classList.contains("show");if("Escape"===t.key)return(this.matches('[data-bs-toggle="dropdown"]')?this:V(this,'[data-bs-toggle="dropdown"]')[0]).focus(),void o.clearMenus();if(n||"ArrowUp"!==t.key&&"ArrowDown"!==t.key)if(n&&"Space"!==t.key){var i=F(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",e).filter(g);if(i.length){var r=i.indexOf(t.target);"ArrowUp"===t.key&&r>0&&r--,"ArrowDown"===t.key&&r<i.length-1&&r++,i[r=-1===r?0:r].focus()}}else o.clearMenus();else(this.matches('[data-bs-toggle="dropdown"]')?this:V(this,'[data-bs-toggle="dropdown"]')[0]).click()}},e(o,null,[{key:"Default",get:function(){return ge}},{key:"DefaultType",get:function(){return me}},{key:"DATA_KEY",get:function(){return"bs.dropdown"}}]),o}(H);B.on(document,"keydown.bs.dropdown.data-api",'[data-bs-toggle="dropdown"]',ve.dataApiKeydownHandler),B.on(document,"keydown.bs.dropdown.data-api",".dropdown-menu",ve.dataApiKeydownHandler),B.on(document,"click.bs.dropdown.data-api",ve.clearMenus),B.on(document,"keyup.bs.dropdown.data-api",ve.clearMenus),B.on(document,"click.bs.dropdown.data-api",'[data-bs-toggle="dropdown"]',(function(t){t.preventDefault(),t.stopPropagation(),ve.dropdownInterface(this,"toggle")})),B.on(document,"click.bs.dropdown.data-api",".dropdown form",(function(t){return t.stopPropagation()})),y("dropdown",ve);var _e={backdrop:!0,keyboard:!0,focus:!0},be={backdrop:"(boolean|string)",keyboard:"boolean",focus:"boolean"},ye=function(t){function o(e,n){var i;return(i=t.call(this,e)||this)._config=i._getConfig(n),i._dialog=Y(".modal-dialog",e),i._backdrop=null,i._isShown=!1,i._isBodyOverflowing=!1,i._ignoreBackdropClick=!1,i._isTransitioning=!1,i._scrollbarWidth=0,i}i(o,t);var r=o.prototype;return r.toggle=function(t){return this._isShown?this.hide():this.show(t)},r.show=function(t){var e=this;if(!this._isShown&&!this._isTransitioning){this._element.classList.contains("fade")&&(this._isTransitioning=!0);var n=B.trigger(this._element,"show.bs.modal",{relatedTarget:t});this._isShown||n.defaultPrevented||(this._isShown=!0,this._checkScrollbar(),this._setScrollbar(),this._adjustDialog(),this._setEscapeEvent(),this._setResizeEvent(),B.on(this._element,"click.dismiss.bs.modal",'[data-bs-dismiss="modal"]',(function(t){return e.hide(t)})),B.on(this._dialog,"mousedown.dismiss.bs.modal",(function(){B.one(e._element,"mouseup.dismiss.bs.modal",(function(t){t.target===e._element&&(e._ignoreBackdropClick=!0)}))})),this._showBackdrop((function(){return e._showElement(t)})))}},r.hide=function(t){var e=this;if(t&&t.preventDefault(),this._isShown&&!this._isTransitioning&&!B.trigger(this._element,"hide.bs.modal").defaultPrevented){this._isShown=!1;var n=this._element.classList.contains("fade");if(n&&(this._isTransitioning=!0),this._setEscapeEvent(),this._setResizeEvent(),B.off(document,"focusin.bs.modal"),this._element.classList.remove("show"),B.off(this._element,"click.dismiss.bs.modal"),B.off(this._dialog,"mousedown.dismiss.bs.modal"),n){var i=u(this._element);B.one(this._element,"transitionend",(function(t){return e._hideModal(t)})),h(this._element,i)}else this._hideModal()}},r.dispose=function(){[window,this._element,this._dialog].forEach((function(t){return B.off(t,".bs.modal")})),t.prototype.dispose.call(this),B.off(document,"focusin.bs.modal"),this._config=null,this._dialog=null,this._backdrop=null,this._isShown=null,this._isBodyOverflowing=null,this._ignoreBackdropClick=null,this._isTransitioning=null,this._scrollbarWidth=null},r.handleUpdate=function(){this._adjustDialog()},r._getConfig=function(t){return t=n({},_e,t),p("modal",t,be),t},r._showElement=function(t){var e=this,n=this._element.classList.contains("fade"),i=Y(".modal-body",this._dialog);this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE||document.body.appendChild(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.scrollTop=0,i&&(i.scrollTop=0),n&&v(this._element),this._element.classList.add("show"),this._config.focus&&this._enforceFocus();var o=function(){e._config.focus&&e._element.focus(),e._isTransitioning=!1,B.trigger(e._element,"shown.bs.modal",{relatedTarget:t})};if(n){var r=u(this._dialog);B.one(this._dialog,"transitionend",o),h(this._dialog,r)}else o()},r._enforceFocus=function(){var t=this;B.off(document,"focusin.bs.modal"),B.on(document,"focusin.bs.modal",(function(e){document===e.target||t._element===e.target||t._element.contains(e.target)||t._element.focus()}))},r._setEscapeEvent=function(){var t=this;this._isShown?B.on(this._element,"keydown.dismiss.bs.modal",(function(e){t._config.keyboard&&"Escape"===e.key?(e.preventDefault(),t.hide()):t._config.keyboard||"Escape"!==e.key||t._triggerBackdropTransition()})):B.off(this._element,"keydown.dismiss.bs.modal")},r._setResizeEvent=function(){var t=this;this._isShown?B.on(window,"resize.bs.modal",(function(){return t._adjustDialog()})):B.off(window,"resize.bs.modal")},r._hideModal=function(){var t=this;this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._isTransitioning=!1,this._showBackdrop((function(){document.body.classList.remove("modal-open"),t._resetAdjustments(),t._resetScrollbar(),B.trigger(t._element,"hidden.bs.modal")}))},r._removeBackdrop=function(){this._backdrop.parentNode.removeChild(this._backdrop),this._backdrop=null},r._showBackdrop=function(t){var e=this,n=this._element.classList.contains("fade")?"fade":"";if(this._isShown&&this._config.backdrop){if(this._backdrop=document.createElement("div"),this._backdrop.className="modal-backdrop",n&&this._backdrop.classList.add(n),document.body.appendChild(this._backdrop),B.on(this._element,"click.dismiss.bs.modal",(function(t){e._ignoreBackdropClick?e._ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"===e._config.backdrop?e._triggerBackdropTransition():e.hide())})),n&&v(this._backdrop),this._backdrop.classList.add("show"),!n)return void t();var i=u(this._backdrop);B.one(this._backdrop,"transitionend",t),h(this._backdrop,i)}else if(!this._isShown&&this._backdrop){this._backdrop.classList.remove("show");var o=function(){e._removeBackdrop(),t()};if(this._element.classList.contains("fade")){var r=u(this._backdrop);B.one(this._backdrop,"transitionend",o),h(this._backdrop,r)}else o()}else t()},r._triggerBackdropTransition=function(){var t=this;if(!B.trigger(this._element,"hidePrevented.bs.modal").defaultPrevented){var e=this._element.scrollHeight>document.documentElement.clientHeight;e||(this._element.style.overflowY="hidden"),this._element.classList.add("modal-static");var n=u(this._dialog);B.off(this._element,"transitionend"),B.one(this._element,"transitionend",(function(){t._element.classList.remove("modal-static"),e||(B.one(t._element,"transitionend",(function(){t._element.style.overflowY=""})),h(t._element,n))})),h(this._element,n),this._element.focus()}},r._adjustDialog=function(){var t=this._element.scrollHeight>document.documentElement.clientHeight;(!this._isBodyOverflowing&&t&&!b||this._isBodyOverflowing&&!t&&b)&&(this._element.style.paddingLeft=this._scrollbarWidth+"px"),(this._isBodyOverflowing&&!t&&!b||!this._isBodyOverflowing&&t&&b)&&(this._element.style.paddingRight=this._scrollbarWidth+"px")},r._resetAdjustments=function(){this._element.style.paddingLeft="",this._element.style.paddingRight=""},r._checkScrollbar=function(){var t=document.body.getBoundingClientRect();this._isBodyOverflowing=Math.round(t.left+t.right)<window.innerWidth,this._scrollbarWidth=this._getScrollbarWidth()},r._setScrollbar=function(){var t=this;this._isBodyOverflowing&&(this._setElementAttributes(".fixed-top, .fixed-bottom, .is-fixed, .sticky-top","paddingRight",(function(e){return e+t._scrollbarWidth})),this._setElementAttributes(".sticky-top","marginRight",(function(e){return e-t._scrollbarWidth})),this._setElementAttributes("body","paddingRight",(function(e){return e+t._scrollbarWidth}))),document.body.classList.add("modal-open")},r._setElementAttributes=function(t,e,n){F(t).forEach((function(t){var i=t.style[e],o=window.getComputedStyle(t)[e];z.setDataAttribute(t,e,i),t.style[e]=n(Number.parseFloat(o))+"px"}))},r._resetScrollbar=function(){this._resetElementAttributes(".fixed-top, .fixed-bottom, .is-fixed, .sticky-top","paddingRight"),this._resetElementAttributes(".sticky-top","marginRight"),this._resetElementAttributes("body","paddingRight")},r._resetElementAttributes=function(t,e){F(t).forEach((function(t){var n=z.getDataAttribute(t,e);void 0===n&&t===document.body?t.style[e]="":(z.removeDataAttribute(t,e),t.style[e]=n)}))},r._getScrollbarWidth=function(){var t=document.createElement("div");t.className="modal-scrollbar-measure",document.body.appendChild(t);var e=t.getBoundingClientRect().width-t.clientWidth;return document.body.removeChild(t),e},o.jQueryInterface=function(t,e){return this.each((function(){var i=T(this,"bs.modal"),r=n({},_e,z.getDataAttributes(this),"object"==typeof t&&t?t:{});if(i||(i=new o(this,r)),"string"==typeof t){if(void 0===i[t])throw new TypeError('No method named "'+t+'"');i[t](e)}}))},e(o,null,[{key:"Default",get:function(){return _e}},{key:"DATA_KEY",get:function(){return"bs.modal"}}]),o}(H);B.on(document,"click.bs.modal.data-api",'[data-bs-toggle="modal"]',(function(t){var e=this,i=c(this);"A"!==this.tagName&&"AREA"!==this.tagName||t.preventDefault(),B.one(i,"show.bs.modal",(function(t){t.defaultPrevented||B.one(i,"hidden.bs.modal",(function(){g(e)&&e.focus()}))}));var o=T(i,"bs.modal");if(!o){var r=n({},z.getDataAttributes(i),z.getDataAttributes(this));o=new ye(i,r)}o.toggle(this)})),y("modal",ye);var we=new Set(["background","cite","href","itemtype","longdesc","poster","src","xlink:href"]),Ee=/^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/gi,Te=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;function ke(t,e,n){var i;if(!t.length)return t;if(n&&"function"==typeof n)return n(t);for(var o=(new window.DOMParser).parseFromString(t,"text/html"),r=Object.keys(e),s=(i=[]).concat.apply(i,o.body.querySelectorAll("*")),a=function(t,n){var i,o=s[t],a=o.nodeName.toLowerCase();if(!r.includes(a))return o.parentNode.removeChild(o),"continue";var l=(i=[]).concat.apply(i,o.attributes),c=[].concat(e["*"]||[],e[a]||[]);l.forEach((function(t){(function(t,e){var n=t.nodeName.toLowerCase();if(e.includes(n))return!we.has(n)||Boolean(Ee.test(t.nodeValue)||Te.test(t.nodeValue));for(var i=e.filter((function(t){return t instanceof RegExp})),o=0,r=i.length;o<r;o++)if(i[o].test(n))return!0;return!1})(t,c)||o.removeAttribute(t.nodeName)}))},l=0,c=s.length;l<c;l++)a(l);return o.body.innerHTML}var Ae=new RegExp("(^|\\s)bs-tooltip\\S+","g"),Le=new Set(["sanitize","allowList","sanitizeFn"]),Oe={animation:"boolean",template:"string",title:"(string|element|function)",trigger:"string",delay:"(number|object)",html:"boolean",selector:"(string|boolean)",placement:"(string|function)",offset:"(array|string|function)",container:"(string|element|boolean)",fallbackPlacements:"array",boundary:"(string|element)",customClass:"(string|function)",sanitize:"boolean",sanitizeFn:"(null|function)",allowList:"object",popperConfig:"(null|object|function)"},De={AUTO:"auto",TOP:"top",RIGHT:b?"left":"right",BOTTOM:"bottom",LEFT:b?"right":"left"},xe={animation:!0,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,selector:!1,placement:"top",offset:[0,0],container:!1,fallbackPlacements:["top","right","bottom","left"],boundary:"clippingParents",customClass:"",sanitize:!0,sanitizeFn:null,allowList:{"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","srcset","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},popperConfig:null},Ce={HIDE:"hide.bs.tooltip",HIDDEN:"hidden.bs.tooltip",SHOW:"show.bs.tooltip",SHOWN:"shown.bs.tooltip",INSERTED:"inserted.bs.tooltip",CLICK:"click.bs.tooltip",FOCUSIN:"focusin.bs.tooltip",FOCUSOUT:"focusout.bs.tooltip",MOUSEENTER:"mouseenter.bs.tooltip",MOUSELEAVE:"mouseleave.bs.tooltip"},Se=function(t){function o(e,n){var i;if(void 0===ae)throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");return(i=t.call(this,e)||this)._isEnabled=!0,i._timeout=0,i._hoverState="",i._activeTrigger={},i._popper=null,i.config=i._getConfig(n),i.tip=null,i._setListeners(),i}i(o,t);var r=o.prototype;return r.enable=function(){this._isEnabled=!0},r.disable=function(){this._isEnabled=!1},r.toggleEnabled=function(){this._isEnabled=!this._isEnabled},r.toggle=function(t){if(this._isEnabled)if(t){var e=this._initializeOnDelegatedTarget(t);e._activeTrigger.click=!e._activeTrigger.click,e._isWithActiveTrigger()?e._enter(null,e):e._leave(null,e)}else{if(this.getTipElement().classList.contains("show"))return void this._leave(null,this);this._enter(null,this)}},r.dispose=function(){clearTimeout(this._timeout),B.off(this._element,this.constructor.EVENT_KEY),B.off(this._element.closest(".modal"),"hide.bs.modal",this._hideModalHandler),this.tip&&this.tip.parentNode&&this.tip.parentNode.removeChild(this.tip),this._isEnabled=null,this._timeout=null,this._hoverState=null,this._activeTrigger=null,this._popper&&this._popper.destroy(),this._popper=null,this.config=null,this.tip=null,t.prototype.dispose.call(this)},r.show=function(){var t=this;if("none"===this._element.style.display)throw new Error("Please use show on visible elements");if(this.isWithContent()&&this._isEnabled){var e=B.trigger(this._element,this.constructor.Event.SHOW),n=function t(e){if(!document.documentElement.attachShadow)return null;if("function"==typeof e.getRootNode){var n=e.getRootNode();return n instanceof ShadowRoot?n:null}return e instanceof ShadowRoot?e:e.parentNode?t(e.parentNode):null}(this._element),i=null===n?this._element.ownerDocument.documentElement.contains(this._element):n.contains(this._element);if(!e.defaultPrevented&&i){var o=this.getTipElement(),r=s(this.constructor.NAME);o.setAttribute("id",r),this._element.setAttribute("aria-describedby",r),this.setContent(),this.config.animation&&o.classList.add("fade");var a="function"==typeof this.config.placement?this.config.placement.call(this,o,this._element):this.config.placement,l=this._getAttachment(a);this._addAttachmentClass(l);var c=this._getContainer();E(o,this.constructor.DATA_KEY,this),this._element.ownerDocument.documentElement.contains(this.tip)||c.appendChild(o),B.trigger(this._element,this.constructor.Event.INSERTED),this._popper=se(this._element,o,this._getPopperConfig(l)),o.classList.add("show");var f,d,p="function"==typeof this.config.customClass?this.config.customClass():this.config.customClass;p&&(f=o.classList).add.apply(f,p.split(" ")),"ontouchstart"in document.documentElement&&(d=[]).concat.apply(d,document.body.children).forEach((function(t){B.on(t,"mouseover",(function(){}))}));var g=function(){var e=t._hoverState;t._hoverState=null,B.trigger(t._element,t.constructor.Event.SHOWN),"out"===e&&t._leave(null,t)};if(this.tip.classList.contains("fade")){var m=u(this.tip);B.one(this.tip,"transitionend",g),h(this.tip,m)}else g()}}},r.hide=function(){var t=this;if(this._popper){var e=this.getTipElement(),n=function(){"show"!==t._hoverState&&e.parentNode&&e.parentNode.removeChild(e),t._cleanTipClass(),t._element.removeAttribute("aria-describedby"),B.trigger(t._element,t.constructor.Event.HIDDEN),t._popper&&(t._popper.destroy(),t._popper=null)};if(!B.trigger(this._element,this.constructor.Event.HIDE).defaultPrevented){var i;if(e.classList.remove("show"),"ontouchstart"in document.documentElement&&(i=[]).concat.apply(i,document.body.children).forEach((function(t){return B.off(t,"mouseover",m)})),this._activeTrigger.click=!1,this._activeTrigger.focus=!1,this._activeTrigger.hover=!1,this.tip.classList.contains("fade")){var o=u(e);B.one(e,"transitionend",n),h(e,o)}else n();this._hoverState=""}}},r.update=function(){null!==this._popper&&this._popper.update()},r.isWithContent=function(){return Boolean(this.getTitle())},r.getTipElement=function(){if(this.tip)return this.tip;var t=document.createElement("div");return t.innerHTML=this.config.template,this.tip=t.children[0],this.tip},r.setContent=function(){var t=this.getTipElement();this.setElementContent(Y(".tooltip-inner",t),this.getTitle()),t.classList.remove("fade","show")},r.setElementContent=function(t,e){if(null!==t)return"object"==typeof e&&d(e)?(e.jquery&&(e=e[0]),void(this.config.html?e.parentNode!==t&&(t.innerHTML="",t.appendChild(e)):t.textContent=e.textContent)):void(this.config.html?(this.config.sanitize&&(e=ke(e,this.config.allowList,this.config.sanitizeFn)),t.innerHTML=e):t.textContent=e)},r.getTitle=function(){var t=this._element.getAttribute("data-bs-original-title");return t||(t="function"==typeof this.config.title?this.config.title.call(this._element):this.config.title),t},r.updateAttachment=function(t){return"right"===t?"end":"left"===t?"start":t},r._initializeOnDelegatedTarget=function(t,e){var n=this.constructor.DATA_KEY;return(e=e||T(t.delegateTarget,n))||(e=new this.constructor(t.delegateTarget,this._getDelegateConfig()),E(t.delegateTarget,n,e)),e},r._getOffset=function(){var t=this,e=this.config.offset;return"string"==typeof e?e.split(",").map((function(t){return Number.parseInt(t,10)})):"function"==typeof e?function(n){return e(n,t._element)}:e},r._getPopperConfig=function(t){var e=this,i={placement:t,modifiers:[{name:"flip",options:{altBoundary:!0,fallbackPlacements:this.config.fallbackPlacements}},{name:"offset",options:{offset:this._getOffset()}},{name:"preventOverflow",options:{boundary:this.config.boundary}},{name:"arrow",options:{element:"."+this.constructor.NAME+"-arrow"}},{name:"onChange",enabled:!0,phase:"afterWrite",fn:function(t){return e._handlePopperPlacementChange(t)}}],onFirstUpdate:function(t){t.options.placement!==t.placement&&e._handlePopperPlacementChange(t)}};return n({},i,"function"==typeof this.config.popperConfig?this.config.popperConfig(i):this.config.popperConfig)},r._addAttachmentClass=function(t){this.getTipElement().classList.add("bs-tooltip-"+this.updateAttachment(t))},r._getContainer=function(){return!1===this.config.container?document.body:d(this.config.container)?this.config.container:Y(this.config.container)},r._getAttachment=function(t){return De[t.toUpperCase()]},r._setListeners=function(){var t=this;this.config.trigger.split(" ").forEach((function(e){if("click"===e)B.on(t._element,t.constructor.Event.CLICK,t.config.selector,(function(e){return t.toggle(e)}));else if("manual"!==e){var n="hover"===e?t.constructor.Event.MOUSEENTER:t.constructor.Event.FOCUSIN,i="hover"===e?t.constructor.Event.MOUSELEAVE:t.constructor.Event.FOCUSOUT;B.on(t._element,n,t.config.selector,(function(e){return t._enter(e)})),B.on(t._element,i,t.config.selector,(function(e){return t._leave(e)}))}})),this._hideModalHandler=function(){t._element&&t.hide()},B.on(this._element.closest(".modal"),"hide.bs.modal",this._hideModalHandler),this.config.selector?this.config=n({},this.config,{trigger:"manual",selector:""}):this._fixTitle()},r._fixTitle=function(){var t=this._element.getAttribute("title"),e=typeof this._element.getAttribute("data-bs-original-title");(t||"string"!==e)&&(this._element.setAttribute("data-bs-original-title",t||""),!t||this._element.getAttribute("aria-label")||this._element.textContent||this._element.setAttribute("aria-label",t),this._element.setAttribute("title",""))},r._enter=function(t,e){e=this._initializeOnDelegatedTarget(t,e),t&&(e._activeTrigger["focusin"===t.type?"focus":"hover"]=!0),e.getTipElement().classList.contains("show")||"show"===e._hoverState?e._hoverState="show":(clearTimeout(e._timeout),e._hoverState="show",e.config.delay&&e.config.delay.show?e._timeout=setTimeout((function(){"show"===e._hoverState&&e.show()}),e.config.delay.show):e.show())},r._leave=function(t,e){e=this._initializeOnDelegatedTarget(t,e),t&&(e._activeTrigger["focusout"===t.type?"focus":"hover"]=!1),e._isWithActiveTrigger()||(clearTimeout(e._timeout),e._hoverState="out",e.config.delay&&e.config.delay.hide?e._timeout=setTimeout((function(){"out"===e._hoverState&&e.hide()}),e.config.delay.hide):e.hide())},r._isWithActiveTrigger=function(){for(var t in this._activeTrigger)if(this._activeTrigger[t])return!0;return!1},r._getConfig=function(t){var e=z.getDataAttributes(this._element);return Object.keys(e).forEach((function(t){Le.has(t)&&delete e[t]})),t&&"object"==typeof t.container&&t.container.jquery&&(t.container=t.container[0]),"number"==typeof(t=n({},this.constructor.Default,e,"object"==typeof t&&t?t:{})).delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),p("tooltip",t,this.constructor.DefaultType),t.sanitize&&(t.template=ke(t.template,t.allowList,t.sanitizeFn)),t},r._getDelegateConfig=function(){var t={};if(this.config)for(var e in this.config)this.constructor.Default[e]!==this.config[e]&&(t[e]=this.config[e]);return t},r._cleanTipClass=function(){var t=this.getTipElement(),e=t.getAttribute("class").match(Ae);null!==e&&e.length>0&&e.map((function(t){return t.trim()})).forEach((function(e){return t.classList.remove(e)}))},r._handlePopperPlacementChange=function(t){var e=t.state;e&&(this.tip=e.elements.popper,this._cleanTipClass(),this._addAttachmentClass(this._getAttachment(e.placement)))},o.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.tooltip"),n="object"==typeof t&&t;if((e||!/dispose|hide/.test(t))&&(e||(e=new o(this,n)),"string"==typeof t)){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},e(o,null,[{key:"Default",get:function(){return xe}},{key:"NAME",get:function(){return"tooltip"}},{key:"DATA_KEY",get:function(){return"bs.tooltip"}},{key:"Event",get:function(){return Ce}},{key:"EVENT_KEY",get:function(){return".bs.tooltip"}},{key:"DefaultType",get:function(){return Oe}}]),o}(H);y("tooltip",Se);var je=new RegExp("(^|\\s)bs-popover\\S+","g"),Ne=n({},Se.Default,{placement:"right",offset:[0,8],trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>'}),Pe=n({},Se.DefaultType,{content:"(string|element|function)"}),Ie={HIDE:"hide.bs.popover",HIDDEN:"hidden.bs.popover",SHOW:"show.bs.popover",SHOWN:"shown.bs.popover",INSERTED:"inserted.bs.popover",CLICK:"click.bs.popover",FOCUSIN:"focusin.bs.popover",FOCUSOUT:"focusout.bs.popover",MOUSEENTER:"mouseenter.bs.popover",MOUSELEAVE:"mouseleave.bs.popover"},Me=function(t){function n(){return t.apply(this,arguments)||this}i(n,t);var o=n.prototype;return o.isWithContent=function(){return this.getTitle()||this._getContent()},o.setContent=function(){var t=this.getTipElement();this.setElementContent(Y(".popover-header",t),this.getTitle());var e=this._getContent();"function"==typeof e&&(e=e.call(this._element)),this.setElementContent(Y(".popover-body",t),e),t.classList.remove("fade","show")},o._addAttachmentClass=function(t){this.getTipElement().classList.add("bs-popover-"+this.updateAttachment(t))},o._getContent=function(){return this._element.getAttribute("data-bs-content")||this.config.content},o._cleanTipClass=function(){var t=this.getTipElement(),e=t.getAttribute("class").match(je);null!==e&&e.length>0&&e.map((function(t){return t.trim()})).forEach((function(e){return t.classList.remove(e)}))},n.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.popover"),i="object"==typeof t?t:null;if((e||!/dispose|hide/.test(t))&&(e||(e=new n(this,i),E(this,"bs.popover",e)),"string"==typeof t)){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},e(n,null,[{key:"Default",get:function(){return Ne}},{key:"NAME",get:function(){return"popover"}},{key:"DATA_KEY",get:function(){return"bs.popover"}},{key:"Event",get:function(){return Ie}},{key:"EVENT_KEY",get:function(){return".bs.popover"}},{key:"DefaultType",get:function(){return Pe}}]),n}(Se);y("popover",Me);var Be={offset:10,method:"auto",target:""},He={offset:"number",method:"string",target:"(string|element)"},Re=function(t){function o(e,n){var i;return(i=t.call(this,e)||this)._scrollElement="BODY"===e.tagName?window:e,i._config=i._getConfig(n),i._selector=i._config.target+" .nav-link, "+i._config.target+" .list-group-item, "+i._config.target+" .dropdown-item",i._offsets=[],i._targets=[],i._activeTarget=null,i._scrollHeight=0,B.on(i._scrollElement,"scroll.bs.scrollspy",(function(){return i._process()})),i.refresh(),i._process(),i}i(o,t);var r=o.prototype;return r.refresh=function(){var t=this,e=this._scrollElement===this._scrollElement.window?"offset":"position",n="auto"===this._config.method?e:this._config.method,i="position"===n?this._getScrollTop():0;this._offsets=[],this._targets=[],this._scrollHeight=this._getScrollHeight(),F(this._selector).map((function(t){var e=l(t),o=e?Y(e):null;if(o){var r=o.getBoundingClientRect();if(r.width||r.height)return[z[n](o).top+i,e]}return null})).filter((function(t){return t})).sort((function(t,e){return t[0]-e[0]})).forEach((function(e){t._offsets.push(e[0]),t._targets.push(e[1])}))},r.dispose=function(){t.prototype.dispose.call(this),B.off(this._scrollElement,".bs.scrollspy"),this._scrollElement=null,this._config=null,this._selector=null,this._offsets=null,this._targets=null,this._activeTarget=null,this._scrollHeight=null},r._getConfig=function(t){if("string"!=typeof(t=n({},Be,"object"==typeof t&&t?t:{})).target&&d(t.target)){var e=t.target.id;e||(e=s("scrollspy"),t.target.id=e),t.target="#"+e}return p("scrollspy",t,He),t},r._getScrollTop=function(){return this._scrollElement===window?this._scrollElement.pageYOffset:this._scrollElement.scrollTop},r._getScrollHeight=function(){return this._scrollElement.scrollHeight||Math.max(document.body.scrollHeight,document.documentElement.scrollHeight)},r._getOffsetHeight=function(){return this._scrollElement===window?window.innerHeight:this._scrollElement.getBoundingClientRect().height},r._process=function(){var t=this._getScrollTop()+this._config.offset,e=this._getScrollHeight(),n=this._config.offset+e-this._getOffsetHeight();if(this._scrollHeight!==e&&this.refresh(),t>=n){var i=this._targets[this._targets.length-1];this._activeTarget!==i&&this._activate(i)}else{if(this._activeTarget&&t<this._offsets[0]&&this._offsets[0]>0)return this._activeTarget=null,void this._clear();for(var o=this._offsets.length;o--;)this._activeTarget!==this._targets[o]&&t>=this._offsets[o]&&(void 0===this._offsets[o+1]||t<this._offsets[o+1])&&this._activate(this._targets[o])}},r._activate=function(t){this._activeTarget=t,this._clear();var e=this._selector.split(",").map((function(e){return e+'[data-bs-target="'+t+'"],'+e+'[href="'+t+'"]'})),n=Y(e.join(","));n.classList.contains("dropdown-item")?(Y(".dropdown-toggle",n.closest(".dropdown")).classList.add("active"),n.classList.add("active")):(n.classList.add("active"),function(t,e){for(var n=[],i=t.parentNode;i&&i.nodeType===Node.ELEMENT_NODE&&3!==i.nodeType;)i.matches(e)&&n.push(i),i=i.parentNode;return n}(n,".nav, .list-group").forEach((function(t){V(t,".nav-link, .list-group-item").forEach((function(t){return t.classList.add("active")})),V(t,".nav-item").forEach((function(t){q(t,".nav-link").forEach((function(t){return t.classList.add("active")}))}))}))),B.trigger(this._scrollElement,"activate.bs.scrollspy",{relatedTarget:t})},r._clear=function(){F(this._selector).filter((function(t){return t.classList.contains("active")})).forEach((function(t){return t.classList.remove("active")}))},o.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.scrollspy");if(e||(e=new o(this,"object"==typeof t&&t)),"string"==typeof t){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},e(o,null,[{key:"Default",get:function(){return Be}},{key:"DATA_KEY",get:function(){return"bs.scrollspy"}}]),o}(H);B.on(window,"load.bs.scrollspy.data-api",(function(){F('[data-bs-spy="scroll"]').forEach((function(t){return new Re(t,z.getDataAttributes(t))}))})),y("scrollspy",Re);var We=function(t){function n(){return t.apply(this,arguments)||this}i(n,t);var o=n.prototype;return o.show=function(){var t=this;if(!(this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE&&this._element.classList.contains("active")||this._element.classList.contains("disabled"))){var e,n=c(this._element),i=this._element.closest(".nav, .list-group");if(i){var o="UL"===i.nodeName||"OL"===i.nodeName?":scope > li > .active":".active";e=(e=F(o,i))[e.length-1]}var r=e?B.trigger(e,"hide.bs.tab",{relatedTarget:this._element}):null;if(!(B.trigger(this._element,"show.bs.tab",{relatedTarget:e}).defaultPrevented||null!==r&&r.defaultPrevented)){this._activate(this._element,i);var s=function(){B.trigger(e,"hidden.bs.tab",{relatedTarget:t._element}),B.trigger(t._element,"shown.bs.tab",{relatedTarget:e})};n?this._activate(n,n.parentNode,s):s()}}},o._activate=function(t,e,n){var i=this,o=(!e||"UL"!==e.nodeName&&"OL"!==e.nodeName?q(e,".active"):F(":scope > li > .active",e))[0],r=n&&o&&o.classList.contains("fade"),s=function(){return i._transitionComplete(t,o,n)};if(o&&r){var a=u(o);o.classList.remove("show"),B.one(o,"transitionend",s),h(o,a)}else s()},o._transitionComplete=function(t,e,n){if(e){e.classList.remove("active");var i=Y(":scope > .dropdown-menu .active",e.parentNode);i&&i.classList.remove("active"),"tab"===e.getAttribute("role")&&e.setAttribute("aria-selected",!1)}t.classList.add("active"),"tab"===t.getAttribute("role")&&t.setAttribute("aria-selected",!0),v(t),t.classList.contains("fade")&&t.classList.add("show"),t.parentNode&&t.parentNode.classList.contains("dropdown-menu")&&(t.closest(".dropdown")&&F(".dropdown-toggle").forEach((function(t){return t.classList.add("active")})),t.setAttribute("aria-expanded",!0)),n&&n()},n.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.tab")||new n(this);if("string"==typeof t){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},e(n,null,[{key:"DATA_KEY",get:function(){return"bs.tab"}}]),n}(H);B.on(document,"click.bs.tab.data-api",'[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',(function(t){t.preventDefault(),(T(this,"bs.tab")||new We(this)).show()})),y("tab",We);var Ke={animation:"boolean",autohide:"boolean",delay:"number"},Ue={animation:!0,autohide:!0,delay:5e3},ze=function(t){function o(e,n){var i;return(i=t.call(this,e)||this)._config=i._getConfig(n),i._timeout=null,i._setListeners(),i}i(o,t);var r=o.prototype;return r.show=function(){var t=this;if(!B.trigger(this._element,"show.bs.toast").defaultPrevented){this._clearTimeout(),this._config.animation&&this._element.classList.add("fade");var e=function(){t._element.classList.remove("showing"),t._element.classList.add("show"),B.trigger(t._element,"shown.bs.toast"),t._config.autohide&&(t._timeout=setTimeout((function(){t.hide()}),t._config.delay))};if(this._element.classList.remove("hide"),v(this._element),this._element.classList.add("showing"),this._config.animation){var n=u(this._element);B.one(this._element,"transitionend",e),h(this._element,n)}else e()}},r.hide=function(){var t=this;if(this._element.classList.contains("show")&&!B.trigger(this._element,"hide.bs.toast").defaultPrevented){var e=function(){t._element.classList.add("hide"),B.trigger(t._element,"hidden.bs.toast")};if(this._element.classList.remove("show"),this._config.animation){var n=u(this._element);B.one(this._element,"transitionend",e),h(this._element,n)}else e()}},r.dispose=function(){this._clearTimeout(),this._element.classList.contains("show")&&this._element.classList.remove("show"),B.off(this._element,"click.dismiss.bs.toast"),t.prototype.dispose.call(this),this._config=null},r._getConfig=function(t){return t=n({},Ue,z.getDataAttributes(this._element),"object"==typeof t&&t?t:{}),p("toast",t,this.constructor.DefaultType),t},r._setListeners=function(){var t=this;B.on(this._element,"click.dismiss.bs.toast",'[data-bs-dismiss="toast"]',(function(){return t.hide()}))},r._clearTimeout=function(){clearTimeout(this._timeout),this._timeout=null},o.jQueryInterface=function(t){return this.each((function(){var e=T(this,"bs.toast");if(e||(e=new o(this,"object"==typeof t&&t)),"string"==typeof t){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t](this)}}))},e(o,null,[{key:"DefaultType",get:function(){return Ke}},{key:"Default",get:function(){return Ue}},{key:"DATA_KEY",get:function(){return"bs.toast"}}]),o}(H);return y("toast",ze),{Alert:R,Button:W,Carousel:$,Collapse:J,Dropdown:ve,Modal:ye,Popover:Me,ScrollSpy:Re,Tab:We,Toast:ze,Tooltip:Se}}));
+//# sourceMappingURL=bootstrap.bundle.min.js.map
\ No newline at end of file
diff --git a/src/main/resources/web/js/echarts.js b/src/main/resources/web/js/echarts.js
new file mode 100644
index 0000000..39b604b
--- /dev/null
+++ b/src/main/resources/web/js/echarts.js
@@ -0,0 +1,90225 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.echarts = {}));
+}(this, (function (exports) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+
+    var Browser = (function () {
+        function Browser() {
+            this.firefox = false;
+            this.ie = false;
+            this.edge = false;
+            this.newEdge = false;
+            this.weChat = false;
+        }
+        return Browser;
+    }());
+    var Env = (function () {
+        function Env() {
+            this.browser = new Browser();
+            this.node = false;
+            this.wxa = false;
+            this.worker = false;
+            this.canvasSupported = false;
+            this.svgSupported = false;
+            this.touchEventsSupported = false;
+            this.pointerEventsSupported = false;
+            this.domSupported = false;
+        }
+        return Env;
+    }());
+    var env = new Env();
+    if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
+        env.wxa = true;
+        env.canvasSupported = true;
+        env.touchEventsSupported = true;
+    }
+    else if (typeof document === 'undefined' && typeof self !== 'undefined') {
+        env.worker = true;
+        env.canvasSupported = true;
+    }
+    else if (typeof navigator === 'undefined') {
+        env.node = true;
+        env.canvasSupported = true;
+        env.svgSupported = true;
+    }
+    else {
+        detect(navigator.userAgent, env);
+    }
+    function detect(ua, env) {
+        var browser = env.browser;
+        var firefox = ua.match(/Firefox\/([\d.]+)/);
+        var ie = ua.match(/MSIE\s([\d.]+)/)
+            || ua.match(/Trident\/.+?rv:(([\d.]+))/);
+        var edge = ua.match(/Edge?\/([\d.]+)/);
+        var weChat = (/micromessenger/i).test(ua);
+        if (firefox) {
+            browser.firefox = true;
+            browser.version = firefox[1];
+        }
+        if (ie) {
+            browser.ie = true;
+            browser.version = ie[1];
+        }
+        if (edge) {
+            browser.edge = true;
+            browser.version = edge[1];
+            browser.newEdge = +edge[1].split('.')[0] > 18;
+        }
+        if (weChat) {
+            browser.weChat = true;
+        }
+        env.canvasSupported = !!document.createElement('canvas').getContext;
+        env.svgSupported = typeof SVGRect !== 'undefined';
+        env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
+        env.pointerEventsSupported = 'onpointerdown' in window
+            && (browser.edge || (browser.ie && +browser.version >= 11));
+        env.domSupported = typeof document !== 'undefined';
+    }
+
+    var BUILTIN_OBJECT = {
+        '[object Function]': true,
+        '[object RegExp]': true,
+        '[object Date]': true,
+        '[object Error]': true,
+        '[object CanvasGradient]': true,
+        '[object CanvasPattern]': true,
+        '[object Image]': true,
+        '[object Canvas]': true
+    };
+    var TYPED_ARRAY = {
+        '[object Int8Array]': true,
+        '[object Uint8Array]': true,
+        '[object Uint8ClampedArray]': true,
+        '[object Int16Array]': true,
+        '[object Uint16Array]': true,
+        '[object Int32Array]': true,
+        '[object Uint32Array]': true,
+        '[object Float32Array]': true,
+        '[object Float64Array]': true
+    };
+    var objToString = Object.prototype.toString;
+    var arrayProto = Array.prototype;
+    var nativeForEach = arrayProto.forEach;
+    var nativeFilter = arrayProto.filter;
+    var nativeSlice = arrayProto.slice;
+    var nativeMap = arrayProto.map;
+    var ctorFunction = function () { }.constructor;
+    var protoFunction = ctorFunction ? ctorFunction.prototype : null;
+    var methods = {};
+    function $override(name, fn) {
+        methods[name] = fn;
+    }
+    var idStart = 0x0907;
+    function guid() {
+        return idStart++;
+    }
+    function logError() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (typeof console !== 'undefined') {
+            console.error.apply(console, args);
+        }
+    }
+    function clone(source) {
+        if (source == null || typeof source !== 'object') {
+            return source;
+        }
+        var result = source;
+        var typeStr = objToString.call(source);
+        if (typeStr === '[object Array]') {
+            if (!isPrimitive(source)) {
+                result = [];
+                for (var i = 0, len = source.length; i < len; i++) {
+                    result[i] = clone(source[i]);
+                }
+            }
+        }
+        else if (TYPED_ARRAY[typeStr]) {
+            if (!isPrimitive(source)) {
+                var Ctor = source.constructor;
+                if (Ctor.from) {
+                    result = Ctor.from(source);
+                }
+                else {
+                    result = new Ctor(source.length);
+                    for (var i = 0, len = source.length; i < len; i++) {
+                        result[i] = clone(source[i]);
+                    }
+                }
+            }
+        }
+        else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
+            result = {};
+            for (var key in source) {
+                if (source.hasOwnProperty(key)) {
+                    result[key] = clone(source[key]);
+                }
+            }
+        }
+        return result;
+    }
+    function merge(target, source, overwrite) {
+        if (!isObject(source) || !isObject(target)) {
+            return overwrite ? clone(source) : target;
+        }
+        for (var key in source) {
+            if (source.hasOwnProperty(key)) {
+                var targetProp = target[key];
+                var sourceProp = source[key];
+                if (isObject(sourceProp)
+                    && isObject(targetProp)
+                    && !isArray(sourceProp)
+                    && !isArray(targetProp)
+                    && !isDom(sourceProp)
+                    && !isDom(targetProp)
+                    && !isBuiltInObject(sourceProp)
+                    && !isBuiltInObject(targetProp)
+                    && !isPrimitive(sourceProp)
+                    && !isPrimitive(targetProp)) {
+                    merge(targetProp, sourceProp, overwrite);
+                }
+                else if (overwrite || !(key in target)) {
+                    target[key] = clone(source[key]);
+                }
+            }
+        }
+        return target;
+    }
+    function mergeAll(targetAndSources, overwrite) {
+        var result = targetAndSources[0];
+        for (var i = 1, len = targetAndSources.length; i < len; i++) {
+            result = merge(result, targetAndSources[i], overwrite);
+        }
+        return result;
+    }
+    function extend(target, source) {
+        if (Object.assign) {
+            Object.assign(target, source);
+        }
+        else {
+            for (var key in source) {
+                if (source.hasOwnProperty(key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    }
+    function defaults(target, source, overlay) {
+        var keysArr = keys(source);
+        for (var i = 0; i < keysArr.length; i++) {
+            var key = keysArr[i];
+            if ((overlay ? source[key] != null : target[key] == null)) {
+                target[key] = source[key];
+            }
+        }
+        return target;
+    }
+    var createCanvas = function () {
+        return methods.createCanvas();
+    };
+    methods.createCanvas = function () {
+        return document.createElement('canvas');
+    };
+    function indexOf(array, value) {
+        if (array) {
+            if (array.indexOf) {
+                return array.indexOf(value);
+            }
+            for (var i = 0, len = array.length; i < len; i++) {
+                if (array[i] === value) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    function inherits(clazz, baseClazz) {
+        var clazzPrototype = clazz.prototype;
+        function F() { }
+        F.prototype = baseClazz.prototype;
+        clazz.prototype = new F();
+        for (var prop in clazzPrototype) {
+            if (clazzPrototype.hasOwnProperty(prop)) {
+                clazz.prototype[prop] = clazzPrototype[prop];
+            }
+        }
+        clazz.prototype.constructor = clazz;
+        clazz.superClass = baseClazz;
+    }
+    function mixin(target, source, override) {
+        target = 'prototype' in target ? target.prototype : target;
+        source = 'prototype' in source ? source.prototype : source;
+        if (Object.getOwnPropertyNames) {
+            var keyList = Object.getOwnPropertyNames(source);
+            for (var i = 0; i < keyList.length; i++) {
+                var key = keyList[i];
+                if (key !== 'constructor') {
+                    if ((override ? source[key] != null : target[key] == null)) {
+                        target[key] = source[key];
+                    }
+                }
+            }
+        }
+        else {
+            defaults(target, source, override);
+        }
+    }
+    function isArrayLike(data) {
+        if (!data) {
+            return false;
+        }
+        if (typeof data === 'string') {
+            return false;
+        }
+        return typeof data.length === 'number';
+    }
+    function each(arr, cb, context) {
+        if (!(arr && cb)) {
+            return;
+        }
+        if (arr.forEach && arr.forEach === nativeForEach) {
+            arr.forEach(cb, context);
+        }
+        else if (arr.length === +arr.length) {
+            for (var i = 0, len = arr.length; i < len; i++) {
+                cb.call(context, arr[i], i, arr);
+            }
+        }
+        else {
+            for (var key in arr) {
+                if (arr.hasOwnProperty(key)) {
+                    cb.call(context, arr[key], key, arr);
+                }
+            }
+        }
+    }
+    function map(arr, cb, context) {
+        if (!arr) {
+            return [];
+        }
+        if (!cb) {
+            return slice(arr);
+        }
+        if (arr.map && arr.map === nativeMap) {
+            return arr.map(cb, context);
+        }
+        else {
+            var result = [];
+            for (var i = 0, len = arr.length; i < len; i++) {
+                result.push(cb.call(context, arr[i], i, arr));
+            }
+            return result;
+        }
+    }
+    function reduce(arr, cb, memo, context) {
+        if (!(arr && cb)) {
+            return;
+        }
+        for (var i = 0, len = arr.length; i < len; i++) {
+            memo = cb.call(context, memo, arr[i], i, arr);
+        }
+        return memo;
+    }
+    function filter(arr, cb, context) {
+        if (!arr) {
+            return [];
+        }
+        if (!cb) {
+            return slice(arr);
+        }
+        if (arr.filter && arr.filter === nativeFilter) {
+            return arr.filter(cb, context);
+        }
+        else {
+            var result = [];
+            for (var i = 0, len = arr.length; i < len; i++) {
+                if (cb.call(context, arr[i], i, arr)) {
+                    result.push(arr[i]);
+                }
+            }
+            return result;
+        }
+    }
+    function find(arr, cb, context) {
+        if (!(arr && cb)) {
+            return;
+        }
+        for (var i = 0, len = arr.length; i < len; i++) {
+            if (cb.call(context, arr[i], i, arr)) {
+                return arr[i];
+            }
+        }
+    }
+    function keys(obj) {
+        if (!obj) {
+            return [];
+        }
+        if (Object.keys) {
+            return Object.keys(obj);
+        }
+        var keyList = [];
+        for (var key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                keyList.push(key);
+            }
+        }
+        return keyList;
+    }
+    function bindPolyfill(func, context) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return function () {
+            return func.apply(context, args.concat(nativeSlice.call(arguments)));
+        };
+    }
+    var bind = (protoFunction && isFunction(protoFunction.bind))
+        ? protoFunction.call.bind(protoFunction.bind)
+        : bindPolyfill;
+    function curry(func) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return function () {
+            return func.apply(this, args.concat(nativeSlice.call(arguments)));
+        };
+    }
+    function isArray(value) {
+        if (Array.isArray) {
+            return Array.isArray(value);
+        }
+        return objToString.call(value) === '[object Array]';
+    }
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+    function isString(value) {
+        return typeof value === 'string';
+    }
+    function isStringSafe(value) {
+        return objToString.call(value) === '[object String]';
+    }
+    function isNumber(value) {
+        return typeof value === 'number';
+    }
+    function isObject(value) {
+        var type = typeof value;
+        return type === 'function' || (!!value && type === 'object');
+    }
+    function isBuiltInObject(value) {
+        return !!BUILTIN_OBJECT[objToString.call(value)];
+    }
+    function isTypedArray(value) {
+        return !!TYPED_ARRAY[objToString.call(value)];
+    }
+    function isDom(value) {
+        return typeof value === 'object'
+            && typeof value.nodeType === 'number'
+            && typeof value.ownerDocument === 'object';
+    }
+    function isGradientObject(value) {
+        return value.colorStops != null;
+    }
+    function isPatternObject(value) {
+        return value.image != null;
+    }
+    function isRegExp(value) {
+        return objToString.call(value) === '[object RegExp]';
+    }
+    function eqNaN(value) {
+        return value !== value;
+    }
+    function retrieve() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        for (var i = 0, len = args.length; i < len; i++) {
+            if (args[i] != null) {
+                return args[i];
+            }
+        }
+    }
+    function retrieve2(value0, value1) {
+        return value0 != null
+            ? value0
+            : value1;
+    }
+    function retrieve3(value0, value1, value2) {
+        return value0 != null
+            ? value0
+            : value1 != null
+                ? value1
+                : value2;
+    }
+    function slice(arr) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return nativeSlice.apply(arr, args);
+    }
+    function normalizeCssArray(val) {
+        if (typeof (val) === 'number') {
+            return [val, val, val, val];
+        }
+        var len = val.length;
+        if (len === 2) {
+            return [val[0], val[1], val[0], val[1]];
+        }
+        else if (len === 3) {
+            return [val[0], val[1], val[2], val[1]];
+        }
+        return val;
+    }
+    function assert(condition, message) {
+        if (!condition) {
+            throw new Error(message);
+        }
+    }
+    function trim(str) {
+        if (str == null) {
+            return null;
+        }
+        else if (typeof str.trim === 'function') {
+            return str.trim();
+        }
+        else {
+            return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+        }
+    }
+    var primitiveKey = '__ec_primitive__';
+    function setAsPrimitive(obj) {
+        obj[primitiveKey] = true;
+    }
+    function isPrimitive(obj) {
+        return obj[primitiveKey];
+    }
+    var HashMap = (function () {
+        function HashMap(obj) {
+            this.data = {};
+            var isArr = isArray(obj);
+            this.data = {};
+            var thisMap = this;
+            (obj instanceof HashMap)
+                ? obj.each(visit)
+                : (obj && each(obj, visit));
+            function visit(value, key) {
+                isArr ? thisMap.set(value, key) : thisMap.set(key, value);
+            }
+        }
+        HashMap.prototype.get = function (key) {
+            return this.data.hasOwnProperty(key) ? this.data[key] : null;
+        };
+        HashMap.prototype.set = function (key, value) {
+            return (this.data[key] = value);
+        };
+        HashMap.prototype.each = function (cb, context) {
+            for (var key in this.data) {
+                if (this.data.hasOwnProperty(key)) {
+                    cb.call(context, this.data[key], key);
+                }
+            }
+        };
+        HashMap.prototype.keys = function () {
+            return keys(this.data);
+        };
+        HashMap.prototype.removeKey = function (key) {
+            delete this.data[key];
+        };
+        return HashMap;
+    }());
+    function createHashMap(obj) {
+        return new HashMap(obj);
+    }
+    function concatArray(a, b) {
+        var newArray = new a.constructor(a.length + b.length);
+        for (var i = 0; i < a.length; i++) {
+            newArray[i] = a[i];
+        }
+        var offset = a.length;
+        for (var i = 0; i < b.length; i++) {
+            newArray[i + offset] = b[i];
+        }
+        return newArray;
+    }
+    function createObject(proto, properties) {
+        var obj;
+        if (Object.create) {
+            obj = Object.create(proto);
+        }
+        else {
+            var StyleCtor = function () { };
+            StyleCtor.prototype = proto;
+            obj = new StyleCtor();
+        }
+        if (properties) {
+            extend(obj, properties);
+        }
+        return obj;
+    }
+    function hasOwn(own, prop) {
+        return own.hasOwnProperty(prop);
+    }
+    function noop() { }
+
+    var util = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        $override: $override,
+        guid: guid,
+        logError: logError,
+        clone: clone,
+        merge: merge,
+        mergeAll: mergeAll,
+        extend: extend,
+        defaults: defaults,
+        createCanvas: createCanvas,
+        indexOf: indexOf,
+        inherits: inherits,
+        mixin: mixin,
+        isArrayLike: isArrayLike,
+        each: each,
+        map: map,
+        reduce: reduce,
+        filter: filter,
+        find: find,
+        keys: keys,
+        bind: bind,
+        curry: curry,
+        isArray: isArray,
+        isFunction: isFunction,
+        isString: isString,
+        isStringSafe: isStringSafe,
+        isNumber: isNumber,
+        isObject: isObject,
+        isBuiltInObject: isBuiltInObject,
+        isTypedArray: isTypedArray,
+        isDom: isDom,
+        isGradientObject: isGradientObject,
+        isPatternObject: isPatternObject,
+        isRegExp: isRegExp,
+        eqNaN: eqNaN,
+        retrieve: retrieve,
+        retrieve2: retrieve2,
+        retrieve3: retrieve3,
+        slice: slice,
+        normalizeCssArray: normalizeCssArray,
+        assert: assert,
+        trim: trim,
+        setAsPrimitive: setAsPrimitive,
+        isPrimitive: isPrimitive,
+        HashMap: HashMap,
+        createHashMap: createHashMap,
+        concatArray: concatArray,
+        createObject: createObject,
+        hasOwn: hasOwn,
+        noop: noop
+    });
+
+    function create(x, y) {
+        if (x == null) {
+            x = 0;
+        }
+        if (y == null) {
+            y = 0;
+        }
+        return [x, y];
+    }
+    function copy(out, v) {
+        out[0] = v[0];
+        out[1] = v[1];
+        return out;
+    }
+    function clone$1(v) {
+        return [v[0], v[1]];
+    }
+    function set(out, a, b) {
+        out[0] = a;
+        out[1] = b;
+        return out;
+    }
+    function add(out, v1, v2) {
+        out[0] = v1[0] + v2[0];
+        out[1] = v1[1] + v2[1];
+        return out;
+    }
+    function scaleAndAdd(out, v1, v2, a) {
+        out[0] = v1[0] + v2[0] * a;
+        out[1] = v1[1] + v2[1] * a;
+        return out;
+    }
+    function sub(out, v1, v2) {
+        out[0] = v1[0] - v2[0];
+        out[1] = v1[1] - v2[1];
+        return out;
+    }
+    function len(v) {
+        return Math.sqrt(lenSquare(v));
+    }
+    var length = len;
+    function lenSquare(v) {
+        return v[0] * v[0] + v[1] * v[1];
+    }
+    var lengthSquare = lenSquare;
+    function mul(out, v1, v2) {
+        out[0] = v1[0] * v2[0];
+        out[1] = v1[1] * v2[1];
+        return out;
+    }
+    function div(out, v1, v2) {
+        out[0] = v1[0] / v2[0];
+        out[1] = v1[1] / v2[1];
+        return out;
+    }
+    function dot(v1, v2) {
+        return v1[0] * v2[0] + v1[1] * v2[1];
+    }
+    function scale(out, v, s) {
+        out[0] = v[0] * s;
+        out[1] = v[1] * s;
+        return out;
+    }
+    function normalize(out, v) {
+        var d = len(v);
+        if (d === 0) {
+            out[0] = 0;
+            out[1] = 0;
+        }
+        else {
+            out[0] = v[0] / d;
+            out[1] = v[1] / d;
+        }
+        return out;
+    }
+    function distance(v1, v2) {
+        return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0])
+            + (v1[1] - v2[1]) * (v1[1] - v2[1]));
+    }
+    var dist = distance;
+    function distanceSquare(v1, v2) {
+        return (v1[0] - v2[0]) * (v1[0] - v2[0])
+            + (v1[1] - v2[1]) * (v1[1] - v2[1]);
+    }
+    var distSquare = distanceSquare;
+    function negate(out, v) {
+        out[0] = -v[0];
+        out[1] = -v[1];
+        return out;
+    }
+    function lerp(out, v1, v2, t) {
+        out[0] = v1[0] + t * (v2[0] - v1[0]);
+        out[1] = v1[1] + t * (v2[1] - v1[1]);
+        return out;
+    }
+    function applyTransform(out, v, m) {
+        var x = v[0];
+        var y = v[1];
+        out[0] = m[0] * x + m[2] * y + m[4];
+        out[1] = m[1] * x + m[3] * y + m[5];
+        return out;
+    }
+    function min(out, v1, v2) {
+        out[0] = Math.min(v1[0], v2[0]);
+        out[1] = Math.min(v1[1], v2[1]);
+        return out;
+    }
+    function max(out, v1, v2) {
+        out[0] = Math.max(v1[0], v2[0]);
+        out[1] = Math.max(v1[1], v2[1]);
+        return out;
+    }
+
+    var vector = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        create: create,
+        copy: copy,
+        clone: clone$1,
+        set: set,
+        add: add,
+        scaleAndAdd: scaleAndAdd,
+        sub: sub,
+        len: len,
+        length: length,
+        lenSquare: lenSquare,
+        lengthSquare: lengthSquare,
+        mul: mul,
+        div: div,
+        dot: dot,
+        scale: scale,
+        normalize: normalize,
+        distance: distance,
+        dist: dist,
+        distanceSquare: distanceSquare,
+        distSquare: distSquare,
+        negate: negate,
+        lerp: lerp,
+        applyTransform: applyTransform,
+        min: min,
+        max: max
+    });
+
+    var Param = (function () {
+        function Param(target, e) {
+            this.target = target;
+            this.topTarget = e && e.topTarget;
+        }
+        return Param;
+    }());
+    var Draggable = (function () {
+        function Draggable(handler) {
+            this.handler = handler;
+            handler.on('mousedown', this._dragStart, this);
+            handler.on('mousemove', this._drag, this);
+            handler.on('mouseup', this._dragEnd, this);
+        }
+        Draggable.prototype._dragStart = function (e) {
+            var draggingTarget = e.target;
+            while (draggingTarget && !draggingTarget.draggable) {
+                draggingTarget = draggingTarget.parent;
+            }
+            if (draggingTarget) {
+                this._draggingTarget = draggingTarget;
+                draggingTarget.dragging = true;
+                this._x = e.offsetX;
+                this._y = e.offsetY;
+                this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event);
+            }
+        };
+        Draggable.prototype._drag = function (e) {
+            var draggingTarget = this._draggingTarget;
+            if (draggingTarget) {
+                var x = e.offsetX;
+                var y = e.offsetY;
+                var dx = x - this._x;
+                var dy = y - this._y;
+                this._x = x;
+                this._y = y;
+                draggingTarget.drift(dx, dy, e);
+                this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event);
+                var dropTarget = this.handler.findHover(x, y, draggingTarget).target;
+                var lastDropTarget = this._dropTarget;
+                this._dropTarget = dropTarget;
+                if (draggingTarget !== dropTarget) {
+                    if (lastDropTarget && dropTarget !== lastDropTarget) {
+                        this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event);
+                    }
+                    if (dropTarget && dropTarget !== lastDropTarget) {
+                        this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event);
+                    }
+                }
+            }
+        };
+        Draggable.prototype._dragEnd = function (e) {
+            var draggingTarget = this._draggingTarget;
+            if (draggingTarget) {
+                draggingTarget.dragging = false;
+            }
+            this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event);
+            if (this._dropTarget) {
+                this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event);
+            }
+            this._draggingTarget = null;
+            this._dropTarget = null;
+        };
+        return Draggable;
+    }());
+
+    var Eventful = (function () {
+        function Eventful(eventProcessors) {
+            if (eventProcessors) {
+                this._$eventProcessor = eventProcessors;
+            }
+        }
+        Eventful.prototype.on = function (event, query, handler, context) {
+            if (!this._$handlers) {
+                this._$handlers = {};
+            }
+            var _h = this._$handlers;
+            if (typeof query === 'function') {
+                context = handler;
+                handler = query;
+                query = null;
+            }
+            if (!handler || !event) {
+                return this;
+            }
+            var eventProcessor = this._$eventProcessor;
+            if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
+                query = eventProcessor.normalizeQuery(query);
+            }
+            if (!_h[event]) {
+                _h[event] = [];
+            }
+            for (var i = 0; i < _h[event].length; i++) {
+                if (_h[event][i].h === handler) {
+                    return this;
+                }
+            }
+            var wrap = {
+                h: handler,
+                query: query,
+                ctx: (context || this),
+                callAtLast: handler.zrEventfulCallAtLast
+            };
+            var lastIndex = _h[event].length - 1;
+            var lastWrap = _h[event][lastIndex];
+            (lastWrap && lastWrap.callAtLast)
+                ? _h[event].splice(lastIndex, 0, wrap)
+                : _h[event].push(wrap);
+            return this;
+        };
+        Eventful.prototype.isSilent = function (eventName) {
+            var _h = this._$handlers;
+            return !_h || !_h[eventName] || !_h[eventName].length;
+        };
+        Eventful.prototype.off = function (eventType, handler) {
+            var _h = this._$handlers;
+            if (!_h) {
+                return this;
+            }
+            if (!eventType) {
+                this._$handlers = {};
+                return this;
+            }
+            if (handler) {
+                if (_h[eventType]) {
+                    var newList = [];
+                    for (var i = 0, l = _h[eventType].length; i < l; i++) {
+                        if (_h[eventType][i].h !== handler) {
+                            newList.push(_h[eventType][i]);
+                        }
+                    }
+                    _h[eventType] = newList;
+                }
+                if (_h[eventType] && _h[eventType].length === 0) {
+                    delete _h[eventType];
+                }
+            }
+            else {
+                delete _h[eventType];
+            }
+            return this;
+        };
+        Eventful.prototype.trigger = function (eventType) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            if (!this._$handlers) {
+                return this;
+            }
+            var _h = this._$handlers[eventType];
+            var eventProcessor = this._$eventProcessor;
+            if (_h) {
+                var argLen = args.length;
+                var len = _h.length;
+                for (var i = 0; i < len; i++) {
+                    var hItem = _h[i];
+                    if (eventProcessor
+                        && eventProcessor.filter
+                        && hItem.query != null
+                        && !eventProcessor.filter(eventType, hItem.query)) {
+                        continue;
+                    }
+                    switch (argLen) {
+                        case 0:
+                            hItem.h.call(hItem.ctx);
+                            break;
+                        case 1:
+                            hItem.h.call(hItem.ctx, args[0]);
+                            break;
+                        case 2:
+                            hItem.h.call(hItem.ctx, args[0], args[1]);
+                            break;
+                        default:
+                            hItem.h.apply(hItem.ctx, args);
+                            break;
+                    }
+                }
+            }
+            eventProcessor && eventProcessor.afterTrigger
+                && eventProcessor.afterTrigger(eventType);
+            return this;
+        };
+        Eventful.prototype.triggerWithContext = function (type) {
+            if (!this._$handlers) {
+                return this;
+            }
+            var _h = this._$handlers[type];
+            var eventProcessor = this._$eventProcessor;
+            if (_h) {
+                var args = arguments;
+                var argLen = args.length;
+                var ctx = args[argLen - 1];
+                var len = _h.length;
+                for (var i = 0; i < len; i++) {
+                    var hItem = _h[i];
+                    if (eventProcessor
+                        && eventProcessor.filter
+                        && hItem.query != null
+                        && !eventProcessor.filter(type, hItem.query)) {
+                        continue;
+                    }
+                    switch (argLen) {
+                        case 0:
+                            hItem.h.call(ctx);
+                            break;
+                        case 1:
+                            hItem.h.call(ctx, args[0]);
+                            break;
+                        case 2:
+                            hItem.h.call(ctx, args[0], args[1]);
+                            break;
+                        default:
+                            hItem.h.apply(ctx, args.slice(1, argLen - 1));
+                            break;
+                    }
+                }
+            }
+            eventProcessor && eventProcessor.afterTrigger
+                && eventProcessor.afterTrigger(type);
+            return this;
+        };
+        return Eventful;
+    }());
+
+    var LN2 = Math.log(2);
+    function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
+        var cacheKey = rowMask + '-' + colMask;
+        var fullRank = rows.length;
+        if (detCache.hasOwnProperty(cacheKey)) {
+            return detCache[cacheKey];
+        }
+        if (rank === 1) {
+            var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2);
+            return rows[rowStart][colStart];
+        }
+        var subRowMask = rowMask | (1 << rowStart);
+        var subRowStart = rowStart + 1;
+        while (rowMask & (1 << subRowStart)) {
+            subRowStart++;
+        }
+        var sum = 0;
+        for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
+            var colTag = 1 << j;
+            if (!(colTag & colMask)) {
+                sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j]
+                    * determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
+                colLocalIdx++;
+            }
+        }
+        detCache[cacheKey] = sum;
+        return sum;
+    }
+    function buildTransformer(src, dest) {
+        var mA = [
+            [src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
+            [0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
+            [src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
+            [0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
+            [src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
+            [0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
+            [src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
+            [0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
+        ];
+        var detCache = {};
+        var det = determinant(mA, 8, 0, 0, 0, detCache);
+        if (det === 0) {
+            return;
+        }
+        var vh = [];
+        for (var i = 0; i < 8; i++) {
+            for (var j = 0; j < 8; j++) {
+                vh[j] == null && (vh[j] = 0);
+                vh[j] += ((i + j) % 2 ? -1 : 1)
+                    * determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache)
+                    / det * dest[i];
+            }
+        }
+        return function (out, srcPointX, srcPointY) {
+            var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
+            out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
+            out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
+        };
+    }
+
+    var EVENT_SAVED_PROP = '___zrEVENTSAVED';
+    var _calcOut = [];
+    function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
+        return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
+            && transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
+    }
+    function transformCoordWithViewport(out, el, inX, inY, inverse) {
+        if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
+            var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
+            var markers = prepareCoordMarkers(el, saved);
+            var transformer = preparePointerTransformer(markers, saved, inverse);
+            if (transformer) {
+                transformer(out, inX, inY);
+                return true;
+            }
+        }
+        return false;
+    }
+    function prepareCoordMarkers(el, saved) {
+        var markers = saved.markers;
+        if (markers) {
+            return markers;
+        }
+        markers = saved.markers = [];
+        var propLR = ['left', 'right'];
+        var propTB = ['top', 'bottom'];
+        for (var i = 0; i < 4; i++) {
+            var marker = document.createElement('div');
+            var stl = marker.style;
+            var idxLR = i % 2;
+            var idxTB = (i >> 1) % 2;
+            stl.cssText = [
+                'position: absolute',
+                'visibility: hidden',
+                'padding: 0',
+                'margin: 0',
+                'border-width: 0',
+                'user-select: none',
+                'width:0',
+                'height:0',
+                propLR[idxLR] + ':0',
+                propTB[idxTB] + ':0',
+                propLR[1 - idxLR] + ':auto',
+                propTB[1 - idxTB] + ':auto',
+                ''
+            ].join('!important;');
+            el.appendChild(marker);
+            markers.push(marker);
+        }
+        return markers;
+    }
+    function preparePointerTransformer(markers, saved, inverse) {
+        var transformerName = inverse ? 'invTrans' : 'trans';
+        var transformer = saved[transformerName];
+        var oldSrcCoords = saved.srcCoords;
+        var srcCoords = [];
+        var destCoords = [];
+        var oldCoordTheSame = true;
+        for (var i = 0; i < 4; i++) {
+            var rect = markers[i].getBoundingClientRect();
+            var ii = 2 * i;
+            var x = rect.left;
+            var y = rect.top;
+            srcCoords.push(x, y);
+            oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
+            destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
+        }
+        return (oldCoordTheSame && transformer)
+            ? transformer
+            : (saved.srcCoords = srcCoords,
+                saved[transformerName] = inverse
+                    ? buildTransformer(destCoords, srcCoords)
+                    : buildTransformer(srcCoords, destCoords));
+    }
+    function isCanvasEl(el) {
+        return el.nodeName.toUpperCase() === 'CANVAS';
+    }
+
+    var isDomLevel2 = (typeof window !== 'undefined') && !!window.addEventListener;
+    var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
+    var _calcOut$1 = [];
+    function clientToLocal(el, e, out, calculate) {
+        out = out || {};
+        if (calculate || !env.canvasSupported) {
+            calculateZrXY(el, e, out);
+        }
+        else if (env.browser.firefox
+            && e.layerX != null
+            && e.layerX !== e.offsetX) {
+            out.zrX = e.layerX;
+            out.zrY = e.layerY;
+        }
+        else if (e.offsetX != null) {
+            out.zrX = e.offsetX;
+            out.zrY = e.offsetY;
+        }
+        else {
+            calculateZrXY(el, e, out);
+        }
+        return out;
+    }
+    function calculateZrXY(el, e, out) {
+        if (env.domSupported && el.getBoundingClientRect) {
+            var ex = e.clientX;
+            var ey = e.clientY;
+            if (isCanvasEl(el)) {
+                var box = el.getBoundingClientRect();
+                out.zrX = ex - box.left;
+                out.zrY = ey - box.top;
+                return;
+            }
+            else {
+                if (transformCoordWithViewport(_calcOut$1, el, ex, ey)) {
+                    out.zrX = _calcOut$1[0];
+                    out.zrY = _calcOut$1[1];
+                    return;
+                }
+            }
+        }
+        out.zrX = out.zrY = 0;
+    }
+    function getNativeEvent(e) {
+        return e
+            || window.event;
+    }
+    function normalizeEvent(el, e, calculate) {
+        e = getNativeEvent(e);
+        if (e.zrX != null) {
+            return e;
+        }
+        var eventType = e.type;
+        var isTouch = eventType && eventType.indexOf('touch') >= 0;
+        if (!isTouch) {
+            clientToLocal(el, e, e, calculate);
+            var wheelDelta = getWheelDeltaMayPolyfill(e);
+            e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
+        }
+        else {
+            var touch = eventType !== 'touchend'
+                ? e.targetTouches[0]
+                : e.changedTouches[0];
+            touch && clientToLocal(el, touch, e, calculate);
+        }
+        var button = e.button;
+        if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) {
+            e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
+        }
+        return e;
+    }
+    function getWheelDeltaMayPolyfill(e) {
+        var rawWheelDelta = e.wheelDelta;
+        if (rawWheelDelta) {
+            return rawWheelDelta;
+        }
+        var deltaX = e.deltaX;
+        var deltaY = e.deltaY;
+        if (deltaX == null || deltaY == null) {
+            return rawWheelDelta;
+        }
+        var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
+        var sign = deltaY > 0 ? -1
+            : deltaY < 0 ? 1
+                : deltaX > 0 ? -1
+                    : 1;
+        return 3 * delta * sign;
+    }
+    function addEventListener(el, name, handler, opt) {
+        if (isDomLevel2) {
+            el.addEventListener(name, handler, opt);
+        }
+        else {
+            el.attachEvent('on' + name, handler);
+        }
+    }
+    function removeEventListener(el, name, handler, opt) {
+        if (isDomLevel2) {
+            el.removeEventListener(name, handler, opt);
+        }
+        else {
+            el.detachEvent('on' + name, handler);
+        }
+    }
+    var stop = isDomLevel2
+        ? function (e) {
+            e.preventDefault();
+            e.stopPropagation();
+            e.cancelBubble = true;
+        }
+        : function (e) {
+            e.returnValue = false;
+            e.cancelBubble = true;
+        };
+    function isMiddleOrRightButtonOnMouseUpDown(e) {
+        return e.which === 2 || e.which === 3;
+    }
+
+    var GestureMgr = (function () {
+        function GestureMgr() {
+            this._track = [];
+        }
+        GestureMgr.prototype.recognize = function (event, target, root) {
+            this._doTrack(event, target, root);
+            return this._recognize(event);
+        };
+        GestureMgr.prototype.clear = function () {
+            this._track.length = 0;
+            return this;
+        };
+        GestureMgr.prototype._doTrack = function (event, target, root) {
+            var touches = event.touches;
+            if (!touches) {
+                return;
+            }
+            var trackItem = {
+                points: [],
+                touches: [],
+                target: target,
+                event: event
+            };
+            for (var i = 0, len = touches.length; i < len; i++) {
+                var touch = touches[i];
+                var pos = clientToLocal(root, touch, {});
+                trackItem.points.push([pos.zrX, pos.zrY]);
+                trackItem.touches.push(touch);
+            }
+            this._track.push(trackItem);
+        };
+        GestureMgr.prototype._recognize = function (event) {
+            for (var eventName in recognizers) {
+                if (recognizers.hasOwnProperty(eventName)) {
+                    var gestureInfo = recognizers[eventName](this._track, event);
+                    if (gestureInfo) {
+                        return gestureInfo;
+                    }
+                }
+            }
+        };
+        return GestureMgr;
+    }());
+    function dist$1(pointPair) {
+        var dx = pointPair[1][0] - pointPair[0][0];
+        var dy = pointPair[1][1] - pointPair[0][1];
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    function center(pointPair) {
+        return [
+            (pointPair[0][0] + pointPair[1][0]) / 2,
+            (pointPair[0][1] + pointPair[1][1]) / 2
+        ];
+    }
+    var recognizers = {
+        pinch: function (tracks, event) {
+            var trackLen = tracks.length;
+            if (!trackLen) {
+                return;
+            }
+            var pinchEnd = (tracks[trackLen - 1] || {}).points;
+            var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
+            if (pinchPre
+                && pinchPre.length > 1
+                && pinchEnd
+                && pinchEnd.length > 1) {
+                var pinchScale = dist$1(pinchEnd) / dist$1(pinchPre);
+                !isFinite(pinchScale) && (pinchScale = 1);
+                event.pinchScale = pinchScale;
+                var pinchCenter = center(pinchEnd);
+                event.pinchX = pinchCenter[0];
+                event.pinchY = pinchCenter[1];
+                return {
+                    type: 'pinch',
+                    target: tracks[0].target,
+                    event: event
+                };
+            }
+        }
+    };
+
+    var SILENT = 'silent';
+    function makeEventPacket(eveType, targetInfo, event) {
+        return {
+            type: eveType,
+            event: event,
+            target: targetInfo.target,
+            topTarget: targetInfo.topTarget,
+            cancelBubble: false,
+            offsetX: event.zrX,
+            offsetY: event.zrY,
+            gestureEvent: event.gestureEvent,
+            pinchX: event.pinchX,
+            pinchY: event.pinchY,
+            pinchScale: event.pinchScale,
+            wheelDelta: event.zrDelta,
+            zrByTouch: event.zrByTouch,
+            which: event.which,
+            stop: stopEvent
+        };
+    }
+    function stopEvent() {
+        stop(this.event);
+    }
+    var EmptyProxy = (function (_super) {
+        __extends(EmptyProxy, _super);
+        function EmptyProxy() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.handler = null;
+            return _this;
+        }
+        EmptyProxy.prototype.dispose = function () { };
+        EmptyProxy.prototype.setCursor = function () { };
+        return EmptyProxy;
+    }(Eventful));
+    var HoveredResult = (function () {
+        function HoveredResult(x, y) {
+            this.x = x;
+            this.y = y;
+        }
+        return HoveredResult;
+    }());
+    var handlerNames = [
+        'click', 'dblclick', 'mousewheel', 'mouseout',
+        'mouseup', 'mousedown', 'mousemove', 'contextmenu'
+    ];
+    var Handler = (function (_super) {
+        __extends(Handler, _super);
+        function Handler(storage, painter, proxy, painterRoot) {
+            var _this = _super.call(this) || this;
+            _this._hovered = new HoveredResult(0, 0);
+            _this.storage = storage;
+            _this.painter = painter;
+            _this.painterRoot = painterRoot;
+            proxy = proxy || new EmptyProxy();
+            _this.proxy = null;
+            _this.setHandlerProxy(proxy);
+            _this._draggingMgr = new Draggable(_this);
+            return _this;
+        }
+        Handler.prototype.setHandlerProxy = function (proxy) {
+            if (this.proxy) {
+                this.proxy.dispose();
+            }
+            if (proxy) {
+                each(handlerNames, function (name) {
+                    proxy.on && proxy.on(name, this[name], this);
+                }, this);
+                proxy.handler = this;
+            }
+            this.proxy = proxy;
+        };
+        Handler.prototype.mousemove = function (event) {
+            var x = event.zrX;
+            var y = event.zrY;
+            var isOutside = isOutsideBoundary(this, x, y);
+            var lastHovered = this._hovered;
+            var lastHoveredTarget = lastHovered.target;
+            if (lastHoveredTarget && !lastHoveredTarget.__zr) {
+                lastHovered = this.findHover(lastHovered.x, lastHovered.y);
+                lastHoveredTarget = lastHovered.target;
+            }
+            var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y);
+            var hoveredTarget = hovered.target;
+            var proxy = this.proxy;
+            proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : 'default');
+            if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) {
+                this.dispatchToElement(lastHovered, 'mouseout', event);
+            }
+            this.dispatchToElement(hovered, 'mousemove', event);
+            if (hoveredTarget && hoveredTarget !== lastHoveredTarget) {
+                this.dispatchToElement(hovered, 'mouseover', event);
+            }
+        };
+        Handler.prototype.mouseout = function (event) {
+            var eventControl = event.zrEventControl;
+            if (eventControl !== 'only_globalout') {
+                this.dispatchToElement(this._hovered, 'mouseout', event);
+            }
+            if (eventControl !== 'no_globalout') {
+                this.trigger('globalout', { type: 'globalout', event: event });
+            }
+        };
+        Handler.prototype.resize = function () {
+            this._hovered = new HoveredResult(0, 0);
+        };
+        Handler.prototype.dispatch = function (eventName, eventArgs) {
+            var handler = this[eventName];
+            handler && handler.call(this, eventArgs);
+        };
+        Handler.prototype.dispose = function () {
+            this.proxy.dispose();
+            this.storage = null;
+            this.proxy = null;
+            this.painter = null;
+        };
+        Handler.prototype.setCursorStyle = function (cursorStyle) {
+            var proxy = this.proxy;
+            proxy.setCursor && proxy.setCursor(cursorStyle);
+        };
+        Handler.prototype.dispatchToElement = function (targetInfo, eventName, event) {
+            targetInfo = targetInfo || {};
+            var el = targetInfo.target;
+            if (el && el.silent) {
+                return;
+            }
+            var eventKey = ('on' + eventName);
+            var eventPacket = makeEventPacket(eventName, targetInfo, event);
+            while (el) {
+                el[eventKey]
+                    && (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket));
+                el.trigger(eventName, eventPacket);
+                el = el.__hostTarget ? el.__hostTarget : el.parent;
+                if (eventPacket.cancelBubble) {
+                    break;
+                }
+            }
+            if (!eventPacket.cancelBubble) {
+                this.trigger(eventName, eventPacket);
+                if (this.painter && this.painter.eachOtherLayer) {
+                    this.painter.eachOtherLayer(function (layer) {
+                        if (typeof (layer[eventKey]) === 'function') {
+                            layer[eventKey].call(layer, eventPacket);
+                        }
+                        if (layer.trigger) {
+                            layer.trigger(eventName, eventPacket);
+                        }
+                    });
+                }
+            }
+        };
+        Handler.prototype.findHover = function (x, y, exclude) {
+            var list = this.storage.getDisplayList();
+            var out = new HoveredResult(x, y);
+            for (var i = list.length - 1; i >= 0; i--) {
+                var hoverCheckResult = void 0;
+                if (list[i] !== exclude
+                    && !list[i].ignore
+                    && (hoverCheckResult = isHover(list[i], x, y))) {
+                    !out.topTarget && (out.topTarget = list[i]);
+                    if (hoverCheckResult !== SILENT) {
+                        out.target = list[i];
+                        break;
+                    }
+                }
+            }
+            return out;
+        };
+        Handler.prototype.processGesture = function (event, stage) {
+            if (!this._gestureMgr) {
+                this._gestureMgr = new GestureMgr();
+            }
+            var gestureMgr = this._gestureMgr;
+            stage === 'start' && gestureMgr.clear();
+            var gestureInfo = gestureMgr.recognize(event, this.findHover(event.zrX, event.zrY, null).target, this.proxy.dom);
+            stage === 'end' && gestureMgr.clear();
+            if (gestureInfo) {
+                var type = gestureInfo.type;
+                event.gestureEvent = type;
+                var res = new HoveredResult();
+                res.target = gestureInfo.target;
+                this.dispatchToElement(res, type, gestureInfo.event);
+            }
+        };
+        return Handler;
+    }(Eventful));
+    each(['click', 'mousedown', 'mouseup', 'mousewheel', 'dblclick', 'contextmenu'], function (name) {
+        Handler.prototype[name] = function (event) {
+            var x = event.zrX;
+            var y = event.zrY;
+            var isOutside = isOutsideBoundary(this, x, y);
+            var hovered;
+            var hoveredTarget;
+            if (name !== 'mouseup' || !isOutside) {
+                hovered = this.findHover(x, y);
+                hoveredTarget = hovered.target;
+            }
+            if (name === 'mousedown') {
+                this._downEl = hoveredTarget;
+                this._downPoint = [event.zrX, event.zrY];
+                this._upEl = hoveredTarget;
+            }
+            else if (name === 'mouseup') {
+                this._upEl = hoveredTarget;
+            }
+            else if (name === 'click') {
+                if (this._downEl !== this._upEl
+                    || !this._downPoint
+                    || dist(this._downPoint, [event.zrX, event.zrY]) > 4) {
+                    return;
+                }
+                this._downPoint = null;
+            }
+            this.dispatchToElement(hovered, name, event);
+        };
+    });
+    function isHover(displayable, x, y) {
+        if (displayable[displayable.rectHover ? 'rectContain' : 'contain'](x, y)) {
+            var el = displayable;
+            var isSilent = void 0;
+            var ignoreClip = false;
+            while (el) {
+                if (el.ignoreClip) {
+                    ignoreClip = true;
+                }
+                if (!ignoreClip) {
+                    var clipPath = el.getClipPath();
+                    if (clipPath && !clipPath.contain(x, y)) {
+                        return false;
+                    }
+                    if (el.silent) {
+                        isSilent = true;
+                    }
+                }
+                var hostEl = el.__hostTarget;
+                el = hostEl ? hostEl : el.parent;
+            }
+            return isSilent ? SILENT : true;
+        }
+        return false;
+    }
+    function isOutsideBoundary(handlerInstance, x, y) {
+        var painter = handlerInstance.painter;
+        return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight();
+    }
+
+    function create$1() {
+        return [1, 0, 0, 1, 0, 0];
+    }
+    function identity(out) {
+        out[0] = 1;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 1;
+        out[4] = 0;
+        out[5] = 0;
+        return out;
+    }
+    function copy$1(out, m) {
+        out[0] = m[0];
+        out[1] = m[1];
+        out[2] = m[2];
+        out[3] = m[3];
+        out[4] = m[4];
+        out[5] = m[5];
+        return out;
+    }
+    function mul$1(out, m1, m2) {
+        var out0 = m1[0] * m2[0] + m1[2] * m2[1];
+        var out1 = m1[1] * m2[0] + m1[3] * m2[1];
+        var out2 = m1[0] * m2[2] + m1[2] * m2[3];
+        var out3 = m1[1] * m2[2] + m1[3] * m2[3];
+        var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];
+        var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];
+        out[0] = out0;
+        out[1] = out1;
+        out[2] = out2;
+        out[3] = out3;
+        out[4] = out4;
+        out[5] = out5;
+        return out;
+    }
+    function translate(out, a, v) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+        out[4] = a[4] + v[0];
+        out[5] = a[5] + v[1];
+        return out;
+    }
+    function rotate(out, a, rad) {
+        var aa = a[0];
+        var ac = a[2];
+        var atx = a[4];
+        var ab = a[1];
+        var ad = a[3];
+        var aty = a[5];
+        var st = Math.sin(rad);
+        var ct = Math.cos(rad);
+        out[0] = aa * ct + ab * st;
+        out[1] = -aa * st + ab * ct;
+        out[2] = ac * ct + ad * st;
+        out[3] = -ac * st + ct * ad;
+        out[4] = ct * atx + st * aty;
+        out[5] = ct * aty - st * atx;
+        return out;
+    }
+    function scale$1(out, a, v) {
+        var vx = v[0];
+        var vy = v[1];
+        out[0] = a[0] * vx;
+        out[1] = a[1] * vy;
+        out[2] = a[2] * vx;
+        out[3] = a[3] * vy;
+        out[4] = a[4] * vx;
+        out[5] = a[5] * vy;
+        return out;
+    }
+    function invert(out, a) {
+        var aa = a[0];
+        var ac = a[2];
+        var atx = a[4];
+        var ab = a[1];
+        var ad = a[3];
+        var aty = a[5];
+        var det = aa * ad - ab * ac;
+        if (!det) {
+            return null;
+        }
+        det = 1.0 / det;
+        out[0] = ad * det;
+        out[1] = -ab * det;
+        out[2] = -ac * det;
+        out[3] = aa * det;
+        out[4] = (ac * aty - ad * atx) * det;
+        out[5] = (ab * atx - aa * aty) * det;
+        return out;
+    }
+    function clone$2(a) {
+        var b = create$1();
+        copy$1(b, a);
+        return b;
+    }
+
+    var matrix = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        create: create$1,
+        identity: identity,
+        copy: copy$1,
+        mul: mul$1,
+        translate: translate,
+        rotate: rotate,
+        scale: scale$1,
+        invert: invert,
+        clone: clone$2
+    });
+
+    var mIdentity = identity;
+    var EPSILON = 5e-5;
+    function isNotAroundZero(val) {
+        return val > EPSILON || val < -EPSILON;
+    }
+    var scaleTmp = [];
+    var tmpTransform = [];
+    var originTransform = create$1();
+    var abs = Math.abs;
+    var Transformable = (function () {
+        function Transformable() {
+        }
+        Transformable.prototype.setPosition = function (arr) {
+            this.x = arr[0];
+            this.y = arr[1];
+        };
+        Transformable.prototype.setScale = function (arr) {
+            this.scaleX = arr[0];
+            this.scaleY = arr[1];
+        };
+        Transformable.prototype.setOrigin = function (arr) {
+            this.originX = arr[0];
+            this.originY = arr[1];
+        };
+        Transformable.prototype.needLocalTransform = function () {
+            return isNotAroundZero(this.rotation)
+                || isNotAroundZero(this.x)
+                || isNotAroundZero(this.y)
+                || isNotAroundZero(this.scaleX - 1)
+                || isNotAroundZero(this.scaleY - 1);
+        };
+        Transformable.prototype.updateTransform = function () {
+            var parent = this.parent;
+            var parentHasTransform = parent && parent.transform;
+            var needLocalTransform = this.needLocalTransform();
+            var m = this.transform;
+            if (!(needLocalTransform || parentHasTransform)) {
+                m && mIdentity(m);
+                return;
+            }
+            m = m || create$1();
+            if (needLocalTransform) {
+                this.getLocalTransform(m);
+            }
+            else {
+                mIdentity(m);
+            }
+            if (parentHasTransform) {
+                if (needLocalTransform) {
+                    mul$1(m, parent.transform, m);
+                }
+                else {
+                    copy$1(m, parent.transform);
+                }
+            }
+            this.transform = m;
+            this._resolveGlobalScaleRatio(m);
+        };
+        Transformable.prototype._resolveGlobalScaleRatio = function (m) {
+            var globalScaleRatio = this.globalScaleRatio;
+            if (globalScaleRatio != null && globalScaleRatio !== 1) {
+                this.getGlobalScale(scaleTmp);
+                var relX = scaleTmp[0] < 0 ? -1 : 1;
+                var relY = scaleTmp[1] < 0 ? -1 : 1;
+                var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
+                var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
+                m[0] *= sx;
+                m[1] *= sx;
+                m[2] *= sy;
+                m[3] *= sy;
+            }
+            this.invTransform = this.invTransform || create$1();
+            invert(this.invTransform, m);
+        };
+        Transformable.prototype.getLocalTransform = function (m) {
+            return Transformable.getLocalTransform(this, m);
+        };
+        Transformable.prototype.getComputedTransform = function () {
+            var transformNode = this;
+            var ancestors = [];
+            while (transformNode) {
+                ancestors.push(transformNode);
+                transformNode = transformNode.parent;
+            }
+            while (transformNode = ancestors.pop()) {
+                transformNode.updateTransform();
+            }
+            return this.transform;
+        };
+        Transformable.prototype.setLocalTransform = function (m) {
+            if (!m) {
+                return;
+            }
+            var sx = m[0] * m[0] + m[1] * m[1];
+            var sy = m[2] * m[2] + m[3] * m[3];
+            if (isNotAroundZero(sx - 1)) {
+                sx = Math.sqrt(sx);
+            }
+            if (isNotAroundZero(sy - 1)) {
+                sy = Math.sqrt(sy);
+            }
+            if (m[0] < 0) {
+                sx = -sx;
+            }
+            if (m[3] < 0) {
+                sy = -sy;
+            }
+            this.rotation = Math.atan2(-m[1] / sy, m[0] / sx);
+            if (sx < 0 && sy < 0) {
+                this.rotation += Math.PI;
+                sx = -sx;
+                sy = -sy;
+            }
+            this.x = m[4];
+            this.y = m[5];
+            this.scaleX = sx;
+            this.scaleY = sy;
+        };
+        Transformable.prototype.decomposeTransform = function () {
+            if (!this.transform) {
+                return;
+            }
+            var parent = this.parent;
+            var m = this.transform;
+            if (parent && parent.transform) {
+                mul$1(tmpTransform, parent.invTransform, m);
+                m = tmpTransform;
+            }
+            var ox = this.originX;
+            var oy = this.originY;
+            if (ox || oy) {
+                originTransform[4] = ox;
+                originTransform[5] = oy;
+                mul$1(tmpTransform, m, originTransform);
+                tmpTransform[4] -= ox;
+                tmpTransform[5] -= oy;
+                m = tmpTransform;
+            }
+            this.setLocalTransform(m);
+        };
+        Transformable.prototype.getGlobalScale = function (out) {
+            var m = this.transform;
+            out = out || [];
+            if (!m) {
+                out[0] = 1;
+                out[1] = 1;
+                return out;
+            }
+            out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+            out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
+            if (m[0] < 0) {
+                out[0] = -out[0];
+            }
+            if (m[3] < 0) {
+                out[1] = -out[1];
+            }
+            return out;
+        };
+        Transformable.prototype.transformCoordToLocal = function (x, y) {
+            var v2 = [x, y];
+            var invTransform = this.invTransform;
+            if (invTransform) {
+                applyTransform(v2, v2, invTransform);
+            }
+            return v2;
+        };
+        Transformable.prototype.transformCoordToGlobal = function (x, y) {
+            var v2 = [x, y];
+            var transform = this.transform;
+            if (transform) {
+                applyTransform(v2, v2, transform);
+            }
+            return v2;
+        };
+        Transformable.prototype.getLineScale = function () {
+            var m = this.transform;
+            return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10
+                ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1]))
+                : 1;
+        };
+        Transformable.getLocalTransform = function (target, m) {
+            m = m || [];
+            mIdentity(m);
+            var ox = target.originX || 0;
+            var oy = target.originY || 0;
+            var sx = target.scaleX;
+            var sy = target.scaleY;
+            var rotation = target.rotation || 0;
+            var x = target.x;
+            var y = target.y;
+            m[4] -= ox;
+            m[5] -= oy;
+            m[0] *= sx;
+            m[1] *= sy;
+            m[2] *= sx;
+            m[3] *= sy;
+            m[4] *= sx;
+            m[5] *= sy;
+            if (rotation) {
+                rotate(m, m, rotation);
+            }
+            m[4] += ox;
+            m[5] += oy;
+            m[4] += x;
+            m[5] += y;
+            return m;
+        };
+        Transformable.initDefaultProps = (function () {
+            var proto = Transformable.prototype;
+            proto.x = 0;
+            proto.y = 0;
+            proto.scaleX = 1;
+            proto.scaleY = 1;
+            proto.originX = 0;
+            proto.originY = 0;
+            proto.rotation = 0;
+            proto.globalScaleRatio = 1;
+        })();
+        return Transformable;
+    }());
+
+    var easing = {
+        linear: function (k) {
+            return k;
+        },
+        quadraticIn: function (k) {
+            return k * k;
+        },
+        quadraticOut: function (k) {
+            return k * (2 - k);
+        },
+        quadraticInOut: function (k) {
+            if ((k *= 2) < 1) {
+                return 0.5 * k * k;
+            }
+            return -0.5 * (--k * (k - 2) - 1);
+        },
+        cubicIn: function (k) {
+            return k * k * k;
+        },
+        cubicOut: function (k) {
+            return --k * k * k + 1;
+        },
+        cubicInOut: function (k) {
+            if ((k *= 2) < 1) {
+                return 0.5 * k * k * k;
+            }
+            return 0.5 * ((k -= 2) * k * k + 2);
+        },
+        quarticIn: function (k) {
+            return k * k * k * k;
+        },
+        quarticOut: function (k) {
+            return 1 - (--k * k * k * k);
+        },
+        quarticInOut: function (k) {
+            if ((k *= 2) < 1) {
+                return 0.5 * k * k * k * k;
+            }
+            return -0.5 * ((k -= 2) * k * k * k - 2);
+        },
+        quinticIn: function (k) {
+            return k * k * k * k * k;
+        },
+        quinticOut: function (k) {
+            return --k * k * k * k * k + 1;
+        },
+        quinticInOut: function (k) {
+            if ((k *= 2) < 1) {
+                return 0.5 * k * k * k * k * k;
+            }
+            return 0.5 * ((k -= 2) * k * k * k * k + 2);
+        },
+        sinusoidalIn: function (k) {
+            return 1 - Math.cos(k * Math.PI / 2);
+        },
+        sinusoidalOut: function (k) {
+            return Math.sin(k * Math.PI / 2);
+        },
+        sinusoidalInOut: function (k) {
+            return 0.5 * (1 - Math.cos(Math.PI * k));
+        },
+        exponentialIn: function (k) {
+            return k === 0 ? 0 : Math.pow(1024, k - 1);
+        },
+        exponentialOut: function (k) {
+            return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
+        },
+        exponentialInOut: function (k) {
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            if ((k *= 2) < 1) {
+                return 0.5 * Math.pow(1024, k - 1);
+            }
+            return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+        },
+        circularIn: function (k) {
+            return 1 - Math.sqrt(1 - k * k);
+        },
+        circularOut: function (k) {
+            return Math.sqrt(1 - (--k * k));
+        },
+        circularInOut: function (k) {
+            if ((k *= 2) < 1) {
+                return -0.5 * (Math.sqrt(1 - k * k) - 1);
+            }
+            return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+        },
+        elasticIn: function (k) {
+            var s;
+            var a = 0.1;
+            var p = 0.4;
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            if (!a || a < 1) {
+                a = 1;
+                s = p / 4;
+            }
+            else {
+                s = p * Math.asin(1 / a) / (2 * Math.PI);
+            }
+            return -(a * Math.pow(2, 10 * (k -= 1))
+                * Math.sin((k - s) * (2 * Math.PI) / p));
+        },
+        elasticOut: function (k) {
+            var s;
+            var a = 0.1;
+            var p = 0.4;
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            if (!a || a < 1) {
+                a = 1;
+                s = p / 4;
+            }
+            else {
+                s = p * Math.asin(1 / a) / (2 * Math.PI);
+            }
+            return (a * Math.pow(2, -10 * k)
+                * Math.sin((k - s) * (2 * Math.PI) / p) + 1);
+        },
+        elasticInOut: function (k) {
+            var s;
+            var a = 0.1;
+            var p = 0.4;
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            if (!a || a < 1) {
+                a = 1;
+                s = p / 4;
+            }
+            else {
+                s = p * Math.asin(1 / a) / (2 * Math.PI);
+            }
+            if ((k *= 2) < 1) {
+                return -0.5 * (a * Math.pow(2, 10 * (k -= 1))
+                    * Math.sin((k - s) * (2 * Math.PI) / p));
+            }
+            return a * Math.pow(2, -10 * (k -= 1))
+                * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
+        },
+        backIn: function (k) {
+            var s = 1.70158;
+            return k * k * ((s + 1) * k - s);
+        },
+        backOut: function (k) {
+            var s = 1.70158;
+            return --k * k * ((s + 1) * k + s) + 1;
+        },
+        backInOut: function (k) {
+            var s = 1.70158 * 1.525;
+            if ((k *= 2) < 1) {
+                return 0.5 * (k * k * ((s + 1) * k - s));
+            }
+            return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+        },
+        bounceIn: function (k) {
+            return 1 - easing.bounceOut(1 - k);
+        },
+        bounceOut: function (k) {
+            if (k < (1 / 2.75)) {
+                return 7.5625 * k * k;
+            }
+            else if (k < (2 / 2.75)) {
+                return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
+            }
+            else if (k < (2.5 / 2.75)) {
+                return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
+            }
+            else {
+                return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
+            }
+        },
+        bounceInOut: function (k) {
+            if (k < 0.5) {
+                return easing.bounceIn(k * 2) * 0.5;
+            }
+            return easing.bounceOut(k * 2 - 1) * 0.5 + 0.5;
+        }
+    };
+
+    var Clip = (function () {
+        function Clip(opts) {
+            this._initialized = false;
+            this._startTime = 0;
+            this._pausedTime = 0;
+            this._paused = false;
+            this._life = opts.life || 1000;
+            this._delay = opts.delay || 0;
+            this.loop = opts.loop == null ? false : opts.loop;
+            this.gap = opts.gap || 0;
+            this.easing = opts.easing || 'linear';
+            this.onframe = opts.onframe;
+            this.ondestroy = opts.ondestroy;
+            this.onrestart = opts.onrestart;
+        }
+        Clip.prototype.step = function (globalTime, deltaTime) {
+            if (!this._initialized) {
+                this._startTime = globalTime + this._delay;
+                this._initialized = true;
+            }
+            if (this._paused) {
+                this._pausedTime += deltaTime;
+                return;
+            }
+            var percent = (globalTime - this._startTime - this._pausedTime) / this._life;
+            if (percent < 0) {
+                percent = 0;
+            }
+            percent = Math.min(percent, 1);
+            var easing$1 = this.easing;
+            var easingFunc = typeof easing$1 === 'string'
+                ? easing[easing$1] : easing$1;
+            var schedule = typeof easingFunc === 'function'
+                ? easingFunc(percent)
+                : percent;
+            this.onframe && this.onframe(schedule);
+            if (percent === 1) {
+                if (this.loop) {
+                    this._restart(globalTime);
+                    this.onrestart && this.onrestart();
+                }
+                else {
+                    return true;
+                }
+            }
+            return false;
+        };
+        Clip.prototype._restart = function (globalTime) {
+            var remainder = (globalTime - this._startTime - this._pausedTime) % this._life;
+            this._startTime = globalTime - remainder + this.gap;
+            this._pausedTime = 0;
+        };
+        Clip.prototype.pause = function () {
+            this._paused = true;
+        };
+        Clip.prototype.resume = function () {
+            this._paused = false;
+        };
+        return Clip;
+    }());
+
+    var Entry = (function () {
+        function Entry(val) {
+            this.value = val;
+        }
+        return Entry;
+    }());
+    var LinkedList = (function () {
+        function LinkedList() {
+            this._len = 0;
+        }
+        LinkedList.prototype.insert = function (val) {
+            var entry = new Entry(val);
+            this.insertEntry(entry);
+            return entry;
+        };
+        LinkedList.prototype.insertEntry = function (entry) {
+            if (!this.head) {
+                this.head = this.tail = entry;
+            }
+            else {
+                this.tail.next = entry;
+                entry.prev = this.tail;
+                entry.next = null;
+                this.tail = entry;
+            }
+            this._len++;
+        };
+        LinkedList.prototype.remove = function (entry) {
+            var prev = entry.prev;
+            var next = entry.next;
+            if (prev) {
+                prev.next = next;
+            }
+            else {
+                this.head = next;
+            }
+            if (next) {
+                next.prev = prev;
+            }
+            else {
+                this.tail = prev;
+            }
+            entry.next = entry.prev = null;
+            this._len--;
+        };
+        LinkedList.prototype.len = function () {
+            return this._len;
+        };
+        LinkedList.prototype.clear = function () {
+            this.head = this.tail = null;
+            this._len = 0;
+        };
+        return LinkedList;
+    }());
+    var LRU = (function () {
+        function LRU(maxSize) {
+            this._list = new LinkedList();
+            this._maxSize = 10;
+            this._map = {};
+            this._maxSize = maxSize;
+        }
+        LRU.prototype.put = function (key, value) {
+            var list = this._list;
+            var map = this._map;
+            var removed = null;
+            if (map[key] == null) {
+                var len = list.len();
+                var entry = this._lastRemovedEntry;
+                if (len >= this._maxSize && len > 0) {
+                    var leastUsedEntry = list.head;
+                    list.remove(leastUsedEntry);
+                    delete map[leastUsedEntry.key];
+                    removed = leastUsedEntry.value;
+                    this._lastRemovedEntry = leastUsedEntry;
+                }
+                if (entry) {
+                    entry.value = value;
+                }
+                else {
+                    entry = new Entry(value);
+                }
+                entry.key = key;
+                list.insertEntry(entry);
+                map[key] = entry;
+            }
+            return removed;
+        };
+        LRU.prototype.get = function (key) {
+            var entry = this._map[key];
+            var list = this._list;
+            if (entry != null) {
+                if (entry !== list.tail) {
+                    list.remove(entry);
+                    list.insertEntry(entry);
+                }
+                return entry.value;
+            }
+        };
+        LRU.prototype.clear = function () {
+            this._list.clear();
+            this._map = {};
+        };
+        LRU.prototype.len = function () {
+            return this._list.len();
+        };
+        return LRU;
+    }());
+
+    var kCSSColorTable = {
+        'transparent': [0, 0, 0, 0], 'aliceblue': [240, 248, 255, 1],
+        'antiquewhite': [250, 235, 215, 1], 'aqua': [0, 255, 255, 1],
+        'aquamarine': [127, 255, 212, 1], 'azure': [240, 255, 255, 1],
+        'beige': [245, 245, 220, 1], 'bisque': [255, 228, 196, 1],
+        'black': [0, 0, 0, 1], 'blanchedalmond': [255, 235, 205, 1],
+        'blue': [0, 0, 255, 1], 'blueviolet': [138, 43, 226, 1],
+        'brown': [165, 42, 42, 1], 'burlywood': [222, 184, 135, 1],
+        'cadetblue': [95, 158, 160, 1], 'chartreuse': [127, 255, 0, 1],
+        'chocolate': [210, 105, 30, 1], 'coral': [255, 127, 80, 1],
+        'cornflowerblue': [100, 149, 237, 1], 'cornsilk': [255, 248, 220, 1],
+        'crimson': [220, 20, 60, 1], 'cyan': [0, 255, 255, 1],
+        'darkblue': [0, 0, 139, 1], 'darkcyan': [0, 139, 139, 1],
+        'darkgoldenrod': [184, 134, 11, 1], 'darkgray': [169, 169, 169, 1],
+        'darkgreen': [0, 100, 0, 1], 'darkgrey': [169, 169, 169, 1],
+        'darkkhaki': [189, 183, 107, 1], 'darkmagenta': [139, 0, 139, 1],
+        'darkolivegreen': [85, 107, 47, 1], 'darkorange': [255, 140, 0, 1],
+        'darkorchid': [153, 50, 204, 1], 'darkred': [139, 0, 0, 1],
+        'darksalmon': [233, 150, 122, 1], 'darkseagreen': [143, 188, 143, 1],
+        'darkslateblue': [72, 61, 139, 1], 'darkslategray': [47, 79, 79, 1],
+        'darkslategrey': [47, 79, 79, 1], 'darkturquoise': [0, 206, 209, 1],
+        'darkviolet': [148, 0, 211, 1], 'deeppink': [255, 20, 147, 1],
+        'deepskyblue': [0, 191, 255, 1], 'dimgray': [105, 105, 105, 1],
+        'dimgrey': [105, 105, 105, 1], 'dodgerblue': [30, 144, 255, 1],
+        'firebrick': [178, 34, 34, 1], 'floralwhite': [255, 250, 240, 1],
+        'forestgreen': [34, 139, 34, 1], 'fuchsia': [255, 0, 255, 1],
+        'gainsboro': [220, 220, 220, 1], 'ghostwhite': [248, 248, 255, 1],
+        'gold': [255, 215, 0, 1], 'goldenrod': [218, 165, 32, 1],
+        'gray': [128, 128, 128, 1], 'green': [0, 128, 0, 1],
+        'greenyellow': [173, 255, 47, 1], 'grey': [128, 128, 128, 1],
+        'honeydew': [240, 255, 240, 1], 'hotpink': [255, 105, 180, 1],
+        'indianred': [205, 92, 92, 1], 'indigo': [75, 0, 130, 1],
+        'ivory': [255, 255, 240, 1], 'khaki': [240, 230, 140, 1],
+        'lavender': [230, 230, 250, 1], 'lavenderblush': [255, 240, 245, 1],
+        'lawngreen': [124, 252, 0, 1], 'lemonchiffon': [255, 250, 205, 1],
+        'lightblue': [173, 216, 230, 1], 'lightcoral': [240, 128, 128, 1],
+        'lightcyan': [224, 255, 255, 1], 'lightgoldenrodyellow': [250, 250, 210, 1],
+        'lightgray': [211, 211, 211, 1], 'lightgreen': [144, 238, 144, 1],
+        'lightgrey': [211, 211, 211, 1], 'lightpink': [255, 182, 193, 1],
+        'lightsalmon': [255, 160, 122, 1], 'lightseagreen': [32, 178, 170, 1],
+        'lightskyblue': [135, 206, 250, 1], 'lightslategray': [119, 136, 153, 1],
+        'lightslategrey': [119, 136, 153, 1], 'lightsteelblue': [176, 196, 222, 1],
+        'lightyellow': [255, 255, 224, 1], 'lime': [0, 255, 0, 1],
+        'limegreen': [50, 205, 50, 1], 'linen': [250, 240, 230, 1],
+        'magenta': [255, 0, 255, 1], 'maroon': [128, 0, 0, 1],
+        'mediumaquamarine': [102, 205, 170, 1], 'mediumblue': [0, 0, 205, 1],
+        'mediumorchid': [186, 85, 211, 1], 'mediumpurple': [147, 112, 219, 1],
+        'mediumseagreen': [60, 179, 113, 1], 'mediumslateblue': [123, 104, 238, 1],
+        'mediumspringgreen': [0, 250, 154, 1], 'mediumturquoise': [72, 209, 204, 1],
+        'mediumvioletred': [199, 21, 133, 1], 'midnightblue': [25, 25, 112, 1],
+        'mintcream': [245, 255, 250, 1], 'mistyrose': [255, 228, 225, 1],
+        'moccasin': [255, 228, 181, 1], 'navajowhite': [255, 222, 173, 1],
+        'navy': [0, 0, 128, 1], 'oldlace': [253, 245, 230, 1],
+        'olive': [128, 128, 0, 1], 'olivedrab': [107, 142, 35, 1],
+        'orange': [255, 165, 0, 1], 'orangered': [255, 69, 0, 1],
+        'orchid': [218, 112, 214, 1], 'palegoldenrod': [238, 232, 170, 1],
+        'palegreen': [152, 251, 152, 1], 'paleturquoise': [175, 238, 238, 1],
+        'palevioletred': [219, 112, 147, 1], 'papayawhip': [255, 239, 213, 1],
+        'peachpuff': [255, 218, 185, 1], 'peru': [205, 133, 63, 1],
+        'pink': [255, 192, 203, 1], 'plum': [221, 160, 221, 1],
+        'powderblue': [176, 224, 230, 1], 'purple': [128, 0, 128, 1],
+        'red': [255, 0, 0, 1], 'rosybrown': [188, 143, 143, 1],
+        'royalblue': [65, 105, 225, 1], 'saddlebrown': [139, 69, 19, 1],
+        'salmon': [250, 128, 114, 1], 'sandybrown': [244, 164, 96, 1],
+        'seagreen': [46, 139, 87, 1], 'seashell': [255, 245, 238, 1],
+        'sienna': [160, 82, 45, 1], 'silver': [192, 192, 192, 1],
+        'skyblue': [135, 206, 235, 1], 'slateblue': [106, 90, 205, 1],
+        'slategray': [112, 128, 144, 1], 'slategrey': [112, 128, 144, 1],
+        'snow': [255, 250, 250, 1], 'springgreen': [0, 255, 127, 1],
+        'steelblue': [70, 130, 180, 1], 'tan': [210, 180, 140, 1],
+        'teal': [0, 128, 128, 1], 'thistle': [216, 191, 216, 1],
+        'tomato': [255, 99, 71, 1], 'turquoise': [64, 224, 208, 1],
+        'violet': [238, 130, 238, 1], 'wheat': [245, 222, 179, 1],
+        'white': [255, 255, 255, 1], 'whitesmoke': [245, 245, 245, 1],
+        'yellow': [255, 255, 0, 1], 'yellowgreen': [154, 205, 50, 1]
+    };
+    function clampCssByte(i) {
+        i = Math.round(i);
+        return i < 0 ? 0 : i > 255 ? 255 : i;
+    }
+    function clampCssAngle(i) {
+        i = Math.round(i);
+        return i < 0 ? 0 : i > 360 ? 360 : i;
+    }
+    function clampCssFloat(f) {
+        return f < 0 ? 0 : f > 1 ? 1 : f;
+    }
+    function parseCssInt(val) {
+        var str = val;
+        if (str.length && str.charAt(str.length - 1) === '%') {
+            return clampCssByte(parseFloat(str) / 100 * 255);
+        }
+        return clampCssByte(parseInt(str, 10));
+    }
+    function parseCssFloat(val) {
+        var str = val;
+        if (str.length && str.charAt(str.length - 1) === '%') {
+            return clampCssFloat(parseFloat(str) / 100);
+        }
+        return clampCssFloat(parseFloat(str));
+    }
+    function cssHueToRgb(m1, m2, h) {
+        if (h < 0) {
+            h += 1;
+        }
+        else if (h > 1) {
+            h -= 1;
+        }
+        if (h * 6 < 1) {
+            return m1 + (m2 - m1) * h * 6;
+        }
+        if (h * 2 < 1) {
+            return m2;
+        }
+        if (h * 3 < 2) {
+            return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+        }
+        return m1;
+    }
+    function lerpNumber(a, b, p) {
+        return a + (b - a) * p;
+    }
+    function setRgba(out, r, g, b, a) {
+        out[0] = r;
+        out[1] = g;
+        out[2] = b;
+        out[3] = a;
+        return out;
+    }
+    function copyRgba(out, a) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+        return out;
+    }
+    var colorCache = new LRU(20);
+    var lastRemovedArr = null;
+    function putToCache(colorStr, rgbaArr) {
+        if (lastRemovedArr) {
+            copyRgba(lastRemovedArr, rgbaArr);
+        }
+        lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || (rgbaArr.slice()));
+    }
+    function parse(colorStr, rgbaArr) {
+        if (!colorStr) {
+            return;
+        }
+        rgbaArr = rgbaArr || [];
+        var cached = colorCache.get(colorStr);
+        if (cached) {
+            return copyRgba(rgbaArr, cached);
+        }
+        colorStr = colorStr + '';
+        var str = colorStr.replace(/ /g, '').toLowerCase();
+        if (str in kCSSColorTable) {
+            copyRgba(rgbaArr, kCSSColorTable[str]);
+            putToCache(colorStr, rgbaArr);
+            return rgbaArr;
+        }
+        var strLen = str.length;
+        if (str.charAt(0) === '#') {
+            if (strLen === 4 || strLen === 5) {
+                var iv = parseInt(str.slice(1, 4), 16);
+                if (!(iv >= 0 && iv <= 0xfff)) {
+                    setRgba(rgbaArr, 0, 0, 0, 1);
+                    return;
+                }
+                setRgba(rgbaArr, ((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8), (iv & 0xf0) | ((iv & 0xf0) >> 4), (iv & 0xf) | ((iv & 0xf) << 4), strLen === 5 ? parseInt(str.slice(4), 16) / 0xf : 1);
+                putToCache(colorStr, rgbaArr);
+                return rgbaArr;
+            }
+            else if (strLen === 7 || strLen === 9) {
+                var iv = parseInt(str.slice(1, 7), 16);
+                if (!(iv >= 0 && iv <= 0xffffff)) {
+                    setRgba(rgbaArr, 0, 0, 0, 1);
+                    return;
+                }
+                setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, strLen === 9 ? parseInt(str.slice(7), 16) / 0xff : 1);
+                putToCache(colorStr, rgbaArr);
+                return rgbaArr;
+            }
+            return;
+        }
+        var op = str.indexOf('(');
+        var ep = str.indexOf(')');
+        if (op !== -1 && ep + 1 === strLen) {
+            var fname = str.substr(0, op);
+            var params = str.substr(op + 1, ep - (op + 1)).split(',');
+            var alpha = 1;
+            switch (fname) {
+                case 'rgba':
+                    if (params.length !== 4) {
+                        return params.length === 3
+                            ? setRgba(rgbaArr, +params[0], +params[1], +params[2], 1)
+                            : setRgba(rgbaArr, 0, 0, 0, 1);
+                    }
+                    alpha = parseCssFloat(params.pop());
+                case 'rgb':
+                    if (params.length !== 3) {
+                        setRgba(rgbaArr, 0, 0, 0, 1);
+                        return;
+                    }
+                    setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), alpha);
+                    putToCache(colorStr, rgbaArr);
+                    return rgbaArr;
+                case 'hsla':
+                    if (params.length !== 4) {
+                        setRgba(rgbaArr, 0, 0, 0, 1);
+                        return;
+                    }
+                    params[3] = parseCssFloat(params[3]);
+                    hsla2rgba(params, rgbaArr);
+                    putToCache(colorStr, rgbaArr);
+                    return rgbaArr;
+                case 'hsl':
+                    if (params.length !== 3) {
+                        setRgba(rgbaArr, 0, 0, 0, 1);
+                        return;
+                    }
+                    hsla2rgba(params, rgbaArr);
+                    putToCache(colorStr, rgbaArr);
+                    return rgbaArr;
+                default:
+                    return;
+            }
+        }
+        setRgba(rgbaArr, 0, 0, 0, 1);
+        return;
+    }
+    function hsla2rgba(hsla, rgba) {
+        var h = (((parseFloat(hsla[0]) % 360) + 360) % 360) / 360;
+        var s = parseCssFloat(hsla[1]);
+        var l = parseCssFloat(hsla[2]);
+        var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+        var m1 = l * 2 - m2;
+        rgba = rgba || [];
+        setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);
+        if (hsla.length === 4) {
+            rgba[3] = hsla[3];
+        }
+        return rgba;
+    }
+    function rgba2hsla(rgba) {
+        if (!rgba) {
+            return;
+        }
+        var R = rgba[0] / 255;
+        var G = rgba[1] / 255;
+        var B = rgba[2] / 255;
+        var vMin = Math.min(R, G, B);
+        var vMax = Math.max(R, G, B);
+        var delta = vMax - vMin;
+        var L = (vMax + vMin) / 2;
+        var H;
+        var S;
+        if (delta === 0) {
+            H = 0;
+            S = 0;
+        }
+        else {
+            if (L < 0.5) {
+                S = delta / (vMax + vMin);
+            }
+            else {
+                S = delta / (2 - vMax - vMin);
+            }
+            var deltaR = (((vMax - R) / 6) + (delta / 2)) / delta;
+            var deltaG = (((vMax - G) / 6) + (delta / 2)) / delta;
+            var deltaB = (((vMax - B) / 6) + (delta / 2)) / delta;
+            if (R === vMax) {
+                H = deltaB - deltaG;
+            }
+            else if (G === vMax) {
+                H = (1 / 3) + deltaR - deltaB;
+            }
+            else if (B === vMax) {
+                H = (2 / 3) + deltaG - deltaR;
+            }
+            if (H < 0) {
+                H += 1;
+            }
+            if (H > 1) {
+                H -= 1;
+            }
+        }
+        var hsla = [H * 360, S, L];
+        if (rgba[3] != null) {
+            hsla.push(rgba[3]);
+        }
+        return hsla;
+    }
+    function lift(color, level) {
+        var colorArr = parse(color);
+        if (colorArr) {
+            for (var i = 0; i < 3; i++) {
+                if (level < 0) {
+                    colorArr[i] = colorArr[i] * (1 - level) | 0;
+                }
+                else {
+                    colorArr[i] = ((255 - colorArr[i]) * level + colorArr[i]) | 0;
+                }
+                if (colorArr[i] > 255) {
+                    colorArr[i] = 255;
+                }
+                else if (colorArr[i] < 0) {
+                    colorArr[i] = 0;
+                }
+            }
+            return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');
+        }
+    }
+    function toHex(color) {
+        var colorArr = parse(color);
+        if (colorArr) {
+            return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + (+colorArr[2])).toString(16).slice(1);
+        }
+    }
+    function fastLerp(normalizedValue, colors, out) {
+        if (!(colors && colors.length)
+            || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+            return;
+        }
+        out = out || [];
+        var value = normalizedValue * (colors.length - 1);
+        var leftIndex = Math.floor(value);
+        var rightIndex = Math.ceil(value);
+        var leftColor = colors[leftIndex];
+        var rightColor = colors[rightIndex];
+        var dv = value - leftIndex;
+        out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));
+        out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));
+        out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));
+        out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));
+        return out;
+    }
+    var fastMapToColor = fastLerp;
+    function lerp$1(normalizedValue, colors, fullOutput) {
+        if (!(colors && colors.length)
+            || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+            return;
+        }
+        var value = normalizedValue * (colors.length - 1);
+        var leftIndex = Math.floor(value);
+        var rightIndex = Math.ceil(value);
+        var leftColor = parse(colors[leftIndex]);
+        var rightColor = parse(colors[rightIndex]);
+        var dv = value - leftIndex;
+        var color = stringify([
+            clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)),
+            clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)),
+            clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)),
+            clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))
+        ], 'rgba');
+        return fullOutput
+            ? {
+                color: color,
+                leftIndex: leftIndex,
+                rightIndex: rightIndex,
+                value: value
+            }
+            : color;
+    }
+    var mapToColor = lerp$1;
+    function modifyHSL(color, h, s, l) {
+        var colorArr = parse(color);
+        if (color) {
+            colorArr = rgba2hsla(colorArr);
+            h != null && (colorArr[0] = clampCssAngle(h));
+            s != null && (colorArr[1] = parseCssFloat(s));
+            l != null && (colorArr[2] = parseCssFloat(l));
+            return stringify(hsla2rgba(colorArr), 'rgba');
+        }
+    }
+    function modifyAlpha(color, alpha) {
+        var colorArr = parse(color);
+        if (colorArr && alpha != null) {
+            colorArr[3] = clampCssFloat(alpha);
+            return stringify(colorArr, 'rgba');
+        }
+    }
+    function stringify(arrColor, type) {
+        if (!arrColor || !arrColor.length) {
+            return;
+        }
+        var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];
+        if (type === 'rgba' || type === 'hsva' || type === 'hsla') {
+            colorStr += ',' + arrColor[3];
+        }
+        return type + '(' + colorStr + ')';
+    }
+    function lum(color, backgroundLum) {
+        var arr = parse(color);
+        return arr
+            ? (0.299 * arr[0] + 0.587 * arr[1] + 0.114 * arr[2]) * arr[3] / 255
+                + (1 - arr[3]) * backgroundLum
+            : 0;
+    }
+    function random() {
+        var r = Math.round(Math.random() * 255);
+        var g = Math.round(Math.random() * 255);
+        var b = Math.round(Math.random() * 255);
+        return 'rgb(' + r + ',' + g + ',' + b + ')';
+    }
+
+    var color = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        parse: parse,
+        lift: lift,
+        toHex: toHex,
+        fastLerp: fastLerp,
+        fastMapToColor: fastMapToColor,
+        lerp: lerp$1,
+        mapToColor: mapToColor,
+        modifyHSL: modifyHSL,
+        modifyAlpha: modifyAlpha,
+        stringify: stringify,
+        lum: lum,
+        random: random
+    });
+
+    var arraySlice = Array.prototype.slice;
+    function interpolateNumber(p0, p1, percent) {
+        return (p1 - p0) * percent + p0;
+    }
+    function step(p0, p1, percent) {
+        return percent > 0.5 ? p1 : p0;
+    }
+    function interpolate1DArray(out, p0, p1, percent) {
+        var len = p0.length;
+        for (var i = 0; i < len; i++) {
+            out[i] = interpolateNumber(p0[i], p1[i], percent);
+        }
+    }
+    function interpolate2DArray(out, p0, p1, percent) {
+        var len = p0.length;
+        var len2 = len && p0[0].length;
+        for (var i = 0; i < len; i++) {
+            if (!out[i]) {
+                out[i] = [];
+            }
+            for (var j = 0; j < len2; j++) {
+                out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);
+            }
+        }
+    }
+    function add1DArray(out, p0, p1, sign) {
+        var len = p0.length;
+        for (var i = 0; i < len; i++) {
+            out[i] = p0[i] + p1[i] * sign;
+        }
+        return out;
+    }
+    function add2DArray(out, p0, p1, sign) {
+        var len = p0.length;
+        var len2 = len && p0[0].length;
+        for (var i = 0; i < len; i++) {
+            if (!out[i]) {
+                out[i] = [];
+            }
+            for (var j = 0; j < len2; j++) {
+                out[i][j] = p0[i][j] + p1[i][j] * sign;
+            }
+        }
+        return out;
+    }
+    function fillArray(val0, val1, arrDim) {
+        var arr0 = val0;
+        var arr1 = val1;
+        if (!arr0.push || !arr1.push) {
+            return;
+        }
+        var arr0Len = arr0.length;
+        var arr1Len = arr1.length;
+        if (arr0Len !== arr1Len) {
+            var isPreviousLarger = arr0Len > arr1Len;
+            if (isPreviousLarger) {
+                arr0.length = arr1Len;
+            }
+            else {
+                for (var i = arr0Len; i < arr1Len; i++) {
+                    arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));
+                }
+            }
+        }
+        var len2 = arr0[0] && arr0[0].length;
+        for (var i = 0; i < arr0.length; i++) {
+            if (arrDim === 1) {
+                if (isNaN(arr0[i])) {
+                    arr0[i] = arr1[i];
+                }
+            }
+            else {
+                for (var j = 0; j < len2; j++) {
+                    if (isNaN(arr0[i][j])) {
+                        arr0[i][j] = arr1[i][j];
+                    }
+                }
+            }
+        }
+    }
+    function is1DArraySame(arr0, arr1) {
+        var len = arr0.length;
+        if (len !== arr1.length) {
+            return false;
+        }
+        for (var i = 0; i < len; i++) {
+            if (arr0[i] !== arr1[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function catmullRomInterpolate(p0, p1, p2, p3, t, t2, t3) {
+        var v0 = (p2 - p0) * 0.5;
+        var v1 = (p3 - p1) * 0.5;
+        return (2 * (p1 - p2) + v0 + v1) * t3
+            + (-3 * (p1 - p2) - 2 * v0 - v1) * t2
+            + v0 * t + p1;
+    }
+    function catmullRomInterpolate1DArray(out, p0, p1, p2, p3, t, t2, t3) {
+        var len = p0.length;
+        for (var i = 0; i < len; i++) {
+            out[i] = catmullRomInterpolate(p0[i], p1[i], p2[i], p3[i], t, t2, t3);
+        }
+    }
+    function catmullRomInterpolate2DArray(out, p0, p1, p2, p3, t, t2, t3) {
+        var len = p0.length;
+        var len2 = p0[0].length;
+        for (var i = 0; i < len; i++) {
+            if (!out[i]) {
+                out[1] = [];
+            }
+            for (var j = 0; j < len2; j++) {
+                out[i][j] = catmullRomInterpolate(p0[i][j], p1[i][j], p2[i][j], p3[i][j], t, t2, t3);
+            }
+        }
+    }
+    function cloneValue(value) {
+        if (isArrayLike(value)) {
+            var len = value.length;
+            if (isArrayLike(value[0])) {
+                var ret = [];
+                for (var i = 0; i < len; i++) {
+                    ret.push(arraySlice.call(value[i]));
+                }
+                return ret;
+            }
+            return arraySlice.call(value);
+        }
+        return value;
+    }
+    function rgba2String(rgba) {
+        rgba[0] = Math.floor(rgba[0]);
+        rgba[1] = Math.floor(rgba[1]);
+        rgba[2] = Math.floor(rgba[2]);
+        return 'rgba(' + rgba.join(',') + ')';
+    }
+    function guessArrayDim(value) {
+        return isArrayLike(value && value[0]) ? 2 : 1;
+    }
+    var tmpRgba = [0, 0, 0, 0];
+    var Track = (function () {
+        function Track(propName) {
+            this.keyframes = [];
+            this.maxTime = 0;
+            this.arrDim = 0;
+            this.interpolable = true;
+            this._needsSort = false;
+            this._isAllValueEqual = true;
+            this._lastFrame = 0;
+            this._lastFramePercent = 0;
+            this.propName = propName;
+        }
+        Track.prototype.isFinished = function () {
+            return this._finished;
+        };
+        Track.prototype.setFinished = function () {
+            this._finished = true;
+            if (this._additiveTrack) {
+                this._additiveTrack.setFinished();
+            }
+        };
+        Track.prototype.needsAnimate = function () {
+            return !this._isAllValueEqual && this.keyframes.length >= 2 && this.interpolable;
+        };
+        Track.prototype.getAdditiveTrack = function () {
+            return this._additiveTrack;
+        };
+        Track.prototype.addKeyframe = function (time, value) {
+            if (time >= this.maxTime) {
+                this.maxTime = time;
+            }
+            else {
+                this._needsSort = true;
+            }
+            var keyframes = this.keyframes;
+            var len = keyframes.length;
+            if (this.interpolable) {
+                if (isArrayLike(value)) {
+                    var arrayDim = guessArrayDim(value);
+                    if (len > 0 && this.arrDim !== arrayDim) {
+                        this.interpolable = false;
+                        return;
+                    }
+                    if (arrayDim === 1 && typeof value[0] !== 'number'
+                        || arrayDim === 2 && typeof value[0][0] !== 'number') {
+                        this.interpolable = false;
+                        return;
+                    }
+                    if (len > 0) {
+                        var lastFrame = keyframes[len - 1];
+                        if (this._isAllValueEqual) {
+                            if (arrayDim === 1) {
+                                if (!is1DArraySame(value, lastFrame.value)) {
+                                    this._isAllValueEqual = false;
+                                }
+                            }
+                            else {
+                                this._isAllValueEqual = false;
+                            }
+                        }
+                    }
+                    this.arrDim = arrayDim;
+                }
+                else {
+                    if (this.arrDim > 0) {
+                        this.interpolable = false;
+                        return;
+                    }
+                    if (typeof value === 'string') {
+                        var colorArray = parse(value);
+                        if (colorArray) {
+                            value = colorArray;
+                            this.isValueColor = true;
+                        }
+                        else {
+                            this.interpolable = false;
+                        }
+                    }
+                    else if (typeof value !== 'number') {
+                        this.interpolable = false;
+                        return;
+                    }
+                    if (this._isAllValueEqual && len > 0) {
+                        var lastFrame = keyframes[len - 1];
+                        if (this.isValueColor && !is1DArraySame(lastFrame.value, value)) {
+                            this._isAllValueEqual = false;
+                        }
+                        else if (lastFrame.value !== value) {
+                            this._isAllValueEqual = false;
+                        }
+                    }
+                }
+            }
+            var kf = {
+                time: time,
+                value: value,
+                percent: 0
+            };
+            this.keyframes.push(kf);
+            return kf;
+        };
+        Track.prototype.prepare = function (additiveTrack) {
+            var kfs = this.keyframes;
+            if (this._needsSort) {
+                kfs.sort(function (a, b) {
+                    return a.time - b.time;
+                });
+            }
+            var arrDim = this.arrDim;
+            var kfsLen = kfs.length;
+            var lastKf = kfs[kfsLen - 1];
+            for (var i = 0; i < kfsLen; i++) {
+                kfs[i].percent = kfs[i].time / this.maxTime;
+                if (arrDim > 0 && i !== kfsLen - 1) {
+                    fillArray(kfs[i].value, lastKf.value, arrDim);
+                }
+            }
+            if (additiveTrack
+                && this.needsAnimate()
+                && additiveTrack.needsAnimate()
+                && arrDim === additiveTrack.arrDim
+                && this.isValueColor === additiveTrack.isValueColor
+                && !additiveTrack._finished) {
+                this._additiveTrack = additiveTrack;
+                var startValue = kfs[0].value;
+                for (var i = 0; i < kfsLen; i++) {
+                    if (arrDim === 0) {
+                        if (this.isValueColor) {
+                            kfs[i].additiveValue
+                                = add1DArray([], kfs[i].value, startValue, -1);
+                        }
+                        else {
+                            kfs[i].additiveValue = kfs[i].value - startValue;
+                        }
+                    }
+                    else if (arrDim === 1) {
+                        kfs[i].additiveValue = add1DArray([], kfs[i].value, startValue, -1);
+                    }
+                    else if (arrDim === 2) {
+                        kfs[i].additiveValue = add2DArray([], kfs[i].value, startValue, -1);
+                    }
+                }
+            }
+        };
+        Track.prototype.step = function (target, percent) {
+            if (this._finished) {
+                return;
+            }
+            if (this._additiveTrack && this._additiveTrack._finished) {
+                this._additiveTrack = null;
+            }
+            var isAdditive = this._additiveTrack != null;
+            var valueKey = isAdditive ? 'additiveValue' : 'value';
+            var keyframes = this.keyframes;
+            var kfsNum = this.keyframes.length;
+            var propName = this.propName;
+            var arrDim = this.arrDim;
+            var isValueColor = this.isValueColor;
+            var frameIdx;
+            if (percent < 0) {
+                frameIdx = 0;
+            }
+            else if (percent < this._lastFramePercent) {
+                var start = Math.min(this._lastFrame + 1, kfsNum - 1);
+                for (frameIdx = start; frameIdx >= 0; frameIdx--) {
+                    if (keyframes[frameIdx].percent <= percent) {
+                        break;
+                    }
+                }
+                frameIdx = Math.min(frameIdx, kfsNum - 2);
+            }
+            else {
+                for (frameIdx = this._lastFrame; frameIdx < kfsNum; frameIdx++) {
+                    if (keyframes[frameIdx].percent > percent) {
+                        break;
+                    }
+                }
+                frameIdx = Math.min(frameIdx - 1, kfsNum - 2);
+            }
+            var nextFrame = keyframes[frameIdx + 1];
+            var frame = keyframes[frameIdx];
+            if (!(frame && nextFrame)) {
+                return;
+            }
+            this._lastFrame = frameIdx;
+            this._lastFramePercent = percent;
+            var range = (nextFrame.percent - frame.percent);
+            if (range === 0) {
+                return;
+            }
+            var w = (percent - frame.percent) / range;
+            var targetArr = isAdditive ? this._additiveValue
+                : (isValueColor ? tmpRgba : target[propName]);
+            if ((arrDim > 0 || isValueColor) && !targetArr) {
+                targetArr = this._additiveValue = [];
+            }
+            if (this.useSpline) {
+                var p1 = keyframes[frameIdx][valueKey];
+                var p0 = keyframes[frameIdx === 0 ? frameIdx : frameIdx - 1][valueKey];
+                var p2 = keyframes[frameIdx > kfsNum - 2 ? kfsNum - 1 : frameIdx + 1][valueKey];
+                var p3 = keyframes[frameIdx > kfsNum - 3 ? kfsNum - 1 : frameIdx + 2][valueKey];
+                if (arrDim > 0) {
+                    arrDim === 1
+                        ? catmullRomInterpolate1DArray(targetArr, p0, p1, p2, p3, w, w * w, w * w * w)
+                        : catmullRomInterpolate2DArray(targetArr, p0, p1, p2, p3, w, w * w, w * w * w);
+                }
+                else if (isValueColor) {
+                    catmullRomInterpolate1DArray(targetArr, p0, p1, p2, p3, w, w * w, w * w * w);
+                    if (!isAdditive) {
+                        target[propName] = rgba2String(targetArr);
+                    }
+                }
+                else {
+                    var value = void 0;
+                    if (!this.interpolable) {
+                        value = p2;
+                    }
+                    else {
+                        value = catmullRomInterpolate(p0, p1, p2, p3, w, w * w, w * w * w);
+                    }
+                    if (isAdditive) {
+                        this._additiveValue = value;
+                    }
+                    else {
+                        target[propName] = value;
+                    }
+                }
+            }
+            else {
+                if (arrDim > 0) {
+                    arrDim === 1
+                        ? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w)
+                        : interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+                }
+                else if (isValueColor) {
+                    interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+                    if (!isAdditive) {
+                        target[propName] = rgba2String(targetArr);
+                    }
+                }
+                else {
+                    var value = void 0;
+                    if (!this.interpolable) {
+                        value = step(frame[valueKey], nextFrame[valueKey], w);
+                    }
+                    else {
+                        value = interpolateNumber(frame[valueKey], nextFrame[valueKey], w);
+                    }
+                    if (isAdditive) {
+                        this._additiveValue = value;
+                    }
+                    else {
+                        target[propName] = value;
+                    }
+                }
+            }
+            if (isAdditive) {
+                this._addToTarget(target);
+            }
+        };
+        Track.prototype._addToTarget = function (target) {
+            var arrDim = this.arrDim;
+            var propName = this.propName;
+            var additiveValue = this._additiveValue;
+            if (arrDim === 0) {
+                if (this.isValueColor) {
+                    parse(target[propName], tmpRgba);
+                    add1DArray(tmpRgba, tmpRgba, additiveValue, 1);
+                    target[propName] = rgba2String(tmpRgba);
+                }
+                else {
+                    target[propName] = target[propName] + additiveValue;
+                }
+            }
+            else if (arrDim === 1) {
+                add1DArray(target[propName], target[propName], additiveValue, 1);
+            }
+            else if (arrDim === 2) {
+                add2DArray(target[propName], target[propName], additiveValue, 1);
+            }
+        };
+        return Track;
+    }());
+    var Animator = (function () {
+        function Animator(target, loop, additiveTo) {
+            this._tracks = {};
+            this._trackKeys = [];
+            this._delay = 0;
+            this._maxTime = 0;
+            this._paused = false;
+            this._started = 0;
+            this._clip = null;
+            this._target = target;
+            this._loop = loop;
+            if (loop && additiveTo) {
+                logError('Can\' use additive animation on looped animation.');
+                return;
+            }
+            this._additiveAnimators = additiveTo;
+        }
+        Animator.prototype.getTarget = function () {
+            return this._target;
+        };
+        Animator.prototype.changeTarget = function (target) {
+            this._target = target;
+        };
+        Animator.prototype.when = function (time, props) {
+            return this.whenWithKeys(time, props, keys(props));
+        };
+        Animator.prototype.whenWithKeys = function (time, props, propNames) {
+            var tracks = this._tracks;
+            for (var i = 0; i < propNames.length; i++) {
+                var propName = propNames[i];
+                var track = tracks[propName];
+                if (!track) {
+                    track = tracks[propName] = new Track(propName);
+                    var initialValue = void 0;
+                    var additiveTrack = this._getAdditiveTrack(propName);
+                    if (additiveTrack) {
+                        var lastFinalKf = additiveTrack.keyframes[additiveTrack.keyframes.length - 1];
+                        initialValue = lastFinalKf && lastFinalKf.value;
+                        if (additiveTrack.isValueColor && initialValue) {
+                            initialValue = rgba2String(initialValue);
+                        }
+                    }
+                    else {
+                        initialValue = this._target[propName];
+                    }
+                    if (initialValue == null) {
+                        continue;
+                    }
+                    if (time !== 0) {
+                        track.addKeyframe(0, cloneValue(initialValue));
+                    }
+                    this._trackKeys.push(propName);
+                }
+                track.addKeyframe(time, cloneValue(props[propName]));
+            }
+            this._maxTime = Math.max(this._maxTime, time);
+            return this;
+        };
+        Animator.prototype.pause = function () {
+            this._clip.pause();
+            this._paused = true;
+        };
+        Animator.prototype.resume = function () {
+            this._clip.resume();
+            this._paused = false;
+        };
+        Animator.prototype.isPaused = function () {
+            return !!this._paused;
+        };
+        Animator.prototype._doneCallback = function () {
+            this._setTracksFinished();
+            this._clip = null;
+            var doneList = this._doneList;
+            if (doneList) {
+                var len = doneList.length;
+                for (var i = 0; i < len; i++) {
+                    doneList[i].call(this);
+                }
+            }
+        };
+        Animator.prototype._abortedCallback = function () {
+            this._setTracksFinished();
+            var animation = this.animation;
+            var abortedList = this._abortedList;
+            if (animation) {
+                animation.removeClip(this._clip);
+            }
+            this._clip = null;
+            if (abortedList) {
+                for (var i = 0; i < abortedList.length; i++) {
+                    abortedList[i].call(this);
+                }
+            }
+        };
+        Animator.prototype._setTracksFinished = function () {
+            var tracks = this._tracks;
+            var tracksKeys = this._trackKeys;
+            for (var i = 0; i < tracksKeys.length; i++) {
+                tracks[tracksKeys[i]].setFinished();
+            }
+        };
+        Animator.prototype._getAdditiveTrack = function (trackName) {
+            var additiveTrack;
+            var additiveAnimators = this._additiveAnimators;
+            if (additiveAnimators) {
+                for (var i = 0; i < additiveAnimators.length; i++) {
+                    var track = additiveAnimators[i].getTrack(trackName);
+                    if (track) {
+                        additiveTrack = track;
+                    }
+                }
+            }
+            return additiveTrack;
+        };
+        Animator.prototype.start = function (easing, forceAnimate) {
+            if (this._started > 0) {
+                return;
+            }
+            this._started = 1;
+            var self = this;
+            var tracks = [];
+            for (var i = 0; i < this._trackKeys.length; i++) {
+                var propName = this._trackKeys[i];
+                var track = this._tracks[propName];
+                var additiveTrack = this._getAdditiveTrack(propName);
+                var kfs = track.keyframes;
+                track.prepare(additiveTrack);
+                if (track.needsAnimate()) {
+                    tracks.push(track);
+                }
+                else if (!track.interpolable) {
+                    var lastKf = kfs[kfs.length - 1];
+                    if (lastKf) {
+                        self._target[track.propName] = lastKf.value;
+                    }
+                }
+            }
+            if (tracks.length || forceAnimate) {
+                var clip = new Clip({
+                    life: this._maxTime,
+                    loop: this._loop,
+                    delay: this._delay,
+                    onframe: function (percent) {
+                        self._started = 2;
+                        var additiveAnimators = self._additiveAnimators;
+                        if (additiveAnimators) {
+                            var stillHasAdditiveAnimator = false;
+                            for (var i = 0; i < additiveAnimators.length; i++) {
+                                if (additiveAnimators[i]._clip) {
+                                    stillHasAdditiveAnimator = true;
+                                    break;
+                                }
+                            }
+                            if (!stillHasAdditiveAnimator) {
+                                self._additiveAnimators = null;
+                            }
+                        }
+                        for (var i = 0; i < tracks.length; i++) {
+                            tracks[i].step(self._target, percent);
+                        }
+                        var onframeList = self._onframeList;
+                        if (onframeList) {
+                            for (var i = 0; i < onframeList.length; i++) {
+                                onframeList[i](self._target, percent);
+                            }
+                        }
+                    },
+                    ondestroy: function () {
+                        self._doneCallback();
+                    }
+                });
+                this._clip = clip;
+                if (this.animation) {
+                    this.animation.addClip(clip);
+                }
+                if (easing && easing !== 'spline') {
+                    clip.easing = easing;
+                }
+            }
+            else {
+                this._doneCallback();
+            }
+            return this;
+        };
+        Animator.prototype.stop = function (forwardToLast) {
+            if (!this._clip) {
+                return;
+            }
+            var clip = this._clip;
+            if (forwardToLast) {
+                clip.onframe(1);
+            }
+            this._abortedCallback();
+        };
+        Animator.prototype.delay = function (time) {
+            this._delay = time;
+            return this;
+        };
+        Animator.prototype.during = function (cb) {
+            if (cb) {
+                if (!this._onframeList) {
+                    this._onframeList = [];
+                }
+                this._onframeList.push(cb);
+            }
+            return this;
+        };
+        Animator.prototype.done = function (cb) {
+            if (cb) {
+                if (!this._doneList) {
+                    this._doneList = [];
+                }
+                this._doneList.push(cb);
+            }
+            return this;
+        };
+        Animator.prototype.aborted = function (cb) {
+            if (cb) {
+                if (!this._abortedList) {
+                    this._abortedList = [];
+                }
+                this._abortedList.push(cb);
+            }
+            return this;
+        };
+        Animator.prototype.getClip = function () {
+            return this._clip;
+        };
+        Animator.prototype.getTrack = function (propName) {
+            return this._tracks[propName];
+        };
+        Animator.prototype.stopTracks = function (propNames, forwardToLast) {
+            if (!propNames.length || !this._clip) {
+                return true;
+            }
+            var tracks = this._tracks;
+            var tracksKeys = this._trackKeys;
+            for (var i = 0; i < propNames.length; i++) {
+                var track = tracks[propNames[i]];
+                if (track) {
+                    if (forwardToLast) {
+                        track.step(this._target, 1);
+                    }
+                    else if (this._started === 1) {
+                        track.step(this._target, 0);
+                    }
+                    track.setFinished();
+                }
+            }
+            var allAborted = true;
+            for (var i = 0; i < tracksKeys.length; i++) {
+                if (!tracks[tracksKeys[i]].isFinished()) {
+                    allAborted = false;
+                    break;
+                }
+            }
+            if (allAborted) {
+                this._abortedCallback();
+            }
+            return allAborted;
+        };
+        Animator.prototype.saveFinalToTarget = function (target, trackKeys) {
+            if (!target) {
+                return;
+            }
+            trackKeys = trackKeys || this._trackKeys;
+            for (var i = 0; i < trackKeys.length; i++) {
+                var propName = trackKeys[i];
+                var track = this._tracks[propName];
+                if (!track || track.isFinished()) {
+                    continue;
+                }
+                var kfs = track.keyframes;
+                var lastKf = kfs[kfs.length - 1];
+                if (lastKf) {
+                    var val = cloneValue(lastKf.value);
+                    if (track.isValueColor) {
+                        val = rgba2String(val);
+                    }
+                    target[propName] = val;
+                }
+            }
+        };
+        Animator.prototype.__changeFinalValue = function (finalProps, trackKeys) {
+            trackKeys = trackKeys || keys(finalProps);
+            for (var i = 0; i < trackKeys.length; i++) {
+                var propName = trackKeys[i];
+                var track = this._tracks[propName];
+                if (!track) {
+                    continue;
+                }
+                var kfs = track.keyframes;
+                if (kfs.length > 1) {
+                    var lastKf = kfs.pop();
+                    track.addKeyframe(lastKf.time, finalProps[propName]);
+                    track.prepare(track.getAdditiveTrack());
+                }
+            }
+        };
+        return Animator;
+    }());
+
+    var Point = (function () {
+        function Point(x, y) {
+            this.x = x || 0;
+            this.y = y || 0;
+        }
+        Point.prototype.copy = function (other) {
+            this.x = other.x;
+            this.y = other.y;
+            return this;
+        };
+        Point.prototype.clone = function () {
+            return new Point(this.x, this.y);
+        };
+        Point.prototype.set = function (x, y) {
+            this.x = x;
+            this.y = y;
+            return this;
+        };
+        Point.prototype.equal = function (other) {
+            return other.x === this.x && other.y === this.y;
+        };
+        Point.prototype.add = function (other) {
+            this.x += other.x;
+            this.y += other.y;
+            return this;
+        };
+        Point.prototype.scale = function (scalar) {
+            this.x *= scalar;
+            this.y *= scalar;
+        };
+        Point.prototype.scaleAndAdd = function (other, scalar) {
+            this.x += other.x * scalar;
+            this.y += other.y * scalar;
+        };
+        Point.prototype.sub = function (other) {
+            this.x -= other.x;
+            this.y -= other.y;
+            return this;
+        };
+        Point.prototype.dot = function (other) {
+            return this.x * other.x + this.y * other.y;
+        };
+        Point.prototype.len = function () {
+            return Math.sqrt(this.x * this.x + this.y * this.y);
+        };
+        Point.prototype.lenSquare = function () {
+            return this.x * this.x + this.y * this.y;
+        };
+        Point.prototype.normalize = function () {
+            var len = this.len();
+            this.x /= len;
+            this.y /= len;
+            return this;
+        };
+        Point.prototype.distance = function (other) {
+            var dx = this.x - other.x;
+            var dy = this.y - other.y;
+            return Math.sqrt(dx * dx + dy * dy);
+        };
+        Point.prototype.distanceSquare = function (other) {
+            var dx = this.x - other.x;
+            var dy = this.y - other.y;
+            return dx * dx + dy * dy;
+        };
+        Point.prototype.negate = function () {
+            this.x = -this.x;
+            this.y = -this.y;
+            return this;
+        };
+        Point.prototype.transform = function (m) {
+            if (!m) {
+                return;
+            }
+            var x = this.x;
+            var y = this.y;
+            this.x = m[0] * x + m[2] * y + m[4];
+            this.y = m[1] * x + m[3] * y + m[5];
+            return this;
+        };
+        Point.prototype.toArray = function (out) {
+            out[0] = this.x;
+            out[1] = this.y;
+            return out;
+        };
+        Point.prototype.fromArray = function (input) {
+            this.x = input[0];
+            this.y = input[1];
+        };
+        Point.set = function (p, x, y) {
+            p.x = x;
+            p.y = y;
+        };
+        Point.copy = function (p, p2) {
+            p.x = p2.x;
+            p.y = p2.y;
+        };
+        Point.len = function (p) {
+            return Math.sqrt(p.x * p.x + p.y * p.y);
+        };
+        Point.lenSquare = function (p) {
+            return p.x * p.x + p.y * p.y;
+        };
+        Point.dot = function (p0, p1) {
+            return p0.x * p1.x + p0.y * p1.y;
+        };
+        Point.add = function (out, p0, p1) {
+            out.x = p0.x + p1.x;
+            out.y = p0.y + p1.y;
+        };
+        Point.sub = function (out, p0, p1) {
+            out.x = p0.x - p1.x;
+            out.y = p0.y - p1.y;
+        };
+        Point.scale = function (out, p0, scalar) {
+            out.x = p0.x * scalar;
+            out.y = p0.y * scalar;
+        };
+        Point.scaleAndAdd = function (out, p0, p1, scalar) {
+            out.x = p0.x + p1.x * scalar;
+            out.y = p0.y + p1.y * scalar;
+        };
+        Point.lerp = function (out, p0, p1, t) {
+            var onet = 1 - t;
+            out.x = onet * p0.x + t * p1.x;
+            out.y = onet * p0.y + t * p1.y;
+        };
+        return Point;
+    }());
+
+    var mathMin = Math.min;
+    var mathMax = Math.max;
+    var lt = new Point();
+    var rb = new Point();
+    var lb = new Point();
+    var rt = new Point();
+    var minTv = new Point();
+    var maxTv = new Point();
+    var BoundingRect = (function () {
+        function BoundingRect(x, y, width, height) {
+            if (width < 0 && isFinite(width)) {
+                x = x + width;
+                width = -width;
+            }
+            if (height < 0 && isFinite(height)) {
+                y = y + height;
+                height = -height;
+            }
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+        }
+        BoundingRect.prototype.union = function (other) {
+            var x = mathMin(other.x, this.x);
+            var y = mathMin(other.y, this.y);
+            if (isFinite(this.x) && isFinite(this.width)) {
+                this.width = mathMax(other.x + other.width, this.x + this.width) - x;
+            }
+            else {
+                this.width = other.width;
+            }
+            if (isFinite(this.y) && isFinite(this.height)) {
+                this.height = mathMax(other.y + other.height, this.y + this.height) - y;
+            }
+            else {
+                this.height = other.height;
+            }
+            this.x = x;
+            this.y = y;
+        };
+        BoundingRect.prototype.applyTransform = function (m) {
+            BoundingRect.applyTransform(this, this, m);
+        };
+        BoundingRect.prototype.calculateTransform = function (b) {
+            var a = this;
+            var sx = b.width / a.width;
+            var sy = b.height / a.height;
+            var m = create$1();
+            translate(m, m, [-a.x, -a.y]);
+            scale$1(m, m, [sx, sy]);
+            translate(m, m, [b.x, b.y]);
+            return m;
+        };
+        BoundingRect.prototype.intersect = function (b, mtv) {
+            if (!b) {
+                return false;
+            }
+            if (!(b instanceof BoundingRect)) {
+                b = BoundingRect.create(b);
+            }
+            var a = this;
+            var ax0 = a.x;
+            var ax1 = a.x + a.width;
+            var ay0 = a.y;
+            var ay1 = a.y + a.height;
+            var bx0 = b.x;
+            var bx1 = b.x + b.width;
+            var by0 = b.y;
+            var by1 = b.y + b.height;
+            var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
+            if (mtv) {
+                var dMin = Infinity;
+                var dMax = 0;
+                var d0 = Math.abs(ax1 - bx0);
+                var d1 = Math.abs(bx1 - ax0);
+                var d2 = Math.abs(ay1 - by0);
+                var d3 = Math.abs(by1 - ay0);
+                var dx = Math.min(d0, d1);
+                var dy = Math.min(d2, d3);
+                if (ax1 < bx0 || bx1 < ax0) {
+                    if (dx > dMax) {
+                        dMax = dx;
+                        if (d0 < d1) {
+                            Point.set(maxTv, -d0, 0);
+                        }
+                        else {
+                            Point.set(maxTv, d1, 0);
+                        }
+                    }
+                }
+                else {
+                    if (dx < dMin) {
+                        dMin = dx;
+                        if (d0 < d1) {
+                            Point.set(minTv, d0, 0);
+                        }
+                        else {
+                            Point.set(minTv, -d1, 0);
+                        }
+                    }
+                }
+                if (ay1 < by0 || by1 < ay0) {
+                    if (dy > dMax) {
+                        dMax = dy;
+                        if (d2 < d3) {
+                            Point.set(maxTv, 0, -d2);
+                        }
+                        else {
+                            Point.set(maxTv, 0, d3);
+                        }
+                    }
+                }
+                else {
+                    if (dx < dMin) {
+                        dMin = dx;
+                        if (d2 < d3) {
+                            Point.set(minTv, 0, d2);
+                        }
+                        else {
+                            Point.set(minTv, 0, -d3);
+                        }
+                    }
+                }
+            }
+            if (mtv) {
+                Point.copy(mtv, overlap ? minTv : maxTv);
+            }
+            return overlap;
+        };
+        BoundingRect.prototype.contain = function (x, y) {
+            var rect = this;
+            return x >= rect.x
+                && x <= (rect.x + rect.width)
+                && y >= rect.y
+                && y <= (rect.y + rect.height);
+        };
+        BoundingRect.prototype.clone = function () {
+            return new BoundingRect(this.x, this.y, this.width, this.height);
+        };
+        BoundingRect.prototype.copy = function (other) {
+            BoundingRect.copy(this, other);
+        };
+        BoundingRect.prototype.plain = function () {
+            return {
+                x: this.x,
+                y: this.y,
+                width: this.width,
+                height: this.height
+            };
+        };
+        BoundingRect.prototype.isFinite = function () {
+            return isFinite(this.x)
+                && isFinite(this.y)
+                && isFinite(this.width)
+                && isFinite(this.height);
+        };
+        BoundingRect.prototype.isZero = function () {
+            return this.width === 0 || this.height === 0;
+        };
+        BoundingRect.create = function (rect) {
+            return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
+        };
+        BoundingRect.copy = function (target, source) {
+            target.x = source.x;
+            target.y = source.y;
+            target.width = source.width;
+            target.height = source.height;
+        };
+        BoundingRect.applyTransform = function (target, source, m) {
+            if (!m) {
+                if (target !== source) {
+                    BoundingRect.copy(target, source);
+                }
+                return;
+            }
+            if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
+                var sx = m[0];
+                var sy = m[3];
+                var tx = m[4];
+                var ty = m[5];
+                target.x = source.x * sx + tx;
+                target.y = source.y * sy + ty;
+                target.width = source.width * sx;
+                target.height = source.height * sy;
+                if (target.width < 0) {
+                    target.x += target.width;
+                    target.width = -target.width;
+                }
+                if (target.height < 0) {
+                    target.y += target.height;
+                    target.height = -target.height;
+                }
+                return;
+            }
+            lt.x = lb.x = source.x;
+            lt.y = rt.y = source.y;
+            rb.x = rt.x = source.x + source.width;
+            rb.y = lb.y = source.y + source.height;
+            lt.transform(m);
+            rt.transform(m);
+            rb.transform(m);
+            lb.transform(m);
+            target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
+            target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
+            var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
+            var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
+            target.width = maxX - target.x;
+            target.height = maxY - target.y;
+        };
+        return BoundingRect;
+    }());
+
+    var textWidthCache = {};
+    var DEFAULT_FONT = '12px sans-serif';
+    var _ctx;
+    var _cachedFont;
+    function defaultMeasureText(text, font) {
+        if (!_ctx) {
+            _ctx = createCanvas().getContext('2d');
+        }
+        if (_cachedFont !== font) {
+            _cachedFont = _ctx.font = font || DEFAULT_FONT;
+        }
+        return _ctx.measureText(text);
+    }
+    var methods$1 = {
+        measureText: defaultMeasureText
+    };
+    function getWidth(text, font) {
+        font = font || DEFAULT_FONT;
+        var cacheOfFont = textWidthCache[font];
+        if (!cacheOfFont) {
+            cacheOfFont = textWidthCache[font] = new LRU(500);
+        }
+        var width = cacheOfFont.get(text);
+        if (width == null) {
+            width = methods$1.measureText(text, font).width;
+            cacheOfFont.put(text, width);
+        }
+        return width;
+    }
+    function innerGetBoundingRect(text, font, textAlign, textBaseline) {
+        var width = getWidth(text, font);
+        var height = getLineHeight(font);
+        var x = adjustTextX(0, width, textAlign);
+        var y = adjustTextY(0, height, textBaseline);
+        var rect = new BoundingRect(x, y, width, height);
+        return rect;
+    }
+    function getBoundingRect(text, font, textAlign, textBaseline) {
+        var textLines = ((text || '') + '').split('\n');
+        var len = textLines.length;
+        if (len === 1) {
+            return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline);
+        }
+        else {
+            var uniondRect = new BoundingRect(0, 0, 0, 0);
+            for (var i = 0; i < textLines.length; i++) {
+                var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline);
+                i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect);
+            }
+            return uniondRect;
+        }
+    }
+    function adjustTextX(x, width, textAlign) {
+        if (textAlign === 'right') {
+            x -= width;
+        }
+        else if (textAlign === 'center') {
+            x -= width / 2;
+        }
+        return x;
+    }
+    function adjustTextY(y, height, verticalAlign) {
+        if (verticalAlign === 'middle') {
+            y -= height / 2;
+        }
+        else if (verticalAlign === 'bottom') {
+            y -= height;
+        }
+        return y;
+    }
+    function getLineHeight(font) {
+        return getWidth('国', font);
+    }
+    function parsePercent(value, maxValue) {
+        if (typeof value === 'string') {
+            if (value.lastIndexOf('%') >= 0) {
+                return parseFloat(value) / 100 * maxValue;
+            }
+            return parseFloat(value);
+        }
+        return value;
+    }
+    function calculateTextPosition(out, opts, rect) {
+        var textPosition = opts.position || 'inside';
+        var distance = opts.distance != null ? opts.distance : 5;
+        var height = rect.height;
+        var width = rect.width;
+        var halfHeight = height / 2;
+        var x = rect.x;
+        var y = rect.y;
+        var textAlign = 'left';
+        var textVerticalAlign = 'top';
+        if (textPosition instanceof Array) {
+            x += parsePercent(textPosition[0], rect.width);
+            y += parsePercent(textPosition[1], rect.height);
+            textAlign = null;
+            textVerticalAlign = null;
+        }
+        else {
+            switch (textPosition) {
+                case 'left':
+                    x -= distance;
+                    y += halfHeight;
+                    textAlign = 'right';
+                    textVerticalAlign = 'middle';
+                    break;
+                case 'right':
+                    x += distance + width;
+                    y += halfHeight;
+                    textVerticalAlign = 'middle';
+                    break;
+                case 'top':
+                    x += width / 2;
+                    y -= distance;
+                    textAlign = 'center';
+                    textVerticalAlign = 'bottom';
+                    break;
+                case 'bottom':
+                    x += width / 2;
+                    y += height + distance;
+                    textAlign = 'center';
+                    break;
+                case 'inside':
+                    x += width / 2;
+                    y += halfHeight;
+                    textAlign = 'center';
+                    textVerticalAlign = 'middle';
+                    break;
+                case 'insideLeft':
+                    x += distance;
+                    y += halfHeight;
+                    textVerticalAlign = 'middle';
+                    break;
+                case 'insideRight':
+                    x += width - distance;
+                    y += halfHeight;
+                    textAlign = 'right';
+                    textVerticalAlign = 'middle';
+                    break;
+                case 'insideTop':
+                    x += width / 2;
+                    y += distance;
+                    textAlign = 'center';
+                    break;
+                case 'insideBottom':
+                    x += width / 2;
+                    y += height - distance;
+                    textAlign = 'center';
+                    textVerticalAlign = 'bottom';
+                    break;
+                case 'insideTopLeft':
+                    x += distance;
+                    y += distance;
+                    break;
+                case 'insideTopRight':
+                    x += width - distance;
+                    y += distance;
+                    textAlign = 'right';
+                    break;
+                case 'insideBottomLeft':
+                    x += distance;
+                    y += height - distance;
+                    textVerticalAlign = 'bottom';
+                    break;
+                case 'insideBottomRight':
+                    x += width - distance;
+                    y += height - distance;
+                    textAlign = 'right';
+                    textVerticalAlign = 'bottom';
+                    break;
+            }
+        }
+        out = out || {};
+        out.x = x;
+        out.y = y;
+        out.align = textAlign;
+        out.verticalAlign = textVerticalAlign;
+        return out;
+    }
+
+    var dpr = 1;
+    if (typeof window !== 'undefined') {
+        dpr = Math.max(window.devicePixelRatio
+            || (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI)
+            || 1, 1);
+    }
+    var devicePixelRatio = dpr;
+    var DARK_MODE_THRESHOLD = 0.4;
+    var DARK_LABEL_COLOR = '#333';
+    var LIGHT_LABEL_COLOR = '#ccc';
+    var LIGHTER_LABEL_COLOR = '#eee';
+
+    var PRESERVED_NORMAL_STATE = '__zr_normal__';
+    var PRIMARY_STATES_KEYS = ['x', 'y', 'scaleX', 'scaleY', 'originX', 'originY', 'rotation', 'ignore'];
+    var DEFAULT_ANIMATABLE_MAP = {
+        x: true,
+        y: true,
+        scaleX: true,
+        scaleY: true,
+        originX: true,
+        originY: true,
+        rotation: true,
+        ignore: false
+    };
+    var tmpTextPosCalcRes = {};
+    var tmpBoundingRect = new BoundingRect(0, 0, 0, 0);
+    var Element = (function () {
+        function Element(props) {
+            this.id = guid();
+            this.animators = [];
+            this.currentStates = [];
+            this.states = {};
+            this._init(props);
+        }
+        Element.prototype._init = function (props) {
+            this.attr(props);
+        };
+        Element.prototype.drift = function (dx, dy, e) {
+            switch (this.draggable) {
+                case 'horizontal':
+                    dy = 0;
+                    break;
+                case 'vertical':
+                    dx = 0;
+                    break;
+            }
+            var m = this.transform;
+            if (!m) {
+                m = this.transform = [1, 0, 0, 1, 0, 0];
+            }
+            m[4] += dx;
+            m[5] += dy;
+            this.decomposeTransform();
+            this.markRedraw();
+        };
+        Element.prototype.beforeUpdate = function () { };
+        Element.prototype.afterUpdate = function () { };
+        Element.prototype.update = function () {
+            this.updateTransform();
+            if (this.__dirty) {
+                this.updateInnerText();
+            }
+        };
+        Element.prototype.updateInnerText = function (forceUpdate) {
+            var textEl = this._textContent;
+            if (textEl && (!textEl.ignore || forceUpdate)) {
+                if (!this.textConfig) {
+                    this.textConfig = {};
+                }
+                var textConfig = this.textConfig;
+                var isLocal = textConfig.local;
+                var attachedTransform = textEl.attachedTransform;
+                var textAlign = void 0;
+                var textVerticalAlign = void 0;
+                var textStyleChanged = false;
+                if (isLocal) {
+                    attachedTransform.parent = this;
+                }
+                else {
+                    attachedTransform.parent = null;
+                }
+                var innerOrigin = false;
+                attachedTransform.x = textEl.x;
+                attachedTransform.y = textEl.y;
+                attachedTransform.originX = textEl.originX;
+                attachedTransform.originY = textEl.originY;
+                attachedTransform.rotation = textEl.rotation;
+                attachedTransform.scaleX = textEl.scaleX;
+                attachedTransform.scaleY = textEl.scaleY;
+                if (textConfig.position != null) {
+                    var layoutRect = tmpBoundingRect;
+                    if (textConfig.layoutRect) {
+                        layoutRect.copy(textConfig.layoutRect);
+                    }
+                    else {
+                        layoutRect.copy(this.getBoundingRect());
+                    }
+                    if (!isLocal) {
+                        layoutRect.applyTransform(this.transform);
+                    }
+                    if (this.calculateTextPosition) {
+                        this.calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
+                    }
+                    else {
+                        calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
+                    }
+                    attachedTransform.x = tmpTextPosCalcRes.x;
+                    attachedTransform.y = tmpTextPosCalcRes.y;
+                    textAlign = tmpTextPosCalcRes.align;
+                    textVerticalAlign = tmpTextPosCalcRes.verticalAlign;
+                    var textOrigin = textConfig.origin;
+                    if (textOrigin && textConfig.rotation != null) {
+                        var relOriginX = void 0;
+                        var relOriginY = void 0;
+                        if (textOrigin === 'center') {
+                            relOriginX = layoutRect.width * 0.5;
+                            relOriginY = layoutRect.height * 0.5;
+                        }
+                        else {
+                            relOriginX = parsePercent(textOrigin[0], layoutRect.width);
+                            relOriginY = parsePercent(textOrigin[1], layoutRect.height);
+                        }
+                        innerOrigin = true;
+                        attachedTransform.originX = -attachedTransform.x + relOriginX + (isLocal ? 0 : layoutRect.x);
+                        attachedTransform.originY = -attachedTransform.y + relOriginY + (isLocal ? 0 : layoutRect.y);
+                    }
+                }
+                if (textConfig.rotation != null) {
+                    attachedTransform.rotation = textConfig.rotation;
+                }
+                var textOffset = textConfig.offset;
+                if (textOffset) {
+                    attachedTransform.x += textOffset[0];
+                    attachedTransform.y += textOffset[1];
+                    if (!innerOrigin) {
+                        attachedTransform.originX = -textOffset[0];
+                        attachedTransform.originY = -textOffset[1];
+                    }
+                }
+                var isInside = textConfig.inside == null
+                    ? (typeof textConfig.position === 'string' && textConfig.position.indexOf('inside') >= 0)
+                    : textConfig.inside;
+                var innerTextDefaultStyle = this._innerTextDefaultStyle || (this._innerTextDefaultStyle = {});
+                var textFill = void 0;
+                var textStroke = void 0;
+                var autoStroke = void 0;
+                if (isInside && this.canBeInsideText()) {
+                    textFill = textConfig.insideFill;
+                    textStroke = textConfig.insideStroke;
+                    if (textFill == null || textFill === 'auto') {
+                        textFill = this.getInsideTextFill();
+                    }
+                    if (textStroke == null || textStroke === 'auto') {
+                        textStroke = this.getInsideTextStroke(textFill);
+                        autoStroke = true;
+                    }
+                }
+                else {
+                    textFill = textConfig.outsideFill;
+                    textStroke = textConfig.outsideStroke;
+                    if (textFill == null || textFill === 'auto') {
+                        textFill = this.getOutsideFill();
+                    }
+                    if (textStroke == null || textStroke === 'auto') {
+                        textStroke = this.getOutsideStroke(textFill);
+                        autoStroke = true;
+                    }
+                }
+                textFill = textFill || '#000';
+                if (textFill !== innerTextDefaultStyle.fill
+                    || textStroke !== innerTextDefaultStyle.stroke
+                    || autoStroke !== innerTextDefaultStyle.autoStroke
+                    || textAlign !== innerTextDefaultStyle.align
+                    || textVerticalAlign !== innerTextDefaultStyle.verticalAlign) {
+                    textStyleChanged = true;
+                    innerTextDefaultStyle.fill = textFill;
+                    innerTextDefaultStyle.stroke = textStroke;
+                    innerTextDefaultStyle.autoStroke = autoStroke;
+                    innerTextDefaultStyle.align = textAlign;
+                    innerTextDefaultStyle.verticalAlign = textVerticalAlign;
+                    textEl.setDefaultTextStyle(innerTextDefaultStyle);
+                }
+                if (textStyleChanged) {
+                    textEl.dirtyStyle();
+                }
+                textEl.markRedraw();
+            }
+        };
+        Element.prototype.canBeInsideText = function () {
+            return true;
+        };
+        Element.prototype.getInsideTextFill = function () {
+            return '#fff';
+        };
+        Element.prototype.getInsideTextStroke = function (textFill) {
+            return '#000';
+        };
+        Element.prototype.getOutsideFill = function () {
+            return this.__zr && this.__zr.isDarkMode() ? LIGHT_LABEL_COLOR : DARK_LABEL_COLOR;
+        };
+        Element.prototype.getOutsideStroke = function (textFill) {
+            var backgroundColor = this.__zr && this.__zr.getBackgroundColor();
+            var colorArr = typeof backgroundColor === 'string' && parse(backgroundColor);
+            if (!colorArr) {
+                colorArr = [255, 255, 255, 1];
+            }
+            var alpha = colorArr[3];
+            var isDark = this.__zr.isDarkMode();
+            for (var i = 0; i < 3; i++) {
+                colorArr[i] = colorArr[i] * alpha + (isDark ? 0 : 255) * (1 - alpha);
+            }
+            colorArr[3] = 1;
+            return stringify(colorArr, 'rgba');
+        };
+        Element.prototype.traverse = function (cb, context) { };
+        Element.prototype.attrKV = function (key, value) {
+            if (key === 'textConfig') {
+                this.setTextConfig(value);
+            }
+            else if (key === 'textContent') {
+                this.setTextContent(value);
+            }
+            else if (key === 'clipPath') {
+                this.setClipPath(value);
+            }
+            else if (key === 'extra') {
+                this.extra = this.extra || {};
+                extend(this.extra, value);
+            }
+            else {
+                this[key] = value;
+            }
+        };
+        Element.prototype.hide = function () {
+            this.ignore = true;
+            this.markRedraw();
+        };
+        Element.prototype.show = function () {
+            this.ignore = false;
+            this.markRedraw();
+        };
+        Element.prototype.attr = function (keyOrObj, value) {
+            if (typeof keyOrObj === 'string') {
+                this.attrKV(keyOrObj, value);
+            }
+            else if (isObject(keyOrObj)) {
+                var obj = keyOrObj;
+                var keysArr = keys(obj);
+                for (var i = 0; i < keysArr.length; i++) {
+                    var key = keysArr[i];
+                    this.attrKV(key, keyOrObj[key]);
+                }
+            }
+            this.markRedraw();
+            return this;
+        };
+        Element.prototype.saveCurrentToNormalState = function (toState) {
+            this._innerSaveToNormal(toState);
+            var normalState = this._normalState;
+            for (var i = 0; i < this.animators.length; i++) {
+                var animator = this.animators[i];
+                var fromStateTransition = animator.__fromStateTransition;
+                if (fromStateTransition && fromStateTransition !== PRESERVED_NORMAL_STATE) {
+                    continue;
+                }
+                var targetName = animator.targetName;
+                var target = targetName
+                    ? normalState[targetName] : normalState;
+                animator.saveFinalToTarget(target);
+            }
+        };
+        Element.prototype._innerSaveToNormal = function (toState) {
+            var normalState = this._normalState;
+            if (!normalState) {
+                normalState = this._normalState = {};
+            }
+            if (toState.textConfig && !normalState.textConfig) {
+                normalState.textConfig = this.textConfig;
+            }
+            this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
+        };
+        Element.prototype._savePrimaryToNormal = function (toState, normalState, primaryKeys) {
+            for (var i = 0; i < primaryKeys.length; i++) {
+                var key = primaryKeys[i];
+                if (toState[key] != null && !(key in normalState)) {
+                    normalState[key] = this[key];
+                }
+            }
+        };
+        Element.prototype.hasState = function () {
+            return this.currentStates.length > 0;
+        };
+        Element.prototype.getState = function (name) {
+            return this.states[name];
+        };
+        Element.prototype.ensureState = function (name) {
+            var states = this.states;
+            if (!states[name]) {
+                states[name] = {};
+            }
+            return states[name];
+        };
+        Element.prototype.clearStates = function (noAnimation) {
+            this.useState(PRESERVED_NORMAL_STATE, false, noAnimation);
+        };
+        Element.prototype.useState = function (stateName, keepCurrentStates, noAnimation) {
+            var toNormalState = stateName === PRESERVED_NORMAL_STATE;
+            var hasStates = this.hasState();
+            if (!hasStates && toNormalState) {
+                return;
+            }
+            var currentStates = this.currentStates;
+            var animationCfg = this.stateTransition;
+            if (indexOf(currentStates, stateName) >= 0 && (keepCurrentStates || currentStates.length === 1)) {
+                return;
+            }
+            var state;
+            if (this.stateProxy && !toNormalState) {
+                state = this.stateProxy(stateName);
+            }
+            if (!state) {
+                state = (this.states && this.states[stateName]);
+            }
+            if (!state && !toNormalState) {
+                logError("State " + stateName + " not exists.");
+                return;
+            }
+            if (!toNormalState) {
+                this.saveCurrentToNormalState(state);
+            }
+            var useHoverLayer = !!(state && state.hoverLayer);
+            if (useHoverLayer) {
+                this._toggleHoverLayerFlag(true);
+            }
+            this._applyStateObj(stateName, state, this._normalState, keepCurrentStates, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
+            if (this._textContent) {
+                this._textContent.useState(stateName, keepCurrentStates);
+            }
+            if (this._textGuide) {
+                this._textGuide.useState(stateName, keepCurrentStates);
+            }
+            if (toNormalState) {
+                this.currentStates = [];
+                this._normalState = {};
+            }
+            else {
+                if (!keepCurrentStates) {
+                    this.currentStates = [stateName];
+                }
+                else {
+                    this.currentStates.push(stateName);
+                }
+            }
+            this._updateAnimationTargets();
+            this.markRedraw();
+            if (!useHoverLayer && this.__inHover) {
+                this._toggleHoverLayerFlag(false);
+                this.__dirty &= ~Element.REDARAW_BIT;
+            }
+            return state;
+        };
+        Element.prototype.useStates = function (states, noAnimation) {
+            if (!states.length) {
+                this.clearStates();
+            }
+            else {
+                var stateObjects = [];
+                var currentStates = this.currentStates;
+                var len = states.length;
+                var notChange = len === currentStates.length;
+                if (notChange) {
+                    for (var i = 0; i < len; i++) {
+                        if (states[i] !== currentStates[i]) {
+                            notChange = false;
+                            break;
+                        }
+                    }
+                }
+                if (notChange) {
+                    return;
+                }
+                for (var i = 0; i < len; i++) {
+                    var stateName = states[i];
+                    var stateObj = void 0;
+                    if (this.stateProxy) {
+                        stateObj = this.stateProxy(stateName, states);
+                    }
+                    if (!stateObj) {
+                        stateObj = this.states[stateName];
+                    }
+                    if (stateObj) {
+                        stateObjects.push(stateObj);
+                    }
+                }
+                var useHoverLayer = !!(stateObjects[len - 1] && stateObjects[len - 1].hoverLayer);
+                if (useHoverLayer) {
+                    this._toggleHoverLayerFlag(true);
+                }
+                var mergedState = this._mergeStates(stateObjects);
+                var animationCfg = this.stateTransition;
+                this.saveCurrentToNormalState(mergedState);
+                this._applyStateObj(states.join(','), mergedState, this._normalState, false, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
+                if (this._textContent) {
+                    this._textContent.useStates(states);
+                }
+                if (this._textGuide) {
+                    this._textGuide.useStates(states);
+                }
+                this._updateAnimationTargets();
+                this.currentStates = states.slice();
+                this.markRedraw();
+                if (!useHoverLayer && this.__inHover) {
+                    this._toggleHoverLayerFlag(false);
+                    this.__dirty &= ~Element.REDARAW_BIT;
+                }
+            }
+        };
+        Element.prototype._updateAnimationTargets = function () {
+            for (var i = 0; i < this.animators.length; i++) {
+                var animator = this.animators[i];
+                if (animator.targetName) {
+                    animator.changeTarget(this[animator.targetName]);
+                }
+            }
+        };
+        Element.prototype.removeState = function (state) {
+            var idx = indexOf(this.currentStates, state);
+            if (idx >= 0) {
+                var currentStates = this.currentStates.slice();
+                currentStates.splice(idx, 1);
+                this.useStates(currentStates);
+            }
+        };
+        Element.prototype.replaceState = function (oldState, newState, forceAdd) {
+            var currentStates = this.currentStates.slice();
+            var idx = indexOf(currentStates, oldState);
+            var newStateExists = indexOf(currentStates, newState) >= 0;
+            if (idx >= 0) {
+                if (!newStateExists) {
+                    currentStates[idx] = newState;
+                }
+                else {
+                    currentStates.splice(idx, 1);
+                }
+            }
+            else if (forceAdd && !newStateExists) {
+                currentStates.push(newState);
+            }
+            this.useStates(currentStates);
+        };
+        Element.prototype.toggleState = function (state, enable) {
+            if (enable) {
+                this.useState(state, true);
+            }
+            else {
+                this.removeState(state);
+            }
+        };
+        Element.prototype._mergeStates = function (states) {
+            var mergedState = {};
+            var mergedTextConfig;
+            for (var i = 0; i < states.length; i++) {
+                var state = states[i];
+                extend(mergedState, state);
+                if (state.textConfig) {
+                    mergedTextConfig = mergedTextConfig || {};
+                    extend(mergedTextConfig, state.textConfig);
+                }
+            }
+            if (mergedTextConfig) {
+                mergedState.textConfig = mergedTextConfig;
+            }
+            return mergedState;
+        };
+        Element.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+            var needsRestoreToNormal = !(state && keepCurrentStates);
+            if (state && state.textConfig) {
+                this.textConfig = extend({}, keepCurrentStates ? this.textConfig : normalState.textConfig);
+                extend(this.textConfig, state.textConfig);
+            }
+            else if (needsRestoreToNormal) {
+                if (normalState.textConfig) {
+                    this.textConfig = normalState.textConfig;
+                }
+            }
+            var transitionTarget = {};
+            var hasTransition = false;
+            for (var i = 0; i < PRIMARY_STATES_KEYS.length; i++) {
+                var key = PRIMARY_STATES_KEYS[i];
+                var propNeedsTransition = transition && DEFAULT_ANIMATABLE_MAP[key];
+                if (state && state[key] != null) {
+                    if (propNeedsTransition) {
+                        hasTransition = true;
+                        transitionTarget[key] = state[key];
+                    }
+                    else {
+                        this[key] = state[key];
+                    }
+                }
+                else if (needsRestoreToNormal) {
+                    if (normalState[key] != null) {
+                        if (propNeedsTransition) {
+                            hasTransition = true;
+                            transitionTarget[key] = normalState[key];
+                        }
+                        else {
+                            this[key] = normalState[key];
+                        }
+                    }
+                }
+            }
+            if (!transition) {
+                for (var i = 0; i < this.animators.length; i++) {
+                    var animator = this.animators[i];
+                    var targetName = animator.targetName;
+                    animator.__changeFinalValue(targetName
+                        ? (state || normalState)[targetName]
+                        : (state || normalState));
+                }
+            }
+            if (hasTransition) {
+                this._transitionState(stateName, transitionTarget, animationCfg);
+            }
+        };
+        Element.prototype._attachComponent = function (componentEl) {
+            if (componentEl.__zr && !componentEl.__hostTarget) {
+                throw new Error('Text element has been added to zrender.');
+            }
+            if (componentEl === this) {
+                throw new Error('Recursive component attachment.');
+            }
+            var zr = this.__zr;
+            if (zr) {
+                componentEl.addSelfToZr(zr);
+            }
+            componentEl.__zr = zr;
+            componentEl.__hostTarget = this;
+        };
+        Element.prototype._detachComponent = function (componentEl) {
+            if (componentEl.__zr) {
+                componentEl.removeSelfFromZr(componentEl.__zr);
+            }
+            componentEl.__zr = null;
+            componentEl.__hostTarget = null;
+        };
+        Element.prototype.getClipPath = function () {
+            return this._clipPath;
+        };
+        Element.prototype.setClipPath = function (clipPath) {
+            if (this._clipPath && this._clipPath !== clipPath) {
+                this.removeClipPath();
+            }
+            this._attachComponent(clipPath);
+            this._clipPath = clipPath;
+            this.markRedraw();
+        };
+        Element.prototype.removeClipPath = function () {
+            var clipPath = this._clipPath;
+            if (clipPath) {
+                this._detachComponent(clipPath);
+                this._clipPath = null;
+                this.markRedraw();
+            }
+        };
+        Element.prototype.getTextContent = function () {
+            return this._textContent;
+        };
+        Element.prototype.setTextContent = function (textEl) {
+            var previousTextContent = this._textContent;
+            if (previousTextContent === textEl) {
+                return;
+            }
+            if (previousTextContent && previousTextContent !== textEl) {
+                this.removeTextContent();
+            }
+            if (textEl.__zr && !textEl.__hostTarget) {
+                throw new Error('Text element has been added to zrender.');
+            }
+            textEl.attachedTransform = new Transformable();
+            this._attachComponent(textEl);
+            this._textContent = textEl;
+            this.markRedraw();
+        };
+        Element.prototype.setTextConfig = function (cfg) {
+            if (!this.textConfig) {
+                this.textConfig = {};
+            }
+            extend(this.textConfig, cfg);
+            this.markRedraw();
+        };
+        Element.prototype.removeTextContent = function () {
+            var textEl = this._textContent;
+            if (textEl) {
+                textEl.attachedTransform = null;
+                this._detachComponent(textEl);
+                this._textContent = null;
+                this._innerTextDefaultStyle = null;
+                this.markRedraw();
+            }
+        };
+        Element.prototype.getTextGuideLine = function () {
+            return this._textGuide;
+        };
+        Element.prototype.setTextGuideLine = function (guideLine) {
+            if (this._textGuide && this._textGuide !== guideLine) {
+                this.removeTextGuideLine();
+            }
+            this._attachComponent(guideLine);
+            this._textGuide = guideLine;
+            this.markRedraw();
+        };
+        Element.prototype.removeTextGuideLine = function () {
+            var textGuide = this._textGuide;
+            if (textGuide) {
+                this._detachComponent(textGuide);
+                this._textGuide = null;
+                this.markRedraw();
+            }
+        };
+        Element.prototype.markRedraw = function () {
+            this.__dirty |= Element.REDARAW_BIT;
+            var zr = this.__zr;
+            if (zr) {
+                if (this.__inHover) {
+                    zr.refreshHover();
+                }
+                else {
+                    zr.refresh();
+                }
+            }
+            if (this.__hostTarget) {
+                this.__hostTarget.markRedraw();
+            }
+        };
+        Element.prototype.dirty = function () {
+            this.markRedraw();
+        };
+        Element.prototype._toggleHoverLayerFlag = function (inHover) {
+            this.__inHover = inHover;
+            var textContent = this._textContent;
+            var textGuide = this._textGuide;
+            if (textContent) {
+                textContent.__inHover = inHover;
+            }
+            if (textGuide) {
+                textGuide.__inHover = inHover;
+            }
+        };
+        Element.prototype.addSelfToZr = function (zr) {
+            this.__zr = zr;
+            var animators = this.animators;
+            if (animators) {
+                for (var i = 0; i < animators.length; i++) {
+                    zr.animation.addAnimator(animators[i]);
+                }
+            }
+            if (this._clipPath) {
+                this._clipPath.addSelfToZr(zr);
+            }
+            if (this._textContent) {
+                this._textContent.addSelfToZr(zr);
+            }
+            if (this._textGuide) {
+                this._textGuide.addSelfToZr(zr);
+            }
+        };
+        Element.prototype.removeSelfFromZr = function (zr) {
+            this.__zr = null;
+            var animators = this.animators;
+            if (animators) {
+                for (var i = 0; i < animators.length; i++) {
+                    zr.animation.removeAnimator(animators[i]);
+                }
+            }
+            if (this._clipPath) {
+                this._clipPath.removeSelfFromZr(zr);
+            }
+            if (this._textContent) {
+                this._textContent.removeSelfFromZr(zr);
+            }
+            if (this._textGuide) {
+                this._textGuide.removeSelfFromZr(zr);
+            }
+        };
+        Element.prototype.animate = function (key, loop) {
+            var target = key ? this[key] : this;
+            if (!target) {
+                logError('Property "'
+                    + key
+                    + '" is not existed in element '
+                    + this.id);
+                return;
+            }
+            var animator = new Animator(target, loop);
+            this.addAnimator(animator, key);
+            return animator;
+        };
+        Element.prototype.addAnimator = function (animator, key) {
+            var zr = this.__zr;
+            var el = this;
+            animator.during(function () {
+                el.updateDuringAnimation(key);
+            }).done(function () {
+                var animators = el.animators;
+                var idx = indexOf(animators, animator);
+                if (idx >= 0) {
+                    animators.splice(idx, 1);
+                }
+            });
+            this.animators.push(animator);
+            if (zr) {
+                zr.animation.addAnimator(animator);
+            }
+            zr && zr.wakeUp();
+        };
+        Element.prototype.updateDuringAnimation = function (key) {
+            this.markRedraw();
+        };
+        Element.prototype.stopAnimation = function (scope, forwardToLast) {
+            var animators = this.animators;
+            var len = animators.length;
+            var leftAnimators = [];
+            for (var i = 0; i < len; i++) {
+                var animator = animators[i];
+                if (!scope || scope === animator.scope) {
+                    animator.stop(forwardToLast);
+                }
+                else {
+                    leftAnimators.push(animator);
+                }
+            }
+            this.animators = leftAnimators;
+            return this;
+        };
+        Element.prototype.animateTo = function (target, cfg, animationProps) {
+            animateTo(this, target, cfg, animationProps);
+        };
+        Element.prototype.animateFrom = function (target, cfg, animationProps) {
+            animateTo(this, target, cfg, animationProps, true);
+        };
+        Element.prototype._transitionState = function (stateName, target, cfg, animationProps) {
+            var animators = animateTo(this, target, cfg, animationProps);
+            for (var i = 0; i < animators.length; i++) {
+                animators[i].__fromStateTransition = stateName;
+            }
+        };
+        Element.prototype.getBoundingRect = function () {
+            return null;
+        };
+        Element.prototype.getPaintRect = function () {
+            return null;
+        };
+        Element.REDARAW_BIT = 1;
+        Element.initDefaultProps = (function () {
+            var elProto = Element.prototype;
+            elProto.type = 'element';
+            elProto.name = '';
+            elProto.ignore = false;
+            elProto.silent = false;
+            elProto.isGroup = false;
+            elProto.draggable = false;
+            elProto.dragging = false;
+            elProto.ignoreClip = false;
+            elProto.__inHover = false;
+            elProto.__dirty = Element.REDARAW_BIT;
+            var logs = {};
+            function logDeprecatedError(key, xKey, yKey) {
+                if (!logs[key + xKey + yKey]) {
+                    console.warn("DEPRECATED: '" + key + "' has been deprecated. use '" + xKey + "', '" + yKey + "' instead");
+                    logs[key + xKey + yKey] = true;
+                }
+            }
+            function createLegacyProperty(key, privateKey, xKey, yKey) {
+                Object.defineProperty(elProto, key, {
+                    get: function () {
+                        logDeprecatedError(key, xKey, yKey);
+                        if (!this[privateKey]) {
+                            var pos = this[privateKey] = [];
+                            enhanceArray(this, pos);
+                        }
+                        return this[privateKey];
+                    },
+                    set: function (pos) {
+                        logDeprecatedError(key, xKey, yKey);
+                        this[xKey] = pos[0];
+                        this[yKey] = pos[1];
+                        this[privateKey] = pos;
+                        enhanceArray(this, pos);
+                    }
+                });
+                function enhanceArray(self, pos) {
+                    Object.defineProperty(pos, 0, {
+                        get: function () {
+                            return self[xKey];
+                        },
+                        set: function (val) {
+                            self[xKey] = val;
+                        }
+                    });
+                    Object.defineProperty(pos, 1, {
+                        get: function () {
+                            return self[yKey];
+                        },
+                        set: function (val) {
+                            self[yKey] = val;
+                        }
+                    });
+                }
+            }
+            if (Object.defineProperty && (!env.browser.ie || env.browser.version > 8)) {
+                createLegacyProperty('position', '_legacyPos', 'x', 'y');
+                createLegacyProperty('scale', '_legacyScale', 'scaleX', 'scaleY');
+                createLegacyProperty('origin', '_legacyOrigin', 'originX', 'originY');
+            }
+        })();
+        return Element;
+    }());
+    mixin(Element, Eventful);
+    mixin(Element, Transformable);
+    function animateTo(animatable, target, cfg, animationProps, reverse) {
+        cfg = cfg || {};
+        var animators = [];
+        animateToShallow(animatable, '', animatable, target, cfg, animationProps, animators, reverse);
+        var finishCount = animators.length;
+        var doneHappened = false;
+        var cfgDone = cfg.done;
+        var cfgAborted = cfg.aborted;
+        var doneCb = function () {
+            doneHappened = true;
+            finishCount--;
+            if (finishCount <= 0) {
+                doneHappened
+                    ? (cfgDone && cfgDone())
+                    : (cfgAborted && cfgAborted());
+            }
+        };
+        var abortedCb = function () {
+            finishCount--;
+            if (finishCount <= 0) {
+                doneHappened
+                    ? (cfgDone && cfgDone())
+                    : (cfgAborted && cfgAborted());
+            }
+        };
+        if (!finishCount) {
+            cfgDone && cfgDone();
+        }
+        if (animators.length > 0 && cfg.during) {
+            animators[0].during(function (target, percent) {
+                cfg.during(percent);
+            });
+        }
+        for (var i = 0; i < animators.length; i++) {
+            var animator = animators[i];
+            if (doneCb) {
+                animator.done(doneCb);
+            }
+            if (abortedCb) {
+                animator.aborted(abortedCb);
+            }
+            animator.start(cfg.easing, cfg.force);
+        }
+        return animators;
+    }
+    function copyArrShallow(source, target, len) {
+        for (var i = 0; i < len; i++) {
+            source[i] = target[i];
+        }
+    }
+    function is2DArray(value) {
+        return isArrayLike(value[0]);
+    }
+    function copyValue(target, source, key) {
+        if (isArrayLike(source[key])) {
+            if (!isArrayLike(target[key])) {
+                target[key] = [];
+            }
+            if (isTypedArray(source[key])) {
+                var len = source[key].length;
+                if (target[key].length !== len) {
+                    target[key] = new (source[key].constructor)(len);
+                    copyArrShallow(target[key], source[key], len);
+                }
+            }
+            else {
+                var sourceArr = source[key];
+                var targetArr = target[key];
+                var len0 = sourceArr.length;
+                if (is2DArray(sourceArr)) {
+                    var len1 = sourceArr[0].length;
+                    for (var i = 0; i < len0; i++) {
+                        if (!targetArr[i]) {
+                            targetArr[i] = Array.prototype.slice.call(sourceArr[i]);
+                        }
+                        else {
+                            copyArrShallow(targetArr[i], sourceArr[i], len1);
+                        }
+                    }
+                }
+                else {
+                    copyArrShallow(targetArr, sourceArr, len0);
+                }
+                targetArr.length = sourceArr.length;
+            }
+        }
+        else {
+            target[key] = source[key];
+        }
+    }
+    function animateToShallow(animatable, topKey, source, target, cfg, animationProps, animators, reverse) {
+        var animatableKeys = [];
+        var changedKeys = [];
+        var targetKeys = keys(target);
+        var duration = cfg.duration;
+        var delay = cfg.delay;
+        var additive = cfg.additive;
+        var setToFinal = cfg.setToFinal;
+        var animateAll = !isObject(animationProps);
+        for (var k = 0; k < targetKeys.length; k++) {
+            var innerKey = targetKeys[k];
+            if (source[innerKey] != null
+                && target[innerKey] != null
+                && (animateAll || animationProps[innerKey])) {
+                if (isObject(target[innerKey]) && !isArrayLike(target[innerKey])) {
+                    if (topKey) {
+                        if (!reverse) {
+                            source[innerKey] = target[innerKey];
+                            animatable.updateDuringAnimation(topKey);
+                        }
+                        continue;
+                    }
+                    animateToShallow(animatable, innerKey, source[innerKey], target[innerKey], cfg, animationProps && animationProps[innerKey], animators, reverse);
+                }
+                else {
+                    animatableKeys.push(innerKey);
+                    changedKeys.push(innerKey);
+                }
+            }
+            else if (!reverse) {
+                source[innerKey] = target[innerKey];
+                animatable.updateDuringAnimation(topKey);
+                changedKeys.push(innerKey);
+            }
+        }
+        var keyLen = animatableKeys.length;
+        if (keyLen > 0
+            || (cfg.force && !animators.length)) {
+            var existsAnimators = animatable.animators;
+            var existsAnimatorsOnSameTarget = [];
+            for (var i = 0; i < existsAnimators.length; i++) {
+                if (existsAnimators[i].targetName === topKey) {
+                    existsAnimatorsOnSameTarget.push(existsAnimators[i]);
+                }
+            }
+            if (!additive && existsAnimatorsOnSameTarget.length) {
+                for (var i = 0; i < existsAnimatorsOnSameTarget.length; i++) {
+                    var allAborted = existsAnimatorsOnSameTarget[i].stopTracks(changedKeys);
+                    if (allAborted) {
+                        var idx = indexOf(existsAnimators, existsAnimatorsOnSameTarget[i]);
+                        existsAnimators.splice(idx, 1);
+                    }
+                }
+            }
+            var revertedSource = void 0;
+            var reversedTarget = void 0;
+            var sourceClone = void 0;
+            if (reverse) {
+                reversedTarget = {};
+                if (setToFinal) {
+                    revertedSource = {};
+                }
+                for (var i = 0; i < keyLen; i++) {
+                    var innerKey = animatableKeys[i];
+                    reversedTarget[innerKey] = source[innerKey];
+                    if (setToFinal) {
+                        revertedSource[innerKey] = target[innerKey];
+                    }
+                    else {
+                        source[innerKey] = target[innerKey];
+                    }
+                }
+            }
+            else if (setToFinal) {
+                sourceClone = {};
+                for (var i = 0; i < keyLen; i++) {
+                    var innerKey = animatableKeys[i];
+                    sourceClone[innerKey] = cloneValue(source[innerKey]);
+                    copyValue(source, target, innerKey);
+                }
+            }
+            var animator = new Animator(source, false, additive ? existsAnimatorsOnSameTarget : null);
+            animator.targetName = topKey;
+            if (cfg.scope) {
+                animator.scope = cfg.scope;
+            }
+            if (setToFinal && revertedSource) {
+                animator.whenWithKeys(0, revertedSource, animatableKeys);
+            }
+            if (sourceClone) {
+                animator.whenWithKeys(0, sourceClone, animatableKeys);
+            }
+            animator.whenWithKeys(duration == null ? 500 : duration, reverse ? reversedTarget : target, animatableKeys).delay(delay || 0);
+            animatable.addAnimator(animator, topKey);
+            animators.push(animator);
+        }
+    }
+
+    var DEFAULT_MIN_MERGE = 32;
+    var DEFAULT_MIN_GALLOPING = 7;
+    function minRunLength(n) {
+        var r = 0;
+        while (n >= DEFAULT_MIN_MERGE) {
+            r |= n & 1;
+            n >>= 1;
+        }
+        return n + r;
+    }
+    function makeAscendingRun(array, lo, hi, compare) {
+        var runHi = lo + 1;
+        if (runHi === hi) {
+            return 1;
+        }
+        if (compare(array[runHi++], array[lo]) < 0) {
+            while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
+                runHi++;
+            }
+            reverseRun(array, lo, runHi);
+        }
+        else {
+            while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
+                runHi++;
+            }
+        }
+        return runHi - lo;
+    }
+    function reverseRun(array, lo, hi) {
+        hi--;
+        while (lo < hi) {
+            var t = array[lo];
+            array[lo++] = array[hi];
+            array[hi--] = t;
+        }
+    }
+    function binaryInsertionSort(array, lo, hi, start, compare) {
+        if (start === lo) {
+            start++;
+        }
+        for (; start < hi; start++) {
+            var pivot = array[start];
+            var left = lo;
+            var right = start;
+            var mid;
+            while (left < right) {
+                mid = left + right >>> 1;
+                if (compare(pivot, array[mid]) < 0) {
+                    right = mid;
+                }
+                else {
+                    left = mid + 1;
+                }
+            }
+            var n = start - left;
+            switch (n) {
+                case 3:
+                    array[left + 3] = array[left + 2];
+                case 2:
+                    array[left + 2] = array[left + 1];
+                case 1:
+                    array[left + 1] = array[left];
+                    break;
+                default:
+                    while (n > 0) {
+                        array[left + n] = array[left + n - 1];
+                        n--;
+                    }
+            }
+            array[left] = pivot;
+        }
+    }
+    function gallopLeft(value, array, start, length, hint, compare) {
+        var lastOffset = 0;
+        var maxOffset = 0;
+        var offset = 1;
+        if (compare(value, array[start + hint]) > 0) {
+            maxOffset = length - hint;
+            while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+                lastOffset = offset;
+                offset = (offset << 1) + 1;
+                if (offset <= 0) {
+                    offset = maxOffset;
+                }
+            }
+            if (offset > maxOffset) {
+                offset = maxOffset;
+            }
+            lastOffset += hint;
+            offset += hint;
+        }
+        else {
+            maxOffset = hint + 1;
+            while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+                lastOffset = offset;
+                offset = (offset << 1) + 1;
+                if (offset <= 0) {
+                    offset = maxOffset;
+                }
+            }
+            if (offset > maxOffset) {
+                offset = maxOffset;
+            }
+            var tmp = lastOffset;
+            lastOffset = hint - offset;
+            offset = hint - tmp;
+        }
+        lastOffset++;
+        while (lastOffset < offset) {
+            var m = lastOffset + (offset - lastOffset >>> 1);
+            if (compare(value, array[start + m]) > 0) {
+                lastOffset = m + 1;
+            }
+            else {
+                offset = m;
+            }
+        }
+        return offset;
+    }
+    function gallopRight(value, array, start, length, hint, compare) {
+        var lastOffset = 0;
+        var maxOffset = 0;
+        var offset = 1;
+        if (compare(value, array[start + hint]) < 0) {
+            maxOffset = hint + 1;
+            while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+                lastOffset = offset;
+                offset = (offset << 1) + 1;
+                if (offset <= 0) {
+                    offset = maxOffset;
+                }
+            }
+            if (offset > maxOffset) {
+                offset = maxOffset;
+            }
+            var tmp = lastOffset;
+            lastOffset = hint - offset;
+            offset = hint - tmp;
+        }
+        else {
+            maxOffset = length - hint;
+            while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+                lastOffset = offset;
+                offset = (offset << 1) + 1;
+                if (offset <= 0) {
+                    offset = maxOffset;
+                }
+            }
+            if (offset > maxOffset) {
+                offset = maxOffset;
+            }
+            lastOffset += hint;
+            offset += hint;
+        }
+        lastOffset++;
+        while (lastOffset < offset) {
+            var m = lastOffset + (offset - lastOffset >>> 1);
+            if (compare(value, array[start + m]) < 0) {
+                offset = m;
+            }
+            else {
+                lastOffset = m + 1;
+            }
+        }
+        return offset;
+    }
+    function TimSort(array, compare) {
+        var minGallop = DEFAULT_MIN_GALLOPING;
+        var length = 0;
+        var runStart;
+        var runLength;
+        var stackSize = 0;
+        length = array.length;
+        var tmp = [];
+        runStart = [];
+        runLength = [];
+        function pushRun(_runStart, _runLength) {
+            runStart[stackSize] = _runStart;
+            runLength[stackSize] = _runLength;
+            stackSize += 1;
+        }
+        function mergeRuns() {
+            while (stackSize > 1) {
+                var n = stackSize - 2;
+                if ((n >= 1 && runLength[n - 1] <= runLength[n] + runLength[n + 1])
+                    || (n >= 2 && runLength[n - 2] <= runLength[n] + runLength[n - 1])) {
+                    if (runLength[n - 1] < runLength[n + 1]) {
+                        n--;
+                    }
+                }
+                else if (runLength[n] > runLength[n + 1]) {
+                    break;
+                }
+                mergeAt(n);
+            }
+        }
+        function forceMergeRuns() {
+            while (stackSize > 1) {
+                var n = stackSize - 2;
+                if (n > 0 && runLength[n - 1] < runLength[n + 1]) {
+                    n--;
+                }
+                mergeAt(n);
+            }
+        }
+        function mergeAt(i) {
+            var start1 = runStart[i];
+            var length1 = runLength[i];
+            var start2 = runStart[i + 1];
+            var length2 = runLength[i + 1];
+            runLength[i] = length1 + length2;
+            if (i === stackSize - 3) {
+                runStart[i + 1] = runStart[i + 2];
+                runLength[i + 1] = runLength[i + 2];
+            }
+            stackSize--;
+            var k = gallopRight(array[start2], array, start1, length1, 0, compare);
+            start1 += k;
+            length1 -= k;
+            if (length1 === 0) {
+                return;
+            }
+            length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+            if (length2 === 0) {
+                return;
+            }
+            if (length1 <= length2) {
+                mergeLow(start1, length1, start2, length2);
+            }
+            else {
+                mergeHigh(start1, length1, start2, length2);
+            }
+        }
+        function mergeLow(start1, length1, start2, length2) {
+            var i = 0;
+            for (i = 0; i < length1; i++) {
+                tmp[i] = array[start1 + i];
+            }
+            var cursor1 = 0;
+            var cursor2 = start2;
+            var dest = start1;
+            array[dest++] = array[cursor2++];
+            if (--length2 === 0) {
+                for (i = 0; i < length1; i++) {
+                    array[dest + i] = tmp[cursor1 + i];
+                }
+                return;
+            }
+            if (length1 === 1) {
+                for (i = 0; i < length2; i++) {
+                    array[dest + i] = array[cursor2 + i];
+                }
+                array[dest + length2] = tmp[cursor1];
+                return;
+            }
+            var _minGallop = minGallop;
+            var count1;
+            var count2;
+            var exit;
+            while (1) {
+                count1 = 0;
+                count2 = 0;
+                exit = false;
+                do {
+                    if (compare(array[cursor2], tmp[cursor1]) < 0) {
+                        array[dest++] = array[cursor2++];
+                        count2++;
+                        count1 = 0;
+                        if (--length2 === 0) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    else {
+                        array[dest++] = tmp[cursor1++];
+                        count1++;
+                        count2 = 0;
+                        if (--length1 === 1) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                } while ((count1 | count2) < _minGallop);
+                if (exit) {
+                    break;
+                }
+                do {
+                    count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+                    if (count1 !== 0) {
+                        for (i = 0; i < count1; i++) {
+                            array[dest + i] = tmp[cursor1 + i];
+                        }
+                        dest += count1;
+                        cursor1 += count1;
+                        length1 -= count1;
+                        if (length1 <= 1) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    array[dest++] = array[cursor2++];
+                    if (--length2 === 0) {
+                        exit = true;
+                        break;
+                    }
+                    count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+                    if (count2 !== 0) {
+                        for (i = 0; i < count2; i++) {
+                            array[dest + i] = array[cursor2 + i];
+                        }
+                        dest += count2;
+                        cursor2 += count2;
+                        length2 -= count2;
+                        if (length2 === 0) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    array[dest++] = tmp[cursor1++];
+                    if (--length1 === 1) {
+                        exit = true;
+                        break;
+                    }
+                    _minGallop--;
+                } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+                if (exit) {
+                    break;
+                }
+                if (_minGallop < 0) {
+                    _minGallop = 0;
+                }
+                _minGallop += 2;
+            }
+            minGallop = _minGallop;
+            minGallop < 1 && (minGallop = 1);
+            if (length1 === 1) {
+                for (i = 0; i < length2; i++) {
+                    array[dest + i] = array[cursor2 + i];
+                }
+                array[dest + length2] = tmp[cursor1];
+            }
+            else if (length1 === 0) {
+                throw new Error();
+            }
+            else {
+                for (i = 0; i < length1; i++) {
+                    array[dest + i] = tmp[cursor1 + i];
+                }
+            }
+        }
+        function mergeHigh(start1, length1, start2, length2) {
+            var i = 0;
+            for (i = 0; i < length2; i++) {
+                tmp[i] = array[start2 + i];
+            }
+            var cursor1 = start1 + length1 - 1;
+            var cursor2 = length2 - 1;
+            var dest = start2 + length2 - 1;
+            var customCursor = 0;
+            var customDest = 0;
+            array[dest--] = array[cursor1--];
+            if (--length1 === 0) {
+                customCursor = dest - (length2 - 1);
+                for (i = 0; i < length2; i++) {
+                    array[customCursor + i] = tmp[i];
+                }
+                return;
+            }
+            if (length2 === 1) {
+                dest -= length1;
+                cursor1 -= length1;
+                customDest = dest + 1;
+                customCursor = cursor1 + 1;
+                for (i = length1 - 1; i >= 0; i--) {
+                    array[customDest + i] = array[customCursor + i];
+                }
+                array[dest] = tmp[cursor2];
+                return;
+            }
+            var _minGallop = minGallop;
+            while (true) {
+                var count1 = 0;
+                var count2 = 0;
+                var exit = false;
+                do {
+                    if (compare(tmp[cursor2], array[cursor1]) < 0) {
+                        array[dest--] = array[cursor1--];
+                        count1++;
+                        count2 = 0;
+                        if (--length1 === 0) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    else {
+                        array[dest--] = tmp[cursor2--];
+                        count2++;
+                        count1 = 0;
+                        if (--length2 === 1) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                } while ((count1 | count2) < _minGallop);
+                if (exit) {
+                    break;
+                }
+                do {
+                    count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+                    if (count1 !== 0) {
+                        dest -= count1;
+                        cursor1 -= count1;
+                        length1 -= count1;
+                        customDest = dest + 1;
+                        customCursor = cursor1 + 1;
+                        for (i = count1 - 1; i >= 0; i--) {
+                            array[customDest + i] = array[customCursor + i];
+                        }
+                        if (length1 === 0) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    array[dest--] = tmp[cursor2--];
+                    if (--length2 === 1) {
+                        exit = true;
+                        break;
+                    }
+                    count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+                    if (count2 !== 0) {
+                        dest -= count2;
+                        cursor2 -= count2;
+                        length2 -= count2;
+                        customDest = dest + 1;
+                        customCursor = cursor2 + 1;
+                        for (i = 0; i < count2; i++) {
+                            array[customDest + i] = tmp[customCursor + i];
+                        }
+                        if (length2 <= 1) {
+                            exit = true;
+                            break;
+                        }
+                    }
+                    array[dest--] = array[cursor1--];
+                    if (--length1 === 0) {
+                        exit = true;
+                        break;
+                    }
+                    _minGallop--;
+                } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+                if (exit) {
+                    break;
+                }
+                if (_minGallop < 0) {
+                    _minGallop = 0;
+                }
+                _minGallop += 2;
+            }
+            minGallop = _minGallop;
+            if (minGallop < 1) {
+                minGallop = 1;
+            }
+            if (length2 === 1) {
+                dest -= length1;
+                cursor1 -= length1;
+                customDest = dest + 1;
+                customCursor = cursor1 + 1;
+                for (i = length1 - 1; i >= 0; i--) {
+                    array[customDest + i] = array[customCursor + i];
+                }
+                array[dest] = tmp[cursor2];
+            }
+            else if (length2 === 0) {
+                throw new Error();
+            }
+            else {
+                customCursor = dest - (length2 - 1);
+                for (i = 0; i < length2; i++) {
+                    array[customCursor + i] = tmp[i];
+                }
+            }
+        }
+        return {
+            mergeRuns: mergeRuns,
+            forceMergeRuns: forceMergeRuns,
+            pushRun: pushRun
+        };
+    }
+    function sort(array, compare, lo, hi) {
+        if (!lo) {
+            lo = 0;
+        }
+        if (!hi) {
+            hi = array.length;
+        }
+        var remaining = hi - lo;
+        if (remaining < 2) {
+            return;
+        }
+        var runLength = 0;
+        if (remaining < DEFAULT_MIN_MERGE) {
+            runLength = makeAscendingRun(array, lo, hi, compare);
+            binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+            return;
+        }
+        var ts = TimSort(array, compare);
+        var minRun = minRunLength(remaining);
+        do {
+            runLength = makeAscendingRun(array, lo, hi, compare);
+            if (runLength < minRun) {
+                var force = remaining;
+                if (force > minRun) {
+                    force = minRun;
+                }
+                binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+                runLength = force;
+            }
+            ts.pushRun(lo, runLength);
+            ts.mergeRuns();
+            remaining -= runLength;
+            lo += runLength;
+        } while (remaining !== 0);
+        ts.forceMergeRuns();
+    }
+
+    var invalidZErrorLogged = false;
+    function logInvalidZError() {
+        if (invalidZErrorLogged) {
+            return;
+        }
+        invalidZErrorLogged = true;
+        console.warn('z / z2 / zlevel of displayable is invalid, which may cause unexpected errors');
+    }
+    function shapeCompareFunc(a, b) {
+        if (a.zlevel === b.zlevel) {
+            if (a.z === b.z) {
+                return a.z2 - b.z2;
+            }
+            return a.z - b.z;
+        }
+        return a.zlevel - b.zlevel;
+    }
+    var Storage = (function () {
+        function Storage() {
+            this._roots = [];
+            this._displayList = [];
+            this._displayListLen = 0;
+            this.displayableSortFunc = shapeCompareFunc;
+        }
+        Storage.prototype.traverse = function (cb, context) {
+            for (var i = 0; i < this._roots.length; i++) {
+                this._roots[i].traverse(cb, context);
+            }
+        };
+        Storage.prototype.getDisplayList = function (update, includeIgnore) {
+            includeIgnore = includeIgnore || false;
+            var displayList = this._displayList;
+            if (update || !displayList.length) {
+                this.updateDisplayList(includeIgnore);
+            }
+            return displayList;
+        };
+        Storage.prototype.updateDisplayList = function (includeIgnore) {
+            this._displayListLen = 0;
+            var roots = this._roots;
+            var displayList = this._displayList;
+            for (var i = 0, len = roots.length; i < len; i++) {
+                this._updateAndAddDisplayable(roots[i], null, includeIgnore);
+            }
+            displayList.length = this._displayListLen;
+            env.canvasSupported && sort(displayList, shapeCompareFunc);
+        };
+        Storage.prototype._updateAndAddDisplayable = function (el, clipPaths, includeIgnore) {
+            if (el.ignore && !includeIgnore) {
+                return;
+            }
+            el.beforeUpdate();
+            el.update();
+            el.afterUpdate();
+            var userSetClipPath = el.getClipPath();
+            if (el.ignoreClip) {
+                clipPaths = null;
+            }
+            else if (userSetClipPath) {
+                if (clipPaths) {
+                    clipPaths = clipPaths.slice();
+                }
+                else {
+                    clipPaths = [];
+                }
+                var currentClipPath = userSetClipPath;
+                var parentClipPath = el;
+                while (currentClipPath) {
+                    currentClipPath.parent = parentClipPath;
+                    currentClipPath.updateTransform();
+                    clipPaths.push(currentClipPath);
+                    parentClipPath = currentClipPath;
+                    currentClipPath = currentClipPath.getClipPath();
+                }
+            }
+            if (el.childrenRef) {
+                var children = el.childrenRef();
+                for (var i = 0; i < children.length; i++) {
+                    var child = children[i];
+                    if (el.__dirty) {
+                        child.__dirty |= Element.REDARAW_BIT;
+                    }
+                    this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
+                }
+                el.__dirty = 0;
+            }
+            else {
+                var disp = el;
+                if (clipPaths && clipPaths.length) {
+                    disp.__clipPaths = clipPaths;
+                }
+                else if (disp.__clipPaths && disp.__clipPaths.length > 0) {
+                    disp.__clipPaths = [];
+                }
+                if (isNaN(disp.z)) {
+                    logInvalidZError();
+                    disp.z = 0;
+                }
+                if (isNaN(disp.z2)) {
+                    logInvalidZError();
+                    disp.z2 = 0;
+                }
+                if (isNaN(disp.zlevel)) {
+                    logInvalidZError();
+                    disp.zlevel = 0;
+                }
+                this._displayList[this._displayListLen++] = disp;
+            }
+            var decalEl = el.getDecalElement && el.getDecalElement();
+            if (decalEl) {
+                this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore);
+            }
+            var textGuide = el.getTextGuideLine();
+            if (textGuide) {
+                this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore);
+            }
+            var textEl = el.getTextContent();
+            if (textEl) {
+                this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore);
+            }
+        };
+        Storage.prototype.addRoot = function (el) {
+            if (el.__zr && el.__zr.storage === this) {
+                return;
+            }
+            this._roots.push(el);
+        };
+        Storage.prototype.delRoot = function (el) {
+            if (el instanceof Array) {
+                for (var i = 0, l = el.length; i < l; i++) {
+                    this.delRoot(el[i]);
+                }
+                return;
+            }
+            var idx = indexOf(this._roots, el);
+            if (idx >= 0) {
+                this._roots.splice(idx, 1);
+            }
+        };
+        Storage.prototype.delAllRoots = function () {
+            this._roots = [];
+            this._displayList = [];
+            this._displayListLen = 0;
+            return;
+        };
+        Storage.prototype.getRoots = function () {
+            return this._roots;
+        };
+        Storage.prototype.dispose = function () {
+            this._displayList = null;
+            this._roots = null;
+        };
+        return Storage;
+    }());
+
+    var requestAnimationFrame;
+    requestAnimationFrame = (typeof window !== 'undefined'
+        && ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window))
+            || (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window))
+            || window.mozRequestAnimationFrame
+            || window.webkitRequestAnimationFrame)) || function (func) {
+        return setTimeout(func, 16);
+    };
+    var requestAnimationFrame$1 = requestAnimationFrame;
+
+    var Animation = (function (_super) {
+        __extends(Animation, _super);
+        function Animation(opts) {
+            var _this = _super.call(this) || this;
+            _this._running = false;
+            _this._time = 0;
+            _this._pausedTime = 0;
+            _this._pauseStart = 0;
+            _this._paused = false;
+            opts = opts || {};
+            _this.stage = opts.stage || {};
+            _this.onframe = opts.onframe || function () { };
+            return _this;
+        }
+        Animation.prototype.addClip = function (clip) {
+            if (clip.animation) {
+                this.removeClip(clip);
+            }
+            if (!this._clipsHead) {
+                this._clipsHead = this._clipsTail = clip;
+            }
+            else {
+                this._clipsTail.next = clip;
+                clip.prev = this._clipsTail;
+                clip.next = null;
+                this._clipsTail = clip;
+            }
+            clip.animation = this;
+        };
+        Animation.prototype.addAnimator = function (animator) {
+            animator.animation = this;
+            var clip = animator.getClip();
+            if (clip) {
+                this.addClip(clip);
+            }
+        };
+        Animation.prototype.removeClip = function (clip) {
+            if (!clip.animation) {
+                return;
+            }
+            var prev = clip.prev;
+            var next = clip.next;
+            if (prev) {
+                prev.next = next;
+            }
+            else {
+                this._clipsHead = next;
+            }
+            if (next) {
+                next.prev = prev;
+            }
+            else {
+                this._clipsTail = prev;
+            }
+            clip.next = clip.prev = clip.animation = null;
+        };
+        Animation.prototype.removeAnimator = function (animator) {
+            var clip = animator.getClip();
+            if (clip) {
+                this.removeClip(clip);
+            }
+            animator.animation = null;
+        };
+        Animation.prototype.update = function (notTriggerFrameAndStageUpdate) {
+            var time = new Date().getTime() - this._pausedTime;
+            var delta = time - this._time;
+            var clip = this._clipsHead;
+            while (clip) {
+                var nextClip = clip.next;
+                var finished = clip.step(time, delta);
+                if (finished) {
+                    clip.ondestroy && clip.ondestroy();
+                    this.removeClip(clip);
+                    clip = nextClip;
+                }
+                else {
+                    clip = nextClip;
+                }
+            }
+            this._time = time;
+            if (!notTriggerFrameAndStageUpdate) {
+                this.onframe(delta);
+                this.trigger('frame', delta);
+                this.stage.update && this.stage.update();
+            }
+        };
+        Animation.prototype._startLoop = function () {
+            var self = this;
+            this._running = true;
+            function step() {
+                if (self._running) {
+                    requestAnimationFrame$1(step);
+                    !self._paused && self.update();
+                }
+            }
+            requestAnimationFrame$1(step);
+        };
+        Animation.prototype.start = function () {
+            if (this._running) {
+                return;
+            }
+            this._time = new Date().getTime();
+            this._pausedTime = 0;
+            this._startLoop();
+        };
+        Animation.prototype.stop = function () {
+            this._running = false;
+        };
+        Animation.prototype.pause = function () {
+            if (!this._paused) {
+                this._pauseStart = new Date().getTime();
+                this._paused = true;
+            }
+        };
+        Animation.prototype.resume = function () {
+            if (this._paused) {
+                this._pausedTime += (new Date().getTime()) - this._pauseStart;
+                this._paused = false;
+            }
+        };
+        Animation.prototype.clear = function () {
+            var clip = this._clipsHead;
+            while (clip) {
+                var nextClip = clip.next;
+                clip.prev = clip.next = clip.animation = null;
+                clip = nextClip;
+            }
+            this._clipsHead = this._clipsTail = null;
+        };
+        Animation.prototype.isFinished = function () {
+            return this._clipsHead == null;
+        };
+        Animation.prototype.animate = function (target, options) {
+            options = options || {};
+            this.start();
+            var animator = new Animator(target, options.loop);
+            this.addAnimator(animator);
+            return animator;
+        };
+        return Animation;
+    }(Eventful));
+
+    var TOUCH_CLICK_DELAY = 300;
+    var globalEventSupported = env.domSupported;
+    var localNativeListenerNames = (function () {
+        var mouseHandlerNames = [
+            'click', 'dblclick', 'mousewheel', 'wheel', 'mouseout',
+            'mouseup', 'mousedown', 'mousemove', 'contextmenu'
+        ];
+        var touchHandlerNames = [
+            'touchstart', 'touchend', 'touchmove'
+        ];
+        var pointerEventNameMap = {
+            pointerdown: 1, pointerup: 1, pointermove: 1, pointerout: 1
+        };
+        var pointerHandlerNames = map(mouseHandlerNames, function (name) {
+            var nm = name.replace('mouse', 'pointer');
+            return pointerEventNameMap.hasOwnProperty(nm) ? nm : name;
+        });
+        return {
+            mouse: mouseHandlerNames,
+            touch: touchHandlerNames,
+            pointer: pointerHandlerNames
+        };
+    })();
+    var globalNativeListenerNames = {
+        mouse: ['mousemove', 'mouseup'],
+        pointer: ['pointermove', 'pointerup']
+    };
+    var wheelEventSupported = false;
+    function isPointerFromTouch(event) {
+        var pointerType = event.pointerType;
+        return pointerType === 'pen' || pointerType === 'touch';
+    }
+    function setTouchTimer(scope) {
+        scope.touching = true;
+        if (scope.touchTimer != null) {
+            clearTimeout(scope.touchTimer);
+            scope.touchTimer = null;
+        }
+        scope.touchTimer = setTimeout(function () {
+            scope.touching = false;
+            scope.touchTimer = null;
+        }, 700);
+    }
+    function markTouch(event) {
+        event && (event.zrByTouch = true);
+    }
+    function normalizeGlobalEvent(instance, event) {
+        return normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event), true);
+    }
+    function isLocalEl(instance, el) {
+        var elTmp = el;
+        var isLocal = false;
+        while (elTmp && elTmp.nodeType !== 9
+            && !(isLocal = elTmp.domBelongToZr
+                || (elTmp !== el && elTmp === instance.painterRoot))) {
+            elTmp = elTmp.parentNode;
+        }
+        return isLocal;
+    }
+    var FakeGlobalEvent = (function () {
+        function FakeGlobalEvent(instance, event) {
+            this.stopPropagation = noop;
+            this.stopImmediatePropagation = noop;
+            this.preventDefault = noop;
+            this.type = event.type;
+            this.target = this.currentTarget = instance.dom;
+            this.pointerType = event.pointerType;
+            this.clientX = event.clientX;
+            this.clientY = event.clientY;
+        }
+        return FakeGlobalEvent;
+    }());
+    var localDOMHandlers = {
+        mousedown: function (event) {
+            event = normalizeEvent(this.dom, event);
+            this.__mayPointerCapture = [event.zrX, event.zrY];
+            this.trigger('mousedown', event);
+        },
+        mousemove: function (event) {
+            event = normalizeEvent(this.dom, event);
+            var downPoint = this.__mayPointerCapture;
+            if (downPoint && (event.zrX !== downPoint[0] || event.zrY !== downPoint[1])) {
+                this.__togglePointerCapture(true);
+            }
+            this.trigger('mousemove', event);
+        },
+        mouseup: function (event) {
+            event = normalizeEvent(this.dom, event);
+            this.__togglePointerCapture(false);
+            this.trigger('mouseup', event);
+        },
+        mouseout: function (event) {
+            event = normalizeEvent(this.dom, event);
+            var element = event.toElement || event.relatedTarget;
+            if (!isLocalEl(this, element)) {
+                if (this.__pointerCapturing) {
+                    event.zrEventControl = 'no_globalout';
+                }
+                this.trigger('mouseout', event);
+            }
+        },
+        wheel: function (event) {
+            wheelEventSupported = true;
+            event = normalizeEvent(this.dom, event);
+            this.trigger('mousewheel', event);
+        },
+        mousewheel: function (event) {
+            if (wheelEventSupported) {
+                return;
+            }
+            event = normalizeEvent(this.dom, event);
+            this.trigger('mousewheel', event);
+        },
+        touchstart: function (event) {
+            event = normalizeEvent(this.dom, event);
+            markTouch(event);
+            this.__lastTouchMoment = new Date();
+            this.handler.processGesture(event, 'start');
+            localDOMHandlers.mousemove.call(this, event);
+            localDOMHandlers.mousedown.call(this, event);
+        },
+        touchmove: function (event) {
+            event = normalizeEvent(this.dom, event);
+            markTouch(event);
+            this.handler.processGesture(event, 'change');
+            localDOMHandlers.mousemove.call(this, event);
+        },
+        touchend: function (event) {
+            event = normalizeEvent(this.dom, event);
+            markTouch(event);
+            this.handler.processGesture(event, 'end');
+            localDOMHandlers.mouseup.call(this, event);
+            if (+new Date() - (+this.__lastTouchMoment) < TOUCH_CLICK_DELAY) {
+                localDOMHandlers.click.call(this, event);
+            }
+        },
+        pointerdown: function (event) {
+            localDOMHandlers.mousedown.call(this, event);
+        },
+        pointermove: function (event) {
+            if (!isPointerFromTouch(event)) {
+                localDOMHandlers.mousemove.call(this, event);
+            }
+        },
+        pointerup: function (event) {
+            localDOMHandlers.mouseup.call(this, event);
+        },
+        pointerout: function (event) {
+            if (!isPointerFromTouch(event)) {
+                localDOMHandlers.mouseout.call(this, event);
+            }
+        }
+    };
+    each(['click', 'dblclick', 'contextmenu'], function (name) {
+        localDOMHandlers[name] = function (event) {
+            event = normalizeEvent(this.dom, event);
+            this.trigger(name, event);
+        };
+    });
+    var globalDOMHandlers = {
+        pointermove: function (event) {
+            if (!isPointerFromTouch(event)) {
+                globalDOMHandlers.mousemove.call(this, event);
+            }
+        },
+        pointerup: function (event) {
+            globalDOMHandlers.mouseup.call(this, event);
+        },
+        mousemove: function (event) {
+            this.trigger('mousemove', event);
+        },
+        mouseup: function (event) {
+            var pointerCaptureReleasing = this.__pointerCapturing;
+            this.__togglePointerCapture(false);
+            this.trigger('mouseup', event);
+            if (pointerCaptureReleasing) {
+                event.zrEventControl = 'only_globalout';
+                this.trigger('mouseout', event);
+            }
+        }
+    };
+    function mountLocalDOMEventListeners(instance, scope) {
+        var domHandlers = scope.domHandlers;
+        if (env.pointerEventsSupported) {
+            each(localNativeListenerNames.pointer, function (nativeEventName) {
+                mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                    domHandlers[nativeEventName].call(instance, event);
+                });
+            });
+        }
+        else {
+            if (env.touchEventsSupported) {
+                each(localNativeListenerNames.touch, function (nativeEventName) {
+                    mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                        domHandlers[nativeEventName].call(instance, event);
+                        setTouchTimer(scope);
+                    });
+                });
+            }
+            each(localNativeListenerNames.mouse, function (nativeEventName) {
+                mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                    event = getNativeEvent(event);
+                    if (!scope.touching) {
+                        domHandlers[nativeEventName].call(instance, event);
+                    }
+                });
+            });
+        }
+    }
+    function mountGlobalDOMEventListeners(instance, scope) {
+        if (env.pointerEventsSupported) {
+            each(globalNativeListenerNames.pointer, mount);
+        }
+        else if (!env.touchEventsSupported) {
+            each(globalNativeListenerNames.mouse, mount);
+        }
+        function mount(nativeEventName) {
+            function nativeEventListener(event) {
+                event = getNativeEvent(event);
+                if (!isLocalEl(instance, event.target)) {
+                    event = normalizeGlobalEvent(instance, event);
+                    scope.domHandlers[nativeEventName].call(instance, event);
+                }
+            }
+            mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true });
+        }
+    }
+    function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) {
+        scope.mounted[nativeEventName] = listener;
+        scope.listenerOpts[nativeEventName] = opt;
+        addEventListener(scope.domTarget, nativeEventName, listener, opt);
+    }
+    function unmountDOMEventListeners(scope) {
+        var mounted = scope.mounted;
+        for (var nativeEventName in mounted) {
+            if (mounted.hasOwnProperty(nativeEventName)) {
+                removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]);
+            }
+        }
+        scope.mounted = {};
+    }
+    var DOMHandlerScope = (function () {
+        function DOMHandlerScope(domTarget, domHandlers) {
+            this.mounted = {};
+            this.listenerOpts = {};
+            this.touching = false;
+            this.domTarget = domTarget;
+            this.domHandlers = domHandlers;
+        }
+        return DOMHandlerScope;
+    }());
+    var HandlerDomProxy = (function (_super) {
+        __extends(HandlerDomProxy, _super);
+        function HandlerDomProxy(dom, painterRoot) {
+            var _this = _super.call(this) || this;
+            _this.__pointerCapturing = false;
+            _this.dom = dom;
+            _this.painterRoot = painterRoot;
+            _this._localHandlerScope = new DOMHandlerScope(dom, localDOMHandlers);
+            if (globalEventSupported) {
+                _this._globalHandlerScope = new DOMHandlerScope(document, globalDOMHandlers);
+            }
+            mountLocalDOMEventListeners(_this, _this._localHandlerScope);
+            return _this;
+        }
+        HandlerDomProxy.prototype.dispose = function () {
+            unmountDOMEventListeners(this._localHandlerScope);
+            if (globalEventSupported) {
+                unmountDOMEventListeners(this._globalHandlerScope);
+            }
+        };
+        HandlerDomProxy.prototype.setCursor = function (cursorStyle) {
+            this.dom.style && (this.dom.style.cursor = cursorStyle || 'default');
+        };
+        HandlerDomProxy.prototype.__togglePointerCapture = function (isPointerCapturing) {
+            this.__mayPointerCapture = null;
+            if (globalEventSupported
+                && ((+this.__pointerCapturing) ^ (+isPointerCapturing))) {
+                this.__pointerCapturing = isPointerCapturing;
+                var globalHandlerScope = this._globalHandlerScope;
+                isPointerCapturing
+                    ? mountGlobalDOMEventListeners(this, globalHandlerScope)
+                    : unmountDOMEventListeners(globalHandlerScope);
+            }
+        };
+        return HandlerDomProxy;
+    }(Eventful));
+
+    var Group = (function (_super) {
+        __extends(Group, _super);
+        function Group(opts) {
+            var _this = _super.call(this) || this;
+            _this.isGroup = true;
+            _this._children = [];
+            _this.attr(opts);
+            return _this;
+        }
+        Group.prototype.childrenRef = function () {
+            return this._children;
+        };
+        Group.prototype.children = function () {
+            return this._children.slice();
+        };
+        Group.prototype.childAt = function (idx) {
+            return this._children[idx];
+        };
+        Group.prototype.childOfName = function (name) {
+            var children = this._children;
+            for (var i = 0; i < children.length; i++) {
+                if (children[i].name === name) {
+                    return children[i];
+                }
+            }
+        };
+        Group.prototype.childCount = function () {
+            return this._children.length;
+        };
+        Group.prototype.add = function (child) {
+            if (child) {
+                if (child !== this && child.parent !== this) {
+                    this._children.push(child);
+                    this._doAdd(child);
+                }
+                if (child.__hostTarget) {
+                    throw 'This elemenet has been used as an attachment';
+                }
+            }
+            return this;
+        };
+        Group.prototype.addBefore = function (child, nextSibling) {
+            if (child && child !== this && child.parent !== this
+                && nextSibling && nextSibling.parent === this) {
+                var children = this._children;
+                var idx = children.indexOf(nextSibling);
+                if (idx >= 0) {
+                    children.splice(idx, 0, child);
+                    this._doAdd(child);
+                }
+            }
+            return this;
+        };
+        Group.prototype.replaceAt = function (child, index) {
+            var children = this._children;
+            var old = children[index];
+            if (child && child !== this && child.parent !== this && child !== old) {
+                children[index] = child;
+                old.parent = null;
+                var zr = this.__zr;
+                if (zr) {
+                    old.removeSelfFromZr(zr);
+                }
+                this._doAdd(child);
+            }
+            return this;
+        };
+        Group.prototype._doAdd = function (child) {
+            if (child.parent) {
+                child.parent.remove(child);
+            }
+            child.parent = this;
+            var zr = this.__zr;
+            if (zr && zr !== child.__zr) {
+                child.addSelfToZr(zr);
+            }
+            zr && zr.refresh();
+        };
+        Group.prototype.remove = function (child) {
+            var zr = this.__zr;
+            var children = this._children;
+            var idx = indexOf(children, child);
+            if (idx < 0) {
+                return this;
+            }
+            children.splice(idx, 1);
+            child.parent = null;
+            if (zr) {
+                child.removeSelfFromZr(zr);
+            }
+            zr && zr.refresh();
+            return this;
+        };
+        Group.prototype.removeAll = function () {
+            var children = this._children;
+            var zr = this.__zr;
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                if (zr) {
+                    child.removeSelfFromZr(zr);
+                }
+                child.parent = null;
+            }
+            children.length = 0;
+            return this;
+        };
+        Group.prototype.eachChild = function (cb, context) {
+            var children = this._children;
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                cb.call(context, child, i);
+            }
+            return this;
+        };
+        Group.prototype.traverse = function (cb, context) {
+            for (var i = 0; i < this._children.length; i++) {
+                var child = this._children[i];
+                var stopped = cb.call(context, child);
+                if (child.isGroup && !stopped) {
+                    child.traverse(cb, context);
+                }
+            }
+            return this;
+        };
+        Group.prototype.addSelfToZr = function (zr) {
+            _super.prototype.addSelfToZr.call(this, zr);
+            for (var i = 0; i < this._children.length; i++) {
+                var child = this._children[i];
+                child.addSelfToZr(zr);
+            }
+        };
+        Group.prototype.removeSelfFromZr = function (zr) {
+            _super.prototype.removeSelfFromZr.call(this, zr);
+            for (var i = 0; i < this._children.length; i++) {
+                var child = this._children[i];
+                child.removeSelfFromZr(zr);
+            }
+        };
+        Group.prototype.getBoundingRect = function (includeChildren) {
+            var tmpRect = new BoundingRect(0, 0, 0, 0);
+            var children = includeChildren || this._children;
+            var tmpMat = [];
+            var rect = null;
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                if (child.ignore || child.invisible) {
+                    continue;
+                }
+                var childRect = child.getBoundingRect();
+                var transform = child.getLocalTransform(tmpMat);
+                if (transform) {
+                    BoundingRect.applyTransform(tmpRect, childRect, transform);
+                    rect = rect || tmpRect.clone();
+                    rect.union(tmpRect);
+                }
+                else {
+                    rect = rect || childRect.clone();
+                    rect.union(childRect);
+                }
+            }
+            return rect || tmpRect;
+        };
+        return Group;
+    }(Element));
+    Group.prototype.type = 'group';
+
+    /*!
+    * ZRender, a high performance 2d drawing library.
+    *
+    * Copyright (c) 2013, Baidu Inc.
+    * All rights reserved.
+    *
+    * LICENSE
+    * https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+    */
+    var useVML = !env.canvasSupported;
+    var painterCtors = {};
+    var instances = {};
+    function delInstance(id) {
+        delete instances[id];
+    }
+    function isDarkMode(backgroundColor) {
+        if (!backgroundColor) {
+            return false;
+        }
+        if (typeof backgroundColor === 'string') {
+            return lum(backgroundColor, 1) < DARK_MODE_THRESHOLD;
+        }
+        else if (backgroundColor.colorStops) {
+            var colorStops = backgroundColor.colorStops;
+            var totalLum = 0;
+            var len = colorStops.length;
+            for (var i = 0; i < len; i++) {
+                totalLum += lum(colorStops[i].color, 1);
+            }
+            totalLum /= len;
+            return totalLum < DARK_MODE_THRESHOLD;
+        }
+        return false;
+    }
+    var ZRender = (function () {
+        function ZRender(id, dom, opts) {
+            var _this = this;
+            this._sleepAfterStill = 10;
+            this._stillFrameAccum = 0;
+            this._needsRefresh = true;
+            this._needsRefreshHover = true;
+            this._darkMode = false;
+            opts = opts || {};
+            this.dom = dom;
+            this.id = id;
+            var storage = new Storage();
+            var rendererType = opts.renderer || 'canvas';
+            if (useVML) {
+                throw new Error('IE8 support has been dropped since 5.0');
+            }
+            if (!painterCtors[rendererType]) {
+                rendererType = keys(painterCtors)[0];
+            }
+            if (!painterCtors[rendererType]) {
+                throw new Error("Renderer '" + rendererType + "' is not imported. Please import it first.");
+            }
+            opts.useDirtyRect = opts.useDirtyRect == null
+                ? false
+                : opts.useDirtyRect;
+            var painter = new painterCtors[rendererType](dom, storage, opts, id);
+            this.storage = storage;
+            this.painter = painter;
+            var handerProxy = (!env.node && !env.worker)
+                ? new HandlerDomProxy(painter.getViewportRoot(), painter.root)
+                : null;
+            this.handler = new Handler(storage, painter, handerProxy, painter.root);
+            this.animation = new Animation({
+                stage: {
+                    update: function () { return _this._flush(true); }
+                }
+            });
+            this.animation.start();
+        }
+        ZRender.prototype.add = function (el) {
+            if (!el) {
+                return;
+            }
+            this.storage.addRoot(el);
+            el.addSelfToZr(this);
+            this.refresh();
+        };
+        ZRender.prototype.remove = function (el) {
+            if (!el) {
+                return;
+            }
+            this.storage.delRoot(el);
+            el.removeSelfFromZr(this);
+            this.refresh();
+        };
+        ZRender.prototype.configLayer = function (zLevel, config) {
+            if (this.painter.configLayer) {
+                this.painter.configLayer(zLevel, config);
+            }
+            this.refresh();
+        };
+        ZRender.prototype.setBackgroundColor = function (backgroundColor) {
+            if (this.painter.setBackgroundColor) {
+                this.painter.setBackgroundColor(backgroundColor);
+            }
+            this.refresh();
+            this._backgroundColor = backgroundColor;
+            this._darkMode = isDarkMode(backgroundColor);
+        };
+        ZRender.prototype.getBackgroundColor = function () {
+            return this._backgroundColor;
+        };
+        ZRender.prototype.setDarkMode = function (darkMode) {
+            this._darkMode = darkMode;
+        };
+        ZRender.prototype.isDarkMode = function () {
+            return this._darkMode;
+        };
+        ZRender.prototype.refreshImmediately = function (fromInside) {
+            if (!fromInside) {
+                this.animation.update(true);
+            }
+            this._needsRefresh = false;
+            this.painter.refresh();
+            this._needsRefresh = false;
+        };
+        ZRender.prototype.refresh = function () {
+            this._needsRefresh = true;
+            this.animation.start();
+        };
+        ZRender.prototype.flush = function () {
+            this._flush(false);
+        };
+        ZRender.prototype._flush = function (fromInside) {
+            var triggerRendered;
+            var start = new Date().getTime();
+            if (this._needsRefresh) {
+                triggerRendered = true;
+                this.refreshImmediately(fromInside);
+            }
+            if (this._needsRefreshHover) {
+                triggerRendered = true;
+                this.refreshHoverImmediately();
+            }
+            var end = new Date().getTime();
+            if (triggerRendered) {
+                this._stillFrameAccum = 0;
+                this.trigger('rendered', {
+                    elapsedTime: end - start
+                });
+            }
+            else if (this._sleepAfterStill > 0) {
+                this._stillFrameAccum++;
+                if (this._stillFrameAccum > this._sleepAfterStill) {
+                    this.animation.stop();
+                }
+            }
+        };
+        ZRender.prototype.setSleepAfterStill = function (stillFramesCount) {
+            this._sleepAfterStill = stillFramesCount;
+        };
+        ZRender.prototype.wakeUp = function () {
+            this.animation.start();
+            this._stillFrameAccum = 0;
+        };
+        ZRender.prototype.addHover = function (el) {
+        };
+        ZRender.prototype.removeHover = function (el) {
+        };
+        ZRender.prototype.clearHover = function () {
+        };
+        ZRender.prototype.refreshHover = function () {
+            this._needsRefreshHover = true;
+        };
+        ZRender.prototype.refreshHoverImmediately = function () {
+            this._needsRefreshHover = false;
+            if (this.painter.refreshHover && this.painter.getType() === 'canvas') {
+                this.painter.refreshHover();
+            }
+        };
+        ZRender.prototype.resize = function (opts) {
+            opts = opts || {};
+            this.painter.resize(opts.width, opts.height);
+            this.handler.resize();
+        };
+        ZRender.prototype.clearAnimation = function () {
+            this.animation.clear();
+        };
+        ZRender.prototype.getWidth = function () {
+            return this.painter.getWidth();
+        };
+        ZRender.prototype.getHeight = function () {
+            return this.painter.getHeight();
+        };
+        ZRender.prototype.pathToImage = function (e, dpr) {
+            if (this.painter.pathToImage) {
+                return this.painter.pathToImage(e, dpr);
+            }
+        };
+        ZRender.prototype.setCursorStyle = function (cursorStyle) {
+            this.handler.setCursorStyle(cursorStyle);
+        };
+        ZRender.prototype.findHover = function (x, y) {
+            return this.handler.findHover(x, y);
+        };
+        ZRender.prototype.on = function (eventName, eventHandler, context) {
+            this.handler.on(eventName, eventHandler, context);
+            return this;
+        };
+        ZRender.prototype.off = function (eventName, eventHandler) {
+            this.handler.off(eventName, eventHandler);
+        };
+        ZRender.prototype.trigger = function (eventName, event) {
+            this.handler.trigger(eventName, event);
+        };
+        ZRender.prototype.clear = function () {
+            var roots = this.storage.getRoots();
+            for (var i = 0; i < roots.length; i++) {
+                if (roots[i] instanceof Group) {
+                    roots[i].removeSelfFromZr(this);
+                }
+            }
+            this.storage.delAllRoots();
+            this.painter.clear();
+        };
+        ZRender.prototype.dispose = function () {
+            this.animation.stop();
+            this.clear();
+            this.storage.dispose();
+            this.painter.dispose();
+            this.handler.dispose();
+            this.animation =
+                this.storage =
+                    this.painter =
+                        this.handler = null;
+            delInstance(this.id);
+        };
+        return ZRender;
+    }());
+    function init(dom, opts) {
+        var zr = new ZRender(guid(), dom, opts);
+        instances[zr.id] = zr;
+        return zr;
+    }
+    function dispose(zr) {
+        zr.dispose();
+    }
+    function disposeAll() {
+        for (var key in instances) {
+            if (instances.hasOwnProperty(key)) {
+                instances[key].dispose();
+            }
+        }
+        instances = {};
+    }
+    function getInstance(id) {
+        return instances[id];
+    }
+    function registerPainter(name, Ctor) {
+        painterCtors[name] = Ctor;
+    }
+    var version = '5.0.4';
+
+    var zrender = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init,
+        dispose: dispose,
+        disposeAll: disposeAll,
+        getInstance: getInstance,
+        registerPainter: registerPainter,
+        version: version
+    });
+
+    var RADIAN_EPSILON = 1e-4;
+
+    function _trim(str) {
+      return str.replace(/^\s+|\s+$/g, '');
+    }
+    /**
+     * Linear mapping a value from domain to range
+     * @param  val
+     * @param  domain Domain extent domain[0] can be bigger than domain[1]
+     * @param  range  Range extent range[0] can be bigger than range[1]
+     * @param  clamp Default to be false
+     */
+
+
+    function linearMap(val, domain, range, clamp) {
+      var subDomain = domain[1] - domain[0];
+      var subRange = range[1] - range[0];
+
+      if (subDomain === 0) {
+        return subRange === 0 ? range[0] : (range[0] + range[1]) / 2;
+      } // Avoid accuracy problem in edge, such as
+      // 146.39 - 62.83 === 83.55999999999999.
+      // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
+      // It is a little verbose for efficiency considering this method
+      // is a hotspot.
+
+
+      if (clamp) {
+        if (subDomain > 0) {
+          if (val <= domain[0]) {
+            return range[0];
+          } else if (val >= domain[1]) {
+            return range[1];
+          }
+        } else {
+          if (val >= domain[0]) {
+            return range[0];
+          } else if (val <= domain[1]) {
+            return range[1];
+          }
+        }
+      } else {
+        if (val === domain[0]) {
+          return range[0];
+        }
+
+        if (val === domain[1]) {
+          return range[1];
+        }
+      }
+
+      return (val - domain[0]) / subDomain * subRange + range[0];
+    }
+    /**
+     * Convert a percent string to absolute number.
+     * Returns NaN if percent is not a valid string or number
+     */
+
+    function parsePercent$1(percent, all) {
+      switch (percent) {
+        case 'center':
+        case 'middle':
+          percent = '50%';
+          break;
+
+        case 'left':
+        case 'top':
+          percent = '0%';
+          break;
+
+        case 'right':
+        case 'bottom':
+          percent = '100%';
+          break;
+      }
+
+      if (typeof percent === 'string') {
+        if (_trim(percent).match(/%$/)) {
+          return parseFloat(percent) / 100 * all;
+        }
+
+        return parseFloat(percent);
+      }
+
+      return percent == null ? NaN : +percent;
+    }
+    function round(x, precision, returnStr) {
+      if (precision == null) {
+        precision = 10;
+      } // Avoid range error
+
+
+      precision = Math.min(Math.max(0, precision), 20);
+      x = (+x).toFixed(precision);
+      return returnStr ? x : +x;
+    }
+    /**
+     * Inplacd asc sort arr.
+     * The input arr will be modified.
+     */
+
+    function asc(arr) {
+      arr.sort(function (a, b) {
+        return a - b;
+      });
+      return arr;
+    }
+    /**
+     * Get precision
+     */
+
+    function getPrecision(val) {
+      val = +val;
+
+      if (isNaN(val)) {
+        return 0;
+      } // It is much faster than methods converting number to string as follows
+      //      let tmp = val.toString();
+      //      return tmp.length - 1 - tmp.indexOf('.');
+      // especially when precision is low
+
+
+      var e = 1;
+      var count = 0;
+
+      while (Math.round(val * e) / e !== val) {
+        e *= 10;
+        count++;
+      }
+
+      return count;
+    }
+    /**
+     * Get precision with slow but safe method
+     */
+
+    function getPrecisionSafe(val) {
+      var str = val.toString(); // Consider scientific notation: '3.4e-12' '3.4e+12'
+
+      var eIndex = str.indexOf('e');
+
+      if (eIndex > 0) {
+        var precision = +str.slice(eIndex + 1);
+        return precision < 0 ? -precision : 0;
+      } else {
+        var dotIndex = str.indexOf('.');
+        return dotIndex < 0 ? 0 : str.length - 1 - dotIndex;
+      }
+    }
+    /**
+     * Minimal dicernible data precisioin according to a single pixel.
+     */
+
+    function getPixelPrecision(dataExtent, pixelExtent) {
+      var log = Math.log;
+      var LN10 = Math.LN10;
+      var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
+      var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10); // toFixed() digits argument must be between 0 and 20.
+
+      var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
+      return !isFinite(precision) ? 20 : precision;
+    }
+    /**
+     * Get a data of given precision, assuring the sum of percentages
+     * in valueList is 1.
+     * The largest remainer method is used.
+     * https://en.wikipedia.org/wiki/Largest_remainder_method
+     *
+     * @param valueList a list of all data
+     * @param idx index of the data to be processed in valueList
+     * @param precision integer number showing digits of precision
+     * @return percent ranging from 0 to 100
+     */
+
+    function getPercentWithPrecision(valueList, idx, precision) {
+      if (!valueList[idx]) {
+        return 0;
+      }
+
+      var sum = reduce(valueList, function (acc, val) {
+        return acc + (isNaN(val) ? 0 : val);
+      }, 0);
+
+      if (sum === 0) {
+        return 0;
+      }
+
+      var digits = Math.pow(10, precision);
+      var votesPerQuota = map(valueList, function (val) {
+        return (isNaN(val) ? 0 : val) / sum * digits * 100;
+      });
+      var targetSeats = digits * 100;
+      var seats = map(votesPerQuota, function (votes) {
+        // Assign automatic seats.
+        return Math.floor(votes);
+      });
+      var currentSum = reduce(seats, function (acc, val) {
+        return acc + val;
+      }, 0);
+      var remainder = map(votesPerQuota, function (votes, idx) {
+        return votes - seats[idx];
+      }); // Has remainding votes.
+
+      while (currentSum < targetSeats) {
+        // Find next largest remainder.
+        var max = Number.NEGATIVE_INFINITY;
+        var maxId = null;
+
+        for (var i = 0, len = remainder.length; i < len; ++i) {
+          if (remainder[i] > max) {
+            max = remainder[i];
+            maxId = i;
+          }
+        } // Add a vote to max remainder.
+
+
+        ++seats[maxId];
+        remainder[maxId] = 0;
+        ++currentSum;
+      }
+
+      return seats[idx] / digits;
+    } // Number.MAX_SAFE_INTEGER, ie do not support.
+
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    /**
+     * To 0 - 2 * PI, considering negative radian.
+     */
+
+    function remRadian(radian) {
+      var pi2 = Math.PI * 2;
+      return (radian % pi2 + pi2) % pi2;
+    }
+    /**
+     * @param {type} radian
+     * @return {boolean}
+     */
+
+    function isRadianAroundZero(val) {
+      return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
+    } // eslint-disable-next-line
+
+    var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line
+
+    /**
+     * @param value valid type: number | string | Date, otherwise return `new Date(NaN)`
+     *   These values can be accepted:
+     *   + An instance of Date, represent a time in its own time zone.
+     *   + Or string in a subset of ISO 8601, only including:
+     *     + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
+     *     + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
+     *     + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
+     *     all of which will be treated as local time if time zone is not specified
+     *     (see <https://momentjs.com/>).
+     *   + Or other string format, including (all of which will be treated as loacal time):
+     *     '2012', '2012-3-1', '2012/3/1', '2012/03/01',
+     *     '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
+     *   + a timestamp, which represent a time in UTC.
+     * @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
+     */
+
+    function parseDate(value) {
+      if (value instanceof Date) {
+        return value;
+      } else if (typeof value === 'string') {
+        // Different browsers parse date in different way, so we parse it manually.
+        // Some other issues:
+        // new Date('1970-01-01') is UTC,
+        // new Date('1970/01/01') and new Date('1970-1-01') is local.
+        // See issue #3623
+        var match = TIME_REG.exec(value);
+
+        if (!match) {
+          // return Invalid Date.
+          return new Date(NaN);
+        } // Use local time when no timezone offset specifed.
+
+
+        if (!match[8]) {
+          // match[n] can only be string or undefined.
+          // But take care of '12' + 1 => '121'.
+          return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, +match[7] || 0);
+        } // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
+        // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
+        // For example, system timezone is set as "Time Zone: America/Toronto",
+        // then these code will get different result:
+        // `new Date(1478411999999).getTimezoneOffset();  // get 240`
+        // `new Date(1478412000000).getTimezoneOffset();  // get 300`
+        // So we should not use `new Date`, but use `Date.UTC`.
+        else {
+            var hour = +match[4] || 0;
+
+            if (match[8].toUpperCase() !== 'Z') {
+              hour -= +match[8].slice(0, 3);
+            }
+
+            return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, +match[7] || 0));
+          }
+      } else if (value == null) {
+        return new Date(NaN);
+      }
+
+      return new Date(Math.round(value));
+    }
+    /**
+     * Quantity of a number. e.g. 0.1, 1, 10, 100
+     *
+     * @param val
+     * @return
+     */
+
+    function quantity(val) {
+      return Math.pow(10, quantityExponent(val));
+    }
+    /**
+     * Exponent of the quantity of a number
+     * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
+     *
+     * @param val non-negative value
+     * @return
+     */
+
+    function quantityExponent(val) {
+      if (val === 0) {
+        return 0;
+      }
+
+      var exp = Math.floor(Math.log(val) / Math.LN10);
+      /**
+       * exp is expected to be the rounded-down result of the base-10 log of val.
+       * But due to the precision loss with Math.log(val), we need to restore it
+       * using 10^exp to make sure we can get val back from exp. #11249
+       */
+
+      if (val / Math.pow(10, exp) >= 10) {
+        exp++;
+      }
+
+      return exp;
+    }
+    /**
+     * find a “nice” number approximately equal to x. Round the number if round = true,
+     * take ceiling if round = false. The primary observation is that the “nicest”
+     * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
+     *
+     * See "Nice Numbers for Graph Labels" of Graphic Gems.
+     *
+     * @param  val Non-negative value.
+     * @param  round
+     * @return Niced number
+     */
+
+    function nice(val, round) {
+      var exponent = quantityExponent(val);
+      var exp10 = Math.pow(10, exponent);
+      var f = val / exp10; // 1 <= f < 10
+
+      var nf;
+
+      if (round) {
+        if (f < 1.5) {
+          nf = 1;
+        } else if (f < 2.5) {
+          nf = 2;
+        } else if (f < 4) {
+          nf = 3;
+        } else if (f < 7) {
+          nf = 5;
+        } else {
+          nf = 10;
+        }
+      } else {
+        if (f < 1) {
+          nf = 1;
+        } else if (f < 2) {
+          nf = 2;
+        } else if (f < 3) {
+          nf = 3;
+        } else if (f < 5) {
+          nf = 5;
+        } else {
+          nf = 10;
+        }
+      }
+
+      val = nf * exp10; // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
+      // 20 is the uppper bound of toFixed.
+
+      return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
+    }
+    /**
+     * This code was copied from "d3.js"
+     * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
+     * See the license statement at the head of this file.
+     * @param ascArr
+     */
+
+    function quantile(ascArr, p) {
+      var H = (ascArr.length - 1) * p + 1;
+      var h = Math.floor(H);
+      var v = +ascArr[h - 1];
+      var e = H - h;
+      return e ? v + e * (ascArr[h] - v) : v;
+    }
+    /**
+     * Order intervals asc, and split them when overlap.
+     * expect(numberUtil.reformIntervals([
+     *     {interval: [18, 62], close: [1, 1]},
+     *     {interval: [-Infinity, -70], close: [0, 0]},
+     *     {interval: [-70, -26], close: [1, 1]},
+     *     {interval: [-26, 18], close: [1, 1]},
+     *     {interval: [62, 150], close: [1, 1]},
+     *     {interval: [106, 150], close: [1, 1]},
+     *     {interval: [150, Infinity], close: [0, 0]}
+     * ])).toEqual([
+     *     {interval: [-Infinity, -70], close: [0, 0]},
+     *     {interval: [-70, -26], close: [1, 1]},
+     *     {interval: [-26, 18], close: [0, 1]},
+     *     {interval: [18, 62], close: [0, 1]},
+     *     {interval: [62, 150], close: [0, 1]},
+     *     {interval: [150, Infinity], close: [0, 0]}
+     * ]);
+     * @param list, where `close` mean open or close
+     *        of the interval, and Infinity can be used.
+     * @return The origin list, which has been reformed.
+     */
+
+    function reformIntervals(list) {
+      list.sort(function (a, b) {
+        return littleThan(a, b, 0) ? -1 : 1;
+      });
+      var curr = -Infinity;
+      var currClose = 1;
+
+      for (var i = 0; i < list.length;) {
+        var interval = list[i].interval;
+        var close_1 = list[i].close;
+
+        for (var lg = 0; lg < 2; lg++) {
+          if (interval[lg] <= curr) {
+            interval[lg] = curr;
+            close_1[lg] = !lg ? 1 - currClose : 1;
+          }
+
+          curr = interval[lg];
+          currClose = close_1[lg];
+        }
+
+        if (interval[0] === interval[1] && close_1[0] * close_1[1] !== 1) {
+          list.splice(i, 1);
+        } else {
+          i++;
+        }
+      }
+
+      return list;
+
+      function littleThan(a, b, lg) {
+        return a.interval[lg] < b.interval[lg] || a.interval[lg] === b.interval[lg] && (a.close[lg] - b.close[lg] === (!lg ? 1 : -1) || !lg && littleThan(a, b, 1));
+      }
+    }
+    /**
+     * [Numberic is defined as]:
+     *     `parseFloat(val) == val`
+     * For example:
+     * numeric:
+     *     typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
+     *     and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
+     * not-numeric:
+     *     null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
+     *     empty string, string with only white-spaces or line-terminal (see es spec),
+     *     0x12, '0x12', '-0x12', 012, '012', '-012',
+     *     non-string, ...
+     *
+     * @test See full test cases in `test/ut/spec/util/number.js`.
+     * @return Must be a typeof number. If not numeric, return NaN.
+     */
+
+    function numericToNumber(val) {
+      var valFloat = parseFloat(val);
+      return valFloat == val // eslint-disable-line eqeqeq
+      && (valFloat !== 0 || typeof val !== 'string' || val.indexOf('x') <= 0) // For case ' 0x0 '.
+      ? valFloat : NaN;
+    }
+    /**
+     * Definition of "numeric": see `numericToNumber`.
+     */
+
+    function isNumeric(val) {
+      return !isNaN(numericToNumber(val));
+    }
+    /**
+     * Use random base to prevent users hard code depending on
+     * this auto generated marker id.
+     * @return An positive integer.
+     */
+
+    function getRandomIdBase() {
+      return Math.round(Math.random() * 9);
+    }
+    /**
+     * Get the greatest common dividor
+     *
+     * @param {number} a one number
+     * @param {number} b the other number
+     */
+
+    function getGreatestCommonDividor(a, b) {
+      if (b === 0) {
+        return a;
+      }
+
+      return getGreatestCommonDividor(b, a % b);
+    }
+    /**
+     * Get the least common multiple
+     *
+     * @param {number} a one number
+     * @param {number} b the other number
+     */
+
+    function getLeastCommonMultiple(a, b) {
+      if (a == null) {
+        return b;
+      }
+
+      if (b == null) {
+        return a;
+      }
+
+      return a * b / getGreatestCommonDividor(a, b);
+    }
+
+    var ECHARTS_PREFIX = '[ECharts] ';
+    var storedLogs = {};
+    var hasConsole = typeof console !== 'undefined' // eslint-disable-next-line
+    && console.warn && console.log;
+    function warn(str) {
+      if (hasConsole) {
+        console.warn(ECHARTS_PREFIX + str);
+      }
+    }
+    function error(str) {
+      if (hasConsole) {
+        console.error(ECHARTS_PREFIX + str);
+      }
+    }
+    function deprecateLog(str) {
+      if ("development" !== 'production') {
+        if (storedLogs[str]) {
+          // Not display duplicate message.
+          return;
+        }
+
+        if (hasConsole) {
+          storedLogs[str] = true;
+          console.warn(ECHARTS_PREFIX + 'DEPRECATED: ' + str);
+        }
+      }
+    }
+    function deprecateReplaceLog(oldOpt, newOpt, scope) {
+      if ("development" !== 'production') {
+        deprecateLog((scope ? "[" + scope + "]" : '') + (oldOpt + " is deprecated, use " + newOpt + " instead."));
+      }
+    }
+    function consoleLog() {
+      var args = [];
+
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+
+      if ("development" !== 'production') {
+        /* eslint-disable no-console */
+        if (typeof console !== 'undefined' && console.log) {
+          console.log.apply(console, args);
+        }
+        /* eslint-enable no-console */
+
+      }
+    }
+    /**
+     * If in __DEV__ environment, get console printable message for users hint.
+     * Parameters are separated by ' '.
+     * @usuage
+     * makePrintable('This is an error on', someVar, someObj);
+     *
+     * @param hintInfo anything about the current execution context to hint users.
+     * @throws Error
+     */
+
+    function makePrintable() {
+      var hintInfo = [];
+
+      for (var _i = 0; _i < arguments.length; _i++) {
+        hintInfo[_i] = arguments[_i];
+      }
+
+      var msg = '';
+
+      if ("development" !== 'production') {
+        // Fuzzy stringify for print.
+        // This code only exist in dev environment.
+        var makePrintableStringIfPossible_1 = function (val) {
+          return val === void 0 ? 'undefined' : val === Infinity ? 'Infinity' : val === -Infinity ? '-Infinity' : eqNaN(val) ? 'NaN' : val instanceof Date ? 'Date(' + val.toISOString() + ')' : isFunction(val) ? 'function () { ... }' : isRegExp(val) ? val + '' : null;
+        };
+
+        msg = map(hintInfo, function (arg) {
+          if (isString(arg)) {
+            // Print without quotation mark for some statement.
+            return arg;
+          } else {
+            var printableStr = makePrintableStringIfPossible_1(arg);
+
+            if (printableStr != null) {
+              return printableStr;
+            } else if (typeof JSON !== 'undefined' && JSON.stringify) {
+              try {
+                return JSON.stringify(arg, function (n, val) {
+                  var printableStr = makePrintableStringIfPossible_1(val);
+                  return printableStr == null ? val : printableStr;
+                }); // In most cases the info object is small, so do not line break.
+              } catch (err) {
+                return '?';
+              }
+            } else {
+              return '?';
+            }
+          }
+        }).join(' ');
+      }
+
+      return msg;
+    }
+    /**
+     * @throws Error
+     */
+
+    function throwError(msg) {
+      throw new Error(msg);
+    }
+
+    /**
+     * Make the name displayable. But we should
+     * make sure it is not duplicated with user
+     * specified name, so use '\0';
+     */
+
+    var DUMMY_COMPONENT_NAME_PREFIX = 'series\0';
+    var INTERNAL_COMPONENT_ID_PREFIX = '\0_ec_\0';
+    /**
+     * If value is not array, then translate it to array.
+     * @param  {*} value
+     * @return {Array} [value] or value
+     */
+
+    function normalizeToArray(value) {
+      return value instanceof Array ? value : value == null ? [] : [value];
+    }
+    /**
+     * Sync default option between normal and emphasis like `position` and `show`
+     * In case some one will write code like
+     *     label: {
+     *          show: false,
+     *          position: 'outside',
+     *          fontSize: 18
+     *     },
+     *     emphasis: {
+     *          label: { show: true }
+     *     }
+     */
+
+    function defaultEmphasis(opt, key, subOpts) {
+      // Caution: performance sensitive.
+      if (opt) {
+        opt[key] = opt[key] || {};
+        opt.emphasis = opt.emphasis || {};
+        opt.emphasis[key] = opt.emphasis[key] || {}; // Default emphasis option from normal
+
+        for (var i = 0, len = subOpts.length; i < len; i++) {
+          var subOptName = subOpts[i];
+
+          if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {
+            opt.emphasis[key][subOptName] = opt[key][subOptName];
+          }
+        }
+      }
+    }
+    var TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding']; // modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([
+    //     'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',
+    //     'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',
+    //     // FIXME: deprecated, check and remove it.
+    //     'textStyle'
+    // ]);
+
+    /**
+     * The method do not ensure performance.
+     * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+     * This helper method retieves value from data.
+     */
+
+    function getDataItemValue(dataItem) {
+      return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;
+    }
+    /**
+     * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+     * This helper method determine if dataItem has extra option besides value
+     */
+
+    function isDataItemOption(dataItem) {
+      return isObject(dataItem) && !(dataItem instanceof Array); // // markLine data can be array
+      // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));
+    }
+    /**
+     * Mapping to existings for merge.
+     *
+     * Mode "normalMege":
+     *     The mapping result (merge result) will keep the order of the existing
+     *     component, rather than the order of new option. Because we should ensure
+     *     some specified index reference (like xAxisIndex) keep work.
+     *     And in most cases, "merge option" is used to update partial option but not
+     *     be expected to change the order.
+     *
+     * Mode "replaceMege":
+     *     (1) Only the id mapped components will be merged.
+     *     (2) Other existing components (except internal compoonets) will be removed.
+     *     (3) Other new options will be used to create new component.
+     *     (4) The index of the existing compoents will not be modified.
+     *     That means their might be "hole" after the removal.
+     *     The new components are created first at those available index.
+     *
+     * Mode "replaceAll":
+     *     This mode try to support that reproduce an echarts instance from another
+     *     echarts instance (via `getOption`) in some simple cases.
+     *     In this senario, the `result` index are exactly the consistent with the `newCmptOptions`,
+     *     which ensures the compoennt index referring (like `xAxisIndex: ?`) corrent. That is,
+     *     the "hole" in `newCmptOptions` will also be kept.
+     *     On the contrary, other modes try best to eliminate holes.
+     *     PENDING: This is an experimental mode yet.
+     *
+     * @return See the comment of <MappingResult>.
+     */
+
+    function mappingToExists(existings, newCmptOptions, mode) {
+      var isNormalMergeMode = mode === 'normalMerge';
+      var isReplaceMergeMode = mode === 'replaceMerge';
+      var isReplaceAllMode = mode === 'replaceAll';
+      existings = existings || [];
+      newCmptOptions = (newCmptOptions || []).slice();
+      var existingIdIdxMap = createHashMap(); // Validate id and name on user input option.
+
+      each(newCmptOptions, function (cmptOption, index) {
+        if (!isObject(cmptOption)) {
+          newCmptOptions[index] = null;
+          return;
+        }
+
+        if ("development" !== 'production') {
+          // There is some legacy case that name is set as `false`.
+          // But should work normally rather than throw error.
+          if (cmptOption.id != null && !isValidIdOrName(cmptOption.id)) {
+            warnInvalidateIdOrName(cmptOption.id);
+          }
+
+          if (cmptOption.name != null && !isValidIdOrName(cmptOption.name)) {
+            warnInvalidateIdOrName(cmptOption.name);
+          }
+        }
+      });
+      var result = prepareResult(existings, existingIdIdxMap, mode);
+
+      if (isNormalMergeMode || isReplaceMergeMode) {
+        mappingById(result, existings, existingIdIdxMap, newCmptOptions);
+      }
+
+      if (isNormalMergeMode) {
+        mappingByName(result, newCmptOptions);
+      }
+
+      if (isNormalMergeMode || isReplaceMergeMode) {
+        mappingByIndex(result, newCmptOptions, isReplaceMergeMode);
+      } else if (isReplaceAllMode) {
+        mappingInReplaceAllMode(result, newCmptOptions);
+      }
+
+      makeIdAndName(result); // The array `result` MUST NOT contain elided items, otherwise the
+      // forEach will ommit those items and result in incorrect result.
+
+      return result;
+    }
+
+    function prepareResult(existings, existingIdIdxMap, mode) {
+      var result = [];
+
+      if (mode === 'replaceAll') {
+        return result;
+      } // Do not use native `map` to in case that the array `existings`
+      // contains elided items, which will be ommited.
+
+
+      for (var index = 0; index < existings.length; index++) {
+        var existing = existings[index]; // Because of replaceMerge, `existing` may be null/undefined.
+
+        if (existing && existing.id != null) {
+          existingIdIdxMap.set(existing.id, index);
+        } // For non-internal-componnets:
+        //     Mode "normalMerge": all existings kept.
+        //     Mode "replaceMerge": all existing removed unless mapped by id.
+        // For internal-components:
+        //     go with "replaceMerge" approach in both mode.
+
+
+        result.push({
+          existing: mode === 'replaceMerge' || isComponentIdInternal(existing) ? null : existing,
+          newOption: null,
+          keyInfo: null,
+          brandNew: null
+        });
+      }
+
+      return result;
+    }
+
+    function mappingById(result, existings, existingIdIdxMap, newCmptOptions) {
+      // Mapping by id if specified.
+      each(newCmptOptions, function (cmptOption, index) {
+        if (!cmptOption || cmptOption.id == null) {
+          return;
+        }
+
+        var optionId = makeComparableKey(cmptOption.id);
+        var existingIdx = existingIdIdxMap.get(optionId);
+
+        if (existingIdx != null) {
+          var resultItem = result[existingIdx];
+          assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".');
+          resultItem.newOption = cmptOption; // In both mode, if id matched, new option will be merged to
+          // the existings rather than creating new component model.
+
+          resultItem.existing = existings[existingIdx];
+          newCmptOptions[index] = null;
+        }
+      });
+    }
+
+    function mappingByName(result, newCmptOptions) {
+      // Mapping by name if specified.
+      each(newCmptOptions, function (cmptOption, index) {
+        if (!cmptOption || cmptOption.name == null) {
+          return;
+        }
+
+        for (var i = 0; i < result.length; i++) {
+          var existing = result[i].existing;
+
+          if (!result[i].newOption // Consider name: two map to one.
+          // Can not match when both ids existing but different.
+          && existing && (existing.id == null || cmptOption.id == null) && !isComponentIdInternal(cmptOption) && !isComponentIdInternal(existing) && keyExistAndEqual('name', existing, cmptOption)) {
+            result[i].newOption = cmptOption;
+            newCmptOptions[index] = null;
+            return;
+          }
+        }
+      });
+    }
+
+    function mappingByIndex(result, newCmptOptions, brandNew) {
+      each(newCmptOptions, function (cmptOption) {
+        if (!cmptOption) {
+          return;
+        } // Find the first place that not mapped by id and not internal component (consider the "hole").
+
+
+        var resultItem;
+        var nextIdx = 0;
+
+        while ( // Be `!resultItem` only when `nextIdx >= result.length`.
+        (resultItem = result[nextIdx]) && ( // (1) Existing models that already have id should be able to mapped to. Because
+        // after mapping performed, model will always be assigned with an id if user not given.
+        // After that all models have id.
+        // (2) If new option has id, it can only set to a hole or append to the last. It should
+        // not be merged to the existings with different id. Because id should not be overwritten.
+        // (3) Name can be overwritten, because axis use name as 'show label text'.
+        resultItem.newOption || isComponentIdInternal(resultItem.existing) || // In mode "replaceMerge", here no not-mapped-non-internal-existing.
+        resultItem.existing && cmptOption.id != null && !keyExistAndEqual('id', cmptOption, resultItem.existing))) {
+          nextIdx++;
+        }
+
+        if (resultItem) {
+          resultItem.newOption = cmptOption;
+          resultItem.brandNew = brandNew;
+        } else {
+          result.push({
+            newOption: cmptOption,
+            brandNew: brandNew,
+            existing: null,
+            keyInfo: null
+          });
+        }
+
+        nextIdx++;
+      });
+    }
+
+    function mappingInReplaceAllMode(result, newCmptOptions) {
+      each(newCmptOptions, function (cmptOption) {
+        // The feature "reproduce" requires "hole" will also reproduced
+        // in case that compoennt index referring are broken.
+        result.push({
+          newOption: cmptOption,
+          brandNew: true,
+          existing: null,
+          keyInfo: null
+        });
+      });
+    }
+    /**
+     * Make id and name for mapping result (result of mappingToExists)
+     * into `keyInfo` field.
+     */
+
+
+    function makeIdAndName(mapResult) {
+      // We use this id to hash component models and view instances
+      // in echarts. id can be specified by user, or auto generated.
+      // The id generation rule ensures new view instance are able
+      // to mapped to old instance when setOption are called in
+      // no-merge mode. So we generate model id by name and plus
+      // type in view id.
+      // name can be duplicated among components, which is convenient
+      // to specify multi components (like series) by one name.
+      // Ensure that each id is distinct.
+      var idMap = createHashMap();
+      each(mapResult, function (item) {
+        var existing = item.existing;
+        existing && idMap.set(existing.id, item);
+      });
+      each(mapResult, function (item) {
+        var opt = item.newOption; // Force ensure id not duplicated.
+
+        assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));
+        opt && opt.id != null && idMap.set(opt.id, item);
+        !item.keyInfo && (item.keyInfo = {});
+      }); // Make name and id.
+
+      each(mapResult, function (item, index) {
+        var existing = item.existing;
+        var opt = item.newOption;
+        var keyInfo = item.keyInfo;
+
+        if (!isObject(opt)) {
+          return;
+        } // name can be overwitten. Consider case: axis.name = '20km'.
+        // But id generated by name will not be changed, which affect
+        // only in that case: setOption with 'not merge mode' and view
+        // instance will be recreated, which can be accepted.
+
+
+        keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name // Avoid diffferent series has the same name,
+        // because name may be used like in color pallet.
+        : DUMMY_COMPONENT_NAME_PREFIX + index;
+
+        if (existing) {
+          keyInfo.id = makeComparableKey(existing.id);
+        } else if (opt.id != null) {
+          keyInfo.id = makeComparableKey(opt.id);
+        } else {
+          // Consider this situatoin:
+          //  optionA: [{name: 'a'}, {name: 'a'}, {..}]
+          //  optionB [{..}, {name: 'a'}, {name: 'a'}]
+          // Series with the same name between optionA and optionB
+          // should be mapped.
+          var idNum = 0;
+
+          do {
+            keyInfo.id = '\0' + keyInfo.name + '\0' + idNum++;
+          } while (idMap.get(keyInfo.id));
+        }
+
+        idMap.set(keyInfo.id, item);
+      });
+    }
+
+    function keyExistAndEqual(attr, obj1, obj2) {
+      var key1 = convertOptionIdName(obj1[attr], null);
+      var key2 = convertOptionIdName(obj2[attr], null); // See `MappingExistingItem`. `id` and `name` trade string equals to number.
+
+      return key1 != null && key2 != null && key1 === key2;
+    }
+    /**
+     * @return return null if not exist.
+     */
+
+
+    function makeComparableKey(val) {
+      if ("development" !== 'production') {
+        if (val == null) {
+          throw new Error();
+        }
+      }
+
+      return convertOptionIdName(val, '');
+    }
+
+    function convertOptionIdName(idOrName, defaultValue) {
+      if (idOrName == null) {
+        return defaultValue;
+      }
+
+      var type = typeof idOrName;
+      return type === 'string' ? idOrName : type === 'number' || isStringSafe(idOrName) ? idOrName + '' : defaultValue;
+    }
+
+    function warnInvalidateIdOrName(idOrName) {
+      if ("development" !== 'production') {
+        warn('`' + idOrName + '` is invalid id or name. Must be a string or number.');
+      }
+    }
+
+    function isValidIdOrName(idOrName) {
+      return isStringSafe(idOrName) || isNumeric(idOrName);
+    }
+
+    function isNameSpecified(componentModel) {
+      var name = componentModel.name; // Is specified when `indexOf` get -1 or > 0.
+
+      return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));
+    }
+    /**
+     * @public
+     * @param {Object} cmptOption
+     * @return {boolean}
+     */
+
+    function isComponentIdInternal(cmptOption) {
+      return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0;
+    }
+    function makeInternalComponentId(idSuffix) {
+      return INTERNAL_COMPONENT_ID_PREFIX + idSuffix;
+    }
+    function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) {
+      // Set mainType and complete subType.
+      each(mappingResult, function (item) {
+        var newOption = item.newOption;
+
+        if (isObject(newOption)) {
+          item.keyInfo.mainType = mainType;
+          item.keyInfo.subType = determineSubType(mainType, newOption, item.existing, componentModelCtor);
+        }
+      });
+    }
+
+    function determineSubType(mainType, newCmptOption, existComponent, componentModelCtor) {
+      var subType = newCmptOption.type ? newCmptOption.type : existComponent ? existComponent.subType // Use determineSubType only when there is no existComponent.
+      : componentModelCtor.determineSubType(mainType, newCmptOption); // tooltip, markline, markpoint may always has no subType
+
+      return subType;
+    }
+    /**
+     * A helper for removing duplicate items between batchA and batchB,
+     * and in themselves, and categorize by series.
+     *
+     * @param batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+     * @param batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+     * @return result: [resultBatchA, resultBatchB]
+     */
+
+
+    function compressBatches(batchA, batchB) {
+      var mapA = {};
+      var mapB = {};
+      makeMap(batchA || [], mapA);
+      makeMap(batchB || [], mapB, mapA);
+      return [mapToArray(mapA), mapToArray(mapB)];
+
+      function makeMap(sourceBatch, map, otherMap) {
+        for (var i = 0, len = sourceBatch.length; i < len; i++) {
+          var seriesId = convertOptionIdName(sourceBatch[i].seriesId, null);
+
+          if (seriesId == null) {
+            return;
+          }
+
+          var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);
+          var otherDataIndices = otherMap && otherMap[seriesId];
+
+          for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {
+            var dataIndex = dataIndices[j];
+
+            if (otherDataIndices && otherDataIndices[dataIndex]) {
+              otherDataIndices[dataIndex] = null;
+            } else {
+              (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;
+            }
+          }
+        }
+      }
+
+      function mapToArray(map, isData) {
+        var result = [];
+
+        for (var i in map) {
+          if (map.hasOwnProperty(i) && map[i] != null) {
+            if (isData) {
+              result.push(+i);
+            } else {
+              var dataIndices = mapToArray(map[i], true);
+              dataIndices.length && result.push({
+                seriesId: i,
+                dataIndex: dataIndices
+              });
+            }
+          }
+        }
+
+        return result;
+      }
+    }
+    /**
+     * @param payload Contains dataIndex (means rawIndex) / dataIndexInside / name
+     *                         each of which can be Array or primary type.
+     * @return dataIndex If not found, return undefined/null.
+     */
+
+    function queryDataIndex(data, payload) {
+      if (payload.dataIndexInside != null) {
+        return payload.dataIndexInside;
+      } else if (payload.dataIndex != null) {
+        return isArray(payload.dataIndex) ? map(payload.dataIndex, function (value) {
+          return data.indexOfRawIndex(value);
+        }) : data.indexOfRawIndex(payload.dataIndex);
+      } else if (payload.name != null) {
+        return isArray(payload.name) ? map(payload.name, function (value) {
+          return data.indexOfName(value);
+        }) : data.indexOfName(payload.name);
+      }
+    }
+    /**
+     * Enable property storage to any host object.
+     * Notice: Serialization is not supported.
+     *
+     * For example:
+     * let inner = zrUitl.makeInner();
+     *
+     * function some1(hostObj) {
+     *      inner(hostObj).someProperty = 1212;
+     *      ...
+     * }
+     * function some2() {
+     *      let fields = inner(this);
+     *      fields.someProperty1 = 1212;
+     *      fields.someProperty2 = 'xx';
+     *      ...
+     * }
+     *
+     * @return {Function}
+     */
+
+    function makeInner() {
+      var key = '__ec_inner_' + innerUniqueIndex++;
+      return function (hostObj) {
+        return hostObj[key] || (hostObj[key] = {});
+      };
+    }
+    var innerUniqueIndex = getRandomIdBase();
+    /**
+     * The same behavior as `component.getReferringComponents`.
+     */
+
+    function parseFinder(ecModel, finderInput, opt) {
+      var finder;
+
+      if (isString(finderInput)) {
+        var obj = {};
+        obj[finderInput + 'Index'] = 0;
+        finder = obj;
+      } else {
+        finder = finderInput;
+      }
+
+      var queryOptionMap = createHashMap();
+      var result = {};
+      var mainTypeSpecified = false;
+      each(finder, function (value, key) {
+        // Exclude 'dataIndex' and other illgal keys.
+        if (key === 'dataIndex' || key === 'dataIndexInside') {
+          result[key] = value;
+          return;
+        }
+
+        var parsedKey = key.match(/^(\w+)(Index|Id|Name)$/) || [];
+        var mainType = parsedKey[1];
+        var queryType = (parsedKey[2] || '').toLowerCase();
+
+        if (!mainType || !queryType || opt && opt.includeMainTypes && indexOf(opt.includeMainTypes, mainType) < 0) {
+          return;
+        }
+
+        mainTypeSpecified = mainTypeSpecified || !!mainType;
+        var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {});
+        queryOption[queryType] = value;
+      });
+      var defaultMainType = opt ? opt.defaultMainType : null;
+
+      if (!mainTypeSpecified && defaultMainType) {
+        queryOptionMap.set(defaultMainType, {});
+      }
+
+      queryOptionMap.each(function (queryOption, mainType) {
+        var queryResult = queryReferringComponents(ecModel, mainType, queryOption, {
+          useDefault: defaultMainType === mainType,
+          enableAll: opt && opt.enableAll != null ? opt.enableAll : true,
+          enableNone: opt && opt.enableNone != null ? opt.enableNone : true
+        });
+        result[mainType + 'Models'] = queryResult.models;
+        result[mainType + 'Model'] = queryResult.models[0];
+      });
+      return result;
+    }
+    var SINGLE_REFERRING = {
+      useDefault: true,
+      enableAll: false,
+      enableNone: false
+    };
+    var MULTIPLE_REFERRING = {
+      useDefault: false,
+      enableAll: true,
+      enableNone: true
+    };
+    function queryReferringComponents(ecModel, mainType, userOption, opt) {
+      opt = opt || SINGLE_REFERRING;
+      var indexOption = userOption.index;
+      var idOption = userOption.id;
+      var nameOption = userOption.name;
+      var result = {
+        models: null,
+        specified: indexOption != null || idOption != null || nameOption != null
+      };
+
+      if (!result.specified) {
+        // Use the first as default if `useDefault`.
+        var firstCmpt = void 0;
+        result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : [];
+        return result;
+      }
+
+      if (indexOption === 'none' || indexOption === false) {
+        assert(opt.enableNone, '`"none"` or `false` is not a valid value on index option.');
+        result.models = [];
+        return result;
+      } // `queryComponents` will return all components if
+      // both all of index/id/name are null/undefined.
+
+
+      if (indexOption === 'all') {
+        assert(opt.enableAll, '`"all"` is not a valid value on index option.');
+        indexOption = idOption = nameOption = null;
+      }
+
+      result.models = ecModel.queryComponents({
+        mainType: mainType,
+        index: indexOption,
+        id: idOption,
+        name: nameOption
+      });
+      return result;
+    }
+    function setAttribute(dom, key, value) {
+      dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;
+    }
+    function getAttribute(dom, key) {
+      return dom.getAttribute ? dom.getAttribute(key) : dom[key];
+    }
+    function getTooltipRenderMode(renderModeOption) {
+      if (renderModeOption === 'auto') {
+        // Using html when `document` exists, use richText otherwise
+        return env.domSupported ? 'html' : 'richText';
+      } else {
+        return renderModeOption || 'html';
+      }
+    }
+    /**
+     * Group a list by key.
+     */
+
+    function groupData(array, getKey // return key
+    ) {
+      var buckets = createHashMap();
+      var keys = [];
+      each(array, function (item) {
+        var key = getKey(item);
+        (buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);
+      });
+      return {
+        keys: keys,
+        buckets: buckets
+      };
+    }
+    /**
+     * Interpolate raw values of a series with percent
+     *
+     * @param data         data
+     * @param labelModel   label model of the text element
+     * @param sourceValue  start value. May be null/undefined when init.
+     * @param targetValue  end value
+     * @param percent      0~1 percentage; 0 uses start value while 1 uses end value
+     * @return             interpolated values
+     *                     If `sourceValue` and `targetValue` are `number`, return `number`.
+     *                     If `sourceValue` and `targetValue` are `string`, return `string`.
+     *                     If `sourceValue` and `targetValue` are `(string | number)[]`, return `(string | number)[]`.
+     *                     Other cases do not supported.
+     */
+
+    function interpolateRawValues(data, precision, sourceValue, targetValue, percent) {
+      var isAutoPrecision = precision == null || precision === 'auto';
+
+      if (targetValue == null) {
+        return targetValue;
+      }
+
+      if (typeof targetValue === 'number') {
+        var value = interpolateNumber(sourceValue || 0, targetValue, percent);
+        return round(value, isAutoPrecision ? Math.max(getPrecisionSafe(sourceValue || 0), getPrecisionSafe(targetValue)) : precision);
+      } else if (typeof targetValue === 'string') {
+        return percent < 1 ? sourceValue : targetValue;
+      } else {
+        var interpolated = [];
+        var leftArr = sourceValue;
+        var rightArr = targetValue;
+        var length_1 = Math.max(leftArr ? leftArr.length : 0, rightArr.length);
+
+        for (var i = 0; i < length_1; ++i) {
+          var info = data.getDimensionInfo(i); // Don't interpolate ordinal dims
+
+          if (info.type === 'ordinal') {
+            // In init, there is no `sourceValue`, but should better not to get undefined result.
+            interpolated[i] = (percent < 1 && leftArr ? leftArr : rightArr)[i];
+          } else {
+            var leftVal = leftArr && leftArr[i] ? leftArr[i] : 0;
+            var rightVal = rightArr[i];
+            var value = interpolateNumber(leftVal, rightVal, percent);
+            interpolated[i] = round(value, isAutoPrecision ? Math.max(getPrecisionSafe(leftVal), getPrecisionSafe(rightVal)) : precision);
+          }
+        }
+
+        return interpolated;
+      }
+    }
+
+    var TYPE_DELIMITER = '.';
+    var IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';
+    var IS_EXTENDED_CLASS = '___EC__EXTENDED_CLASS___';
+    /**
+     * Notice, parseClassType('') should returns {main: '', sub: ''}
+     * @public
+     */
+
+    function parseClassType(componentType) {
+      var ret = {
+        main: '',
+        sub: ''
+      };
+
+      if (componentType) {
+        var typeArr = componentType.split(TYPE_DELIMITER);
+        ret.main = typeArr[0] || '';
+        ret.sub = typeArr[1] || '';
+      }
+
+      return ret;
+    }
+    /**
+     * @public
+     */
+
+    function checkClassType(componentType) {
+      assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal');
+    }
+
+    function isExtendedClass(clz) {
+      return !!(clz && clz[IS_EXTENDED_CLASS]);
+    }
+    /**
+     * Implements `ExtendableConstructor` for `rootClz`.
+     *
+     * @usage
+     * ```ts
+     * class Xxx {}
+     * type XxxConstructor = typeof Xxx & ExtendableConstructor
+     * enableClassExtend(Xxx as XxxConstructor);
+     * ```
+     */
+
+    function enableClassExtend(rootClz, mandatoryMethods) {
+      rootClz.$constructor = rootClz; // FIXME: not necessary?
+
+      rootClz.extend = function (proto) {
+        if ("development" !== 'production') {
+          each(mandatoryMethods, function (method) {
+            if (!proto[method]) {
+              console.warn('Method `' + method + '` should be implemented' + (proto.type ? ' in ' + proto.type : '') + '.');
+            }
+          });
+        }
+
+        var superClass = this; // For backward compat, we both support ts class inheritance and this
+        // "extend" approach.
+        // The constructor should keep the same behavior as ts class inheritance:
+        // If this constructor/$constructor is not declared, auto invoke the super
+        // constructor.
+        // If this constructor/$constructor is declared, it is responsible for
+        // calling the super constructor.
+
+        function ExtendedClass() {
+          var args = [];
+
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+
+          if (!proto.$constructor) {
+            if (!isESClass(superClass)) {
+              // Will throw error if superClass is an es6 native class.
+              superClass.apply(this, arguments);
+            } else {
+              var ins = createObject( // @ts-ignore
+              ExtendedClass.prototype, new (superClass.bind.apply(superClass, __spreadArrays([void 0], args)))());
+              return ins;
+            }
+          } else {
+            proto.$constructor.apply(this, arguments);
+          }
+        }
+
+        ExtendedClass[IS_EXTENDED_CLASS] = true;
+        extend(ExtendedClass.prototype, proto);
+        ExtendedClass.extend = this.extend;
+        ExtendedClass.superCall = superCall;
+        ExtendedClass.superApply = superApply;
+        inherits(ExtendedClass, this);
+        ExtendedClass.superClass = superClass;
+        return ExtendedClass;
+      };
+    }
+
+    function isESClass(fn) {
+      return typeof fn === 'function' && /^class\s/.test(Function.prototype.toString.call(fn));
+    }
+    /**
+     * A work around to both support ts extend and this extend mechanism.
+     * on sub-class.
+     * @usage
+     * ```ts
+     * class Component { ... }
+     * classUtil.enableClassExtend(Component);
+     * classUtil.enableClassManagement(Component, {registerWhenExtend: true});
+     *
+     * class Series extends Component { ... }
+     * // Without calling `markExtend`, `registerWhenExtend` will not work.
+     * Component.markExtend(Series);
+     * ```
+     */
+
+
+    function mountExtend(SubClz, SupperClz) {
+      SubClz.extend = SupperClz.extend;
+    } // A random offset.
+
+    var classBase = Math.round(Math.random() * 10);
+    /**
+     * Implements `CheckableConstructor` for `target`.
+     * Can not use instanceof, consider different scope by
+     * cross domain or es module import in ec extensions.
+     * Mount a method "isInstance()" to Clz.
+     *
+     * @usage
+     * ```ts
+     * class Xxx {}
+     * type XxxConstructor = typeof Xxx & CheckableConstructor;
+     * enableClassCheck(Xxx as XxxConstructor)
+     * ```
+     */
+
+    function enableClassCheck(target) {
+      var classAttr = ['__\0is_clz', classBase++].join('_');
+      target.prototype[classAttr] = true;
+
+      if ("development" !== 'production') {
+        assert(!target.isInstance, 'The method "is" can not be defined.');
+      }
+
+      target.isInstance = function (obj) {
+        return !!(obj && obj[classAttr]);
+      };
+    } // superCall should have class info, which can not be fetch from 'this'.
+    // Consider this case:
+    // class A has method f,
+    // class B inherits class A, overrides method f, f call superApply('f'),
+    // class C inherits class B, do not overrides method f,
+    // then when method of class C is called, dead loop occured.
+
+    function superCall(context, methodName) {
+      var args = [];
+
+      for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+      }
+
+      return this.superClass.prototype[methodName].apply(context, args);
+    }
+
+    function superApply(context, methodName, args) {
+      return this.superClass.prototype[methodName].apply(context, args);
+    }
+    /**
+     * Implements `ClassManager` for `target`
+     *
+     * @usage
+     * ```ts
+     * class Xxx {}
+     * type XxxConstructor = typeof Xxx & ClassManager
+     * enableClassManagement(Xxx as XxxConstructor);
+     * ```
+     */
+
+
+    function enableClassManagement(target) {
+      /**
+       * Component model classes
+       * key: componentType,
+       * value:
+       *     componentClass, when componentType is 'xxx'
+       *     or Object.<subKey, componentClass>, when componentType is 'xxx.yy'
+       */
+      var storage = {};
+
+      target.registerClass = function (clz) {
+        // `type` should not be a "instance memeber".
+        // If using TS class, should better declared as `static type = 'series.pie'`.
+        // otherwise users have to mount `type` on prototype manually.
+        // For backward compat and enable instance visit type via `this.type`,
+        // we stil support fetch `type` from prototype.
+        var componentFullType = clz.type || clz.prototype.type;
+
+        if (componentFullType) {
+          checkClassType(componentFullType); // If only static type declared, we assign it to prototype mandatorily.
+
+          clz.prototype.type = componentFullType;
+          var componentTypeInfo = parseClassType(componentFullType);
+
+          if (!componentTypeInfo.sub) {
+            if ("development" !== 'production') {
+              if (storage[componentTypeInfo.main]) {
+                console.warn(componentTypeInfo.main + ' exists.');
+              }
+            }
+
+            storage[componentTypeInfo.main] = clz;
+          } else if (componentTypeInfo.sub !== IS_CONTAINER) {
+            var container = makeContainer(componentTypeInfo);
+            container[componentTypeInfo.sub] = clz;
+          }
+        }
+
+        return clz;
+      };
+
+      target.getClass = function (mainType, subType, throwWhenNotFound) {
+        var clz = storage[mainType];
+
+        if (clz && clz[IS_CONTAINER]) {
+          clz = subType ? clz[subType] : null;
+        }
+
+        if (throwWhenNotFound && !clz) {
+          throw new Error(!subType ? mainType + '.' + 'type should be specified.' : 'Component ' + mainType + '.' + (subType || '') + ' not exists. Load it first.');
+        }
+
+        return clz;
+      };
+
+      target.getClassesByMainType = function (componentType) {
+        var componentTypeInfo = parseClassType(componentType);
+        var result = [];
+        var obj = storage[componentTypeInfo.main];
+
+        if (obj && obj[IS_CONTAINER]) {
+          each(obj, function (o, type) {
+            type !== IS_CONTAINER && result.push(o);
+          });
+        } else {
+          result.push(obj);
+        }
+
+        return result;
+      };
+
+      target.hasClass = function (componentType) {
+        // Just consider componentType.main.
+        var componentTypeInfo = parseClassType(componentType);
+        return !!storage[componentTypeInfo.main];
+      };
+      /**
+       * @return Like ['aa', 'bb'], but can not be ['aa.xx']
+       */
+
+
+      target.getAllClassMainTypes = function () {
+        var types = [];
+        each(storage, function (obj, type) {
+          types.push(type);
+        });
+        return types;
+      };
+      /**
+       * If a main type is container and has sub types
+       */
+
+
+      target.hasSubTypes = function (componentType) {
+        var componentTypeInfo = parseClassType(componentType);
+        var obj = storage[componentTypeInfo.main];
+        return obj && obj[IS_CONTAINER];
+      };
+
+      function makeContainer(componentTypeInfo) {
+        var container = storage[componentTypeInfo.main];
+
+        if (!container || !container[IS_CONTAINER]) {
+          container = storage[componentTypeInfo.main] = {};
+          container[IS_CONTAINER] = true;
+        }
+
+        return container;
+      }
+    } // /**
+    //  * @param {string|Array.<string>} properties
+    //  */
+    // export function setReadOnly(obj, properties) {
+    // FIXME It seems broken in IE8 simulation of IE11
+    // if (!zrUtil.isArray(properties)) {
+    //     properties = properties != null ? [properties] : [];
+    // }
+    // zrUtil.each(properties, function (prop) {
+    //     let value = obj[prop];
+    //     Object.defineProperty
+    //         && Object.defineProperty(obj, prop, {
+    //             value: value, writable: false
+    //         });
+    //     zrUtil.isArray(obj[prop])
+    //         && Object.freeze
+    //         && Object.freeze(obj[prop]);
+    // });
+    // }
+
+    function makeStyleMapper(properties, ignoreParent) {
+      // Normalize
+      for (var i = 0; i < properties.length; i++) {
+        if (!properties[i][1]) {
+          properties[i][1] = properties[i][0];
+        }
+      }
+
+      ignoreParent = ignoreParent || false;
+      return function (model, excludes, includes) {
+        var style = {};
+
+        for (var i = 0; i < properties.length; i++) {
+          var propName = properties[i][1];
+
+          if (excludes && indexOf(excludes, propName) >= 0 || includes && indexOf(includes, propName) < 0) {
+            continue;
+          }
+
+          var val = model.getShallow(propName, ignoreParent);
+
+          if (val != null) {
+            style[properties[i][0]] = val;
+          }
+        } // TODO Text or image?
+
+
+        return style;
+      };
+    }
+
+    var AREA_STYLE_KEY_MAP = [['fill', 'color'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['opacity'], ['shadowColor'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+    // So do not transfer decal directly.
+    ];
+    var getAreaStyle = makeStyleMapper(AREA_STYLE_KEY_MAP);
+
+    var AreaStyleMixin =
+    /** @class */
+    function () {
+      function AreaStyleMixin() {}
+
+      AreaStyleMixin.prototype.getAreaStyle = function (excludes, includes) {
+        return getAreaStyle(this, excludes, includes);
+      };
+
+      return AreaStyleMixin;
+    }();
+
+    var globalImageCache = new LRU(50);
+    function findExistImage(newImageOrSrc) {
+        if (typeof newImageOrSrc === 'string') {
+            var cachedImgObj = globalImageCache.get(newImageOrSrc);
+            return cachedImgObj && cachedImgObj.image;
+        }
+        else {
+            return newImageOrSrc;
+        }
+    }
+    function createOrUpdateImage(newImageOrSrc, image, hostEl, onload, cbPayload) {
+        if (!newImageOrSrc) {
+            return image;
+        }
+        else if (typeof newImageOrSrc === 'string') {
+            if ((image && image.__zrImageSrc === newImageOrSrc) || !hostEl) {
+                return image;
+            }
+            var cachedImgObj = globalImageCache.get(newImageOrSrc);
+            var pendingWrap = { hostEl: hostEl, cb: onload, cbPayload: cbPayload };
+            if (cachedImgObj) {
+                image = cachedImgObj.image;
+                !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);
+            }
+            else {
+                image = new Image();
+                image.onload = image.onerror = imageOnLoad;
+                globalImageCache.put(newImageOrSrc, image.__cachedImgObj = {
+                    image: image,
+                    pending: [pendingWrap]
+                });
+                image.src = image.__zrImageSrc = newImageOrSrc;
+            }
+            return image;
+        }
+        else {
+            return newImageOrSrc;
+        }
+    }
+    function imageOnLoad() {
+        var cachedImgObj = this.__cachedImgObj;
+        this.onload = this.onerror = this.__cachedImgObj = null;
+        for (var i = 0; i < cachedImgObj.pending.length; i++) {
+            var pendingWrap = cachedImgObj.pending[i];
+            var cb = pendingWrap.cb;
+            cb && cb(this, pendingWrap.cbPayload);
+            pendingWrap.hostEl.dirty();
+        }
+        cachedImgObj.pending.length = 0;
+    }
+    function isImageReady(image) {
+        return image && image.width && image.height;
+    }
+
+    var STYLE_REG = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g;
+    function truncateText(text, containerWidth, font, ellipsis, options) {
+        if (!containerWidth) {
+            return '';
+        }
+        var textLines = (text + '').split('\n');
+        options = prepareTruncateOptions(containerWidth, font, ellipsis, options);
+        for (var i = 0, len = textLines.length; i < len; i++) {
+            textLines[i] = truncateSingleLine(textLines[i], options);
+        }
+        return textLines.join('\n');
+    }
+    function prepareTruncateOptions(containerWidth, font, ellipsis, options) {
+        options = options || {};
+        var preparedOpts = extend({}, options);
+        preparedOpts.font = font;
+        ellipsis = retrieve2(ellipsis, '...');
+        preparedOpts.maxIterations = retrieve2(options.maxIterations, 2);
+        var minChar = preparedOpts.minChar = retrieve2(options.minChar, 0);
+        preparedOpts.cnCharWidth = getWidth('国', font);
+        var ascCharWidth = preparedOpts.ascCharWidth = getWidth('a', font);
+        preparedOpts.placeholder = retrieve2(options.placeholder, '');
+        var contentWidth = containerWidth = Math.max(0, containerWidth - 1);
+        for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {
+            contentWidth -= ascCharWidth;
+        }
+        var ellipsisWidth = getWidth(ellipsis, font);
+        if (ellipsisWidth > contentWidth) {
+            ellipsis = '';
+            ellipsisWidth = 0;
+        }
+        contentWidth = containerWidth - ellipsisWidth;
+        preparedOpts.ellipsis = ellipsis;
+        preparedOpts.ellipsisWidth = ellipsisWidth;
+        preparedOpts.contentWidth = contentWidth;
+        preparedOpts.containerWidth = containerWidth;
+        return preparedOpts;
+    }
+    function truncateSingleLine(textLine, options) {
+        var containerWidth = options.containerWidth;
+        var font = options.font;
+        var contentWidth = options.contentWidth;
+        if (!containerWidth) {
+            return '';
+        }
+        var lineWidth = getWidth(textLine, font);
+        if (lineWidth <= containerWidth) {
+            return textLine;
+        }
+        for (var j = 0;; j++) {
+            if (lineWidth <= contentWidth || j >= options.maxIterations) {
+                textLine += options.ellipsis;
+                break;
+            }
+            var subLength = j === 0
+                ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth)
+                : lineWidth > 0
+                    ? Math.floor(textLine.length * contentWidth / lineWidth)
+                    : 0;
+            textLine = textLine.substr(0, subLength);
+            lineWidth = getWidth(textLine, font);
+        }
+        if (textLine === '') {
+            textLine = options.placeholder;
+        }
+        return textLine;
+    }
+    function estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {
+        var width = 0;
+        var i = 0;
+        for (var len = text.length; i < len && width < contentWidth; i++) {
+            var charCode = text.charCodeAt(i);
+            width += (0 <= charCode && charCode <= 127) ? ascCharWidth : cnCharWidth;
+        }
+        return i;
+    }
+    function parsePlainText(text, style) {
+        text != null && (text += '');
+        var overflow = style.overflow;
+        var padding = style.padding;
+        var font = style.font;
+        var truncate = overflow === 'truncate';
+        var calculatedLineHeight = getLineHeight(font);
+        var lineHeight = retrieve2(style.lineHeight, calculatedLineHeight);
+        var truncateLineOverflow = style.lineOverflow === 'truncate';
+        var width = style.width;
+        var lines;
+        if (width != null && overflow === 'break' || overflow === 'breakAll') {
+            lines = text ? wrapText(text, style.font, width, overflow === 'breakAll', 0).lines : [];
+        }
+        else {
+            lines = text ? text.split('\n') : [];
+        }
+        var contentHeight = lines.length * lineHeight;
+        var height = retrieve2(style.height, contentHeight);
+        if (contentHeight > height && truncateLineOverflow) {
+            var lineCount = Math.floor(height / lineHeight);
+            lines = lines.slice(0, lineCount);
+        }
+        var outerHeight = height;
+        var outerWidth = width;
+        if (padding) {
+            outerHeight += padding[0] + padding[2];
+            if (outerWidth != null) {
+                outerWidth += padding[1] + padding[3];
+            }
+        }
+        if (text && truncate && outerWidth != null) {
+            var options = prepareTruncateOptions(width, font, style.ellipsis, {
+                minChar: style.truncateMinChar,
+                placeholder: style.placeholder
+            });
+            for (var i = 0; i < lines.length; i++) {
+                lines[i] = truncateSingleLine(lines[i], options);
+            }
+        }
+        if (width == null) {
+            var maxWidth = 0;
+            for (var i = 0; i < lines.length; i++) {
+                maxWidth = Math.max(getWidth(lines[i], font), maxWidth);
+            }
+            width = maxWidth;
+        }
+        return {
+            lines: lines,
+            height: height,
+            outerHeight: outerHeight,
+            lineHeight: lineHeight,
+            calculatedLineHeight: calculatedLineHeight,
+            contentHeight: contentHeight,
+            width: width
+        };
+    }
+    var RichTextToken = (function () {
+        function RichTextToken() {
+        }
+        return RichTextToken;
+    }());
+    var RichTextLine = (function () {
+        function RichTextLine(tokens) {
+            this.tokens = [];
+            if (tokens) {
+                this.tokens = tokens;
+            }
+        }
+        return RichTextLine;
+    }());
+    var RichTextContentBlock = (function () {
+        function RichTextContentBlock() {
+            this.width = 0;
+            this.height = 0;
+            this.contentWidth = 0;
+            this.contentHeight = 0;
+            this.outerWidth = 0;
+            this.outerHeight = 0;
+            this.lines = [];
+        }
+        return RichTextContentBlock;
+    }());
+    function parseRichText(text, style) {
+        var contentBlock = new RichTextContentBlock();
+        text != null && (text += '');
+        if (!text) {
+            return contentBlock;
+        }
+        var topWidth = style.width;
+        var topHeight = style.height;
+        var overflow = style.overflow;
+        var wrapInfo = (overflow === 'break' || overflow === 'breakAll') && topWidth != null
+            ? { width: topWidth, accumWidth: 0, breakAll: overflow === 'breakAll' }
+            : null;
+        var lastIndex = STYLE_REG.lastIndex = 0;
+        var result;
+        while ((result = STYLE_REG.exec(text)) != null) {
+            var matchedIndex = result.index;
+            if (matchedIndex > lastIndex) {
+                pushTokens(contentBlock, text.substring(lastIndex, matchedIndex), style, wrapInfo);
+            }
+            pushTokens(contentBlock, result[2], style, wrapInfo, result[1]);
+            lastIndex = STYLE_REG.lastIndex;
+        }
+        if (lastIndex < text.length) {
+            pushTokens(contentBlock, text.substring(lastIndex, text.length), style, wrapInfo);
+        }
+        var pendingList = [];
+        var calculatedHeight = 0;
+        var calculatedWidth = 0;
+        var stlPadding = style.padding;
+        var truncate = overflow === 'truncate';
+        var truncateLine = style.lineOverflow === 'truncate';
+        function finishLine(line, lineWidth, lineHeight) {
+            line.width = lineWidth;
+            line.lineHeight = lineHeight;
+            calculatedHeight += lineHeight;
+            calculatedWidth = Math.max(calculatedWidth, lineWidth);
+        }
+        outer: for (var i = 0; i < contentBlock.lines.length; i++) {
+            var line = contentBlock.lines[i];
+            var lineHeight = 0;
+            var lineWidth = 0;
+            for (var j = 0; j < line.tokens.length; j++) {
+                var token = line.tokens[j];
+                var tokenStyle = token.styleName && style.rich[token.styleName] || {};
+                var textPadding = token.textPadding = tokenStyle.padding;
+                var paddingH = textPadding ? textPadding[1] + textPadding[3] : 0;
+                var font = token.font = tokenStyle.font || style.font;
+                token.contentHeight = getLineHeight(font);
+                var tokenHeight = retrieve2(tokenStyle.height, token.contentHeight);
+                token.innerHeight = tokenHeight;
+                textPadding && (tokenHeight += textPadding[0] + textPadding[2]);
+                token.height = tokenHeight;
+                token.lineHeight = retrieve3(tokenStyle.lineHeight, style.lineHeight, tokenHeight);
+                token.align = tokenStyle && tokenStyle.align || style.align;
+                token.verticalAlign = tokenStyle && tokenStyle.verticalAlign || 'middle';
+                if (truncateLine && topHeight != null && calculatedHeight + token.lineHeight > topHeight) {
+                    if (j > 0) {
+                        line.tokens = line.tokens.slice(0, j);
+                        finishLine(line, lineWidth, lineHeight);
+                        contentBlock.lines = contentBlock.lines.slice(0, i + 1);
+                    }
+                    else {
+                        contentBlock.lines = contentBlock.lines.slice(0, i);
+                    }
+                    break outer;
+                }
+                var styleTokenWidth = tokenStyle.width;
+                var tokenWidthNotSpecified = styleTokenWidth == null || styleTokenWidth === 'auto';
+                if (typeof styleTokenWidth === 'string' && styleTokenWidth.charAt(styleTokenWidth.length - 1) === '%') {
+                    token.percentWidth = styleTokenWidth;
+                    pendingList.push(token);
+                    token.contentWidth = getWidth(token.text, font);
+                }
+                else {
+                    if (tokenWidthNotSpecified) {
+                        var textBackgroundColor = tokenStyle.backgroundColor;
+                        var bgImg = textBackgroundColor && textBackgroundColor.image;
+                        if (bgImg) {
+                            bgImg = findExistImage(bgImg);
+                            if (isImageReady(bgImg)) {
+                                token.width = Math.max(token.width, bgImg.width * tokenHeight / bgImg.height);
+                            }
+                        }
+                    }
+                    var remainTruncWidth = truncate && topWidth != null
+                        ? topWidth - lineWidth : null;
+                    if (remainTruncWidth != null && remainTruncWidth < token.width) {
+                        if (!tokenWidthNotSpecified || remainTruncWidth < paddingH) {
+                            token.text = '';
+                            token.width = token.contentWidth = 0;
+                        }
+                        else {
+                            token.text = truncateText(token.text, remainTruncWidth - paddingH, font, style.ellipsis, { minChar: style.truncateMinChar });
+                            token.width = token.contentWidth = getWidth(token.text, font);
+                        }
+                    }
+                    else {
+                        token.contentWidth = getWidth(token.text, font);
+                    }
+                }
+                token.width += paddingH;
+                lineWidth += token.width;
+                tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));
+            }
+            finishLine(line, lineWidth, lineHeight);
+        }
+        contentBlock.outerWidth = contentBlock.width = retrieve2(topWidth, calculatedWidth);
+        contentBlock.outerHeight = contentBlock.height = retrieve2(topHeight, calculatedHeight);
+        contentBlock.contentHeight = calculatedHeight;
+        contentBlock.contentWidth = calculatedWidth;
+        if (stlPadding) {
+            contentBlock.outerWidth += stlPadding[1] + stlPadding[3];
+            contentBlock.outerHeight += stlPadding[0] + stlPadding[2];
+        }
+        for (var i = 0; i < pendingList.length; i++) {
+            var token = pendingList[i];
+            var percentWidth = token.percentWidth;
+            token.width = parseInt(percentWidth, 10) / 100 * contentBlock.width;
+        }
+        return contentBlock;
+    }
+    function pushTokens(block, str, style, wrapInfo, styleName) {
+        var isEmptyStr = str === '';
+        var tokenStyle = styleName && style.rich[styleName] || {};
+        var lines = block.lines;
+        var font = tokenStyle.font || style.font;
+        var newLine = false;
+        var strLines;
+        var linesWidths;
+        if (wrapInfo) {
+            var tokenPadding = tokenStyle.padding;
+            var tokenPaddingH = tokenPadding ? tokenPadding[1] + tokenPadding[3] : 0;
+            if (tokenStyle.width != null && tokenStyle.width !== 'auto') {
+                var outerWidth_1 = parsePercent$2(tokenStyle.width, wrapInfo.width) + tokenPaddingH;
+                if (lines.length > 0) {
+                    if (outerWidth_1 + wrapInfo.accumWidth > wrapInfo.width) {
+                        strLines = str.split('\n');
+                        newLine = true;
+                    }
+                }
+                wrapInfo.accumWidth = outerWidth_1;
+            }
+            else {
+                var res = wrapText(str, font, wrapInfo.width, wrapInfo.breakAll, wrapInfo.accumWidth);
+                wrapInfo.accumWidth = res.accumWidth + tokenPaddingH;
+                linesWidths = res.linesWidths;
+                strLines = res.lines;
+            }
+        }
+        else {
+            strLines = str.split('\n');
+        }
+        for (var i = 0; i < strLines.length; i++) {
+            var text = strLines[i];
+            var token = new RichTextToken();
+            token.styleName = styleName;
+            token.text = text;
+            token.isLineHolder = !text && !isEmptyStr;
+            if (typeof tokenStyle.width === 'number') {
+                token.width = tokenStyle.width;
+            }
+            else {
+                token.width = linesWidths
+                    ? linesWidths[i]
+                    : getWidth(text, font);
+            }
+            if (!i && !newLine) {
+                var tokens = (lines[lines.length - 1] || (lines[0] = new RichTextLine())).tokens;
+                var tokensLen = tokens.length;
+                (tokensLen === 1 && tokens[0].isLineHolder)
+                    ? (tokens[0] = token)
+                    : ((text || !tokensLen || isEmptyStr) && tokens.push(token));
+            }
+            else {
+                lines.push(new RichTextLine([token]));
+            }
+        }
+    }
+    function isLatin(ch) {
+        var code = ch.charCodeAt(0);
+        return code >= 0x21 && code <= 0xFF;
+    }
+    var breakCharMap = reduce(',&?/;] '.split(''), function (obj, ch) {
+        obj[ch] = true;
+        return obj;
+    }, {});
+    function isWordBreakChar(ch) {
+        if (isLatin(ch)) {
+            if (breakCharMap[ch]) {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    function wrapText(text, font, lineWidth, isBreakAll, lastAccumWidth) {
+        var lines = [];
+        var linesWidths = [];
+        var line = '';
+        var currentWord = '';
+        var currentWordWidth = 0;
+        var accumWidth = 0;
+        for (var i = 0; i < text.length; i++) {
+            var ch = text.charAt(i);
+            if (ch === '\n') {
+                if (currentWord) {
+                    line += currentWord;
+                    accumWidth += currentWordWidth;
+                }
+                lines.push(line);
+                linesWidths.push(accumWidth);
+                line = '';
+                currentWord = '';
+                currentWordWidth = 0;
+                accumWidth = 0;
+                continue;
+            }
+            var chWidth = getWidth(ch, font);
+            var inWord = isBreakAll ? false : !isWordBreakChar(ch);
+            if (!lines.length
+                ? lastAccumWidth + accumWidth + chWidth > lineWidth
+                : accumWidth + chWidth > lineWidth) {
+                if (!accumWidth) {
+                    if (inWord) {
+                        lines.push(currentWord);
+                        linesWidths.push(currentWordWidth);
+                        currentWord = ch;
+                        currentWordWidth = chWidth;
+                    }
+                    else {
+                        lines.push(ch);
+                        linesWidths.push(chWidth);
+                    }
+                }
+                else if (line || currentWord) {
+                    if (inWord) {
+                        if (!line) {
+                            line = currentWord;
+                            currentWord = '';
+                            currentWordWidth = 0;
+                            accumWidth = currentWordWidth;
+                        }
+                        lines.push(line);
+                        linesWidths.push(accumWidth - currentWordWidth);
+                        currentWord += ch;
+                        currentWordWidth += chWidth;
+                        line = '';
+                        accumWidth = currentWordWidth;
+                    }
+                    else {
+                        if (currentWord) {
+                            line += currentWord;
+                            accumWidth += currentWordWidth;
+                            currentWord = '';
+                            currentWordWidth = 0;
+                        }
+                        lines.push(line);
+                        linesWidths.push(accumWidth);
+                        line = ch;
+                        accumWidth = chWidth;
+                    }
+                }
+                continue;
+            }
+            accumWidth += chWidth;
+            if (inWord) {
+                currentWord += ch;
+                currentWordWidth += chWidth;
+            }
+            else {
+                if (currentWord) {
+                    line += currentWord;
+                    currentWord = '';
+                    currentWordWidth = 0;
+                }
+                line += ch;
+            }
+        }
+        if (!lines.length && !line) {
+            line = text;
+            currentWord = '';
+            currentWordWidth = 0;
+        }
+        if (currentWord) {
+            line += currentWord;
+        }
+        if (line) {
+            lines.push(line);
+            linesWidths.push(accumWidth);
+        }
+        if (lines.length === 1) {
+            accumWidth += lastAccumWidth;
+        }
+        return {
+            accumWidth: accumWidth,
+            lines: lines,
+            linesWidths: linesWidths
+        };
+    }
+    function parsePercent$2(value, maxValue) {
+        if (typeof value === 'string') {
+            if (value.lastIndexOf('%') >= 0) {
+                return parseFloat(value) / 100 * maxValue;
+            }
+            return parseFloat(value);
+        }
+        return value;
+    }
+
+    var STYLE_MAGIC_KEY = '__zr_style_' + Math.round((Math.random() * 10));
+    var DEFAULT_COMMON_STYLE = {
+        shadowBlur: 0,
+        shadowOffsetX: 0,
+        shadowOffsetY: 0,
+        shadowColor: '#000',
+        opacity: 1,
+        blend: 'source-over'
+    };
+    var DEFAULT_COMMON_ANIMATION_PROPS = {
+        style: {
+            shadowBlur: true,
+            shadowOffsetX: true,
+            shadowOffsetY: true,
+            shadowColor: true,
+            opacity: true
+        }
+    };
+    DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
+    var PRIMARY_STATES_KEYS$1 = ['z', 'z2', 'invisible'];
+    var Displayable = (function (_super) {
+        __extends(Displayable, _super);
+        function Displayable(props) {
+            return _super.call(this, props) || this;
+        }
+        Displayable.prototype._init = function (props) {
+            var keysArr = keys(props);
+            for (var i = 0; i < keysArr.length; i++) {
+                var key = keysArr[i];
+                if (key === 'style') {
+                    this.useStyle(props[key]);
+                }
+                else {
+                    _super.prototype.attrKV.call(this, key, props[key]);
+                }
+            }
+            if (!this.style) {
+                this.useStyle({});
+            }
+        };
+        Displayable.prototype.beforeBrush = function () { };
+        Displayable.prototype.afterBrush = function () { };
+        Displayable.prototype.innerBeforeBrush = function () { };
+        Displayable.prototype.innerAfterBrush = function () { };
+        Displayable.prototype.shouldBePainted = function (viewWidth, viewHeight, considerClipPath, considerAncestors) {
+            var m = this.transform;
+            if (this.ignore
+                || this.invisible
+                || this.style.opacity === 0
+                || (this.culling
+                    && isDisplayableCulled(this, viewWidth, viewHeight))
+                || (m && !m[0] && !m[3])) {
+                return false;
+            }
+            if (considerClipPath && this.__clipPaths) {
+                for (var i = 0; i < this.__clipPaths.length; ++i) {
+                    if (this.__clipPaths[i].isZeroArea()) {
+                        return false;
+                    }
+                }
+            }
+            if (considerAncestors && this.parent) {
+                var parent_1 = this.parent;
+                while (parent_1) {
+                    if (parent_1.ignore) {
+                        return false;
+                    }
+                    parent_1 = parent_1.parent;
+                }
+            }
+            return true;
+        };
+        Displayable.prototype.contain = function (x, y) {
+            return this.rectContain(x, y);
+        };
+        Displayable.prototype.traverse = function (cb, context) {
+            cb.call(context, this);
+        };
+        Displayable.prototype.rectContain = function (x, y) {
+            var coord = this.transformCoordToLocal(x, y);
+            var rect = this.getBoundingRect();
+            return rect.contain(coord[0], coord[1]);
+        };
+        Displayable.prototype.getPaintRect = function () {
+            var rect = this._paintRect;
+            if (!this._paintRect || this.__dirty) {
+                var transform = this.transform;
+                var elRect = this.getBoundingRect();
+                var style = this.style;
+                var shadowSize = style.shadowBlur || 0;
+                var shadowOffsetX = style.shadowOffsetX || 0;
+                var shadowOffsetY = style.shadowOffsetY || 0;
+                rect = this._paintRect || (this._paintRect = new BoundingRect(0, 0, 0, 0));
+                if (transform) {
+                    BoundingRect.applyTransform(rect, elRect, transform);
+                }
+                else {
+                    rect.copy(elRect);
+                }
+                if (shadowSize || shadowOffsetX || shadowOffsetY) {
+                    rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
+                    rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
+                    rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
+                    rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
+                }
+                var tolerance = this.dirtyRectTolerance;
+                if (!rect.isZero()) {
+                    rect.x = Math.floor(rect.x - tolerance);
+                    rect.y = Math.floor(rect.y - tolerance);
+                    rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
+                    rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
+                }
+            }
+            return rect;
+        };
+        Displayable.prototype.setPrevPaintRect = function (paintRect) {
+            if (paintRect) {
+                this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0);
+                this._prevPaintRect.copy(paintRect);
+            }
+            else {
+                this._prevPaintRect = null;
+            }
+        };
+        Displayable.prototype.getPrevPaintRect = function () {
+            return this._prevPaintRect;
+        };
+        Displayable.prototype.animateStyle = function (loop) {
+            return this.animate('style', loop);
+        };
+        Displayable.prototype.updateDuringAnimation = function (targetKey) {
+            if (targetKey === 'style') {
+                this.dirtyStyle();
+            }
+            else {
+                this.markRedraw();
+            }
+        };
+        Displayable.prototype.attrKV = function (key, value) {
+            if (key !== 'style') {
+                _super.prototype.attrKV.call(this, key, value);
+            }
+            else {
+                if (!this.style) {
+                    this.useStyle(value);
+                }
+                else {
+                    this.setStyle(value);
+                }
+            }
+        };
+        Displayable.prototype.setStyle = function (keyOrObj, value) {
+            if (typeof keyOrObj === 'string') {
+                this.style[keyOrObj] = value;
+            }
+            else {
+                extend(this.style, keyOrObj);
+            }
+            this.dirtyStyle();
+            return this;
+        };
+        Displayable.prototype.dirtyStyle = function () {
+            this.markRedraw();
+            this.__dirty |= Displayable.STYLE_CHANGED_BIT;
+            if (this._rect) {
+                this._rect = null;
+            }
+        };
+        Displayable.prototype.dirty = function () {
+            this.dirtyStyle();
+        };
+        Displayable.prototype.styleChanged = function () {
+            return !!(this.__dirty & Displayable.STYLE_CHANGED_BIT);
+        };
+        Displayable.prototype.styleUpdated = function () {
+            this.__dirty &= ~Displayable.STYLE_CHANGED_BIT;
+        };
+        Displayable.prototype.createStyle = function (obj) {
+            return createObject(DEFAULT_COMMON_STYLE, obj);
+        };
+        Displayable.prototype.useStyle = function (obj) {
+            if (!obj[STYLE_MAGIC_KEY]) {
+                obj = this.createStyle(obj);
+            }
+            if (this.__inHover) {
+                this.__hoverStyle = obj;
+            }
+            else {
+                this.style = obj;
+            }
+            this.dirtyStyle();
+        };
+        Displayable.prototype.isStyleObject = function (obj) {
+            return obj[STYLE_MAGIC_KEY];
+        };
+        Displayable.prototype._innerSaveToNormal = function (toState) {
+            _super.prototype._innerSaveToNormal.call(this, toState);
+            var normalState = this._normalState;
+            if (toState.style && !normalState.style) {
+                normalState.style = this._mergeStyle(this.createStyle(), this.style);
+            }
+            this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS$1);
+        };
+        Displayable.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+            _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+            var needsRestoreToNormal = !(state && keepCurrentStates);
+            var targetStyle;
+            if (state && state.style) {
+                if (transition) {
+                    if (keepCurrentStates) {
+                        targetStyle = state.style;
+                    }
+                    else {
+                        targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
+                        this._mergeStyle(targetStyle, state.style);
+                    }
+                }
+                else {
+                    targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
+                    this._mergeStyle(targetStyle, state.style);
+                }
+            }
+            else if (needsRestoreToNormal) {
+                targetStyle = normalState.style;
+            }
+            if (targetStyle) {
+                if (transition) {
+                    var sourceStyle = this.style;
+                    this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
+                    if (needsRestoreToNormal) {
+                        var changedKeys = keys(sourceStyle);
+                        for (var i = 0; i < changedKeys.length; i++) {
+                            var key = changedKeys[i];
+                            if (key in targetStyle) {
+                                targetStyle[key] = targetStyle[key];
+                                this.style[key] = sourceStyle[key];
+                            }
+                        }
+                    }
+                    var targetKeys = keys(targetStyle);
+                    for (var i = 0; i < targetKeys.length; i++) {
+                        var key = targetKeys[i];
+                        this.style[key] = this.style[key];
+                    }
+                    this._transitionState(stateName, {
+                        style: targetStyle
+                    }, animationCfg, this.getAnimationStyleProps());
+                }
+                else {
+                    this.useStyle(targetStyle);
+                }
+            }
+            for (var i = 0; i < PRIMARY_STATES_KEYS$1.length; i++) {
+                var key = PRIMARY_STATES_KEYS$1[i];
+                if (state && state[key] != null) {
+                    this[key] = state[key];
+                }
+                else if (needsRestoreToNormal) {
+                    if (normalState[key] != null) {
+                        this[key] = normalState[key];
+                    }
+                }
+            }
+        };
+        Displayable.prototype._mergeStates = function (states) {
+            var mergedState = _super.prototype._mergeStates.call(this, states);
+            var mergedStyle;
+            for (var i = 0; i < states.length; i++) {
+                var state = states[i];
+                if (state.style) {
+                    mergedStyle = mergedStyle || {};
+                    this._mergeStyle(mergedStyle, state.style);
+                }
+            }
+            if (mergedStyle) {
+                mergedState.style = mergedStyle;
+            }
+            return mergedState;
+        };
+        Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) {
+            extend(targetStyle, sourceStyle);
+            return targetStyle;
+        };
+        Displayable.prototype.getAnimationStyleProps = function () {
+            return DEFAULT_COMMON_ANIMATION_PROPS;
+        };
+        Displayable.STYLE_CHANGED_BIT = 2;
+        Displayable.initDefaultProps = (function () {
+            var dispProto = Displayable.prototype;
+            dispProto.type = 'displayable';
+            dispProto.invisible = false;
+            dispProto.z = 0;
+            dispProto.z2 = 0;
+            dispProto.zlevel = 0;
+            dispProto.culling = false;
+            dispProto.cursor = 'pointer';
+            dispProto.rectHover = false;
+            dispProto.incremental = false;
+            dispProto._rect = null;
+            dispProto.dirtyRectTolerance = 0;
+            dispProto.__dirty = Element.REDARAW_BIT | Displayable.STYLE_CHANGED_BIT;
+        })();
+        return Displayable;
+    }(Element));
+    var tmpRect = new BoundingRect(0, 0, 0, 0);
+    var viewRect = new BoundingRect(0, 0, 0, 0);
+    function isDisplayableCulled(el, width, height) {
+        tmpRect.copy(el.getBoundingRect());
+        if (el.transform) {
+            tmpRect.applyTransform(el.transform);
+        }
+        viewRect.width = width;
+        viewRect.height = height;
+        return !tmpRect.intersect(viewRect);
+    }
+
+    var mathPow = Math.pow;
+    var mathSqrt = Math.sqrt;
+    var EPSILON$1 = 1e-8;
+    var EPSILON_NUMERIC = 1e-4;
+    var THREE_SQRT = mathSqrt(3);
+    var ONE_THIRD = 1 / 3;
+    var _v0 = create();
+    var _v1 = create();
+    var _v2 = create();
+    function isAroundZero(val) {
+        return val > -EPSILON$1 && val < EPSILON$1;
+    }
+    function isNotAroundZero$1(val) {
+        return val > EPSILON$1 || val < -EPSILON$1;
+    }
+    function cubicAt(p0, p1, p2, p3, t) {
+        var onet = 1 - t;
+        return onet * onet * (onet * p0 + 3 * t * p1)
+            + t * t * (t * p3 + 3 * onet * p2);
+    }
+    function cubicDerivativeAt(p0, p1, p2, p3, t) {
+        var onet = 1 - t;
+        return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet
+            + (p3 - p2) * t * t);
+    }
+    function cubicRootAt(p0, p1, p2, p3, val, roots) {
+        var a = p3 + 3 * (p1 - p2) - p0;
+        var b = 3 * (p2 - p1 * 2 + p0);
+        var c = 3 * (p1 - p0);
+        var d = p0 - val;
+        var A = b * b - 3 * a * c;
+        var B = b * c - 9 * a * d;
+        var C = c * c - 3 * b * d;
+        var n = 0;
+        if (isAroundZero(A) && isAroundZero(B)) {
+            if (isAroundZero(b)) {
+                roots[0] = 0;
+            }
+            else {
+                var t1 = -c / b;
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+            }
+        }
+        else {
+            var disc = B * B - 4 * A * C;
+            if (isAroundZero(disc)) {
+                var K = B / A;
+                var t1 = -b / a + K;
+                var t2 = -K / 2;
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+                if (t2 >= 0 && t2 <= 1) {
+                    roots[n++] = t2;
+                }
+            }
+            else if (disc > 0) {
+                var discSqrt = mathSqrt(disc);
+                var Y1 = A * b + 1.5 * a * (-B + discSqrt);
+                var Y2 = A * b + 1.5 * a * (-B - discSqrt);
+                if (Y1 < 0) {
+                    Y1 = -mathPow(-Y1, ONE_THIRD);
+                }
+                else {
+                    Y1 = mathPow(Y1, ONE_THIRD);
+                }
+                if (Y2 < 0) {
+                    Y2 = -mathPow(-Y2, ONE_THIRD);
+                }
+                else {
+                    Y2 = mathPow(Y2, ONE_THIRD);
+                }
+                var t1 = (-b - (Y1 + Y2)) / (3 * a);
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+            }
+            else {
+                var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));
+                var theta = Math.acos(T) / 3;
+                var ASqrt = mathSqrt(A);
+                var tmp = Math.cos(theta);
+                var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);
+                var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);
+                var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+                if (t2 >= 0 && t2 <= 1) {
+                    roots[n++] = t2;
+                }
+                if (t3 >= 0 && t3 <= 1) {
+                    roots[n++] = t3;
+                }
+            }
+        }
+        return n;
+    }
+    function cubicExtrema(p0, p1, p2, p3, extrema) {
+        var b = 6 * p2 - 12 * p1 + 6 * p0;
+        var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;
+        var c = 3 * p1 - 3 * p0;
+        var n = 0;
+        if (isAroundZero(a)) {
+            if (isNotAroundZero$1(b)) {
+                var t1 = -c / b;
+                if (t1 >= 0 && t1 <= 1) {
+                    extrema[n++] = t1;
+                }
+            }
+        }
+        else {
+            var disc = b * b - 4 * a * c;
+            if (isAroundZero(disc)) {
+                extrema[0] = -b / (2 * a);
+            }
+            else if (disc > 0) {
+                var discSqrt = mathSqrt(disc);
+                var t1 = (-b + discSqrt) / (2 * a);
+                var t2 = (-b - discSqrt) / (2 * a);
+                if (t1 >= 0 && t1 <= 1) {
+                    extrema[n++] = t1;
+                }
+                if (t2 >= 0 && t2 <= 1) {
+                    extrema[n++] = t2;
+                }
+            }
+        }
+        return n;
+    }
+    function cubicSubdivide(p0, p1, p2, p3, t, out) {
+        var p01 = (p1 - p0) * t + p0;
+        var p12 = (p2 - p1) * t + p1;
+        var p23 = (p3 - p2) * t + p2;
+        var p012 = (p12 - p01) * t + p01;
+        var p123 = (p23 - p12) * t + p12;
+        var p0123 = (p123 - p012) * t + p012;
+        out[0] = p0;
+        out[1] = p01;
+        out[2] = p012;
+        out[3] = p0123;
+        out[4] = p0123;
+        out[5] = p123;
+        out[6] = p23;
+        out[7] = p3;
+    }
+    function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {
+        var t;
+        var interval = 0.005;
+        var d = Infinity;
+        var prev;
+        var next;
+        var d1;
+        var d2;
+        _v0[0] = x;
+        _v0[1] = y;
+        for (var _t = 0; _t < 1; _t += 0.05) {
+            _v1[0] = cubicAt(x0, x1, x2, x3, _t);
+            _v1[1] = cubicAt(y0, y1, y2, y3, _t);
+            d1 = distSquare(_v0, _v1);
+            if (d1 < d) {
+                t = _t;
+                d = d1;
+            }
+        }
+        d = Infinity;
+        for (var i = 0; i < 32; i++) {
+            if (interval < EPSILON_NUMERIC) {
+                break;
+            }
+            prev = t - interval;
+            next = t + interval;
+            _v1[0] = cubicAt(x0, x1, x2, x3, prev);
+            _v1[1] = cubicAt(y0, y1, y2, y3, prev);
+            d1 = distSquare(_v1, _v0);
+            if (prev >= 0 && d1 < d) {
+                t = prev;
+                d = d1;
+            }
+            else {
+                _v2[0] = cubicAt(x0, x1, x2, x3, next);
+                _v2[1] = cubicAt(y0, y1, y2, y3, next);
+                d2 = distSquare(_v2, _v0);
+                if (next <= 1 && d2 < d) {
+                    t = next;
+                    d = d2;
+                }
+                else {
+                    interval *= 0.5;
+                }
+            }
+        }
+        if (out) {
+            out[0] = cubicAt(x0, x1, x2, x3, t);
+            out[1] = cubicAt(y0, y1, y2, y3, t);
+        }
+        return mathSqrt(d);
+    }
+    function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) {
+        var px = x0;
+        var py = y0;
+        var d = 0;
+        var step = 1 / iteration;
+        for (var i = 1; i <= iteration; i++) {
+            var t = i * step;
+            var x = cubicAt(x0, x1, x2, x3, t);
+            var y = cubicAt(y0, y1, y2, y3, t);
+            var dx = x - px;
+            var dy = y - py;
+            d += Math.sqrt(dx * dx + dy * dy);
+            px = x;
+            py = y;
+        }
+        return d;
+    }
+    function quadraticAt(p0, p1, p2, t) {
+        var onet = 1 - t;
+        return onet * (onet * p0 + 2 * t * p1) + t * t * p2;
+    }
+    function quadraticDerivativeAt(p0, p1, p2, t) {
+        return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));
+    }
+    function quadraticRootAt(p0, p1, p2, val, roots) {
+        var a = p0 - 2 * p1 + p2;
+        var b = 2 * (p1 - p0);
+        var c = p0 - val;
+        var n = 0;
+        if (isAroundZero(a)) {
+            if (isNotAroundZero$1(b)) {
+                var t1 = -c / b;
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+            }
+        }
+        else {
+            var disc = b * b - 4 * a * c;
+            if (isAroundZero(disc)) {
+                var t1 = -b / (2 * a);
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+            }
+            else if (disc > 0) {
+                var discSqrt = mathSqrt(disc);
+                var t1 = (-b + discSqrt) / (2 * a);
+                var t2 = (-b - discSqrt) / (2 * a);
+                if (t1 >= 0 && t1 <= 1) {
+                    roots[n++] = t1;
+                }
+                if (t2 >= 0 && t2 <= 1) {
+                    roots[n++] = t2;
+                }
+            }
+        }
+        return n;
+    }
+    function quadraticExtremum(p0, p1, p2) {
+        var divider = p0 + p2 - 2 * p1;
+        if (divider === 0) {
+            return 0.5;
+        }
+        else {
+            return (p0 - p1) / divider;
+        }
+    }
+    function quadraticSubdivide(p0, p1, p2, t, out) {
+        var p01 = (p1 - p0) * t + p0;
+        var p12 = (p2 - p1) * t + p1;
+        var p012 = (p12 - p01) * t + p01;
+        out[0] = p0;
+        out[1] = p01;
+        out[2] = p012;
+        out[3] = p012;
+        out[4] = p12;
+        out[5] = p2;
+    }
+    function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {
+        var t;
+        var interval = 0.005;
+        var d = Infinity;
+        _v0[0] = x;
+        _v0[1] = y;
+        for (var _t = 0; _t < 1; _t += 0.05) {
+            _v1[0] = quadraticAt(x0, x1, x2, _t);
+            _v1[1] = quadraticAt(y0, y1, y2, _t);
+            var d1 = distSquare(_v0, _v1);
+            if (d1 < d) {
+                t = _t;
+                d = d1;
+            }
+        }
+        d = Infinity;
+        for (var i = 0; i < 32; i++) {
+            if (interval < EPSILON_NUMERIC) {
+                break;
+            }
+            var prev = t - interval;
+            var next = t + interval;
+            _v1[0] = quadraticAt(x0, x1, x2, prev);
+            _v1[1] = quadraticAt(y0, y1, y2, prev);
+            var d1 = distSquare(_v1, _v0);
+            if (prev >= 0 && d1 < d) {
+                t = prev;
+                d = d1;
+            }
+            else {
+                _v2[0] = quadraticAt(x0, x1, x2, next);
+                _v2[1] = quadraticAt(y0, y1, y2, next);
+                var d2 = distSquare(_v2, _v0);
+                if (next <= 1 && d2 < d) {
+                    t = next;
+                    d = d2;
+                }
+                else {
+                    interval *= 0.5;
+                }
+            }
+        }
+        if (out) {
+            out[0] = quadraticAt(x0, x1, x2, t);
+            out[1] = quadraticAt(y0, y1, y2, t);
+        }
+        return mathSqrt(d);
+    }
+    function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) {
+        var px = x0;
+        var py = y0;
+        var d = 0;
+        var step = 1 / iteration;
+        for (var i = 1; i <= iteration; i++) {
+            var t = i * step;
+            var x = quadraticAt(x0, x1, x2, t);
+            var y = quadraticAt(y0, y1, y2, t);
+            var dx = x - px;
+            var dy = y - py;
+            d += Math.sqrt(dx * dx + dy * dy);
+            px = x;
+            py = y;
+        }
+        return d;
+    }
+
+    var mathMin$1 = Math.min;
+    var mathMax$1 = Math.max;
+    var mathSin = Math.sin;
+    var mathCos = Math.cos;
+    var PI2 = Math.PI * 2;
+    var start = create();
+    var end = create();
+    var extremity = create();
+    function fromPoints(points, min, max) {
+        if (points.length === 0) {
+            return;
+        }
+        var p = points[0];
+        var left = p[0];
+        var right = p[0];
+        var top = p[1];
+        var bottom = p[1];
+        for (var i = 1; i < points.length; i++) {
+            p = points[i];
+            left = mathMin$1(left, p[0]);
+            right = mathMax$1(right, p[0]);
+            top = mathMin$1(top, p[1]);
+            bottom = mathMax$1(bottom, p[1]);
+        }
+        min[0] = left;
+        min[1] = top;
+        max[0] = right;
+        max[1] = bottom;
+    }
+    function fromLine(x0, y0, x1, y1, min, max) {
+        min[0] = mathMin$1(x0, x1);
+        min[1] = mathMin$1(y0, y1);
+        max[0] = mathMax$1(x0, x1);
+        max[1] = mathMax$1(y0, y1);
+    }
+    var xDim = [];
+    var yDim = [];
+    function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {
+        var cubicExtrema$1 = cubicExtrema;
+        var cubicAt$1 = cubicAt;
+        var n = cubicExtrema$1(x0, x1, x2, x3, xDim);
+        min[0] = Infinity;
+        min[1] = Infinity;
+        max[0] = -Infinity;
+        max[1] = -Infinity;
+        for (var i = 0; i < n; i++) {
+            var x = cubicAt$1(x0, x1, x2, x3, xDim[i]);
+            min[0] = mathMin$1(x, min[0]);
+            max[0] = mathMax$1(x, max[0]);
+        }
+        n = cubicExtrema$1(y0, y1, y2, y3, yDim);
+        for (var i = 0; i < n; i++) {
+            var y = cubicAt$1(y0, y1, y2, y3, yDim[i]);
+            min[1] = mathMin$1(y, min[1]);
+            max[1] = mathMax$1(y, max[1]);
+        }
+        min[0] = mathMin$1(x0, min[0]);
+        max[0] = mathMax$1(x0, max[0]);
+        min[0] = mathMin$1(x3, min[0]);
+        max[0] = mathMax$1(x3, max[0]);
+        min[1] = mathMin$1(y0, min[1]);
+        max[1] = mathMax$1(y0, max[1]);
+        min[1] = mathMin$1(y3, min[1]);
+        max[1] = mathMax$1(y3, max[1]);
+    }
+    function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {
+        var quadraticExtremum$1 = quadraticExtremum;
+        var quadraticAt$1 = quadraticAt;
+        var tx = mathMax$1(mathMin$1(quadraticExtremum$1(x0, x1, x2), 1), 0);
+        var ty = mathMax$1(mathMin$1(quadraticExtremum$1(y0, y1, y2), 1), 0);
+        var x = quadraticAt$1(x0, x1, x2, tx);
+        var y = quadraticAt$1(y0, y1, y2, ty);
+        min[0] = mathMin$1(x0, x2, x);
+        min[1] = mathMin$1(y0, y2, y);
+        max[0] = mathMax$1(x0, x2, x);
+        max[1] = mathMax$1(y0, y2, y);
+    }
+    function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min$1, max$1) {
+        var vec2Min = min;
+        var vec2Max = max;
+        var diff = Math.abs(startAngle - endAngle);
+        if (diff % PI2 < 1e-4 && diff > 1e-4) {
+            min$1[0] = x - rx;
+            min$1[1] = y - ry;
+            max$1[0] = x + rx;
+            max$1[1] = y + ry;
+            return;
+        }
+        start[0] = mathCos(startAngle) * rx + x;
+        start[1] = mathSin(startAngle) * ry + y;
+        end[0] = mathCos(endAngle) * rx + x;
+        end[1] = mathSin(endAngle) * ry + y;
+        vec2Min(min$1, start, end);
+        vec2Max(max$1, start, end);
+        startAngle = startAngle % (PI2);
+        if (startAngle < 0) {
+            startAngle = startAngle + PI2;
+        }
+        endAngle = endAngle % (PI2);
+        if (endAngle < 0) {
+            endAngle = endAngle + PI2;
+        }
+        if (startAngle > endAngle && !anticlockwise) {
+            endAngle += PI2;
+        }
+        else if (startAngle < endAngle && anticlockwise) {
+            startAngle += PI2;
+        }
+        if (anticlockwise) {
+            var tmp = endAngle;
+            endAngle = startAngle;
+            startAngle = tmp;
+        }
+        for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
+            if (angle > startAngle) {
+                extremity[0] = mathCos(angle) * rx + x;
+                extremity[1] = mathSin(angle) * ry + y;
+                vec2Min(min$1, extremity, min$1);
+                vec2Max(max$1, extremity, max$1);
+            }
+        }
+    }
+
+    var CMD = {
+        M: 1,
+        L: 2,
+        C: 3,
+        Q: 4,
+        A: 5,
+        Z: 6,
+        R: 7
+    };
+    var tmpOutX = [];
+    var tmpOutY = [];
+    var min$1 = [];
+    var max$1 = [];
+    var min2 = [];
+    var max2 = [];
+    var mathMin$2 = Math.min;
+    var mathMax$2 = Math.max;
+    var mathCos$1 = Math.cos;
+    var mathSin$1 = Math.sin;
+    var mathSqrt$1 = Math.sqrt;
+    var mathAbs = Math.abs;
+    var PI = Math.PI;
+    var PI2$1 = PI * 2;
+    var hasTypedArray = typeof Float32Array !== 'undefined';
+    var tmpAngles = [];
+    function modPI2(radian) {
+        var n = Math.round(radian / PI * 1e8) / 1e8;
+        return (n % 2) * PI;
+    }
+    function normalizeArcAngles(angles, anticlockwise) {
+        var newStartAngle = modPI2(angles[0]);
+        if (newStartAngle < 0) {
+            newStartAngle += PI2$1;
+        }
+        var delta = newStartAngle - angles[0];
+        var newEndAngle = angles[1];
+        newEndAngle += delta;
+        if (!anticlockwise && newEndAngle - newStartAngle >= PI2$1) {
+            newEndAngle = newStartAngle + PI2$1;
+        }
+        else if (anticlockwise && newStartAngle - newEndAngle >= PI2$1) {
+            newEndAngle = newStartAngle - PI2$1;
+        }
+        else if (!anticlockwise && newStartAngle > newEndAngle) {
+            newEndAngle = newStartAngle +
+                (PI2$1 - modPI2(newStartAngle - newEndAngle));
+        }
+        else if (anticlockwise && newStartAngle < newEndAngle) {
+            newEndAngle = newStartAngle -
+                (PI2$1 - modPI2(newEndAngle - newStartAngle));
+        }
+        angles[0] = newStartAngle;
+        angles[1] = newEndAngle;
+    }
+    var PathProxy = (function () {
+        function PathProxy(notSaveData) {
+            this.dpr = 1;
+            this._version = 0;
+            this._xi = 0;
+            this._yi = 0;
+            this._x0 = 0;
+            this._y0 = 0;
+            this._len = 0;
+            if (notSaveData) {
+                this._saveData = false;
+            }
+            if (this._saveData) {
+                this.data = [];
+            }
+        }
+        PathProxy.prototype.increaseVersion = function () {
+            this._version++;
+        };
+        PathProxy.prototype.getVersion = function () {
+            return this._version;
+        };
+        PathProxy.prototype.setScale = function (sx, sy, segmentIgnoreThreshold) {
+            segmentIgnoreThreshold = segmentIgnoreThreshold || 0;
+            if (segmentIgnoreThreshold > 0) {
+                this._ux = mathAbs(segmentIgnoreThreshold / devicePixelRatio / sx) || 0;
+                this._uy = mathAbs(segmentIgnoreThreshold / devicePixelRatio / sy) || 0;
+            }
+        };
+        PathProxy.prototype.setDPR = function (dpr) {
+            this.dpr = dpr;
+        };
+        PathProxy.prototype.setContext = function (ctx) {
+            this._ctx = ctx;
+        };
+        PathProxy.prototype.getContext = function () {
+            return this._ctx;
+        };
+        PathProxy.prototype.beginPath = function () {
+            this._ctx && this._ctx.beginPath();
+            this.reset();
+            return this;
+        };
+        PathProxy.prototype.reset = function () {
+            if (this._saveData) {
+                this._len = 0;
+            }
+            if (this._lineDash) {
+                this._lineDash = null;
+                this._dashOffset = 0;
+            }
+            if (this._pathSegLen) {
+                this._pathSegLen = null;
+                this._pathLen = 0;
+            }
+            this._version++;
+        };
+        PathProxy.prototype.moveTo = function (x, y) {
+            this.addData(CMD.M, x, y);
+            this._ctx && this._ctx.moveTo(x, y);
+            this._x0 = x;
+            this._y0 = y;
+            this._xi = x;
+            this._yi = y;
+            return this;
+        };
+        PathProxy.prototype.lineTo = function (x, y) {
+            var exceedUnit = mathAbs(x - this._xi) > this._ux
+                || mathAbs(y - this._yi) > this._uy
+                || this._len < 5;
+            this.addData(CMD.L, x, y);
+            if (this._ctx && exceedUnit) {
+                this._needsDash ? this._dashedLineTo(x, y)
+                    : this._ctx.lineTo(x, y);
+            }
+            if (exceedUnit) {
+                this._xi = x;
+                this._yi = y;
+            }
+            return this;
+        };
+        PathProxy.prototype.bezierCurveTo = function (x1, y1, x2, y2, x3, y3) {
+            this.addData(CMD.C, x1, y1, x2, y2, x3, y3);
+            if (this._ctx) {
+                this._needsDash ? this._dashedBezierTo(x1, y1, x2, y2, x3, y3)
+                    : this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+            }
+            this._xi = x3;
+            this._yi = y3;
+            return this;
+        };
+        PathProxy.prototype.quadraticCurveTo = function (x1, y1, x2, y2) {
+            this.addData(CMD.Q, x1, y1, x2, y2);
+            if (this._ctx) {
+                this._needsDash ? this._dashedQuadraticTo(x1, y1, x2, y2)
+                    : this._ctx.quadraticCurveTo(x1, y1, x2, y2);
+            }
+            this._xi = x2;
+            this._yi = y2;
+            return this;
+        };
+        PathProxy.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) {
+            tmpAngles[0] = startAngle;
+            tmpAngles[1] = endAngle;
+            normalizeArcAngles(tmpAngles, anticlockwise);
+            startAngle = tmpAngles[0];
+            endAngle = tmpAngles[1];
+            var delta = endAngle - startAngle;
+            this.addData(CMD.A, cx, cy, r, r, startAngle, delta, 0, anticlockwise ? 0 : 1);
+            this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
+            this._xi = mathCos$1(endAngle) * r + cx;
+            this._yi = mathSin$1(endAngle) * r + cy;
+            return this;
+        };
+        PathProxy.prototype.arcTo = function (x1, y1, x2, y2, radius) {
+            if (this._ctx) {
+                this._ctx.arcTo(x1, y1, x2, y2, radius);
+            }
+            return this;
+        };
+        PathProxy.prototype.rect = function (x, y, w, h) {
+            this._ctx && this._ctx.rect(x, y, w, h);
+            this.addData(CMD.R, x, y, w, h);
+            return this;
+        };
+        PathProxy.prototype.closePath = function () {
+            this.addData(CMD.Z);
+            var ctx = this._ctx;
+            var x0 = this._x0;
+            var y0 = this._y0;
+            if (ctx) {
+                this._needsDash && this._dashedLineTo(x0, y0);
+                ctx.closePath();
+            }
+            this._xi = x0;
+            this._yi = y0;
+            return this;
+        };
+        PathProxy.prototype.fill = function (ctx) {
+            ctx && ctx.fill();
+            this.toStatic();
+        };
+        PathProxy.prototype.stroke = function (ctx) {
+            ctx && ctx.stroke();
+            this.toStatic();
+        };
+        PathProxy.prototype.setLineDash = function (lineDash) {
+            if (lineDash instanceof Array) {
+                this._lineDash = lineDash;
+                this._dashIdx = 0;
+                var lineDashSum = 0;
+                for (var i = 0; i < lineDash.length; i++) {
+                    lineDashSum += lineDash[i];
+                }
+                this._dashSum = lineDashSum;
+                this._needsDash = true;
+            }
+            else {
+                this._lineDash = null;
+                this._needsDash = false;
+            }
+            return this;
+        };
+        PathProxy.prototype.setLineDashOffset = function (offset) {
+            this._dashOffset = offset;
+            return this;
+        };
+        PathProxy.prototype.len = function () {
+            return this._len;
+        };
+        PathProxy.prototype.setData = function (data) {
+            var len = data.length;
+            if (!(this.data && this.data.length === len) && hasTypedArray) {
+                this.data = new Float32Array(len);
+            }
+            for (var i = 0; i < len; i++) {
+                this.data[i] = data[i];
+            }
+            this._len = len;
+        };
+        PathProxy.prototype.appendPath = function (path) {
+            if (!(path instanceof Array)) {
+                path = [path];
+            }
+            var len = path.length;
+            var appendSize = 0;
+            var offset = this._len;
+            for (var i = 0; i < len; i++) {
+                appendSize += path[i].len();
+            }
+            if (hasTypedArray && (this.data instanceof Float32Array)) {
+                this.data = new Float32Array(offset + appendSize);
+            }
+            for (var i = 0; i < len; i++) {
+                var appendPathData = path[i].data;
+                for (var k = 0; k < appendPathData.length; k++) {
+                    this.data[offset++] = appendPathData[k];
+                }
+            }
+            this._len = offset;
+        };
+        PathProxy.prototype.addData = function (cmd, a, b, c, d, e, f, g, h) {
+            if (!this._saveData) {
+                return;
+            }
+            var data = this.data;
+            if (this._len + arguments.length > data.length) {
+                this._expandData();
+                data = this.data;
+            }
+            for (var i = 0; i < arguments.length; i++) {
+                data[this._len++] = arguments[i];
+            }
+        };
+        PathProxy.prototype._expandData = function () {
+            if (!(this.data instanceof Array)) {
+                var newData = [];
+                for (var i = 0; i < this._len; i++) {
+                    newData[i] = this.data[i];
+                }
+                this.data = newData;
+            }
+        };
+        PathProxy.prototype._dashedLineTo = function (x1, y1) {
+            var dashSum = this._dashSum;
+            var lineDash = this._lineDash;
+            var ctx = this._ctx;
+            var offset = this._dashOffset;
+            var x0 = this._xi;
+            var y0 = this._yi;
+            var dx = x1 - x0;
+            var dy = y1 - y0;
+            var dist = mathSqrt$1(dx * dx + dy * dy);
+            var x = x0;
+            var y = y0;
+            var nDash = lineDash.length;
+            var dash;
+            var idx;
+            dx /= dist;
+            dy /= dist;
+            if (offset < 0) {
+                offset = dashSum + offset;
+            }
+            offset %= dashSum;
+            x -= offset * dx;
+            y -= offset * dy;
+            while ((dx > 0 && x <= x1) || (dx < 0 && x >= x1)
+                || (dx === 0 && ((dy > 0 && y <= y1) || (dy < 0 && y >= y1)))) {
+                idx = this._dashIdx;
+                dash = lineDash[idx];
+                x += dx * dash;
+                y += dy * dash;
+                this._dashIdx = (idx + 1) % nDash;
+                if ((dx > 0 && x < x0) || (dx < 0 && x > x0) || (dy > 0 && y < y0) || (dy < 0 && y > y0)) {
+                    continue;
+                }
+                ctx[idx % 2 ? 'moveTo' : 'lineTo'](dx >= 0 ? mathMin$2(x, x1) : mathMax$2(x, x1), dy >= 0 ? mathMin$2(y, y1) : mathMax$2(y, y1));
+            }
+            dx = x - x1;
+            dy = y - y1;
+            this._dashOffset = -mathSqrt$1(dx * dx + dy * dy);
+        };
+        PathProxy.prototype._dashedBezierTo = function (x1, y1, x2, y2, x3, y3) {
+            var ctx = this._ctx;
+            var dashSum = this._dashSum;
+            var offset = this._dashOffset;
+            var lineDash = this._lineDash;
+            var x0 = this._xi;
+            var y0 = this._yi;
+            var bezierLen = 0;
+            var idx = this._dashIdx;
+            var nDash = lineDash.length;
+            var t;
+            var dx;
+            var dy;
+            var x;
+            var y;
+            var tmpLen = 0;
+            if (offset < 0) {
+                offset = dashSum + offset;
+            }
+            offset %= dashSum;
+            for (t = 0; t < 1; t += 0.1) {
+                dx = cubicAt(x0, x1, x2, x3, t + 0.1)
+                    - cubicAt(x0, x1, x2, x3, t);
+                dy = cubicAt(y0, y1, y2, y3, t + 0.1)
+                    - cubicAt(y0, y1, y2, y3, t);
+                bezierLen += mathSqrt$1(dx * dx + dy * dy);
+            }
+            for (; idx < nDash; idx++) {
+                tmpLen += lineDash[idx];
+                if (tmpLen > offset) {
+                    break;
+                }
+            }
+            t = (tmpLen - offset) / bezierLen;
+            while (t <= 1) {
+                x = cubicAt(x0, x1, x2, x3, t);
+                y = cubicAt(y0, y1, y2, y3, t);
+                idx % 2 ? ctx.moveTo(x, y)
+                    : ctx.lineTo(x, y);
+                t += lineDash[idx] / bezierLen;
+                idx = (idx + 1) % nDash;
+            }
+            (idx % 2 !== 0) && ctx.lineTo(x3, y3);
+            dx = x3 - x;
+            dy = y3 - y;
+            this._dashOffset = -mathSqrt$1(dx * dx + dy * dy);
+        };
+        PathProxy.prototype._dashedQuadraticTo = function (x1, y1, x2, y2) {
+            var x3 = x2;
+            var y3 = y2;
+            x2 = (x2 + 2 * x1) / 3;
+            y2 = (y2 + 2 * y1) / 3;
+            x1 = (this._xi + 2 * x1) / 3;
+            y1 = (this._yi + 2 * y1) / 3;
+            this._dashedBezierTo(x1, y1, x2, y2, x3, y3);
+        };
+        PathProxy.prototype.toStatic = function () {
+            if (!this._saveData) {
+                return;
+            }
+            var data = this.data;
+            if (data instanceof Array) {
+                data.length = this._len;
+                if (hasTypedArray && this._len > 11) {
+                    this.data = new Float32Array(data);
+                }
+            }
+        };
+        PathProxy.prototype.getBoundingRect = function () {
+            min$1[0] = min$1[1] = min2[0] = min2[1] = Number.MAX_VALUE;
+            max$1[0] = max$1[1] = max2[0] = max2[1] = -Number.MAX_VALUE;
+            var data = this.data;
+            var xi = 0;
+            var yi = 0;
+            var x0 = 0;
+            var y0 = 0;
+            var i;
+            for (i = 0; i < this._len;) {
+                var cmd = data[i++];
+                var isFirst = i === 1;
+                if (isFirst) {
+                    xi = data[i];
+                    yi = data[i + 1];
+                    x0 = xi;
+                    y0 = yi;
+                }
+                switch (cmd) {
+                    case CMD.M:
+                        xi = x0 = data[i++];
+                        yi = y0 = data[i++];
+                        min2[0] = x0;
+                        min2[1] = y0;
+                        max2[0] = x0;
+                        max2[1] = y0;
+                        break;
+                    case CMD.L:
+                        fromLine(xi, yi, data[i], data[i + 1], min2, max2);
+                        xi = data[i++];
+                        yi = data[i++];
+                        break;
+                    case CMD.C:
+                        fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);
+                        xi = data[i++];
+                        yi = data[i++];
+                        break;
+                    case CMD.Q:
+                        fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);
+                        xi = data[i++];
+                        yi = data[i++];
+                        break;
+                    case CMD.A:
+                        var cx = data[i++];
+                        var cy = data[i++];
+                        var rx = data[i++];
+                        var ry = data[i++];
+                        var startAngle = data[i++];
+                        var endAngle = data[i++] + startAngle;
+                        i += 1;
+                        var anticlockwise = !data[i++];
+                        if (isFirst) {
+                            x0 = mathCos$1(startAngle) * rx + cx;
+                            y0 = mathSin$1(startAngle) * ry + cy;
+                        }
+                        fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);
+                        xi = mathCos$1(endAngle) * rx + cx;
+                        yi = mathSin$1(endAngle) * ry + cy;
+                        break;
+                    case CMD.R:
+                        x0 = xi = data[i++];
+                        y0 = yi = data[i++];
+                        var width = data[i++];
+                        var height = data[i++];
+                        fromLine(x0, y0, x0 + width, y0 + height, min2, max2);
+                        break;
+                    case CMD.Z:
+                        xi = x0;
+                        yi = y0;
+                        break;
+                }
+                min(min$1, min$1, min2);
+                max(max$1, max$1, max2);
+            }
+            if (i === 0) {
+                min$1[0] = min$1[1] = max$1[0] = max$1[1] = 0;
+            }
+            return new BoundingRect(min$1[0], min$1[1], max$1[0] - min$1[0], max$1[1] - min$1[1]);
+        };
+        PathProxy.prototype._calculateLength = function () {
+            var data = this.data;
+            var len = this._len;
+            var ux = this._ux;
+            var uy = this._uy;
+            var xi = 0;
+            var yi = 0;
+            var x0 = 0;
+            var y0 = 0;
+            if (!this._pathSegLen) {
+                this._pathSegLen = [];
+            }
+            var pathSegLen = this._pathSegLen;
+            var pathTotalLen = 0;
+            var segCount = 0;
+            for (var i = 0; i < len;) {
+                var cmd = data[i++];
+                var isFirst = i === 1;
+                if (isFirst) {
+                    xi = data[i];
+                    yi = data[i + 1];
+                    x0 = xi;
+                    y0 = yi;
+                }
+                var l = -1;
+                switch (cmd) {
+                    case CMD.M:
+                        xi = x0 = data[i++];
+                        yi = y0 = data[i++];
+                        break;
+                    case CMD.L: {
+                        var x2 = data[i++];
+                        var y2 = data[i++];
+                        var dx = x2 - xi;
+                        var dy = y2 - yi;
+                        if (mathAbs(dx) > ux || mathAbs(dy) > uy || i === len - 1) {
+                            l = Math.sqrt(dx * dx + dy * dy);
+                            xi = x2;
+                            yi = y2;
+                        }
+                        break;
+                    }
+                    case CMD.C: {
+                        var x1 = data[i++];
+                        var y1 = data[i++];
+                        var x2 = data[i++];
+                        var y2 = data[i++];
+                        var x3 = data[i++];
+                        var y3 = data[i++];
+                        l = cubicLength(xi, yi, x1, y1, x2, y2, x3, y3, 10);
+                        xi = x3;
+                        yi = y3;
+                        break;
+                    }
+                    case CMD.Q: {
+                        var x1 = data[i++];
+                        var y1 = data[i++];
+                        var x2 = data[i++];
+                        var y2 = data[i++];
+                        l = quadraticLength(xi, yi, x1, y1, x2, y2, 10);
+                        xi = x2;
+                        yi = y2;
+                        break;
+                    }
+                    case CMD.A:
+                        var cx = data[i++];
+                        var cy = data[i++];
+                        var rx = data[i++];
+                        var ry = data[i++];
+                        var startAngle = data[i++];
+                        var delta = data[i++];
+                        var endAngle = delta + startAngle;
+                        i += 1;
+                        var anticlockwise = !data[i++];
+                        if (isFirst) {
+                            x0 = mathCos$1(startAngle) * rx + cx;
+                            y0 = mathSin$1(startAngle) * ry + cy;
+                        }
+                        l = mathMax$2(rx, ry) * mathMin$2(PI2$1, Math.abs(delta));
+                        xi = mathCos$1(endAngle) * rx + cx;
+                        yi = mathSin$1(endAngle) * ry + cy;
+                        break;
+                    case CMD.R: {
+                        x0 = xi = data[i++];
+                        y0 = yi = data[i++];
+                        var width = data[i++];
+                        var height = data[i++];
+                        l = width * 2 + height * 2;
+                        break;
+                    }
+                    case CMD.Z: {
+                        var dx = x0 - xi;
+                        var dy = y0 - yi;
+                        l = Math.sqrt(dx * dx + dy * dy);
+                        xi = x0;
+                        yi = y0;
+                        break;
+                    }
+                }
+                if (l >= 0) {
+                    pathSegLen[segCount++] = l;
+                    pathTotalLen += l;
+                }
+            }
+            this._pathLen = pathTotalLen;
+            return pathTotalLen;
+        };
+        PathProxy.prototype.rebuildPath = function (ctx, percent) {
+            var d = this.data;
+            var ux = this._ux;
+            var uy = this._uy;
+            var len = this._len;
+            var x0;
+            var y0;
+            var xi;
+            var yi;
+            var x;
+            var y;
+            var drawPart = percent < 1;
+            var pathSegLen;
+            var pathTotalLen;
+            var accumLength = 0;
+            var segCount = 0;
+            var displayedLength;
+            if (drawPart) {
+                if (!this._pathSegLen) {
+                    this._calculateLength();
+                }
+                pathSegLen = this._pathSegLen;
+                pathTotalLen = this._pathLen;
+                displayedLength = percent * pathTotalLen;
+                if (!displayedLength) {
+                    return;
+                }
+            }
+            lo: for (var i = 0; i < len;) {
+                var cmd = d[i++];
+                var isFirst = i === 1;
+                if (isFirst) {
+                    xi = d[i];
+                    yi = d[i + 1];
+                    x0 = xi;
+                    y0 = yi;
+                }
+                switch (cmd) {
+                    case CMD.M:
+                        x0 = xi = d[i++];
+                        y0 = yi = d[i++];
+                        ctx.moveTo(xi, yi);
+                        break;
+                    case CMD.L: {
+                        x = d[i++];
+                        y = d[i++];
+                        if (mathAbs(x - xi) > ux || mathAbs(y - yi) > uy || i === len - 1) {
+                            if (drawPart) {
+                                var l = pathSegLen[segCount++];
+                                if (accumLength + l > displayedLength) {
+                                    var t = (displayedLength - accumLength) / l;
+                                    ctx.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t);
+                                    break lo;
+                                }
+                                accumLength += l;
+                            }
+                            ctx.lineTo(x, y);
+                            xi = x;
+                            yi = y;
+                        }
+                        break;
+                    }
+                    case CMD.C: {
+                        var x1 = d[i++];
+                        var y1 = d[i++];
+                        var x2 = d[i++];
+                        var y2 = d[i++];
+                        var x3 = d[i++];
+                        var y3 = d[i++];
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                var t = (displayedLength - accumLength) / l;
+                                cubicSubdivide(xi, x1, x2, x3, t, tmpOutX);
+                                cubicSubdivide(yi, y1, y2, y3, t, tmpOutY);
+                                ctx.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]);
+                                break lo;
+                            }
+                            accumLength += l;
+                        }
+                        ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+                        xi = x3;
+                        yi = y3;
+                        break;
+                    }
+                    case CMD.Q: {
+                        var x1 = d[i++];
+                        var y1 = d[i++];
+                        var x2 = d[i++];
+                        var y2 = d[i++];
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                var t = (displayedLength - accumLength) / l;
+                                quadraticSubdivide(xi, x1, x2, t, tmpOutX);
+                                quadraticSubdivide(yi, y1, y2, t, tmpOutY);
+                                ctx.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]);
+                                break lo;
+                            }
+                            accumLength += l;
+                        }
+                        ctx.quadraticCurveTo(x1, y1, x2, y2);
+                        xi = x2;
+                        yi = y2;
+                        break;
+                    }
+                    case CMD.A:
+                        var cx = d[i++];
+                        var cy = d[i++];
+                        var rx = d[i++];
+                        var ry = d[i++];
+                        var startAngle = d[i++];
+                        var delta = d[i++];
+                        var psi = d[i++];
+                        var anticlockwise = !d[i++];
+                        var r = (rx > ry) ? rx : ry;
+                        var isEllipse = mathAbs(rx - ry) > 1e-3;
+                        var endAngle = startAngle + delta;
+                        var breakBuild = false;
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                endAngle = startAngle + delta * (displayedLength - accumLength) / l;
+                                breakBuild = true;
+                            }
+                            accumLength += l;
+                        }
+                        if (isEllipse && ctx.ellipse) {
+                            ctx.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise);
+                        }
+                        else {
+                            ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
+                        }
+                        if (breakBuild) {
+                            break lo;
+                        }
+                        if (isFirst) {
+                            x0 = mathCos$1(startAngle) * rx + cx;
+                            y0 = mathSin$1(startAngle) * ry + cy;
+                        }
+                        xi = mathCos$1(endAngle) * rx + cx;
+                        yi = mathSin$1(endAngle) * ry + cy;
+                        break;
+                    case CMD.R:
+                        x0 = xi = d[i];
+                        y0 = yi = d[i + 1];
+                        x = d[i++];
+                        y = d[i++];
+                        var width = d[i++];
+                        var height = d[i++];
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                var d_1 = displayedLength - accumLength;
+                                ctx.moveTo(x, y);
+                                ctx.lineTo(x + mathMin$2(d_1, width), y);
+                                d_1 -= width;
+                                if (d_1 > 0) {
+                                    ctx.lineTo(x + width, y + mathMin$2(d_1, height));
+                                }
+                                d_1 -= height;
+                                if (d_1 > 0) {
+                                    ctx.lineTo(x + mathMax$2(width - d_1, 0), y + height);
+                                }
+                                d_1 -= width;
+                                if (d_1 > 0) {
+                                    ctx.lineTo(x, y + mathMax$2(height - d_1, 0));
+                                }
+                                break lo;
+                            }
+                            accumLength += l;
+                        }
+                        ctx.rect(x, y, width, height);
+                        break;
+                    case CMD.Z:
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                var t = (displayedLength - accumLength) / l;
+                                ctx.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t);
+                                break lo;
+                            }
+                            accumLength += l;
+                        }
+                        ctx.closePath();
+                        xi = x0;
+                        yi = y0;
+                }
+            }
+        };
+        PathProxy.CMD = CMD;
+        PathProxy.initDefaultProps = (function () {
+            var proto = PathProxy.prototype;
+            proto._saveData = true;
+            proto._needsDash = false;
+            proto._dashOffset = 0;
+            proto._dashIdx = 0;
+            proto._dashSum = 0;
+            proto._ux = 0;
+            proto._uy = 0;
+        })();
+        return PathProxy;
+    }());
+
+    function containStroke(x0, y0, x1, y1, lineWidth, x, y) {
+        if (lineWidth === 0) {
+            return false;
+        }
+        var _l = lineWidth;
+        var _a = 0;
+        var _b = x0;
+        if ((y > y0 + _l && y > y1 + _l)
+            || (y < y0 - _l && y < y1 - _l)
+            || (x > x0 + _l && x > x1 + _l)
+            || (x < x0 - _l && x < x1 - _l)) {
+            return false;
+        }
+        if (x0 !== x1) {
+            _a = (y0 - y1) / (x0 - x1);
+            _b = (x0 * y1 - x1 * y0) / (x0 - x1);
+        }
+        else {
+            return Math.abs(x - x0) <= _l / 2;
+        }
+        var tmp = _a * x - y + _b;
+        var _s = tmp * tmp / (_a * _a + 1);
+        return _s <= _l / 2 * _l / 2;
+    }
+
+    function containStroke$1(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {
+        if (lineWidth === 0) {
+            return false;
+        }
+        var _l = lineWidth;
+        if ((y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l)
+            || (y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l)
+            || (x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l)
+            || (x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l)) {
+            return false;
+        }
+        var d = cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);
+        return d <= _l / 2;
+    }
+
+    function containStroke$2(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {
+        if (lineWidth === 0) {
+            return false;
+        }
+        var _l = lineWidth;
+        if ((y > y0 + _l && y > y1 + _l && y > y2 + _l)
+            || (y < y0 - _l && y < y1 - _l && y < y2 - _l)
+            || (x > x0 + _l && x > x1 + _l && x > x2 + _l)
+            || (x < x0 - _l && x < x1 - _l && x < x2 - _l)) {
+            return false;
+        }
+        var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);
+        return d <= _l / 2;
+    }
+
+    var PI2$2 = Math.PI * 2;
+    function normalizeRadian(angle) {
+        angle %= PI2$2;
+        if (angle < 0) {
+            angle += PI2$2;
+        }
+        return angle;
+    }
+
+    var PI2$3 = Math.PI * 2;
+    function containStroke$3(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {
+        if (lineWidth === 0) {
+            return false;
+        }
+        var _l = lineWidth;
+        x -= cx;
+        y -= cy;
+        var d = Math.sqrt(x * x + y * y);
+        if ((d - _l > r) || (d + _l < r)) {
+            return false;
+        }
+        if (Math.abs(startAngle - endAngle) % PI2$3 < 1e-4) {
+            return true;
+        }
+        if (anticlockwise) {
+            var tmp = startAngle;
+            startAngle = normalizeRadian(endAngle);
+            endAngle = normalizeRadian(tmp);
+        }
+        else {
+            startAngle = normalizeRadian(startAngle);
+            endAngle = normalizeRadian(endAngle);
+        }
+        if (startAngle > endAngle) {
+            endAngle += PI2$3;
+        }
+        var angle = Math.atan2(y, x);
+        if (angle < 0) {
+            angle += PI2$3;
+        }
+        return (angle >= startAngle && angle <= endAngle)
+            || (angle + PI2$3 >= startAngle && angle + PI2$3 <= endAngle);
+    }
+
+    function windingLine(x0, y0, x1, y1, x, y) {
+        if ((y > y0 && y > y1) || (y < y0 && y < y1)) {
+            return 0;
+        }
+        if (y1 === y0) {
+            return 0;
+        }
+        var t = (y - y0) / (y1 - y0);
+        var dir = y1 < y0 ? 1 : -1;
+        if (t === 1 || t === 0) {
+            dir = y1 < y0 ? 0.5 : -0.5;
+        }
+        var x_ = t * (x1 - x0) + x0;
+        return x_ === x ? Infinity : x_ > x ? dir : 0;
+    }
+
+    var CMD$1 = PathProxy.CMD;
+    var PI2$4 = Math.PI * 2;
+    var EPSILON$2 = 1e-4;
+    function isAroundEqual(a, b) {
+        return Math.abs(a - b) < EPSILON$2;
+    }
+    var roots = [-1, -1, -1];
+    var extrema = [-1, -1];
+    function swapExtrema() {
+        var tmp = extrema[0];
+        extrema[0] = extrema[1];
+        extrema[1] = tmp;
+    }
+    function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {
+        if ((y > y0 && y > y1 && y > y2 && y > y3)
+            || (y < y0 && y < y1 && y < y2 && y < y3)) {
+            return 0;
+        }
+        var nRoots = cubicRootAt(y0, y1, y2, y3, y, roots);
+        if (nRoots === 0) {
+            return 0;
+        }
+        else {
+            var w = 0;
+            var nExtrema = -1;
+            var y0_ = void 0;
+            var y1_ = void 0;
+            for (var i = 0; i < nRoots; i++) {
+                var t = roots[i];
+                var unit = (t === 0 || t === 1) ? 0.5 : 1;
+                var x_ = cubicAt(x0, x1, x2, x3, t);
+                if (x_ < x) {
+                    continue;
+                }
+                if (nExtrema < 0) {
+                    nExtrema = cubicExtrema(y0, y1, y2, y3, extrema);
+                    if (extrema[1] < extrema[0] && nExtrema > 1) {
+                        swapExtrema();
+                    }
+                    y0_ = cubicAt(y0, y1, y2, y3, extrema[0]);
+                    if (nExtrema > 1) {
+                        y1_ = cubicAt(y0, y1, y2, y3, extrema[1]);
+                    }
+                }
+                if (nExtrema === 2) {
+                    if (t < extrema[0]) {
+                        w += y0_ < y0 ? unit : -unit;
+                    }
+                    else if (t < extrema[1]) {
+                        w += y1_ < y0_ ? unit : -unit;
+                    }
+                    else {
+                        w += y3 < y1_ ? unit : -unit;
+                    }
+                }
+                else {
+                    if (t < extrema[0]) {
+                        w += y0_ < y0 ? unit : -unit;
+                    }
+                    else {
+                        w += y3 < y0_ ? unit : -unit;
+                    }
+                }
+            }
+            return w;
+        }
+    }
+    function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {
+        if ((y > y0 && y > y1 && y > y2)
+            || (y < y0 && y < y1 && y < y2)) {
+            return 0;
+        }
+        var nRoots = quadraticRootAt(y0, y1, y2, y, roots);
+        if (nRoots === 0) {
+            return 0;
+        }
+        else {
+            var t = quadraticExtremum(y0, y1, y2);
+            if (t >= 0 && t <= 1) {
+                var w = 0;
+                var y_ = quadraticAt(y0, y1, y2, t);
+                for (var i = 0; i < nRoots; i++) {
+                    var unit = (roots[i] === 0 || roots[i] === 1) ? 0.5 : 1;
+                    var x_ = quadraticAt(x0, x1, x2, roots[i]);
+                    if (x_ < x) {
+                        continue;
+                    }
+                    if (roots[i] < t) {
+                        w += y_ < y0 ? unit : -unit;
+                    }
+                    else {
+                        w += y2 < y_ ? unit : -unit;
+                    }
+                }
+                return w;
+            }
+            else {
+                var unit = (roots[0] === 0 || roots[0] === 1) ? 0.5 : 1;
+                var x_ = quadraticAt(x0, x1, x2, roots[0]);
+                if (x_ < x) {
+                    return 0;
+                }
+                return y2 < y0 ? unit : -unit;
+            }
+        }
+    }
+    function windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {
+        y -= cy;
+        if (y > r || y < -r) {
+            return 0;
+        }
+        var tmp = Math.sqrt(r * r - y * y);
+        roots[0] = -tmp;
+        roots[1] = tmp;
+        var dTheta = Math.abs(startAngle - endAngle);
+        if (dTheta < 1e-4) {
+            return 0;
+        }
+        if (dTheta >= PI2$4 - 1e-4) {
+            startAngle = 0;
+            endAngle = PI2$4;
+            var dir = anticlockwise ? 1 : -1;
+            if (x >= roots[0] + cx && x <= roots[1] + cx) {
+                return dir;
+            }
+            else {
+                return 0;
+            }
+        }
+        if (startAngle > endAngle) {
+            var tmp_1 = startAngle;
+            startAngle = endAngle;
+            endAngle = tmp_1;
+        }
+        if (startAngle < 0) {
+            startAngle += PI2$4;
+            endAngle += PI2$4;
+        }
+        var w = 0;
+        for (var i = 0; i < 2; i++) {
+            var x_ = roots[i];
+            if (x_ + cx > x) {
+                var angle = Math.atan2(y, x_);
+                var dir = anticlockwise ? 1 : -1;
+                if (angle < 0) {
+                    angle = PI2$4 + angle;
+                }
+                if ((angle >= startAngle && angle <= endAngle)
+                    || (angle + PI2$4 >= startAngle && angle + PI2$4 <= endAngle)) {
+                    if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {
+                        dir = -dir;
+                    }
+                    w += dir;
+                }
+            }
+        }
+        return w;
+    }
+    function containPath(path, lineWidth, isStroke, x, y) {
+        var data = path.data;
+        var len = path.len();
+        var w = 0;
+        var xi = 0;
+        var yi = 0;
+        var x0 = 0;
+        var y0 = 0;
+        var x1;
+        var y1;
+        for (var i = 0; i < len;) {
+            var cmd = data[i++];
+            var isFirst = i === 1;
+            if (cmd === CMD$1.M && i > 1) {
+                if (!isStroke) {
+                    w += windingLine(xi, yi, x0, y0, x, y);
+                }
+            }
+            if (isFirst) {
+                xi = data[i];
+                yi = data[i + 1];
+                x0 = xi;
+                y0 = yi;
+            }
+            switch (cmd) {
+                case CMD$1.M:
+                    x0 = data[i++];
+                    y0 = data[i++];
+                    xi = x0;
+                    yi = y0;
+                    break;
+                case CMD$1.L:
+                    if (isStroke) {
+                        if (containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0;
+                    }
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD$1.C:
+                    if (isStroke) {
+                        if (containStroke$1(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+                    }
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD$1.Q:
+                    if (isStroke) {
+                        if (containStroke$2(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+                    }
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD$1.A:
+                    var cx = data[i++];
+                    var cy = data[i++];
+                    var rx = data[i++];
+                    var ry = data[i++];
+                    var theta = data[i++];
+                    var dTheta = data[i++];
+                    i += 1;
+                    var anticlockwise = !!(1 - data[i++]);
+                    x1 = Math.cos(theta) * rx + cx;
+                    y1 = Math.sin(theta) * ry + cy;
+                    if (!isFirst) {
+                        w += windingLine(xi, yi, x1, y1, x, y);
+                    }
+                    else {
+                        x0 = x1;
+                        y0 = y1;
+                    }
+                    var _x = (x - cx) * ry / rx + cx;
+                    if (isStroke) {
+                        if (containStroke$3(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);
+                    }
+                    xi = Math.cos(theta + dTheta) * rx + cx;
+                    yi = Math.sin(theta + dTheta) * ry + cy;
+                    break;
+                case CMD$1.R:
+                    x0 = xi = data[i++];
+                    y0 = yi = data[i++];
+                    var width = data[i++];
+                    var height = data[i++];
+                    x1 = x0 + width;
+                    y1 = y0 + height;
+                    if (isStroke) {
+                        if (containStroke(x0, y0, x1, y0, lineWidth, x, y)
+                            || containStroke(x1, y0, x1, y1, lineWidth, x, y)
+                            || containStroke(x1, y1, x0, y1, lineWidth, x, y)
+                            || containStroke(x0, y1, x0, y0, lineWidth, x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingLine(x1, y0, x1, y1, x, y);
+                        w += windingLine(x0, y1, x0, y0, x, y);
+                    }
+                    break;
+                case CMD$1.Z:
+                    if (isStroke) {
+                        if (containStroke(xi, yi, x0, y0, lineWidth, x, y)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        w += windingLine(xi, yi, x0, y0, x, y);
+                    }
+                    xi = x0;
+                    yi = y0;
+                    break;
+            }
+        }
+        if (!isStroke && !isAroundEqual(yi, y0)) {
+            w += windingLine(xi, yi, x0, y0, x, y) || 0;
+        }
+        return w !== 0;
+    }
+    function contain(pathProxy, x, y) {
+        return containPath(pathProxy, 0, false, x, y);
+    }
+    function containStroke$4(pathProxy, lineWidth, x, y) {
+        return containPath(pathProxy, lineWidth, true, x, y);
+    }
+
+    var DEFAULT_PATH_STYLE = defaults({
+        fill: '#000',
+        stroke: null,
+        strokePercent: 1,
+        fillOpacity: 1,
+        strokeOpacity: 1,
+        lineDashOffset: 0,
+        lineWidth: 1,
+        lineCap: 'butt',
+        miterLimit: 10,
+        strokeNoScale: false,
+        strokeFirst: false
+    }, DEFAULT_COMMON_STYLE);
+    var DEFAULT_PATH_ANIMATION_PROPS = {
+        style: defaults({
+            fill: true,
+            stroke: true,
+            strokePercent: true,
+            fillOpacity: true,
+            strokeOpacity: true,
+            lineDashOffset: true,
+            lineWidth: true,
+            miterLimit: true
+        }, DEFAULT_COMMON_ANIMATION_PROPS.style)
+    };
+    var pathCopyParams = [
+        'x', 'y', 'rotation', 'scaleX', 'scaleY', 'originX', 'originY', 'invisible',
+        'culling', 'z', 'z2', 'zlevel', 'parent'
+    ];
+    var Path = (function (_super) {
+        __extends(Path, _super);
+        function Path(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Path.prototype.update = function () {
+            var _this = this;
+            _super.prototype.update.call(this);
+            var style = this.style;
+            if (style.decal) {
+                var decalEl = this._decalEl
+                    = this._decalEl || new Path();
+                if (decalEl.buildPath === Path.prototype.buildPath) {
+                    decalEl.buildPath = function (ctx) {
+                        _this.buildPath(ctx, _this.shape);
+                    };
+                }
+                decalEl.silent = true;
+                var decalElStyle = decalEl.style;
+                for (var key in style) {
+                    if (decalElStyle[key] !== style[key]) {
+                        decalElStyle[key] = style[key];
+                    }
+                }
+                decalElStyle.fill = style.fill ? style.decal : null;
+                decalElStyle.decal = null;
+                decalElStyle.shadowColor = null;
+                style.strokeFirst && (decalElStyle.stroke = null);
+                for (var i = 0; i < pathCopyParams.length; ++i) {
+                    decalEl[pathCopyParams[i]] = this[pathCopyParams[i]];
+                }
+                decalEl.__dirty |= Element.REDARAW_BIT;
+            }
+            else if (this._decalEl) {
+                this._decalEl = null;
+            }
+        };
+        Path.prototype.getDecalElement = function () {
+            return this._decalEl;
+        };
+        Path.prototype._init = function (props) {
+            var keysArr = keys(props);
+            this.shape = this.getDefaultShape();
+            var defaultStyle = this.getDefaultStyle();
+            if (defaultStyle) {
+                this.useStyle(defaultStyle);
+            }
+            for (var i = 0; i < keysArr.length; i++) {
+                var key = keysArr[i];
+                var value = props[key];
+                if (key === 'style') {
+                    if (!this.style) {
+                        this.useStyle(value);
+                    }
+                    else {
+                        extend(this.style, value);
+                    }
+                }
+                else if (key === 'shape') {
+                    extend(this.shape, value);
+                }
+                else {
+                    _super.prototype.attrKV.call(this, key, value);
+                }
+            }
+            if (!this.style) {
+                this.useStyle({});
+            }
+        };
+        Path.prototype.getDefaultStyle = function () {
+            return null;
+        };
+        Path.prototype.getDefaultShape = function () {
+            return {};
+        };
+        Path.prototype.canBeInsideText = function () {
+            return this.hasFill();
+        };
+        Path.prototype.getInsideTextFill = function () {
+            var pathFill = this.style.fill;
+            if (pathFill !== 'none') {
+                if (isString(pathFill)) {
+                    var fillLum = lum(pathFill, 0);
+                    if (fillLum > 0.5) {
+                        return DARK_LABEL_COLOR;
+                    }
+                    else if (fillLum > 0.2) {
+                        return LIGHTER_LABEL_COLOR;
+                    }
+                    return LIGHT_LABEL_COLOR;
+                }
+                else if (pathFill) {
+                    return LIGHT_LABEL_COLOR;
+                }
+            }
+            return DARK_LABEL_COLOR;
+        };
+        Path.prototype.getInsideTextStroke = function (textFill) {
+            var pathFill = this.style.fill;
+            if (isString(pathFill)) {
+                var zr = this.__zr;
+                var isDarkMode = !!(zr && zr.isDarkMode());
+                var isDarkLabel = lum(textFill, 0) < DARK_MODE_THRESHOLD;
+                if (isDarkMode === isDarkLabel) {
+                    return pathFill;
+                }
+            }
+        };
+        Path.prototype.buildPath = function (ctx, shapeCfg, inBundle) { };
+        Path.prototype.pathUpdated = function () {
+            this.__dirty &= ~Path.SHAPE_CHANGED_BIT;
+        };
+        Path.prototype.createPathProxy = function () {
+            this.path = new PathProxy(false);
+        };
+        Path.prototype.hasStroke = function () {
+            var style = this.style;
+            var stroke = style.stroke;
+            return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0));
+        };
+        Path.prototype.hasFill = function () {
+            var style = this.style;
+            var fill = style.fill;
+            return fill != null && fill !== 'none';
+        };
+        Path.prototype.getBoundingRect = function () {
+            var rect = this._rect;
+            var style = this.style;
+            var needsUpdateRect = !rect;
+            if (needsUpdateRect) {
+                var firstInvoke = false;
+                if (!this.path) {
+                    firstInvoke = true;
+                    this.createPathProxy();
+                }
+                var path = this.path;
+                if (firstInvoke || (this.__dirty & Path.SHAPE_CHANGED_BIT)) {
+                    path.beginPath();
+                    this.buildPath(path, this.shape, false);
+                    this.pathUpdated();
+                }
+                rect = path.getBoundingRect();
+            }
+            this._rect = rect;
+            if (this.hasStroke() && this.path && this.path.len() > 0) {
+                var rectWithStroke = this._rectWithStroke || (this._rectWithStroke = rect.clone());
+                if (this.__dirty || needsUpdateRect) {
+                    rectWithStroke.copy(rect);
+                    var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+                    var w = style.lineWidth;
+                    if (!this.hasFill()) {
+                        var strokeContainThreshold = this.strokeContainThreshold;
+                        w = Math.max(w, strokeContainThreshold == null ? 4 : strokeContainThreshold);
+                    }
+                    if (lineScale > 1e-10) {
+                        rectWithStroke.width += w / lineScale;
+                        rectWithStroke.height += w / lineScale;
+                        rectWithStroke.x -= w / lineScale / 2;
+                        rectWithStroke.y -= w / lineScale / 2;
+                    }
+                }
+                return rectWithStroke;
+            }
+            return rect;
+        };
+        Path.prototype.contain = function (x, y) {
+            var localPos = this.transformCoordToLocal(x, y);
+            var rect = this.getBoundingRect();
+            var style = this.style;
+            x = localPos[0];
+            y = localPos[1];
+            if (rect.contain(x, y)) {
+                var pathProxy = this.path;
+                if (this.hasStroke()) {
+                    var lineWidth = style.lineWidth;
+                    var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+                    if (lineScale > 1e-10) {
+                        if (!this.hasFill()) {
+                            lineWidth = Math.max(lineWidth, this.strokeContainThreshold);
+                        }
+                        if (containStroke$4(pathProxy, lineWidth / lineScale, x, y)) {
+                            return true;
+                        }
+                    }
+                }
+                if (this.hasFill()) {
+                    return contain(pathProxy, x, y);
+                }
+            }
+            return false;
+        };
+        Path.prototype.dirtyShape = function () {
+            this.__dirty |= Path.SHAPE_CHANGED_BIT;
+            if (this._rect) {
+                this._rect = null;
+            }
+            if (this._decalEl) {
+                this._decalEl.dirtyShape();
+            }
+            this.markRedraw();
+        };
+        Path.prototype.dirty = function () {
+            this.dirtyStyle();
+            this.dirtyShape();
+        };
+        Path.prototype.animateShape = function (loop) {
+            return this.animate('shape', loop);
+        };
+        Path.prototype.updateDuringAnimation = function (targetKey) {
+            if (targetKey === 'style') {
+                this.dirtyStyle();
+            }
+            else if (targetKey === 'shape') {
+                this.dirtyShape();
+            }
+            else {
+                this.markRedraw();
+            }
+        };
+        Path.prototype.attrKV = function (key, value) {
+            if (key === 'shape') {
+                this.setShape(value);
+            }
+            else {
+                _super.prototype.attrKV.call(this, key, value);
+            }
+        };
+        Path.prototype.setShape = function (keyOrObj, value) {
+            var shape = this.shape;
+            if (!shape) {
+                shape = this.shape = {};
+            }
+            if (typeof keyOrObj === 'string') {
+                shape[keyOrObj] = value;
+            }
+            else {
+                extend(shape, keyOrObj);
+            }
+            this.dirtyShape();
+            return this;
+        };
+        Path.prototype.shapeChanged = function () {
+            return !!(this.__dirty & Path.SHAPE_CHANGED_BIT);
+        };
+        Path.prototype.createStyle = function (obj) {
+            return createObject(DEFAULT_PATH_STYLE, obj);
+        };
+        Path.prototype._innerSaveToNormal = function (toState) {
+            _super.prototype._innerSaveToNormal.call(this, toState);
+            var normalState = this._normalState;
+            if (toState.shape && !normalState.shape) {
+                normalState.shape = extend({}, this.shape);
+            }
+        };
+        Path.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+            _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+            var needsRestoreToNormal = !(state && keepCurrentStates);
+            var targetShape;
+            if (state && state.shape) {
+                if (transition) {
+                    if (keepCurrentStates) {
+                        targetShape = state.shape;
+                    }
+                    else {
+                        targetShape = extend({}, normalState.shape);
+                        extend(targetShape, state.shape);
+                    }
+                }
+                else {
+                    targetShape = extend({}, keepCurrentStates ? this.shape : normalState.shape);
+                    extend(targetShape, state.shape);
+                }
+            }
+            else if (needsRestoreToNormal) {
+                targetShape = normalState.shape;
+            }
+            if (targetShape) {
+                if (transition) {
+                    this.shape = extend({}, this.shape);
+                    var targetShapePrimaryProps = {};
+                    var shapeKeys = keys(targetShape);
+                    for (var i = 0; i < shapeKeys.length; i++) {
+                        var key = shapeKeys[i];
+                        if (typeof targetShape[key] === 'object') {
+                            this.shape[key] = targetShape[key];
+                        }
+                        else {
+                            targetShapePrimaryProps[key] = targetShape[key];
+                        }
+                    }
+                    this._transitionState(stateName, {
+                        shape: targetShapePrimaryProps
+                    }, animationCfg);
+                }
+                else {
+                    this.shape = targetShape;
+                    this.dirtyShape();
+                }
+            }
+        };
+        Path.prototype._mergeStates = function (states) {
+            var mergedState = _super.prototype._mergeStates.call(this, states);
+            var mergedShape;
+            for (var i = 0; i < states.length; i++) {
+                var state = states[i];
+                if (state.shape) {
+                    mergedShape = mergedShape || {};
+                    this._mergeStyle(mergedShape, state.shape);
+                }
+            }
+            if (mergedShape) {
+                mergedState.shape = mergedShape;
+            }
+            return mergedState;
+        };
+        Path.prototype.getAnimationStyleProps = function () {
+            return DEFAULT_PATH_ANIMATION_PROPS;
+        };
+        Path.prototype.isZeroArea = function () {
+            return false;
+        };
+        Path.extend = function (defaultProps) {
+            var Sub = (function (_super) {
+                __extends(Sub, _super);
+                function Sub(opts) {
+                    var _this = _super.call(this, opts) || this;
+                    defaultProps.init && defaultProps.init.call(_this, opts);
+                    return _this;
+                }
+                Sub.prototype.getDefaultStyle = function () {
+                    return clone(defaultProps.style);
+                };
+                Sub.prototype.getDefaultShape = function () {
+                    return clone(defaultProps.shape);
+                };
+                return Sub;
+            }(Path));
+            for (var key in defaultProps) {
+                if (typeof defaultProps[key] === 'function') {
+                    Sub.prototype[key] = defaultProps[key];
+                }
+            }
+            return Sub;
+        };
+        Path.SHAPE_CHANGED_BIT = 4;
+        Path.initDefaultProps = (function () {
+            var pathProto = Path.prototype;
+            pathProto.type = 'path';
+            pathProto.strokeContainThreshold = 5;
+            pathProto.segmentIgnoreThreshold = 0;
+            pathProto.subPixelOptimize = false;
+            pathProto.autoBatch = false;
+            pathProto.__dirty = Element.REDARAW_BIT | Displayable.STYLE_CHANGED_BIT | Path.SHAPE_CHANGED_BIT;
+        })();
+        return Path;
+    }(Displayable));
+
+    var DEFAULT_TSPAN_STYLE = defaults({
+        strokeFirst: true,
+        font: DEFAULT_FONT,
+        x: 0,
+        y: 0,
+        textAlign: 'left',
+        textBaseline: 'top',
+        miterLimit: 2
+    }, DEFAULT_PATH_STYLE);
+    var TSpan = (function (_super) {
+        __extends(TSpan, _super);
+        function TSpan() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TSpan.prototype.hasStroke = function () {
+            var style = this.style;
+            var stroke = style.stroke;
+            return stroke != null && stroke !== 'none' && style.lineWidth > 0;
+        };
+        TSpan.prototype.hasFill = function () {
+            var style = this.style;
+            var fill = style.fill;
+            return fill != null && fill !== 'none';
+        };
+        TSpan.prototype.createStyle = function (obj) {
+            return createObject(DEFAULT_TSPAN_STYLE, obj);
+        };
+        TSpan.prototype.setBoundingRect = function (rect) {
+            this._rect = rect;
+        };
+        TSpan.prototype.getBoundingRect = function () {
+            var style = this.style;
+            if (!this._rect) {
+                var text = style.text;
+                text != null ? (text += '') : (text = '');
+                var rect = getBoundingRect(text, style.font, style.textAlign, style.textBaseline);
+                rect.x += style.x || 0;
+                rect.y += style.y || 0;
+                if (this.hasStroke()) {
+                    var w = style.lineWidth;
+                    rect.x -= w / 2;
+                    rect.y -= w / 2;
+                    rect.width += w;
+                    rect.height += w;
+                }
+                this._rect = rect;
+            }
+            return this._rect;
+        };
+        TSpan.initDefaultProps = (function () {
+            var tspanProto = TSpan.prototype;
+            tspanProto.dirtyRectTolerance = 10;
+        })();
+        return TSpan;
+    }(Displayable));
+    TSpan.prototype.type = 'tspan';
+
+    var DEFAULT_IMAGE_STYLE = defaults({
+        x: 0,
+        y: 0
+    }, DEFAULT_COMMON_STYLE);
+    var DEFAULT_IMAGE_ANIMATION_PROPS = {
+        style: defaults({
+            x: true,
+            y: true,
+            width: true,
+            height: true,
+            sx: true,
+            sy: true,
+            sWidth: true,
+            sHeight: true
+        }, DEFAULT_COMMON_ANIMATION_PROPS.style)
+    };
+    function isImageLike(source) {
+        return !!(source
+            && typeof source !== 'string'
+            && source.width && source.height);
+    }
+    var ZRImage = (function (_super) {
+        __extends(ZRImage, _super);
+        function ZRImage() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ZRImage.prototype.createStyle = function (obj) {
+            return createObject(DEFAULT_IMAGE_STYLE, obj);
+        };
+        ZRImage.prototype._getSize = function (dim) {
+            var style = this.style;
+            var size = style[dim];
+            if (size != null) {
+                return size;
+            }
+            var imageSource = isImageLike(style.image)
+                ? style.image : this.__image;
+            if (!imageSource) {
+                return 0;
+            }
+            var otherDim = dim === 'width' ? 'height' : 'width';
+            var otherDimSize = style[otherDim];
+            if (otherDimSize == null) {
+                return imageSource[dim];
+            }
+            else {
+                return imageSource[dim] / imageSource[otherDim] * otherDimSize;
+            }
+        };
+        ZRImage.prototype.getWidth = function () {
+            return this._getSize('width');
+        };
+        ZRImage.prototype.getHeight = function () {
+            return this._getSize('height');
+        };
+        ZRImage.prototype.getAnimationStyleProps = function () {
+            return DEFAULT_IMAGE_ANIMATION_PROPS;
+        };
+        ZRImage.prototype.getBoundingRect = function () {
+            var style = this.style;
+            if (!this._rect) {
+                this._rect = new BoundingRect(style.x || 0, style.y || 0, this.getWidth(), this.getHeight());
+            }
+            return this._rect;
+        };
+        return ZRImage;
+    }(Displayable));
+    ZRImage.prototype.type = 'image';
+
+    function buildPath(ctx, shape) {
+        var x = shape.x;
+        var y = shape.y;
+        var width = shape.width;
+        var height = shape.height;
+        var r = shape.r;
+        var r1;
+        var r2;
+        var r3;
+        var r4;
+        if (width < 0) {
+            x = x + width;
+            width = -width;
+        }
+        if (height < 0) {
+            y = y + height;
+            height = -height;
+        }
+        if (typeof r === 'number') {
+            r1 = r2 = r3 = r4 = r;
+        }
+        else if (r instanceof Array) {
+            if (r.length === 1) {
+                r1 = r2 = r3 = r4 = r[0];
+            }
+            else if (r.length === 2) {
+                r1 = r3 = r[0];
+                r2 = r4 = r[1];
+            }
+            else if (r.length === 3) {
+                r1 = r[0];
+                r2 = r4 = r[1];
+                r3 = r[2];
+            }
+            else {
+                r1 = r[0];
+                r2 = r[1];
+                r3 = r[2];
+                r4 = r[3];
+            }
+        }
+        else {
+            r1 = r2 = r3 = r4 = 0;
+        }
+        var total;
+        if (r1 + r2 > width) {
+            total = r1 + r2;
+            r1 *= width / total;
+            r2 *= width / total;
+        }
+        if (r3 + r4 > width) {
+            total = r3 + r4;
+            r3 *= width / total;
+            r4 *= width / total;
+        }
+        if (r2 + r3 > height) {
+            total = r2 + r3;
+            r2 *= height / total;
+            r3 *= height / total;
+        }
+        if (r1 + r4 > height) {
+            total = r1 + r4;
+            r1 *= height / total;
+            r4 *= height / total;
+        }
+        ctx.moveTo(x + r1, y);
+        ctx.lineTo(x + width - r2, y);
+        r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);
+        ctx.lineTo(x + width, y + height - r3);
+        r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);
+        ctx.lineTo(x + r4, y + height);
+        r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);
+        ctx.lineTo(x, y + r1);
+        r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);
+    }
+
+    var round$1 = Math.round;
+    function subPixelOptimizeLine(outputShape, inputShape, style) {
+        if (!inputShape) {
+            return;
+        }
+        var x1 = inputShape.x1;
+        var x2 = inputShape.x2;
+        var y1 = inputShape.y1;
+        var y2 = inputShape.y2;
+        outputShape.x1 = x1;
+        outputShape.x2 = x2;
+        outputShape.y1 = y1;
+        outputShape.y2 = y2;
+        var lineWidth = style && style.lineWidth;
+        if (!lineWidth) {
+            return outputShape;
+        }
+        if (round$1(x1 * 2) === round$1(x2 * 2)) {
+            outputShape.x1 = outputShape.x2 = subPixelOptimize(x1, lineWidth, true);
+        }
+        if (round$1(y1 * 2) === round$1(y2 * 2)) {
+            outputShape.y1 = outputShape.y2 = subPixelOptimize(y1, lineWidth, true);
+        }
+        return outputShape;
+    }
+    function subPixelOptimizeRect(outputShape, inputShape, style) {
+        if (!inputShape) {
+            return;
+        }
+        var originX = inputShape.x;
+        var originY = inputShape.y;
+        var originWidth = inputShape.width;
+        var originHeight = inputShape.height;
+        outputShape.x = originX;
+        outputShape.y = originY;
+        outputShape.width = originWidth;
+        outputShape.height = originHeight;
+        var lineWidth = style && style.lineWidth;
+        if (!lineWidth) {
+            return outputShape;
+        }
+        outputShape.x = subPixelOptimize(originX, lineWidth, true);
+        outputShape.y = subPixelOptimize(originY, lineWidth, true);
+        outputShape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - outputShape.x, originWidth === 0 ? 0 : 1);
+        outputShape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - outputShape.y, originHeight === 0 ? 0 : 1);
+        return outputShape;
+    }
+    function subPixelOptimize(position, lineWidth, positiveOrNegative) {
+        if (!lineWidth) {
+            return position;
+        }
+        var doubledPosition = round$1(position * 2);
+        return (doubledPosition + round$1(lineWidth)) % 2 === 0
+            ? doubledPosition / 2
+            : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;
+    }
+
+    var RectShape = (function () {
+        function RectShape() {
+            this.x = 0;
+            this.y = 0;
+            this.width = 0;
+            this.height = 0;
+        }
+        return RectShape;
+    }());
+    var subPixelOptimizeOutputShape = {};
+    var Rect = (function (_super) {
+        __extends(Rect, _super);
+        function Rect(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Rect.prototype.getDefaultShape = function () {
+            return new RectShape();
+        };
+        Rect.prototype.buildPath = function (ctx, shape) {
+            var x;
+            var y;
+            var width;
+            var height;
+            if (this.subPixelOptimize) {
+                var optimizedShape = subPixelOptimizeRect(subPixelOptimizeOutputShape, shape, this.style);
+                x = optimizedShape.x;
+                y = optimizedShape.y;
+                width = optimizedShape.width;
+                height = optimizedShape.height;
+                optimizedShape.r = shape.r;
+                shape = optimizedShape;
+            }
+            else {
+                x = shape.x;
+                y = shape.y;
+                width = shape.width;
+                height = shape.height;
+            }
+            if (!shape.r) {
+                ctx.rect(x, y, width, height);
+            }
+            else {
+                buildPath(ctx, shape);
+            }
+        };
+        Rect.prototype.isZeroArea = function () {
+            return !this.shape.width || !this.shape.height;
+        };
+        return Rect;
+    }(Path));
+    Rect.prototype.type = 'rect';
+
+    var DEFAULT_RICH_TEXT_COLOR = {
+        fill: '#000'
+    };
+    var DEFAULT_STROKE_LINE_WIDTH = 2;
+    var DEFAULT_TEXT_ANIMATION_PROPS = {
+        style: defaults({
+            fill: true,
+            stroke: true,
+            fillOpacity: true,
+            strokeOpacity: true,
+            lineWidth: true,
+            fontSize: true,
+            lineHeight: true,
+            width: true,
+            height: true,
+            textShadowColor: true,
+            textShadowBlur: true,
+            textShadowOffsetX: true,
+            textShadowOffsetY: true,
+            backgroundColor: true,
+            padding: true,
+            borderColor: true,
+            borderWidth: true,
+            borderRadius: true
+        }, DEFAULT_COMMON_ANIMATION_PROPS.style)
+    };
+    var ZRText = (function (_super) {
+        __extends(ZRText, _super);
+        function ZRText(opts) {
+            var _this = _super.call(this) || this;
+            _this.type = 'text';
+            _this._children = [];
+            _this._defaultStyle = DEFAULT_RICH_TEXT_COLOR;
+            _this.attr(opts);
+            return _this;
+        }
+        ZRText.prototype.childrenRef = function () {
+            return this._children;
+        };
+        ZRText.prototype.update = function () {
+            if (this.styleChanged()) {
+                this._updateSubTexts();
+            }
+            for (var i = 0; i < this._children.length; i++) {
+                var child = this._children[i];
+                child.zlevel = this.zlevel;
+                child.z = this.z;
+                child.z2 = this.z2;
+                child.culling = this.culling;
+                child.cursor = this.cursor;
+                child.invisible = this.invisible;
+            }
+            var attachedTransform = this.attachedTransform;
+            if (attachedTransform) {
+                attachedTransform.updateTransform();
+                var m = attachedTransform.transform;
+                if (m) {
+                    this.transform = this.transform || [];
+                    copy$1(this.transform, m);
+                }
+                else {
+                    this.transform = null;
+                }
+            }
+            else {
+                _super.prototype.update.call(this);
+            }
+        };
+        ZRText.prototype.getComputedTransform = function () {
+            if (this.__hostTarget) {
+                this.__hostTarget.getComputedTransform();
+                this.__hostTarget.updateInnerText(true);
+            }
+            return this.attachedTransform ? this.attachedTransform.getComputedTransform()
+                : _super.prototype.getComputedTransform.call(this);
+        };
+        ZRText.prototype._updateSubTexts = function () {
+            this._childCursor = 0;
+            normalizeTextStyle(this.style);
+            this.style.rich
+                ? this._updateRichTexts()
+                : this._updatePlainTexts();
+            this._children.length = this._childCursor;
+            this.styleUpdated();
+        };
+        ZRText.prototype.addSelfToZr = function (zr) {
+            _super.prototype.addSelfToZr.call(this, zr);
+            for (var i = 0; i < this._children.length; i++) {
+                this._children[i].__zr = zr;
+            }
+        };
+        ZRText.prototype.removeSelfFromZr = function (zr) {
+            _super.prototype.removeSelfFromZr.call(this, zr);
+            for (var i = 0; i < this._children.length; i++) {
+                this._children[i].__zr = null;
+            }
+        };
+        ZRText.prototype.getBoundingRect = function () {
+            if (this.styleChanged()) {
+                this._updateSubTexts();
+            }
+            if (!this._rect) {
+                var tmpRect = new BoundingRect(0, 0, 0, 0);
+                var children = this._children;
+                var tmpMat = [];
+                var rect = null;
+                for (var i = 0; i < children.length; i++) {
+                    var child = children[i];
+                    var childRect = child.getBoundingRect();
+                    var transform = child.getLocalTransform(tmpMat);
+                    if (transform) {
+                        tmpRect.copy(childRect);
+                        tmpRect.applyTransform(transform);
+                        rect = rect || tmpRect.clone();
+                        rect.union(tmpRect);
+                    }
+                    else {
+                        rect = rect || childRect.clone();
+                        rect.union(childRect);
+                    }
+                }
+                this._rect = rect || tmpRect;
+            }
+            return this._rect;
+        };
+        ZRText.prototype.setDefaultTextStyle = function (defaultTextStyle) {
+            this._defaultStyle = defaultTextStyle || DEFAULT_RICH_TEXT_COLOR;
+        };
+        ZRText.prototype.setTextContent = function (textContent) {
+            throw new Error('Can\'t attach text on another text');
+        };
+        ZRText.prototype._mergeStyle = function (targetStyle, sourceStyle) {
+            if (!sourceStyle) {
+                return targetStyle;
+            }
+            var sourceRich = sourceStyle.rich;
+            var targetRich = targetStyle.rich || (sourceRich && {});
+            extend(targetStyle, sourceStyle);
+            if (sourceRich && targetRich) {
+                this._mergeRich(targetRich, sourceRich);
+                targetStyle.rich = targetRich;
+            }
+            else if (targetRich) {
+                targetStyle.rich = targetRich;
+            }
+            return targetStyle;
+        };
+        ZRText.prototype._mergeRich = function (targetRich, sourceRich) {
+            var richNames = keys(sourceRich);
+            for (var i = 0; i < richNames.length; i++) {
+                var richName = richNames[i];
+                targetRich[richName] = targetRich[richName] || {};
+                extend(targetRich[richName], sourceRich[richName]);
+            }
+        };
+        ZRText.prototype.getAnimationStyleProps = function () {
+            return DEFAULT_TEXT_ANIMATION_PROPS;
+        };
+        ZRText.prototype._getOrCreateChild = function (Ctor) {
+            var child = this._children[this._childCursor];
+            if (!child || !(child instanceof Ctor)) {
+                child = new Ctor();
+            }
+            this._children[this._childCursor++] = child;
+            child.__zr = this.__zr;
+            child.parent = this;
+            return child;
+        };
+        ZRText.prototype._updatePlainTexts = function () {
+            var style = this.style;
+            var textFont = style.font || DEFAULT_FONT;
+            var textPadding = style.padding;
+            var text = getStyleText(style);
+            var contentBlock = parsePlainText(text, style);
+            var needDrawBg = needDrawBackground(style);
+            var bgColorDrawn = !!(style.backgroundColor);
+            var outerHeight = contentBlock.outerHeight;
+            var textLines = contentBlock.lines;
+            var lineHeight = contentBlock.lineHeight;
+            var defaultStyle = this._defaultStyle;
+            var baseX = style.x || 0;
+            var baseY = style.y || 0;
+            var textAlign = style.align || defaultStyle.align || 'left';
+            var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign || 'top';
+            var textX = baseX;
+            var textY = adjustTextY(baseY, contentBlock.contentHeight, verticalAlign);
+            if (needDrawBg || textPadding) {
+                var outerWidth_1 = contentBlock.width;
+                textPadding && (outerWidth_1 += textPadding[1] + textPadding[3]);
+                var boxX = adjustTextX(baseX, outerWidth_1, textAlign);
+                var boxY = adjustTextY(baseY, outerHeight, verticalAlign);
+                needDrawBg && this._renderBackground(style, style, boxX, boxY, outerWidth_1, outerHeight);
+            }
+            textY += lineHeight / 2;
+            if (textPadding) {
+                textX = getTextXForPadding(baseX, textAlign, textPadding);
+                if (verticalAlign === 'top') {
+                    textY += textPadding[0];
+                }
+                else if (verticalAlign === 'bottom') {
+                    textY -= textPadding[2];
+                }
+            }
+            var defaultLineWidth = 0;
+            var useDefaultFill = false;
+            var textFill = getFill('fill' in style
+                ? style.fill
+                : (useDefaultFill = true, defaultStyle.fill));
+            var textStroke = getStroke('stroke' in style
+                ? style.stroke
+                : (!bgColorDrawn
+                    && (!defaultStyle.autoStroke || useDefaultFill))
+                    ? (defaultLineWidth = DEFAULT_STROKE_LINE_WIDTH, defaultStyle.stroke)
+                    : null);
+            var hasShadow = style.textShadowBlur > 0;
+            var fixedBoundingRect = style.width != null
+                && (style.overflow === 'truncate' || style.overflow === 'break' || style.overflow === 'breakAll');
+            var calculatedLineHeight = contentBlock.calculatedLineHeight;
+            for (var i = 0; i < textLines.length; i++) {
+                var el = this._getOrCreateChild(TSpan);
+                var subElStyle = el.createStyle();
+                el.useStyle(subElStyle);
+                subElStyle.text = textLines[i];
+                subElStyle.x = textX;
+                subElStyle.y = textY;
+                if (textAlign) {
+                    subElStyle.textAlign = textAlign;
+                }
+                subElStyle.textBaseline = 'middle';
+                subElStyle.opacity = style.opacity;
+                subElStyle.strokeFirst = true;
+                if (hasShadow) {
+                    subElStyle.shadowBlur = style.textShadowBlur || 0;
+                    subElStyle.shadowColor = style.textShadowColor || 'transparent';
+                    subElStyle.shadowOffsetX = style.textShadowOffsetX || 0;
+                    subElStyle.shadowOffsetY = style.textShadowOffsetY || 0;
+                }
+                if (textStroke) {
+                    subElStyle.stroke = textStroke;
+                    subElStyle.lineWidth = style.lineWidth || defaultLineWidth;
+                    subElStyle.lineDash = style.lineDash;
+                    subElStyle.lineDashOffset = style.lineDashOffset || 0;
+                }
+                if (textFill) {
+                    subElStyle.fill = textFill;
+                }
+                subElStyle.font = textFont;
+                textY += lineHeight;
+                if (fixedBoundingRect) {
+                    el.setBoundingRect(new BoundingRect(adjustTextX(subElStyle.x, style.width, subElStyle.textAlign), adjustTextY(subElStyle.y, calculatedLineHeight, subElStyle.textBaseline), style.width, calculatedLineHeight));
+                }
+            }
+        };
+        ZRText.prototype._updateRichTexts = function () {
+            var style = this.style;
+            var text = getStyleText(style);
+            var contentBlock = parseRichText(text, style);
+            var contentWidth = contentBlock.width;
+            var outerWidth = contentBlock.outerWidth;
+            var outerHeight = contentBlock.outerHeight;
+            var textPadding = style.padding;
+            var baseX = style.x || 0;
+            var baseY = style.y || 0;
+            var defaultStyle = this._defaultStyle;
+            var textAlign = style.align || defaultStyle.align;
+            var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign;
+            var boxX = adjustTextX(baseX, outerWidth, textAlign);
+            var boxY = adjustTextY(baseY, outerHeight, verticalAlign);
+            var xLeft = boxX;
+            var lineTop = boxY;
+            if (textPadding) {
+                xLeft += textPadding[3];
+                lineTop += textPadding[0];
+            }
+            var xRight = xLeft + contentWidth;
+            if (needDrawBackground(style)) {
+                this._renderBackground(style, style, boxX, boxY, outerWidth, outerHeight);
+            }
+            var bgColorDrawn = !!(style.backgroundColor);
+            for (var i = 0; i < contentBlock.lines.length; i++) {
+                var line = contentBlock.lines[i];
+                var tokens = line.tokens;
+                var tokenCount = tokens.length;
+                var lineHeight = line.lineHeight;
+                var remainedWidth = line.width;
+                var leftIndex = 0;
+                var lineXLeft = xLeft;
+                var lineXRight = xRight;
+                var rightIndex = tokenCount - 1;
+                var token = void 0;
+                while (leftIndex < tokenCount
+                    && (token = tokens[leftIndex], !token.align || token.align === 'left')) {
+                    this._placeToken(token, style, lineHeight, lineTop, lineXLeft, 'left', bgColorDrawn);
+                    remainedWidth -= token.width;
+                    lineXLeft += token.width;
+                    leftIndex++;
+                }
+                while (rightIndex >= 0
+                    && (token = tokens[rightIndex], token.align === 'right')) {
+                    this._placeToken(token, style, lineHeight, lineTop, lineXRight, 'right', bgColorDrawn);
+                    remainedWidth -= token.width;
+                    lineXRight -= token.width;
+                    rightIndex--;
+                }
+                lineXLeft += (contentWidth - (lineXLeft - xLeft) - (xRight - lineXRight) - remainedWidth) / 2;
+                while (leftIndex <= rightIndex) {
+                    token = tokens[leftIndex];
+                    this._placeToken(token, style, lineHeight, lineTop, lineXLeft + token.width / 2, 'center', bgColorDrawn);
+                    lineXLeft += token.width;
+                    leftIndex++;
+                }
+                lineTop += lineHeight;
+            }
+        };
+        ZRText.prototype._placeToken = function (token, style, lineHeight, lineTop, x, textAlign, parentBgColorDrawn) {
+            var tokenStyle = style.rich[token.styleName] || {};
+            tokenStyle.text = token.text;
+            var verticalAlign = token.verticalAlign;
+            var y = lineTop + lineHeight / 2;
+            if (verticalAlign === 'top') {
+                y = lineTop + token.height / 2;
+            }
+            else if (verticalAlign === 'bottom') {
+                y = lineTop + lineHeight - token.height / 2;
+            }
+            var needDrawBg = !token.isLineHolder && needDrawBackground(tokenStyle);
+            needDrawBg && this._renderBackground(tokenStyle, style, textAlign === 'right'
+                ? x - token.width
+                : textAlign === 'center'
+                    ? x - token.width / 2
+                    : x, y - token.height / 2, token.width, token.height);
+            var bgColorDrawn = !!tokenStyle.backgroundColor;
+            var textPadding = token.textPadding;
+            if (textPadding) {
+                x = getTextXForPadding(x, textAlign, textPadding);
+                y -= token.height / 2 - textPadding[0] - token.innerHeight / 2;
+            }
+            var el = this._getOrCreateChild(TSpan);
+            var subElStyle = el.createStyle();
+            el.useStyle(subElStyle);
+            var defaultStyle = this._defaultStyle;
+            var useDefaultFill = false;
+            var defaultLineWidth = 0;
+            var textFill = getStroke('fill' in tokenStyle ? tokenStyle.fill
+                : 'fill' in style ? style.fill
+                    : (useDefaultFill = true, defaultStyle.fill));
+            var textStroke = getStroke('stroke' in tokenStyle ? tokenStyle.stroke
+                : 'stroke' in style ? style.stroke
+                    : (!bgColorDrawn
+                        && !parentBgColorDrawn
+                        && (!defaultStyle.autoStroke || useDefaultFill)) ? (defaultLineWidth = DEFAULT_STROKE_LINE_WIDTH, defaultStyle.stroke)
+                        : null);
+            var hasShadow = tokenStyle.textShadowBlur > 0
+                || style.textShadowBlur > 0;
+            subElStyle.text = token.text;
+            subElStyle.x = x;
+            subElStyle.y = y;
+            if (hasShadow) {
+                subElStyle.shadowBlur = tokenStyle.textShadowBlur || style.textShadowBlur || 0;
+                subElStyle.shadowColor = tokenStyle.textShadowColor || style.textShadowColor || 'transparent';
+                subElStyle.shadowOffsetX = tokenStyle.textShadowOffsetX || style.textShadowOffsetX || 0;
+                subElStyle.shadowOffsetY = tokenStyle.textShadowOffsetY || style.textShadowOffsetY || 0;
+            }
+            subElStyle.textAlign = textAlign;
+            subElStyle.textBaseline = 'middle';
+            subElStyle.font = token.font || DEFAULT_FONT;
+            subElStyle.opacity = retrieve3(tokenStyle.opacity, style.opacity, 1);
+            if (textStroke) {
+                subElStyle.lineWidth = retrieve3(tokenStyle.lineWidth, style.lineWidth, defaultLineWidth);
+                subElStyle.lineDash = retrieve2(tokenStyle.lineDash, style.lineDash);
+                subElStyle.lineDashOffset = style.lineDashOffset || 0;
+                subElStyle.stroke = textStroke;
+            }
+            if (textFill) {
+                subElStyle.fill = textFill;
+            }
+            var textWidth = token.contentWidth;
+            var textHeight = token.contentHeight;
+            el.setBoundingRect(new BoundingRect(adjustTextX(subElStyle.x, textWidth, subElStyle.textAlign), adjustTextY(subElStyle.y, textHeight, subElStyle.textBaseline), textWidth, textHeight));
+        };
+        ZRText.prototype._renderBackground = function (style, topStyle, x, y, width, height) {
+            var textBackgroundColor = style.backgroundColor;
+            var textBorderWidth = style.borderWidth;
+            var textBorderColor = style.borderColor;
+            var isPlainBg = isString(textBackgroundColor);
+            var textBorderRadius = style.borderRadius;
+            var self = this;
+            var rectEl;
+            var imgEl;
+            if (isPlainBg || (textBorderWidth && textBorderColor)) {
+                rectEl = this._getOrCreateChild(Rect);
+                rectEl.useStyle(rectEl.createStyle());
+                rectEl.style.fill = null;
+                var rectShape = rectEl.shape;
+                rectShape.x = x;
+                rectShape.y = y;
+                rectShape.width = width;
+                rectShape.height = height;
+                rectShape.r = textBorderRadius;
+                rectEl.dirtyShape();
+            }
+            if (isPlainBg) {
+                var rectStyle = rectEl.style;
+                rectStyle.fill = textBackgroundColor || null;
+                rectStyle.fillOpacity = retrieve2(style.fillOpacity, 1);
+            }
+            else if (textBackgroundColor && textBackgroundColor.image) {
+                imgEl = this._getOrCreateChild(ZRImage);
+                imgEl.onload = function () {
+                    self.dirtyStyle();
+                };
+                var imgStyle = imgEl.style;
+                imgStyle.image = textBackgroundColor.image;
+                imgStyle.x = x;
+                imgStyle.y = y;
+                imgStyle.width = width;
+                imgStyle.height = height;
+            }
+            if (textBorderWidth && textBorderColor) {
+                var rectStyle = rectEl.style;
+                rectStyle.lineWidth = textBorderWidth;
+                rectStyle.stroke = textBorderColor;
+                rectStyle.strokeOpacity = retrieve2(style.strokeOpacity, 1);
+                rectStyle.lineDash = style.borderDash;
+                rectStyle.lineDashOffset = style.borderDashOffset || 0;
+                rectEl.strokeContainThreshold = 0;
+                if (rectEl.hasFill() && rectEl.hasStroke()) {
+                    rectStyle.strokeFirst = true;
+                    rectStyle.lineWidth *= 2;
+                }
+            }
+            var commonStyle = (rectEl || imgEl).style;
+            commonStyle.shadowBlur = style.shadowBlur || 0;
+            commonStyle.shadowColor = style.shadowColor || 'transparent';
+            commonStyle.shadowOffsetX = style.shadowOffsetX || 0;
+            commonStyle.shadowOffsetY = style.shadowOffsetY || 0;
+            commonStyle.opacity = retrieve3(style.opacity, topStyle.opacity, 1);
+        };
+        ZRText.makeFont = function (style) {
+            var font = '';
+            if (style.fontSize || style.fontFamily || style.fontWeight) {
+                var fontSize = '';
+                if (typeof style.fontSize === 'string'
+                    && (style.fontSize.indexOf('px') !== -1
+                        || style.fontSize.indexOf('rem') !== -1
+                        || style.fontSize.indexOf('em') !== -1)) {
+                    fontSize = style.fontSize;
+                }
+                else if (!isNaN(+style.fontSize)) {
+                    fontSize = style.fontSize + 'px';
+                }
+                else {
+                    fontSize = '12px';
+                }
+                font = [
+                    style.fontStyle,
+                    style.fontWeight,
+                    fontSize,
+                    style.fontFamily || 'sans-serif'
+                ].join(' ');
+            }
+            return font && trim(font) || style.textFont || style.font;
+        };
+        return ZRText;
+    }(Displayable));
+    var VALID_TEXT_ALIGN = { left: true, right: 1, center: 1 };
+    var VALID_TEXT_VERTICAL_ALIGN = { top: 1, bottom: 1, middle: 1 };
+    function normalizeTextStyle(style) {
+        normalizeStyle(style);
+        each(style.rich, normalizeStyle);
+        return style;
+    }
+    function normalizeStyle(style) {
+        if (style) {
+            style.font = ZRText.makeFont(style);
+            var textAlign = style.align;
+            textAlign === 'middle' && (textAlign = 'center');
+            style.align = (textAlign == null || VALID_TEXT_ALIGN[textAlign]) ? textAlign : 'left';
+            var verticalAlign = style.verticalAlign;
+            verticalAlign === 'center' && (verticalAlign = 'middle');
+            style.verticalAlign = (verticalAlign == null || VALID_TEXT_VERTICAL_ALIGN[verticalAlign]) ? verticalAlign : 'top';
+            var textPadding = style.padding;
+            if (textPadding) {
+                style.padding = normalizeCssArray(style.padding);
+            }
+        }
+    }
+    function getStroke(stroke, lineWidth) {
+        return (stroke == null || lineWidth <= 0 || stroke === 'transparent' || stroke === 'none')
+            ? null
+            : (stroke.image || stroke.colorStops)
+                ? '#000'
+                : stroke;
+    }
+    function getFill(fill) {
+        return (fill == null || fill === 'none')
+            ? null
+            : (fill.image || fill.colorStops)
+                ? '#000'
+                : fill;
+    }
+    function getTextXForPadding(x, textAlign, textPadding) {
+        return textAlign === 'right'
+            ? (x - textPadding[1])
+            : textAlign === 'center'
+                ? (x + textPadding[3] / 2 - textPadding[1] / 2)
+                : (x + textPadding[3]);
+    }
+    function getStyleText(style) {
+        var text = style.text;
+        text != null && (text += '');
+        return text;
+    }
+    function needDrawBackground(style) {
+        return !!(style.backgroundColor
+            || (style.borderWidth && style.borderColor));
+    }
+
+    var getECData = makeInner();
+
+    var _highlightNextDigit = 1;
+    var _highlightKeyMap = {};
+    var getSavedStates = makeInner();
+    var HOVER_STATE_NORMAL = 0;
+    var HOVER_STATE_BLUR = 1;
+    var HOVER_STATE_EMPHASIS = 2;
+    var SPECIAL_STATES = ['emphasis', 'blur', 'select'];
+    var DISPLAY_STATES = ['normal', 'emphasis', 'blur', 'select'];
+    var Z2_EMPHASIS_LIFT = 10;
+    var Z2_SELECT_LIFT = 9;
+    var HIGHLIGHT_ACTION_TYPE = 'highlight';
+    var DOWNPLAY_ACTION_TYPE = 'downplay';
+    var SELECT_ACTION_TYPE = 'select';
+    var UNSELECT_ACTION_TYPE = 'unselect';
+    var TOGGLE_SELECT_ACTION_TYPE = 'toggleSelect';
+
+    function hasFillOrStroke(fillOrStroke) {
+      return fillOrStroke != null && fillOrStroke !== 'none';
+    } // Most lifted color are duplicated.
+
+
+    var liftedColorCache = new LRU(100);
+
+    function liftColor(color$1) {
+      if (typeof color$1 !== 'string') {
+        return color$1;
+      }
+
+      var liftedColor = liftedColorCache.get(color$1);
+
+      if (!liftedColor) {
+        liftedColor = lift(color$1, -0.1);
+        liftedColorCache.put(color$1, liftedColor);
+      }
+
+      return liftedColor;
+    }
+
+    function doChangeHoverState(el, stateName, hoverStateEnum) {
+      if (el.onHoverStateChange && (el.hoverState || 0) !== hoverStateEnum) {
+        el.onHoverStateChange(stateName);
+      }
+
+      el.hoverState = hoverStateEnum;
+    }
+
+    function singleEnterEmphasis(el) {
+      // Only mark the flag.
+      // States will be applied in the echarts.ts in next frame.
+      doChangeHoverState(el, 'emphasis', HOVER_STATE_EMPHASIS);
+    }
+
+    function singleLeaveEmphasis(el) {
+      // Only mark the flag.
+      // States will be applied in the echarts.ts in next frame.
+      if (el.hoverState === HOVER_STATE_EMPHASIS) {
+        doChangeHoverState(el, 'normal', HOVER_STATE_NORMAL);
+      }
+    }
+
+    function singleEnterBlur(el) {
+      doChangeHoverState(el, 'blur', HOVER_STATE_BLUR);
+    }
+
+    function singleLeaveBlur(el) {
+      if (el.hoverState === HOVER_STATE_BLUR) {
+        doChangeHoverState(el, 'normal', HOVER_STATE_NORMAL);
+      }
+    }
+
+    function singleEnterSelect(el) {
+      el.selected = true;
+    }
+
+    function singleLeaveSelect(el) {
+      el.selected = false;
+    }
+
+    function updateElementState(el, updater, commonParam) {
+      updater(el, commonParam);
+    }
+
+    function traverseUpdateState(el, updater, commonParam) {
+      updateElementState(el, updater, commonParam);
+      el.isGroup && el.traverse(function (child) {
+        updateElementState(child, updater, commonParam);
+      });
+    }
+
+    function setStatesFlag(el, stateName) {
+      switch (stateName) {
+        case 'emphasis':
+          el.hoverState = HOVER_STATE_EMPHASIS;
+          break;
+
+        case 'normal':
+          el.hoverState = HOVER_STATE_NORMAL;
+          break;
+
+        case 'blur':
+          el.hoverState = HOVER_STATE_BLUR;
+          break;
+
+        case 'select':
+          el.selected = true;
+      }
+    }
+
+    function getFromStateStyle(el, props, toStateName, defaultValue) {
+      var style = el.style;
+      var fromState = {};
+
+      for (var i = 0; i < props.length; i++) {
+        var propName = props[i];
+        var val = style[propName];
+        fromState[propName] = val == null ? defaultValue && defaultValue[propName] : val;
+      }
+
+      for (var i = 0; i < el.animators.length; i++) {
+        var animator = el.animators[i];
+
+        if (animator.__fromStateTransition // Dont consider the animation to emphasis state.
+        && animator.__fromStateTransition.indexOf(toStateName) < 0 && animator.targetName === 'style') {
+          animator.saveFinalToTarget(fromState, props);
+        }
+      }
+
+      return fromState;
+    }
+
+    function createEmphasisDefaultState(el, stateName, targetStates, state) {
+      var hasSelect = targetStates && indexOf(targetStates, 'select') >= 0;
+      var cloned = false;
+
+      if (el instanceof Path) {
+        var store = getSavedStates(el);
+        var fromFill = hasSelect ? store.selectFill || store.normalFill : store.normalFill;
+        var fromStroke = hasSelect ? store.selectStroke || store.normalStroke : store.normalStroke;
+
+        if (hasFillOrStroke(fromFill) || hasFillOrStroke(fromStroke)) {
+          state = state || {}; // Apply default color lift
+
+          var emphasisStyle = state.style || {};
+
+          if (!hasFillOrStroke(emphasisStyle.fill) && hasFillOrStroke(fromFill)) {
+            cloned = true; // Not modify the original value.
+
+            state = extend({}, state);
+            emphasisStyle = extend({}, emphasisStyle); // Already being applied 'emphasis'. DON'T lift color multiple times.
+
+            emphasisStyle.fill = liftColor(fromFill);
+          } // Not highlight stroke if fill has been highlighted.
+          else if (!hasFillOrStroke(emphasisStyle.stroke) && hasFillOrStroke(fromStroke)) {
+              if (!cloned) {
+                state = extend({}, state);
+                emphasisStyle = extend({}, emphasisStyle);
+              }
+
+              emphasisStyle.stroke = liftColor(fromStroke);
+            }
+
+          state.style = emphasisStyle;
+        }
+      }
+
+      if (state) {
+        // TODO Share with textContent?
+        if (state.z2 == null) {
+          if (!cloned) {
+            state = extend({}, state);
+          }
+
+          var z2EmphasisLift = el.z2EmphasisLift;
+          state.z2 = el.z2 + (z2EmphasisLift != null ? z2EmphasisLift : Z2_EMPHASIS_LIFT);
+        }
+      }
+
+      return state;
+    }
+
+    function createSelectDefaultState(el, stateName, state) {
+      // const hasSelect = indexOf(el.currentStates, stateName) >= 0;
+      if (state) {
+        // TODO Share with textContent?
+        if (state.z2 == null) {
+          state = extend({}, state);
+          var z2SelectLift = el.z2SelectLift;
+          state.z2 = el.z2 + (z2SelectLift != null ? z2SelectLift : Z2_SELECT_LIFT);
+        }
+      }
+
+      return state;
+    }
+
+    function createBlurDefaultState(el, stateName, state) {
+      var hasBlur = indexOf(el.currentStates, stateName) >= 0;
+      var currentOpacity = el.style.opacity;
+      var fromState = !hasBlur ? getFromStateStyle(el, ['opacity'], stateName, {
+        opacity: 1
+      }) : null;
+      state = state || {};
+      var blurStyle = state.style || {};
+
+      if (blurStyle.opacity == null) {
+        // clone state
+        state = extend({}, state);
+        blurStyle = extend({
+          // Already being applied 'emphasis'. DON'T mul opacity multiple times.
+          opacity: hasBlur ? currentOpacity : fromState.opacity * 0.1
+        }, blurStyle);
+        state.style = blurStyle;
+      }
+
+      return state;
+    }
+
+    function elementStateProxy(stateName, targetStates) {
+      var state = this.states[stateName];
+
+      if (this.style) {
+        if (stateName === 'emphasis') {
+          return createEmphasisDefaultState(this, stateName, targetStates, state);
+        } else if (stateName === 'blur') {
+          return createBlurDefaultState(this, stateName, state);
+        } else if (stateName === 'select') {
+          return createSelectDefaultState(this, stateName, state);
+        }
+      }
+
+      return state;
+    }
+    /**FI
+     * Set hover style (namely "emphasis style") of element.
+     * @param el Should not be `zrender/graphic/Group`.
+     * @param focus 'self' | 'selfInSeries' | 'series'
+     */
+
+
+    function setDefaultStateProxy(el) {
+      el.stateProxy = elementStateProxy;
+      var textContent = el.getTextContent();
+      var textGuide = el.getTextGuideLine();
+
+      if (textContent) {
+        textContent.stateProxy = elementStateProxy;
+      }
+
+      if (textGuide) {
+        textGuide.stateProxy = elementStateProxy;
+      }
+    }
+    function enterEmphasisWhenMouseOver(el, e) {
+      !shouldSilent(el, e) // "emphasis" event highlight has higher priority than mouse highlight.
+      && !el.__highByOuter && traverseUpdateState(el, singleEnterEmphasis);
+    }
+    function leaveEmphasisWhenMouseOut(el, e) {
+      !shouldSilent(el, e) // "emphasis" event highlight has higher priority than mouse highlight.
+      && !el.__highByOuter && traverseUpdateState(el, singleLeaveEmphasis);
+    }
+    function enterEmphasis(el, highlightDigit) {
+      el.__highByOuter |= 1 << (highlightDigit || 0);
+      traverseUpdateState(el, singleEnterEmphasis);
+    }
+    function leaveEmphasis(el, highlightDigit) {
+      !(el.__highByOuter &= ~(1 << (highlightDigit || 0))) && traverseUpdateState(el, singleLeaveEmphasis);
+    }
+    function enterBlur(el) {
+      traverseUpdateState(el, singleEnterBlur);
+    }
+    function leaveBlur(el) {
+      traverseUpdateState(el, singleLeaveBlur);
+    }
+    function enterSelect(el) {
+      traverseUpdateState(el, singleEnterSelect);
+    }
+    function leaveSelect(el) {
+      traverseUpdateState(el, singleLeaveSelect);
+    }
+
+    function shouldSilent(el, e) {
+      return el.__highDownSilentOnTouch && e.zrByTouch;
+    }
+
+    function allLeaveBlur(api) {
+      var model = api.getModel();
+      model.eachComponent(function (componentType, componentModel) {
+        var view = componentType === 'series' ? api.getViewOfSeriesModel(componentModel) : api.getViewOfComponentModel(componentModel); // Leave blur anyway
+
+        view.group.traverse(function (child) {
+          singleLeaveBlur(child);
+        });
+      });
+    }
+
+    function toggleSeriesBlurState(targetSeriesIndex, focus, blurScope, api, isBlur) {
+      var ecModel = api.getModel();
+      blurScope = blurScope || 'coordinateSystem';
+
+      function leaveBlurOfIndices(data, dataIndices) {
+        for (var i = 0; i < dataIndices.length; i++) {
+          var itemEl = data.getItemGraphicEl(dataIndices[i]);
+          itemEl && leaveBlur(itemEl);
+        }
+      }
+
+      if (!isBlur) {
+        allLeaveBlur(api);
+        return;
+      }
+
+      if (targetSeriesIndex == null) {
+        return;
+      }
+
+      if (!focus || focus === 'none') {
+        return;
+      }
+
+      var targetSeriesModel = ecModel.getSeriesByIndex(targetSeriesIndex);
+      var targetCoordSys = targetSeriesModel.coordinateSystem;
+
+      if (targetCoordSys && targetCoordSys.master) {
+        targetCoordSys = targetCoordSys.master;
+      }
+
+      var blurredSeries = [];
+      ecModel.eachSeries(function (seriesModel) {
+        var sameSeries = targetSeriesModel === seriesModel;
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys && coordSys.master) {
+          coordSys = coordSys.master;
+        }
+
+        var sameCoordSys = coordSys && targetCoordSys ? coordSys === targetCoordSys : sameSeries; // If there is no coordinate system. use sameSeries instead.
+
+        if (!( // Not blur other series if blurScope series
+        blurScope === 'series' && !sameSeries // Not blur other coordinate system if blurScope is coordinateSystem
+        || blurScope === 'coordinateSystem' && !sameCoordSys // Not blur self series if focus is series.
+        || focus === 'series' && sameSeries // TODO blurScope: coordinate system
+        )) {
+          var view = api.getViewOfSeriesModel(seriesModel);
+          view.group.traverse(function (child) {
+            singleEnterBlur(child);
+          });
+
+          if (isArrayLike(focus)) {
+            leaveBlurOfIndices(seriesModel.getData(), focus);
+          } else if (isObject(focus)) {
+            var dataTypes = keys(focus);
+
+            for (var d = 0; d < dataTypes.length; d++) {
+              leaveBlurOfIndices(seriesModel.getData(dataTypes[d]), focus[dataTypes[d]]);
+            }
+          }
+
+          blurredSeries.push(seriesModel);
+        }
+      });
+      ecModel.eachComponent(function (componentType, componentModel) {
+        if (componentType === 'series') {
+          return;
+        }
+
+        var view = api.getViewOfComponentModel(componentModel);
+
+        if (view && view.blurSeries) {
+          view.blurSeries(blurredSeries, ecModel);
+        }
+      });
+    }
+    function toggleSeriesBlurStateFromPayload(seriesModel, payload, api) {
+      if (!isHighDownPayload(payload)) {
+        return;
+      }
+
+      var isHighlight = payload.type === HIGHLIGHT_ACTION_TYPE;
+      var seriesIndex = seriesModel.seriesIndex;
+      var data = seriesModel.getData(payload.dataType);
+      var dataIndex = queryDataIndex(data, payload); // Pick the first one if there is multiple/none exists.
+
+      dataIndex = (isArray(dataIndex) ? dataIndex[0] : dataIndex) || 0;
+      var el = data.getItemGraphicEl(dataIndex);
+
+      if (!el) {
+        var count = data.count();
+        var current = 0; // If data on dataIndex is NaN.
+
+        while (!el && current < count) {
+          el = data.getItemGraphicEl(current++);
+        }
+      }
+
+      if (el) {
+        var ecData = getECData(el);
+        toggleSeriesBlurState(seriesIndex, ecData.focus, ecData.blurScope, api, isHighlight);
+      } else {
+        // If there is no element put on the data. Try getting it from raw option
+        // TODO Should put it on seriesModel?
+        var focus_1 = seriesModel.get(['emphasis', 'focus']);
+        var blurScope = seriesModel.get(['emphasis', 'blurScope']);
+
+        if (focus_1 != null) {
+          toggleSeriesBlurState(seriesIndex, focus_1, blurScope, api, isHighlight);
+        }
+      }
+    }
+    function toggleSelectionFromPayload(seriesModel, payload, api) {
+      if (!isSelectChangePayload(payload)) {
+        return;
+      }
+
+      var dataType = payload.dataType;
+      var data = seriesModel.getData(dataType);
+      var dataIndex = queryDataIndex(data, payload);
+
+      if (!isArray(dataIndex)) {
+        dataIndex = [dataIndex];
+      }
+
+      seriesModel[payload.type === TOGGLE_SELECT_ACTION_TYPE ? 'toggleSelect' : payload.type === SELECT_ACTION_TYPE ? 'select' : 'unselect'](dataIndex, dataType);
+    }
+    function updateSeriesElementSelection(seriesModel) {
+      var allData = seriesModel.getAllData();
+      each(allData, function (_a) {
+        var data = _a.data,
+            type = _a.type;
+        data.eachItemGraphicEl(function (el, idx) {
+          seriesModel.isSelected(idx, type) ? enterSelect(el) : leaveSelect(el);
+        });
+      });
+    }
+    function getAllSelectedIndices(ecModel) {
+      var ret = [];
+      ecModel.eachSeries(function (seriesModel) {
+        var allData = seriesModel.getAllData();
+        each(allData, function (_a) {
+          var data = _a.data,
+              type = _a.type;
+          var dataIndices = seriesModel.getSelectedDataIndices();
+
+          if (dataIndices.length > 0) {
+            var item = {
+              dataIndex: dataIndices,
+              seriesIndex: seriesModel.seriesIndex
+            };
+
+            if (type != null) {
+              item.dataType = type;
+            }
+
+            ret.push(item);
+          }
+        });
+      });
+      return ret;
+    }
+    /**
+     * Enable the function that mouseover will trigger the emphasis state.
+     *
+     * NOTE:
+     * This function should be used on the element with dataIndex, seriesIndex.
+     *
+     */
+
+    function enableHoverEmphasis(el, focus, blurScope) {
+      setAsHighDownDispatcher(el, true);
+      traverseUpdateState(el, setDefaultStateProxy);
+      enableHoverFocus(el, focus, blurScope);
+    }
+    function enableHoverFocus(el, focus, blurScope) {
+      var ecData = getECData(el);
+
+      if (focus != null) {
+        // TODO dataIndex may be set after this function. This check is not useful.
+        // if (ecData.dataIndex == null) {
+        //     if (__DEV__) {
+        //         console.warn('focus can only been set on element with dataIndex');
+        //     }
+        // }
+        // else {
+        ecData.focus = focus;
+        ecData.blurScope = blurScope; // }
+      } else if (ecData.focus) {
+        ecData.focus = null;
+      }
+    }
+    var OTHER_STATES = ['emphasis', 'blur', 'select'];
+    var defaultStyleGetterMap = {
+      itemStyle: 'getItemStyle',
+      lineStyle: 'getLineStyle',
+      areaStyle: 'getAreaStyle'
+    };
+    /**
+     * Set emphasis/blur/selected states of element.
+     */
+
+    function setStatesStylesFromModel(el, itemModel, styleType, // default itemStyle
+    getter) {
+      styleType = styleType || 'itemStyle';
+
+      for (var i = 0; i < OTHER_STATES.length; i++) {
+        var stateName = OTHER_STATES[i];
+        var model = itemModel.getModel([stateName, styleType]);
+        var state = el.ensureState(stateName); // Let it throw error if getterType is not found.
+
+        state.style = getter ? getter(model) : model[defaultStyleGetterMap[styleType]]();
+      }
+    }
+    /**
+     * @parame el
+     * @param el.highDownSilentOnTouch
+     *        In touch device, mouseover event will be trigger on touchstart event
+     *        (see module:zrender/dom/HandlerProxy). By this mechanism, we can
+     *        conveniently use hoverStyle when tap on touch screen without additional
+     *        code for compatibility.
+     *        But if the chart/component has select feature, which usually also use
+     *        hoverStyle, there might be conflict between 'select-highlight' and
+     *        'hover-highlight' especially when roam is enabled (see geo for example).
+     *        In this case, `highDownSilentOnTouch` should be used to disable
+     *        hover-highlight on touch device.
+     * @param asDispatcher If `false`, do not set as "highDownDispatcher".
+     */
+
+    function setAsHighDownDispatcher(el, asDispatcher) {
+      var disable = asDispatcher === false;
+      var extendedEl = el; // Make `highDownSilentOnTouch` and `onStateChange` only work after
+      // `setAsHighDownDispatcher` called. Avoid it is modified by user unexpectedly.
+
+      if (el.highDownSilentOnTouch) {
+        extendedEl.__highDownSilentOnTouch = el.highDownSilentOnTouch;
+      } // Simple optimize, since this method might be
+      // called for each elements of a group in some cases.
+
+
+      if (!disable || extendedEl.__highDownDispatcher) {
+        // Emphasis, normal can be triggered manually by API or other components like hover link.
+        // el[method]('emphasis', onElementEmphasisEvent)[method]('normal', onElementNormalEvent);
+        // Also keep previous record.
+        extendedEl.__highByOuter = extendedEl.__highByOuter || 0;
+        extendedEl.__highDownDispatcher = !disable;
+      }
+    }
+    function isHighDownDispatcher(el) {
+      return !!(el && el.__highDownDispatcher);
+    }
+    /**
+     * Support hightlight/downplay record on each elements.
+     * For the case: hover highlight/downplay (legend, visualMap, ...) and
+     * user triggerred hightlight/downplay should not conflict.
+     * Only all of the highlightDigit cleared, return to normal.
+     * @param {string} highlightKey
+     * @return {number} highlightDigit
+     */
+
+    function getHighlightDigit(highlightKey) {
+      var highlightDigit = _highlightKeyMap[highlightKey];
+
+      if (highlightDigit == null && _highlightNextDigit <= 32) {
+        highlightDigit = _highlightKeyMap[highlightKey] = _highlightNextDigit++;
+      }
+
+      return highlightDigit;
+    }
+    function isSelectChangePayload(payload) {
+      var payloadType = payload.type;
+      return payloadType === SELECT_ACTION_TYPE || payloadType === UNSELECT_ACTION_TYPE || payloadType === TOGGLE_SELECT_ACTION_TYPE;
+    }
+    function isHighDownPayload(payload) {
+      var payloadType = payload.type;
+      return payloadType === HIGHLIGHT_ACTION_TYPE || payloadType === DOWNPLAY_ACTION_TYPE;
+    }
+    function savePathStates(el) {
+      var store = getSavedStates(el);
+      store.normalFill = el.style.fill;
+      store.normalStroke = el.style.stroke;
+      var selectState = el.states.select || {};
+      store.selectFill = selectState.style && selectState.style.fill || null;
+      store.selectStroke = selectState.style && selectState.style.stroke || null;
+    }
+
+    var CMD$2 = PathProxy.CMD;
+    var points = [[], [], []];
+    var mathSqrt$2 = Math.sqrt;
+    var mathAtan2 = Math.atan2;
+    function transformPath(path, m) {
+        var data = path.data;
+        var len = path.len();
+        var cmd;
+        var nPoint;
+        var i;
+        var j;
+        var k;
+        var p;
+        var M = CMD$2.M;
+        var C = CMD$2.C;
+        var L = CMD$2.L;
+        var R = CMD$2.R;
+        var A = CMD$2.A;
+        var Q = CMD$2.Q;
+        for (i = 0, j = 0; i < len;) {
+            cmd = data[i++];
+            j = i;
+            nPoint = 0;
+            switch (cmd) {
+                case M:
+                    nPoint = 1;
+                    break;
+                case L:
+                    nPoint = 1;
+                    break;
+                case C:
+                    nPoint = 3;
+                    break;
+                case Q:
+                    nPoint = 2;
+                    break;
+                case A:
+                    var x = m[4];
+                    var y = m[5];
+                    var sx = mathSqrt$2(m[0] * m[0] + m[1] * m[1]);
+                    var sy = mathSqrt$2(m[2] * m[2] + m[3] * m[3]);
+                    var angle = mathAtan2(-m[1] / sy, m[0] / sx);
+                    data[i] *= sx;
+                    data[i++] += x;
+                    data[i] *= sy;
+                    data[i++] += y;
+                    data[i++] *= sx;
+                    data[i++] *= sy;
+                    data[i++] += angle;
+                    data[i++] += angle;
+                    i += 2;
+                    j = i;
+                    break;
+                case R:
+                    p[0] = data[i++];
+                    p[1] = data[i++];
+                    applyTransform(p, p, m);
+                    data[j++] = p[0];
+                    data[j++] = p[1];
+                    p[0] += data[i++];
+                    p[1] += data[i++];
+                    applyTransform(p, p, m);
+                    data[j++] = p[0];
+                    data[j++] = p[1];
+            }
+            for (k = 0; k < nPoint; k++) {
+                var p_1 = points[k];
+                p_1[0] = data[i++];
+                p_1[1] = data[i++];
+                applyTransform(p_1, p_1, m);
+                data[j++] = p_1[0];
+                data[j++] = p_1[1];
+            }
+        }
+        path.increaseVersion();
+    }
+
+    var mathSqrt$3 = Math.sqrt;
+    var mathSin$2 = Math.sin;
+    var mathCos$2 = Math.cos;
+    var PI$1 = Math.PI;
+    function vMag(v) {
+        return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+    }
+    function vRatio(u, v) {
+        return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));
+    }
+    function vAngle(u, v) {
+        return (u[0] * v[1] < u[1] * v[0] ? -1 : 1)
+            * Math.acos(vRatio(u, v));
+    }
+    function processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) {
+        var psi = psiDeg * (PI$1 / 180.0);
+        var xp = mathCos$2(psi) * (x1 - x2) / 2.0
+            + mathSin$2(psi) * (y1 - y2) / 2.0;
+        var yp = -1 * mathSin$2(psi) * (x1 - x2) / 2.0
+            + mathCos$2(psi) * (y1 - y2) / 2.0;
+        var lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+        if (lambda > 1) {
+            rx *= mathSqrt$3(lambda);
+            ry *= mathSqrt$3(lambda);
+        }
+        var f = (fa === fs ? -1 : 1)
+            * mathSqrt$3((((rx * rx) * (ry * ry))
+                - ((rx * rx) * (yp * yp))
+                - ((ry * ry) * (xp * xp))) / ((rx * rx) * (yp * yp)
+                + (ry * ry) * (xp * xp))) || 0;
+        var cxp = f * rx * yp / ry;
+        var cyp = f * -ry * xp / rx;
+        var cx = (x1 + x2) / 2.0
+            + mathCos$2(psi) * cxp
+            - mathSin$2(psi) * cyp;
+        var cy = (y1 + y2) / 2.0
+            + mathSin$2(psi) * cxp
+            + mathCos$2(psi) * cyp;
+        var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);
+        var u = [(xp - cxp) / rx, (yp - cyp) / ry];
+        var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];
+        var dTheta = vAngle(u, v);
+        if (vRatio(u, v) <= -1) {
+            dTheta = PI$1;
+        }
+        if (vRatio(u, v) >= 1) {
+            dTheta = 0;
+        }
+        if (dTheta < 0) {
+            var n = Math.round(dTheta / PI$1 * 1e6) / 1e6;
+            dTheta = PI$1 * 2 + (n % 2) * PI$1;
+        }
+        path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs);
+    }
+    var commandReg = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/ig;
+    var numberReg = /-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g;
+    function createPathProxyFromString(data) {
+        var path = new PathProxy();
+        if (!data) {
+            return path;
+        }
+        var cpx = 0;
+        var cpy = 0;
+        var subpathX = cpx;
+        var subpathY = cpy;
+        var prevCmd;
+        var CMD = PathProxy.CMD;
+        var cmdList = data.match(commandReg);
+        if (!cmdList) {
+            return path;
+        }
+        for (var l = 0; l < cmdList.length; l++) {
+            var cmdText = cmdList[l];
+            var cmdStr = cmdText.charAt(0);
+            var cmd = void 0;
+            var p = cmdText.match(numberReg) || [];
+            var pLen = p.length;
+            for (var i = 0; i < pLen; i++) {
+                p[i] = parseFloat(p[i]);
+            }
+            var off = 0;
+            while (off < pLen) {
+                var ctlPtx = void 0;
+                var ctlPty = void 0;
+                var rx = void 0;
+                var ry = void 0;
+                var psi = void 0;
+                var fa = void 0;
+                var fs = void 0;
+                var x1 = cpx;
+                var y1 = cpy;
+                var len = void 0;
+                var pathData = void 0;
+                switch (cmdStr) {
+                    case 'l':
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'L':
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'm':
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        cmd = CMD.M;
+                        path.addData(cmd, cpx, cpy);
+                        subpathX = cpx;
+                        subpathY = cpy;
+                        cmdStr = 'l';
+                        break;
+                    case 'M':
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        cmd = CMD.M;
+                        path.addData(cmd, cpx, cpy);
+                        subpathX = cpx;
+                        subpathY = cpy;
+                        cmdStr = 'L';
+                        break;
+                    case 'h':
+                        cpx += p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'H':
+                        cpx = p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'v':
+                        cpy += p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'V':
+                        cpy = p[off++];
+                        cmd = CMD.L;
+                        path.addData(cmd, cpx, cpy);
+                        break;
+                    case 'C':
+                        cmd = CMD.C;
+                        path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]);
+                        cpx = p[off - 2];
+                        cpy = p[off - 1];
+                        break;
+                    case 'c':
+                        cmd = CMD.C;
+                        path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy);
+                        cpx += p[off - 2];
+                        cpy += p[off - 1];
+                        break;
+                    case 'S':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        len = path.len();
+                        pathData = path.data;
+                        if (prevCmd === CMD.C) {
+                            ctlPtx += cpx - pathData[len - 4];
+                            ctlPty += cpy - pathData[len - 3];
+                        }
+                        cmd = CMD.C;
+                        x1 = p[off++];
+                        y1 = p[off++];
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);
+                        break;
+                    case 's':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        len = path.len();
+                        pathData = path.data;
+                        if (prevCmd === CMD.C) {
+                            ctlPtx += cpx - pathData[len - 4];
+                            ctlPty += cpy - pathData[len - 3];
+                        }
+                        cmd = CMD.C;
+                        x1 = cpx + p[off++];
+                        y1 = cpy + p[off++];
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);
+                        break;
+                    case 'Q':
+                        x1 = p[off++];
+                        y1 = p[off++];
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        cmd = CMD.Q;
+                        path.addData(cmd, x1, y1, cpx, cpy);
+                        break;
+                    case 'q':
+                        x1 = p[off++] + cpx;
+                        y1 = p[off++] + cpy;
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        cmd = CMD.Q;
+                        path.addData(cmd, x1, y1, cpx, cpy);
+                        break;
+                    case 'T':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        len = path.len();
+                        pathData = path.data;
+                        if (prevCmd === CMD.Q) {
+                            ctlPtx += cpx - pathData[len - 4];
+                            ctlPty += cpy - pathData[len - 3];
+                        }
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        cmd = CMD.Q;
+                        path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);
+                        break;
+                    case 't':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        len = path.len();
+                        pathData = path.data;
+                        if (prevCmd === CMD.Q) {
+                            ctlPtx += cpx - pathData[len - 4];
+                            ctlPty += cpy - pathData[len - 3];
+                        }
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        cmd = CMD.Q;
+                        path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);
+                        break;
+                    case 'A':
+                        rx = p[off++];
+                        ry = p[off++];
+                        psi = p[off++];
+                        fa = p[off++];
+                        fs = p[off++];
+                        x1 = cpx, y1 = cpy;
+                        cpx = p[off++];
+                        cpy = p[off++];
+                        cmd = CMD.A;
+                        processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);
+                        break;
+                    case 'a':
+                        rx = p[off++];
+                        ry = p[off++];
+                        psi = p[off++];
+                        fa = p[off++];
+                        fs = p[off++];
+                        x1 = cpx, y1 = cpy;
+                        cpx += p[off++];
+                        cpy += p[off++];
+                        cmd = CMD.A;
+                        processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);
+                        break;
+                }
+            }
+            if (cmdStr === 'z' || cmdStr === 'Z') {
+                cmd = CMD.Z;
+                path.addData(cmd);
+                cpx = subpathX;
+                cpy = subpathY;
+            }
+            prevCmd = cmd;
+        }
+        path.toStatic();
+        return path;
+    }
+    var SVGPath = (function (_super) {
+        __extends(SVGPath, _super);
+        function SVGPath() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SVGPath.prototype.applyTransform = function (m) { };
+        return SVGPath;
+    }(Path));
+    function isPathProxy(path) {
+        return path.setData != null;
+    }
+    function createPathOptions(str, opts) {
+        var pathProxy = createPathProxyFromString(str);
+        var innerOpts = extend({}, opts);
+        innerOpts.buildPath = function (path) {
+            if (isPathProxy(path)) {
+                path.setData(pathProxy.data);
+                var ctx = path.getContext();
+                if (ctx) {
+                    path.rebuildPath(ctx, 1);
+                }
+            }
+            else {
+                var ctx = path;
+                pathProxy.rebuildPath(ctx, 1);
+            }
+        };
+        innerOpts.applyTransform = function (m) {
+            transformPath(pathProxy, m);
+            this.dirtyShape();
+        };
+        return innerOpts;
+    }
+    function createFromString(str, opts) {
+        return new SVGPath(createPathOptions(str, opts));
+    }
+    function extendFromString(str, defaultOpts) {
+        var innerOpts = createPathOptions(str, defaultOpts);
+        var Sub = (function (_super) {
+            __extends(Sub, _super);
+            function Sub(opts) {
+                var _this = _super.call(this, opts) || this;
+                _this.applyTransform = innerOpts.applyTransform;
+                _this.buildPath = innerOpts.buildPath;
+                return _this;
+            }
+            return Sub;
+        }(SVGPath));
+        return Sub;
+    }
+    function mergePath(pathEls, opts) {
+        var pathList = [];
+        var len = pathEls.length;
+        for (var i = 0; i < len; i++) {
+            var pathEl = pathEls[i];
+            if (!pathEl.path) {
+                pathEl.createPathProxy();
+            }
+            if (pathEl.shapeChanged()) {
+                pathEl.buildPath(pathEl.path, pathEl.shape, true);
+            }
+            pathList.push(pathEl.path);
+        }
+        var pathBundle = new Path(opts);
+        pathBundle.createPathProxy();
+        pathBundle.buildPath = function (path) {
+            if (isPathProxy(path)) {
+                path.appendPath(pathList);
+                var ctx = path.getContext();
+                if (ctx) {
+                    path.rebuildPath(ctx, 1);
+                }
+            }
+        };
+        return pathBundle;
+    }
+
+    var CircleShape = (function () {
+        function CircleShape() {
+            this.cx = 0;
+            this.cy = 0;
+            this.r = 0;
+        }
+        return CircleShape;
+    }());
+    var Circle = (function (_super) {
+        __extends(Circle, _super);
+        function Circle(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Circle.prototype.getDefaultShape = function () {
+            return new CircleShape();
+        };
+        Circle.prototype.buildPath = function (ctx, shape, inBundle) {
+            if (inBundle) {
+                ctx.moveTo(shape.cx + shape.r, shape.cy);
+            }
+            ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
+        };
+        return Circle;
+    }(Path));
+    Circle.prototype.type = 'circle';
+
+    var EllipseShape = (function () {
+        function EllipseShape() {
+            this.cx = 0;
+            this.cy = 0;
+            this.rx = 0;
+            this.ry = 0;
+        }
+        return EllipseShape;
+    }());
+    var Ellipse = (function (_super) {
+        __extends(Ellipse, _super);
+        function Ellipse(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Ellipse.prototype.getDefaultShape = function () {
+            return new EllipseShape();
+        };
+        Ellipse.prototype.buildPath = function (ctx, shape) {
+            var k = 0.5522848;
+            var x = shape.cx;
+            var y = shape.cy;
+            var a = shape.rx;
+            var b = shape.ry;
+            var ox = a * k;
+            var oy = b * k;
+            ctx.moveTo(x - a, y);
+            ctx.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b);
+            ctx.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y);
+            ctx.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b);
+            ctx.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y);
+            ctx.closePath();
+        };
+        return Ellipse;
+    }(Path));
+    Ellipse.prototype.type = 'ellipse';
+
+    var PI$2 = Math.PI;
+    var PI2$5 = PI$2 * 2;
+    var mathSin$3 = Math.sin;
+    var mathCos$3 = Math.cos;
+    var mathACos = Math.acos;
+    var mathATan2 = Math.atan2;
+    var mathAbs$1 = Math.abs;
+    var mathSqrt$4 = Math.sqrt;
+    var mathMax$3 = Math.max;
+    var mathMin$3 = Math.min;
+    var e = 1e-4;
+    function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+        var x10 = x1 - x0;
+        var y10 = y1 - y0;
+        var x32 = x3 - x2;
+        var y32 = y3 - y2;
+        var t = y32 * x10 - x32 * y10;
+        if (t * t < e) {
+            return;
+        }
+        t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
+        return [x0 + t * x10, y0 + t * y10];
+    }
+    function computeCornerTangents(x0, y0, x1, y1, radius, cr, clockwise) {
+        var x01 = x0 - x1;
+        var y01 = y0 - y1;
+        var lo = (clockwise ? cr : -cr) / mathSqrt$4(x01 * x01 + y01 * y01);
+        var ox = lo * y01;
+        var oy = -lo * x01;
+        var x11 = x0 + ox;
+        var y11 = y0 + oy;
+        var x10 = x1 + ox;
+        var y10 = y1 + oy;
+        var x00 = (x11 + x10) / 2;
+        var y00 = (y11 + y10) / 2;
+        var dx = x10 - x11;
+        var dy = y10 - y11;
+        var d2 = dx * dx + dy * dy;
+        var r = radius - cr;
+        var s = x11 * y10 - x10 * y11;
+        var d = (dy < 0 ? -1 : 1) * mathSqrt$4(mathMax$3(0, r * r * d2 - s * s));
+        var cx0 = (s * dy - dx * d) / d2;
+        var cy0 = (-s * dx - dy * d) / d2;
+        var cx1 = (s * dy + dx * d) / d2;
+        var cy1 = (-s * dx + dy * d) / d2;
+        var dx0 = cx0 - x00;
+        var dy0 = cy0 - y00;
+        var dx1 = cx1 - x00;
+        var dy1 = cy1 - y00;
+        if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
+            cx0 = cx1;
+            cy0 = cy1;
+        }
+        return {
+            cx: cx0,
+            cy: cy0,
+            x01: -ox,
+            y01: -oy,
+            x11: cx0 * (radius / r - 1),
+            y11: cy0 * (radius / r - 1)
+        };
+    }
+    function buildPath$1(ctx, shape) {
+        var radius = mathMax$3(shape.r, 0);
+        var innerRadius = mathMax$3(shape.r0 || 0, 0);
+        var hasRadius = radius > 0;
+        var hasInnerRadius = innerRadius > 0;
+        if (!hasRadius && !hasInnerRadius) {
+            return;
+        }
+        if (!hasRadius) {
+            radius = innerRadius;
+            innerRadius = 0;
+        }
+        if (innerRadius > radius) {
+            var tmp = radius;
+            radius = innerRadius;
+            innerRadius = tmp;
+        }
+        var clockwise = !!shape.clockwise;
+        var startAngle = shape.startAngle;
+        var endAngle = shape.endAngle;
+        var arc;
+        if (startAngle === endAngle) {
+            arc = 0;
+        }
+        else {
+            var tmpAngles = [startAngle, endAngle];
+            normalizeArcAngles(tmpAngles, !clockwise);
+            arc = mathAbs$1(tmpAngles[0] - tmpAngles[1]);
+        }
+        var x = shape.cx;
+        var y = shape.cy;
+        var cornerRadius = shape.cornerRadius || 0;
+        var innerCornerRadius = shape.innerCornerRadius || 0;
+        if (!(radius > e)) {
+            ctx.moveTo(x, y);
+        }
+        else if (arc > PI2$5 - e) {
+            ctx.moveTo(x + radius * mathCos$3(startAngle), y + radius * mathSin$3(startAngle));
+            ctx.arc(x, y, radius, startAngle, endAngle, !clockwise);
+            if (innerRadius > e) {
+                ctx.moveTo(x + innerRadius * mathCos$3(endAngle), y + innerRadius * mathSin$3(endAngle));
+                ctx.arc(x, y, innerRadius, endAngle, startAngle, clockwise);
+            }
+        }
+        else {
+            var halfRd = mathAbs$1(radius - innerRadius) / 2;
+            var cr = mathMin$3(halfRd, cornerRadius);
+            var icr = mathMin$3(halfRd, innerCornerRadius);
+            var cr0 = icr;
+            var cr1 = cr;
+            var xrs = radius * mathCos$3(startAngle);
+            var yrs = radius * mathSin$3(startAngle);
+            var xire = innerRadius * mathCos$3(endAngle);
+            var yire = innerRadius * mathSin$3(endAngle);
+            var xre = void 0;
+            var yre = void 0;
+            var xirs = void 0;
+            var yirs = void 0;
+            if (cr > e || icr > e) {
+                xre = radius * mathCos$3(endAngle);
+                yre = radius * mathSin$3(endAngle);
+                xirs = innerRadius * mathCos$3(startAngle);
+                yirs = innerRadius * mathSin$3(startAngle);
+                if (arc < PI$2) {
+                    var it_1 = intersect(xrs, yrs, xirs, yirs, xre, yre, xire, yire);
+                    if (it_1) {
+                        var x0 = xrs - it_1[0];
+                        var y0 = yrs - it_1[1];
+                        var x1 = xre - it_1[0];
+                        var y1 = yre - it_1[1];
+                        var a = 1 / mathSin$3(mathACos((x0 * x1 + y0 * y1) / (mathSqrt$4(x0 * x0 + y0 * y0) * mathSqrt$4(x1 * x1 + y1 * y1))) / 2);
+                        var b = mathSqrt$4(it_1[0] * it_1[0] + it_1[1] * it_1[1]);
+                        cr0 = mathMin$3(icr, (innerRadius - b) / (a - 1));
+                        cr1 = mathMin$3(cr, (radius - b) / (a + 1));
+                    }
+                }
+            }
+            if (!(arc > e)) {
+                ctx.moveTo(x + xrs, y + yrs);
+            }
+            else if (cr1 > e) {
+                var ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, radius, cr1, clockwise);
+                var ct1 = computeCornerTangents(xre, yre, xire, yire, radius, cr1, clockwise);
+                ctx.moveTo(x + ct0.cx + ct0.x01, y + ct0.cy + ct0.y01);
+                if (cr1 < cr) {
+                    ctx.arc(x + ct0.cx, y + ct0.cy, cr1, mathATan2(ct0.y01, ct0.x01), mathATan2(ct1.y01, ct1.x01), !clockwise);
+                }
+                else {
+                    ctx.arc(x + ct0.cx, y + ct0.cy, cr1, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
+                    ctx.arc(x, y, radius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), !clockwise);
+                    ctx.arc(x + ct1.cx, y + ct1.cy, cr1, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
+                }
+            }
+            else {
+                ctx.moveTo(x + xrs, y + yrs);
+                ctx.arc(x, y, radius, startAngle, endAngle, !clockwise);
+            }
+            if (!(innerRadius > e) || !(arc > e)) {
+                ctx.lineTo(x + xire, y + yire);
+            }
+            else if (cr0 > e) {
+                var ct0 = computeCornerTangents(xire, yire, xre, yre, innerRadius, -cr0, clockwise);
+                var ct1 = computeCornerTangents(xrs, yrs, xirs, yirs, innerRadius, -cr0, clockwise);
+                ctx.lineTo(x + ct0.cx + ct0.x01, y + ct0.cy + ct0.y01);
+                if (cr0 < icr) {
+                    ctx.arc(x + ct0.cx, y + ct0.cy, cr0, mathATan2(ct0.y01, ct0.x01), mathATan2(ct1.y01, ct1.x01), !clockwise);
+                }
+                else {
+                    ctx.arc(x + ct0.cx, y + ct0.cy, cr0, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
+                    ctx.arc(x, y, innerRadius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), clockwise);
+                    ctx.arc(x + ct1.cx, y + ct1.cy, cr0, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
+                }
+            }
+            else {
+                ctx.lineTo(x + xire, y + yire);
+                ctx.arc(x, y, innerRadius, endAngle, startAngle, clockwise);
+            }
+        }
+        ctx.closePath();
+    }
+
+    var SectorShape = (function () {
+        function SectorShape() {
+            this.cx = 0;
+            this.cy = 0;
+            this.r0 = 0;
+            this.r = 0;
+            this.startAngle = 0;
+            this.endAngle = Math.PI * 2;
+            this.clockwise = true;
+            this.cornerRadius = 0;
+            this.innerCornerRadius = 0;
+        }
+        return SectorShape;
+    }());
+    var Sector = (function (_super) {
+        __extends(Sector, _super);
+        function Sector(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Sector.prototype.getDefaultShape = function () {
+            return new SectorShape();
+        };
+        Sector.prototype.buildPath = function (ctx, shape) {
+            buildPath$1(ctx, shape);
+        };
+        Sector.prototype.isZeroArea = function () {
+            return this.shape.startAngle === this.shape.endAngle
+                || this.shape.r === this.shape.r0;
+        };
+        return Sector;
+    }(Path));
+    Sector.prototype.type = 'sector';
+
+    var RingShape = (function () {
+        function RingShape() {
+            this.cx = 0;
+            this.cy = 0;
+            this.r = 0;
+            this.r0 = 0;
+        }
+        return RingShape;
+    }());
+    var Ring = (function (_super) {
+        __extends(Ring, _super);
+        function Ring(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Ring.prototype.getDefaultShape = function () {
+            return new RingShape();
+        };
+        Ring.prototype.buildPath = function (ctx, shape) {
+            var x = shape.cx;
+            var y = shape.cy;
+            var PI2 = Math.PI * 2;
+            ctx.moveTo(x + shape.r, y);
+            ctx.arc(x, y, shape.r, 0, PI2, false);
+            ctx.moveTo(x + shape.r0, y);
+            ctx.arc(x, y, shape.r0, 0, PI2, true);
+        };
+        return Ring;
+    }(Path));
+    Ring.prototype.type = 'ring';
+
+    function interpolate(p0, p1, p2, p3, t, t2, t3) {
+        var v0 = (p2 - p0) * 0.5;
+        var v1 = (p3 - p1) * 0.5;
+        return (2 * (p1 - p2) + v0 + v1) * t3
+            + (-3 * (p1 - p2) - 2 * v0 - v1) * t2
+            + v0 * t + p1;
+    }
+    function smoothSpline(points, isLoop) {
+        var len = points.length;
+        var ret = [];
+        var distance$1 = 0;
+        for (var i = 1; i < len; i++) {
+            distance$1 += distance(points[i - 1], points[i]);
+        }
+        var segs = distance$1 / 2;
+        segs = segs < len ? len : segs;
+        for (var i = 0; i < segs; i++) {
+            var pos = i / (segs - 1) * (isLoop ? len : len - 1);
+            var idx = Math.floor(pos);
+            var w = pos - idx;
+            var p0 = void 0;
+            var p1 = points[idx % len];
+            var p2 = void 0;
+            var p3 = void 0;
+            if (!isLoop) {
+                p0 = points[idx === 0 ? idx : idx - 1];
+                p2 = points[idx > len - 2 ? len - 1 : idx + 1];
+                p3 = points[idx > len - 3 ? len - 1 : idx + 2];
+            }
+            else {
+                p0 = points[(idx - 1 + len) % len];
+                p2 = points[(idx + 1) % len];
+                p3 = points[(idx + 2) % len];
+            }
+            var w2 = w * w;
+            var w3 = w * w2;
+            ret.push([
+                interpolate(p0[0], p1[0], p2[0], p3[0], w, w2, w3),
+                interpolate(p0[1], p1[1], p2[1], p3[1], w, w2, w3)
+            ]);
+        }
+        return ret;
+    }
+
+    function smoothBezier(points, smooth, isLoop, constraint) {
+        var cps = [];
+        var v = [];
+        var v1 = [];
+        var v2 = [];
+        var prevPoint;
+        var nextPoint;
+        var min$1;
+        var max$1;
+        if (constraint) {
+            min$1 = [Infinity, Infinity];
+            max$1 = [-Infinity, -Infinity];
+            for (var i = 0, len = points.length; i < len; i++) {
+                min(min$1, min$1, points[i]);
+                max(max$1, max$1, points[i]);
+            }
+            min(min$1, min$1, constraint[0]);
+            max(max$1, max$1, constraint[1]);
+        }
+        for (var i = 0, len = points.length; i < len; i++) {
+            var point = points[i];
+            if (isLoop) {
+                prevPoint = points[i ? i - 1 : len - 1];
+                nextPoint = points[(i + 1) % len];
+            }
+            else {
+                if (i === 0 || i === len - 1) {
+                    cps.push(clone$1(points[i]));
+                    continue;
+                }
+                else {
+                    prevPoint = points[i - 1];
+                    nextPoint = points[i + 1];
+                }
+            }
+            sub(v, nextPoint, prevPoint);
+            scale(v, v, smooth);
+            var d0 = distance(point, prevPoint);
+            var d1 = distance(point, nextPoint);
+            var sum = d0 + d1;
+            if (sum !== 0) {
+                d0 /= sum;
+                d1 /= sum;
+            }
+            scale(v1, v, -d0);
+            scale(v2, v, d1);
+            var cp0 = add([], point, v1);
+            var cp1 = add([], point, v2);
+            if (constraint) {
+                max(cp0, cp0, min$1);
+                min(cp0, cp0, max$1);
+                max(cp1, cp1, min$1);
+                min(cp1, cp1, max$1);
+            }
+            cps.push(cp0);
+            cps.push(cp1);
+        }
+        if (isLoop) {
+            cps.push(cps.shift());
+        }
+        return cps;
+    }
+
+    function buildPath$2(ctx, shape, closePath) {
+        var smooth = shape.smooth;
+        var points = shape.points;
+        if (points && points.length >= 2) {
+            if (smooth && smooth !== 'spline') {
+                var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint);
+                ctx.moveTo(points[0][0], points[0][1]);
+                var len = points.length;
+                for (var i = 0; i < (closePath ? len : len - 1); i++) {
+                    var cp1 = controlPoints[i * 2];
+                    var cp2 = controlPoints[i * 2 + 1];
+                    var p = points[(i + 1) % len];
+                    ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);
+                }
+            }
+            else {
+                if (smooth === 'spline') {
+                    points = smoothSpline(points, closePath);
+                }
+                ctx.moveTo(points[0][0], points[0][1]);
+                for (var i = 1, l = points.length; i < l; i++) {
+                    ctx.lineTo(points[i][0], points[i][1]);
+                }
+            }
+            closePath && ctx.closePath();
+        }
+    }
+
+    var PolygonShape = (function () {
+        function PolygonShape() {
+            this.points = null;
+            this.smooth = 0;
+            this.smoothConstraint = null;
+        }
+        return PolygonShape;
+    }());
+    var Polygon = (function (_super) {
+        __extends(Polygon, _super);
+        function Polygon(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Polygon.prototype.getDefaultShape = function () {
+            return new PolygonShape();
+        };
+        Polygon.prototype.buildPath = function (ctx, shape) {
+            buildPath$2(ctx, shape, true);
+        };
+        return Polygon;
+    }(Path));
+    Polygon.prototype.type = 'polygon';
+
+    var PolylineShape = (function () {
+        function PolylineShape() {
+            this.points = null;
+            this.percent = 1;
+            this.smooth = 0;
+            this.smoothConstraint = null;
+        }
+        return PolylineShape;
+    }());
+    var Polyline = (function (_super) {
+        __extends(Polyline, _super);
+        function Polyline(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Polyline.prototype.getDefaultStyle = function () {
+            return {
+                stroke: '#000',
+                fill: null
+            };
+        };
+        Polyline.prototype.getDefaultShape = function () {
+            return new PolylineShape();
+        };
+        Polyline.prototype.buildPath = function (ctx, shape) {
+            buildPath$2(ctx, shape, false);
+        };
+        return Polyline;
+    }(Path));
+    Polyline.prototype.type = 'polyline';
+
+    var subPixelOptimizeOutputShape$1 = {};
+    var LineShape = (function () {
+        function LineShape() {
+            this.x1 = 0;
+            this.y1 = 0;
+            this.x2 = 0;
+            this.y2 = 0;
+            this.percent = 1;
+        }
+        return LineShape;
+    }());
+    var Line = (function (_super) {
+        __extends(Line, _super);
+        function Line(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Line.prototype.getDefaultStyle = function () {
+            return {
+                stroke: '#000',
+                fill: null
+            };
+        };
+        Line.prototype.getDefaultShape = function () {
+            return new LineShape();
+        };
+        Line.prototype.buildPath = function (ctx, shape) {
+            var x1;
+            var y1;
+            var x2;
+            var y2;
+            if (this.subPixelOptimize) {
+                var optimizedShape = subPixelOptimizeLine(subPixelOptimizeOutputShape$1, shape, this.style);
+                x1 = optimizedShape.x1;
+                y1 = optimizedShape.y1;
+                x2 = optimizedShape.x2;
+                y2 = optimizedShape.y2;
+            }
+            else {
+                x1 = shape.x1;
+                y1 = shape.y1;
+                x2 = shape.x2;
+                y2 = shape.y2;
+            }
+            var percent = shape.percent;
+            if (percent === 0) {
+                return;
+            }
+            ctx.moveTo(x1, y1);
+            if (percent < 1) {
+                x2 = x1 * (1 - percent) + x2 * percent;
+                y2 = y1 * (1 - percent) + y2 * percent;
+            }
+            ctx.lineTo(x2, y2);
+        };
+        Line.prototype.pointAt = function (p) {
+            var shape = this.shape;
+            return [
+                shape.x1 * (1 - p) + shape.x2 * p,
+                shape.y1 * (1 - p) + shape.y2 * p
+            ];
+        };
+        return Line;
+    }(Path));
+    Line.prototype.type = 'line';
+
+    var out = [];
+    var BezierCurveShape = (function () {
+        function BezierCurveShape() {
+            this.x1 = 0;
+            this.y1 = 0;
+            this.x2 = 0;
+            this.y2 = 0;
+            this.cpx1 = 0;
+            this.cpy1 = 0;
+            this.percent = 1;
+        }
+        return BezierCurveShape;
+    }());
+    function someVectorAt(shape, t, isTangent) {
+        var cpx2 = shape.cpx2;
+        var cpy2 = shape.cpy2;
+        if (cpx2 === null || cpy2 === null) {
+            return [
+                (isTangent ? cubicDerivativeAt : cubicAt)(shape.x1, shape.cpx1, shape.cpx2, shape.x2, t),
+                (isTangent ? cubicDerivativeAt : cubicAt)(shape.y1, shape.cpy1, shape.cpy2, shape.y2, t)
+            ];
+        }
+        else {
+            return [
+                (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t),
+                (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t)
+            ];
+        }
+    }
+    var BezierCurve = (function (_super) {
+        __extends(BezierCurve, _super);
+        function BezierCurve(opts) {
+            return _super.call(this, opts) || this;
+        }
+        BezierCurve.prototype.getDefaultStyle = function () {
+            return {
+                stroke: '#000',
+                fill: null
+            };
+        };
+        BezierCurve.prototype.getDefaultShape = function () {
+            return new BezierCurveShape();
+        };
+        BezierCurve.prototype.buildPath = function (ctx, shape) {
+            var x1 = shape.x1;
+            var y1 = shape.y1;
+            var x2 = shape.x2;
+            var y2 = shape.y2;
+            var cpx1 = shape.cpx1;
+            var cpy1 = shape.cpy1;
+            var cpx2 = shape.cpx2;
+            var cpy2 = shape.cpy2;
+            var percent = shape.percent;
+            if (percent === 0) {
+                return;
+            }
+            ctx.moveTo(x1, y1);
+            if (cpx2 == null || cpy2 == null) {
+                if (percent < 1) {
+                    quadraticSubdivide(x1, cpx1, x2, percent, out);
+                    cpx1 = out[1];
+                    x2 = out[2];
+                    quadraticSubdivide(y1, cpy1, y2, percent, out);
+                    cpy1 = out[1];
+                    y2 = out[2];
+                }
+                ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);
+            }
+            else {
+                if (percent < 1) {
+                    cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);
+                    cpx1 = out[1];
+                    cpx2 = out[2];
+                    x2 = out[3];
+                    cubicSubdivide(y1, cpy1, cpy2, y2, percent, out);
+                    cpy1 = out[1];
+                    cpy2 = out[2];
+                    y2 = out[3];
+                }
+                ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);
+            }
+        };
+        BezierCurve.prototype.pointAt = function (t) {
+            return someVectorAt(this.shape, t, false);
+        };
+        BezierCurve.prototype.tangentAt = function (t) {
+            var p = someVectorAt(this.shape, t, true);
+            return normalize(p, p);
+        };
+        return BezierCurve;
+    }(Path));
+    BezierCurve.prototype.type = 'bezier-curve';
+
+    var ArcShape = (function () {
+        function ArcShape() {
+            this.cx = 0;
+            this.cy = 0;
+            this.r = 0;
+            this.startAngle = 0;
+            this.endAngle = Math.PI * 2;
+            this.clockwise = true;
+        }
+        return ArcShape;
+    }());
+    var Arc = (function (_super) {
+        __extends(Arc, _super);
+        function Arc(opts) {
+            return _super.call(this, opts) || this;
+        }
+        Arc.prototype.getDefaultStyle = function () {
+            return {
+                stroke: '#000',
+                fill: null
+            };
+        };
+        Arc.prototype.getDefaultShape = function () {
+            return new ArcShape();
+        };
+        Arc.prototype.buildPath = function (ctx, shape) {
+            var x = shape.cx;
+            var y = shape.cy;
+            var r = Math.max(shape.r, 0);
+            var startAngle = shape.startAngle;
+            var endAngle = shape.endAngle;
+            var clockwise = shape.clockwise;
+            var unitX = Math.cos(startAngle);
+            var unitY = Math.sin(startAngle);
+            ctx.moveTo(unitX * r + x, unitY * r + y);
+            ctx.arc(x, y, r, startAngle, endAngle, !clockwise);
+        };
+        return Arc;
+    }(Path));
+    Arc.prototype.type = 'arc';
+
+    var CompoundPath = (function (_super) {
+        __extends(CompoundPath, _super);
+        function CompoundPath() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.type = 'compound';
+            return _this;
+        }
+        CompoundPath.prototype._updatePathDirty = function () {
+            var paths = this.shape.paths;
+            var dirtyPath = this.shapeChanged();
+            for (var i = 0; i < paths.length; i++) {
+                dirtyPath = dirtyPath || paths[i].shapeChanged();
+            }
+            if (dirtyPath) {
+                this.dirtyShape();
+            }
+        };
+        CompoundPath.prototype.beforeBrush = function () {
+            this._updatePathDirty();
+            var paths = this.shape.paths || [];
+            var scale = this.getGlobalScale();
+            for (var i = 0; i < paths.length; i++) {
+                if (!paths[i].path) {
+                    paths[i].createPathProxy();
+                }
+                paths[i].path.setScale(scale[0], scale[1], paths[i].segmentIgnoreThreshold);
+            }
+        };
+        CompoundPath.prototype.buildPath = function (ctx, shape) {
+            var paths = shape.paths || [];
+            for (var i = 0; i < paths.length; i++) {
+                paths[i].buildPath(ctx, paths[i].shape, true);
+            }
+        };
+        CompoundPath.prototype.afterBrush = function () {
+            var paths = this.shape.paths || [];
+            for (var i = 0; i < paths.length; i++) {
+                paths[i].pathUpdated();
+            }
+        };
+        CompoundPath.prototype.getBoundingRect = function () {
+            this._updatePathDirty.call(this);
+            return Path.prototype.getBoundingRect.call(this);
+        };
+        return CompoundPath;
+    }(Path));
+
+    var Gradient = (function () {
+        function Gradient(colorStops) {
+            this.colorStops = colorStops || [];
+        }
+        Gradient.prototype.addColorStop = function (offset, color) {
+            this.colorStops.push({
+                offset: offset,
+                color: color
+            });
+        };
+        return Gradient;
+    }());
+
+    var LinearGradient = (function (_super) {
+        __extends(LinearGradient, _super);
+        function LinearGradient(x, y, x2, y2, colorStops, globalCoord) {
+            var _this = _super.call(this, colorStops) || this;
+            _this.x = x == null ? 0 : x;
+            _this.y = y == null ? 0 : y;
+            _this.x2 = x2 == null ? 1 : x2;
+            _this.y2 = y2 == null ? 0 : y2;
+            _this.type = 'linear';
+            _this.global = globalCoord || false;
+            return _this;
+        }
+        return LinearGradient;
+    }(Gradient));
+
+    var RadialGradient = (function (_super) {
+        __extends(RadialGradient, _super);
+        function RadialGradient(x, y, r, colorStops, globalCoord) {
+            var _this = _super.call(this, colorStops) || this;
+            _this.x = x == null ? 0.5 : x;
+            _this.y = y == null ? 0.5 : y;
+            _this.r = r == null ? 0.5 : r;
+            _this.type = 'radial';
+            _this.global = globalCoord || false;
+            return _this;
+        }
+        return RadialGradient;
+    }(Gradient));
+
+    var extent = [0, 0];
+    var extent2 = [0, 0];
+    var minTv$1 = new Point();
+    var maxTv$1 = new Point();
+    var OrientedBoundingRect = (function () {
+        function OrientedBoundingRect(rect, transform) {
+            this._corners = [];
+            this._axes = [];
+            this._origin = [0, 0];
+            for (var i = 0; i < 4; i++) {
+                this._corners[i] = new Point();
+            }
+            for (var i = 0; i < 2; i++) {
+                this._axes[i] = new Point();
+            }
+            if (rect) {
+                this.fromBoundingRect(rect, transform);
+            }
+        }
+        OrientedBoundingRect.prototype.fromBoundingRect = function (rect, transform) {
+            var corners = this._corners;
+            var axes = this._axes;
+            var x = rect.x;
+            var y = rect.y;
+            var x2 = x + rect.width;
+            var y2 = y + rect.height;
+            corners[0].set(x, y);
+            corners[1].set(x2, y);
+            corners[2].set(x2, y2);
+            corners[3].set(x, y2);
+            if (transform) {
+                for (var i = 0; i < 4; i++) {
+                    corners[i].transform(transform);
+                }
+            }
+            Point.sub(axes[0], corners[1], corners[0]);
+            Point.sub(axes[1], corners[3], corners[0]);
+            axes[0].normalize();
+            axes[1].normalize();
+            for (var i = 0; i < 2; i++) {
+                this._origin[i] = axes[i].dot(corners[0]);
+            }
+        };
+        OrientedBoundingRect.prototype.intersect = function (other, mtv) {
+            var overlapped = true;
+            var noMtv = !mtv;
+            minTv$1.set(Infinity, Infinity);
+            maxTv$1.set(0, 0);
+            if (!this._intersectCheckOneSide(this, other, minTv$1, maxTv$1, noMtv, 1)) {
+                overlapped = false;
+                if (noMtv) {
+                    return overlapped;
+                }
+            }
+            if (!this._intersectCheckOneSide(other, this, minTv$1, maxTv$1, noMtv, -1)) {
+                overlapped = false;
+                if (noMtv) {
+                    return overlapped;
+                }
+            }
+            if (!noMtv) {
+                Point.copy(mtv, overlapped ? minTv$1 : maxTv$1);
+            }
+            return overlapped;
+        };
+        OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, minTv, maxTv, noMtv, inverse) {
+            var overlapped = true;
+            for (var i = 0; i < 2; i++) {
+                var axis = this._axes[i];
+                this._getProjMinMaxOnAxis(i, self._corners, extent);
+                this._getProjMinMaxOnAxis(i, other._corners, extent2);
+                if (extent[1] < extent2[0] || extent[0] > extent2[1]) {
+                    overlapped = false;
+                    if (noMtv) {
+                        return overlapped;
+                    }
+                    var dist0 = Math.abs(extent2[0] - extent[1]);
+                    var dist1 = Math.abs(extent[0] - extent2[1]);
+                    if (Math.min(dist0, dist1) > maxTv.len()) {
+                        if (dist0 < dist1) {
+                            Point.scale(maxTv, axis, -dist0 * inverse);
+                        }
+                        else {
+                            Point.scale(maxTv, axis, dist1 * inverse);
+                        }
+                    }
+                }
+                else if (minTv) {
+                    var dist0 = Math.abs(extent2[0] - extent[1]);
+                    var dist1 = Math.abs(extent[0] - extent2[1]);
+                    if (Math.min(dist0, dist1) < minTv.len()) {
+                        if (dist0 < dist1) {
+                            Point.scale(minTv, axis, dist0 * inverse);
+                        }
+                        else {
+                            Point.scale(minTv, axis, -dist1 * inverse);
+                        }
+                    }
+                }
+            }
+            return overlapped;
+        };
+        OrientedBoundingRect.prototype._getProjMinMaxOnAxis = function (dim, corners, out) {
+            var axis = this._axes[dim];
+            var origin = this._origin;
+            var proj = corners[0].dot(axis) + origin[dim];
+            var min = proj;
+            var max = proj;
+            for (var i = 1; i < corners.length; i++) {
+                var proj_1 = corners[i].dot(axis) + origin[dim];
+                min = Math.min(proj_1, min);
+                max = Math.max(proj_1, max);
+            }
+            out[0] = min;
+            out[1] = max;
+        };
+        return OrientedBoundingRect;
+    }());
+
+    var m = [];
+    var IncrementalDisplayable = (function (_super) {
+        __extends(IncrementalDisplayable, _super);
+        function IncrementalDisplayable() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.notClear = true;
+            _this.incremental = true;
+            _this._displayables = [];
+            _this._temporaryDisplayables = [];
+            _this._cursor = 0;
+            return _this;
+        }
+        IncrementalDisplayable.prototype.traverse = function (cb, context) {
+            cb.call(context, this);
+        };
+        IncrementalDisplayable.prototype.useStyle = function () {
+            this.style = {};
+        };
+        IncrementalDisplayable.prototype.getCursor = function () {
+            return this._cursor;
+        };
+        IncrementalDisplayable.prototype.innerAfterBrush = function () {
+            this._cursor = this._displayables.length;
+        };
+        IncrementalDisplayable.prototype.clearDisplaybles = function () {
+            this._displayables = [];
+            this._temporaryDisplayables = [];
+            this._cursor = 0;
+            this.markRedraw();
+            this.notClear = false;
+        };
+        IncrementalDisplayable.prototype.clearTemporalDisplayables = function () {
+            this._temporaryDisplayables = [];
+        };
+        IncrementalDisplayable.prototype.addDisplayable = function (displayable, notPersistent) {
+            if (notPersistent) {
+                this._temporaryDisplayables.push(displayable);
+            }
+            else {
+                this._displayables.push(displayable);
+            }
+            this.markRedraw();
+        };
+        IncrementalDisplayable.prototype.addDisplayables = function (displayables, notPersistent) {
+            notPersistent = notPersistent || false;
+            for (var i = 0; i < displayables.length; i++) {
+                this.addDisplayable(displayables[i], notPersistent);
+            }
+        };
+        IncrementalDisplayable.prototype.getDisplayables = function () {
+            return this._displayables;
+        };
+        IncrementalDisplayable.prototype.getTemporalDisplayables = function () {
+            return this._temporaryDisplayables;
+        };
+        IncrementalDisplayable.prototype.eachPendingDisplayable = function (cb) {
+            for (var i = this._cursor; i < this._displayables.length; i++) {
+                cb && cb(this._displayables[i]);
+            }
+            for (var i = 0; i < this._temporaryDisplayables.length; i++) {
+                cb && cb(this._temporaryDisplayables[i]);
+            }
+        };
+        IncrementalDisplayable.prototype.update = function () {
+            this.updateTransform();
+            for (var i = this._cursor; i < this._displayables.length; i++) {
+                var displayable = this._displayables[i];
+                displayable.parent = this;
+                displayable.update();
+                displayable.parent = null;
+            }
+            for (var i = 0; i < this._temporaryDisplayables.length; i++) {
+                var displayable = this._temporaryDisplayables[i];
+                displayable.parent = this;
+                displayable.update();
+                displayable.parent = null;
+            }
+        };
+        IncrementalDisplayable.prototype.getBoundingRect = function () {
+            if (!this._rect) {
+                var rect = new BoundingRect(Infinity, Infinity, -Infinity, -Infinity);
+                for (var i = 0; i < this._displayables.length; i++) {
+                    var displayable = this._displayables[i];
+                    var childRect = displayable.getBoundingRect().clone();
+                    if (displayable.needLocalTransform()) {
+                        childRect.applyTransform(displayable.getLocalTransform(m));
+                    }
+                    rect.union(childRect);
+                }
+                this._rect = rect;
+            }
+            return this._rect;
+        };
+        IncrementalDisplayable.prototype.contain = function (x, y) {
+            var localPos = this.transformCoordToLocal(x, y);
+            var rect = this.getBoundingRect();
+            if (rect.contain(localPos[0], localPos[1])) {
+                for (var i = 0; i < this._displayables.length; i++) {
+                    var displayable = this._displayables[i];
+                    if (displayable.contain(x, y)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        return IncrementalDisplayable;
+    }(Displayable));
+
+    var mathMax$4 = Math.max;
+    var mathMin$4 = Math.min;
+    var _customShapeMap = {};
+    /**
+     * Extend shape with parameters
+     */
+
+    function extendShape(opts) {
+      return Path.extend(opts);
+    }
+    var extendPathFromString = extendFromString;
+    /**
+     * Extend path
+     */
+
+    function extendPath(pathData, opts) {
+      return extendPathFromString(pathData, opts);
+    }
+    /**
+     * Register a user defined shape.
+     * The shape class can be fetched by `getShapeClass`
+     * This method will overwrite the registered shapes, including
+     * the registered built-in shapes, if using the same `name`.
+     * The shape can be used in `custom series` and
+     * `graphic component` by declaring `{type: name}`.
+     *
+     * @param name
+     * @param ShapeClass Can be generated by `extendShape`.
+     */
+
+    function registerShape(name, ShapeClass) {
+      _customShapeMap[name] = ShapeClass;
+    }
+    /**
+     * Find shape class registered by `registerShape`. Usually used in
+     * fetching user defined shape.
+     *
+     * [Caution]:
+     * (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared
+     * to use user registered shapes.
+     * Because the built-in shape (see `getBuiltInShape`) will be registered by
+     * `registerShape` by default. That enables users to get both built-in
+     * shapes as well as the shapes belonging to themsleves. But users can overwrite
+     * the built-in shapes by using names like 'circle', 'rect' via calling
+     * `registerShape`. So the echarts inner featrues should not fetch shapes from here
+     * in case that it is overwritten by users, except that some features, like
+     * `custom series`, `graphic component`, do it deliberately.
+     *
+     * (2) In the features like `custom series`, `graphic component`, the user input
+     * `{tpye: 'xxx'}` does not only specify shapes but also specify other graphic
+     * elements like `'group'`, `'text'`, `'image'` or event `'path'`. Those names
+     * are reserved names, that is, if some user register a shape named `'image'`,
+     * the shape will not be used. If we intending to add some more reserved names
+     * in feature, that might bring break changes (disable some existing user shape
+     * names). But that case probably rearly happen. So we dont make more mechanism
+     * to resolve this issue here.
+     *
+     * @param name
+     * @return The shape class. If not found, return nothing.
+     */
+
+    function getShapeClass(name) {
+      if (_customShapeMap.hasOwnProperty(name)) {
+        return _customShapeMap[name];
+      }
+    }
+    /**
+     * Create a path element from path data string
+     * @param pathData
+     * @param opts
+     * @param rect
+     * @param layout 'center' or 'cover' default to be cover
+     */
+
+    function makePath(pathData, opts, rect, layout) {
+      var path = createFromString(pathData, opts);
+
+      if (rect) {
+        if (layout === 'center') {
+          rect = centerGraphic(rect, path.getBoundingRect());
+        }
+
+        resizePath(path, rect);
+      }
+
+      return path;
+    }
+    /**
+     * Create a image element from image url
+     * @param imageUrl image url
+     * @param opts options
+     * @param rect constrain rect
+     * @param layout 'center' or 'cover'. Default to be 'cover'
+     */
+
+    function makeImage(imageUrl, rect, layout) {
+      var zrImg = new ZRImage({
+        style: {
+          image: imageUrl,
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        },
+        onload: function (img) {
+          if (layout === 'center') {
+            var boundingRect = {
+              width: img.width,
+              height: img.height
+            };
+            zrImg.setStyle(centerGraphic(rect, boundingRect));
+          }
+        }
+      });
+      return zrImg;
+    }
+    /**
+     * Get position of centered element in bounding box.
+     *
+     * @param  rect         element local bounding box
+     * @param  boundingRect constraint bounding box
+     * @return element position containing x, y, width, and height
+     */
+
+    function centerGraphic(rect, boundingRect) {
+      // Set rect to center, keep width / height ratio.
+      var aspect = boundingRect.width / boundingRect.height;
+      var width = rect.height * aspect;
+      var height;
+
+      if (width <= rect.width) {
+        height = rect.height;
+      } else {
+        width = rect.width;
+        height = width / aspect;
+      }
+
+      var cx = rect.x + rect.width / 2;
+      var cy = rect.y + rect.height / 2;
+      return {
+        x: cx - width / 2,
+        y: cy - height / 2,
+        width: width,
+        height: height
+      };
+    }
+
+    var mergePath$1 = mergePath;
+    /**
+     * Resize a path to fit the rect
+     * @param path
+     * @param rect
+     */
+
+    function resizePath(path, rect) {
+      if (!path.applyTransform) {
+        return;
+      }
+
+      var pathRect = path.getBoundingRect();
+      var m = pathRect.calculateTransform(rect);
+      path.applyTransform(m);
+    }
+    /**
+     * Sub pixel optimize line for canvas
+     */
+
+    function subPixelOptimizeLine$1(param) {
+      subPixelOptimizeLine(param.shape, param.shape, param.style);
+      return param;
+    }
+    /**
+     * Sub pixel optimize rect for canvas
+     */
+
+    function subPixelOptimizeRect$1(param) {
+      subPixelOptimizeRect(param.shape, param.shape, param.style);
+      return param;
+    }
+    /**
+     * Sub pixel optimize for canvas
+     *
+     * @param position Coordinate, such as x, y
+     * @param lineWidth Should be nonnegative integer.
+     * @param positiveOrNegative Default false (negative).
+     * @return Optimized position.
+     */
+
+    var subPixelOptimize$1 = subPixelOptimize;
+
+    function animateOrSetProps(animationType, el, props, animatableModel, dataIndex, cb, during) {
+      var isFrom = false;
+      var removeOpt;
+
+      if (typeof dataIndex === 'function') {
+        during = cb;
+        cb = dataIndex;
+        dataIndex = null;
+      } else if (isObject(dataIndex)) {
+        cb = dataIndex.cb;
+        during = dataIndex.during;
+        isFrom = dataIndex.isFrom;
+        removeOpt = dataIndex.removeOpt;
+        dataIndex = dataIndex.dataIndex;
+      }
+
+      var isUpdate = animationType === 'update';
+      var isRemove = animationType === 'remove';
+      var animationPayload; // Check if there is global animation configuration from dataZoom/resize can override the config in option.
+      // If animation is enabled. Will use this animation config in payload.
+      // If animation is disabled. Just ignore it.
+
+      if (animatableModel && animatableModel.ecModel) {
+        var updatePayload = animatableModel.ecModel.getUpdatePayload();
+        animationPayload = updatePayload && updatePayload.animation;
+      }
+
+      var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();
+
+      if (!isRemove) {
+        // Must stop the remove animation.
+        el.stopAnimation('remove');
+      }
+
+      if (animationEnabled) {
+        var duration = void 0;
+        var animationEasing = void 0;
+        var animationDelay = void 0;
+
+        if (animationPayload) {
+          duration = animationPayload.duration || 0;
+          animationEasing = animationPayload.easing || 'cubicOut';
+          animationDelay = animationPayload.delay || 0;
+        } else if (isRemove) {
+          removeOpt = removeOpt || {};
+          duration = retrieve2(removeOpt.duration, 200);
+          animationEasing = retrieve2(removeOpt.easing, 'cubicOut');
+          animationDelay = 0;
+        } else {
+          duration = animatableModel.getShallow(isUpdate ? 'animationDurationUpdate' : 'animationDuration');
+          animationEasing = animatableModel.getShallow(isUpdate ? 'animationEasingUpdate' : 'animationEasing');
+          animationDelay = animatableModel.getShallow(isUpdate ? 'animationDelayUpdate' : 'animationDelay');
+        }
+
+        if (typeof animationDelay === 'function') {
+          animationDelay = animationDelay(dataIndex, animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);
+        }
+
+        if (typeof duration === 'function') {
+          duration = duration(dataIndex);
+        }
+
+        duration > 0 ? isFrom ? el.animateFrom(props, {
+          duration: duration,
+          delay: animationDelay || 0,
+          easing: animationEasing,
+          done: cb,
+          force: !!cb || !!during,
+          scope: animationType,
+          during: during
+        }) : el.animateTo(props, {
+          duration: duration,
+          delay: animationDelay || 0,
+          easing: animationEasing,
+          done: cb,
+          force: !!cb || !!during,
+          setToFinal: true,
+          scope: animationType,
+          during: during
+        }) : ( // FIXME:
+        // If `duration` is 0, only the animation on props
+        // can be stoped, other animation should be continued?
+        // But at present using duration 0 in `animateTo`, `animateFrom`
+        // might cause unexpected behavior.
+        el.stopAnimation(), // If `isFrom`, the props is the "from" props.
+        !isFrom && el.attr(props), cb && cb());
+      } else {
+        el.stopAnimation();
+        !isFrom && el.attr(props); // Call during once.
+
+        during && during(1);
+        cb && cb();
+      }
+    }
+    /**
+     * Update graphic element properties with or without animation according to the
+     * configuration in series.
+     *
+     * Caution: this method will stop previous animation.
+     * So do not use this method to one element twice before
+     * animation starts, unless you know what you are doing.
+     * @example
+     *     graphic.updateProps(el, {
+     *         position: [100, 100]
+     *     }, seriesModel, dataIndex, function () { console.log('Animation done!'); });
+     *     // Or
+     *     graphic.updateProps(el, {
+     *         position: [100, 100]
+     *     }, seriesModel, function () { console.log('Animation done!'); });
+     */
+
+
+    function updateProps(el, props, // TODO: TYPE AnimatableModel
+    animatableModel, dataIndex, cb, during) {
+      animateOrSetProps('update', el, props, animatableModel, dataIndex, cb, during);
+    }
+    /**
+     * Init graphic element properties with or without animation according to the
+     * configuration in series.
+     *
+     * Caution: this method will stop previous animation.
+     * So do not use this method to one element twice before
+     * animation starts, unless you know what you are doing.
+     */
+
+    function initProps(el, props, animatableModel, dataIndex, cb, during) {
+      animateOrSetProps('init', el, props, animatableModel, dataIndex, cb, during);
+    }
+    /**
+     * Remove graphic element
+     */
+
+    function removeElement(el, props, animatableModel, dataIndex, cb, during) {
+      // Don't do remove animation twice.
+      if (isElementRemoved(el)) {
+        return;
+      }
+
+      animateOrSetProps('remove', el, props, animatableModel, dataIndex, cb, during);
+    }
+
+    function fadeOutDisplayable(el, animatableModel, dataIndex, done) {
+      el.removeTextContent();
+      el.removeTextGuideLine();
+      removeElement(el, {
+        style: {
+          opacity: 0
+        }
+      }, animatableModel, dataIndex, done);
+    }
+
+    function removeElementWithFadeOut(el, animatableModel, dataIndex) {
+      function doRemove() {
+        el.parent && el.parent.remove(el);
+      } // Hide label and labelLine first
+      // TODO Also use fade out animation?
+
+
+      if (!el.isGroup) {
+        fadeOutDisplayable(el, animatableModel, dataIndex, doRemove);
+      } else {
+        el.traverse(function (disp) {
+          if (!disp.isGroup) {
+            // Can invoke doRemove multiple times.
+            fadeOutDisplayable(disp, animatableModel, dataIndex, doRemove);
+          }
+        });
+      }
+    }
+    /**
+     * If element is removed.
+     * It can determine if element is having remove animation.
+     */
+
+    function isElementRemoved(el) {
+      if (!el.__zr) {
+        return true;
+      }
+
+      for (var i = 0; i < el.animators.length; i++) {
+        var animator = el.animators[i];
+
+        if (animator.scope === 'remove') {
+          return true;
+        }
+      }
+
+      return false;
+    }
+    /**
+     * Get transform matrix of target (param target),
+     * in coordinate of its ancestor (param ancestor)
+     *
+     * @param target
+     * @param [ancestor]
+     */
+
+    function getTransform(target, ancestor) {
+      var mat = identity([]);
+
+      while (target && target !== ancestor) {
+        mul$1(mat, target.getLocalTransform(), mat);
+        target = target.parent;
+      }
+
+      return mat;
+    }
+    /**
+     * Apply transform to an vertex.
+     * @param target [x, y]
+     * @param transform Can be:
+     *      + Transform matrix: like [1, 0, 0, 1, 0, 0]
+     *      + {position, rotation, scale}, the same as `zrender/Transformable`.
+     * @param invert Whether use invert matrix.
+     * @return [x, y]
+     */
+
+    function applyTransform$1(target, transform, invert$1) {
+      if (transform && !isArrayLike(transform)) {
+        transform = Transformable.getLocalTransform(transform);
+      }
+
+      if (invert$1) {
+        transform = invert([], transform);
+      }
+
+      return applyTransform([], target, transform);
+    }
+    /**
+     * @param direction 'left' 'right' 'top' 'bottom'
+     * @param transform Transform matrix: like [1, 0, 0, 1, 0, 0]
+     * @param invert Whether use invert matrix.
+     * @return Transformed direction. 'left' 'right' 'top' 'bottom'
+     */
+
+    function transformDirection(direction, transform, invert) {
+      // Pick a base, ensure that transform result will not be (0, 0).
+      var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);
+      var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);
+      var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];
+      vertex = applyTransform$1(vertex, transform, invert);
+      return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';
+    }
+
+    function isNotGroup(el) {
+      return !el.isGroup;
+    }
+
+    function isPath(el) {
+      return el.shape != null;
+    }
+    /**
+     * Apply group transition animation from g1 to g2.
+     * If no animatableModel, no animation.
+     */
+
+
+    function groupTransition(g1, g2, animatableModel) {
+      if (!g1 || !g2) {
+        return;
+      }
+
+      function getElMap(g) {
+        var elMap = {};
+        g.traverse(function (el) {
+          if (isNotGroup(el) && el.anid) {
+            elMap[el.anid] = el;
+          }
+        });
+        return elMap;
+      }
+
+      function getAnimatableProps(el) {
+        var obj = {
+          x: el.x,
+          y: el.y,
+          rotation: el.rotation
+        };
+
+        if (isPath(el)) {
+          obj.shape = extend({}, el.shape);
+        }
+
+        return obj;
+      }
+
+      var elMap1 = getElMap(g1);
+      g2.traverse(function (el) {
+        if (isNotGroup(el) && el.anid) {
+          var oldEl = elMap1[el.anid];
+
+          if (oldEl) {
+            var newProp = getAnimatableProps(el);
+            el.attr(getAnimatableProps(oldEl));
+            updateProps(el, newProp, animatableModel, getECData(el).dataIndex);
+          }
+        }
+      });
+    }
+    function clipPointsByRect(points, rect) {
+      // FIXME: this way migth be incorrect when grpahic clipped by a corner.
+      // and when element have border.
+      return map(points, function (point) {
+        var x = point[0];
+        x = mathMax$4(x, rect.x);
+        x = mathMin$4(x, rect.x + rect.width);
+        var y = point[1];
+        y = mathMax$4(y, rect.y);
+        y = mathMin$4(y, rect.y + rect.height);
+        return [x, y];
+      });
+    }
+    /**
+     * Return a new clipped rect. If rect size are negative, return undefined.
+     */
+
+    function clipRectByRect(targetRect, rect) {
+      var x = mathMax$4(targetRect.x, rect.x);
+      var x2 = mathMin$4(targetRect.x + targetRect.width, rect.x + rect.width);
+      var y = mathMax$4(targetRect.y, rect.y);
+      var y2 = mathMin$4(targetRect.y + targetRect.height, rect.y + rect.height); // If the total rect is cliped, nothing, including the border,
+      // should be painted. So return undefined.
+
+      if (x2 >= x && y2 >= y) {
+        return {
+          x: x,
+          y: y,
+          width: x2 - x,
+          height: y2 - y
+        };
+      }
+    }
+    function createIcon(iconStr, // Support 'image://' or 'path://' or direct svg path.
+    opt, rect) {
+      var innerOpts = extend({
+        rectHover: true
+      }, opt);
+      var style = innerOpts.style = {
+        strokeNoScale: true
+      };
+      rect = rect || {
+        x: -1,
+        y: -1,
+        width: 2,
+        height: 2
+      };
+
+      if (iconStr) {
+        return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), defaults(style, rect), new ZRImage(innerOpts)) : makePath(iconStr.replace('path://', ''), innerOpts, rect, 'center');
+      }
+    }
+    /**
+     * Return `true` if the given line (line `a`) and the given polygon
+     * are intersect.
+     * Note that we do not count colinear as intersect here because no
+     * requirement for that. We could do that if required in future.
+     */
+
+    function linePolygonIntersect(a1x, a1y, a2x, a2y, points) {
+      for (var i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
+        var p = points[i];
+
+        if (lineLineIntersect(a1x, a1y, a2x, a2y, p[0], p[1], p2[0], p2[1])) {
+          return true;
+        }
+
+        p2 = p;
+      }
+    }
+    /**
+     * Return `true` if the given two lines (line `a` and line `b`)
+     * are intersect.
+     * Note that we do not count colinear as intersect here because no
+     * requirement for that. We could do that if required in future.
+     */
+
+    function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+      // let `vec_m` to be `vec_a2 - vec_a1` and `vec_n` to be `vec_b2 - vec_b1`.
+      var mx = a2x - a1x;
+      var my = a2y - a1y;
+      var nx = b2x - b1x;
+      var ny = b2y - b1y; // `vec_m` and `vec_n` are parallel iff
+      //     exising `k` such that `vec_m = k · vec_n`, equivalent to `vec_m X vec_n = 0`.
+
+      var nmCrossProduct = crossProduct2d(nx, ny, mx, my);
+
+      if (nearZero(nmCrossProduct)) {
+        return false;
+      } // `vec_m` and `vec_n` are intersect iff
+      //     existing `p` and `q` in [0, 1] such that `vec_a1 + p * vec_m = vec_b1 + q * vec_n`,
+      //     such that `q = ((vec_a1 - vec_b1) X vec_m) / (vec_n X vec_m)`
+      //           and `p = ((vec_a1 - vec_b1) X vec_n) / (vec_n X vec_m)`.
+
+
+      var b1a1x = a1x - b1x;
+      var b1a1y = a1y - b1y;
+      var q = crossProduct2d(b1a1x, b1a1y, mx, my) / nmCrossProduct;
+
+      if (q < 0 || q > 1) {
+        return false;
+      }
+
+      var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;
+
+      if (p < 0 || p > 1) {
+        return false;
+      }
+
+      return true;
+    }
+    /**
+     * Cross product of 2-dimension vector.
+     */
+
+    function crossProduct2d(x1, y1, x2, y2) {
+      return x1 * y2 - x2 * y1;
+    }
+
+    function nearZero(val) {
+      return val <= 1e-6 && val >= -1e-6;
+    } // Register built-in shapes. These shapes might be overwirtten
+    // by users, although we do not recommend that.
+
+
+    registerShape('circle', Circle);
+    registerShape('ellipse', Ellipse);
+    registerShape('sector', Sector);
+    registerShape('ring', Ring);
+    registerShape('polygon', Polygon);
+    registerShape('polyline', Polyline);
+    registerShape('rect', Rect);
+    registerShape('line', Line);
+    registerShape('bezierCurve', BezierCurve);
+    registerShape('arc', Arc);
+
+    var graphic = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        extendShape: extendShape,
+        extendPath: extendPath,
+        registerShape: registerShape,
+        getShapeClass: getShapeClass,
+        makePath: makePath,
+        makeImage: makeImage,
+        mergePath: mergePath$1,
+        resizePath: resizePath,
+        subPixelOptimizeLine: subPixelOptimizeLine$1,
+        subPixelOptimizeRect: subPixelOptimizeRect$1,
+        subPixelOptimize: subPixelOptimize$1,
+        updateProps: updateProps,
+        initProps: initProps,
+        removeElement: removeElement,
+        removeElementWithFadeOut: removeElementWithFadeOut,
+        isElementRemoved: isElementRemoved,
+        getTransform: getTransform,
+        applyTransform: applyTransform$1,
+        transformDirection: transformDirection,
+        groupTransition: groupTransition,
+        clipPointsByRect: clipPointsByRect,
+        clipRectByRect: clipRectByRect,
+        createIcon: createIcon,
+        linePolygonIntersect: linePolygonIntersect,
+        lineLineIntersect: lineLineIntersect,
+        Group: Group,
+        Image: ZRImage,
+        Text: ZRText,
+        Circle: Circle,
+        Ellipse: Ellipse,
+        Sector: Sector,
+        Ring: Ring,
+        Polygon: Polygon,
+        Polyline: Polyline,
+        Rect: Rect,
+        Line: Line,
+        BezierCurve: BezierCurve,
+        Arc: Arc,
+        IncrementalDisplayable: IncrementalDisplayable,
+        CompoundPath: CompoundPath,
+        LinearGradient: LinearGradient,
+        RadialGradient: RadialGradient,
+        BoundingRect: BoundingRect,
+        OrientedBoundingRect: OrientedBoundingRect,
+        Point: Point,
+        Path: Path
+    });
+
+    var EMPTY_OBJ = {};
+    function setLabelText(label, labelTexts) {
+      for (var i = 0; i < SPECIAL_STATES.length; i++) {
+        var stateName = SPECIAL_STATES[i];
+        var text = labelTexts[stateName];
+        var state = label.ensureState(stateName);
+        state.style = state.style || {};
+        state.style.text = text;
+      }
+
+      var oldStates = label.currentStates.slice();
+      label.clearStates(true);
+      label.setStyle({
+        text: labelTexts.normal
+      });
+      label.useStates(oldStates, true);
+    }
+
+    function getLabelText(opt, stateModels, interpolatedValue) {
+      var labelFetcher = opt.labelFetcher;
+      var labelDataIndex = opt.labelDataIndex;
+      var labelDimIndex = opt.labelDimIndex;
+      var normalModel = stateModels.normal;
+      var baseText;
+
+      if (labelFetcher) {
+        baseText = labelFetcher.getFormattedLabel(labelDataIndex, 'normal', null, labelDimIndex, normalModel && normalModel.get('formatter'), interpolatedValue != null ? {
+          interpolatedValue: interpolatedValue
+        } : null);
+      }
+
+      if (baseText == null) {
+        baseText = isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt, interpolatedValue) : opt.defaultText;
+      }
+
+      var statesText = {
+        normal: baseText
+      };
+
+      for (var i = 0; i < SPECIAL_STATES.length; i++) {
+        var stateName = SPECIAL_STATES[i];
+        var stateModel = stateModels[stateName];
+        statesText[stateName] = retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, stateName, null, labelDimIndex, stateModel && stateModel.get('formatter')) : null, baseText);
+      }
+
+      return statesText;
+    }
+
+    function setLabelStyle(targetEl, labelStatesModels, opt, stateSpecified // TODO specified position?
+    ) {
+      opt = opt || EMPTY_OBJ;
+      var isSetOnText = targetEl instanceof ZRText;
+      var needsCreateText = false;
+
+      for (var i = 0; i < DISPLAY_STATES.length; i++) {
+        var stateModel = labelStatesModels[DISPLAY_STATES[i]];
+
+        if (stateModel && stateModel.getShallow('show')) {
+          needsCreateText = true;
+          break;
+        }
+      }
+
+      var textContent = isSetOnText ? targetEl : targetEl.getTextContent();
+
+      if (needsCreateText) {
+        if (!isSetOnText) {
+          // Reuse the previous
+          if (!textContent) {
+            textContent = new ZRText();
+            targetEl.setTextContent(textContent);
+          } // Use same state proxy
+
+
+          if (targetEl.stateProxy) {
+            textContent.stateProxy = targetEl.stateProxy;
+          }
+        }
+
+        var labelStatesTexts = getLabelText(opt, labelStatesModels);
+        var normalModel = labelStatesModels.normal;
+        var showNormal = !!normalModel.getShallow('show');
+        var normalStyle = createTextStyle(normalModel, stateSpecified && stateSpecified.normal, opt, false, !isSetOnText);
+        normalStyle.text = labelStatesTexts.normal;
+
+        if (!isSetOnText) {
+          // Always create new
+          targetEl.setTextConfig(createTextConfig(normalModel, opt, false));
+        }
+
+        for (var i = 0; i < SPECIAL_STATES.length; i++) {
+          var stateName = SPECIAL_STATES[i];
+          var stateModel = labelStatesModels[stateName];
+
+          if (stateModel) {
+            var stateObj = textContent.ensureState(stateName);
+            var stateShow = !!retrieve2(stateModel.getShallow('show'), showNormal);
+
+            if (stateShow !== showNormal) {
+              stateObj.ignore = !stateShow;
+            }
+
+            stateObj.style = createTextStyle(stateModel, stateSpecified && stateSpecified[stateName], opt, true, !isSetOnText);
+            stateObj.style.text = labelStatesTexts[stateName];
+
+            if (!isSetOnText) {
+              var targetElEmphasisState = targetEl.ensureState(stateName);
+              targetElEmphasisState.textConfig = createTextConfig(stateModel, opt, true);
+            }
+          }
+        } // PENDING: if there is many requirements that emphasis position
+        // need to be different from normal position, we might consider
+        // auto slient is those cases.
+
+
+        textContent.silent = !!normalModel.getShallow('silent'); // Keep x and y
+
+        if (textContent.style.x != null) {
+          normalStyle.x = textContent.style.x;
+        }
+
+        if (textContent.style.y != null) {
+          normalStyle.y = textContent.style.y;
+        }
+
+        textContent.ignore = !showNormal; // Always create new style.
+
+        textContent.useStyle(normalStyle);
+        textContent.dirty();
+
+        if (opt.enableTextSetter) {
+          labelInner(textContent).setLabelText = function (interpolatedValue) {
+            var labelStatesTexts = getLabelText(opt, labelStatesModels, interpolatedValue);
+            setLabelText(textContent, labelStatesTexts);
+          };
+        }
+      } else if (textContent) {
+        // Not display rich text.
+        textContent.ignore = true;
+      }
+
+      targetEl.dirty();
+    }
+    function getLabelStatesModels(itemModel, labelName) {
+      labelName = labelName || 'label';
+      var statesModels = {
+        normal: itemModel.getModel(labelName)
+      };
+
+      for (var i = 0; i < SPECIAL_STATES.length; i++) {
+        var stateName = SPECIAL_STATES[i];
+        statesModels[stateName] = itemModel.getModel([stateName, labelName]);
+      }
+
+      return statesModels;
+    }
+    /**
+     * Set basic textStyle properties.
+     */
+
+    function createTextStyle(textStyleModel, specifiedTextStyle, // Fixed style in the code. Can't be set by model.
+    opt, isNotNormal, isAttached // If text is attached on an element. If so, auto color will handling in zrender.
+    ) {
+      var textStyle = {};
+      setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached);
+      specifiedTextStyle && extend(textStyle, specifiedTextStyle); // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);
+
+      return textStyle;
+    }
+    function createTextConfig(textStyleModel, opt, isNotNormal) {
+      opt = opt || {};
+      var textConfig = {};
+      var labelPosition;
+      var labelRotate = textStyleModel.getShallow('rotate');
+      var labelDistance = retrieve2(textStyleModel.getShallow('distance'), isNotNormal ? null : 5);
+      var labelOffset = textStyleModel.getShallow('offset');
+      labelPosition = textStyleModel.getShallow('position') || (isNotNormal ? null : 'inside'); // 'outside' is not a valid zr textPostion value, but used
+      // in bar series, and magric type should be considered.
+
+      labelPosition === 'outside' && (labelPosition = opt.defaultOutsidePosition || 'top');
+
+      if (labelPosition != null) {
+        textConfig.position = labelPosition;
+      }
+
+      if (labelOffset != null) {
+        textConfig.offset = labelOffset;
+      }
+
+      if (labelRotate != null) {
+        labelRotate *= Math.PI / 180;
+        textConfig.rotation = labelRotate;
+      }
+
+      if (labelDistance != null) {
+        textConfig.distance = labelDistance;
+      } // fill and auto is determined by the color of path fill if it's not specified by developers.
+
+
+      textConfig.outsideFill = textStyleModel.get('color') === 'inherit' ? opt.inheritColor || null : 'auto';
+      return textConfig;
+    }
+    /**
+     * The uniform entry of set text style, that is, retrieve style definitions
+     * from `model` and set to `textStyle` object.
+     *
+     * Never in merge mode, but in overwrite mode, that is, all of the text style
+     * properties will be set. (Consider the states of normal and emphasis and
+     * default value can be adopted, merge would make the logic too complicated
+     * to manage.)
+     */
+
+    function setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached) {
+      // Consider there will be abnormal when merge hover style to normal style if given default value.
+      opt = opt || EMPTY_OBJ;
+      var ecModel = textStyleModel.ecModel;
+      var globalTextStyle = ecModel && ecModel.option.textStyle; // Consider case:
+      // {
+      //     data: [{
+      //         value: 12,
+      //         label: {
+      //             rich: {
+      //                 // no 'a' here but using parent 'a'.
+      //             }
+      //         }
+      //     }],
+      //     rich: {
+      //         a: { ... }
+      //     }
+      // }
+
+      var richItemNames = getRichItemNames(textStyleModel);
+      var richResult;
+
+      if (richItemNames) {
+        richResult = {};
+
+        for (var name_1 in richItemNames) {
+          if (richItemNames.hasOwnProperty(name_1)) {
+            // Cascade is supported in rich.
+            var richTextStyle = textStyleModel.getModel(['rich', name_1]); // In rich, never `disableBox`.
+            // FIXME: consider `label: {formatter: '{a|xx}', color: 'blue', rich: {a: {}}}`,
+            // the default color `'blue'` will not be adopted if no color declared in `rich`.
+            // That might confuses users. So probably we should put `textStyleModel` as the
+            // root ancestor of the `richTextStyle`. But that would be a break change.
+
+            setTokenTextStyle(richResult[name_1] = {}, richTextStyle, globalTextStyle, opt, isNotNormal, isAttached, false, true);
+          }
+        }
+      }
+
+      if (richResult) {
+        textStyle.rich = richResult;
+      }
+
+      var overflow = textStyleModel.get('overflow');
+
+      if (overflow) {
+        textStyle.overflow = overflow;
+      }
+
+      var margin = textStyleModel.get('minMargin');
+
+      if (margin != null) {
+        textStyle.margin = margin;
+      }
+
+      setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, true, false);
+    } // Consider case:
+    // {
+    //     data: [{
+    //         value: 12,
+    //         label: {
+    //             rich: {
+    //                 // no 'a' here but using parent 'a'.
+    //             }
+    //         }
+    //     }],
+    //     rich: {
+    //         a: { ... }
+    //     }
+    // }
+    // TODO TextStyleModel
+
+
+    function getRichItemNames(textStyleModel) {
+      // Use object to remove duplicated names.
+      var richItemNameMap;
+
+      while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {
+        var rich = (textStyleModel.option || EMPTY_OBJ).rich;
+
+        if (rich) {
+          richItemNameMap = richItemNameMap || {};
+          var richKeys = keys(rich);
+
+          for (var i = 0; i < richKeys.length; i++) {
+            var richKey = richKeys[i];
+            richItemNameMap[richKey] = 1;
+          }
+        }
+
+        textStyleModel = textStyleModel.parentModel;
+      }
+
+      return richItemNameMap;
+    }
+
+    var TEXT_PROPS_WITH_GLOBAL = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY'];
+    var TEXT_PROPS_SELF = ['align', 'lineHeight', 'width', 'height', 'tag', 'verticalAlign'];
+    var TEXT_PROPS_BOX = ['padding', 'borderWidth', 'borderRadius', 'borderDashOffset', 'backgroundColor', 'borderColor', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY'];
+
+    function setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, isBlock, inRich) {
+      // In merge mode, default value should not be given.
+      globalTextStyle = !isNotNormal && globalTextStyle || EMPTY_OBJ;
+      var inheritColor = opt && opt.inheritColor;
+      var fillColor = textStyleModel.getShallow('color');
+      var strokeColor = textStyleModel.getShallow('textBorderColor');
+      var opacity = retrieve2(textStyleModel.getShallow('opacity'), globalTextStyle.opacity);
+
+      if (fillColor === 'inherit' || fillColor === 'auto') {
+        if ("development" !== 'production') {
+          if (fillColor === 'auto') {
+            deprecateReplaceLog('color: \'auto\'', 'color: \'inherit\'');
+          }
+        }
+
+        if (inheritColor) {
+          fillColor = inheritColor;
+        } else {
+          fillColor = null;
+        }
+      }
+
+      if (strokeColor === 'inherit' || strokeColor === 'auto') {
+        if ("development" !== 'production') {
+          if (strokeColor === 'auto') {
+            deprecateReplaceLog('color: \'auto\'', 'color: \'inherit\'');
+          }
+        }
+
+        if (inheritColor) {
+          strokeColor = inheritColor;
+        } else {
+          strokeColor = null;
+        }
+      }
+
+      if (!isAttached) {
+        // Only use default global textStyle.color if text is individual.
+        // Otherwise it will use the strategy of attached text color because text may be on a path.
+        fillColor = fillColor || globalTextStyle.color;
+        strokeColor = strokeColor || globalTextStyle.textBorderColor;
+      }
+
+      if (fillColor != null) {
+        textStyle.fill = fillColor;
+      }
+
+      if (strokeColor != null) {
+        textStyle.stroke = strokeColor;
+      }
+
+      var textBorderWidth = retrieve2(textStyleModel.getShallow('textBorderWidth'), globalTextStyle.textBorderWidth);
+
+      if (textBorderWidth != null) {
+        textStyle.lineWidth = textBorderWidth;
+      }
+
+      var textBorderType = retrieve2(textStyleModel.getShallow('textBorderType'), globalTextStyle.textBorderType);
+
+      if (textBorderType != null) {
+        textStyle.lineDash = textBorderType;
+      }
+
+      var textBorderDashOffset = retrieve2(textStyleModel.getShallow('textBorderDashOffset'), globalTextStyle.textBorderDashOffset);
+
+      if (textBorderDashOffset != null) {
+        textStyle.lineDashOffset = textBorderDashOffset;
+      }
+
+      if (!isNotNormal && opacity == null && !inRich) {
+        opacity = opt && opt.defaultOpacity;
+      }
+
+      if (opacity != null) {
+        textStyle.opacity = opacity;
+      } // TODO
+
+
+      if (!isNotNormal && !isAttached) {
+        // Set default finally.
+        if (textStyle.fill == null && opt.inheritColor) {
+          textStyle.fill = opt.inheritColor;
+        }
+      } // Do not use `getFont` here, because merge should be supported, where
+      // part of these properties may be changed in emphasis style, and the
+      // others should remain their original value got from normal style.
+
+
+      for (var i = 0; i < TEXT_PROPS_WITH_GLOBAL.length; i++) {
+        var key = TEXT_PROPS_WITH_GLOBAL[i];
+        var val = retrieve2(textStyleModel.getShallow(key), globalTextStyle[key]);
+
+        if (val != null) {
+          textStyle[key] = val;
+        }
+      }
+
+      for (var i = 0; i < TEXT_PROPS_SELF.length; i++) {
+        var key = TEXT_PROPS_SELF[i];
+        var val = textStyleModel.getShallow(key);
+
+        if (val != null) {
+          textStyle[key] = val;
+        }
+      }
+
+      if (textStyle.verticalAlign == null) {
+        var baseline = textStyleModel.getShallow('baseline');
+
+        if (baseline != null) {
+          textStyle.verticalAlign = baseline;
+        }
+      }
+
+      if (!isBlock || !opt.disableBox) {
+        for (var i = 0; i < TEXT_PROPS_BOX.length; i++) {
+          var key = TEXT_PROPS_BOX[i];
+          var val = textStyleModel.getShallow(key);
+
+          if (val != null) {
+            textStyle[key] = val;
+          }
+        }
+
+        var borderType = textStyleModel.getShallow('borderType');
+
+        if (borderType != null) {
+          textStyle.borderDash = borderType;
+        }
+
+        if ((textStyle.backgroundColor === 'auto' || textStyle.backgroundColor === 'inherit') && inheritColor) {
+          if ("development" !== 'production') {
+            if (textStyle.backgroundColor === 'auto') {
+              deprecateReplaceLog('backgroundColor: \'auto\'', 'backgroundColor: \'inherit\'');
+            }
+          }
+
+          textStyle.backgroundColor = inheritColor;
+        }
+
+        if ((textStyle.borderColor === 'auto' || textStyle.borderColor === 'inherit') && inheritColor) {
+          if ("development" !== 'production') {
+            if (textStyle.borderColor === 'auto') {
+              deprecateReplaceLog('borderColor: \'auto\'', 'borderColor: \'inherit\'');
+            }
+          }
+
+          textStyle.borderColor = inheritColor;
+        }
+      }
+    }
+
+    function getFont(opt, ecModel) {
+      var gTextStyleModel = ecModel && ecModel.getModel('textStyle');
+      return trim([// FIXME in node-canvas fontWeight is before fontStyle
+      opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow('fontStyle') || '', opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow('fontWeight') || '', (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow('fontSize') || 12) + 'px', opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow('fontFamily') || 'sans-serif'].join(' '));
+    }
+    var labelInner = makeInner();
+    function setLabelValueAnimation(label, labelStatesModels, value, getDefaultText) {
+      if (!label) {
+        return;
+      }
+
+      var obj = labelInner(label);
+      obj.prevValue = obj.value;
+      obj.value = value;
+      var normalLabelModel = labelStatesModels.normal;
+      obj.valueAnimation = normalLabelModel.get('valueAnimation');
+
+      if (obj.valueAnimation) {
+        obj.precision = normalLabelModel.get('precision');
+        obj.defaultInterpolatedText = getDefaultText;
+        obj.statesModels = labelStatesModels;
+      }
+    }
+    function animateLabelValue(textEl, dataIndex, data, animatableModel, labelFetcher) {
+      var labelInnerStore = labelInner(textEl);
+
+      if (!labelInnerStore.valueAnimation) {
+        return;
+      }
+
+      var defaultInterpolatedText = labelInnerStore.defaultInterpolatedText; // Consider the case that being animating, do not use the `obj.value`,
+      // Otherwise it will jump to the `obj.value` when this new animation started.
+
+      var currValue = retrieve2(labelInnerStore.interpolatedValue, labelInnerStore.prevValue);
+      var targetValue = labelInnerStore.value;
+
+      function during(percent) {
+        var interpolated = interpolateRawValues(data, labelInnerStore.precision, currValue, targetValue, percent);
+        labelInnerStore.interpolatedValue = percent === 1 ? null : interpolated;
+        var labelText = getLabelText({
+          labelDataIndex: dataIndex,
+          labelFetcher: labelFetcher,
+          defaultText: defaultInterpolatedText ? defaultInterpolatedText(interpolated) : interpolated + ''
+        }, labelInnerStore.statesModels, interpolated);
+        setLabelText(textEl, labelText);
+      }
+
+      (currValue == null ? initProps : updateProps)(textEl, {}, animatableModel, dataIndex, null, during);
+    }
+
+    var PATH_COLOR = ['textStyle', 'color']; // TODO Performance improvement?
+
+    var tmpRichText = new ZRText();
+
+    var TextStyleMixin =
+    /** @class */
+    function () {
+      function TextStyleMixin() {}
+      /**
+       * Get color property or get color from option.textStyle.color
+       */
+      // TODO Callback
+
+
+      TextStyleMixin.prototype.getTextColor = function (isEmphasis) {
+        var ecModel = this.ecModel;
+        return this.getShallow('color') || (!isEmphasis && ecModel ? ecModel.get(PATH_COLOR) : null);
+      };
+      /**
+       * Create font string from fontStyle, fontWeight, fontSize, fontFamily
+       * @return {string}
+       */
+
+
+      TextStyleMixin.prototype.getFont = function () {
+        return getFont({
+          fontStyle: this.getShallow('fontStyle'),
+          fontWeight: this.getShallow('fontWeight'),
+          fontSize: this.getShallow('fontSize'),
+          fontFamily: this.getShallow('fontFamily')
+        }, this.ecModel);
+      };
+
+      TextStyleMixin.prototype.getTextRect = function (text) {
+        tmpRichText.useStyle({
+          text: text,
+          fontStyle: this.getShallow('fontStyle'),
+          fontWeight: this.getShallow('fontWeight'),
+          fontSize: this.getShallow('fontSize'),
+          fontFamily: this.getShallow('fontFamily'),
+          verticalAlign: this.getShallow('verticalAlign') || this.getShallow('baseline'),
+          padding: this.getShallow('padding'),
+          lineHeight: this.getShallow('lineHeight'),
+          rich: this.getShallow('rich')
+        });
+        tmpRichText.update();
+        return tmpRichText.getBoundingRect();
+      };
+
+      return TextStyleMixin;
+    }();
+
+    var LINE_STYLE_KEY_MAP = [['lineWidth', 'width'], ['stroke', 'color'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'type'], ['lineDashOffset', 'dashOffset'], ['lineCap', 'cap'], ['lineJoin', 'join'], ['miterLimit'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+    // So do not transfer decal directly.
+    ];
+    var getLineStyle = makeStyleMapper(LINE_STYLE_KEY_MAP);
+
+    var LineStyleMixin =
+    /** @class */
+    function () {
+      function LineStyleMixin() {}
+
+      LineStyleMixin.prototype.getLineStyle = function (excludes) {
+        return getLineStyle(this, excludes);
+      };
+
+      return LineStyleMixin;
+    }();
+
+    var ITEM_STYLE_KEY_MAP = [['fill', 'color'], ['stroke', 'borderColor'], ['lineWidth', 'borderWidth'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'borderType'], ['lineDashOffset', 'borderDashOffset'], ['lineCap', 'borderCap'], ['lineJoin', 'borderJoin'], ['miterLimit', 'borderMiterLimit'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+    // So do not transfer decal directly.
+    ];
+    var getItemStyle = makeStyleMapper(ITEM_STYLE_KEY_MAP);
+
+    var ItemStyleMixin =
+    /** @class */
+    function () {
+      function ItemStyleMixin() {}
+
+      ItemStyleMixin.prototype.getItemStyle = function (excludes, includes) {
+        return getItemStyle(this, excludes, includes);
+      };
+
+      return ItemStyleMixin;
+    }();
+
+    var Model =
+    /** @class */
+    function () {
+      function Model(option, parentModel, ecModel) {
+        this.parentModel = parentModel;
+        this.ecModel = ecModel;
+        this.option = option; // Simple optimization
+        // if (this.init) {
+        //     if (arguments.length <= 4) {
+        //         this.init(option, parentModel, ecModel, extraOpt);
+        //     }
+        //     else {
+        //         this.init.apply(this, arguments);
+        //     }
+        // }
+      }
+
+      Model.prototype.init = function (option, parentModel, ecModel) {
+        var rest = [];
+
+        for (var _i = 3; _i < arguments.length; _i++) {
+          rest[_i - 3] = arguments[_i];
+        }
+      };
+      /**
+       * Merge the input option to me.
+       */
+
+
+      Model.prototype.mergeOption = function (option, ecModel) {
+        merge(this.option, option, true);
+      }; // `path` can be 'xxx.yyy.zzz', so the return value type have to be `ModelOption`
+      // TODO: TYPE strict key check?
+      // get(path: string | string[], ignoreParent?: boolean): ModelOption;
+
+
+      Model.prototype.get = function (path, ignoreParent) {
+        if (path == null) {
+          return this.option;
+        }
+
+        return this._doGet(this.parsePath(path), !ignoreParent && this.parentModel);
+      };
+
+      Model.prototype.getShallow = function (key, ignoreParent) {
+        var option = this.option;
+        var val = option == null ? option : option[key];
+
+        if (val == null && !ignoreParent) {
+          var parentModel = this.parentModel;
+
+          if (parentModel) {
+            // FIXME:TS do not know how to make it works
+            val = parentModel.getShallow(key);
+          }
+        }
+
+        return val;
+      }; // `path` can be 'xxx.yyy.zzz', so the return value type have to be `Model<ModelOption>`
+      // getModel(path: string | string[], parentModel?: Model): Model;
+      // TODO 'xxx.yyy.zzz' is deprecated
+
+
+      Model.prototype.getModel = function (path, parentModel) {
+        var hasPath = path != null;
+        var pathFinal = hasPath ? this.parsePath(path) : null;
+        var obj = hasPath ? this._doGet(pathFinal) : this.option;
+        parentModel = parentModel || this.parentModel && this.parentModel.getModel(this.resolveParentPath(pathFinal));
+        return new Model(obj, parentModel, this.ecModel);
+      };
+      /**
+       * Squash option stack into one.
+       * parentModel will be removed after squashed.
+       *
+       * NOTE: resolveParentPath will not be applied here for simplicity. DON'T use this function
+       * if resolveParentPath is modified.
+       *
+       * @param deepMerge If do deep merge. Default to be false.
+       */
+      // squash(
+      //     deepMerge?: boolean,
+      //     handleCallback?: (func: () => object) => object
+      // ) {
+      //     const optionStack = [];
+      //     let model: Model = this;
+      //     while (model) {
+      //         if (model.option) {
+      //             optionStack.push(model.option);
+      //         }
+      //         model = model.parentModel;
+      //     }
+      //     const newOption = {} as Opt;
+      //     let option;
+      //     while (option = optionStack.pop()) {    // Top down merge
+      //         if (isFunction(option) && handleCallback) {
+      //             option = handleCallback(option);
+      //         }
+      //         if (deepMerge) {
+      //             merge(newOption, option);
+      //         }
+      //         else {
+      //             extend(newOption, option);
+      //         }
+      //     }
+      //     // Remove parentModel
+      //     this.option = newOption;
+      //     this.parentModel = null;
+      // }
+
+      /**
+       * If model has option
+       */
+
+
+      Model.prototype.isEmpty = function () {
+        return this.option == null;
+      };
+
+      Model.prototype.restoreData = function () {}; // Pending
+
+
+      Model.prototype.clone = function () {
+        var Ctor = this.constructor;
+        return new Ctor(clone(this.option));
+      }; // setReadOnly(properties): void {
+      // clazzUtil.setReadOnly(this, properties);
+      // }
+      // If path is null/undefined, return null/undefined.
+
+
+      Model.prototype.parsePath = function (path) {
+        if (typeof path === 'string') {
+          return path.split('.');
+        }
+
+        return path;
+      }; // Resolve path for parent. Perhaps useful when parent use a different property.
+      // Default to be a identity resolver.
+      // Can be modified to a different resolver.
+
+
+      Model.prototype.resolveParentPath = function (path) {
+        return path;
+      }; // FIXME:TS check whether put this method here
+
+
+      Model.prototype.isAnimationEnabled = function () {
+        if (!env.node && this.option) {
+          if (this.option.animation != null) {
+            return !!this.option.animation;
+          } else if (this.parentModel) {
+            return this.parentModel.isAnimationEnabled();
+          }
+        }
+      };
+
+      Model.prototype._doGet = function (pathArr, parentModel) {
+        var obj = this.option;
+
+        if (!pathArr) {
+          return obj;
+        }
+
+        for (var i = 0; i < pathArr.length; i++) {
+          // Ignore empty
+          if (!pathArr[i]) {
+            continue;
+          } // obj could be number/string/... (like 0)
+
+
+          obj = obj && typeof obj === 'object' ? obj[pathArr[i]] : null;
+
+          if (obj == null) {
+            break;
+          }
+        }
+
+        if (obj == null && parentModel) {
+          obj = parentModel._doGet(this.resolveParentPath(pathArr), parentModel.parentModel);
+        }
+
+        return obj;
+      };
+
+      return Model;
+    }();
+
+    enableClassExtend(Model);
+    enableClassCheck(Model);
+    mixin(Model, LineStyleMixin);
+    mixin(Model, ItemStyleMixin);
+    mixin(Model, AreaStyleMixin);
+    mixin(Model, TextStyleMixin);
+
+    var base = Math.round(Math.random() * 10);
+    /**
+     * @public
+     * @param {string} type
+     * @return {string}
+     */
+
+    function getUID(type) {
+      // Considering the case of crossing js context,
+      // use Math.random to make id as unique as possible.
+      return [type || '', base++].join('_');
+    }
+    /**
+     * Implements `SubTypeDefaulterManager` for `target`.
+     */
+
+    function enableSubTypeDefaulter(target) {
+      var subTypeDefaulters = {};
+
+      target.registerSubTypeDefaulter = function (componentType, defaulter) {
+        var componentTypeInfo = parseClassType(componentType);
+        subTypeDefaulters[componentTypeInfo.main] = defaulter;
+      };
+
+      target.determineSubType = function (componentType, option) {
+        var type = option.type;
+
+        if (!type) {
+          var componentTypeMain = parseClassType(componentType).main;
+
+          if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) {
+            type = subTypeDefaulters[componentTypeMain](option);
+          }
+        }
+
+        return type;
+      };
+    }
+    /**
+     * Implements `TopologicalTravelable<any>` for `entity`.
+     *
+     * Topological travel on Activity Network (Activity On Vertices).
+     * Dependencies is defined in Model.prototype.dependencies, like ['xAxis', 'yAxis'].
+     * If 'xAxis' or 'yAxis' is absent in componentTypeList, just ignore it in topology.
+     * If there is circle dependencey, Error will be thrown.
+     */
+
+    function enableTopologicalTravel(entity, dependencyGetter) {
+      /**
+       * @param targetNameList Target Component type list.
+       *                       Can be ['aa', 'bb', 'aa.xx']
+       * @param fullNameList By which we can build dependency graph.
+       * @param callback Params: componentType, dependencies.
+       * @param context Scope of callback.
+       */
+      entity.topologicalTravel = function (targetNameList, fullNameList, callback, context) {
+        if (!targetNameList.length) {
+          return;
+        }
+
+        var result = makeDepndencyGraph(fullNameList);
+        var graph = result.graph;
+        var noEntryList = result.noEntryList;
+        var targetNameSet = {};
+        each(targetNameList, function (name) {
+          targetNameSet[name] = true;
+        });
+
+        while (noEntryList.length) {
+          var currComponentType = noEntryList.pop();
+          var currVertex = graph[currComponentType];
+          var isInTargetNameSet = !!targetNameSet[currComponentType];
+
+          if (isInTargetNameSet) {
+            callback.call(context, currComponentType, currVertex.originalDeps.slice());
+            delete targetNameSet[currComponentType];
+          }
+
+          each(currVertex.successor, isInTargetNameSet ? removeEdgeAndAdd : removeEdge);
+        }
+
+        each(targetNameSet, function () {
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            errMsg = makePrintable('Circle dependency may exists: ', targetNameSet, targetNameList, fullNameList);
+          }
+
+          throw new Error(errMsg);
+        });
+
+        function removeEdge(succComponentType) {
+          graph[succComponentType].entryCount--;
+
+          if (graph[succComponentType].entryCount === 0) {
+            noEntryList.push(succComponentType);
+          }
+        } // Consider this case: legend depends on series, and we call
+        // chart.setOption({series: [...]}), where only series is in option.
+        // If we do not have 'removeEdgeAndAdd', legendModel.mergeOption will
+        // not be called, but only sereis.mergeOption is called. Thus legend
+        // have no chance to update its local record about series (like which
+        // name of series is available in legend).
+
+
+        function removeEdgeAndAdd(succComponentType) {
+          targetNameSet[succComponentType] = true;
+          removeEdge(succComponentType);
+        }
+      };
+
+      function makeDepndencyGraph(fullNameList) {
+        var graph = {};
+        var noEntryList = [];
+        each(fullNameList, function (name) {
+          var thisItem = createDependencyGraphItem(graph, name);
+          var originalDeps = thisItem.originalDeps = dependencyGetter(name);
+          var availableDeps = getAvailableDependencies(originalDeps, fullNameList);
+          thisItem.entryCount = availableDeps.length;
+
+          if (thisItem.entryCount === 0) {
+            noEntryList.push(name);
+          }
+
+          each(availableDeps, function (dependentName) {
+            if (indexOf(thisItem.predecessor, dependentName) < 0) {
+              thisItem.predecessor.push(dependentName);
+            }
+
+            var thatItem = createDependencyGraphItem(graph, dependentName);
+
+            if (indexOf(thatItem.successor, dependentName) < 0) {
+              thatItem.successor.push(name);
+            }
+          });
+        });
+        return {
+          graph: graph,
+          noEntryList: noEntryList
+        };
+      }
+
+      function createDependencyGraphItem(graph, name) {
+        if (!graph[name]) {
+          graph[name] = {
+            predecessor: [],
+            successor: []
+          };
+        }
+
+        return graph[name];
+      }
+
+      function getAvailableDependencies(originalDeps, fullNameList) {
+        var availableDeps = [];
+        each(originalDeps, function (dep) {
+          indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep);
+        });
+        return availableDeps;
+      }
+    }
+    function inheritDefaultOption(superOption, subOption) {
+      // See also `model/Component.ts#getDefaultOption`
+      return merge(merge({}, superOption, true), subOption, true);
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * Language: English.
+     */
+    var langEN = {
+      time: {
+        month: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
+        monthAbbr: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+        dayOfWeek: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+        dayOfWeekAbbr: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+      },
+      legend: {
+        selector: {
+          all: 'All',
+          inverse: 'Inv'
+        }
+      },
+      toolbox: {
+        brush: {
+          title: {
+            rect: 'Box Select',
+            polygon: 'Lasso Select',
+            lineX: 'Horizontally Select',
+            lineY: 'Vertically Select',
+            keep: 'Keep Selections',
+            clear: 'Clear Selections'
+          }
+        },
+        dataView: {
+          title: 'Data View',
+          lang: ['Data View', 'Close', 'Refresh']
+        },
+        dataZoom: {
+          title: {
+            zoom: 'Zoom',
+            back: 'Zoom Reset'
+          }
+        },
+        magicType: {
+          title: {
+            line: 'Switch to Line Chart',
+            bar: 'Switch to Bar Chart',
+            stack: 'Stack',
+            tiled: 'Tile'
+          }
+        },
+        restore: {
+          title: 'Restore'
+        },
+        saveAsImage: {
+          title: 'Save as Image',
+          lang: ['Right Click to Save Image']
+        }
+      },
+      series: {
+        typeNames: {
+          pie: 'Pie chart',
+          bar: 'Bar chart',
+          line: 'Line chart',
+          scatter: 'Scatter plot',
+          effectScatter: 'Ripple scatter plot',
+          radar: 'Radar chart',
+          tree: 'Tree',
+          treemap: 'Treemap',
+          boxplot: 'Boxplot',
+          candlestick: 'Candlestick',
+          k: 'K line chart',
+          heatmap: 'Heat map',
+          map: 'Map',
+          parallel: 'Parallel coordinate map',
+          lines: 'Line graph',
+          graph: 'Relationship graph',
+          sankey: 'Sankey diagram',
+          funnel: 'Funnel chart',
+          gauge: 'Guage',
+          pictorialBar: 'Pictorial bar',
+          themeRiver: 'Theme River Map',
+          sunburst: 'Sunburst'
+        }
+      },
+      aria: {
+        general: {
+          withTitle: 'This is a chart about "{title}"',
+          withoutTitle: 'This is a chart'
+        },
+        series: {
+          single: {
+            prefix: '',
+            withName: ' with type {seriesType} named {seriesName}.',
+            withoutName: ' with type {seriesType}.'
+          },
+          multiple: {
+            prefix: '. It consists of {seriesCount} series count.',
+            withName: ' The {seriesId} series is a {seriesType} representing {seriesName}.',
+            withoutName: ' The {seriesId} series is a {seriesType}.',
+            separator: {
+              middle: '',
+              end: ''
+            }
+          }
+        },
+        data: {
+          allData: 'The data is as follows: ',
+          partialData: 'The first {displayCnt} items are: ',
+          withName: 'the data for {name} is {value}',
+          withoutName: '{value}',
+          separator: {
+            middle: ', ',
+            end: '. '
+          }
+        }
+      }
+    };
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+     * Licensed to the Apache Software Foundation (ASF) under one
+     * or more contributor license agreements.  See the NOTICE file
+     * distributed with this work for additional information
+     * regarding copyright ownership.  The ASF licenses this file
+     * to you under the Apache License, Version 2.0 (the
+     * "License"); you may not use this file except in compliance
+     * with the License.  You may obtain a copy of the License at
+     *
+     *   http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing,
+     * software distributed under the License is distributed on an
+     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+     * KIND, either express or implied.  See the License for the
+     * specific language governing permissions and limitations
+     * under the License.
+     */
+    var langZH = {
+      time: {
+        month: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
+        monthAbbr: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'],
+        dayOfWeek: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
+        dayOfWeekAbbr: ['日', '一', '二', '三', '四', '五', '六']
+      },
+      legend: {
+        selector: {
+          all: '全选',
+          inverse: '反选'
+        }
+      },
+      toolbox: {
+        brush: {
+          title: {
+            rect: '矩形选择',
+            polygon: '圈选',
+            lineX: '横向选择',
+            lineY: '纵向选择',
+            keep: '保持选择',
+            clear: '清除选择'
+          }
+        },
+        dataView: {
+          title: '数据视图',
+          lang: ['数据视图', '关闭', '刷新']
+        },
+        dataZoom: {
+          title: {
+            zoom: '区域缩放',
+            back: '区域缩放还原'
+          }
+        },
+        magicType: {
+          title: {
+            line: '切换为折线图',
+            bar: '切换为柱状图',
+            stack: '切换为堆叠',
+            tiled: '切换为平铺'
+          }
+        },
+        restore: {
+          title: '还原'
+        },
+        saveAsImage: {
+          title: '保存为图片',
+          lang: ['右键另存为图片']
+        }
+      },
+      series: {
+        typeNames: {
+          pie: '饼图',
+          bar: '柱状图',
+          line: '折线图',
+          scatter: '散点图',
+          effectScatter: '涟漪散点图',
+          radar: '雷达图',
+          tree: '树图',
+          treemap: '矩形树图',
+          boxplot: '箱型图',
+          candlestick: 'K线图',
+          k: 'K线图',
+          heatmap: '热力图',
+          map: '地图',
+          parallel: '平行坐标图',
+          lines: '线图',
+          graph: '关系图',
+          sankey: '桑基图',
+          funnel: '漏斗图',
+          gauge: '仪表盘图',
+          pictorialBar: '象形柱图',
+          themeRiver: '主题河流图',
+          sunburst: '旭日图'
+        }
+      },
+      aria: {
+        general: {
+          withTitle: '这是一个关于“{title}”的图表。',
+          withoutTitle: '这是一个图表，'
+        },
+        series: {
+          single: {
+            prefix: '',
+            withName: '图表类型是{seriesType}，表示{seriesName}。',
+            withoutName: '图表类型是{seriesType}。'
+          },
+          multiple: {
+            prefix: '它由{seriesCount}个图表系列组成。',
+            withName: '第{seriesId}个系列是一个表示{seriesName}的{seriesType}，',
+            withoutName: '第{seriesId}个系列是一个{seriesType}，',
+            separator: {
+              middle: '；',
+              end: '。'
+            }
+          }
+        },
+        data: {
+          allData: '其数据是——',
+          partialData: '其中，前{displayCnt}项是——',
+          withName: '{name}的数据是{value}',
+          withoutName: '{value}',
+          separator: {
+            middle: '，',
+            end: ''
+          }
+        }
+      }
+    };
+
+    var LOCALE_ZH = 'ZH';
+    var LOCALE_EN = 'EN';
+    var DEFAULT_LOCALE = LOCALE_EN;
+    var localeStorage = {};
+    var localeModels = {};
+    var SYSTEM_LANG = !env.domSupported ? DEFAULT_LOCALE : function () {
+      var langStr = (
+      /* eslint-disable-next-line */
+      document.documentElement.lang || navigator.language || navigator.browserLanguage).toUpperCase();
+      return langStr.indexOf(LOCALE_ZH) > -1 ? LOCALE_ZH : DEFAULT_LOCALE;
+    }();
+    function registerLocale(locale, localeObj) {
+      locale = locale.toUpperCase();
+      localeModels[locale] = new Model(localeObj);
+      localeStorage[locale] = localeObj;
+    } // export function getLocale(locale: string) {
+    //     return localeStorage[locale];
+    // }
+
+    function createLocaleObject(locale) {
+      if (isString(locale)) {
+        var localeObj = localeStorage[locale.toUpperCase()] || {};
+
+        if (locale === LOCALE_ZH || locale === LOCALE_EN) {
+          return clone(localeObj);
+        } else {
+          return merge(clone(localeObj), clone(localeStorage[DEFAULT_LOCALE]), false);
+        }
+      } else {
+        return merge(clone(locale), clone(localeStorage[DEFAULT_LOCALE]), false);
+      }
+    }
+    function getLocaleModel(lang) {
+      return localeModels[lang];
+    }
+    function getDefaultLocaleModel() {
+      return localeModels[DEFAULT_LOCALE];
+    } // Default locale
+
+    registerLocale(LOCALE_EN, langEN);
+    registerLocale(LOCALE_ZH, langZH);
+
+    var ONE_SECOND = 1000;
+    var ONE_MINUTE = ONE_SECOND * 60;
+    var ONE_HOUR = ONE_MINUTE * 60;
+    var ONE_DAY = ONE_HOUR * 24;
+    var ONE_YEAR = ONE_DAY * 365;
+    var defaultLeveledFormatter = {
+      year: '{yyyy}',
+      month: '{MMM}',
+      day: '{d}',
+      hour: '{HH}:{mm}',
+      minute: '{HH}:{mm}',
+      second: '{HH}:{mm}:{ss}',
+      millisecond: '{hh}:{mm}:{ss} {SSS}',
+      none: '{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}'
+    };
+    var fullDayFormatter = '{yyyy}-{MM}-{dd}';
+    var fullLeveledFormatter = {
+      year: '{yyyy}',
+      month: '{yyyy}-{MM}',
+      day: fullDayFormatter,
+      hour: fullDayFormatter + ' ' + defaultLeveledFormatter.hour,
+      minute: fullDayFormatter + ' ' + defaultLeveledFormatter.minute,
+      second: fullDayFormatter + ' ' + defaultLeveledFormatter.second,
+      millisecond: defaultLeveledFormatter.none
+    };
+    var primaryTimeUnits = ['year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond'];
+    var timeUnits = ['year', 'half-year', 'quarter', 'month', 'week', 'half-week', 'day', 'half-day', 'quarter-day', 'hour', 'minute', 'second', 'millisecond'];
+    function pad(str, len) {
+      str += '';
+      return '0000'.substr(0, len - str.length) + str;
+    }
+    function getPrimaryTimeUnit(timeUnit) {
+      switch (timeUnit) {
+        case 'half-year':
+        case 'quarter':
+          return 'month';
+
+        case 'week':
+        case 'half-week':
+          return 'day';
+
+        case 'half-day':
+        case 'quarter-day':
+          return 'hour';
+
+        default:
+          // year, minutes, second, milliseconds
+          return timeUnit;
+      }
+    }
+    function isPrimaryTimeUnit(timeUnit) {
+      return timeUnit === getPrimaryTimeUnit(timeUnit);
+    }
+    function getDefaultFormatPrecisionOfInterval(timeUnit) {
+      switch (timeUnit) {
+        case 'year':
+        case 'month':
+          return 'day';
+
+        case 'millisecond':
+          return 'millisecond';
+
+        default:
+          // Also for day, hour, minute, second
+          return 'second';
+      }
+    }
+    function format( // Note: The result based on `isUTC` are totally different, which can not be just simply
+    // substituted by the result without `isUTC`. So we make the param `isUTC` mandatory.
+    time, template, isUTC, lang) {
+      var date = parseDate(time);
+      var y = date[fullYearGetterName(isUTC)]();
+      var M = date[monthGetterName(isUTC)]() + 1;
+      var q = Math.floor((M - 1) / 4) + 1;
+      var d = date[dateGetterName(isUTC)]();
+      var e = date['get' + (isUTC ? 'UTC' : '') + 'Day']();
+      var H = date[hoursGetterName(isUTC)]();
+      var h = (H - 1) % 12 + 1;
+      var m = date[minutesGetterName(isUTC)]();
+      var s = date[secondsGetterName(isUTC)]();
+      var S = date[millisecondsGetterName(isUTC)]();
+      var localeModel = lang instanceof Model ? lang : getLocaleModel(lang || SYSTEM_LANG) || getDefaultLocaleModel();
+      var timeModel = localeModel.getModel('time');
+      var month = timeModel.get('month');
+      var monthAbbr = timeModel.get('monthAbbr');
+      var dayOfWeek = timeModel.get('dayOfWeek');
+      var dayOfWeekAbbr = timeModel.get('dayOfWeekAbbr');
+      return (template || '').replace(/{yyyy}/g, y + '').replace(/{yy}/g, y % 100 + '').replace(/{Q}/g, q + '').replace(/{MMMM}/g, month[M - 1]).replace(/{MMM}/g, monthAbbr[M - 1]).replace(/{MM}/g, pad(M, 2)).replace(/{M}/g, M + '').replace(/{dd}/g, pad(d, 2)).replace(/{d}/g, d + '').replace(/{eeee}/g, dayOfWeek[e]).replace(/{ee}/g, dayOfWeekAbbr[e]).replace(/{e}/g, e + '').replace(/{HH}/g, pad(H, 2)).replace(/{H}/g, H + '').replace(/{hh}/g, pad(h + '', 2)).replace(/{h}/g, h + '').replace(/{mm}/g, pad(m, 2)).replace(/{m}/g, m + '').replace(/{ss}/g, pad(s, 2)).replace(/{s}/g, s + '').replace(/{SSS}/g, pad(S, 3)).replace(/{S}/g, S + '');
+    }
+    function leveledFormat(tick, idx, formatter, lang, isUTC) {
+      var template = null;
+
+      if (typeof formatter === 'string') {
+        // Single formatter for all units at all levels
+        template = formatter;
+      } else if (typeof formatter === 'function') {
+        // Callback formatter
+        template = formatter(tick.value, idx, {
+          level: tick.level
+        });
+      } else {
+        var defaults$1 = extend({}, defaultLeveledFormatter);
+
+        if (tick.level > 0) {
+          for (var i = 0; i < primaryTimeUnits.length; ++i) {
+            defaults$1[primaryTimeUnits[i]] = "{primary|" + defaults$1[primaryTimeUnits[i]] + "}";
+          }
+        }
+
+        var mergedFormatter = formatter ? formatter.inherit === false ? formatter // Use formatter with bigger units
+        : defaults(formatter, defaults$1) : defaults$1;
+        var unit = getUnitFromValue(tick.value, isUTC);
+
+        if (mergedFormatter[unit]) {
+          template = mergedFormatter[unit];
+        } else if (mergedFormatter.inherit) {
+          // Unit formatter is not defined and should inherit from bigger units
+          var targetId = timeUnits.indexOf(unit);
+
+          for (var i = targetId - 1; i >= 0; --i) {
+            if (mergedFormatter[unit]) {
+              template = mergedFormatter[unit];
+              break;
+            }
+          }
+
+          template = template || defaults$1.none;
+        }
+
+        if (isArray(template)) {
+          var levelId = tick.level == null ? 0 : tick.level >= 0 ? tick.level : template.length + tick.level;
+          levelId = Math.min(levelId, template.length - 1);
+          template = template[levelId];
+        }
+      }
+
+      return format(new Date(tick.value), template, isUTC, lang);
+    }
+    function getUnitFromValue(value, isUTC) {
+      var date = parseDate(value);
+      var M = date[monthGetterName(isUTC)]() + 1;
+      var d = date[dateGetterName(isUTC)]();
+      var h = date[hoursGetterName(isUTC)]();
+      var m = date[minutesGetterName(isUTC)]();
+      var s = date[secondsGetterName(isUTC)]();
+      var S = date[millisecondsGetterName(isUTC)]();
+      var isSecond = S === 0;
+      var isMinute = isSecond && s === 0;
+      var isHour = isMinute && m === 0;
+      var isDay = isHour && h === 0;
+      var isMonth = isDay && d === 1;
+      var isYear = isMonth && M === 1;
+
+      if (isYear) {
+        return 'year';
+      } else if (isMonth) {
+        return 'month';
+      } else if (isDay) {
+        return 'day';
+      } else if (isHour) {
+        return 'hour';
+      } else if (isMinute) {
+        return 'minute';
+      } else if (isSecond) {
+        return 'second';
+      } else {
+        return 'millisecond';
+      }
+    }
+    function getUnitValue(value, unit, isUTC) {
+      var date = typeof value === 'number' ? parseDate(value) : value;
+      unit = unit || getUnitFromValue(value, isUTC);
+
+      switch (unit) {
+        case 'year':
+          return date[fullYearGetterName(isUTC)]();
+
+        case 'half-year':
+          return date[monthGetterName(isUTC)]() >= 6 ? 1 : 0;
+
+        case 'quarter':
+          return Math.floor((date[monthGetterName(isUTC)]() + 1) / 4);
+
+        case 'month':
+          return date[monthGetterName(isUTC)]();
+
+        case 'day':
+          return date[dateGetterName(isUTC)]();
+
+        case 'half-day':
+          return date[hoursGetterName(isUTC)]() / 24;
+
+        case 'hour':
+          return date[hoursGetterName(isUTC)]();
+
+        case 'minute':
+          return date[minutesGetterName(isUTC)]();
+
+        case 'second':
+          return date[secondsGetterName(isUTC)]();
+
+        case 'millisecond':
+          return date[millisecondsGetterName(isUTC)]();
+      }
+    }
+    function fullYearGetterName(isUTC) {
+      return isUTC ? 'getUTCFullYear' : 'getFullYear';
+    }
+    function monthGetterName(isUTC) {
+      return isUTC ? 'getUTCMonth' : 'getMonth';
+    }
+    function dateGetterName(isUTC) {
+      return isUTC ? 'getUTCDate' : 'getDate';
+    }
+    function hoursGetterName(isUTC) {
+      return isUTC ? 'getUTCHours' : 'getHours';
+    }
+    function minutesGetterName(isUTC) {
+      return isUTC ? 'getUTCMinutes' : 'getMinutes';
+    }
+    function secondsGetterName(isUTC) {
+      return isUTC ? 'getUTCSeconds' : 'getSeconds';
+    }
+    function millisecondsGetterName(isUTC) {
+      return isUTC ? 'getUTCSeconds' : 'getSeconds';
+    }
+    function fullYearSetterName(isUTC) {
+      return isUTC ? 'setUTCFullYear' : 'setFullYear';
+    }
+    function monthSetterName(isUTC) {
+      return isUTC ? 'setUTCMonth' : 'setMonth';
+    }
+    function dateSetterName(isUTC) {
+      return isUTC ? 'setUTCDate' : 'setDate';
+    }
+    function hoursSetterName(isUTC) {
+      return isUTC ? 'setUTCHours' : 'setHours';
+    }
+    function minutesSetterName(isUTC) {
+      return isUTC ? 'setUTCMinutes' : 'setMinutes';
+    }
+    function secondsSetterName(isUTC) {
+      return isUTC ? 'setUTCSeconds' : 'setSeconds';
+    }
+    function millisecondsSetterName(isUTC) {
+      return isUTC ? 'setUTCSeconds' : 'setSeconds';
+    }
+
+    function getTextRect(text, font, align, verticalAlign, padding, rich, truncate, lineHeight) {
+      deprecateLog('getTextRect is deprecated.');
+      var textEl = new ZRText({
+        style: {
+          text: text,
+          font: font,
+          align: align,
+          verticalAlign: verticalAlign,
+          padding: padding,
+          rich: rich,
+          overflow: truncate ? 'truncate' : null,
+          lineHeight: lineHeight
+        }
+      });
+      return textEl.getBoundingRect();
+    }
+
+    /**
+     * Add a comma each three digit.
+     */
+
+    function addCommas(x) {
+      if (!isNumeric(x)) {
+        return isString(x) ? x : '-';
+      }
+
+      var parts = (x + '').split('.');
+      return parts[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, '$1,') + (parts.length > 1 ? '.' + parts[1] : '');
+    }
+    function toCamelCase(str, upperCaseFirst) {
+      str = (str || '').toLowerCase().replace(/-(.)/g, function (match, group1) {
+        return group1.toUpperCase();
+      });
+
+      if (upperCaseFirst && str) {
+        str = str.charAt(0).toUpperCase() + str.slice(1);
+      }
+
+      return str;
+    }
+    var normalizeCssArray$1 = normalizeCssArray;
+    var replaceReg = /([&<>"'])/g;
+    var replaceMap = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '\'': '&#39;'
+    };
+    function encodeHTML(source) {
+      return source == null ? '' : (source + '').replace(replaceReg, function (str, c) {
+        return replaceMap[c];
+      });
+    }
+    /**
+     * Make value user readable for tooltip and label.
+     * "User readable":
+     *     Try to not print programmer-specific text like NaN, Infinity, null, undefined.
+     *     Avoid to display an empty string, which users can not recognize there is
+     *     a value and it might look like a bug.
+     */
+
+    function makeValueReadable(value, valueType, useUTC) {
+      var USER_READABLE_DEFUALT_TIME_PATTERN = 'yyyy-MM-dd hh:mm:ss';
+
+      function stringToUserReadable(str) {
+        return str && trim(str) ? str : '-';
+      }
+
+      function isNumberUserReadable(num) {
+        return !!(num != null && !isNaN(num) && isFinite(num));
+      }
+
+      var isTypeTime = valueType === 'time';
+      var isValueDate = value instanceof Date;
+
+      if (isTypeTime || isValueDate) {
+        var date = isTypeTime ? parseDate(value) : value;
+
+        if (!isNaN(+date)) {
+          return format(date, USER_READABLE_DEFUALT_TIME_PATTERN, useUTC);
+        } else if (isValueDate) {
+          return '-';
+        } // In other cases, continue to try to display the value in the following code.
+
+      }
+
+      if (valueType === 'ordinal') {
+        return isStringSafe(value) ? stringToUserReadable(value) : isNumber(value) ? isNumberUserReadable(value) ? value + '' : '-' : '-';
+      } // By default.
+
+
+      var numericResult = numericToNumber(value);
+      return isNumberUserReadable(numericResult) ? addCommas(numericResult) : isStringSafe(value) ? stringToUserReadable(value) : '-';
+    }
+    var TPL_VAR_ALIAS = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
+
+    var wrapVar = function (varName, seriesIdx) {
+      return '{' + varName + (seriesIdx == null ? '' : seriesIdx) + '}';
+    };
+    /**
+     * Template formatter
+     * @param {Array.<Object>|Object} paramsList
+     */
+
+
+    function formatTpl(tpl, paramsList, encode) {
+      if (!isArray(paramsList)) {
+        paramsList = [paramsList];
+      }
+
+      var seriesLen = paramsList.length;
+
+      if (!seriesLen) {
+        return '';
+      }
+
+      var $vars = paramsList[0].$vars || [];
+
+      for (var i = 0; i < $vars.length; i++) {
+        var alias = TPL_VAR_ALIAS[i];
+        tpl = tpl.replace(wrapVar(alias), wrapVar(alias, 0));
+      }
+
+      for (var seriesIdx = 0; seriesIdx < seriesLen; seriesIdx++) {
+        for (var k = 0; k < $vars.length; k++) {
+          var val = paramsList[seriesIdx][$vars[k]];
+          tpl = tpl.replace(wrapVar(TPL_VAR_ALIAS[k], seriesIdx), encode ? encodeHTML(val) : val);
+        }
+      }
+
+      return tpl;
+    }
+    /**
+     * simple Template formatter
+     */
+
+    function formatTplSimple(tpl, param, encode) {
+      each(param, function (value, key) {
+        tpl = tpl.replace('{' + key + '}', encode ? encodeHTML(value) : value);
+      });
+      return tpl;
+    }
+    function getTooltipMarker(inOpt, extraCssText) {
+      var opt = isString(inOpt) ? {
+        color: inOpt,
+        extraCssText: extraCssText
+      } : inOpt || {};
+      var color = opt.color;
+      var type = opt.type;
+      extraCssText = opt.extraCssText;
+      var renderMode = opt.renderMode || 'html';
+
+      if (!color) {
+        return '';
+      }
+
+      if (renderMode === 'html') {
+        return type === 'subItem' ? '<span style="display:inline-block;vertical-align:middle;margin-right:8px;margin-left:3px;' + 'border-radius:4px;width:4px;height:4px;background-color:' // Only support string
+        + encodeHTML(color) + ';' + (extraCssText || '') + '"></span>' : '<span style="display:inline-block;margin-right:4px;' + 'border-radius:10px;width:10px;height:10px;background-color:' + encodeHTML(color) + ';' + (extraCssText || '') + '"></span>';
+      } else {
+        // Should better not to auto generate style name by auto-increment number here.
+        // Because this util is usually called in tooltip formatter, which is probably
+        // called repeatly when mouse move and the auto-increment number increases fast.
+        // Users can make their own style name by theirselves, make it unique and readable.
+        var markerId = opt.markerId || 'markerX';
+        return {
+          renderMode: renderMode,
+          content: '{' + markerId + '|}  ',
+          style: type === 'subItem' ? {
+            width: 4,
+            height: 4,
+            borderRadius: 2,
+            backgroundColor: color
+          } : {
+            width: 10,
+            height: 10,
+            borderRadius: 5,
+            backgroundColor: color
+          }
+        };
+      }
+    }
+    /**
+     * @deprecated Use `time/format` instead.
+     * ISO Date format
+     * @param {string} tpl
+     * @param {number} value
+     * @param {boolean} [isUTC=false] Default in local time.
+     *           see `module:echarts/scale/Time`
+     *           and `module:echarts/util/number#parseDate`.
+     * @inner
+     */
+
+    function formatTime(tpl, value, isUTC) {
+      if ("development" !== 'production') {
+        deprecateReplaceLog('echarts.format.formatTime', 'echarts.time.format');
+      }
+
+      if (tpl === 'week' || tpl === 'month' || tpl === 'quarter' || tpl === 'half-year' || tpl === 'year') {
+        tpl = 'MM-dd\nyyyy';
+      }
+
+      var date = parseDate(value);
+      var utc = isUTC ? 'UTC' : '';
+      var y = date['get' + utc + 'FullYear']();
+      var M = date['get' + utc + 'Month']() + 1;
+      var d = date['get' + utc + 'Date']();
+      var h = date['get' + utc + 'Hours']();
+      var m = date['get' + utc + 'Minutes']();
+      var s = date['get' + utc + 'Seconds']();
+      var S = date['get' + utc + 'Milliseconds']();
+      tpl = tpl.replace('MM', pad(M, 2)).replace('M', M).replace('yyyy', y).replace('yy', y % 100 + '').replace('dd', pad(d, 2)).replace('d', d).replace('hh', pad(h, 2)).replace('h', h).replace('mm', pad(m, 2)).replace('m', m).replace('ss', pad(s, 2)).replace('s', s).replace('SSS', pad(S, 3));
+      return tpl;
+    }
+    /**
+     * Capital first
+     * @param {string} str
+     * @return {string}
+     */
+
+    function capitalFirst(str) {
+      return str ? str.charAt(0).toUpperCase() + str.substr(1) : str;
+    }
+    /**
+     * @return Never be null/undefined.
+     */
+
+    function convertToColorString(color, defaultColor) {
+      defaultColor = defaultColor || 'transparent';
+      return isString(color) ? color : isObject(color) ? color.colorStops && (color.colorStops[0] || {}).color || defaultColor : defaultColor;
+    }
+    /**
+     * open new tab
+     * @param link url
+     * @param target blank or self
+     */
+
+    function windowOpen(link, target) {
+      /* global window */
+      if (target === '_blank' || target === 'blank') {
+        var blank = window.open();
+        blank.opener = null;
+        blank.location.href = link;
+      } else {
+        window.open(link, target);
+      }
+    }
+
+    var each$1 = each;
+    /**
+     * @public
+     */
+
+    var LOCATION_PARAMS = ['left', 'right', 'top', 'bottom', 'width', 'height'];
+    /**
+     * @public
+     */
+
+    var HV_NAMES = [['width', 'left', 'right'], ['height', 'top', 'bottom']];
+
+    function boxLayout(orient, group, gap, maxWidth, maxHeight) {
+      var x = 0;
+      var y = 0;
+
+      if (maxWidth == null) {
+        maxWidth = Infinity;
+      }
+
+      if (maxHeight == null) {
+        maxHeight = Infinity;
+      }
+
+      var currentLineMaxSize = 0;
+      group.eachChild(function (child, idx) {
+        var rect = child.getBoundingRect();
+        var nextChild = group.childAt(idx + 1);
+        var nextChildRect = nextChild && nextChild.getBoundingRect();
+        var nextX;
+        var nextY;
+
+        if (orient === 'horizontal') {
+          var moveX = rect.width + (nextChildRect ? -nextChildRect.x + rect.x : 0);
+          nextX = x + moveX; // Wrap when width exceeds maxWidth or meet a `newline` group
+          // FIXME compare before adding gap?
+
+          if (nextX > maxWidth || child.newline) {
+            x = 0;
+            nextX = moveX;
+            y += currentLineMaxSize + gap;
+            currentLineMaxSize = rect.height;
+          } else {
+            // FIXME: consider rect.y is not `0`?
+            currentLineMaxSize = Math.max(currentLineMaxSize, rect.height);
+          }
+        } else {
+          var moveY = rect.height + (nextChildRect ? -nextChildRect.y + rect.y : 0);
+          nextY = y + moveY; // Wrap when width exceeds maxHeight or meet a `newline` group
+
+          if (nextY > maxHeight || child.newline) {
+            x += currentLineMaxSize + gap;
+            y = 0;
+            nextY = moveY;
+            currentLineMaxSize = rect.width;
+          } else {
+            currentLineMaxSize = Math.max(currentLineMaxSize, rect.width);
+          }
+        }
+
+        if (child.newline) {
+          return;
+        }
+
+        child.x = x;
+        child.y = y;
+        child.markRedraw();
+        orient === 'horizontal' ? x = nextX + gap : y = nextY + gap;
+      });
+    }
+    /**
+     * VBox or HBox layouting
+     * @param {string} orient
+     * @param {module:zrender/graphic/Group} group
+     * @param {number} gap
+     * @param {number} [width=Infinity]
+     * @param {number} [height=Infinity]
+     */
+
+
+    var box = boxLayout;
+    /**
+     * VBox layouting
+     * @param {module:zrender/graphic/Group} group
+     * @param {number} gap
+     * @param {number} [width=Infinity]
+     * @param {number} [height=Infinity]
+     */
+
+    var vbox = curry(boxLayout, 'vertical');
+    /**
+     * HBox layouting
+     * @param {module:zrender/graphic/Group} group
+     * @param {number} gap
+     * @param {number} [width=Infinity]
+     * @param {number} [height=Infinity]
+     */
+
+    var hbox = curry(boxLayout, 'horizontal');
+    /**
+     * If x or x2 is not specified or 'center' 'left' 'right',
+     * the width would be as long as possible.
+     * If y or y2 is not specified or 'middle' 'top' 'bottom',
+     * the height would be as long as possible.
+     */
+
+    function getAvailableSize(positionInfo, containerRect, margin) {
+      var containerWidth = containerRect.width;
+      var containerHeight = containerRect.height;
+      var x = parsePercent$1(positionInfo.left, containerWidth);
+      var y = parsePercent$1(positionInfo.top, containerHeight);
+      var x2 = parsePercent$1(positionInfo.right, containerWidth);
+      var y2 = parsePercent$1(positionInfo.bottom, containerHeight);
+      (isNaN(x) || isNaN(parseFloat(positionInfo.left))) && (x = 0);
+      (isNaN(x2) || isNaN(parseFloat(positionInfo.right))) && (x2 = containerWidth);
+      (isNaN(y) || isNaN(parseFloat(positionInfo.top))) && (y = 0);
+      (isNaN(y2) || isNaN(parseFloat(positionInfo.bottom))) && (y2 = containerHeight);
+      margin = normalizeCssArray$1(margin || 0);
+      return {
+        width: Math.max(x2 - x - margin[1] - margin[3], 0),
+        height: Math.max(y2 - y - margin[0] - margin[2], 0)
+      };
+    }
+    /**
+     * Parse position info.
+     */
+
+    function getLayoutRect(positionInfo, containerRect, margin) {
+      margin = normalizeCssArray$1(margin || 0);
+      var containerWidth = containerRect.width;
+      var containerHeight = containerRect.height;
+      var left = parsePercent$1(positionInfo.left, containerWidth);
+      var top = parsePercent$1(positionInfo.top, containerHeight);
+      var right = parsePercent$1(positionInfo.right, containerWidth);
+      var bottom = parsePercent$1(positionInfo.bottom, containerHeight);
+      var width = parsePercent$1(positionInfo.width, containerWidth);
+      var height = parsePercent$1(positionInfo.height, containerHeight);
+      var verticalMargin = margin[2] + margin[0];
+      var horizontalMargin = margin[1] + margin[3];
+      var aspect = positionInfo.aspect; // If width is not specified, calculate width from left and right
+
+      if (isNaN(width)) {
+        width = containerWidth - right - horizontalMargin - left;
+      }
+
+      if (isNaN(height)) {
+        height = containerHeight - bottom - verticalMargin - top;
+      }
+
+      if (aspect != null) {
+        // If width and height are not given
+        // 1. Graph should not exceeds the container
+        // 2. Aspect must be keeped
+        // 3. Graph should take the space as more as possible
+        // FIXME
+        // Margin is not considered, because there is no case that both
+        // using margin and aspect so far.
+        if (isNaN(width) && isNaN(height)) {
+          if (aspect > containerWidth / containerHeight) {
+            width = containerWidth * 0.8;
+          } else {
+            height = containerHeight * 0.8;
+          }
+        } // Calculate width or height with given aspect
+
+
+        if (isNaN(width)) {
+          width = aspect * height;
+        }
+
+        if (isNaN(height)) {
+          height = width / aspect;
+        }
+      } // If left is not specified, calculate left from right and width
+
+
+      if (isNaN(left)) {
+        left = containerWidth - right - width - horizontalMargin;
+      }
+
+      if (isNaN(top)) {
+        top = containerHeight - bottom - height - verticalMargin;
+      } // Align left and top
+
+
+      switch (positionInfo.left || positionInfo.right) {
+        case 'center':
+          left = containerWidth / 2 - width / 2 - margin[3];
+          break;
+
+        case 'right':
+          left = containerWidth - width - horizontalMargin;
+          break;
+      }
+
+      switch (positionInfo.top || positionInfo.bottom) {
+        case 'middle':
+        case 'center':
+          top = containerHeight / 2 - height / 2 - margin[0];
+          break;
+
+        case 'bottom':
+          top = containerHeight - height - verticalMargin;
+          break;
+      } // If something is wrong and left, top, width, height are calculated as NaN
+
+
+      left = left || 0;
+      top = top || 0;
+
+      if (isNaN(width)) {
+        // Width may be NaN if only one value is given except width
+        width = containerWidth - horizontalMargin - left - (right || 0);
+      }
+
+      if (isNaN(height)) {
+        // Height may be NaN if only one value is given except height
+        height = containerHeight - verticalMargin - top - (bottom || 0);
+      }
+
+      var rect = new BoundingRect(left + margin[3], top + margin[0], width, height);
+      rect.margin = margin;
+      return rect;
+    }
+    /**
+     * Position a zr element in viewport
+     *  Group position is specified by either
+     *  {left, top}, {right, bottom}
+     *  If all properties exists, right and bottom will be igonred.
+     *
+     * Logic:
+     *     1. Scale (against origin point in parent coord)
+     *     2. Rotate (against origin point in parent coord)
+     *     3. Traslate (with el.position by this method)
+     * So this method only fixes the last step 'Traslate', which does not affect
+     * scaling and rotating.
+     *
+     * If be called repeatly with the same input el, the same result will be gotten.
+     *
+     * @param el Should have `getBoundingRect` method.
+     * @param positionInfo
+     * @param positionInfo.left
+     * @param positionInfo.top
+     * @param positionInfo.right
+     * @param positionInfo.bottom
+     * @param positionInfo.width Only for opt.boundingModel: 'raw'
+     * @param positionInfo.height Only for opt.boundingModel: 'raw'
+     * @param containerRect
+     * @param margin
+     * @param opt
+     * @param opt.hv Only horizontal or only vertical. Default to be [1, 1]
+     * @param opt.boundingMode
+     *        Specify how to calculate boundingRect when locating.
+     *        'all': Position the boundingRect that is transformed and uioned
+     *               both itself and its descendants.
+     *               This mode simplies confine the elements in the bounding
+     *               of their container (e.g., using 'right: 0').
+     *        'raw': Position the boundingRect that is not transformed and only itself.
+     *               This mode is useful when you want a element can overflow its
+     *               container. (Consider a rotated circle needs to be located in a corner.)
+     *               In this mode positionInfo.width/height can only be number.
+     */
+
+    function positionElement(el, positionInfo, containerRect, margin, opt) {
+      var h = !opt || !opt.hv || opt.hv[0];
+      var v = !opt || !opt.hv || opt.hv[1];
+      var boundingMode = opt && opt.boundingMode || 'all';
+
+      if (!h && !v) {
+        return;
+      }
+
+      var rect;
+
+      if (boundingMode === 'raw') {
+        rect = el.type === 'group' ? new BoundingRect(0, 0, +positionInfo.width || 0, +positionInfo.height || 0) : el.getBoundingRect();
+      } else {
+        rect = el.getBoundingRect();
+
+        if (el.needLocalTransform()) {
+          var transform = el.getLocalTransform(); // Notice: raw rect may be inner object of el,
+          // which should not be modified.
+
+          rect = rect.clone();
+          rect.applyTransform(transform);
+        }
+      } // The real width and height can not be specified but calculated by the given el.
+
+
+      var layoutRect = getLayoutRect(defaults({
+        width: rect.width,
+        height: rect.height
+      }, positionInfo), containerRect, margin); // Because 'tranlate' is the last step in transform
+      // (see zrender/core/Transformable#getLocalTransform),
+      // we can just only modify el.position to get final result.
+
+      var dx = h ? layoutRect.x - rect.x : 0;
+      var dy = v ? layoutRect.y - rect.y : 0;
+
+      if (boundingMode === 'raw') {
+        el.x = dx;
+        el.y = dy;
+      } else {
+        el.x += dx;
+        el.y += dy;
+      }
+
+      el.markRedraw();
+    }
+    /**
+     * @param option Contains some of the properties in HV_NAMES.
+     * @param hvIdx 0: horizontal; 1: vertical.
+     */
+
+    function sizeCalculable(option, hvIdx) {
+      return option[HV_NAMES[hvIdx][0]] != null || option[HV_NAMES[hvIdx][1]] != null && option[HV_NAMES[hvIdx][2]] != null;
+    }
+    function fetchLayoutMode(ins) {
+      var layoutMode = ins.layoutMode || ins.constructor.layoutMode;
+      return isObject(layoutMode) ? layoutMode : layoutMode ? {
+        type: layoutMode
+      } : null;
+    }
+    /**
+     * Consider Case:
+     * When default option has {left: 0, width: 100}, and we set {right: 0}
+     * through setOption or media query, using normal zrUtil.merge will cause
+     * {right: 0} does not take effect.
+     *
+     * @example
+     * ComponentModel.extend({
+     *     init: function () {
+     *         ...
+     *         let inputPositionParams = layout.getLayoutParams(option);
+     *         this.mergeOption(inputPositionParams);
+     *     },
+     *     mergeOption: function (newOption) {
+     *         newOption && zrUtil.merge(thisOption, newOption, true);
+     *         layout.mergeLayoutParam(thisOption, newOption);
+     *     }
+     * });
+     *
+     * @param targetOption
+     * @param newOption
+     * @param opt
+     */
+
+    function mergeLayoutParam(targetOption, newOption, opt) {
+      var ignoreSize = opt && opt.ignoreSize;
+      !isArray(ignoreSize) && (ignoreSize = [ignoreSize, ignoreSize]);
+      var hResult = merge(HV_NAMES[0], 0);
+      var vResult = merge(HV_NAMES[1], 1);
+      copy(HV_NAMES[0], targetOption, hResult);
+      copy(HV_NAMES[1], targetOption, vResult);
+
+      function merge(names, hvIdx) {
+        var newParams = {};
+        var newValueCount = 0;
+        var merged = {};
+        var mergedValueCount = 0;
+        var enoughParamNumber = 2;
+        each$1(names, function (name) {
+          merged[name] = targetOption[name];
+        });
+        each$1(names, function (name) {
+          // Consider case: newOption.width is null, which is
+          // set by user for removing width setting.
+          hasProp(newOption, name) && (newParams[name] = merged[name] = newOption[name]);
+          hasValue(newParams, name) && newValueCount++;
+          hasValue(merged, name) && mergedValueCount++;
+        });
+
+        if (ignoreSize[hvIdx]) {
+          // Only one of left/right is premitted to exist.
+          if (hasValue(newOption, names[1])) {
+            merged[names[2]] = null;
+          } else if (hasValue(newOption, names[2])) {
+            merged[names[1]] = null;
+          }
+
+          return merged;
+        } // Case: newOption: {width: ..., right: ...},
+        // or targetOption: {right: ...} and newOption: {width: ...},
+        // There is no conflict when merged only has params count
+        // little than enoughParamNumber.
+
+
+        if (mergedValueCount === enoughParamNumber || !newValueCount) {
+          return merged;
+        } // Case: newOption: {width: ..., right: ...},
+        // Than we can make sure user only want those two, and ignore
+        // all origin params in targetOption.
+        else if (newValueCount >= enoughParamNumber) {
+            return newParams;
+          } else {
+            // Chose another param from targetOption by priority.
+            for (var i = 0; i < names.length; i++) {
+              var name_1 = names[i];
+
+              if (!hasProp(newParams, name_1) && hasProp(targetOption, name_1)) {
+                newParams[name_1] = targetOption[name_1];
+                break;
+              }
+            }
+
+            return newParams;
+          }
+      }
+
+      function hasProp(obj, name) {
+        return obj.hasOwnProperty(name);
+      }
+
+      function hasValue(obj, name) {
+        return obj[name] != null && obj[name] !== 'auto';
+      }
+
+      function copy(names, target, source) {
+        each$1(names, function (name) {
+          target[name] = source[name];
+        });
+      }
+    }
+    /**
+     * Retrieve 'left', 'right', 'top', 'bottom', 'width', 'height' from object.
+     */
+
+    function getLayoutParams(source) {
+      return copyLayoutParams({}, source);
+    }
+    /**
+     * Retrieve 'left', 'right', 'top', 'bottom', 'width', 'height' from object.
+     * @param {Object} source
+     * @return {Object} Result contains those props.
+     */
+
+    function copyLayoutParams(target, source) {
+      source && target && each$1(LOCATION_PARAMS, function (name) {
+        source.hasOwnProperty(name) && (target[name] = source[name]);
+      });
+      return target;
+    }
+
+    var inner = makeInner();
+
+    var ComponentModel =
+    /** @class */
+    function (_super) {
+      __extends(ComponentModel, _super);
+
+      function ComponentModel(option, parentModel, ecModel) {
+        var _this = _super.call(this, option, parentModel, ecModel) || this;
+
+        _this.uid = getUID('ec_cpt_model');
+        return _this;
+      }
+
+      ComponentModel.prototype.init = function (option, parentModel, ecModel) {
+        this.mergeDefaultAndTheme(option, ecModel);
+      };
+
+      ComponentModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+        var layoutMode = fetchLayoutMode(this);
+        var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
+        var themeModel = ecModel.getTheme();
+        merge(option, themeModel.get(this.mainType));
+        merge(option, this.getDefaultOption());
+
+        if (layoutMode) {
+          mergeLayoutParam(option, inputPositionParams, layoutMode);
+        }
+      };
+
+      ComponentModel.prototype.mergeOption = function (option, ecModel) {
+        merge(this.option, option, true);
+        var layoutMode = fetchLayoutMode(this);
+
+        if (layoutMode) {
+          mergeLayoutParam(this.option, option, layoutMode);
+        }
+      };
+      /**
+       * Called immediately after `init` or `mergeOption` of this instance called.
+       */
+
+
+      ComponentModel.prototype.optionUpdated = function (newCptOption, isInit) {};
+      /**
+       * [How to declare defaultOption]:
+       *
+       * (A) If using class declaration in typescript (since echarts 5):
+       * ```ts
+       * import {ComponentOption} from '../model/option';
+       * export interface XxxOption extends ComponentOption {
+       *     aaa: number
+       * }
+       * export class XxxModel extends Component {
+       *     static type = 'xxx';
+       *     static defaultOption: XxxOption = {
+       *         aaa: 123
+       *     }
+       * }
+       * Component.registerClass(XxxModel);
+       * ```
+       * ```ts
+       * import {inheritDefaultOption} from '../util/component';
+       * import {XxxModel, XxxOption} from './XxxModel';
+       * export interface XxxSubOption extends XxxOption {
+       *     bbb: number
+       * }
+       * class XxxSubModel extends XxxModel {
+       *     static defaultOption: XxxSubOption = inheritDefaultOption(XxxModel.defaultOption, {
+       *         bbb: 456
+       *     })
+       *     fn() {
+       *         let opt = this.getDefaultOption();
+       *         // opt is {aaa: 123, bbb: 456}
+       *     }
+       * }
+       * ```
+       *
+       * (B) If using class extend (previous approach in echarts 3 & 4):
+       * ```js
+       * let XxxComponent = Component.extend({
+       *     defaultOption: {
+       *         xx: 123
+       *     }
+       * })
+       * ```
+       * ```js
+       * let XxxSubComponent = XxxComponent.extend({
+       *     defaultOption: {
+       *         yy: 456
+       *     },
+       *     fn: function () {
+       *         let opt = this.getDefaultOption();
+       *         // opt is {xx: 123, yy: 456}
+       *     }
+       * })
+       * ```
+       */
+
+
+      ComponentModel.prototype.getDefaultOption = function () {
+        var ctor = this.constructor; // If using class declaration, it is different to travel super class
+        // in legacy env and auto merge defaultOption. So if using class
+        // declaration, defaultOption should be merged manually.
+
+        if (!isExtendedClass(ctor)) {
+          // When using ts class, defaultOption must be declared as static.
+          return ctor.defaultOption;
+        } // FIXME: remove this approach?
+
+
+        var fields = inner(this);
+
+        if (!fields.defaultOption) {
+          var optList = [];
+          var clz = ctor;
+
+          while (clz) {
+            var opt = clz.prototype.defaultOption;
+            opt && optList.push(opt);
+            clz = clz.superClass;
+          }
+
+          var defaultOption = {};
+
+          for (var i = optList.length - 1; i >= 0; i--) {
+            defaultOption = merge(defaultOption, optList[i], true);
+          }
+
+          fields.defaultOption = defaultOption;
+        }
+
+        return fields.defaultOption;
+      };
+      /**
+       * Notice: always force to input param `useDefault` in case that forget to consider it.
+       * The same behavior as `modelUtil.parseFinder`.
+       *
+       * @param useDefault In many cases like series refer axis and axis refer grid,
+       *        If axis index / axis id not specified, use the first target as default.
+       *        In other cases like dataZoom refer axis, if not specified, measn no refer.
+       */
+
+
+      ComponentModel.prototype.getReferringComponents = function (mainType, opt) {
+        var indexKey = mainType + 'Index';
+        var idKey = mainType + 'Id';
+        return queryReferringComponents(this.ecModel, mainType, {
+          index: this.get(indexKey, true),
+          id: this.get(idKey, true)
+        }, opt);
+      };
+
+      ComponentModel.prototype.getBoxLayoutParams = function () {
+        // Consider itself having box layout configs.
+        var boxLayoutModel = this;
+        return {
+          left: boxLayoutModel.get('left'),
+          top: boxLayoutModel.get('top'),
+          right: boxLayoutModel.get('right'),
+          bottom: boxLayoutModel.get('bottom'),
+          width: boxLayoutModel.get('width'),
+          height: boxLayoutModel.get('height')
+        };
+      };
+
+      ComponentModel.protoInitialize = function () {
+        var proto = ComponentModel.prototype;
+        proto.type = 'component';
+        proto.id = '';
+        proto.name = '';
+        proto.mainType = '';
+        proto.subType = '';
+        proto.componentIndex = 0;
+      }();
+
+      return ComponentModel;
+    }(Model);
+
+    mountExtend(ComponentModel, Model);
+    enableClassManagement(ComponentModel);
+    enableSubTypeDefaulter(ComponentModel);
+    enableTopologicalTravel(ComponentModel, getDependencies);
+
+    function getDependencies(componentType) {
+      var deps = [];
+      each(ComponentModel.getClassesByMainType(componentType), function (clz) {
+        deps = deps.concat(clz.dependencies || clz.prototype.dependencies || []);
+      }); // Ensure main type.
+
+      deps = map(deps, function (type) {
+        return parseClassType(type).main;
+      }); // Hack dataset for convenience.
+
+      if (componentType !== 'dataset' && indexOf(deps, 'dataset') <= 0) {
+        deps.unshift('dataset');
+      }
+
+      return deps;
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var platform = ''; // Navigator not exists in node
+
+    if (typeof navigator !== 'undefined') {
+      /* global navigator */
+      platform = navigator.platform || '';
+    }
+
+    var decalColor = 'rgba(0, 0, 0, 0.2)';
+    var globalDefault = {
+      darkMode: 'auto',
+      // backgroundColor: 'rgba(0,0,0,0)',
+      // https://dribbble.com/shots/1065960-Infographic-Pie-chart-visualization
+      // color: ['#5793f3', '#d14a61', '#fd9c35', '#675bba', '#fec42c', '#dd4444', '#d4df5a', '#cd4870'],
+      // Light colors:
+      // color: ['#bcd3bb', '#e88f70', '#edc1a5', '#9dc5c8', '#e1e8c8', '#7b7c68', '#e5b5b5', '#f0b489', '#928ea8', '#bda29a'],
+      // color: ['#cc5664', '#9bd6ec', '#ea946e', '#8acaaa', '#f1ec64', '#ee8686', '#a48dc1', '#5da6bc', '#b9dcae'],
+      // Dark colors:
+      // color: [
+      //     '#c23531', '#2f4554', '#61a0a8', '#d48265', '#91c7ae', '#749f83',
+      //     '#ca8622', '#bda29a', '#6e7074', '#546570', '#c4ccd3'
+      // ],
+      color: [// '#51689b', '#ce5c5c', '#fbc357', '#8fbf8f', '#659d84', '#fb8e6a', '#c77288', '#786090', '#91c4c5', '#6890ba'
+      '#5470c6', '#91cc75', '#fac858', '#ee6666', '#73c0de', '#3ba272', '#fc8452', '#9a60b4', '#ea7ccc'],
+      gradientColor: ['#f6efa6', '#d88273', '#bf444c'],
+      aria: {
+        decal: {
+          decals: [{
+            color: decalColor,
+            dashArrayX: [1, 0],
+            dashArrayY: [2, 5],
+            symbolSize: 1,
+            rotation: Math.PI / 6
+          }, {
+            color: decalColor,
+            symbol: 'circle',
+            dashArrayX: [[8, 8], [0, 8, 8, 0]],
+            dashArrayY: [6, 0],
+            symbolSize: 0.8
+          }, {
+            color: decalColor,
+            dashArrayX: [1, 0],
+            dashArrayY: [4, 3],
+            rotation: -Math.PI / 4
+          }, {
+            color: decalColor,
+            dashArrayX: [[6, 6], [0, 6, 6, 0]],
+            dashArrayY: [6, 0]
+          }, {
+            color: decalColor,
+            dashArrayX: [[1, 0], [1, 6]],
+            dashArrayY: [1, 0, 6, 0],
+            rotation: Math.PI / 4
+          }, {
+            color: decalColor,
+            symbol: 'triangle',
+            dashArrayX: [[9, 9], [0, 9, 9, 0]],
+            dashArrayY: [7, 2],
+            symbolSize: 0.75
+          }]
+        }
+      },
+      // If xAxis and yAxis declared, grid is created by default.
+      // grid: {},
+      textStyle: {
+        // color: '#000',
+        // decoration: 'none',
+        // PENDING
+        fontFamily: platform.match(/^Win/) ? 'Microsoft YaHei' : 'sans-serif',
+        // fontFamily: 'Arial, Verdana, sans-serif',
+        fontSize: 12,
+        fontStyle: 'normal',
+        fontWeight: 'normal'
+      },
+      // http://blogs.adobe.com/webplatform/2014/02/24/using-blend-modes-in-html-canvas/
+      // https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
+      // Default is source-over
+      blendMode: null,
+      stateAnimation: {
+        duration: 300,
+        easing: 'cubicOut'
+      },
+      animation: 'auto',
+      animationDuration: 1000,
+      animationDurationUpdate: 500,
+      animationEasing: 'cubicInOut',
+      animationEasingUpdate: 'cubicInOut',
+      animationThreshold: 2000,
+      // Configuration for progressive/incremental rendering
+      progressiveThreshold: 3000,
+      progressive: 400,
+      // Threshold of if use single hover layer to optimize.
+      // It is recommended that `hoverLayerThreshold` is equivalent to or less than
+      // `progressiveThreshold`, otherwise hover will cause restart of progressive,
+      // which is unexpected.
+      // see example <echarts/test/heatmap-large.html>.
+      hoverLayerThreshold: 3000,
+      // See: module:echarts/scale/Time
+      useUTC: false
+    };
+
+    var VISUAL_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);
+    var SOURCE_FORMAT_ORIGINAL = 'original';
+    var SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';
+    var SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';
+    var SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';
+    var SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';
+    var SOURCE_FORMAT_UNKNOWN = 'unknown';
+    var SERIES_LAYOUT_BY_COLUMN = 'column';
+    var SERIES_LAYOUT_BY_ROW = 'row';
+
+    var BE_ORDINAL = {
+      Must: 1,
+      Might: 2,
+      Not: 3 // Other cases
+
+    };
+    var innerGlobalModel = makeInner();
+    /**
+     * MUST be called before mergeOption of all series.
+     */
+
+    function resetSourceDefaulter(ecModel) {
+      // `datasetMap` is used to make default encode.
+      innerGlobalModel(ecModel).datasetMap = createHashMap();
+    }
+    /**
+     * [The strategy of the arrengment of data dimensions for dataset]:
+     * "value way": all axes are non-category axes. So series one by one take
+     *     several (the number is coordSysDims.length) dimensions from dataset.
+     *     The result of data arrengment of data dimensions like:
+     *     | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |
+     * "category way": at least one axis is category axis. So the the first data
+     *     dimension is always mapped to the first category axis and shared by
+     *     all of the series. The other data dimensions are taken by series like
+     *     "value way" does.
+     *     The result of data arrengment of data dimensions like:
+     *     | ser_shared_x | ser0_y | ser1_y | ser2_y |
+     *
+     * @return encode Never be `null/undefined`.
+     */
+
+    function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {
+      var encode = {};
+      var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.
+
+      if (!datasetModel || !coordDimensions) {
+        return encode;
+      }
+
+      var encodeItemName = [];
+      var encodeSeriesName = [];
+      var ecModel = seriesModel.ecModel;
+      var datasetMap = innerGlobalModel(ecModel).datasetMap;
+      var key = datasetModel.uid + '_' + source.seriesLayoutBy;
+      var baseCategoryDimIndex;
+      var categoryWayValueDimStart;
+      coordDimensions = coordDimensions.slice();
+      each(coordDimensions, function (coordDimInfoLoose, coordDimIdx) {
+        var coordDimInfo = isObject(coordDimInfoLoose) ? coordDimInfoLoose : coordDimensions[coordDimIdx] = {
+          name: coordDimInfoLoose
+        };
+
+        if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {
+          baseCategoryDimIndex = coordDimIdx;
+          categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimInfo);
+        }
+
+        encode[coordDimInfo.name] = [];
+      });
+      var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {
+        categoryWayDim: categoryWayValueDimStart,
+        valueWayDim: 0
+      }); // TODO
+      // Auto detect first time axis and do arrangement.
+
+      each(coordDimensions, function (coordDimInfo, coordDimIdx) {
+        var coordDimName = coordDimInfo.name;
+        var count = getDataDimCountOnCoordDim(coordDimInfo); // In value way.
+
+        if (baseCategoryDimIndex == null) {
+          var start = datasetRecord.valueWayDim;
+          pushDim(encode[coordDimName], start, count);
+          pushDim(encodeSeriesName, start, count);
+          datasetRecord.valueWayDim += count; // ??? TODO give a better default series name rule?
+          // especially when encode x y specified.
+          // consider: when mutiple series share one dimension
+          // category axis, series name should better use
+          // the other dimsion name. On the other hand, use
+          // both dimensions name.
+        } // In category way, the first category axis.
+        else if (baseCategoryDimIndex === coordDimIdx) {
+            pushDim(encode[coordDimName], 0, count);
+            pushDim(encodeItemName, 0, count);
+          } // In category way, the other axis.
+          else {
+              var start = datasetRecord.categoryWayDim;
+              pushDim(encode[coordDimName], start, count);
+              pushDim(encodeSeriesName, start, count);
+              datasetRecord.categoryWayDim += count;
+            }
+      });
+
+      function pushDim(dimIdxArr, idxFrom, idxCount) {
+        for (var i = 0; i < idxCount; i++) {
+          dimIdxArr.push(idxFrom + i);
+        }
+      }
+
+      function getDataDimCountOnCoordDim(coordDimInfo) {
+        var dimsDef = coordDimInfo.dimsDef;
+        return dimsDef ? dimsDef.length : 1;
+      }
+
+      encodeItemName.length && (encode.itemName = encodeItemName);
+      encodeSeriesName.length && (encode.seriesName = encodeSeriesName);
+      return encode;
+    }
+    /**
+     * Work for data like [{name: ..., value: ...}, ...].
+     *
+     * @return encode Never be `null/undefined`.
+     */
+
+    function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {
+      var encode = {};
+      var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.
+
+      if (!datasetModel) {
+        return encode;
+      }
+
+      var sourceFormat = source.sourceFormat;
+      var dimensionsDefine = source.dimensionsDefine;
+      var potentialNameDimIndex;
+
+      if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
+        each(dimensionsDefine, function (dim, idx) {
+          if ((isObject(dim) ? dim.name : dim) === 'name') {
+            potentialNameDimIndex = idx;
+          }
+        });
+      }
+
+      var idxResult = function () {
+        var idxRes0 = {};
+        var idxRes1 = {};
+        var guessRecords = []; // 5 is an experience value.
+
+        for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {
+          var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);
+          guessRecords.push(guessResult);
+          var isPureNumber = guessResult === BE_ORDINAL.Not; // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,
+          // and then find a name dim with the priority:
+          // "BE_ORDINAL.Might|BE_ORDINAL.Must" > "other dim" > "the value dim itself".
+
+          if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {
+            idxRes0.v = i;
+          }
+
+          if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {
+            idxRes0.n = i;
+          }
+
+          if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {
+            return idxRes0;
+          } // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),
+          // find the first BE_ORDINAL.Might as the value dim,
+          // and then find a name dim with the priority:
+          // "other dim" > "the value dim itself".
+          // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be
+          // treated as number.
+
+
+          if (!isPureNumber) {
+            if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {
+              idxRes1.v = i;
+            }
+
+            if (idxRes1.n == null || idxRes1.n === idxRes1.v) {
+              idxRes1.n = i;
+            }
+          }
+        }
+
+        function fulfilled(idxResult) {
+          return idxResult.v != null && idxResult.n != null;
+        }
+
+        return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;
+      }();
+
+      if (idxResult) {
+        encode.value = [idxResult.v]; // `potentialNameDimIndex` has highest priority.
+
+        var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n; // By default, label use itemName in charts.
+        // So we dont set encodeLabel here.
+
+        encode.itemName = [nameDimIndex];
+        encode.seriesName = [nameDimIndex];
+      }
+
+      return encode;
+    }
+    /**
+     * @return If return null/undefined, indicate that should not use datasetModel.
+     */
+
+    function querySeriesUpstreamDatasetModel(seriesModel) {
+      // Caution: consider the scenario:
+      // A dataset is declared and a series is not expected to use the dataset,
+      // and at the beginning `setOption({series: { noData })` (just prepare other
+      // option but no data), then `setOption({series: {data: [...]}); In this case,
+      // the user should set an empty array to avoid that dataset is used by default.
+      var thisData = seriesModel.get('data', true);
+
+      if (!thisData) {
+        return queryReferringComponents(seriesModel.ecModel, 'dataset', {
+          index: seriesModel.get('datasetIndex', true),
+          id: seriesModel.get('datasetId', true)
+        }, SINGLE_REFERRING).models[0];
+      }
+    }
+    /**
+     * @return Always return an array event empty.
+     */
+
+    function queryDatasetUpstreamDatasetModels(datasetModel) {
+      // Only these attributes declared, we by defualt reference to `datasetIndex: 0`.
+      // Otherwise, no reference.
+      if (!datasetModel.get('transform', true) && !datasetModel.get('fromTransformResult', true)) {
+        return [];
+      }
+
+      return queryReferringComponents(datasetModel.ecModel, 'dataset', {
+        index: datasetModel.get('fromDatasetIndex', true),
+        id: datasetModel.get('fromDatasetId', true)
+      }, SINGLE_REFERRING).models;
+    }
+    /**
+     * The rule should not be complex, otherwise user might not
+     * be able to known where the data is wrong.
+     * The code is ugly, but how to make it neat?
+     */
+
+    function guessOrdinal(source, dimIndex) {
+      return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);
+    } // dimIndex may be overflow source data.
+    // return {BE_ORDINAL}
+
+    function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {
+      var result; // Experience value.
+
+      var maxLoop = 5;
+
+      if (isTypedArray(data)) {
+        return BE_ORDINAL.Not;
+      } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine
+      // always exists in source.
+
+
+      var dimName;
+      var dimType;
+
+      if (dimensionsDefine) {
+        var dimDefItem = dimensionsDefine[dimIndex];
+
+        if (isObject(dimDefItem)) {
+          dimName = dimDefItem.name;
+          dimType = dimDefItem.type;
+        } else if (isString(dimDefItem)) {
+          dimName = dimDefItem;
+        }
+      }
+
+      if (dimType != null) {
+        return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;
+      }
+
+      if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
+        var dataArrayRows = data;
+
+        if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {
+          var sample = dataArrayRows[dimIndex];
+
+          for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {
+            if ((result = detectValue(sample[startIndex + i])) != null) {
+              return result;
+            }
+          }
+        } else {
+          for (var i = 0; i < dataArrayRows.length && i < maxLoop; i++) {
+            var row = dataArrayRows[startIndex + i];
+
+            if (row && (result = detectValue(row[dimIndex])) != null) {
+              return result;
+            }
+          }
+        }
+      } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
+        var dataObjectRows = data;
+
+        if (!dimName) {
+          return BE_ORDINAL.Not;
+        }
+
+        for (var i = 0; i < dataObjectRows.length && i < maxLoop; i++) {
+          var item = dataObjectRows[i];
+
+          if (item && (result = detectValue(item[dimName])) != null) {
+            return result;
+          }
+        }
+      } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
+        var dataKeyedColumns = data;
+
+        if (!dimName) {
+          return BE_ORDINAL.Not;
+        }
+
+        var sample = dataKeyedColumns[dimName];
+
+        if (!sample || isTypedArray(sample)) {
+          return BE_ORDINAL.Not;
+        }
+
+        for (var i = 0; i < sample.length && i < maxLoop; i++) {
+          if ((result = detectValue(sample[i])) != null) {
+            return result;
+          }
+        }
+      } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {
+        var dataOriginal = data;
+
+        for (var i = 0; i < dataOriginal.length && i < maxLoop; i++) {
+          var item = dataOriginal[i];
+          var val = getDataItemValue(item);
+
+          if (!isArray(val)) {
+            return BE_ORDINAL.Not;
+          }
+
+          if ((result = detectValue(val[dimIndex])) != null) {
+            return result;
+          }
+        }
+      }
+
+      function detectValue(val) {
+        var beStr = isString(val); // Consider usage convenience, '1', '2' will be treated as "number".
+        // `isFinit('')` get `true`.
+
+        if (val != null && isFinite(val) && val !== '') {
+          return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;
+        } else if (beStr && val !== '-') {
+          return BE_ORDINAL.Must;
+        }
+      }
+
+      return BE_ORDINAL.Not;
+    }
+
+    var internalOptionCreatorMap = createHashMap();
+    function registerInternalOptionCreator(mainType, creator) {
+      assert(internalOptionCreatorMap.get(mainType) == null && creator);
+      internalOptionCreatorMap.set(mainType, creator);
+    }
+    function concatInternalOptions(ecModel, mainType, newCmptOptionList) {
+      var internalOptionCreator = internalOptionCreatorMap.get(mainType);
+
+      if (!internalOptionCreator) {
+        return newCmptOptionList;
+      }
+
+      var internalOptions = internalOptionCreator(ecModel);
+
+      if (!internalOptions) {
+        return newCmptOptionList;
+      }
+
+      if ("development" !== 'production') {
+        for (var i = 0; i < internalOptions.length; i++) {
+          assert(isComponentIdInternal(internalOptions[i]));
+        }
+      }
+
+      return newCmptOptionList.concat(internalOptions);
+    }
+
+    var innerColor = makeInner();
+    var innerDecal = makeInner();
+
+    var PaletteMixin =
+    /** @class */
+    function () {
+      function PaletteMixin() {}
+
+      PaletteMixin.prototype.getColorFromPalette = function (name, scope, requestNum) {
+        var defaultPalette = normalizeToArray(this.get('color', true));
+        var layeredPalette = this.get('colorLayer', true);
+        return getFromPalette(this, innerColor, defaultPalette, layeredPalette, name, scope, requestNum);
+      };
+
+      PaletteMixin.prototype.clearColorPalette = function () {
+        clearPalette(this, innerColor);
+      };
+
+      return PaletteMixin;
+    }();
+
+    function getDecalFromPalette(ecModel, name, scope, requestNum) {
+      var defaultDecals = normalizeToArray(ecModel.get(['aria', 'decal', 'decals']));
+      return getFromPalette(ecModel, innerDecal, defaultDecals, null, name, scope, requestNum);
+    }
+
+    function getNearestPalette(palettes, requestColorNum) {
+      var paletteNum = palettes.length; // TODO palettes must be in order
+
+      for (var i = 0; i < paletteNum; i++) {
+        if (palettes[i].length > requestColorNum) {
+          return palettes[i];
+        }
+      }
+
+      return palettes[paletteNum - 1];
+    }
+    /**
+     * @param name MUST NOT be null/undefined. Otherwise call this function
+     *             twise with the same parameters will get different result.
+     * @param scope default this.
+     * @return Can be null/undefined
+     */
+
+
+    function getFromPalette(that, inner, defaultPalette, layeredPalette, name, scope, requestNum) {
+      scope = scope || that;
+      var scopeFields = inner(scope);
+      var paletteIdx = scopeFields.paletteIdx || 0;
+      var paletteNameMap = scopeFields.paletteNameMap = scopeFields.paletteNameMap || {}; // Use `hasOwnProperty` to avoid conflict with Object.prototype.
+
+      if (paletteNameMap.hasOwnProperty(name)) {
+        return paletteNameMap[name];
+      }
+
+      var palette = requestNum == null || !layeredPalette ? defaultPalette : getNearestPalette(layeredPalette, requestNum); // In case can't find in layered color palette.
+
+      palette = palette || defaultPalette;
+
+      if (!palette || !palette.length) {
+        return;
+      }
+
+      var pickedPaletteItem = palette[paletteIdx];
+
+      if (name) {
+        paletteNameMap[name] = pickedPaletteItem;
+      }
+
+      scopeFields.paletteIdx = (paletteIdx + 1) % palette.length;
+      return pickedPaletteItem;
+    }
+
+    function clearPalette(that, inner) {
+      inner(that).paletteIdx = 0;
+      inner(that).paletteNameMap = {};
+    }
+
+    // Internal method names:
+    // -----------------------
+
+    var reCreateSeriesIndices;
+    var assertSeriesInitialized;
+    var initBase;
+    var OPTION_INNER_KEY = '\0_ec_inner';
+    var OPTION_INNER_VALUE = 1;
+
+    var GlobalModel =
+    /** @class */
+    function (_super) {
+      __extends(GlobalModel, _super);
+
+      function GlobalModel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      GlobalModel.prototype.init = function (option, parentModel, ecModel, theme, locale, optionManager) {
+        theme = theme || {};
+        this.option = null; // Mark as not initialized.
+
+        this._theme = new Model(theme);
+        this._locale = new Model(locale);
+        this._optionManager = optionManager;
+      };
+
+      GlobalModel.prototype.setOption = function (option, opts, optionPreprocessorFuncs) {
+        if ("development" !== 'production') {
+          assert(option != null, 'option is null/undefined');
+          assert(option[OPTION_INNER_KEY] !== OPTION_INNER_VALUE, 'please use chart.getOption()');
+        }
+
+        var innerOpt = normalizeSetOptionInput(opts);
+
+        this._optionManager.setOption(option, optionPreprocessorFuncs, innerOpt);
+
+        this._resetOption(null, innerOpt);
+      };
+      /**
+       * @param type null/undefined: reset all.
+       *        'recreate': force recreate all.
+       *        'timeline': only reset timeline option
+       *        'media': only reset media query option
+       * @return Whether option changed.
+       */
+
+
+      GlobalModel.prototype.resetOption = function (type, opt) {
+        return this._resetOption(type, normalizeSetOptionInput(opt));
+      };
+
+      GlobalModel.prototype._resetOption = function (type, opt) {
+        var optionChanged = false;
+        var optionManager = this._optionManager;
+
+        if (!type || type === 'recreate') {
+          var baseOption = optionManager.mountOption(type === 'recreate');
+
+          if (!this.option || type === 'recreate') {
+            initBase(this, baseOption);
+          } else {
+            this.restoreData();
+
+            this._mergeOption(baseOption, opt);
+          }
+
+          optionChanged = true;
+        }
+
+        if (type === 'timeline' || type === 'media') {
+          this.restoreData();
+        } // By design, if `setOption(option2)` at the second time, and `option2` is a `ECUnitOption`,
+        // it should better not have the same props with `MediaUnit['option']`.
+        // Becuase either `option2` or `MediaUnit['option']` will be always merged to "current option"
+        // rather than original "baseOption". If they both override a prop, the result might be
+        // unexpected when media state changed after `setOption` called.
+        // If we really need to modify a props in each `MediaUnit['option']`, use the full version
+        // (`{baseOption, media}`) in `setOption`.
+        // For `timeline`, the case is the same.
+
+
+        if (!type || type === 'recreate' || type === 'timeline') {
+          var timelineOption = optionManager.getTimelineOption(this);
+
+          if (timelineOption) {
+            optionChanged = true;
+
+            this._mergeOption(timelineOption, opt);
+          }
+        }
+
+        if (!type || type === 'recreate' || type === 'media') {
+          var mediaOptions = optionManager.getMediaOption(this);
+
+          if (mediaOptions.length) {
+            each(mediaOptions, function (mediaOption) {
+              optionChanged = true;
+
+              this._mergeOption(mediaOption, opt);
+            }, this);
+          }
+        }
+
+        return optionChanged;
+      };
+
+      GlobalModel.prototype.mergeOption = function (option) {
+        this._mergeOption(option, null);
+      };
+
+      GlobalModel.prototype._mergeOption = function (newOption, opt) {
+        var option = this.option;
+        var componentsMap = this._componentsMap;
+        var componentsCount = this._componentsCount;
+        var newCmptTypes = [];
+        var newCmptTypeMap = createHashMap();
+        var replaceMergeMainTypeMap = opt && opt.replaceMergeMainTypeMap;
+        resetSourceDefaulter(this); // If no component class, merge directly.
+        // For example: color, animaiton options, etc.
+
+        each(newOption, function (componentOption, mainType) {
+          if (componentOption == null) {
+            return;
+          }
+
+          if (!ComponentModel.hasClass(mainType)) {
+            // globalSettingTask.dirty();
+            option[mainType] = option[mainType] == null ? clone(componentOption) : merge(option[mainType], componentOption, true);
+          } else if (mainType) {
+            newCmptTypes.push(mainType);
+            newCmptTypeMap.set(mainType, true);
+          }
+        });
+
+        if (replaceMergeMainTypeMap) {
+          // If there is a mainType `xxx` in `replaceMerge` but not declared in option,
+          // we trade it as it is declared in option as `{xxx: []}`. Because:
+          // (1) for normal merge, `{xxx: null/undefined}` are the same meaning as `{xxx: []}`.
+          // (2) some preprocessor may convert some of `{xxx: null/undefined}` to `{xxx: []}`.
+          replaceMergeMainTypeMap.each(function (val, mainTypeInReplaceMerge) {
+            if (ComponentModel.hasClass(mainTypeInReplaceMerge) && !newCmptTypeMap.get(mainTypeInReplaceMerge)) {
+              newCmptTypes.push(mainTypeInReplaceMerge);
+              newCmptTypeMap.set(mainTypeInReplaceMerge, true);
+            }
+          });
+        }
+
+        ComponentModel.topologicalTravel(newCmptTypes, ComponentModel.getAllClassMainTypes(), visitComponent, this);
+
+        function visitComponent(mainType) {
+          var newCmptOptionList = concatInternalOptions(this, mainType, normalizeToArray(newOption[mainType]));
+          var oldCmptList = componentsMap.get(mainType);
+          var mergeMode = // `!oldCmptList` means init. See the comment in `mappingToExists`
+          !oldCmptList ? 'replaceAll' : replaceMergeMainTypeMap && replaceMergeMainTypeMap.get(mainType) ? 'replaceMerge' : 'normalMerge';
+          var mappingResult = mappingToExists(oldCmptList, newCmptOptionList, mergeMode); // Set mainType and complete subType.
+
+          setComponentTypeToKeyInfo(mappingResult, mainType, ComponentModel); // Empty it before the travel, in order to prevent `this._componentsMap`
+          // from being used in the `init`/`mergeOption`/`optionUpdated` of some
+          // components, which is probably incorrect logic.
+
+          option[mainType] = null;
+          componentsMap.set(mainType, null);
+          componentsCount.set(mainType, 0);
+          var optionsByMainType = [];
+          var cmptsByMainType = [];
+          var cmptsCountByMainType = 0;
+          each(mappingResult, function (resultItem, index) {
+            var componentModel = resultItem.existing;
+            var newCmptOption = resultItem.newOption;
+
+            if (!newCmptOption) {
+              if (componentModel) {
+                // Consider where is no new option and should be merged using {},
+                // see removeEdgeAndAdd in topologicalTravel and
+                // ComponentModel.getAllClassMainTypes.
+                componentModel.mergeOption({}, this);
+                componentModel.optionUpdated({}, false);
+              } // If no both `resultItem.exist` and `resultItem.option`,
+              // either it is in `replaceMerge` and not matched by any id,
+              // or it has been removed in previous `replaceMerge` and left a "hole" in this component index.
+
+            } else {
+              var ComponentModelClass = ComponentModel.getClass(mainType, resultItem.keyInfo.subType, true);
+
+              if (componentModel && componentModel.constructor === ComponentModelClass) {
+                componentModel.name = resultItem.keyInfo.name; // componentModel.settingTask && componentModel.settingTask.dirty();
+
+                componentModel.mergeOption(newCmptOption, this);
+                componentModel.optionUpdated(newCmptOption, false);
+              } else {
+                // PENDING Global as parent ?
+                var extraOpt = extend({
+                  componentIndex: index
+                }, resultItem.keyInfo);
+                componentModel = new ComponentModelClass(newCmptOption, this, this, extraOpt); // Assign `keyInfo`
+
+                extend(componentModel, extraOpt);
+
+                if (resultItem.brandNew) {
+                  componentModel.__requireNewView = true;
+                }
+
+                componentModel.init(newCmptOption, this, this); // Call optionUpdated after init.
+                // newCmptOption has been used as componentModel.option
+                // and may be merged with theme and default, so pass null
+                // to avoid confusion.
+
+                componentModel.optionUpdated(null, true);
+              }
+            }
+
+            if (componentModel) {
+              optionsByMainType.push(componentModel.option);
+              cmptsByMainType.push(componentModel);
+              cmptsCountByMainType++;
+            } else {
+              // Always do assign to avoid elided item in array.
+              optionsByMainType.push(void 0);
+              cmptsByMainType.push(void 0);
+            }
+          }, this);
+          option[mainType] = optionsByMainType;
+          componentsMap.set(mainType, cmptsByMainType);
+          componentsCount.set(mainType, cmptsCountByMainType); // Backup series for filtering.
+
+          if (mainType === 'series') {
+            reCreateSeriesIndices(this);
+          }
+        } // If no series declared, ensure `_seriesIndices` initialized.
+
+
+        if (!this._seriesIndices) {
+          reCreateSeriesIndices(this);
+        }
+      };
+      /**
+       * Get option for output (cloned option and inner info removed)
+       */
+
+
+      GlobalModel.prototype.getOption = function () {
+        var option = clone(this.option);
+        each(option, function (optInMainType, mainType) {
+          if (ComponentModel.hasClass(mainType)) {
+            var opts = normalizeToArray(optInMainType); // Inner cmpts need to be removed.
+            // Inner cmpts might not be at last since ec5.0, but still
+            // compatible for users: if inner cmpt at last, splice the returned array.
+
+            var realLen = opts.length;
+            var metNonInner = false;
+
+            for (var i = realLen - 1; i >= 0; i--) {
+              // Remove options with inner id.
+              if (opts[i] && !isComponentIdInternal(opts[i])) {
+                metNonInner = true;
+              } else {
+                opts[i] = null;
+                !metNonInner && realLen--;
+              }
+            }
+
+            opts.length = realLen;
+            option[mainType] = opts;
+          }
+        });
+        delete option[OPTION_INNER_KEY];
+        return option;
+      };
+
+      GlobalModel.prototype.getTheme = function () {
+        return this._theme;
+      };
+
+      GlobalModel.prototype.getLocaleModel = function () {
+        return this._locale;
+      };
+
+      GlobalModel.prototype.getLocale = function (localePosition) {
+        var locale = this.getLocaleModel();
+        return locale.get(localePosition);
+      };
+
+      GlobalModel.prototype.setUpdatePayload = function (payload) {
+        this._payload = payload;
+      };
+
+      GlobalModel.prototype.getUpdatePayload = function () {
+        return this._payload;
+      };
+      /**
+       * @param idx If not specified, return the first one.
+       */
+
+
+      GlobalModel.prototype.getComponent = function (mainType, idx) {
+        var list = this._componentsMap.get(mainType);
+
+        if (list) {
+          var cmpt = list[idx || 0];
+
+          if (cmpt) {
+            return cmpt;
+          } else if (idx == null) {
+            for (var i = 0; i < list.length; i++) {
+              if (list[i]) {
+                return list[i];
+              }
+            }
+          }
+        }
+      };
+      /**
+       * @return Never be null/undefined.
+       */
+
+
+      GlobalModel.prototype.queryComponents = function (condition) {
+        var mainType = condition.mainType;
+
+        if (!mainType) {
+          return [];
+        }
+
+        var index = condition.index;
+        var id = condition.id;
+        var name = condition.name;
+
+        var cmpts = this._componentsMap.get(mainType);
+
+        if (!cmpts || !cmpts.length) {
+          return [];
+        }
+
+        var result;
+
+        if (index != null) {
+          result = [];
+          each(normalizeToArray(index), function (idx) {
+            cmpts[idx] && result.push(cmpts[idx]);
+          });
+        } else if (id != null) {
+          result = queryByIdOrName('id', id, cmpts);
+        } else if (name != null) {
+          result = queryByIdOrName('name', name, cmpts);
+        } else {
+          // Return all non-empty components in that mainType
+          result = filter(cmpts, function (cmpt) {
+            return !!cmpt;
+          });
+        }
+
+        return filterBySubType(result, condition);
+      };
+      /**
+       * The interface is different from queryComponents,
+       * which is convenient for inner usage.
+       *
+       * @usage
+       * let result = findComponents(
+       *     {mainType: 'dataZoom', query: {dataZoomId: 'abc'}}
+       * );
+       * let result = findComponents(
+       *     {mainType: 'series', subType: 'pie', query: {seriesName: 'uio'}}
+       * );
+       * let result = findComponents(
+       *     {mainType: 'series',
+       *     filter: function (model, index) {...}}
+       * );
+       * // result like [component0, componnet1, ...]
+       */
+
+
+      GlobalModel.prototype.findComponents = function (condition) {
+        var query = condition.query;
+        var mainType = condition.mainType;
+        var queryCond = getQueryCond(query);
+        var result = queryCond ? this.queryComponents(queryCond) // Retrieve all non-empty components.
+        : filter(this._componentsMap.get(mainType), function (cmpt) {
+          return !!cmpt;
+        });
+        return doFilter(filterBySubType(result, condition));
+
+        function getQueryCond(q) {
+          var indexAttr = mainType + 'Index';
+          var idAttr = mainType + 'Id';
+          var nameAttr = mainType + 'Name';
+          return q && (q[indexAttr] != null || q[idAttr] != null || q[nameAttr] != null) ? {
+            mainType: mainType,
+            // subType will be filtered finally.
+            index: q[indexAttr],
+            id: q[idAttr],
+            name: q[nameAttr]
+          } : null;
+        }
+
+        function doFilter(res) {
+          return condition.filter ? filter(res, condition.filter) : res;
+        }
+      };
+
+      GlobalModel.prototype.eachComponent = function (mainType, cb, context) {
+        var componentsMap = this._componentsMap;
+
+        if (isFunction(mainType)) {
+          var ctxForAll_1 = cb;
+          var cbForAll_1 = mainType;
+          componentsMap.each(function (cmpts, componentType) {
+            for (var i = 0; cmpts && i < cmpts.length; i++) {
+              var cmpt = cmpts[i];
+              cmpt && cbForAll_1.call(ctxForAll_1, componentType, cmpt, cmpt.componentIndex);
+            }
+          });
+        } else {
+          var cmpts = isString(mainType) ? componentsMap.get(mainType) : isObject(mainType) ? this.findComponents(mainType) : null;
+
+          for (var i = 0; cmpts && i < cmpts.length; i++) {
+            var cmpt = cmpts[i];
+            cmpt && cb.call(context, cmpt, cmpt.componentIndex);
+          }
+        }
+      };
+      /**
+       * Get series list before filtered by name.
+       */
+
+
+      GlobalModel.prototype.getSeriesByName = function (name) {
+        var nameStr = convertOptionIdName(name, null);
+        return filter(this._componentsMap.get('series'), function (oneSeries) {
+          return !!oneSeries && nameStr != null && oneSeries.name === nameStr;
+        });
+      };
+      /**
+       * Get series list before filtered by index.
+       */
+
+
+      GlobalModel.prototype.getSeriesByIndex = function (seriesIndex) {
+        return this._componentsMap.get('series')[seriesIndex];
+      };
+      /**
+       * Get series list before filtered by type.
+       * FIXME: rename to getRawSeriesByType?
+       */
+
+
+      GlobalModel.prototype.getSeriesByType = function (subType) {
+        return filter(this._componentsMap.get('series'), function (oneSeries) {
+          return !!oneSeries && oneSeries.subType === subType;
+        });
+      };
+      /**
+       * Get all series before filtered.
+       */
+
+
+      GlobalModel.prototype.getSeries = function () {
+        return filter(this._componentsMap.get('series').slice(), function (oneSeries) {
+          return !!oneSeries;
+        });
+      };
+      /**
+       * Count series before filtered.
+       */
+
+
+      GlobalModel.prototype.getSeriesCount = function () {
+        return this._componentsCount.get('series');
+      };
+      /**
+       * After filtering, series may be different
+       * frome raw series.
+       */
+
+
+      GlobalModel.prototype.eachSeries = function (cb, context) {
+        assertSeriesInitialized(this);
+        each(this._seriesIndices, function (rawSeriesIndex) {
+          var series = this._componentsMap.get('series')[rawSeriesIndex];
+
+          cb.call(context, series, rawSeriesIndex);
+        }, this);
+      };
+      /**
+       * Iterate raw series before filtered.
+       *
+       * @param {Function} cb
+       * @param {*} context
+       */
+
+
+      GlobalModel.prototype.eachRawSeries = function (cb, context) {
+        each(this._componentsMap.get('series'), function (series) {
+          series && cb.call(context, series, series.componentIndex);
+        });
+      };
+      /**
+       * After filtering, series may be different.
+       * frome raw series.
+       */
+
+
+      GlobalModel.prototype.eachSeriesByType = function (subType, cb, context) {
+        assertSeriesInitialized(this);
+        each(this._seriesIndices, function (rawSeriesIndex) {
+          var series = this._componentsMap.get('series')[rawSeriesIndex];
+
+          if (series.subType === subType) {
+            cb.call(context, series, rawSeriesIndex);
+          }
+        }, this);
+      };
+      /**
+       * Iterate raw series before filtered of given type.
+       */
+
+
+      GlobalModel.prototype.eachRawSeriesByType = function (subType, cb, context) {
+        return each(this.getSeriesByType(subType), cb, context);
+      };
+
+      GlobalModel.prototype.isSeriesFiltered = function (seriesModel) {
+        assertSeriesInitialized(this);
+        return this._seriesIndicesMap.get(seriesModel.componentIndex) == null;
+      };
+
+      GlobalModel.prototype.getCurrentSeriesIndices = function () {
+        return (this._seriesIndices || []).slice();
+      };
+
+      GlobalModel.prototype.filterSeries = function (cb, context) {
+        assertSeriesInitialized(this);
+        var newSeriesIndices = [];
+        each(this._seriesIndices, function (seriesRawIdx) {
+          var series = this._componentsMap.get('series')[seriesRawIdx];
+
+          cb.call(context, series, seriesRawIdx) && newSeriesIndices.push(seriesRawIdx);
+        }, this);
+        this._seriesIndices = newSeriesIndices;
+        this._seriesIndicesMap = createHashMap(newSeriesIndices);
+      };
+
+      GlobalModel.prototype.restoreData = function (payload) {
+        reCreateSeriesIndices(this);
+        var componentsMap = this._componentsMap;
+        var componentTypes = [];
+        componentsMap.each(function (components, componentType) {
+          if (ComponentModel.hasClass(componentType)) {
+            componentTypes.push(componentType);
+          }
+        });
+        ComponentModel.topologicalTravel(componentTypes, ComponentModel.getAllClassMainTypes(), function (componentType) {
+          each(componentsMap.get(componentType), function (component) {
+            if (component && (componentType !== 'series' || !isNotTargetSeries(component, payload))) {
+              component.restoreData();
+            }
+          });
+        });
+      };
+
+      GlobalModel.internalField = function () {
+        reCreateSeriesIndices = function (ecModel) {
+          var seriesIndices = ecModel._seriesIndices = [];
+          each(ecModel._componentsMap.get('series'), function (series) {
+            // series may have been removed by `replaceMerge`.
+            series && seriesIndices.push(series.componentIndex);
+          });
+          ecModel._seriesIndicesMap = createHashMap(seriesIndices);
+        };
+
+        assertSeriesInitialized = function (ecModel) {
+          // Components that use _seriesIndices should depends on series component,
+          // which make sure that their initialization is after series.
+          if ("development" !== 'production') {
+            if (!ecModel._seriesIndices) {
+              throw new Error('Option should contains series.');
+            }
+          }
+        };
+
+        initBase = function (ecModel, baseOption) {
+          // Using OPTION_INNER_KEY to mark that this option can not be used outside,
+          // i.e. `chart.setOption(chart.getModel().option);` is forbiden.
+          ecModel.option = {};
+          ecModel.option[OPTION_INNER_KEY] = OPTION_INNER_VALUE; // Init with series: [], in case of calling findSeries method
+          // before series initialized.
+
+          ecModel._componentsMap = createHashMap({
+            series: []
+          });
+          ecModel._componentsCount = createHashMap(); // If user spefied `option.aria`, aria will be enable. This detection should be
+          // performed before theme and globalDefault merge.
+
+          var airaOption = baseOption.aria;
+
+          if (isObject(airaOption) && airaOption.enabled == null) {
+            airaOption.enabled = true;
+          }
+
+          mergeTheme(baseOption, ecModel._theme.option); // TODO Needs clone when merging to the unexisted property
+
+          merge(baseOption, globalDefault, false);
+
+          ecModel._mergeOption(baseOption, null);
+        };
+      }();
+
+      return GlobalModel;
+    }(Model);
+
+    function isNotTargetSeries(seriesModel, payload) {
+      if (payload) {
+        var index = payload.seriesIndex;
+        var id = payload.seriesId;
+        var name_1 = payload.seriesName;
+        return index != null && seriesModel.componentIndex !== index || id != null && seriesModel.id !== id || name_1 != null && seriesModel.name !== name_1;
+      }
+    }
+
+    function mergeTheme(option, theme) {
+      // PENDING
+      // NOT use `colorLayer` in theme if option has `color`
+      var notMergeColorLayer = option.color && !option.colorLayer;
+      each(theme, function (themeItem, name) {
+        if (name === 'colorLayer' && notMergeColorLayer) {
+          return;
+        } // If it is component model mainType, the model handles that merge later.
+        // otherwise, merge them here.
+
+
+        if (!ComponentModel.hasClass(name)) {
+          if (typeof themeItem === 'object') {
+            option[name] = !option[name] ? clone(themeItem) : merge(option[name], themeItem, false);
+          } else {
+            if (option[name] == null) {
+              option[name] = themeItem;
+            }
+          }
+        }
+      });
+    }
+
+    function queryByIdOrName(attr, idOrName, cmpts) {
+      // Here is a break from echarts4: string and number are
+      // treated as equal.
+      if (isArray(idOrName)) {
+        var keyMap_1 = createHashMap();
+        each(idOrName, function (idOrNameItem) {
+          if (idOrNameItem != null) {
+            var idName = convertOptionIdName(idOrNameItem, null);
+            idName != null && keyMap_1.set(idOrNameItem, true);
+          }
+        });
+        return filter(cmpts, function (cmpt) {
+          return cmpt && keyMap_1.get(cmpt[attr]);
+        });
+      } else {
+        var idName_1 = convertOptionIdName(idOrName, null);
+        return filter(cmpts, function (cmpt) {
+          return cmpt && idName_1 != null && cmpt[attr] === idName_1;
+        });
+      }
+    }
+
+    function filterBySubType(components, condition) {
+      // Using hasOwnProperty for restrict. Consider
+      // subType is undefined in user payload.
+      return condition.hasOwnProperty('subType') ? filter(components, function (cmpt) {
+        return cmpt && cmpt.subType === condition.subType;
+      }) : components;
+    }
+
+    function normalizeSetOptionInput(opts) {
+      var replaceMergeMainTypeMap = createHashMap();
+      opts && each(normalizeToArray(opts.replaceMerge), function (mainType) {
+        if ("development" !== 'production') {
+          assert(ComponentModel.hasClass(mainType), '"' + mainType + '" is not valid component main type in "replaceMerge"');
+        }
+
+        replaceMergeMainTypeMap.set(mainType, true);
+      });
+      return {
+        replaceMergeMainTypeMap: replaceMergeMainTypeMap
+      };
+    }
+
+    mixin(GlobalModel, PaletteMixin);
+
+    var availableMethods = ['getDom', 'getZr', 'getWidth', 'getHeight', 'getDevicePixelRatio', 'dispatchAction', 'isDisposed', 'on', 'off', 'getDataURL', 'getConnectedDataURL', // 'getModel',
+    'getOption', // 'getViewOfComponentModel',
+    // 'getViewOfSeriesModel',
+    'getId', 'updateLabelLayout'];
+
+    var ExtensionAPI =
+    /** @class */
+    function () {
+      function ExtensionAPI(ecInstance) {
+        each(availableMethods, function (methodName) {
+          this[methodName] = bind(ecInstance[methodName], ecInstance);
+        }, this);
+      }
+
+      return ExtensionAPI;
+    }();
+
+    var coordinateSystemCreators = {};
+
+    var CoordinateSystemManager =
+    /** @class */
+    function () {
+      function CoordinateSystemManager() {
+        this._coordinateSystems = [];
+      }
+
+      CoordinateSystemManager.prototype.create = function (ecModel, api) {
+        var coordinateSystems = [];
+        each(coordinateSystemCreators, function (creater, type) {
+          var list = creater.create(ecModel, api);
+          coordinateSystems = coordinateSystems.concat(list || []);
+        });
+        this._coordinateSystems = coordinateSystems;
+      };
+
+      CoordinateSystemManager.prototype.update = function (ecModel, api) {
+        each(this._coordinateSystems, function (coordSys) {
+          coordSys.update && coordSys.update(ecModel, api);
+        });
+      };
+
+      CoordinateSystemManager.prototype.getCoordinateSystems = function () {
+        return this._coordinateSystems.slice();
+      };
+
+      CoordinateSystemManager.register = function (type, creator) {
+        coordinateSystemCreators[type] = creator;
+      };
+
+      CoordinateSystemManager.get = function (type) {
+        return coordinateSystemCreators[type];
+      };
+
+      return CoordinateSystemManager;
+    }();
+
+    var QUERY_REG = /^(min|max)?(.+)$/; // Key: mainType
+    // type FakeComponentsMap = HashMap<(MappingExistingItem & { subType: string })[]>;
+
+    /**
+     * TERM EXPLANATIONS:
+     * See `ECOption` and `ECUnitOption` in `src/util/types.ts`.
+     */
+
+    var OptionManager =
+    /** @class */
+    function () {
+      // timeline.notMerge is not supported in ec3. Firstly there is rearly
+      // case that notMerge is needed. Secondly supporting 'notMerge' requires
+      // rawOption cloned and backuped when timeline changed, which does no
+      // good to performance. What's more, that both timeline and setOption
+      // method supply 'notMerge' brings complex and some problems.
+      // Consider this case:
+      // (step1) chart.setOption({timeline: {notMerge: false}, ...}, false);
+      // (step2) chart.setOption({timeline: {notMerge: true}, ...}, false);
+      function OptionManager(api) {
+        this._timelineOptions = [];
+        this._mediaList = [];
+        /**
+         * -1, means default.
+         * empty means no media.
+         */
+
+        this._currentMediaIndices = [];
+        this._api = api;
+      }
+
+      OptionManager.prototype.setOption = function (rawOption, optionPreprocessorFuncs, opt) {
+        if (rawOption) {
+          // That set dat primitive is dangerous if user reuse the data when setOption again.
+          each(normalizeToArray(rawOption.series), function (series) {
+            series && series.data && isTypedArray(series.data) && setAsPrimitive(series.data);
+          });
+          each(normalizeToArray(rawOption.dataset), function (dataset) {
+            dataset && dataset.source && isTypedArray(dataset.source) && setAsPrimitive(dataset.source);
+          });
+        } // Caution: some series modify option data, if do not clone,
+        // it should ensure that the repeat modify correctly
+        // (create a new object when modify itself).
+
+
+        rawOption = clone(rawOption); // FIXME
+        // If some property is set in timeline options or media option but
+        // not set in baseOption, a warning should be given.
+
+        var optionBackup = this._optionBackup;
+        var newParsedOption = parseRawOption(rawOption, optionPreprocessorFuncs, !optionBackup);
+        this._newBaseOption = newParsedOption.baseOption; // For setOption at second time (using merge mode);
+
+        if (optionBackup) {
+          // FIXME
+          // the restore merge solution is essentially incorrect.
+          // the mapping can not be 100% consistent with ecModel, which probably brings
+          // potential bug!
+          // The first merge is delayed, becuase in most cases, users do not call `setOption` twice.
+          // let fakeCmptsMap = this._fakeCmptsMap;
+          // if (!fakeCmptsMap) {
+          //     fakeCmptsMap = this._fakeCmptsMap = createHashMap();
+          //     mergeToBackupOption(fakeCmptsMap, null, optionBackup.baseOption, null);
+          // }
+          // mergeToBackupOption(
+          //     fakeCmptsMap, optionBackup.baseOption, newParsedOption.baseOption, opt
+          // );
+          // For simplicity, timeline options and media options do not support merge,
+          // that is, if you `setOption` twice and both has timeline options, the latter
+          // timeline opitons will not be merged to the formers, but just substitude them.
+          if (newParsedOption.timelineOptions.length) {
+            optionBackup.timelineOptions = newParsedOption.timelineOptions;
+          }
+
+          if (newParsedOption.mediaList.length) {
+            optionBackup.mediaList = newParsedOption.mediaList;
+          }
+
+          if (newParsedOption.mediaDefault) {
+            optionBackup.mediaDefault = newParsedOption.mediaDefault;
+          }
+        } else {
+          this._optionBackup = newParsedOption;
+        }
+      };
+
+      OptionManager.prototype.mountOption = function (isRecreate) {
+        var optionBackup = this._optionBackup;
+        this._timelineOptions = optionBackup.timelineOptions;
+        this._mediaList = optionBackup.mediaList;
+        this._mediaDefault = optionBackup.mediaDefault;
+        this._currentMediaIndices = [];
+        return clone(isRecreate // this._optionBackup.baseOption, which is created at the first `setOption`
+        // called, and is merged into every new option by inner method `mergeToBackupOption`
+        // each time `setOption` called, can be only used in `isRecreate`, because
+        // its reliability is under suspicion. In other cases option merge is
+        // performed by `model.mergeOption`.
+        ? optionBackup.baseOption : this._newBaseOption);
+      };
+
+      OptionManager.prototype.getTimelineOption = function (ecModel) {
+        var option;
+        var timelineOptions = this._timelineOptions;
+
+        if (timelineOptions.length) {
+          // getTimelineOption can only be called after ecModel inited,
+          // so we can get currentIndex from timelineModel.
+          var timelineModel = ecModel.getComponent('timeline');
+
+          if (timelineModel) {
+            option = clone( // FIXME:TS as TimelineModel or quivlant interface
+            timelineOptions[timelineModel.getCurrentIndex()]);
+          }
+        }
+
+        return option;
+      };
+
+      OptionManager.prototype.getMediaOption = function (ecModel) {
+        var ecWidth = this._api.getWidth();
+
+        var ecHeight = this._api.getHeight();
+
+        var mediaList = this._mediaList;
+        var mediaDefault = this._mediaDefault;
+        var indices = [];
+        var result = []; // No media defined.
+
+        if (!mediaList.length && !mediaDefault) {
+          return result;
+        } // Multi media may be applied, the latter defined media has higher priority.
+
+
+        for (var i = 0, len = mediaList.length; i < len; i++) {
+          if (applyMediaQuery(mediaList[i].query, ecWidth, ecHeight)) {
+            indices.push(i);
+          }
+        } // FIXME
+        // Whether mediaDefault should force users to provide? Otherwise
+        // the change by media query can not be recorvered.
+
+
+        if (!indices.length && mediaDefault) {
+          indices = [-1];
+        }
+
+        if (indices.length && !indicesEquals(indices, this._currentMediaIndices)) {
+          result = map(indices, function (index) {
+            return clone(index === -1 ? mediaDefault.option : mediaList[index].option);
+          });
+        } // Otherwise return nothing.
+
+
+        this._currentMediaIndices = indices;
+        return result;
+      };
+
+      return OptionManager;
+    }();
+    /**
+     * [RAW_OPTION_PATTERNS]
+     * (Note: "series: []" represents all other props in `ECUnitOption`)
+     *
+     * (1) No prop "baseOption" declared:
+     * Root option is used as "baseOption" (except prop "options" and "media").
+     * ```js
+     * option = {
+     *     series: [],
+     *     timeline: {},
+     *     options: [],
+     * };
+     * option = {
+     *     series: [],
+     *     media: {},
+     * };
+     * option = {
+     *     series: [],
+     *     timeline: {},
+     *     options: [],
+     *     media: {},
+     * }
+     * ```
+     *
+     * (2) Prop "baseOption" declared:
+     * If "baseOption" declared, `ECUnitOption` props can only be declared
+     * inside "baseOption" except prop "timeline" (compat ec2).
+     * ```js
+     * option = {
+     *     baseOption: {
+     *         timeline: {},
+     *         series: [],
+     *     },
+     *     options: []
+     * };
+     * option = {
+     *     baseOption: {
+     *         series: [],
+     *     },
+     *     media: []
+     * };
+     * option = {
+     *     baseOption: {
+     *         timeline: {},
+     *         series: [],
+     *     },
+     *     options: []
+     *     media: []
+     * };
+     * option = {
+     *     // ec3 compat ec2: allow (only) `timeline` declared
+     *     // outside baseOption. Keep this setting for compat.
+     *     timeline: {},
+     *     baseOption: {
+     *         series: [],
+     *     },
+     *     options: [],
+     *     media: []
+     * };
+     * ```
+     */
+
+
+    function parseRawOption( // `rawOption` May be modified
+    rawOption, optionPreprocessorFuncs, isNew) {
+      var mediaList = [];
+      var mediaDefault;
+      var baseOption;
+      var declaredBaseOption = rawOption.baseOption; // Compatible with ec2, [RAW_OPTION_PATTERNS] above.
+
+      var timelineOnRoot = rawOption.timeline;
+      var timelineOptionsOnRoot = rawOption.options;
+      var mediaOnRoot = rawOption.media;
+      var hasMedia = !!rawOption.media;
+      var hasTimeline = !!(timelineOptionsOnRoot || timelineOnRoot || declaredBaseOption && declaredBaseOption.timeline);
+
+      if (declaredBaseOption) {
+        baseOption = declaredBaseOption; // For merge option.
+
+        if (!baseOption.timeline) {
+          baseOption.timeline = timelineOnRoot;
+        }
+      } // For convenience, enable to use the root option as the `baseOption`:
+      // `{ ...normalOptionProps, media: [{ ... }, { ... }] }`
+      else {
+          if (hasTimeline || hasMedia) {
+            rawOption.options = rawOption.media = null;
+          }
+
+          baseOption = rawOption;
+        }
+
+      if (hasMedia) {
+        if (isArray(mediaOnRoot)) {
+          each(mediaOnRoot, function (singleMedia) {
+            if ("development" !== 'production') {
+              // Real case of wrong config.
+              if (singleMedia && !singleMedia.option && isObject(singleMedia.query) && isObject(singleMedia.query.option)) {
+                error('Illegal media option. Must be like { media: [ { query: {}, option: {} } ] }');
+              }
+            }
+
+            if (singleMedia && singleMedia.option) {
+              if (singleMedia.query) {
+                mediaList.push(singleMedia);
+              } else if (!mediaDefault) {
+                // Use the first media default.
+                mediaDefault = singleMedia;
+              }
+            }
+          });
+        } else {
+          if ("development" !== 'production') {
+            // Real case of wrong config.
+            error('Illegal media option. Must be an array. Like { media: [ {...}, {...} ] }');
+          }
+        }
+      }
+
+      doPreprocess(baseOption);
+      each(timelineOptionsOnRoot, function (option) {
+        return doPreprocess(option);
+      });
+      each(mediaList, function (media) {
+        return doPreprocess(media.option);
+      });
+
+      function doPreprocess(option) {
+        each(optionPreprocessorFuncs, function (preProcess) {
+          preProcess(option, isNew);
+        });
+      }
+
+      return {
+        baseOption: baseOption,
+        timelineOptions: timelineOptionsOnRoot || [],
+        mediaDefault: mediaDefault,
+        mediaList: mediaList
+      };
+    }
+    /**
+     * @see <http://www.w3.org/TR/css3-mediaqueries/#media1>
+     * Support: width, height, aspectRatio
+     * Can use max or min as prefix.
+     */
+
+
+    function applyMediaQuery(query, ecWidth, ecHeight) {
+      var realMap = {
+        width: ecWidth,
+        height: ecHeight,
+        aspectratio: ecWidth / ecHeight // lowser case for convenientce.
+
+      };
+      var applicatable = true;
+      each(query, function (value, attr) {
+        var matched = attr.match(QUERY_REG);
+
+        if (!matched || !matched[1] || !matched[2]) {
+          return;
+        }
+
+        var operator = matched[1];
+        var realAttr = matched[2].toLowerCase();
+
+        if (!compare(realMap[realAttr], value, operator)) {
+          applicatable = false;
+        }
+      });
+      return applicatable;
+    }
+
+    function compare(real, expect, operator) {
+      if (operator === 'min') {
+        return real >= expect;
+      } else if (operator === 'max') {
+        return real <= expect;
+      } else {
+        // Equals
+        return real === expect;
+      }
+    }
+
+    function indicesEquals(indices1, indices2) {
+      // indices is always order by asc and has only finite number.
+      return indices1.join(',') === indices2.join(',');
+    }
+
+    var each$2 = each;
+    var isObject$1 = isObject;
+    var POSSIBLE_STYLES = ['areaStyle', 'lineStyle', 'nodeStyle', 'linkStyle', 'chordStyle', 'label', 'labelLine'];
+
+    function compatEC2ItemStyle(opt) {
+      var itemStyleOpt = opt && opt.itemStyle;
+
+      if (!itemStyleOpt) {
+        return;
+      }
+
+      for (var i = 0, len = POSSIBLE_STYLES.length; i < len; i++) {
+        var styleName = POSSIBLE_STYLES[i];
+        var normalItemStyleOpt = itemStyleOpt.normal;
+        var emphasisItemStyleOpt = itemStyleOpt.emphasis;
+
+        if (normalItemStyleOpt && normalItemStyleOpt[styleName]) {
+          if ("development" !== 'production') {
+            deprecateReplaceLog("itemStyle.normal." + styleName, styleName);
+          }
+
+          opt[styleName] = opt[styleName] || {};
+
+          if (!opt[styleName].normal) {
+            opt[styleName].normal = normalItemStyleOpt[styleName];
+          } else {
+            merge(opt[styleName].normal, normalItemStyleOpt[styleName]);
+          }
+
+          normalItemStyleOpt[styleName] = null;
+        }
+
+        if (emphasisItemStyleOpt && emphasisItemStyleOpt[styleName]) {
+          if ("development" !== 'production') {
+            deprecateReplaceLog("itemStyle.emphasis." + styleName, "emphasis." + styleName);
+          }
+
+          opt[styleName] = opt[styleName] || {};
+
+          if (!opt[styleName].emphasis) {
+            opt[styleName].emphasis = emphasisItemStyleOpt[styleName];
+          } else {
+            merge(opt[styleName].emphasis, emphasisItemStyleOpt[styleName]);
+          }
+
+          emphasisItemStyleOpt[styleName] = null;
+        }
+      }
+    }
+
+    function convertNormalEmphasis(opt, optType, useExtend) {
+      if (opt && opt[optType] && (opt[optType].normal || opt[optType].emphasis)) {
+        var normalOpt = opt[optType].normal;
+        var emphasisOpt = opt[optType].emphasis;
+
+        if (normalOpt) {
+          if ("development" !== 'production') {
+            // eslint-disable-next-line max-len
+            deprecateLog("'normal' hierarchy in " + optType + " has been removed since 4.0. All style properties are configured in " + optType + " directly now.");
+          } // Timeline controlStyle has other properties besides normal and emphasis
+
+
+          if (useExtend) {
+            opt[optType].normal = opt[optType].emphasis = null;
+            defaults(opt[optType], normalOpt);
+          } else {
+            opt[optType] = normalOpt;
+          }
+        }
+
+        if (emphasisOpt) {
+          if ("development" !== 'production') {
+            deprecateLog(optType + ".emphasis has been changed to emphasis." + optType + " since 4.0");
+          }
+
+          opt.emphasis = opt.emphasis || {};
+          opt.emphasis[optType] = emphasisOpt; // Also compat the case user mix the style and focus together in ec3 style
+          // for example: { itemStyle: { normal: {}, emphasis: {focus, shadowBlur} } }
+
+          if (emphasisOpt.focus) {
+            opt.emphasis.focus = emphasisOpt.focus;
+          }
+
+          if (emphasisOpt.blurScope) {
+            opt.emphasis.blurScope = emphasisOpt.blurScope;
+          }
+        }
+      }
+    }
+
+    function removeEC3NormalStatus(opt) {
+      convertNormalEmphasis(opt, 'itemStyle');
+      convertNormalEmphasis(opt, 'lineStyle');
+      convertNormalEmphasis(opt, 'areaStyle');
+      convertNormalEmphasis(opt, 'label');
+      convertNormalEmphasis(opt, 'labelLine'); // treemap
+
+      convertNormalEmphasis(opt, 'upperLabel'); // graph
+
+      convertNormalEmphasis(opt, 'edgeLabel');
+    }
+
+    function compatTextStyle(opt, propName) {
+      // Check whether is not object (string\null\undefined ...)
+      var labelOptSingle = isObject$1(opt) && opt[propName];
+      var textStyle = isObject$1(labelOptSingle) && labelOptSingle.textStyle;
+
+      if (textStyle) {
+        if ("development" !== 'production') {
+          // eslint-disable-next-line max-len
+          deprecateLog("textStyle hierarchy in " + propName + " has been removed since 4.0. All textStyle properties are configured in " + propName + " directly now.");
+        }
+
+        for (var i = 0, len = TEXT_STYLE_OPTIONS.length; i < len; i++) {
+          var textPropName = TEXT_STYLE_OPTIONS[i];
+
+          if (textStyle.hasOwnProperty(textPropName)) {
+            labelOptSingle[textPropName] = textStyle[textPropName];
+          }
+        }
+      }
+    }
+
+    function compatEC3CommonStyles(opt) {
+      if (opt) {
+        removeEC3NormalStatus(opt);
+        compatTextStyle(opt, 'label');
+        opt.emphasis && compatTextStyle(opt.emphasis, 'label');
+      }
+    }
+
+    function processSeries(seriesOpt) {
+      if (!isObject$1(seriesOpt)) {
+        return;
+      }
+
+      compatEC2ItemStyle(seriesOpt);
+      removeEC3NormalStatus(seriesOpt);
+      compatTextStyle(seriesOpt, 'label'); // treemap
+
+      compatTextStyle(seriesOpt, 'upperLabel'); // graph
+
+      compatTextStyle(seriesOpt, 'edgeLabel');
+
+      if (seriesOpt.emphasis) {
+        compatTextStyle(seriesOpt.emphasis, 'label'); // treemap
+
+        compatTextStyle(seriesOpt.emphasis, 'upperLabel'); // graph
+
+        compatTextStyle(seriesOpt.emphasis, 'edgeLabel');
+      }
+
+      var markPoint = seriesOpt.markPoint;
+
+      if (markPoint) {
+        compatEC2ItemStyle(markPoint);
+        compatEC3CommonStyles(markPoint);
+      }
+
+      var markLine = seriesOpt.markLine;
+
+      if (markLine) {
+        compatEC2ItemStyle(markLine);
+        compatEC3CommonStyles(markLine);
+      }
+
+      var markArea = seriesOpt.markArea;
+
+      if (markArea) {
+        compatEC3CommonStyles(markArea);
+      }
+
+      var data = seriesOpt.data; // Break with ec3: if `setOption` again, there may be no `type` in option,
+      // then the backward compat based on option type will not be performed.
+
+      if (seriesOpt.type === 'graph') {
+        data = data || seriesOpt.nodes;
+        var edgeData = seriesOpt.links || seriesOpt.edges;
+
+        if (edgeData && !isTypedArray(edgeData)) {
+          for (var i = 0; i < edgeData.length; i++) {
+            compatEC3CommonStyles(edgeData[i]);
+          }
+        }
+
+        each(seriesOpt.categories, function (opt) {
+          removeEC3NormalStatus(opt);
+        });
+      }
+
+      if (data && !isTypedArray(data)) {
+        for (var i = 0; i < data.length; i++) {
+          compatEC3CommonStyles(data[i]);
+        }
+      } // mark point data
+
+
+      markPoint = seriesOpt.markPoint;
+
+      if (markPoint && markPoint.data) {
+        var mpData = markPoint.data;
+
+        for (var i = 0; i < mpData.length; i++) {
+          compatEC3CommonStyles(mpData[i]);
+        }
+      } // mark line data
+
+
+      markLine = seriesOpt.markLine;
+
+      if (markLine && markLine.data) {
+        var mlData = markLine.data;
+
+        for (var i = 0; i < mlData.length; i++) {
+          if (isArray(mlData[i])) {
+            compatEC3CommonStyles(mlData[i][0]);
+            compatEC3CommonStyles(mlData[i][1]);
+          } else {
+            compatEC3CommonStyles(mlData[i]);
+          }
+        }
+      } // Series
+
+
+      if (seriesOpt.type === 'gauge') {
+        compatTextStyle(seriesOpt, 'axisLabel');
+        compatTextStyle(seriesOpt, 'title');
+        compatTextStyle(seriesOpt, 'detail');
+      } else if (seriesOpt.type === 'treemap') {
+        convertNormalEmphasis(seriesOpt.breadcrumb, 'itemStyle');
+        each(seriesOpt.levels, function (opt) {
+          removeEC3NormalStatus(opt);
+        });
+      } else if (seriesOpt.type === 'tree') {
+        removeEC3NormalStatus(seriesOpt.leaves);
+      } // sunburst starts from ec4, so it does not need to compat levels.
+
+    }
+
+    function toArr(o) {
+      return isArray(o) ? o : o ? [o] : [];
+    }
+
+    function toObj(o) {
+      return (isArray(o) ? o[0] : o) || {};
+    }
+
+    function globalCompatStyle(option, isTheme) {
+      each$2(toArr(option.series), function (seriesOpt) {
+        isObject$1(seriesOpt) && processSeries(seriesOpt);
+      });
+      var axes = ['xAxis', 'yAxis', 'radiusAxis', 'angleAxis', 'singleAxis', 'parallelAxis', 'radar'];
+      isTheme && axes.push('valueAxis', 'categoryAxis', 'logAxis', 'timeAxis');
+      each$2(axes, function (axisName) {
+        each$2(toArr(option[axisName]), function (axisOpt) {
+          if (axisOpt) {
+            compatTextStyle(axisOpt, 'axisLabel');
+            compatTextStyle(axisOpt.axisPointer, 'label');
+          }
+        });
+      });
+      each$2(toArr(option.parallel), function (parallelOpt) {
+        var parallelAxisDefault = parallelOpt && parallelOpt.parallelAxisDefault;
+        compatTextStyle(parallelAxisDefault, 'axisLabel');
+        compatTextStyle(parallelAxisDefault && parallelAxisDefault.axisPointer, 'label');
+      });
+      each$2(toArr(option.calendar), function (calendarOpt) {
+        convertNormalEmphasis(calendarOpt, 'itemStyle');
+        compatTextStyle(calendarOpt, 'dayLabel');
+        compatTextStyle(calendarOpt, 'monthLabel');
+        compatTextStyle(calendarOpt, 'yearLabel');
+      }); // radar.name.textStyle
+
+      each$2(toArr(option.radar), function (radarOpt) {
+        compatTextStyle(radarOpt, 'name'); // Use axisName instead of name because component has name property
+
+        if (radarOpt.name && radarOpt.axisName == null) {
+          radarOpt.axisName = radarOpt.name;
+          delete radarOpt.name;
+
+          if ("development" !== 'production') {
+            deprecateLog('name property in radar component has been changed to axisName');
+          }
+        }
+
+        if (radarOpt.nameGap != null && radarOpt.axisNameGap == null) {
+          radarOpt.axisNameGap = radarOpt.nameGap;
+          delete radarOpt.nameGap;
+
+          if ("development" !== 'production') {
+            deprecateLog('nameGap property in radar component has been changed to axisNameGap');
+          }
+        }
+      });
+      each$2(toArr(option.geo), function (geoOpt) {
+        if (isObject$1(geoOpt)) {
+          compatEC3CommonStyles(geoOpt);
+          each$2(toArr(geoOpt.regions), function (regionObj) {
+            compatEC3CommonStyles(regionObj);
+          });
+        }
+      });
+      each$2(toArr(option.timeline), function (timelineOpt) {
+        compatEC3CommonStyles(timelineOpt);
+        convertNormalEmphasis(timelineOpt, 'label');
+        convertNormalEmphasis(timelineOpt, 'itemStyle');
+        convertNormalEmphasis(timelineOpt, 'controlStyle', true);
+        var data = timelineOpt.data;
+        isArray(data) && each(data, function (item) {
+          if (isObject(item)) {
+            convertNormalEmphasis(item, 'label');
+            convertNormalEmphasis(item, 'itemStyle');
+          }
+        });
+      });
+      each$2(toArr(option.toolbox), function (toolboxOpt) {
+        convertNormalEmphasis(toolboxOpt, 'iconStyle');
+        each$2(toolboxOpt.feature, function (featureOpt) {
+          convertNormalEmphasis(featureOpt, 'iconStyle');
+        });
+      });
+      compatTextStyle(toObj(option.axisPointer), 'label');
+      compatTextStyle(toObj(option.tooltip).axisPointer, 'label'); // Clean logs
+      // storedLogs = {};
+    }
+
+    function get(opt, path) {
+      var pathArr = path.split(',');
+      var obj = opt;
+
+      for (var i = 0; i < pathArr.length; i++) {
+        obj = obj && obj[pathArr[i]];
+
+        if (obj == null) {
+          break;
+        }
+      }
+
+      return obj;
+    }
+
+    function set$1(opt, path, val, overwrite) {
+      var pathArr = path.split(',');
+      var obj = opt;
+      var key;
+      var i = 0;
+
+      for (; i < pathArr.length - 1; i++) {
+        key = pathArr[i];
+
+        if (obj[key] == null) {
+          obj[key] = {};
+        }
+
+        obj = obj[key];
+      }
+
+      if (overwrite || obj[pathArr[i]] == null) {
+        obj[pathArr[i]] = val;
+      }
+    }
+
+    function compatLayoutProperties(option) {
+      option && each(LAYOUT_PROPERTIES, function (prop) {
+        if (prop[0] in option && !(prop[1] in option)) {
+          option[prop[1]] = option[prop[0]];
+        }
+      });
+    }
+
+    var LAYOUT_PROPERTIES = [['x', 'left'], ['y', 'top'], ['x2', 'right'], ['y2', 'bottom']];
+    var COMPATITABLE_COMPONENTS = ['grid', 'geo', 'parallel', 'legend', 'toolbox', 'title', 'visualMap', 'dataZoom', 'timeline'];
+    var BAR_ITEM_STYLE_MAP = [['borderRadius', 'barBorderRadius'], ['borderColor', 'barBorderColor'], ['borderWidth', 'barBorderWidth']];
+
+    function compatBarItemStyle(option) {
+      var itemStyle = option && option.itemStyle;
+
+      if (itemStyle) {
+        for (var i = 0; i < BAR_ITEM_STYLE_MAP.length; i++) {
+          var oldName = BAR_ITEM_STYLE_MAP[i][1];
+          var newName = BAR_ITEM_STYLE_MAP[i][0];
+
+          if (itemStyle[oldName] != null) {
+            itemStyle[newName] = itemStyle[oldName];
+
+            if ("development" !== 'production') {
+              deprecateReplaceLog(oldName, newName);
+            }
+          }
+        }
+      }
+    }
+
+    function compatPieLabel(option) {
+      if (!option) {
+        return;
+      }
+
+      if (option.alignTo === 'edge' && option.margin != null && option.edgeDistance == null) {
+        if ("development" !== 'production') {
+          deprecateReplaceLog('label.margin', 'label.edgeDistance', 'pie');
+        }
+
+        option.edgeDistance = option.margin;
+      }
+    }
+
+    function compatSunburstState(option) {
+      if (!option) {
+        return;
+      }
+
+      if (option.downplay && !option.blur) {
+        option.blur = option.downplay;
+
+        if ("development" !== 'production') {
+          deprecateReplaceLog('downplay', 'blur', 'sunburst');
+        }
+      }
+    }
+
+    function compatGraphFocus(option) {
+      if (!option) {
+        return;
+      }
+
+      if (option.focusNodeAdjacency != null) {
+        option.emphasis = option.emphasis || {};
+
+        if (option.emphasis.focus == null) {
+          if ("development" !== 'production') {
+            deprecateReplaceLog('focusNodeAdjacency', 'emphasis: { focus: \'adjacency\'}', 'graph/sankey');
+          }
+
+          option.emphasis.focus = 'adjacency';
+        }
+      }
+    }
+
+    function traverseTree(data, cb) {
+      if (data) {
+        for (var i = 0; i < data.length; i++) {
+          cb(data[i]);
+          data[i] && traverseTree(data[i].children, cb);
+        }
+      }
+    }
+
+    function globalBackwardCompat(option, isTheme) {
+      globalCompatStyle(option, isTheme); // Make sure series array for model initialization.
+
+      option.series = normalizeToArray(option.series);
+      each(option.series, function (seriesOpt) {
+        if (!isObject(seriesOpt)) {
+          return;
+        }
+
+        var seriesType = seriesOpt.type;
+
+        if (seriesType === 'line') {
+          if (seriesOpt.clipOverflow != null) {
+            seriesOpt.clip = seriesOpt.clipOverflow;
+
+            if ("development" !== 'production') {
+              deprecateReplaceLog('clipOverflow', 'clip', 'line');
+            }
+          }
+        } else if (seriesType === 'pie' || seriesType === 'gauge') {
+          if (seriesOpt.clockWise != null) {
+            seriesOpt.clockwise = seriesOpt.clockWise;
+
+            if ("development" !== 'production') {
+              deprecateReplaceLog('clockWise', 'clockwise');
+            }
+          }
+
+          compatPieLabel(seriesOpt.label);
+          var data = seriesOpt.data;
+
+          if (data && !isTypedArray(data)) {
+            for (var i = 0; i < data.length; i++) {
+              compatPieLabel(data[i]);
+            }
+          }
+
+          if (seriesOpt.hoverOffset != null) {
+            seriesOpt.emphasis = seriesOpt.emphasis || {};
+
+            if (seriesOpt.emphasis.scaleSize = null) {
+              if ("development" !== 'production') {
+                deprecateReplaceLog('hoverOffset', 'emphasis.scaleSize');
+              }
+
+              seriesOpt.emphasis.scaleSize = seriesOpt.hoverOffset;
+            }
+          }
+        } else if (seriesType === 'gauge') {
+          var pointerColor = get(seriesOpt, 'pointer.color');
+          pointerColor != null && set$1(seriesOpt, 'itemStyle.color', pointerColor);
+        } else if (seriesType === 'bar') {
+          compatBarItemStyle(seriesOpt);
+          compatBarItemStyle(seriesOpt.backgroundStyle);
+          compatBarItemStyle(seriesOpt.emphasis);
+          var data = seriesOpt.data;
+
+          if (data && !isTypedArray(data)) {
+            for (var i = 0; i < data.length; i++) {
+              if (typeof data[i] === 'object') {
+                compatBarItemStyle(data[i]);
+                compatBarItemStyle(data[i] && data[i].emphasis);
+              }
+            }
+          }
+        } else if (seriesType === 'sunburst') {
+          var highlightPolicy = seriesOpt.highlightPolicy;
+
+          if (highlightPolicy) {
+            seriesOpt.emphasis = seriesOpt.emphasis || {};
+
+            if (!seriesOpt.emphasis.focus) {
+              seriesOpt.emphasis.focus = highlightPolicy;
+
+              if ("development" !== 'production') {
+                deprecateReplaceLog('highlightPolicy', 'emphasis.focus', 'sunburst');
+              }
+            }
+          }
+
+          compatSunburstState(seriesOpt);
+          traverseTree(seriesOpt.data, compatSunburstState);
+        } else if (seriesType === 'graph' || seriesType === 'sankey') {
+          compatGraphFocus(seriesOpt); // TODO nodes, edges?
+        } else if (seriesType === 'map') {
+          if (seriesOpt.mapType && !seriesOpt.map) {
+            if ("development" !== 'production') {
+              deprecateReplaceLog('mapType', 'map', 'map');
+            }
+
+            seriesOpt.map = seriesOpt.mapType;
+          }
+
+          if (seriesOpt.mapLocation) {
+            if ("development" !== 'production') {
+              deprecateLog('`mapLocation` is not used anymore.');
+            }
+
+            defaults(seriesOpt, seriesOpt.mapLocation);
+          }
+        }
+
+        if (seriesOpt.hoverAnimation != null) {
+          seriesOpt.emphasis = seriesOpt.emphasis || {};
+
+          if (seriesOpt.emphasis && seriesOpt.emphasis.scale == null) {
+            if ("development" !== 'production') {
+              deprecateReplaceLog('hoverAnimation', 'emphasis.scale');
+            }
+
+            seriesOpt.emphasis.scale = seriesOpt.hoverAnimation;
+          }
+        }
+
+        compatLayoutProperties(seriesOpt);
+      }); // dataRange has changed to visualMap
+
+      if (option.dataRange) {
+        option.visualMap = option.dataRange;
+      }
+
+      each(COMPATITABLE_COMPONENTS, function (componentName) {
+        var options = option[componentName];
+
+        if (options) {
+          if (!isArray(options)) {
+            options = [options];
+          }
+
+          each(options, function (option) {
+            compatLayoutProperties(option);
+          });
+        }
+      });
+    }
+
+    //     data processing stage is blocked in stream.
+    //     See <module:echarts/stream/Scheduler#performDataProcessorTasks>
+    // (2) Only register once when import repeatly.
+    //     Should be executed after series filtered and before stack calculation.
+
+    function dataStack(ecModel) {
+      var stackInfoMap = createHashMap();
+      ecModel.eachSeries(function (seriesModel) {
+        var stack = seriesModel.get('stack'); // Compatibal: when `stack` is set as '', do not stack.
+
+        if (stack) {
+          var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []);
+          var data = seriesModel.getData();
+          var stackInfo = {
+            // Used for calculate axis extent automatically.
+            // TODO: Type getCalculationInfo return more specific type?
+            stackResultDimension: data.getCalculationInfo('stackResultDimension'),
+            stackedOverDimension: data.getCalculationInfo('stackedOverDimension'),
+            stackedDimension: data.getCalculationInfo('stackedDimension'),
+            stackedByDimension: data.getCalculationInfo('stackedByDimension'),
+            isStackedByIndex: data.getCalculationInfo('isStackedByIndex'),
+            data: data,
+            seriesModel: seriesModel
+          }; // If stacked on axis that do not support data stack.
+
+          if (!stackInfo.stackedDimension || !(stackInfo.isStackedByIndex || stackInfo.stackedByDimension)) {
+            return;
+          }
+
+          stackInfoList.length && data.setCalculationInfo('stackedOnSeries', stackInfoList[stackInfoList.length - 1].seriesModel);
+          stackInfoList.push(stackInfo);
+        }
+      });
+      stackInfoMap.each(calculateStack);
+    }
+
+    function calculateStack(stackInfoList) {
+      each(stackInfoList, function (targetStackInfo, idxInStack) {
+        var resultVal = [];
+        var resultNaN = [NaN, NaN];
+        var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension];
+        var targetData = targetStackInfo.data;
+        var isStackedByIndex = targetStackInfo.isStackedByIndex; // Should not write on raw data, because stack series model list changes
+        // depending on legend selection.
+
+        var newData = targetData.map(dims, function (v0, v1, dataIndex) {
+          var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex); // Consider `connectNulls` of line area, if value is NaN, stackedOver
+          // should also be NaN, to draw a appropriate belt area.
+
+          if (isNaN(sum)) {
+            return resultNaN;
+          }
+
+          var byValue;
+          var stackedDataRawIndex;
+
+          if (isStackedByIndex) {
+            stackedDataRawIndex = targetData.getRawIndex(dataIndex);
+          } else {
+            byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex);
+          } // If stackOver is NaN, chart view will render point on value start.
+
+
+          var stackedOver = NaN;
+
+          for (var j = idxInStack - 1; j >= 0; j--) {
+            var stackInfo = stackInfoList[j]; // Has been optimized by inverted indices on `stackedByDimension`.
+
+            if (!isStackedByIndex) {
+              stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue);
+            }
+
+            if (stackedDataRawIndex >= 0) {
+              var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex); // Considering positive stack, negative stack and empty data
+
+              if (sum >= 0 && val > 0 || // Positive stack
+              sum <= 0 && val < 0 // Negative stack
+              ) {
+                  sum += val;
+                  stackedOver = val;
+                  break;
+                }
+            }
+          }
+
+          resultVal[0] = sum;
+          resultVal[1] = stackedOver;
+          return resultVal;
+        });
+        targetData.hostModel.setData(newData); // Update for consequent calculation
+
+        targetStackInfo.data = newData;
+      });
+    }
+
+    var SourceImpl =
+    /** @class */
+    function () {
+      // readonly frozen: boolean;
+      function SourceImpl(fields) {
+        this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);
+        this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN; // Visit config
+
+        this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;
+        this.startIndex = fields.startIndex || 0;
+        this.dimensionsDefine = fields.dimensionsDefine;
+        this.dimensionsDetectedCount = fields.dimensionsDetectedCount;
+        this.encodeDefine = fields.encodeDefine;
+        this.metaRawOption = fields.metaRawOption;
+      }
+
+      return SourceImpl;
+    }();
+
+    function isSourceInstance(val) {
+      return val instanceof SourceImpl;
+    }
+    function createSource(sourceData, thisMetaRawOption, // can be null. If not provided, auto detect it from `sourceData`.
+    sourceFormat, encodeDefine // can be null
+    ) {
+      sourceFormat = sourceFormat || detectSourceFormat(sourceData);
+      var seriesLayoutBy = thisMetaRawOption.seriesLayoutBy;
+      var determined = determineSourceDimensions(sourceData, sourceFormat, seriesLayoutBy, thisMetaRawOption.sourceHeader, thisMetaRawOption.dimensions);
+      var source = new SourceImpl({
+        data: sourceData,
+        sourceFormat: sourceFormat,
+        seriesLayoutBy: seriesLayoutBy,
+        dimensionsDefine: determined.dimensionsDefine,
+        startIndex: determined.startIndex,
+        dimensionsDetectedCount: determined.dimensionsDetectedCount,
+        encodeDefine: makeEncodeDefine(encodeDefine),
+        metaRawOption: clone(thisMetaRawOption)
+      });
+      return source;
+    }
+    /**
+     * Wrap original series data for some compatibility cases.
+     */
+
+    function createSourceFromSeriesDataOption(data) {
+      return new SourceImpl({
+        data: data,
+        sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL
+      });
+    }
+    /**
+     * Clone source but excludes source data.
+     */
+
+    function cloneSourceShallow(source) {
+      return new SourceImpl({
+        data: source.data,
+        sourceFormat: source.sourceFormat,
+        seriesLayoutBy: source.seriesLayoutBy,
+        dimensionsDefine: clone(source.dimensionsDefine),
+        startIndex: source.startIndex,
+        dimensionsDetectedCount: source.dimensionsDetectedCount,
+        encodeDefine: makeEncodeDefine(source.encodeDefine)
+      });
+    }
+
+    function makeEncodeDefine(encodeDefine) {
+      // null means user not specify `series.encode`.
+      return encodeDefine ? createHashMap(encodeDefine) : null;
+    }
+    /**
+     * Note: An empty array will be detected as `SOURCE_FORMAT_ARRAY_ROWS`.
+     */
+
+
+    function detectSourceFormat(data) {
+      var sourceFormat = SOURCE_FORMAT_UNKNOWN;
+
+      if (isTypedArray(data)) {
+        sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;
+      } else if (isArray(data)) {
+        // FIXME Whether tolerate null in top level array?
+        if (data.length === 0) {
+          sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;
+        }
+
+        for (var i = 0, len = data.length; i < len; i++) {
+          var item = data[i];
+
+          if (item == null) {
+            continue;
+          } else if (isArray(item)) {
+            sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;
+            break;
+          } else if (isObject(item)) {
+            sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;
+            break;
+          }
+        }
+      } else if (isObject(data)) {
+        for (var key in data) {
+          if (hasOwn(data, key) && isArrayLike(data[key])) {
+            sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;
+            break;
+          }
+        }
+      }
+
+      return sourceFormat;
+    }
+    /**
+     * Determine the source definitions from data standalone dimensions definitions
+     * are not specified.
+     */
+
+    function determineSourceDimensions(data, sourceFormat, seriesLayoutBy, sourceHeader, // standalone raw dimensions definition, like:
+    // {
+    //     dimensions: ['aa', 'bb', { name: 'cc', type: 'time' }]
+    // }
+    // in `dataset` or `series`
+    dimensionsDefine) {
+      var dimensionsDetectedCount;
+      var startIndex; // PEDING: could data be null/undefined here?
+      // currently, if `dataset.source` not specified, error thrown.
+      // if `series.data` not specified, nothing rendered without error thrown.
+      // Should test these cases.
+
+      if (!data) {
+        return {
+          dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+          startIndex: startIndex,
+          dimensionsDetectedCount: dimensionsDetectedCount
+        };
+      }
+
+      if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
+        var dataArrayRows = data; // Rule: Most of the first line are string: it is header.
+        // Caution: consider a line with 5 string and 1 number,
+        // it still can not be sure it is a head, because the
+        // 5 string may be 5 values of category columns.
+
+        if (sourceHeader === 'auto' || sourceHeader == null) {
+          arrayRowsTravelFirst(function (val) {
+            // '-' is regarded as null/undefined.
+            if (val != null && val !== '-') {
+              if (isString(val)) {
+                startIndex == null && (startIndex = 1);
+              } else {
+                startIndex = 0;
+              }
+            } // 10 is an experience number, avoid long loop.
+
+          }, seriesLayoutBy, dataArrayRows, 10);
+        } else {
+          startIndex = isNumber(sourceHeader) ? sourceHeader : sourceHeader ? 1 : 0;
+        }
+
+        if (!dimensionsDefine && startIndex === 1) {
+          dimensionsDefine = [];
+          arrayRowsTravelFirst(function (val, index) {
+            dimensionsDefine[index] = val != null ? val + '' : '';
+          }, seriesLayoutBy, dataArrayRows, Infinity);
+        }
+
+        dimensionsDetectedCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? dataArrayRows.length : dataArrayRows[0] ? dataArrayRows[0].length : null;
+      } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
+        if (!dimensionsDefine) {
+          dimensionsDefine = objectRowsCollectDimensions(data);
+        }
+      } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
+        if (!dimensionsDefine) {
+          dimensionsDefine = [];
+          each(data, function (colArr, key) {
+            dimensionsDefine.push(key);
+          });
+        }
+      } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {
+        var value0 = getDataItemValue(data[0]);
+        dimensionsDetectedCount = isArray(value0) && value0.length || 1;
+      } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {
+        if ("development" !== 'production') {
+          assert(!!dimensionsDefine, 'dimensions must be given if data is TypedArray.');
+        }
+      }
+
+      return {
+        startIndex: startIndex,
+        dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+        dimensionsDetectedCount: dimensionsDetectedCount
+      };
+    }
+
+    function objectRowsCollectDimensions(data) {
+      var firstIndex = 0;
+      var obj;
+
+      while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line
+
+
+      if (obj) {
+        var dimensions_1 = [];
+        each(obj, function (value, key) {
+          dimensions_1.push(key);
+        });
+        return dimensions_1;
+      }
+    } // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],
+    // which is reasonable. But dimension name is duplicated.
+    // Returns undefined or an array contains only object without null/undefiend or string.
+
+
+    function normalizeDimensionsOption(dimensionsDefine) {
+      if (!dimensionsDefine) {
+        // The meaning of null/undefined is different from empty array.
+        return;
+      }
+
+      var nameMap = createHashMap();
+      return map(dimensionsDefine, function (rawItem, index) {
+        rawItem = isObject(rawItem) ? rawItem : {
+          name: rawItem
+        }; // Other fields will be discarded.
+
+        var item = {
+          name: rawItem.name,
+          displayName: rawItem.displayName,
+          type: rawItem.type
+        }; // User can set null in dimensions.
+        // We dont auto specify name, othewise a given name may
+        // cause it be refered unexpectedly.
+
+        if (item.name == null) {
+          return item;
+        } // Also consider number form like 2012.
+
+
+        item.name += ''; // User may also specify displayName.
+        // displayName will always exists except user not
+        // specified or dim name is not specified or detected.
+        // (A auto generated dim name will not be used as
+        // displayName).
+
+        if (item.displayName == null) {
+          item.displayName = item.name;
+        }
+
+        var exist = nameMap.get(item.name);
+
+        if (!exist) {
+          nameMap.set(item.name, {
+            count: 1
+          });
+        } else {
+          item.name += '-' + exist.count++;
+        }
+
+        return item;
+      });
+    }
+
+    function arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {
+      if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {
+        for (var i = 0; i < data.length && i < maxLoop; i++) {
+          cb(data[i] ? data[i][0] : null, i);
+        }
+      } else {
+        var value0 = data[0] || [];
+
+        for (var i = 0; i < value0.length && i < maxLoop; i++) {
+          cb(value0[i], i);
+        }
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var _a, _b, _c; // TODO
+    var providerMethods;
+    var mountMethods;
+    /**
+     * If normal array used, mutable chunk size is supported.
+     * If typed array used, chunk size must be fixed.
+     */
+
+    var DefaultDataProvider =
+    /** @class */
+    function () {
+      function DefaultDataProvider(sourceParam, dimSize) {
+        // let source: Source;
+        var source = !isSourceInstance(sourceParam) ? createSourceFromSeriesDataOption(sourceParam) : sourceParam; // declare source is Source;
+
+        this._source = source;
+        var data = this._data = source.data; // Typed array. TODO IE10+?
+
+        if (source.sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {
+          if ("development" !== 'production') {
+            if (dimSize == null) {
+              throw new Error('Typed array data must specify dimension size');
+            }
+          }
+
+          this._offset = 0;
+          this._dimSize = dimSize;
+          this._data = data;
+        }
+
+        mountMethods(this, data, source);
+      }
+
+      DefaultDataProvider.prototype.getSource = function () {
+        return this._source;
+      };
+
+      DefaultDataProvider.prototype.count = function () {
+        return 0;
+      };
+
+      DefaultDataProvider.prototype.getItem = function (idx, out) {
+        return;
+      };
+
+      DefaultDataProvider.prototype.appendData = function (newData) {};
+
+      DefaultDataProvider.prototype.clean = function () {};
+
+      DefaultDataProvider.protoInitialize = function () {
+        // PENDING: To avoid potential incompat (e.g., prototype
+        // is visited somewhere), still init them on prototype.
+        var proto = DefaultDataProvider.prototype;
+        proto.pure = false;
+        proto.persistent = true;
+      }();
+
+      DefaultDataProvider.internalField = function () {
+        var _a;
+
+        mountMethods = function (provider, data, source) {
+          var sourceFormat = source.sourceFormat;
+          var seriesLayoutBy = source.seriesLayoutBy;
+          var startIndex = source.startIndex;
+          var dimsDef = source.dimensionsDefine;
+          var methods = providerMethods[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+
+          if ("development" !== 'production') {
+            assert(methods, 'Invalide sourceFormat: ' + sourceFormat);
+          }
+
+          extend(provider, methods);
+
+          if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {
+            provider.getItem = getItemForTypedArray;
+            provider.count = countForTypedArray;
+            provider.fillStorage = fillStorageForTypedArray;
+          } else {
+            var rawItemGetter = getRawSourceItemGetter(sourceFormat, seriesLayoutBy);
+            provider.getItem = bind(rawItemGetter, null, data, startIndex, dimsDef);
+            var rawCounter = getRawSourceDataCounter(sourceFormat, seriesLayoutBy);
+            provider.count = bind(rawCounter, null, data, startIndex, dimsDef);
+          }
+        };
+
+        var getItemForTypedArray = function (idx, out) {
+          idx = idx - this._offset;
+          out = out || [];
+          var data = this._data;
+          var dimSize = this._dimSize;
+          var offset = dimSize * idx;
+
+          for (var i = 0; i < dimSize; i++) {
+            out[i] = data[offset + i];
+          }
+
+          return out;
+        };
+
+        var fillStorageForTypedArray = function (start, end, storage, extent) {
+          var data = this._data;
+          var dimSize = this._dimSize;
+
+          for (var dim = 0; dim < dimSize; dim++) {
+            var dimExtent = extent[dim];
+            var min = dimExtent[0] == null ? Infinity : dimExtent[0];
+            var max = dimExtent[1] == null ? -Infinity : dimExtent[1];
+            var count = end - start;
+            var arr = storage[dim];
+
+            for (var i = 0; i < count; i++) {
+              // appendData with TypedArray will always do replace in provider.
+              var val = data[i * dimSize + dim];
+              arr[start + i] = val;
+              val < min && (min = val);
+              val > max && (max = val);
+            }
+
+            dimExtent[0] = min;
+            dimExtent[1] = max;
+          }
+        };
+
+        var countForTypedArray = function () {
+          return this._data ? this._data.length / this._dimSize : 0;
+        };
+
+        providerMethods = (_a = {}, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = {
+          pure: true,
+          appendData: appendDataSimply
+        }, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = {
+          pure: true,
+          appendData: function () {
+            throw new Error('Do not support appendData when set seriesLayoutBy: "row".');
+          }
+        }, _a[SOURCE_FORMAT_OBJECT_ROWS] = {
+          pure: true,
+          appendData: appendDataSimply
+        }, _a[SOURCE_FORMAT_KEYED_COLUMNS] = {
+          pure: true,
+          appendData: function (newData) {
+            var data = this._data;
+            each(newData, function (newCol, key) {
+              var oldCol = data[key] || (data[key] = []);
+
+              for (var i = 0; i < (newCol || []).length; i++) {
+                oldCol.push(newCol[i]);
+              }
+            });
+          }
+        }, _a[SOURCE_FORMAT_ORIGINAL] = {
+          appendData: appendDataSimply
+        }, _a[SOURCE_FORMAT_TYPED_ARRAY] = {
+          persistent: false,
+          pure: true,
+          appendData: function (newData) {
+            if ("development" !== 'production') {
+              assert(isTypedArray(newData), 'Added data must be TypedArray if data in initialization is TypedArray');
+            }
+
+            this._data = newData;
+          },
+          // Clean self if data is already used.
+          clean: function () {
+            // PENDING
+            this._offset += this.count();
+            this._data = null;
+          }
+        }, _a);
+
+        function appendDataSimply(newData) {
+          for (var i = 0; i < newData.length; i++) {
+            this._data.push(newData[i]);
+          }
+        }
+      }();
+
+      return DefaultDataProvider;
+    }();
+
+    var getItemSimply = function (rawData, startIndex, dimsDef, idx) {
+      return rawData[idx];
+    };
+
+    var rawSourceItemGetterMap = (_a = {}, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef, idx) {
+      return rawData[idx + startIndex];
+    }, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef, idx) {
+      idx += startIndex;
+      var item = [];
+      var data = rawData;
+
+      for (var i = 0; i < data.length; i++) {
+        var row = data[i];
+        item.push(row ? row[idx] : null);
+      }
+
+      return item;
+    }, _a[SOURCE_FORMAT_OBJECT_ROWS] = getItemSimply, _a[SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef, idx) {
+      var item = [];
+
+      for (var i = 0; i < dimsDef.length; i++) {
+        var dimName = dimsDef[i].name;
+
+        if ("development" !== 'production') {
+          if (dimName == null) {
+            throw new Error();
+          }
+        }
+
+        var col = rawData[dimName];
+        item.push(col ? col[idx] : null);
+      }
+
+      return item;
+    }, _a[SOURCE_FORMAT_ORIGINAL] = getItemSimply, _a);
+    function getRawSourceItemGetter(sourceFormat, seriesLayoutBy) {
+      var method = rawSourceItemGetterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+
+      if ("development" !== 'production') {
+        assert(method, 'Do not suppport get item on "' + sourceFormat + '", "' + seriesLayoutBy + '".');
+      }
+
+      return method;
+    }
+
+    var countSimply = function (rawData, startIndex, dimsDef) {
+      return rawData.length;
+    };
+
+    var rawSourceDataCounterMap = (_b = {}, _b[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef) {
+      return Math.max(0, rawData.length - startIndex);
+    }, _b[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef) {
+      var row = rawData[0];
+      return row ? Math.max(0, row.length - startIndex) : 0;
+    }, _b[SOURCE_FORMAT_OBJECT_ROWS] = countSimply, _b[SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef) {
+      var dimName = dimsDef[0].name;
+
+      if ("development" !== 'production') {
+        if (dimName == null) {
+          throw new Error();
+        }
+      }
+
+      var col = rawData[dimName];
+      return col ? col.length : 0;
+    }, _b[SOURCE_FORMAT_ORIGINAL] = countSimply, _b);
+    function getRawSourceDataCounter(sourceFormat, seriesLayoutBy) {
+      var method = rawSourceDataCounterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+
+      if ("development" !== 'production') {
+        assert(method, 'Do not suppport count on "' + sourceFormat + '", "' + seriesLayoutBy + '".');
+      }
+
+      return method;
+    }
+
+    var getRawValueSimply = function (dataItem, dimIndex, dimName) {
+      return dimIndex != null ? dataItem[dimIndex] : dataItem;
+    };
+
+    var rawSourceValueGetterMap = (_c = {}, _c[SOURCE_FORMAT_ARRAY_ROWS] = getRawValueSimply, _c[SOURCE_FORMAT_OBJECT_ROWS] = function (dataItem, dimIndex, dimName) {
+      return dimIndex != null ? dataItem[dimName] : dataItem;
+    }, _c[SOURCE_FORMAT_KEYED_COLUMNS] = getRawValueSimply, _c[SOURCE_FORMAT_ORIGINAL] = function (dataItem, dimIndex, dimName) {
+      // FIXME: In some case (markpoint in geo (geo-map.html)),
+      // dataItem is {coord: [...]}
+      var value = getDataItemValue(dataItem);
+      return dimIndex == null || !(value instanceof Array) ? value : value[dimIndex];
+    }, _c[SOURCE_FORMAT_TYPED_ARRAY] = getRawValueSimply, _c);
+    function getRawSourceValueGetter(sourceFormat) {
+      var method = rawSourceValueGetterMap[sourceFormat];
+
+      if ("development" !== 'production') {
+        assert(method, 'Do not suppport get value on "' + sourceFormat + '".');
+      }
+
+      return method;
+    }
+
+    function getMethodMapKey(sourceFormat, seriesLayoutBy) {
+      return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + '_' + seriesLayoutBy : sourceFormat;
+    } // ??? FIXME can these logic be more neat: getRawValue, getRawDataItem,
+    // Consider persistent.
+    // Caution: why use raw value to display on label or tooltip?
+    // A reason is to avoid format. For example time value we do not know
+    // how to format is expected. More over, if stack is used, calculated
+    // value may be 0.91000000001, which have brings trouble to display.
+    // TODO: consider how to treat null/undefined/NaN when display?
+
+
+    function retrieveRawValue(data, dataIndex, dim // If dimIndex is null/undefined, return OptionDataItem.
+    // Otherwise, return OptionDataValue.
+    ) {
+      if (!data) {
+        return;
+      } // Consider data may be not persistent.
+
+
+      var dataItem = data.getRawDataItem(dataIndex);
+
+      if (dataItem == null) {
+        return;
+      }
+
+      var sourceFormat = data.getProvider().getSource().sourceFormat;
+      var dimName;
+      var dimIndex;
+      var dimInfo = data.getDimensionInfo(dim);
+
+      if (dimInfo) {
+        dimName = dimInfo.name;
+        dimIndex = dimInfo.index;
+      }
+
+      return getRawSourceValueGetter(sourceFormat)(dataItem, dimIndex, dimName);
+    }
+
+    var DIMENSION_LABEL_REG = /\{@(.+?)\}/g;
+
+    var DataFormatMixin =
+    /** @class */
+    function () {
+      function DataFormatMixin() {}
+      /**
+       * Get params for formatter
+       */
+
+
+      DataFormatMixin.prototype.getDataParams = function (dataIndex, dataType) {
+        var data = this.getData(dataType);
+        var rawValue = this.getRawValue(dataIndex, dataType);
+        var rawDataIndex = data.getRawIndex(dataIndex);
+        var name = data.getName(dataIndex);
+        var itemOpt = data.getRawDataItem(dataIndex);
+        var style = data.getItemVisual(dataIndex, 'style');
+        var color = style && style[data.getItemVisual(dataIndex, 'drawType') || 'fill'];
+        var borderColor = style && style.stroke;
+        var mainType = this.mainType;
+        var isSeries = mainType === 'series';
+        var userOutput = data.userOutput;
+        return {
+          componentType: mainType,
+          componentSubType: this.subType,
+          componentIndex: this.componentIndex,
+          seriesType: isSeries ? this.subType : null,
+          seriesIndex: this.seriesIndex,
+          seriesId: isSeries ? this.id : null,
+          seriesName: isSeries ? this.name : null,
+          name: name,
+          dataIndex: rawDataIndex,
+          data: itemOpt,
+          dataType: dataType,
+          value: rawValue,
+          color: color,
+          borderColor: borderColor,
+          dimensionNames: userOutput ? userOutput.dimensionNames : null,
+          encode: userOutput ? userOutput.encode : null,
+          // Param name list for mapping `a`, `b`, `c`, `d`, `e`
+          $vars: ['seriesName', 'name', 'value']
+        };
+      };
+      /**
+       * Format label
+       * @param dataIndex
+       * @param status 'normal' by default
+       * @param dataType
+       * @param labelDimIndex Only used in some chart that
+       *        use formatter in different dimensions, like radar.
+       * @param formatter Formatter given outside.
+       * @return return null/undefined if no formatter
+       */
+
+
+      DataFormatMixin.prototype.getFormattedLabel = function (dataIndex, status, dataType, labelDimIndex, formatter, extendParams) {
+        status = status || 'normal';
+        var data = this.getData(dataType);
+        var params = this.getDataParams(dataIndex, dataType);
+
+        if (extendParams) {
+          params.value = extendParams.interpolatedValue;
+        }
+
+        if (labelDimIndex != null && isArray(params.value)) {
+          params.value = params.value[labelDimIndex];
+        }
+
+        if (!formatter) {
+          var itemModel = data.getItemModel(dataIndex); // @ts-ignore
+
+          formatter = itemModel.get(status === 'normal' ? ['label', 'formatter'] : [status, 'label', 'formatter']);
+        }
+
+        if (typeof formatter === 'function') {
+          params.status = status;
+          params.dimensionIndex = labelDimIndex;
+          return formatter(params);
+        } else if (typeof formatter === 'string') {
+          var str = formatTpl(formatter, params); // Support 'aaa{@[3]}bbb{@product}ccc'.
+          // Do not support '}' in dim name util have to.
+
+          return str.replace(DIMENSION_LABEL_REG, function (origin, dimStr) {
+            var len = dimStr.length;
+            var dimLoose = dimStr.charAt(0) === '[' && dimStr.charAt(len - 1) === ']' ? +dimStr.slice(1, len - 1) // Also support: '[]' => 0
+            : dimStr;
+            var val = retrieveRawValue(data, dataIndex, dimLoose);
+
+            if (extendParams && isArray(extendParams.interpolatedValue)) {
+              var dimInfo = data.getDimensionInfo(dimLoose);
+
+              if (dimInfo) {
+                val = extendParams.interpolatedValue[dimInfo.index];
+              }
+            }
+
+            return val != null ? val + '' : '';
+          });
+        }
+      };
+      /**
+       * Get raw value in option
+       */
+
+
+      DataFormatMixin.prototype.getRawValue = function (idx, dataType) {
+        return retrieveRawValue(this.getData(dataType), idx);
+      };
+      /**
+       * Should be implemented.
+       * @param {number} dataIndex
+       * @param {boolean} [multipleSeries=false]
+       * @param {string} [dataType]
+       */
+
+
+      DataFormatMixin.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        // Empty function
+        return;
+      };
+
+      return DataFormatMixin;
+    }();
+    // but guess little chance has been used outside. Do we need to backward
+    // compat it?
+    // type TooltipFormatResultLegacyObject = {
+    //     // `html` means the markup language text, either in 'html' or 'richText'.
+    //     // The name `html` is not appropriate becuase in 'richText' it is not a HTML
+    //     // string. But still support it for backward compat.
+    //     html: string;
+    //     markers: Dictionary<ColorString>;
+    // };
+
+    /**
+     * For backward compat, normalize the return from `formatTooltip`.
+     */
+
+    function normalizeTooltipFormatResult(result // markersExisting: Dictionary<ColorString>
+    ) {
+      var markupText; // let markers: Dictionary<ColorString>;
+
+      var markupFragment;
+
+      if (isObject(result)) {
+        if (result.type) {
+          markupFragment = result;
+        } else {
+          if ("development" !== 'production') {
+            console.warn('The return type of `formatTooltip` is not supported: ' + makePrintable(result));
+          }
+        } // else {
+        //     markupText = (result as TooltipFormatResultLegacyObject).html;
+        //     markers = (result as TooltipFormatResultLegacyObject).markers;
+        //     if (markersExisting) {
+        //         markers = zrUtil.merge(markersExisting, markers);
+        //     }
+        // }
+
+      } else {
+        markupText = result;
+      }
+
+      return {
+        markupText: markupText,
+        // markers: markers || markersExisting,
+        markupFragment: markupFragment
+      };
+    }
+
+    /**
+     * @param {Object} define
+     * @return See the return of `createTask`.
+     */
+
+    function createTask(define) {
+      return new Task(define);
+    }
+
+    var Task =
+    /** @class */
+    function () {
+      function Task(define) {
+        define = define || {};
+        this._reset = define.reset;
+        this._plan = define.plan;
+        this._count = define.count;
+        this._onDirty = define.onDirty;
+        this._dirty = true;
+      }
+      /**
+       * @param step Specified step.
+       * @param skip Skip customer perform call.
+       * @param modBy Sampling window size.
+       * @param modDataCount Sampling count.
+       * @return whether unfinished.
+       */
+
+
+      Task.prototype.perform = function (performArgs) {
+        var upTask = this._upstream;
+        var skip = performArgs && performArgs.skip; // TODO some refactor.
+        // Pull data. Must pull data each time, because context.data
+        // may be updated by Series.setData.
+
+        if (this._dirty && upTask) {
+          var context = this.context;
+          context.data = context.outputData = upTask.context.outputData;
+        }
+
+        if (this.__pipeline) {
+          this.__pipeline.currentTask = this;
+        }
+
+        var planResult;
+
+        if (this._plan && !skip) {
+          planResult = this._plan(this.context);
+        } // Support sharding by mod, which changes the render sequence and makes the rendered graphic
+        // elements uniformed distributed when progress, especially when moving or zooming.
+
+
+        var lastModBy = normalizeModBy(this._modBy);
+        var lastModDataCount = this._modDataCount || 0;
+        var modBy = normalizeModBy(performArgs && performArgs.modBy);
+        var modDataCount = performArgs && performArgs.modDataCount || 0;
+
+        if (lastModBy !== modBy || lastModDataCount !== modDataCount) {
+          planResult = 'reset';
+        }
+
+        function normalizeModBy(val) {
+          !(val >= 1) && (val = 1); // jshint ignore:line
+
+          return val;
+        }
+
+        var forceFirstProgress;
+
+        if (this._dirty || planResult === 'reset') {
+          this._dirty = false;
+          forceFirstProgress = this._doReset(skip);
+        }
+
+        this._modBy = modBy;
+        this._modDataCount = modDataCount;
+        var step = performArgs && performArgs.step;
+
+        if (upTask) {
+          if ("development" !== 'production') {
+            assert(upTask._outputDueEnd != null);
+          }
+
+          this._dueEnd = upTask._outputDueEnd;
+        } // DataTask or overallTask
+        else {
+            if ("development" !== 'production') {
+              assert(!this._progress || this._count);
+            }
+
+            this._dueEnd = this._count ? this._count(this.context) : Infinity;
+          } // Note: Stubs, that its host overall task let it has progress, has progress.
+        // If no progress, pass index from upstream to downstream each time plan called.
+
+
+        if (this._progress) {
+          var start = this._dueIndex;
+          var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);
+
+          if (!skip && (forceFirstProgress || start < end)) {
+            var progress = this._progress;
+
+            if (isArray(progress)) {
+              for (var i = 0; i < progress.length; i++) {
+                this._doProgress(progress[i], start, end, modBy, modDataCount);
+              }
+            } else {
+              this._doProgress(progress, start, end, modBy, modDataCount);
+            }
+          }
+
+          this._dueIndex = end; // If no `outputDueEnd`, assume that output data and
+          // input data is the same, so use `dueIndex` as `outputDueEnd`.
+
+          var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end;
+
+          if ("development" !== 'production') {
+            // ??? Can not rollback.
+            assert(outputDueEnd >= this._outputDueEnd);
+          }
+
+          this._outputDueEnd = outputDueEnd;
+        } else {
+          // (1) Some overall task has no progress.
+          // (2) Stubs, that its host overall task do not let it has progress, has no progress.
+          // This should always be performed so it can be passed to downstream.
+          this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;
+        }
+
+        return this.unfinished();
+      };
+
+      Task.prototype.dirty = function () {
+        this._dirty = true;
+        this._onDirty && this._onDirty(this.context);
+      };
+
+      Task.prototype._doProgress = function (progress, start, end, modBy, modDataCount) {
+        iterator.reset(start, end, modBy, modDataCount);
+        this._callingProgress = progress;
+
+        this._callingProgress({
+          start: start,
+          end: end,
+          count: end - start,
+          next: iterator.next
+        }, this.context);
+      };
+
+      Task.prototype._doReset = function (skip) {
+        this._dueIndex = this._outputDueEnd = this._dueEnd = 0;
+        this._settedOutputEnd = null;
+        var progress;
+        var forceFirstProgress;
+
+        if (!skip && this._reset) {
+          progress = this._reset(this.context);
+
+          if (progress && progress.progress) {
+            forceFirstProgress = progress.forceFirstProgress;
+            progress = progress.progress;
+          } // To simplify no progress checking, array must has item.
+
+
+          if (isArray(progress) && !progress.length) {
+            progress = null;
+          }
+        }
+
+        this._progress = progress;
+        this._modBy = this._modDataCount = null;
+        var downstream = this._downstream;
+        downstream && downstream.dirty();
+        return forceFirstProgress;
+      };
+
+      Task.prototype.unfinished = function () {
+        return this._progress && this._dueIndex < this._dueEnd;
+      };
+      /**
+       * @param downTask The downstream task.
+       * @return The downstream task.
+       */
+
+
+      Task.prototype.pipe = function (downTask) {
+        if ("development" !== 'production') {
+          assert(downTask && !downTask._disposed && downTask !== this);
+        } // If already downstream, do not dirty downTask.
+
+
+        if (this._downstream !== downTask || this._dirty) {
+          this._downstream = downTask;
+          downTask._upstream = this;
+          downTask.dirty();
+        }
+      };
+
+      Task.prototype.dispose = function () {
+        if (this._disposed) {
+          return;
+        }
+
+        this._upstream && (this._upstream._downstream = null);
+        this._downstream && (this._downstream._upstream = null);
+        this._dirty = false;
+        this._disposed = true;
+      };
+
+      Task.prototype.getUpstream = function () {
+        return this._upstream;
+      };
+
+      Task.prototype.getDownstream = function () {
+        return this._downstream;
+      };
+
+      Task.prototype.setOutputEnd = function (end) {
+        // This only happend in dataTask, dataZoom, map, currently.
+        // where dataZoom do not set end each time, but only set
+        // when reset. So we should record the setted end, in case
+        // that the stub of dataZoom perform again and earse the
+        // setted end by upstream.
+        this._outputDueEnd = this._settedOutputEnd = end;
+      };
+
+      return Task;
+    }();
+
+    var iterator = function () {
+      var end;
+      var current;
+      var modBy;
+      var modDataCount;
+      var winCount;
+      var it = {
+        reset: function (s, e, sStep, sCount) {
+          current = s;
+          end = e;
+          modBy = sStep;
+          modDataCount = sCount;
+          winCount = Math.ceil(modDataCount / modBy);
+          it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;
+        }
+      };
+      return it;
+
+      function sequentialNext() {
+        return current < end ? current++ : null;
+      }
+
+      function modNext() {
+        var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);
+        var result = current >= end ? null : dataIndex < modDataCount ? dataIndex // If modDataCount is smaller than data.count() (consider `appendData` case),
+        // Use normal linear rendering mode.
+        : current;
+        current++;
+        return result;
+      }
+    }(); ///////////////////////////////////////////////////////////
+    // For stream debug (Should be commented out after used!)
+    // @usage: printTask(this, 'begin');
+    // @usage: printTask(this, null, {someExtraProp});
+    // @usage: Use `__idxInPipeline` as conditional breakpiont.
+    //
+    // window.printTask = function (task: any, prefix: string, extra: { [key: string]: unknown }): void {
+    //     window.ecTaskUID == null && (window.ecTaskUID = 0);
+    //     task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);
+    //     task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);
+    //     let props = [];
+    //     if (task.__pipeline) {
+    //         let val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;
+    //         props.push({text: '__idxInPipeline/total', value: val});
+    //     } else {
+    //         let stubCount = 0;
+    //         task.agentStubMap.each(() => stubCount++);
+    //         props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});
+    //     }
+    //     props.push({text: 'uid', value: task.uidDebug});
+    //     if (task.__pipeline) {
+    //         props.push({text: 'pipelineId', value: task.__pipeline.id});
+    //         task.agent && props.push(
+    //             {text: 'stubFor', value: task.agent.uidDebug}
+    //         );
+    //     }
+    //     props.push(
+    //         {text: 'dirty', value: task._dirty},
+    //         {text: 'dueIndex', value: task._dueIndex},
+    //         {text: 'dueEnd', value: task._dueEnd},
+    //         {text: 'outputDueEnd', value: task._outputDueEnd}
+    //     );
+    //     if (extra) {
+    //         Object.keys(extra).forEach(key => {
+    //             props.push({text: key, value: extra[key]});
+    //         });
+    //     }
+    //     let args = ['color: blue'];
+    //     let msg = `%c[${prefix || 'T'}] %c` + props.map(item => (
+    //         args.push('color: green', 'color: red'),
+    //         `${item.text}: %c${item.value}`
+    //     )).join('%c, ');
+    //     console.log.apply(console, [msg].concat(args));
+    //     // console.log(this);
+    // };
+    // window.printPipeline = function (task: any, prefix: string) {
+    //     const pipeline = task.__pipeline;
+    //     let currTask = pipeline.head;
+    //     while (currTask) {
+    //         window.printTask(currTask, prefix);
+    //         currTask = currTask._downstream;
+    //     }
+    // };
+    // window.showChain = function (chainHeadTask) {
+    //     var chain = [];
+    //     var task = chainHeadTask;
+    //     while (task) {
+    //         chain.push({
+    //             task: task,
+    //             up: task._upstream,
+    //             down: task._downstream,
+    //             idxInPipeline: task.__idxInPipeline
+    //         });
+    //         task = task._downstream;
+    //     }
+    //     return chain;
+    // };
+    // window.findTaskInChain = function (task, chainHeadTask) {
+    //     let chain = window.showChain(chainHeadTask);
+    //     let result = [];
+    //     for (let i = 0; i < chain.length; i++) {
+    //         let chainItem = chain[i];
+    //         if (chainItem.task === task) {
+    //             result.push(i);
+    //         }
+    //     }
+    //     return result;
+    // };
+    // window.printChainAEachInChainB = function (chainHeadTaskA, chainHeadTaskB) {
+    //     let chainA = window.showChain(chainHeadTaskA);
+    //     for (let i = 0; i < chainA.length; i++) {
+    //         console.log('chainAIdx:', i, 'inChainB:', window.findTaskInChain(chainA[i].task, chainHeadTaskB));
+    //     }
+    // };
+
+    /**
+     * Convert raw the value in to inner value in List.
+     *
+     * [Performance sensitive]
+     *
+     * [Caution]: this is the key logic of user value parser.
+     * For backward compatibiliy, do not modify it until have to!
+     */
+
+    function parseDataValue(value, // For high performance, do not omit the second param.
+    opt) {
+      // Performance sensitive.
+      var dimType = opt && opt.type;
+
+      if (dimType === 'ordinal') {
+        // If given value is a category string
+        var ordinalMeta = opt && opt.ordinalMeta;
+        return ordinalMeta ? ordinalMeta.parseAndCollect(value) : value;
+      }
+
+      if (dimType === 'time' // spead up when using timestamp
+      && typeof value !== 'number' && value != null && value !== '-') {
+        value = +parseDate(value);
+      } // dimType defaults 'number'.
+      // If dimType is not ordinal and value is null or undefined or NaN or '-',
+      // parse to NaN.
+      // number-like string (like ' 123 ') can be converted to a number.
+      // where null/undefined or other string will be converted to NaN.
+
+
+      return value == null || value === '' ? NaN // If string (like '-'), using '+' parse to NaN
+      // If object, also parse to NaN
+      : +value;
+    }
+    var valueParserMap = createHashMap({
+      'number': function (val) {
+        // Do not use `numericToNumber` here. We have by defualt `numericToNumber`.
+        // Here the number parser can have loose rule:
+        // enable to cut suffix: "120px" => 120, "14%" => 14.
+        return parseFloat(val);
+      },
+      'time': function (val) {
+        // return timestamp.
+        return +parseDate(val);
+      },
+      'trim': function (val) {
+        return typeof val === 'string' ? trim(val) : val;
+      }
+    });
+    function getRawValueParser(type) {
+      return valueParserMap.get(type);
+    }
+    var ORDER_COMPARISON_OP_MAP = {
+      lt: function (lval, rval) {
+        return lval < rval;
+      },
+      lte: function (lval, rval) {
+        return lval <= rval;
+      },
+      gt: function (lval, rval) {
+        return lval > rval;
+      },
+      gte: function (lval, rval) {
+        return lval >= rval;
+      }
+    };
+
+    var FilterOrderComparator =
+    /** @class */
+    function () {
+      function FilterOrderComparator(op, rval) {
+        if (typeof rval !== 'number') {
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            errMsg = 'rvalue of "<", ">", "<=", ">=" can only be number in filter.';
+          }
+
+          throwError(errMsg);
+        }
+
+        this._opFn = ORDER_COMPARISON_OP_MAP[op];
+        this._rvalFloat = numericToNumber(rval);
+      } // Performance sensitive.
+
+
+      FilterOrderComparator.prototype.evaluate = function (lval) {
+        // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+        return typeof lval === 'number' ? this._opFn(lval, this._rvalFloat) : this._opFn(numericToNumber(lval), this._rvalFloat);
+      };
+
+      return FilterOrderComparator;
+    }();
+
+    var SortOrderComparator =
+    /** @class */
+    function () {
+      /**
+       * @param order by defualt: 'asc'
+       * @param incomparable by defualt: Always on the tail.
+       *        That is, if 'asc' => 'max', if 'desc' => 'min'
+       *        See the definition of "incomparable" in [SORT_COMPARISON_RULE]
+       */
+      function SortOrderComparator(order, incomparable) {
+        var isDesc = order === 'desc';
+        this._resultLT = isDesc ? 1 : -1;
+
+        if (incomparable == null) {
+          incomparable = isDesc ? 'min' : 'max';
+        }
+
+        this._incomparable = incomparable === 'min' ? -Infinity : Infinity;
+      } // See [SORT_COMPARISON_RULE].
+      // Performance sensitive.
+
+
+      SortOrderComparator.prototype.evaluate = function (lval, rval) {
+        // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+        var lvalTypeof = typeof lval;
+        var rvalTypeof = typeof rval;
+        var lvalFloat = lvalTypeof === 'number' ? lval : numericToNumber(lval);
+        var rvalFloat = rvalTypeof === 'number' ? rval : numericToNumber(rval);
+        var lvalNotNumeric = isNaN(lvalFloat);
+        var rvalNotNumeric = isNaN(rvalFloat);
+
+        if (lvalNotNumeric) {
+          lvalFloat = this._incomparable;
+        }
+
+        if (rvalNotNumeric) {
+          rvalFloat = this._incomparable;
+        }
+
+        if (lvalNotNumeric && rvalNotNumeric) {
+          var lvalIsStr = lvalTypeof === 'string';
+          var rvalIsStr = rvalTypeof === 'string';
+
+          if (lvalIsStr) {
+            lvalFloat = rvalIsStr ? lval : 0;
+          }
+
+          if (rvalIsStr) {
+            rvalFloat = lvalIsStr ? rval : 0;
+          }
+        }
+
+        return lvalFloat < rvalFloat ? this._resultLT : lvalFloat > rvalFloat ? -this._resultLT : 0;
+      };
+
+      return SortOrderComparator;
+    }();
+
+    var FilterEqualityComparator =
+    /** @class */
+    function () {
+      function FilterEqualityComparator(isEq, rval) {
+        this._rval = rval;
+        this._isEQ = isEq;
+        this._rvalTypeof = typeof rval;
+        this._rvalFloat = numericToNumber(rval);
+      } // Performance sensitive.
+
+
+      FilterEqualityComparator.prototype.evaluate = function (lval) {
+        var eqResult = lval === this._rval;
+
+        if (!eqResult) {
+          var lvalTypeof = typeof lval;
+
+          if (lvalTypeof !== this._rvalTypeof && (lvalTypeof === 'number' || this._rvalTypeof === 'number')) {
+            eqResult = numericToNumber(lval) === this._rvalFloat;
+          }
+        }
+
+        return this._isEQ ? eqResult : !eqResult;
+      };
+
+      return FilterEqualityComparator;
+    }();
+    /**
+     * [FILTER_COMPARISON_RULE]
+     * `lt`|`lte`|`gt`|`gte`:
+     * + rval must be a number. And lval will be converted to number (`numericToNumber`) to compare.
+     * `eq`:
+     * + If same type, compare with `===`.
+     * + If there is one number, convert to number (`numericToNumber`) to compare.
+     * + Else return `false`.
+     * `ne`:
+     * + Not `eq`.
+     *
+     *
+     * [SORT_COMPARISON_RULE]
+     * All the values are grouped into three categories:
+     * + "numeric" (number and numeric string)
+     * + "non-numeric-string" (string that excluding numeric string)
+     * + "others"
+     * "numeric" vs "numeric": values are ordered by number order.
+     * "non-numeric-string" vs "non-numeric-string": values are ordered by ES spec (#sec-abstract-relational-comparison).
+     * "others" vs "others": do not change order (always return 0).
+     * "numeric" vs "non-numeric-string": "non-numeric-string" is treated as "incomparable".
+     * "number" vs "others": "others" is treated as "incomparable".
+     * "non-numeric-string" vs "others": "others" is treated as "incomparable".
+     * "incomparable" will be seen as -Infinity or Infinity (depends on the settings).
+     * MEMO:
+     *   non-numeric string sort make sence when need to put the items with the same tag together.
+     *   But if we support string sort, we still need to avoid the misleading like `'2' > '12'`,
+     *   So we treat "numeric-string" sorted by number order rather than string comparison.
+     *
+     *
+     * [CHECK_LIST_OF_THE_RULE_DESIGN]
+     * + Do not support string comparison until required. And also need to
+     *   void the misleading of "2" > "12".
+     * + Should avoid the misleading case:
+     *   `" 22 " gte "22"` is `true` but `" 22 " eq "22"` is `false`.
+     * + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...
+     * + Only "numeric" can be converted to comparable number, otherwise converted to NaN.
+     *   See `util/number.ts#numericToNumber`.
+     *
+     * @return If `op` is not `RelationalOperator`, return null;
+     */
+
+
+    function createFilterComparator(op, rval) {
+      return op === 'eq' || op === 'ne' ? new FilterEqualityComparator(op === 'eq', rval) : hasOwn(ORDER_COMPARISON_OP_MAP, op) ? new FilterOrderComparator(op, rval) : null;
+    }
+
+    /**
+     * TODO: disable writable.
+     * This structure will be exposed to users.
+     */
+
+    var ExternalSource =
+    /** @class */
+    function () {
+      function ExternalSource() {}
+
+      ExternalSource.prototype.getRawData = function () {
+        // Only built-in transform available.
+        throw new Error('not supported');
+      };
+
+      ExternalSource.prototype.getRawDataItem = function (dataIndex) {
+        // Only built-in transform available.
+        throw new Error('not supported');
+      };
+
+      ExternalSource.prototype.cloneRawData = function () {
+        return;
+      };
+      /**
+       * @return If dimension not found, return null/undefined.
+       */
+
+
+      ExternalSource.prototype.getDimensionInfo = function (dim) {
+        return;
+      };
+      /**
+       * dimensions defined if and only if either:
+       * (a) dataset.dimensions are declared.
+       * (b) dataset data include dimensions definitions in data (detected or via specified `sourceHeader`).
+       * If dimensions are defined, `dimensionInfoAll` is corresponding to
+       * the defined dimensions.
+       * Otherwise, `dimensionInfoAll` is determined by data columns.
+       * @return Always return an array (even empty array).
+       */
+
+
+      ExternalSource.prototype.cloneAllDimensionInfo = function () {
+        return;
+      };
+
+      ExternalSource.prototype.count = function () {
+        return;
+      };
+      /**
+       * Only support by dimension index.
+       * No need to support by dimension name in transform function,
+       * becuase transform function is not case-specific, no need to use name literally.
+       */
+
+
+      ExternalSource.prototype.retrieveValue = function (dataIndex, dimIndex) {
+        return;
+      };
+
+      ExternalSource.prototype.retrieveValueFromItem = function (dataItem, dimIndex) {
+        return;
+      };
+
+      ExternalSource.prototype.convertValue = function (rawVal, dimInfo) {
+        return parseDataValue(rawVal, dimInfo);
+      };
+
+      return ExternalSource;
+    }();
+
+    function createExternalSource(internalSource, externalTransform) {
+      var extSource = new ExternalSource();
+      var data = internalSource.data;
+      var sourceFormat = extSource.sourceFormat = internalSource.sourceFormat;
+      var sourceHeaderCount = internalSource.startIndex;
+      var errMsg = '';
+
+      if (internalSource.seriesLayoutBy !== SERIES_LAYOUT_BY_COLUMN) {
+        // For the logic simplicity in transformer, only 'culumn' is
+        // supported in data transform. Otherwise, the `dimensionsDefine`
+        // might be detected by 'row', which probably confuses users.
+        if ("development" !== 'production') {
+          errMsg = '`seriesLayoutBy` of upstream dataset can only be "column" in data transform.';
+        }
+
+        throwError(errMsg);
+      } // [MEMO]
+      // Create a new dimensions structure for exposing.
+      // Do not expose all dimension info to users directly.
+      // Becuase the dimension is probably auto detected from data and not might reliable.
+      // Should not lead the transformers to think that is relialbe and return it.
+      // See [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.
+
+
+      var dimensions = [];
+      var dimsByName = {};
+      var dimsDef = internalSource.dimensionsDefine;
+
+      if (dimsDef) {
+        each(dimsDef, function (dimDef, idx) {
+          var name = dimDef.name;
+          var dimDefExt = {
+            index: idx,
+            name: name,
+            displayName: dimDef.displayName
+          };
+          dimensions.push(dimDefExt); // Users probably not sepcify dimension name. For simplicity, data transform
+          // do not generate dimension name.
+
+          if (name != null) {
+            // Dimension name should not be duplicated.
+            // For simplicity, data transform forbid name duplication, do not generate
+            // new name like module `completeDimensions.ts` did, but just tell users.
+            var errMsg_1 = '';
+
+            if (hasOwn(dimsByName, name)) {
+              if ("development" !== 'production') {
+                errMsg_1 = 'dimension name "' + name + '" duplicated.';
+              }
+
+              throwError(errMsg_1);
+            }
+
+            dimsByName[name] = dimDefExt;
+          }
+        });
+      } // If dimension definitions are not defined and can not be detected.
+      // e.g., pure data `[[11, 22], ...]`.
+      else {
+          for (var i = 0; i < internalSource.dimensionsDetectedCount || 0; i++) {
+            // Do not generete name or anything others. The consequence process in
+            // `transform` or `series` probably have there own name generation strategry.
+            dimensions.push({
+              index: i
+            });
+          }
+        } // Implement public methods:
+
+
+      var rawItemGetter = getRawSourceItemGetter(sourceFormat, SERIES_LAYOUT_BY_COLUMN);
+
+      if (externalTransform.__isBuiltIn) {
+        extSource.getRawDataItem = function (dataIndex) {
+          return rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex);
+        };
+
+        extSource.getRawData = bind(getRawData, null, internalSource);
+      }
+
+      extSource.cloneRawData = bind(cloneRawData, null, internalSource);
+      var rawCounter = getRawSourceDataCounter(sourceFormat, SERIES_LAYOUT_BY_COLUMN);
+      extSource.count = bind(rawCounter, null, data, sourceHeaderCount, dimensions);
+      var rawValueGetter = getRawSourceValueGetter(sourceFormat);
+
+      extSource.retrieveValue = function (dataIndex, dimIndex) {
+        var rawItem = rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex);
+        return retrieveValueFromItem(rawItem, dimIndex);
+      };
+
+      var retrieveValueFromItem = extSource.retrieveValueFromItem = function (dataItem, dimIndex) {
+        if (dataItem == null) {
+          return;
+        }
+
+        var dimDef = dimensions[dimIndex]; // When `dimIndex` is `null`, `rawValueGetter` return the whole item.
+
+        if (dimDef) {
+          return rawValueGetter(dataItem, dimIndex, dimDef.name);
+        }
+      };
+
+      extSource.getDimensionInfo = bind(getDimensionInfo, null, dimensions, dimsByName);
+      extSource.cloneAllDimensionInfo = bind(cloneAllDimensionInfo, null, dimensions);
+      return extSource;
+    }
+
+    function getRawData(upstream) {
+      var sourceFormat = upstream.sourceFormat;
+
+      if (!isSupportedSourceFormat(sourceFormat)) {
+        var errMsg = '';
+
+        if ("development" !== 'production') {
+          errMsg = '`getRawData` is not supported in source format ' + sourceFormat;
+        }
+
+        throwError(errMsg);
+      }
+
+      return upstream.data;
+    }
+
+    function cloneRawData(upstream) {
+      var sourceFormat = upstream.sourceFormat;
+      var data = upstream.data;
+
+      if (!isSupportedSourceFormat(sourceFormat)) {
+        var errMsg = '';
+
+        if ("development" !== 'production') {
+          errMsg = '`cloneRawData` is not supported in source format ' + sourceFormat;
+        }
+
+        throwError(errMsg);
+      }
+
+      if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
+        var result = [];
+
+        for (var i = 0, len = data.length; i < len; i++) {
+          // Not strictly clone for performance
+          result.push(data[i].slice());
+        }
+
+        return result;
+      } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
+        var result = [];
+
+        for (var i = 0, len = data.length; i < len; i++) {
+          // Not strictly clone for performance
+          result.push(extend({}, data[i]));
+        }
+
+        return result;
+      }
+    }
+
+    function getDimensionInfo(dimensions, dimsByName, dim) {
+      if (dim == null) {
+        return;
+      } // Keep the same logic as `List::getDimension` did.
+
+
+      if (typeof dim === 'number' // If being a number-like string but not being defined a dimension name.
+      || !isNaN(dim) && !hasOwn(dimsByName, dim)) {
+        return dimensions[dim];
+      } else if (hasOwn(dimsByName, dim)) {
+        return dimsByName[dim];
+      }
+    }
+
+    function cloneAllDimensionInfo(dimensions) {
+      return clone(dimensions);
+    }
+
+    var externalTransformMap = createHashMap();
+    function registerExternalTransform(externalTransform) {
+      externalTransform = clone(externalTransform);
+      var type = externalTransform.type;
+      var errMsg = '';
+
+      if (!type) {
+        if ("development" !== 'production') {
+          errMsg = 'Must have a `type` when `registerTransform`.';
+        }
+
+        throwError(errMsg);
+      }
+
+      var typeParsed = type.split(':');
+
+      if (typeParsed.length !== 2) {
+        if ("development" !== 'production') {
+          errMsg = 'Name must include namespace like "ns:regression".';
+        }
+
+        throwError(errMsg);
+      } // Namespace 'echarts:xxx' is official namespace, where the transforms should
+      // be called directly via 'xxx' rather than 'echarts:xxx'.
+
+
+      var isBuiltIn = false;
+
+      if (typeParsed[0] === 'echarts') {
+        type = typeParsed[1];
+        isBuiltIn = true;
+      }
+
+      externalTransform.__isBuiltIn = isBuiltIn;
+      externalTransformMap.set(type, externalTransform);
+    }
+    function applyDataTransform(rawTransOption, sourceList, infoForPrint) {
+      var pipedTransOption = normalizeToArray(rawTransOption);
+      var pipeLen = pipedTransOption.length;
+      var errMsg = '';
+
+      if (!pipeLen) {
+        if ("development" !== 'production') {
+          errMsg = 'If `transform` declared, it should at least contain one transform.';
+        }
+
+        throwError(errMsg);
+      }
+
+      for (var i = 0, len = pipeLen; i < len; i++) {
+        var transOption = pipedTransOption[i];
+        sourceList = applySingleDataTransform(transOption, sourceList, infoForPrint, pipeLen === 1 ? null : i); // piped transform only support single input, except the fist one.
+        // piped transform only support single output, except the last one.
+
+        if (i !== len - 1) {
+          sourceList.length = Math.max(sourceList.length, 1);
+        }
+      }
+
+      return sourceList;
+    }
+
+    function applySingleDataTransform(transOption, upSourceList, infoForPrint, // If `pipeIndex` is null/undefined, no piped transform.
+    pipeIndex) {
+      var errMsg = '';
+
+      if (!upSourceList.length) {
+        if ("development" !== 'production') {
+          errMsg = 'Must have at least one upstream dataset.';
+        }
+
+        throwError(errMsg);
+      }
+
+      if (!isObject(transOption)) {
+        if ("development" !== 'production') {
+          errMsg = 'transform declaration must be an object rather than ' + typeof transOption + '.';
+        }
+
+        throwError(errMsg);
+      }
+
+      var transType = transOption.type;
+      var externalTransform = externalTransformMap.get(transType);
+
+      if (!externalTransform) {
+        if ("development" !== 'production') {
+          errMsg = 'Can not find transform on type "' + transType + '".';
+        }
+
+        throwError(errMsg);
+      } // Prepare source
+
+
+      var extUpSourceList = map(upSourceList, function (upSource) {
+        return createExternalSource(upSource, externalTransform);
+      });
+      var resultList = normalizeToArray(externalTransform.transform({
+        upstream: extUpSourceList[0],
+        upstreamList: extUpSourceList,
+        config: clone(transOption.config)
+      }));
+
+      if ("development" !== 'production') {
+        if (transOption.print) {
+          var printStrArr = map(resultList, function (extSource) {
+            var pipeIndexStr = pipeIndex != null ? ' === pipe index: ' + pipeIndex : '';
+            return ['=== dataset index: ' + infoForPrint.datasetIndex + pipeIndexStr + ' ===', '- transform result data:', makePrintable(extSource.data), '- transform result dimensions:', makePrintable(extSource.dimensions)].join('\n');
+          }).join('\n');
+          consoleLog(printStrArr);
+        }
+      }
+
+      return map(resultList, function (result, resultIndex) {
+        var errMsg = '';
+
+        if (!isObject(result)) {
+          if ("development" !== 'production') {
+            errMsg = 'A transform should not return some empty results.';
+          }
+
+          throwError(errMsg);
+        }
+
+        if (!result.data) {
+          if ("development" !== 'production') {
+            errMsg = 'Transform result data should be not be null or undefined';
+          }
+
+          throwError(errMsg);
+        }
+
+        var sourceFormat = detectSourceFormat(result.data);
+
+        if (!isSupportedSourceFormat(sourceFormat)) {
+          if ("development" !== 'production') {
+            errMsg = 'Transform result data should be array rows or object rows.';
+          }
+
+          throwError(errMsg);
+        }
+
+        var resultMetaRawOption;
+        var firstUpSource = upSourceList[0];
+        /**
+         * Intuitively, the end users known the content of the original `dataset.source`,
+         * calucating the transform result in mind.
+         * Suppose the original `dataset.source` is:
+         * ```js
+         * [
+         *     ['product', '2012', '2013', '2014', '2015'],
+         *     ['AAA', 41.1, 30.4, 65.1, 53.3],
+         *     ['BBB', 86.5, 92.1, 85.7, 83.1],
+         *     ['CCC', 24.1, 67.2, 79.5, 86.4]
+         * ]
+         * ```
+         * The dimension info have to be detected from the source data.
+         * Some of the transformers (like filter, sort) will follow the dimension info
+         * of upstream, while others use new dimensions (like aggregate).
+         * Transformer can output a field `dimensions` to define the its own output dimensions.
+         * We also allow transformers to ignore the output `dimensions` field, and
+         * inherit the upstream dimensions definition. It can reduce the burden of handling
+         * dimensions in transformers.
+         *
+         * See also [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.
+         */
+
+        if (firstUpSource && resultIndex === 0 // If transformer returns `dimensions`, it means that the transformer has different
+        // dimensions definitions. We do not inherit anything from upstream.
+        && !result.dimensions) {
+          var startIndex = firstUpSource.startIndex; // We copy the header of upstream to the result becuase:
+          // (1) The returned data always does not contain header line and can not be used
+          // as dimension-detection. In this case we can not use "detected dimensions" of
+          // upstream directly, because it might be detected based on different `seriesLayoutBy`.
+          // (2) We should support that the series read the upstream source in `seriesLayoutBy: 'row'`.
+          // So the original detected header should be add to the result, otherwise they can not be read.
+
+          if (startIndex) {
+            result.data = firstUpSource.data.slice(0, startIndex).concat(result.data);
+          }
+
+          resultMetaRawOption = {
+            seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,
+            sourceHeader: startIndex,
+            dimensions: firstUpSource.metaRawOption.dimensions
+          };
+        } else {
+          resultMetaRawOption = {
+            seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,
+            sourceHeader: 0,
+            dimensions: result.dimensions
+          };
+        }
+
+        return createSource(result.data, resultMetaRawOption, null, null);
+      });
+    }
+
+    function isSupportedSourceFormat(sourceFormat) {
+      return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS || sourceFormat === SOURCE_FORMAT_OBJECT_ROWS;
+    }
+
+    /**
+     * [REQUIREMENT_MEMO]:
+     * (0) `metaRawOption` means `dimensions`/`sourceHeader`/`seriesLayoutBy` in raw option.
+     * (1) Keep support the feature: `metaRawOption` can be specified both on `series` and
+     * `root-dataset`. Them on `series` has higher priority.
+     * (2) Do not support to set `metaRawOption` on a `non-root-dataset`, because it might
+     * confuse users: whether those props indicate how to visit the upstream source or visit
+     * the transform result source, and some transforms has nothing to do with these props,
+     * and some transforms might have multiple upstream.
+     * (3) Transforms should specify `metaRawOption` in each output, just like they can be
+     * declared in `root-dataset`.
+     * (4) At present only support visit source in `SERIES_LAYOUT_BY_COLUMN` in transforms.
+     * That is for reducing complexity in transfroms.
+     * PENDING: Whether to provide transposition transform?
+     *
+     * [IMPLEMENTAION_MEMO]:
+     * "sourceVisitConfig" are calculated from `metaRawOption` and `data`.
+     * They will not be calculated until `source` is about to be visited (to prevent from
+     * duplicate calcuation). `source` is visited only in series and input to transforms.
+     *
+     * [DIMENSION_INHERIT_RULE]:
+     * By default the dimensions are inherited from ancestors, unless a transform return
+     * a new dimensions definition.
+     * Consider the case:
+     * ```js
+     * dataset: [{
+     *     source: [ ['Product', 'Sales', 'Prise'], ['Cookies', 321, 44.21], ...]
+     * }, {
+     *     transform: { type: 'filter', ... }
+     * }]
+     * dataset: [{
+     *     dimension: ['Product', 'Sales', 'Prise'],
+     *     source: [ ['Cookies', 321, 44.21], ...]
+     * }, {
+     *     transform: { type: 'filter', ... }
+     * }]
+     * ```
+     * The two types of option should have the same behavior after transform.
+     *
+     *
+     * [SCENARIO]:
+     * (1) Provide source data directly:
+     * ```js
+     * series: {
+     *     encode: {...},
+     *     dimensions: [...]
+     *     seriesLayoutBy: 'row',
+     *     data: [[...]]
+     * }
+     * ```
+     * (2) Series refer to dataset.
+     * ```js
+     * series: [{
+     *     encode: {...}
+     *     // Ignore datasetIndex means `datasetIndex: 0`
+     *     // and the dimensions defination in dataset is used
+     * }, {
+     *     encode: {...},
+     *     seriesLayoutBy: 'column',
+     *     datasetIndex: 1
+     * }]
+     * ```
+     * (3) dataset transform
+     * ```js
+     * dataset: [{
+     *     source: [...]
+     * }, {
+     *     source: [...]
+     * }, {
+     *     // By default from 0.
+     *     transform: { type: 'filter', config: {...} }
+     * }, {
+     *     // Piped.
+     *     transform: [
+     *         { type: 'filter', config: {...} },
+     *         { type: 'sort', config: {...} }
+     *     ]
+     * }, {
+     *     id: 'regressionData',
+     *     fromDatasetIndex: 1,
+     *     // Third-party transform
+     *     transform: { type: 'ecStat:regression', config: {...} }
+     * }, {
+     *     // retrieve the extra result.
+     *     id: 'regressionFormula',
+     *     fromDatasetId: 'regressionData',
+     *     fromTransformResult: 1
+     * }]
+     * ```
+     */
+
+    var SourceManager =
+    /** @class */
+    function () {
+      function SourceManager(sourceHost) {
+        // Cached source. Do not repeat calculating if not dirty.
+        this._sourceList = []; // version sign of each upstream source manager.
+
+        this._upstreamSignList = [];
+        this._versionSignBase = 0;
+        this._sourceHost = sourceHost;
+      }
+      /**
+       * Mark dirty.
+       */
+
+
+      SourceManager.prototype.dirty = function () {
+        this._setLocalSource([], []);
+      };
+
+      SourceManager.prototype._setLocalSource = function (sourceList, upstreamSignList) {
+        this._sourceList = sourceList;
+        this._upstreamSignList = upstreamSignList;
+        this._versionSignBase++;
+
+        if (this._versionSignBase > 9e10) {
+          this._versionSignBase = 0;
+        }
+      };
+      /**
+       * For detecting whether the upstream source is dirty, so that
+       * the local cached source (in `_sourceList`) should be discarded.
+       */
+
+
+      SourceManager.prototype._getVersionSign = function () {
+        return this._sourceHost.uid + '_' + this._versionSignBase;
+      };
+      /**
+       * Always return a source instance. Otherwise throw error.
+       */
+
+
+      SourceManager.prototype.prepareSource = function () {
+        // For the case that call `setOption` multiple time but no data changed,
+        // cache the result source to prevent from repeating transform.
+        if (this._isDirty()) {
+          this._createSource();
+        }
+      };
+
+      SourceManager.prototype._createSource = function () {
+        this._setLocalSource([], []);
+
+        var sourceHost = this._sourceHost;
+
+        var upSourceMgrList = this._getUpstreamSourceManagers();
+
+        var hasUpstream = !!upSourceMgrList.length;
+        var resultSourceList;
+        var upstreamSignList;
+
+        if (isSeries(sourceHost)) {
+          var seriesModel = sourceHost;
+          var data = void 0;
+          var sourceFormat = void 0;
+          var upSource = void 0; // Has upstream dataset
+
+          if (hasUpstream) {
+            var upSourceMgr = upSourceMgrList[0];
+            upSourceMgr.prepareSource();
+            upSource = upSourceMgr.getSource();
+            data = upSource.data;
+            sourceFormat = upSource.sourceFormat;
+            upstreamSignList = [upSourceMgr._getVersionSign()];
+          } // Series data is from own.
+          else {
+              data = seriesModel.get('data', true);
+              sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;
+              upstreamSignList = [];
+            } // See [REQUIREMENT_MEMO], merge settings on series and parent dataset if it is root.
+
+
+          var newMetaRawOption = this._getSourceMetaRawOption();
+
+          var upMetaRawOption = upSource ? upSource.metaRawOption : null;
+          var seriesLayoutBy = retrieve2(newMetaRawOption.seriesLayoutBy, upMetaRawOption ? upMetaRawOption.seriesLayoutBy : null);
+          var sourceHeader = retrieve2(newMetaRawOption.sourceHeader, upMetaRawOption ? upMetaRawOption.sourceHeader : null); // Note here we should not use `upSource.dimensionsDefine`. Consider the case:
+          // `upSource.dimensionsDefine` is detected by `seriesLayoutBy: 'column'`,
+          // but series need `seriesLayoutBy: 'row'`.
+
+          var dimensions = retrieve2(newMetaRawOption.dimensions, upMetaRawOption ? upMetaRawOption.dimensions : null);
+          resultSourceList = [createSource(data, {
+            seriesLayoutBy: seriesLayoutBy,
+            sourceHeader: sourceHeader,
+            dimensions: dimensions
+          }, sourceFormat, seriesModel.get('encode', true))];
+        } else {
+          var datasetModel = sourceHost; // Has upstream dataset.
+
+          if (hasUpstream) {
+            var result = this._applyTransform(upSourceMgrList);
+
+            resultSourceList = result.sourceList;
+            upstreamSignList = result.upstreamSignList;
+          } // Is root dataset.
+          else {
+              var sourceData = datasetModel.get('source', true);
+              resultSourceList = [createSource(sourceData, this._getSourceMetaRawOption(), null, // Note: dataset option does not have `encode`.
+              null)];
+              upstreamSignList = [];
+            }
+        }
+
+        if ("development" !== 'production') {
+          assert(resultSourceList && upstreamSignList);
+        }
+
+        this._setLocalSource(resultSourceList, upstreamSignList);
+      };
+
+      SourceManager.prototype._applyTransform = function (upMgrList) {
+        var datasetModel = this._sourceHost;
+        var transformOption = datasetModel.get('transform', true);
+        var fromTransformResult = datasetModel.get('fromTransformResult', true);
+
+        if ("development" !== 'production') {
+          assert(fromTransformResult != null || transformOption != null);
+        }
+
+        if (fromTransformResult != null) {
+          var errMsg = '';
+
+          if (upMgrList.length !== 1) {
+            if ("development" !== 'production') {
+              errMsg = 'When using `fromTransformResult`, there should be only one upstream dataset';
+            }
+
+            doThrow(errMsg);
+          }
+        }
+
+        var sourceList;
+        var upSourceList = [];
+        var upstreamSignList = [];
+        each(upMgrList, function (upMgr) {
+          upMgr.prepareSource();
+          var upSource = upMgr.getSource(fromTransformResult || 0);
+          var errMsg = '';
+
+          if (fromTransformResult != null && !upSource) {
+            if ("development" !== 'production') {
+              errMsg = 'Can not retrieve result by `fromTransformResult`: ' + fromTransformResult;
+            }
+
+            doThrow(errMsg);
+          }
+
+          upSourceList.push(upSource);
+          upstreamSignList.push(upMgr._getVersionSign());
+        });
+
+        if (transformOption) {
+          sourceList = applyDataTransform(transformOption, upSourceList, {
+            datasetIndex: datasetModel.componentIndex
+          });
+        } else if (fromTransformResult != null) {
+          sourceList = [cloneSourceShallow(upSourceList[0])];
+        }
+
+        return {
+          sourceList: sourceList,
+          upstreamSignList: upstreamSignList
+        };
+      };
+
+      SourceManager.prototype._isDirty = function () {
+        var sourceList = this._sourceList;
+
+        if (!sourceList.length) {
+          return true;
+        } // All sourceList is from the some upsteam.
+
+
+        var upSourceMgrList = this._getUpstreamSourceManagers();
+
+        for (var i = 0; i < upSourceMgrList.length; i++) {
+          var upSrcMgr = upSourceMgrList[i];
+
+          if ( // Consider the case that there is ancestor diry, call it recursively.
+          // The performance is probably not an issue because usually the chain is not long.
+          upSrcMgr._isDirty() || this._upstreamSignList[i] !== upSrcMgr._getVersionSign()) {
+            return true;
+          }
+        }
+      };
+      /**
+       * @param sourceIndex By defualt 0, means "main source".
+       *                    Most cases there is only one source.
+       */
+
+
+      SourceManager.prototype.getSource = function (sourceIndex) {
+        return this._sourceList[sourceIndex || 0];
+      };
+      /**
+       * PEDING: Is it fast enough?
+       * If no upstream, return empty array.
+       */
+
+
+      SourceManager.prototype._getUpstreamSourceManagers = function () {
+        // Always get the relationship from the raw option.
+        // Do not cache the link of the dependency graph, so that
+        // no need to update them when change happen.
+        var sourceHost = this._sourceHost;
+
+        if (isSeries(sourceHost)) {
+          var datasetModel = querySeriesUpstreamDatasetModel(sourceHost);
+          return !datasetModel ? [] : [datasetModel.getSourceManager()];
+        } else {
+          return map(queryDatasetUpstreamDatasetModels(sourceHost), function (datasetModel) {
+            return datasetModel.getSourceManager();
+          });
+        }
+      };
+
+      SourceManager.prototype._getSourceMetaRawOption = function () {
+        var sourceHost = this._sourceHost;
+        var seriesLayoutBy;
+        var sourceHeader;
+        var dimensions;
+
+        if (isSeries(sourceHost)) {
+          seriesLayoutBy = sourceHost.get('seriesLayoutBy', true);
+          sourceHeader = sourceHost.get('sourceHeader', true);
+          dimensions = sourceHost.get('dimensions', true);
+        } // See [REQUIREMENT_MEMO], `non-root-dataset` do not support them.
+        else if (!this._getUpstreamSourceManagers().length) {
+            var model = sourceHost;
+            seriesLayoutBy = model.get('seriesLayoutBy', true);
+            sourceHeader = model.get('sourceHeader', true);
+            dimensions = model.get('dimensions', true);
+          }
+
+        return {
+          seriesLayoutBy: seriesLayoutBy,
+          sourceHeader: sourceHeader,
+          dimensions: dimensions
+        };
+      };
+
+      return SourceManager;
+    }();
+    // disable the transform merge, but do not disable transfrom clone from rawOption.
+
+    function disableTransformOptionMerge(datasetModel) {
+      var transformOption = datasetModel.option.transform;
+      transformOption && setAsPrimitive(datasetModel.option.transform);
+    }
+
+    function isSeries(sourceHost) {
+      // Avoid circular dependency with Series.ts
+      return sourceHost.mainType === 'series';
+    }
+
+    function doThrow(errMsg) {
+      throw new Error(errMsg);
+    }
+
+    var TOOLTIP_LINE_HEIGHT_CSS = 'line-height:1'; // TODO: more textStyle option
+
+    function getTooltipTextStyle(textStyle, renderMode) {
+      var nameFontColor = textStyle.color || '#6e7079';
+      var nameFontSize = textStyle.fontSize || 12;
+      var nameFontWeight = textStyle.fontWeight || '400';
+      var valueFontColor = textStyle.color || '#464646';
+      var valueFontSize = textStyle.fontSize || 14;
+      var valueFontWeight = textStyle.fontWeight || '900';
+
+      if (renderMode === 'html') {
+        // `textStyle` is probably from user input, should be encoded to reduce security risk.
+        return {
+          // eslint-disable-next-line max-len
+          nameStyle: "font-size:" + encodeHTML(nameFontSize + '') + "px;color:" + encodeHTML(nameFontColor) + ";font-weight:" + encodeHTML(nameFontWeight + ''),
+          // eslint-disable-next-line max-len
+          valueStyle: "font-size:" + encodeHTML(valueFontSize + '') + "px;color:" + encodeHTML(valueFontColor) + ";font-weight:" + encodeHTML(valueFontWeight + '')
+        };
+      } else {
+        return {
+          nameStyle: {
+            fontSize: nameFontSize,
+            fill: nameFontColor,
+            fontWeight: nameFontWeight
+          },
+          valueStyle: {
+            fontSize: valueFontSize,
+            fill: valueFontColor,
+            fontWeight: valueFontWeight
+          }
+        };
+      }
+    } // See `TooltipMarkupLayoutIntent['innerGapLevel']`.
+    // (value from UI design)
+
+
+    var HTML_GAPS = [0, 10, 20, 30];
+    var RICH_TEXT_GAPS = ['', '\n', '\n\n', '\n\n\n']; // eslint-disable-next-line max-len
+
+    function createTooltipMarkup(type, option) {
+      option.type = type;
+      return option;
+    }
+
+    function getBuilder(fragment) {
+      return hasOwn(builderMap, fragment.type) && builderMap[fragment.type];
+    }
+
+    var builderMap = {
+      /**
+       * A `section` block is like:
+       * ```
+       * header
+       * subBlock
+       * subBlock
+       * ...
+       * ```
+       */
+      section: {
+        planLayout: function (fragment) {
+          var subBlockLen = fragment.blocks.length;
+          var thisBlockHasInnerGap = subBlockLen > 1 || subBlockLen > 0 && !fragment.noHeader;
+          var thisGapLevelBetweenSubBlocks = 0;
+          each(fragment.blocks, function (subBlock) {
+            getBuilder(subBlock).planLayout(subBlock);
+            var subGapLevel = subBlock.__gapLevelBetweenSubBlocks; // If the some of the sub-blocks have some gaps (like 10px) inside, this block
+            // should use a larger gap (like 20px) to distinguish those sub-blocks.
+
+            if (subGapLevel >= thisGapLevelBetweenSubBlocks) {
+              thisGapLevelBetweenSubBlocks = subGapLevel + (thisBlockHasInnerGap && ( // 0 always can not be readable gap level.
+              !subGapLevel // If no header, always keep the sub gap level. Otherwise
+              // look weird in case `multipleSeries`.
+              || subBlock.type === 'section' && !subBlock.noHeader) ? 1 : 0);
+            }
+          });
+          fragment.__gapLevelBetweenSubBlocks = thisGapLevelBetweenSubBlocks;
+        },
+        build: function (ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+          var noHeader = fragment.noHeader;
+          var gaps = getGap(fragment);
+          var subMarkupText = buildSubBlocks(ctx, fragment, noHeader ? topMarginForOuterGap : gaps.html, toolTipTextStyle);
+
+          if (noHeader) {
+            return subMarkupText;
+          }
+
+          var displayableHeader = makeValueReadable(fragment.header, 'ordinal', ctx.useUTC);
+          var nameStyle = getTooltipTextStyle(toolTipTextStyle, ctx.renderMode).nameStyle;
+
+          if (ctx.renderMode === 'richText') {
+            return wrapInlineNameRichText(ctx, displayableHeader, nameStyle) + gaps.richText + subMarkupText;
+          } else {
+            return wrapBlockHTML("<div style=\"" + nameStyle + ";" + TOOLTIP_LINE_HEIGHT_CSS + ";\">" + encodeHTML(displayableHeader) + '</div>' + subMarkupText, topMarginForOuterGap);
+          }
+        }
+      },
+
+      /**
+       * A `nameValue` block is like:
+       * ```
+       * marker  name  value
+       * ```
+       */
+      nameValue: {
+        planLayout: function (fragment) {
+          fragment.__gapLevelBetweenSubBlocks = 0;
+        },
+        build: function (ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+          var renderMode = ctx.renderMode;
+          var noName = fragment.noName;
+          var noValue = fragment.noValue;
+          var noMarker = !fragment.markerType;
+          var name = fragment.name;
+          var value = fragment.value;
+          var useUTC = ctx.useUTC;
+
+          if (noName && noValue) {
+            return;
+          }
+
+          var markerStr = noMarker ? '' : ctx.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || '#333', renderMode);
+          var readableName = noName ? '' : makeValueReadable(name, 'ordinal', useUTC);
+          var valueTypeOption = fragment.valueType;
+          var readableValueList = noValue ? [] : isArray(value) ? map(value, function (val, idx) {
+            return makeValueReadable(val, isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption, useUTC);
+          }) : [makeValueReadable(value, isArray(valueTypeOption) ? valueTypeOption[0] : valueTypeOption, useUTC)];
+          var valueAlignRight = !noMarker || !noName; // It little weird if only value next to marker but far from marker.
+
+          var valueCloseToMarker = !noMarker && noName;
+
+          var _a = getTooltipTextStyle(toolTipTextStyle, renderMode),
+              nameStyle = _a.nameStyle,
+              valueStyle = _a.valueStyle;
+
+          return renderMode === 'richText' ? (noMarker ? '' : markerStr) + (noName ? '' : wrapInlineNameRichText(ctx, readableName, nameStyle)) // Value has commas inside, so use ' ' as delimiter for multiple values.
+          + (noValue ? '' : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML((noMarker ? '' : markerStr) + (noName ? '' : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? '' : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
+        }
+      }
+    };
+
+    function buildSubBlocks(ctx, fragment, topMarginForOuterGap, tooltipTextStyle) {
+      var subMarkupTextList = [];
+      var subBlocks = fragment.blocks || [];
+      assert(!subBlocks || isArray(subBlocks));
+      subBlocks = subBlocks || [];
+      var orderMode = ctx.orderMode;
+
+      if (fragment.sortBlocks && orderMode) {
+        subBlocks = subBlocks.slice();
+        var orderMap = {
+          valueAsc: 'asc',
+          valueDesc: 'desc'
+        };
+
+        if (hasOwn(orderMap, orderMode)) {
+          var comparator_1 = new SortOrderComparator(orderMap[orderMode], null);
+          subBlocks.sort(function (a, b) {
+            return comparator_1.evaluate(a.sortParam, b.sortParam);
+          });
+        } // FIXME 'seriesDesc' necessary?
+        else if (orderMode === 'seriesDesc') {
+            subBlocks.reverse();
+          }
+      }
+
+      var gaps = getGap(fragment);
+      each(subBlocks, function (subBlock, idx) {
+        var subMarkupText = getBuilder(subBlock).build(ctx, subBlock, idx > 0 ? gaps.html : 0, tooltipTextStyle);
+        subMarkupText != null && subMarkupTextList.push(subMarkupText);
+      });
+
+      if (!subMarkupTextList.length) {
+        return;
+      }
+
+      return ctx.renderMode === 'richText' ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(subMarkupTextList.join(''), topMarginForOuterGap);
+    }
+    /**
+     * @return markupText. null/undefined means no content.
+     */
+
+
+    function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) {
+      if (!fragment) {
+        return;
+      }
+
+      var builder = getBuilder(fragment);
+      builder.planLayout(fragment);
+      var ctx = {
+        useUTC: useUTC,
+        renderMode: renderMode,
+        orderMode: orderMode,
+        markupStyleCreator: markupStyleCreator
+      };
+      return builder.build(ctx, fragment, 0, toolTipTextStyle);
+    }
+
+    function getGap(fragment) {
+      var gapLevelBetweenSubBlocks = fragment.__gapLevelBetweenSubBlocks;
+      return {
+        html: HTML_GAPS[gapLevelBetweenSubBlocks],
+        richText: RICH_TEXT_GAPS[gapLevelBetweenSubBlocks]
+      };
+    }
+
+    function wrapBlockHTML(encodedContent, topGap) {
+      var clearfix = '<div style="clear:both"></div>';
+      var marginCSS = "margin: " + topGap + "px 0 0";
+      return "<div style=\"" + marginCSS + ";" + TOOLTIP_LINE_HEIGHT_CSS + ";\">" + encodedContent + clearfix + '</div>';
+    }
+
+    function wrapInlineNameHTML(name, leftHasMarker, style) {
+      var marginCss = leftHasMarker ? 'margin-left:2px' : '';
+      return "<span style=\"" + style + ";" + marginCss + "\">" + encodeHTML(name) + '</span>';
+    }
+
+    function wrapInlineValueHTML(valueList, alignRight, valueCloseToMarker, style) {
+      // Do not too close to marker, considering there are multiple values separated by spaces.
+      var paddingStr = valueCloseToMarker ? '10px' : '20px';
+      var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : '';
+      return "<span style=\"" + alignCSS + ";" + style + "\">" // Value has commas inside, so use '  ' as delimiter for multiple values.
+      + map(valueList, function (value) {
+        return encodeHTML(value);
+      }).join('&nbsp;&nbsp;') + '</span>';
+    }
+
+    function wrapInlineNameRichText(ctx, name, style) {
+      return ctx.markupStyleCreator.wrapRichTextStyle(name, style);
+    }
+
+    function wrapInlineValueRichText(ctx, valueList, alignRight, valueCloseToMarker, style) {
+      var styles = [style];
+      var paddingLeft = valueCloseToMarker ? 10 : 20;
+      alignRight && styles.push({
+        padding: [0, 0, 0, paddingLeft],
+        align: 'right'
+      }); // Value has commas inside, so use '  ' as delimiter for multiple values.
+
+      return ctx.markupStyleCreator.wrapRichTextStyle(valueList.join('  '), styles);
+    }
+
+    function retrieveVisualColorForTooltipMarker(series, dataIndex) {
+      var style = series.getData().getItemVisual(dataIndex, 'style');
+      var color = style[series.visualDrawType];
+      return convertToColorString(color);
+    }
+    function getPaddingFromTooltipModel(model, renderMode) {
+      var padding = model.get('padding');
+      return padding != null ? padding // We give slightly different to look pretty.
+      : renderMode === 'richText' ? [8, 10] : 10;
+    }
+    /**
+     * The major feature is generate styles for `renderMode: 'richText'`.
+     * But it also serves `renderMode: 'html'` to provide
+     * "renderMode-independent" API.
+     */
+
+    var TooltipMarkupStyleCreator =
+    /** @class */
+    function () {
+      function TooltipMarkupStyleCreator() {
+        this.richTextStyles = {}; // Notice that "generate a style name" usuall happens repeatly when mouse moving and
+        // displaying a tooltip. So we put the `_nextStyleNameId` as a member of each creator
+        // rather than static shared by all creators (which will cause it increase to fast).
+
+        this._nextStyleNameId = getRandomIdBase();
+      }
+
+      TooltipMarkupStyleCreator.prototype._generateStyleName = function () {
+        return '__EC_aUTo_' + this._nextStyleNameId++;
+      };
+
+      TooltipMarkupStyleCreator.prototype.makeTooltipMarker = function (markerType, colorStr, renderMode) {
+        var markerId = renderMode === 'richText' ? this._generateStyleName() : null;
+        var marker = getTooltipMarker({
+          color: colorStr,
+          type: markerType,
+          renderMode: renderMode,
+          markerId: markerId
+        });
+
+        if (isString(marker)) {
+          return marker;
+        } else {
+          if ("development" !== 'production') {
+            assert(markerId);
+          }
+
+          this.richTextStyles[markerId] = marker.style;
+          return marker.content;
+        }
+      };
+      /**
+       * @usage
+       * ```ts
+       * const styledText = markupStyleCreator.wrapRichTextStyle([
+       *     // The styles will be auto merged.
+       *     {
+       *         fontSize: 12,
+       *         color: 'blue'
+       *     },
+       *     {
+       *         padding: 20
+       *     }
+       * ]);
+       * ```
+       */
+
+
+      TooltipMarkupStyleCreator.prototype.wrapRichTextStyle = function (text, styles) {
+        var finalStl = {};
+
+        if (isArray(styles)) {
+          each(styles, function (stl) {
+            return extend(finalStl, stl);
+          });
+        } else {
+          extend(finalStl, styles);
+        }
+
+        var styleName = this._generateStyleName();
+
+        this.richTextStyles[styleName] = finalStl;
+        return "{" + styleName + "|" + text + "}";
+      };
+
+      return TooltipMarkupStyleCreator;
+    }();
+
+    function defaultSeriesFormatTooltip(opt) {
+      var series = opt.series;
+      var dataIndex = opt.dataIndex;
+      var multipleSeries = opt.multipleSeries;
+      var data = series.getData();
+      var tooltipDims = data.mapDimensionsAll('defaultedTooltip');
+      var tooltipDimLen = tooltipDims.length;
+      var value = series.getRawValue(dataIndex);
+      var isValueArr = isArray(value);
+      var markerColor = retrieveVisualColorForTooltipMarker(series, dataIndex); // Complicated rule for pretty tooltip.
+
+      var inlineValue;
+      var inlineValueType;
+      var subBlocks;
+      var sortParam;
+
+      if (tooltipDimLen > 1 || isValueArr && !tooltipDimLen) {
+        var formatArrResult = formatTooltipArrayValue(value, series, dataIndex, tooltipDims, markerColor);
+        inlineValue = formatArrResult.inlineValues;
+        inlineValueType = formatArrResult.inlineValueTypes;
+        subBlocks = formatArrResult.blocks; // Only support tooltip sort by the first inline value. It's enough in most cases.
+
+        sortParam = formatArrResult.inlineValues[0];
+      } else if (tooltipDimLen) {
+        var dimInfo = data.getDimensionInfo(tooltipDims[0]);
+        sortParam = inlineValue = retrieveRawValue(data, dataIndex, tooltipDims[0]);
+        inlineValueType = dimInfo.type;
+      } else {
+        sortParam = inlineValue = isValueArr ? value[0] : value;
+      } // Do not show generated series name. It might not be readable.
+
+
+      var seriesNameSpecified = isNameSpecified(series);
+      var seriesName = seriesNameSpecified && series.name || '';
+      var itemName = data.getName(dataIndex);
+      var inlineName = multipleSeries ? seriesName : itemName;
+      return createTooltipMarkup('section', {
+        header: seriesName,
+        // When series name not specified, do not show a header line with only '-'.
+        // This case alway happen in tooltip.trigger: 'item'.
+        noHeader: multipleSeries || !seriesNameSpecified,
+        sortParam: sortParam,
+        blocks: [createTooltipMarkup('nameValue', {
+          markerType: 'item',
+          markerColor: markerColor,
+          // Do not mix display seriesName and itemName in one tooltip,
+          // which might confuses users.
+          name: inlineName,
+          // name dimension might be auto assigned, where the name might
+          // be not readable. So we check trim here.
+          noName: !trim(inlineName),
+          value: inlineValue,
+          valueType: inlineValueType
+        })].concat(subBlocks || [])
+      });
+    }
+
+    function formatTooltipArrayValue(value, series, dataIndex, tooltipDims, colorStr) {
+      // check: category-no-encode-has-axis-data in dataset.html
+      var data = series.getData();
+      var isValueMultipleLine = reduce(value, function (isValueMultipleLine, val, idx) {
+        var dimItem = data.getDimensionInfo(idx);
+        return isValueMultipleLine = isValueMultipleLine || dimItem && dimItem.tooltip !== false && dimItem.displayName != null;
+      }, false);
+      var inlineValues = [];
+      var inlineValueTypes = [];
+      var blocks = [];
+      tooltipDims.length ? each(tooltipDims, function (dim) {
+        setEachItem(retrieveRawValue(data, dataIndex, dim), dim);
+      }) // By default, all dims is used on tooltip.
+      : each(value, setEachItem);
+
+      function setEachItem(val, dim) {
+        var dimInfo = data.getDimensionInfo(dim); // If `dimInfo.tooltip` is not set, show tooltip.
+
+        if (!dimInfo || dimInfo.otherDims.tooltip === false) {
+          return;
+        }
+
+        if (isValueMultipleLine) {
+          blocks.push(createTooltipMarkup('nameValue', {
+            markerType: 'subItem',
+            markerColor: colorStr,
+            name: dimInfo.displayName,
+            value: val,
+            valueType: dimInfo.type
+          }));
+        } else {
+          inlineValues.push(val);
+          inlineValueTypes.push(dimInfo.type);
+        }
+      }
+
+      return {
+        inlineValues: inlineValues,
+        inlineValueTypes: inlineValueTypes,
+        blocks: blocks
+      };
+    }
+
+    var inner$1 = makeInner();
+
+    function getSelectionKey(data, dataIndex) {
+      return data.getName(dataIndex) || data.getId(dataIndex);
+    }
+
+    var SeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(SeriesModel, _super);
+
+      function SeriesModel() {
+        // [Caution]: Becuase this class or desecendants can be used as `XXX.extend(subProto)`,
+        // the class members must not be initialized in constructor or declaration place.
+        // Otherwise there is bad case:
+        //   class A {xxx = 1;}
+        //   enableClassExtend(A);
+        //   class B extends A {}
+        //   var C = B.extend({xxx: 5});
+        //   var c = new C();
+        //   console.log(c.xxx); // expect 5 but always 1.
+        var _this = _super !== null && _super.apply(this, arguments) || this; // ---------------------------------------
+        // Props about data selection
+        // ---------------------------------------
+
+
+        _this._selectedDataIndicesMap = {};
+        return _this;
+      }
+
+      SeriesModel.prototype.init = function (option, parentModel, ecModel) {
+        this.seriesIndex = this.componentIndex;
+        this.dataTask = createTask({
+          count: dataTaskCount,
+          reset: dataTaskReset
+        });
+        this.dataTask.context = {
+          model: this
+        };
+        this.mergeDefaultAndTheme(option, ecModel);
+        var sourceManager = inner$1(this).sourceManager = new SourceManager(this);
+        sourceManager.prepareSource();
+        var data = this.getInitialData(option, ecModel);
+        wrapData(data, this);
+        this.dataTask.context.data = data;
+
+        if ("development" !== 'production') {
+          assert(data, 'getInitialData returned invalid data.');
+        }
+
+        inner$1(this).dataBeforeProcessed = data; // If we reverse the order (make data firstly, and then make
+        // dataBeforeProcessed by cloneShallow), cloneShallow will
+        // cause data.graph.data !== data when using
+        // module:echarts/data/Graph or module:echarts/data/Tree.
+        // See module:echarts/data/helper/linkList
+        // Theoretically, it is unreasonable to call `seriesModel.getData()` in the model
+        // init or merge stage, because the data can be restored. So we do not `restoreData`
+        // and `setData` here, which forbids calling `seriesModel.getData()` in this stage.
+        // Call `seriesModel.getRawData()` instead.
+        // this.restoreData();
+
+        autoSeriesName(this);
+
+        this._initSelectedMapFromData(data);
+      };
+      /**
+       * Util for merge default and theme to option
+       */
+
+
+      SeriesModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+        var layoutMode = fetchLayoutMode(this);
+        var inputPositionParams = layoutMode ? getLayoutParams(option) : {}; // Backward compat: using subType on theme.
+        // But if name duplicate between series subType
+        // (for example: parallel) add component mainType,
+        // add suffix 'Series'.
+
+        var themeSubType = this.subType;
+
+        if (ComponentModel.hasClass(themeSubType)) {
+          themeSubType += 'Series';
+        }
+
+        merge(option, ecModel.getTheme().get(this.subType));
+        merge(option, this.getDefaultOption()); // Default label emphasis `show`
+
+        defaultEmphasis(option, 'label', ['show']);
+        this.fillDataTextStyle(option.data);
+
+        if (layoutMode) {
+          mergeLayoutParam(option, inputPositionParams, layoutMode);
+        }
+      };
+
+      SeriesModel.prototype.mergeOption = function (newSeriesOption, ecModel) {
+        // this.settingTask.dirty();
+        newSeriesOption = merge(this.option, newSeriesOption, true);
+        this.fillDataTextStyle(newSeriesOption.data);
+        var layoutMode = fetchLayoutMode(this);
+
+        if (layoutMode) {
+          mergeLayoutParam(this.option, newSeriesOption, layoutMode);
+        }
+
+        var sourceManager = inner$1(this).sourceManager;
+        sourceManager.dirty();
+        sourceManager.prepareSource();
+        var data = this.getInitialData(newSeriesOption, ecModel);
+        wrapData(data, this);
+        this.dataTask.dirty();
+        this.dataTask.context.data = data;
+        inner$1(this).dataBeforeProcessed = data;
+        autoSeriesName(this);
+
+        this._initSelectedMapFromData(data);
+      };
+
+      SeriesModel.prototype.fillDataTextStyle = function (data) {
+        // Default data label emphasis `show`
+        // FIXME Tree structure data ?
+        // FIXME Performance ?
+        if (data && !isTypedArray(data)) {
+          var props = ['show'];
+
+          for (var i = 0; i < data.length; i++) {
+            if (data[i] && data[i].label) {
+              defaultEmphasis(data[i], 'label', props);
+            }
+          }
+        }
+      };
+      /**
+       * Init a data structure from data related option in series
+       * Must be overriden.
+       */
+
+
+      SeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return;
+      };
+      /**
+       * Append data to list
+       */
+
+
+      SeriesModel.prototype.appendData = function (params) {
+        // FIXME ???
+        // (1) If data from dataset, forbidden append.
+        // (2) support append data of dataset.
+        var data = this.getRawData();
+        data.appendData(params.data);
+      };
+      /**
+       * Consider some method like `filter`, `map` need make new data,
+       * We should make sure that `seriesModel.getData()` get correct
+       * data in the stream procedure. So we fetch data from upstream
+       * each time `task.perform` called.
+       */
+
+
+      SeriesModel.prototype.getData = function (dataType) {
+        var task = getCurrentTask(this);
+
+        if (task) {
+          var data = task.context.data;
+          return dataType == null ? data : data.getLinkedData(dataType);
+        } else {
+          // When series is not alive (that may happen when click toolbox
+          // restore or setOption with not merge mode), series data may
+          // be still need to judge animation or something when graphic
+          // elements want to know whether fade out.
+          return inner$1(this).data;
+        }
+      };
+
+      SeriesModel.prototype.getAllData = function () {
+        var mainData = this.getData();
+        return mainData && mainData.getLinkedDataAll ? mainData.getLinkedDataAll() : [{
+          data: mainData
+        }];
+      };
+
+      SeriesModel.prototype.setData = function (data) {
+        var task = getCurrentTask(this);
+
+        if (task) {
+          var context = task.context; // Consider case: filter, data sample.
+          // FIXME:TS never used, so comment it
+          // if (context.data !== data && task.modifyOutputEnd) {
+          //     task.setOutputEnd(data.count());
+          // }
+
+          context.outputData = data; // Caution: setData should update context.data,
+          // Because getData may be called multiply in a
+          // single stage and expect to get the data just
+          // set. (For example, AxisProxy, x y both call
+          // getData and setDate sequentially).
+          // So the context.data should be fetched from
+          // upstream each time when a stage starts to be
+          // performed.
+
+          if (task !== this.dataTask) {
+            context.data = data;
+          }
+        }
+
+        inner$1(this).data = data;
+      };
+
+      SeriesModel.prototype.getSource = function () {
+        return inner$1(this).sourceManager.getSource();
+      };
+      /**
+       * Get data before processed
+       */
+
+
+      SeriesModel.prototype.getRawData = function () {
+        return inner$1(this).dataBeforeProcessed;
+      };
+      /**
+       * Get base axis if has coordinate system and has axis.
+       * By default use coordSys.getBaseAxis();
+       * Can be overrided for some chart.
+       * @return {type} description
+       */
+
+
+      SeriesModel.prototype.getBaseAxis = function () {
+        var coordSys = this.coordinateSystem; // @ts-ignore
+
+        return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis();
+      };
+      /**
+       * Default tooltip formatter
+       *
+       * @param dataIndex
+       * @param multipleSeries
+       * @param dataType
+       * @param renderMode valid values: 'html'(by default) and 'richText'.
+       *        'html' is used for rendering tooltip in extra DOM form, and the result
+       *        string is used as DOM HTML content.
+       *        'richText' is used for rendering tooltip in rich text form, for those where
+       *        DOM operation is not supported.
+       * @return formatted tooltip with `html` and `markers`
+       *        Notice: The override method can also return string
+       */
+
+
+      SeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        return defaultSeriesFormatTooltip({
+          series: this,
+          dataIndex: dataIndex,
+          multipleSeries: multipleSeries
+        });
+      };
+
+      SeriesModel.prototype.isAnimationEnabled = function () {
+        if (env.node) {
+          return false;
+        }
+
+        var animationEnabled = this.getShallow('animation');
+
+        if (animationEnabled) {
+          if (this.getData().count() > this.getShallow('animationThreshold')) {
+            animationEnabled = false;
+          }
+        }
+
+        return !!animationEnabled;
+      };
+
+      SeriesModel.prototype.restoreData = function () {
+        this.dataTask.dirty();
+      };
+
+      SeriesModel.prototype.getColorFromPalette = function (name, scope, requestColorNum) {
+        var ecModel = this.ecModel; // PENDING
+
+        var color = PaletteMixin.prototype.getColorFromPalette.call(this, name, scope, requestColorNum);
+
+        if (!color) {
+          color = ecModel.getColorFromPalette(name, scope, requestColorNum);
+        }
+
+        return color;
+      };
+      /**
+       * Use `data.mapDimensionsAll(coordDim)` instead.
+       * @deprecated
+       */
+
+
+      SeriesModel.prototype.coordDimToDataDim = function (coordDim) {
+        return this.getRawData().mapDimensionsAll(coordDim);
+      };
+      /**
+       * Get progressive rendering count each step
+       */
+
+
+      SeriesModel.prototype.getProgressive = function () {
+        return this.get('progressive');
+      };
+      /**
+       * Get progressive rendering count each step
+       */
+
+
+      SeriesModel.prototype.getProgressiveThreshold = function () {
+        return this.get('progressiveThreshold');
+      }; // PENGING If selectedMode is null ?
+
+
+      SeriesModel.prototype.select = function (innerDataIndices, dataType) {
+        this._innerSelect(this.getData(dataType), innerDataIndices);
+      };
+
+      SeriesModel.prototype.unselect = function (innerDataIndices, dataType) {
+        var selectedMap = this.option.selectedMap;
+
+        if (!selectedMap) {
+          return;
+        }
+
+        var data = this.getData(dataType);
+
+        for (var i = 0; i < innerDataIndices.length; i++) {
+          var dataIndex = innerDataIndices[i];
+          var nameOrId = getSelectionKey(data, dataIndex);
+          selectedMap[nameOrId] = false;
+          this._selectedDataIndicesMap[nameOrId] = -1;
+        }
+      };
+
+      SeriesModel.prototype.toggleSelect = function (innerDataIndices, dataType) {
+        var tmpArr = [];
+
+        for (var i = 0; i < innerDataIndices.length; i++) {
+          tmpArr[0] = innerDataIndices[i];
+          this.isSelected(innerDataIndices[i], dataType) ? this.unselect(tmpArr, dataType) : this.select(tmpArr, dataType);
+        }
+      };
+
+      SeriesModel.prototype.getSelectedDataIndices = function () {
+        var selectedDataIndicesMap = this._selectedDataIndicesMap;
+        var nameOrIds = keys(selectedDataIndicesMap);
+        var dataIndices = [];
+
+        for (var i = 0; i < nameOrIds.length; i++) {
+          var dataIndex = selectedDataIndicesMap[nameOrIds[i]];
+
+          if (dataIndex >= 0) {
+            dataIndices.push(dataIndex);
+          }
+        }
+
+        return dataIndices;
+      };
+
+      SeriesModel.prototype.isSelected = function (dataIndex, dataType) {
+        var selectedMap = this.option.selectedMap;
+
+        if (!selectedMap) {
+          return false;
+        }
+
+        var data = this.getData(dataType);
+        var nameOrId = getSelectionKey(data, dataIndex);
+        return selectedMap[nameOrId] || false;
+      };
+
+      SeriesModel.prototype._innerSelect = function (data, innerDataIndices) {
+        var _a, _b;
+
+        var selectedMode = this.option.selectedMode;
+        var len = innerDataIndices.length;
+
+        if (!selectedMode || !len) {
+          return;
+        }
+
+        if (selectedMode === 'multiple') {
+          var selectedMap = this.option.selectedMap || (this.option.selectedMap = {});
+
+          for (var i = 0; i < len; i++) {
+            var dataIndex = innerDataIndices[i]; // TODO diffrent types of data share same object.
+
+            var nameOrId = getSelectionKey(data, dataIndex);
+            selectedMap[nameOrId] = true;
+            this._selectedDataIndicesMap[nameOrId] = data.getRawIndex(dataIndex);
+          }
+        } else if (selectedMode === 'single' || selectedMode === true) {
+          var lastDataIndex = innerDataIndices[len - 1];
+          var nameOrId = getSelectionKey(data, lastDataIndex);
+          this.option.selectedMap = (_a = {}, _a[nameOrId] = true, _a);
+          this._selectedDataIndicesMap = (_b = {}, _b[nameOrId] = data.getRawIndex(lastDataIndex), _b);
+        }
+      };
+
+      SeriesModel.prototype._initSelectedMapFromData = function (data) {
+        // Ignore select info in data if selectedMap exists.
+        // NOTE It's only for legacy usage. edge data is not supported.
+        if (this.option.selectedMap) {
+          return;
+        }
+
+        var dataIndices = [];
+
+        if (data.hasItemOption) {
+          data.each(function (idx) {
+            var rawItem = data.getRawDataItem(idx);
+
+            if (typeof rawItem === 'object' && rawItem.selected) {
+              dataIndices.push(idx);
+            }
+          });
+        }
+
+        if (dataIndices.length > 0) {
+          this._innerSelect(data, dataIndices);
+        }
+      }; // /**
+      //  * @see {module:echarts/stream/Scheduler}
+      //  */
+      // abstract pipeTask: null
+
+
+      SeriesModel.registerClass = function (clz) {
+        return ComponentModel.registerClass(clz);
+      };
+
+      SeriesModel.protoInitialize = function () {
+        var proto = SeriesModel.prototype;
+        proto.type = 'series.__base__';
+        proto.seriesIndex = 0;
+        proto.useColorPaletteOnData = false;
+        proto.ignoreStyleOnData = false;
+        proto.hasSymbolVisual = false;
+        proto.defaultSymbol = 'circle'; // Make sure the values can be accessed!
+
+        proto.visualStyleAccessPath = 'itemStyle';
+        proto.visualDrawType = 'fill';
+      }();
+
+      return SeriesModel;
+    }(ComponentModel);
+
+    mixin(SeriesModel, DataFormatMixin);
+    mixin(SeriesModel, PaletteMixin);
+    mountExtend(SeriesModel, ComponentModel);
+    /**
+     * MUST be called after `prepareSource` called
+     * Here we need to make auto series, especially for auto legend. But we
+     * do not modify series.name in option to avoid side effects.
+     */
+
+    function autoSeriesName(seriesModel) {
+      // User specified name has higher priority, otherwise it may cause
+      // series can not be queried unexpectedly.
+      var name = seriesModel.name;
+
+      if (!isNameSpecified(seriesModel)) {
+        seriesModel.name = getSeriesAutoName(seriesModel) || name;
+      }
+    }
+
+    function getSeriesAutoName(seriesModel) {
+      var data = seriesModel.getRawData();
+      var dataDims = data.mapDimensionsAll('seriesName');
+      var nameArr = [];
+      each(dataDims, function (dataDim) {
+        var dimInfo = data.getDimensionInfo(dataDim);
+        dimInfo.displayName && nameArr.push(dimInfo.displayName);
+      });
+      return nameArr.join(' ');
+    }
+
+    function dataTaskCount(context) {
+      return context.model.getRawData().count();
+    }
+
+    function dataTaskReset(context) {
+      var seriesModel = context.model;
+      seriesModel.setData(seriesModel.getRawData().cloneShallow());
+      return dataTaskProgress;
+    }
+
+    function dataTaskProgress(param, context) {
+      // Avoid repead cloneShallow when data just created in reset.
+      if (context.outputData && param.end > context.outputData.count()) {
+        context.model.getRawData().cloneShallow(context.outputData);
+      }
+    } // TODO refactor
+
+
+    function wrapData(data, seriesModel) {
+      each(__spreadArrays(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS), function (methodName) {
+        data.wrapMethod(methodName, curry(onDataChange, seriesModel));
+      });
+    }
+
+    function onDataChange(seriesModel, newList) {
+      var task = getCurrentTask(seriesModel);
+
+      if (task) {
+        // Consider case: filter, selectRange
+        task.setOutputEnd((newList || this).count());
+      }
+
+      return newList;
+    }
+
+    function getCurrentTask(seriesModel) {
+      var scheduler = (seriesModel.ecModel || {}).scheduler;
+      var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid);
+
+      if (pipeline) {
+        // When pipline finished, the currrentTask keep the last
+        // task (renderTask).
+        var task = pipeline.currentTask;
+
+        if (task) {
+          var agentStubMap = task.agentStubMap;
+
+          if (agentStubMap) {
+            task = agentStubMap.get(seriesModel.uid);
+          }
+        }
+
+        return task;
+      }
+    }
+
+    var ComponentView =
+    /** @class */
+    function () {
+      function ComponentView() {
+        this.group = new Group();
+        this.uid = getUID('viewComponent');
+      }
+
+      ComponentView.prototype.init = function (ecModel, api) {};
+
+      ComponentView.prototype.render = function (model, ecModel, api, payload) {};
+
+      ComponentView.prototype.dispose = function (ecModel, api) {};
+
+      ComponentView.prototype.updateView = function (model, ecModel, api, payload) {// Do nothing;
+      };
+
+      ComponentView.prototype.updateLayout = function (model, ecModel, api, payload) {// Do nothing;
+      };
+
+      ComponentView.prototype.updateVisual = function (model, ecModel, api, payload) {// Do nothing;
+      };
+      /**
+       * Hook for blur target series.
+       * Can be used in marker for blur the markers
+       */
+
+
+      ComponentView.prototype.blurSeries = function (seriesModels, ecModel) {// Do nothing;
+      };
+
+      return ComponentView;
+    }();
+    enableClassExtend(ComponentView);
+    enableClassManagement(ComponentView);
+
+    /**
+     * @return {string} If large mode changed, return string 'reset';
+     */
+
+    function createRenderPlanner() {
+      var inner = makeInner();
+      return function (seriesModel) {
+        var fields = inner(seriesModel);
+        var pipelineContext = seriesModel.pipelineContext;
+        var originalLarge = !!fields.large;
+        var originalProgressive = !!fields.progressiveRender; // FIXME: if the planner works on a filtered series, `pipelineContext` does not
+        // exists. See #11611 . Probably we need to modify this structure, see the comment
+        // on `performRawSeries` in `Schedular.js`.
+
+        var large = fields.large = !!(pipelineContext && pipelineContext.large);
+        var progressive = fields.progressiveRender = !!(pipelineContext && pipelineContext.progressiveRender);
+        return !!(originalLarge !== large || originalProgressive !== progressive) && 'reset';
+      };
+    }
+
+    var inner$2 = makeInner();
+    var renderPlanner = createRenderPlanner();
+
+    var ChartView =
+    /** @class */
+    function () {
+      function ChartView() {
+        this.group = new Group();
+        this.uid = getUID('viewChart');
+        this.renderTask = createTask({
+          plan: renderTaskPlan,
+          reset: renderTaskReset
+        });
+        this.renderTask.context = {
+          view: this
+        };
+      }
+
+      ChartView.prototype.init = function (ecModel, api) {};
+
+      ChartView.prototype.render = function (seriesModel, ecModel, api, payload) {};
+      /**
+       * Highlight series or specified data item.
+       */
+
+
+      ChartView.prototype.highlight = function (seriesModel, ecModel, api, payload) {
+        toggleHighlight(seriesModel.getData(), payload, 'emphasis');
+      };
+      /**
+       * Downplay series or specified data item.
+       */
+
+
+      ChartView.prototype.downplay = function (seriesModel, ecModel, api, payload) {
+        toggleHighlight(seriesModel.getData(), payload, 'normal');
+      };
+      /**
+       * Remove self.
+       */
+
+
+      ChartView.prototype.remove = function (ecModel, api) {
+        this.group.removeAll();
+      };
+      /**
+       * Dispose self.
+       */
+
+
+      ChartView.prototype.dispose = function (ecModel, api) {};
+
+      ChartView.prototype.updateView = function (seriesModel, ecModel, api, payload) {
+        this.render(seriesModel, ecModel, api, payload);
+      }; // FIXME never used?
+
+
+      ChartView.prototype.updateLayout = function (seriesModel, ecModel, api, payload) {
+        this.render(seriesModel, ecModel, api, payload);
+      }; // FIXME never used?
+
+
+      ChartView.prototype.updateVisual = function (seriesModel, ecModel, api, payload) {
+        this.render(seriesModel, ecModel, api, payload);
+      };
+
+      ChartView.markUpdateMethod = function (payload, methodName) {
+        inner$2(payload).updateMethod = methodName;
+      };
+
+      ChartView.protoInitialize = function () {
+        var proto = ChartView.prototype;
+        proto.type = 'chart';
+      }();
+
+      return ChartView;
+    }();
+    /**
+     * Set state of single element
+     */
+
+    function elSetState(el, state, highlightDigit) {
+      if (el) {
+        (state === 'emphasis' ? enterEmphasis : leaveEmphasis)(el, highlightDigit);
+      }
+    }
+
+    function toggleHighlight(data, payload, state) {
+      var dataIndex = queryDataIndex(data, payload);
+      var highlightDigit = payload && payload.highlightKey != null ? getHighlightDigit(payload.highlightKey) : null;
+
+      if (dataIndex != null) {
+        each(normalizeToArray(dataIndex), function (dataIdx) {
+          elSetState(data.getItemGraphicEl(dataIdx), state, highlightDigit);
+        });
+      } else {
+        data.eachItemGraphicEl(function (el) {
+          elSetState(el, state, highlightDigit);
+        });
+      }
+    }
+
+    enableClassExtend(ChartView, ['dispose']);
+    enableClassManagement(ChartView);
+
+    function renderTaskPlan(context) {
+      return renderPlanner(context.model);
+    }
+
+    function renderTaskReset(context) {
+      var seriesModel = context.model;
+      var ecModel = context.ecModel;
+      var api = context.api;
+      var payload = context.payload; // FIXME: remove updateView updateVisual
+
+      var progressiveRender = seriesModel.pipelineContext.progressiveRender;
+      var view = context.view;
+      var updateMethod = payload && inner$2(payload).updateMethod;
+      var methodName = progressiveRender ? 'incrementalPrepareRender' : updateMethod && view[updateMethod] ? updateMethod // `appendData` is also supported when data amount
+      // is less than progressive threshold.
+      : 'render';
+
+      if (methodName !== 'render') {
+        view[methodName](seriesModel, ecModel, api, payload);
+      }
+
+      return progressMethodMap[methodName];
+    }
+
+    var progressMethodMap = {
+      incrementalPrepareRender: {
+        progress: function (params, context) {
+          context.view.incrementalRender(params, context.model, context.ecModel, context.api, context.payload);
+        }
+      },
+      render: {
+        // Put view.render in `progress` to support appendData. But in this case
+        // view.render should not be called in reset, otherwise it will be called
+        // twise. Use `forceFirstProgress` to make sure that view.render is called
+        // in any cases.
+        forceFirstProgress: true,
+        progress: function (params, context) {
+          context.view.render(context.model, context.ecModel, context.api, context.payload);
+        }
+      }
+    };
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var ORIGIN_METHOD = '\0__throttleOriginMethod';
+    var RATE = '\0__throttleRate';
+    var THROTTLE_TYPE = '\0__throttleType';
+    /**
+     * @public
+     * @param {(Function)} fn
+     * @param {number} [delay=0] Unit: ms.
+     * @param {boolean} [debounce=false]
+     *        true: If call interval less than `delay`, only the last call works.
+     *        false: If call interval less than `delay, call works on fixed rate.
+     * @return {(Function)} throttled fn.
+     */
+
+    function throttle(fn, delay, debounce) {
+      var currCall;
+      var lastCall = 0;
+      var lastExec = 0;
+      var timer = null;
+      var diff;
+      var scope;
+      var args;
+      var debounceNextCall;
+      delay = delay || 0;
+
+      function exec() {
+        lastExec = new Date().getTime();
+        timer = null;
+        fn.apply(scope, args || []);
+      }
+
+      var cb = function () {
+        var cbArgs = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          cbArgs[_i] = arguments[_i];
+        }
+
+        currCall = new Date().getTime();
+        scope = this;
+        args = cbArgs;
+        var thisDelay = debounceNextCall || delay;
+        var thisDebounce = debounceNextCall || debounce;
+        debounceNextCall = null;
+        diff = currCall - (thisDebounce ? lastCall : lastExec) - thisDelay;
+        clearTimeout(timer); // Here we should make sure that: the `exec` SHOULD NOT be called later
+        // than a new call of `cb`, that is, preserving the command order. Consider
+        // calculating "scale rate" when roaming as an example. When a call of `cb`
+        // happens, either the `exec` is called dierectly, or the call is delayed.
+        // But the delayed call should never be later than next call of `cb`. Under
+        // this assurance, we can simply update view state each time `dispatchAction`
+        // triggered by user roaming, but not need to add extra code to avoid the
+        // state being "rolled-back".
+
+        if (thisDebounce) {
+          timer = setTimeout(exec, thisDelay);
+        } else {
+          if (diff >= 0) {
+            exec();
+          } else {
+            timer = setTimeout(exec, -diff);
+          }
+        }
+
+        lastCall = currCall;
+      };
+      /**
+       * Clear throttle.
+       * @public
+       */
+
+
+      cb.clear = function () {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+      /**
+       * Enable debounce once.
+       */
+
+
+      cb.debounceNextCall = function (debounceDelay) {
+        debounceNextCall = debounceDelay;
+      };
+
+      return cb;
+    }
+    /**
+     * Create throttle method or update throttle rate.
+     *
+     * @example
+     * ComponentView.prototype.render = function () {
+     *     ...
+     *     throttle.createOrUpdate(
+     *         this,
+     *         '_dispatchAction',
+     *         this.model.get('throttle'),
+     *         'fixRate'
+     *     );
+     * };
+     * ComponentView.prototype.remove = function () {
+     *     throttle.clear(this, '_dispatchAction');
+     * };
+     * ComponentView.prototype.dispose = function () {
+     *     throttle.clear(this, '_dispatchAction');
+     * };
+     *
+     */
+
+    function createOrUpdate(obj, fnAttr, rate, throttleType) {
+      var fn = obj[fnAttr];
+
+      if (!fn) {
+        return;
+      }
+
+      var originFn = fn[ORIGIN_METHOD] || fn;
+      var lastThrottleType = fn[THROTTLE_TYPE];
+      var lastRate = fn[RATE];
+
+      if (lastRate !== rate || lastThrottleType !== throttleType) {
+        if (rate == null || !throttleType) {
+          return obj[fnAttr] = originFn;
+        }
+
+        fn = obj[fnAttr] = throttle(originFn, rate, throttleType === 'debounce');
+        fn[ORIGIN_METHOD] = originFn;
+        fn[THROTTLE_TYPE] = throttleType;
+        fn[RATE] = rate;
+      }
+
+      return fn;
+    }
+    /**
+     * Clear throttle. Example see throttle.createOrUpdate.
+     */
+
+    function clear(obj, fnAttr) {
+      var fn = obj[fnAttr];
+
+      if (fn && fn[ORIGIN_METHOD]) {
+        obj[fnAttr] = fn[ORIGIN_METHOD];
+      }
+    }
+
+    var inner$3 = makeInner();
+    var defaultStyleMappers = {
+      itemStyle: makeStyleMapper(ITEM_STYLE_KEY_MAP, true),
+      lineStyle: makeStyleMapper(LINE_STYLE_KEY_MAP, true)
+    };
+    var defaultColorKey = {
+      lineStyle: 'stroke',
+      itemStyle: 'fill'
+    };
+
+    function getStyleMapper(seriesModel, stylePath) {
+      var styleMapper = seriesModel.visualStyleMapper || defaultStyleMappers[stylePath];
+
+      if (!styleMapper) {
+        console.warn("Unkown style type '" + stylePath + "'.");
+        return defaultStyleMappers.itemStyle;
+      }
+
+      return styleMapper;
+    }
+
+    function getDefaultColorKey(seriesModel, stylePath) {
+      // return defaultColorKey[stylePath] ||
+      var colorKey = seriesModel.visualDrawType || defaultColorKey[stylePath];
+
+      if (!colorKey) {
+        console.warn("Unkown style type '" + stylePath + "'.");
+        return 'fill';
+      }
+
+      return colorKey;
+    }
+
+    var seriesStyleTask = {
+      createOnAllSeries: true,
+      performRawSeries: true,
+      reset: function (seriesModel, ecModel) {
+        var data = seriesModel.getData();
+        var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle'; // Set in itemStyle
+
+        var styleModel = seriesModel.getModel(stylePath);
+        var getStyle = getStyleMapper(seriesModel, stylePath);
+        var globalStyle = getStyle(styleModel);
+        var decalOption = styleModel.getShallow('decal');
+
+        if (decalOption) {
+          data.setVisual('decal', decalOption);
+          decalOption.dirty = true;
+        } // TODO
+
+
+        var colorKey = getDefaultColorKey(seriesModel, stylePath);
+        var color = globalStyle[colorKey]; // TODO style callback
+
+        var colorCallback = isFunction(color) ? color : null; // Get from color palette by default.
+
+        if (!globalStyle[colorKey] || colorCallback) {
+          // Note: if some series has color specified (e.g., by itemStyle.color), we DO NOT
+          // make it effect palette. Bacause some scenarios users need to make some series
+          // transparent or as background, which should better not effect the palette.
+          globalStyle[colorKey] = seriesModel.getColorFromPalette( // TODO series count changed.
+          seriesModel.name, null, ecModel.getSeriesCount());
+          data.setVisual('colorFromPalette', true);
+        }
+
+        data.setVisual('style', globalStyle);
+        data.setVisual('drawType', colorKey); // Only visible series has each data be visual encoded
+
+        if (!ecModel.isSeriesFiltered(seriesModel) && colorCallback) {
+          data.setVisual('colorFromPalette', false);
+          return {
+            dataEach: function (data, idx) {
+              var dataParams = seriesModel.getDataParams(idx);
+              var itemStyle = extend({}, globalStyle);
+              itemStyle[colorKey] = colorCallback(dataParams);
+              data.setItemVisual(idx, 'style', itemStyle);
+            }
+          };
+        }
+      }
+    };
+    var sharedModel = new Model();
+    var dataStyleTask = {
+      createOnAllSeries: true,
+      performRawSeries: true,
+      reset: function (seriesModel, ecModel) {
+        if (seriesModel.ignoreStyleOnData || ecModel.isSeriesFiltered(seriesModel)) {
+          return;
+        }
+
+        var data = seriesModel.getData();
+        var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle'; // Set in itemStyle
+
+        var getStyle = getStyleMapper(seriesModel, stylePath);
+        var colorKey = data.getVisual('drawType');
+        return {
+          dataEach: data.hasItemOption ? function (data, idx) {
+            // Not use getItemModel for performance considuration
+            var rawItem = data.getRawDataItem(idx);
+
+            if (rawItem && rawItem[stylePath]) {
+              sharedModel.option = rawItem[stylePath];
+              var style = getStyle(sharedModel);
+              var existsStyle = data.ensureUniqueItemVisual(idx, 'style');
+              extend(existsStyle, style);
+
+              if (sharedModel.option.decal) {
+                data.setItemVisual(idx, 'decal', sharedModel.option.decal);
+                sharedModel.option.decal.dirty = true;
+              }
+
+              if (colorKey in style) {
+                data.setItemVisual(idx, 'colorFromPalette', false);
+              }
+            }
+          } : null
+        };
+      }
+    }; // Pick color from palette for the data which has not been set with color yet.
+    // Note: do not support stream rendering. No such cases yet.
+
+    var dataColorPaletteTask = {
+      performRawSeries: true,
+      overallReset: function (ecModel) {
+        // Each type of series use one scope.
+        // Pie and funnel are using diferrent scopes
+        var paletteScopeGroupByType = createHashMap();
+        ecModel.eachSeries(function (seriesModel) {
+          if (!seriesModel.useColorPaletteOnData) {
+            return;
+          }
+
+          var colorScope = paletteScopeGroupByType.get(seriesModel.type);
+
+          if (!colorScope) {
+            colorScope = {};
+            paletteScopeGroupByType.set(seriesModel.type, colorScope);
+          }
+
+          inner$3(seriesModel).scope = colorScope;
+        });
+        ecModel.eachSeries(function (seriesModel) {
+          if (!seriesModel.useColorPaletteOnData || ecModel.isSeriesFiltered(seriesModel)) {
+            return;
+          }
+
+          var dataAll = seriesModel.getRawData();
+          var idxMap = {};
+          var data = seriesModel.getData();
+          var colorScope = inner$3(seriesModel).scope;
+          var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle';
+          var colorKey = getDefaultColorKey(seriesModel, stylePath);
+          data.each(function (idx) {
+            var rawIdx = data.getRawIndex(idx);
+            idxMap[rawIdx] = idx;
+          }); // Iterate on data before filtered. To make sure color from palette can be
+          // Consistent when toggling legend.
+
+          dataAll.each(function (rawIdx) {
+            var idx = idxMap[rawIdx];
+            var fromPalette = data.getItemVisual(idx, 'colorFromPalette'); // Get color from palette for each data only when the color is inherited from series color, which is
+            // also picked from color palette. So following situation is not in the case:
+            // 1. series.itemStyle.color is set
+            // 2. color is encoded by visualMap
+
+            if (fromPalette) {
+              var itemStyle = data.ensureUniqueItemVisual(idx, 'style');
+              var name_1 = dataAll.getName(rawIdx) || rawIdx + '';
+              var dataCount = dataAll.count();
+              itemStyle[colorKey] = seriesModel.getColorFromPalette(name_1, colorScope, dataCount);
+            }
+          });
+        });
+      }
+    };
+
+    var PI$3 = Math.PI;
+    /**
+     * @param {module:echarts/ExtensionAPI} api
+     * @param {Object} [opts]
+     * @param {string} [opts.text]
+     * @param {string} [opts.color]
+     * @param {string} [opts.textColor]
+     * @return {module:zrender/Element}
+     */
+
+    function defaultLoading(api, opts) {
+      opts = opts || {};
+      defaults(opts, {
+        text: 'loading',
+        textColor: '#000',
+        fontSize: 12,
+        fontWeight: 'normal',
+        fontStyle: 'normal',
+        fontFamily: 'sans-serif',
+        maskColor: 'rgba(255, 255, 255, 0.8)',
+        showSpinner: true,
+        color: '#5470c6',
+        spinnerRadius: 10,
+        lineWidth: 5,
+        zlevel: 0
+      });
+      var group = new Group();
+      var mask = new Rect({
+        style: {
+          fill: opts.maskColor
+        },
+        zlevel: opts.zlevel,
+        z: 10000
+      });
+      group.add(mask);
+      var textContent = new ZRText({
+        style: {
+          text: opts.text,
+          fill: opts.textColor,
+          fontSize: opts.fontSize,
+          fontWeight: opts.fontWeight,
+          fontStyle: opts.fontStyle,
+          fontFamily: opts.fontFamily
+        }
+      });
+      var labelRect = new Rect({
+        style: {
+          fill: 'none'
+        },
+        textContent: textContent,
+        textConfig: {
+          position: 'right',
+          distance: 10
+        },
+        zlevel: opts.zlevel,
+        z: 10001
+      });
+      group.add(labelRect);
+      var arc;
+
+      if (opts.showSpinner) {
+        arc = new Arc({
+          shape: {
+            startAngle: -PI$3 / 2,
+            endAngle: -PI$3 / 2 + 0.1,
+            r: opts.spinnerRadius
+          },
+          style: {
+            stroke: opts.color,
+            lineCap: 'round',
+            lineWidth: opts.lineWidth
+          },
+          zlevel: opts.zlevel,
+          z: 10001
+        });
+        arc.animateShape(true).when(1000, {
+          endAngle: PI$3 * 3 / 2
+        }).start('circularInOut');
+        arc.animateShape(true).when(1000, {
+          startAngle: PI$3 * 3 / 2
+        }).delay(300).start('circularInOut');
+        group.add(arc);
+      } // Inject resize
+
+
+      group.resize = function () {
+        var textWidth = textContent.getBoundingRect().width;
+        var r = opts.showSpinner ? opts.spinnerRadius : 0; // cx = (containerWidth - arcDiameter - textDistance - textWidth) / 2
+        // textDistance needs to be calculated when both animation and text exist
+
+        var cx = (api.getWidth() - r * 2 - (opts.showSpinner && textWidth ? 10 : 0) - textWidth) / 2 - (opts.showSpinner && textWidth ? 0 : 5 + textWidth / 2) // only show the text
+        + (opts.showSpinner ? 0 : textWidth / 2) // only show the spinner
+        + (textWidth ? 0 : r);
+        var cy = api.getHeight() / 2;
+        opts.showSpinner && arc.setShape({
+          cx: cx,
+          cy: cy
+        });
+        labelRect.setShape({
+          x: cx - r,
+          y: cy - r,
+          width: r * 2,
+          height: r * 2
+        });
+        mask.setShape({
+          x: 0,
+          y: 0,
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+      };
+
+      group.resize();
+      return group;
+    }
+
+    var Scheduler =
+    /** @class */
+    function () {
+      function Scheduler(ecInstance, api, dataProcessorHandlers, visualHandlers) {
+        // key: handlerUID
+        this._stageTaskMap = createHashMap();
+        this.ecInstance = ecInstance;
+        this.api = api; // Fix current processors in case that in some rear cases that
+        // processors might be registered after echarts instance created.
+        // Register processors incrementally for a echarts instance is
+        // not supported by this stream architecture.
+
+        dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();
+        visualHandlers = this._visualHandlers = visualHandlers.slice();
+        this._allHandlers = dataProcessorHandlers.concat(visualHandlers);
+      }
+
+      Scheduler.prototype.restoreData = function (ecModel, payload) {
+        // TODO: Only restore needed series and components, but not all components.
+        // Currently `restoreData` of all of the series and component will be called.
+        // But some independent components like `title`, `legend`, `graphic`, `toolbox`,
+        // `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,
+        // and some components like coordinate system, axes, dataZoom, visualMap only
+        // need their target series refresh.
+        // (1) If we are implementing this feature some day, we should consider these cases:
+        // if a data processor depends on a component (e.g., dataZoomProcessor depends
+        // on the settings of `dataZoom`), it should be re-performed if the component
+        // is modified by `setOption`.
+        // (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,
+        // it should be re-performed when the result array of `getTargetSeries` changed.
+        // We use `dependencies` to cover these issues.
+        // (3) How to update target series when coordinate system related components modified.
+        // TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,
+        // and this case all of the tasks will be set as dirty.
+        ecModel.restoreData(payload); // Theoretically an overall task not only depends on each of its target series, but also
+        // depends on all of the series.
+        // The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks
+        // dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure
+        // that the overall task is set as dirty and to be performed, otherwise it probably cause
+        // state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it
+        // probably cause state chaos (consider `dataZoomProcessor`).
+
+        this._stageTaskMap.each(function (taskRecord) {
+          var overallTask = taskRecord.overallTask;
+          overallTask && overallTask.dirty();
+        });
+      }; // If seriesModel provided, incremental threshold is check by series data.
+
+
+      Scheduler.prototype.getPerformArgs = function (task, isBlock) {
+        // For overall task
+        if (!task.__pipeline) {
+          return;
+        }
+
+        var pipeline = this._pipelineMap.get(task.__pipeline.id);
+
+        var pCtx = pipeline.context;
+        var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex;
+        var step = incremental ? pipeline.step : null;
+        var modDataCount = pCtx && pCtx.modDataCount;
+        var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;
+        return {
+          step: step,
+          modBy: modBy,
+          modDataCount: modDataCount
+        };
+      };
+
+      Scheduler.prototype.getPipeline = function (pipelineId) {
+        return this._pipelineMap.get(pipelineId);
+      };
+      /**
+       * Current, progressive rendering starts from visual and layout.
+       * Always detect render mode in the same stage, avoiding that incorrect
+       * detection caused by data filtering.
+       * Caution:
+       * `updateStreamModes` use `seriesModel.getData()`.
+       */
+
+
+      Scheduler.prototype.updateStreamModes = function (seriesModel, view) {
+        var pipeline = this._pipelineMap.get(seriesModel.uid);
+
+        var data = seriesModel.getData();
+        var dataLen = data.count(); // `progressiveRender` means that can render progressively in each
+        // animation frame. Note that some types of series do not provide
+        // `view.incrementalPrepareRender` but support `chart.appendData`. We
+        // use the term `incremental` but not `progressive` to describe the
+        // case that `chart.appendData`.
+
+        var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;
+        var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold'); // TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.
+        // see `test/candlestick-large3.html`
+
+        var modDataCount = seriesModel.get('progressiveChunkMode') === 'mod' ? dataLen : null;
+        seriesModel.pipelineContext = pipeline.context = {
+          progressiveRender: progressiveRender,
+          modDataCount: modDataCount,
+          large: large
+        };
+      };
+
+      Scheduler.prototype.restorePipelines = function (ecModel) {
+        var scheduler = this;
+        var pipelineMap = scheduler._pipelineMap = createHashMap();
+        ecModel.eachSeries(function (seriesModel) {
+          var progressive = seriesModel.getProgressive();
+          var pipelineId = seriesModel.uid;
+          pipelineMap.set(pipelineId, {
+            id: pipelineId,
+            head: null,
+            tail: null,
+            threshold: seriesModel.getProgressiveThreshold(),
+            progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),
+            blockIndex: -1,
+            step: Math.round(progressive || 700),
+            count: 0
+          });
+
+          scheduler._pipe(seriesModel, seriesModel.dataTask);
+        });
+      };
+
+      Scheduler.prototype.prepareStageTasks = function () {
+        var stageTaskMap = this._stageTaskMap;
+        var ecModel = this.api.getModel();
+        var api = this.api;
+        each(this._allHandlers, function (handler) {
+          var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, {});
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            // Currently do not need to support to sepecify them both.
+            errMsg = '"reset" and "overallReset" must not be both specified.';
+          }
+
+          assert(!(handler.reset && handler.overallReset), errMsg);
+          handler.reset && this._createSeriesStageTask(handler, record, ecModel, api);
+          handler.overallReset && this._createOverallStageTask(handler, record, ecModel, api);
+        }, this);
+      };
+
+      Scheduler.prototype.prepareView = function (view, model, ecModel, api) {
+        var renderTask = view.renderTask;
+        var context = renderTask.context;
+        context.model = model;
+        context.ecModel = ecModel;
+        context.api = api;
+        renderTask.__block = !view.incrementalPrepareRender;
+
+        this._pipe(model, renderTask);
+      };
+
+      Scheduler.prototype.performDataProcessorTasks = function (ecModel, payload) {
+        // If we do not use `block` here, it should be considered when to update modes.
+        this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, {
+          block: true
+        });
+      };
+
+      Scheduler.prototype.performVisualTasks = function (ecModel, payload, opt) {
+        this._performStageTasks(this._visualHandlers, ecModel, payload, opt);
+      };
+
+      Scheduler.prototype._performStageTasks = function (stageHandlers, ecModel, payload, opt) {
+        opt = opt || {};
+        var unfinished = false;
+        var scheduler = this;
+        each(stageHandlers, function (stageHandler, idx) {
+          if (opt.visualType && opt.visualType !== stageHandler.visualType) {
+            return;
+          }
+
+          var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid);
+
+          var seriesTaskMap = stageHandlerRecord.seriesTaskMap;
+          var overallTask = stageHandlerRecord.overallTask;
+
+          if (overallTask) {
+            var overallNeedDirty_1;
+            var agentStubMap = overallTask.agentStubMap;
+            agentStubMap.each(function (stub) {
+              if (needSetDirty(opt, stub)) {
+                stub.dirty();
+                overallNeedDirty_1 = true;
+              }
+            });
+            overallNeedDirty_1 && overallTask.dirty();
+            scheduler.updatePayload(overallTask, payload);
+            var performArgs_1 = scheduler.getPerformArgs(overallTask, opt.block); // Execute stubs firstly, which may set the overall task dirty,
+            // then execute the overall task. And stub will call seriesModel.setData,
+            // which ensures that in the overallTask seriesModel.getData() will not
+            // return incorrect data.
+
+            agentStubMap.each(function (stub) {
+              stub.perform(performArgs_1);
+            });
+
+            if (overallTask.perform(performArgs_1)) {
+              unfinished = true;
+            }
+          } else if (seriesTaskMap) {
+            seriesTaskMap.each(function (task, pipelineId) {
+              if (needSetDirty(opt, task)) {
+                task.dirty();
+              }
+
+              var performArgs = scheduler.getPerformArgs(task, opt.block); // FIXME
+              // if intending to decalare `performRawSeries` in handlers, only
+              // stream-independent (specifically, data item independent) operations can be
+              // performed. Because is a series is filtered, most of the tasks will not
+              // be performed. A stream-dependent operation probably cause wrong biz logic.
+              // Perhaps we should not provide a separate callback for this case instead
+              // of providing the config `performRawSeries`. The stream-dependent operaions
+              // and stream-independent operations should better not be mixed.
+
+              performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task.context.model);
+              scheduler.updatePayload(task, payload);
+
+              if (task.perform(performArgs)) {
+                unfinished = true;
+              }
+            });
+          }
+        });
+
+        function needSetDirty(opt, task) {
+          return opt.setDirty && (!opt.dirtyMap || opt.dirtyMap.get(task.__pipeline.id));
+        }
+
+        this.unfinished = unfinished || this.unfinished;
+      };
+
+      Scheduler.prototype.performSeriesTasks = function (ecModel) {
+        var unfinished;
+        ecModel.eachSeries(function (seriesModel) {
+          // Progress to the end for dataInit and dataRestore.
+          unfinished = seriesModel.dataTask.perform() || unfinished;
+        });
+        this.unfinished = unfinished || this.unfinished;
+      };
+
+      Scheduler.prototype.plan = function () {
+        // Travel pipelines, check block.
+        this._pipelineMap.each(function (pipeline) {
+          var task = pipeline.tail;
+
+          do {
+            if (task.__block) {
+              pipeline.blockIndex = task.__idxInPipeline;
+              break;
+            }
+
+            task = task.getUpstream();
+          } while (task);
+        });
+      };
+
+      Scheduler.prototype.updatePayload = function (task, payload) {
+        payload !== 'remain' && (task.context.payload = payload);
+      };
+
+      Scheduler.prototype._createSeriesStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {
+        var scheduler = this;
+        var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap; // The count of stages are totally about only several dozen, so
+        // do not need to reuse the map.
+
+        var newSeriesTaskMap = stageHandlerRecord.seriesTaskMap = createHashMap();
+        var seriesType = stageHandler.seriesType;
+        var getTargetSeries = stageHandler.getTargetSeries; // If a stageHandler should cover all series, `createOnAllSeries` should be declared mandatorily,
+        // to avoid some typo or abuse. Otherwise if an extension do not specify a `seriesType`,
+        // it works but it may cause other irrelevant charts blocked.
+
+        if (stageHandler.createOnAllSeries) {
+          ecModel.eachRawSeries(create);
+        } else if (seriesType) {
+          ecModel.eachRawSeriesByType(seriesType, create);
+        } else if (getTargetSeries) {
+          getTargetSeries(ecModel, api).each(create);
+        }
+
+        function create(seriesModel) {
+          var pipelineId = seriesModel.uid; // Init tasks for each seriesModel only once.
+          // Reuse original task instance.
+
+          var task = newSeriesTaskMap.set(pipelineId, oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId) || createTask({
+            plan: seriesTaskPlan,
+            reset: seriesTaskReset,
+            count: seriesTaskCount
+          }));
+          task.context = {
+            model: seriesModel,
+            ecModel: ecModel,
+            api: api,
+            // PENDING: `useClearVisual` not used?
+            useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,
+            plan: stageHandler.plan,
+            reset: stageHandler.reset,
+            scheduler: scheduler
+          };
+
+          scheduler._pipe(seriesModel, task);
+        }
+      };
+
+      Scheduler.prototype._createOverallStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {
+        var scheduler = this;
+        var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask // For overall task, the function only be called on reset stage.
+        || createTask({
+          reset: overallTaskReset
+        });
+        overallTask.context = {
+          ecModel: ecModel,
+          api: api,
+          overallReset: stageHandler.overallReset,
+          scheduler: scheduler
+        };
+        var oldAgentStubMap = overallTask.agentStubMap; // The count of stages are totally about only several dozen, so
+        // do not need to reuse the map.
+
+        var newAgentStubMap = overallTask.agentStubMap = createHashMap();
+        var seriesType = stageHandler.seriesType;
+        var getTargetSeries = stageHandler.getTargetSeries;
+        var overallProgress = true;
+        var shouldOverallTaskDirty = false; // FIXME:TS never used, so comment it
+        // let modifyOutputEnd = stageHandler.modifyOutputEnd;
+        // An overall task with seriesType detected or has `getTargetSeries`, we add
+        // stub in each pipelines, it will set the overall task dirty when the pipeline
+        // progress. Moreover, to avoid call the overall task each frame (too frequent),
+        // we set the pipeline block.
+
+        var errMsg = '';
+
+        if ("development" !== 'production') {
+          errMsg = '"createOnAllSeries" do not supported for "overallReset", ' + 'becuase it will block all streams.';
+        }
+
+        assert(!stageHandler.createOnAllSeries, errMsg);
+
+        if (seriesType) {
+          ecModel.eachRawSeriesByType(seriesType, createStub);
+        } else if (getTargetSeries) {
+          getTargetSeries(ecModel, api).each(createStub);
+        } // Otherwise, (usually it is legancy case), the overall task will only be
+        // executed when upstream dirty. Otherwise the progressive rendering of all
+        // pipelines will be disabled unexpectedly. But it still needs stubs to receive
+        // dirty info from upsteam.
+        else {
+            overallProgress = false;
+            each(ecModel.getSeries(), createStub);
+          }
+
+        function createStub(seriesModel) {
+          var pipelineId = seriesModel.uid;
+          var stub = newAgentStubMap.set(pipelineId, oldAgentStubMap && oldAgentStubMap.get(pipelineId) || ( // When the result of `getTargetSeries` changed, the overallTask
+          // should be set as dirty and re-performed.
+          shouldOverallTaskDirty = true, createTask({
+            reset: stubReset,
+            onDirty: stubOnDirty
+          })));
+          stub.context = {
+            model: seriesModel,
+            overallProgress: overallProgress // FIXME:TS never used, so comment it
+            // modifyOutputEnd: modifyOutputEnd
+
+          };
+          stub.agent = overallTask;
+          stub.__block = overallProgress;
+
+          scheduler._pipe(seriesModel, stub);
+        }
+
+        if (shouldOverallTaskDirty) {
+          overallTask.dirty();
+        }
+      };
+
+      Scheduler.prototype._pipe = function (seriesModel, task) {
+        var pipelineId = seriesModel.uid;
+
+        var pipeline = this._pipelineMap.get(pipelineId);
+
+        !pipeline.head && (pipeline.head = task);
+        pipeline.tail && pipeline.tail.pipe(task);
+        pipeline.tail = task;
+        task.__idxInPipeline = pipeline.count++;
+        task.__pipeline = pipeline;
+      };
+
+      Scheduler.wrapStageHandler = function (stageHandler, visualType) {
+        if (isFunction(stageHandler)) {
+          stageHandler = {
+            overallReset: stageHandler,
+            seriesType: detectSeriseType(stageHandler)
+          };
+        }
+
+        stageHandler.uid = getUID('stageHandler');
+        visualType && (stageHandler.visualType = visualType);
+        return stageHandler;
+      };
+      return Scheduler;
+    }();
+
+    function overallTaskReset(context) {
+      context.overallReset(context.ecModel, context.api, context.payload);
+    }
+
+    function stubReset(context) {
+      return context.overallProgress && stubProgress;
+    }
+
+    function stubProgress() {
+      this.agent.dirty();
+      this.getDownstream().dirty();
+    }
+
+    function stubOnDirty() {
+      this.agent && this.agent.dirty();
+    }
+
+    function seriesTaskPlan(context) {
+      return context.plan ? context.plan(context.model, context.ecModel, context.api, context.payload) : null;
+    }
+
+    function seriesTaskReset(context) {
+      if (context.useClearVisual) {
+        context.data.clearAllVisual();
+      }
+
+      var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));
+      return resetDefines.length > 1 ? map(resetDefines, function (v, idx) {
+        return makeSeriesTaskProgress(idx);
+      }) : singleSeriesTaskProgress;
+    }
+
+    var singleSeriesTaskProgress = makeSeriesTaskProgress(0);
+
+    function makeSeriesTaskProgress(resetDefineIdx) {
+      return function (params, context) {
+        var data = context.data;
+        var resetDefine = context.resetDefines[resetDefineIdx];
+
+        if (resetDefine && resetDefine.dataEach) {
+          for (var i = params.start; i < params.end; i++) {
+            resetDefine.dataEach(data, i);
+          }
+        } else if (resetDefine && resetDefine.progress) {
+          resetDefine.progress(params, data);
+        }
+      };
+    }
+
+    function seriesTaskCount(context) {
+      return context.data.count();
+    }
+    /**
+     * Only some legacy stage handlers (usually in echarts extensions) are pure function.
+     * To ensure that they can work normally, they should work in block mode, that is,
+     * they should not be started util the previous tasks finished. So they cause the
+     * progressive rendering disabled. We try to detect the series type, to narrow down
+     * the block range to only the series type they concern, but not all series.
+     */
+
+
+    function detectSeriseType(legacyFunc) {
+      seriesType = null;
+
+      try {
+        // Assume there is no async when calling `eachSeriesByType`.
+        legacyFunc(ecModelMock, apiMock);
+      } catch (e) {}
+
+      return seriesType;
+    }
+
+    var ecModelMock = {};
+    var apiMock = {};
+    var seriesType;
+    mockMethods(ecModelMock, GlobalModel);
+    mockMethods(apiMock, ExtensionAPI);
+
+    ecModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function (type) {
+      seriesType = type;
+    };
+
+    ecModelMock.eachComponent = function (cond) {
+      if (cond.mainType === 'series' && cond.subType) {
+        seriesType = cond.subType;
+      }
+    };
+
+    function mockMethods(target, Clz) {
+      /* eslint-disable */
+      for (var name_1 in Clz.prototype) {
+        // Do not use hasOwnProperty
+        target[name_1] = noop;
+      }
+      /* eslint-enable */
+
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var colorAll = ['#37A2DA', '#32C5E9', '#67E0E3', '#9FE6B8', '#FFDB5C', '#ff9f7f', '#fb7293', '#E062AE', '#E690D1', '#e7bcf3', '#9d96f5', '#8378EA', '#96BFFF'];
+    var lightTheme = {
+      color: colorAll,
+      colorLayer: [['#37A2DA', '#ffd85c', '#fd7b5f'], ['#37A2DA', '#67E0E3', '#FFDB5C', '#ff9f7f', '#E062AE', '#9d96f5'], ['#37A2DA', '#32C5E9', '#9FE6B8', '#FFDB5C', '#ff9f7f', '#fb7293', '#e7bcf3', '#8378EA', '#96BFFF'], colorAll]
+    };
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var contrastColor = '#B9B8CE';
+    var backgroundColor = '#100C2A';
+
+    var axisCommon = function () {
+      return {
+        axisLine: {
+          lineStyle: {
+            color: contrastColor
+          }
+        },
+        splitLine: {
+          lineStyle: {
+            color: '#484753'
+          }
+        },
+        splitArea: {
+          areaStyle: {
+            color: ['rgba(255,255,255,0.02)', 'rgba(255,255,255,0.05)']
+          }
+        },
+        minorSplitLine: {
+          lineStyle: {
+            color: '#20203B'
+          }
+        }
+      };
+    };
+
+    var colorPalette = ['#4992ff', '#7cffb2', '#fddd60', '#ff6e76', '#58d9f9', '#05c091', '#ff8a45', '#8d48e3', '#dd79ff'];
+    var theme = {
+      darkMode: true,
+      color: colorPalette,
+      backgroundColor: backgroundColor,
+      axisPointer: {
+        lineStyle: {
+          color: '#817f91'
+        },
+        crossStyle: {
+          color: '#817f91'
+        },
+        label: {
+          // TODO Contrast of label backgorundColor
+          color: '#fff'
+        }
+      },
+      legend: {
+        textStyle: {
+          color: contrastColor
+        }
+      },
+      textStyle: {
+        color: contrastColor
+      },
+      title: {
+        textStyle: {
+          color: '#EEF1FA'
+        },
+        subtextStyle: {
+          color: '#B9B8CE'
+        }
+      },
+      toolbox: {
+        iconStyle: {
+          borderColor: contrastColor
+        }
+      },
+      dataZoom: {
+        borderColor: '#71708A',
+        textStyle: {
+          color: contrastColor
+        },
+        brushStyle: {
+          color: 'rgba(135,163,206,0.3)'
+        },
+        handleStyle: {
+          color: '#353450',
+          borderColor: '#C5CBE3'
+        },
+        moveHandleStyle: {
+          color: '#B0B6C3',
+          opacity: 0.3
+        },
+        fillerColor: 'rgba(135,163,206,0.2)',
+        emphasis: {
+          handleStyle: {
+            borderColor: '#91B7F2',
+            color: '#4D587D'
+          },
+          moveHandleStyle: {
+            color: '#636D9A',
+            opacity: 0.7
+          }
+        },
+        dataBackground: {
+          lineStyle: {
+            color: '#71708A',
+            width: 1
+          },
+          areaStyle: {
+            color: '#71708A'
+          }
+        },
+        selectedDataBackground: {
+          lineStyle: {
+            color: '#87A3CE'
+          },
+          areaStyle: {
+            color: '#87A3CE'
+          }
+        }
+      },
+      visualMap: {
+        textStyle: {
+          color: contrastColor
+        }
+      },
+      timeline: {
+        lineStyle: {
+          color: contrastColor
+        },
+        label: {
+          color: contrastColor
+        },
+        controlStyle: {
+          color: contrastColor,
+          borderColor: contrastColor
+        }
+      },
+      calendar: {
+        itemStyle: {
+          color: backgroundColor
+        },
+        dayLabel: {
+          color: contrastColor
+        },
+        monthLabel: {
+          color: contrastColor
+        },
+        yearLabel: {
+          color: contrastColor
+        }
+      },
+      timeAxis: axisCommon(),
+      logAxis: axisCommon(),
+      valueAxis: axisCommon(),
+      categoryAxis: axisCommon(),
+      line: {
+        symbol: 'circle'
+      },
+      graph: {
+        color: colorPalette
+      },
+      gauge: {
+        title: {
+          color: contrastColor
+        },
+        axisLine: {
+          lineStyle: {
+            color: [[1, 'rgba(207,212,219,0.2)']]
+          }
+        },
+        axisLabel: {
+          color: contrastColor
+        },
+        detail: {
+          color: '#EEF1FA'
+        }
+      },
+      candlestick: {
+        itemStyle: {
+          color: '#f64e56',
+          color0: '#54ea92',
+          borderColor: '#f64e56',
+          borderColor0: '#54ea92' // borderColor: '#ca2824',
+          // borderColor0: '#09a443'
+
+        }
+      }
+    };
+    theme.categoryAxis.splitLine.show = false;
+
+    function parseXML(svg) {
+        if (isString(svg)) {
+            var parser = new DOMParser();
+            svg = parser.parseFromString(svg, 'text/xml');
+        }
+        var svgNode = svg;
+        if (svgNode.nodeType === 9) {
+            svgNode = svgNode.firstChild;
+        }
+        while (svgNode.nodeName.toLowerCase() !== 'svg' || svgNode.nodeType !== 1) {
+            svgNode = svgNode.nextSibling;
+        }
+        return svgNode;
+    }
+
+    var storage = createHashMap();
+    var mapDataStorage = {
+      /**
+       * Compatible with previous `echarts.registerMap`.
+       * @usage
+       * ```js
+       * $.get('USA.json', function (geoJson) {
+       *     echarts.registerMap('USA', geoJson);
+       *     // Or
+       *     echarts.registerMap('USA', {
+       *         geoJson: geoJson,
+       *         specialAreas: {}
+       *     })
+       * });
+       *
+       * $.get('airport.svg', function (svg) {
+       *     echarts.registerMap('airport', {
+       *         svg: svg
+       *     }
+       * });
+       *
+       * echarts.registerMap('eu', [
+       *     {svg: eu-topographic.svg},
+       *     {geoJSON: eu.json}
+       * ])
+       * ```
+       */
+      registerMap: function (mapName, rawDef, rawSpecialAreas) {
+        var records;
+
+        if (isArray(rawDef)) {
+          records = rawDef;
+        } else if (rawDef.svg) {
+          records = [{
+            type: 'svg',
+            source: rawDef.svg,
+            specialAreas: rawDef.specialAreas
+          }];
+        } else {
+          // Backward compatibility.
+          var geoSource = rawDef.geoJson || rawDef.geoJSON;
+
+          if (geoSource && !rawDef.features) {
+            rawSpecialAreas = rawDef.specialAreas;
+            rawDef = geoSource;
+          }
+
+          records = [{
+            type: 'geoJSON',
+            source: rawDef,
+            specialAreas: rawSpecialAreas
+          }];
+        }
+
+        each(records, function (record) {
+          var type = record.type;
+          type === 'geoJson' && (type = record.type = 'geoJSON');
+          var parse = parsers[type];
+
+          if ("development" !== 'production') {
+            assert(parse, 'Illegal map type: ' + type);
+          }
+
+          parse(record);
+        });
+        return storage.set(mapName, records);
+      },
+      retrieveMap: function (mapName) {
+        return storage.get(mapName);
+      }
+    };
+    var parsers = {
+      geoJSON: function (record) {
+        var source = record.source;
+        record.geoJSON = !isString(source) ? source : typeof JSON !== 'undefined' && JSON.parse ? JSON.parse(source) : new Function('return (' + source + ');')();
+      },
+      // Only perform parse to XML object here, which might be time
+      // consiming for large SVG.
+      // Although convert XML to zrender element is also time consiming,
+      // if we do it here, the clone of zrender elements has to be
+      // required. So we do it once for each geo instance, util real
+      // performance issues call for optimizing it.
+      svg: function (record) {
+        record.svgXML = parseXML(record.source);
+      }
+    };
+
+    /**
+     * Usage of query:
+     * `chart.on('click', query, handler);`
+     * The `query` can be:
+     * + The component type query string, only `mainType` or `mainType.subType`,
+     *   like: 'xAxis', 'series', 'xAxis.category' or 'series.line'.
+     * + The component query object, like:
+     *   `{seriesIndex: 2}`, `{seriesName: 'xx'}`, `{seriesId: 'some'}`,
+     *   `{xAxisIndex: 2}`, `{xAxisName: 'xx'}`, `{xAxisId: 'some'}`.
+     * + The data query object, like:
+     *   `{dataIndex: 123}`, `{dataType: 'link'}`, `{name: 'some'}`.
+     * + The other query object (cmponent customized query), like:
+     *   `{element: 'some'}` (only available in custom series).
+     *
+     * Caveat: If a prop in the `query` object is `null/undefined`, it is the
+     * same as there is no such prop in the `query` object.
+     */
+
+    var ECEventProcessor =
+    /** @class */
+    function () {
+      function ECEventProcessor() {}
+
+      ECEventProcessor.prototype.normalizeQuery = function (query) {
+        var cptQuery = {};
+        var dataQuery = {};
+        var otherQuery = {}; // `query` is `mainType` or `mainType.subType` of component.
+
+        if (isString(query)) {
+          var condCptType = parseClassType(query); // `.main` and `.sub` may be ''.
+
+          cptQuery.mainType = condCptType.main || null;
+          cptQuery.subType = condCptType.sub || null;
+        } // `query` is an object, convert to {mainType, index, name, id}.
+        else {
+            // `xxxIndex`, `xxxName`, `xxxId`, `name`, `dataIndex`, `dataType` is reserved,
+            // can not be used in `compomentModel.filterForExposedEvent`.
+            var suffixes_1 = ['Index', 'Name', 'Id'];
+            var dataKeys_1 = {
+              name: 1,
+              dataIndex: 1,
+              dataType: 1
+            };
+            each(query, function (val, key) {
+              var reserved = false;
+
+              for (var i = 0; i < suffixes_1.length; i++) {
+                var propSuffix = suffixes_1[i];
+                var suffixPos = key.lastIndexOf(propSuffix);
+
+                if (suffixPos > 0 && suffixPos === key.length - propSuffix.length) {
+                  var mainType = key.slice(0, suffixPos); // Consider `dataIndex`.
+
+                  if (mainType !== 'data') {
+                    cptQuery.mainType = mainType;
+                    cptQuery[propSuffix.toLowerCase()] = val;
+                    reserved = true;
+                  }
+                }
+              }
+
+              if (dataKeys_1.hasOwnProperty(key)) {
+                dataQuery[key] = val;
+                reserved = true;
+              }
+
+              if (!reserved) {
+                otherQuery[key] = val;
+              }
+            });
+          }
+
+        return {
+          cptQuery: cptQuery,
+          dataQuery: dataQuery,
+          otherQuery: otherQuery
+        };
+      };
+
+      ECEventProcessor.prototype.filter = function (eventType, query) {
+        // They should be assigned before each trigger call.
+        var eventInfo = this.eventInfo;
+
+        if (!eventInfo) {
+          return true;
+        }
+
+        var targetEl = eventInfo.targetEl;
+        var packedEvent = eventInfo.packedEvent;
+        var model = eventInfo.model;
+        var view = eventInfo.view; // For event like 'globalout'.
+
+        if (!model || !view) {
+          return true;
+        }
+
+        var cptQuery = query.cptQuery;
+        var dataQuery = query.dataQuery;
+        return check(cptQuery, model, 'mainType') && check(cptQuery, model, 'subType') && check(cptQuery, model, 'index', 'componentIndex') && check(cptQuery, model, 'name') && check(cptQuery, model, 'id') && check(dataQuery, packedEvent, 'name') && check(dataQuery, packedEvent, 'dataIndex') && check(dataQuery, packedEvent, 'dataType') && (!view.filterForExposedEvent || view.filterForExposedEvent(eventType, query.otherQuery, targetEl, packedEvent));
+
+        function check(query, host, prop, propOnHost) {
+          return query[prop] == null || host[propOnHost || prop] === query[prop];
+        }
+      };
+
+      ECEventProcessor.prototype.afterTrigger = function () {
+        // Make sure the eventInfo wont be used in next trigger.
+        this.eventInfo = null;
+      };
+
+      return ECEventProcessor;
+    }();
+
+    var seriesSymbolTask = {
+      createOnAllSeries: true,
+      // For legend.
+      performRawSeries: true,
+      reset: function (seriesModel, ecModel) {
+        var data = seriesModel.getData();
+
+        if (seriesModel.legendSymbol) {
+          data.setVisual('legendSymbol', seriesModel.legendSymbol);
+        }
+
+        if (!seriesModel.hasSymbolVisual) {
+          return;
+        }
+
+        var symbolType = seriesModel.get('symbol');
+        var symbolSize = seriesModel.get('symbolSize');
+        var keepAspect = seriesModel.get('symbolKeepAspect');
+        var symbolRotate = seriesModel.get('symbolRotate');
+        var hasSymbolTypeCallback = isFunction(symbolType);
+        var hasSymbolSizeCallback = isFunction(symbolSize);
+        var hasSymbolRotateCallback = isFunction(symbolRotate);
+        var hasCallback = hasSymbolTypeCallback || hasSymbolSizeCallback || hasSymbolRotateCallback;
+        var seriesSymbol = !hasSymbolTypeCallback && symbolType ? symbolType : seriesModel.defaultSymbol;
+        var seriesSymbolSize = !hasSymbolSizeCallback ? symbolSize : null;
+        var seriesSymbolRotate = !hasSymbolRotateCallback ? symbolRotate : null;
+        data.setVisual({
+          legendSymbol: seriesModel.legendSymbol || seriesSymbol,
+          // If seting callback functions on `symbol` or `symbolSize`, for simplicity and avoiding
+          // to bring trouble, we do not pick a reuslt from one of its calling on data item here,
+          // but just use the default value. Callback on `symbol` or `symbolSize` is convenient in
+          // some cases but generally it is not recommanded.
+          symbol: seriesSymbol,
+          symbolSize: seriesSymbolSize,
+          symbolKeepAspect: keepAspect,
+          symbolRotate: seriesSymbolRotate
+        }); // Only visible series has each data be visual encoded
+
+        if (ecModel.isSeriesFiltered(seriesModel)) {
+          return;
+        }
+
+        function dataEach(data, idx) {
+          var rawValue = seriesModel.getRawValue(idx);
+          var params = seriesModel.getDataParams(idx);
+          hasSymbolTypeCallback && data.setItemVisual(idx, 'symbol', symbolType(rawValue, params));
+          hasSymbolSizeCallback && data.setItemVisual(idx, 'symbolSize', symbolSize(rawValue, params));
+          hasSymbolRotateCallback && data.setItemVisual(idx, 'symbolRotate', symbolRotate(rawValue, params));
+        }
+
+        return {
+          dataEach: hasCallback ? dataEach : null
+        };
+      }
+    };
+    var dataSymbolTask = {
+      createOnAllSeries: true,
+      // For legend.
+      performRawSeries: true,
+      reset: function (seriesModel, ecModel) {
+        if (!seriesModel.hasSymbolVisual) {
+          return;
+        } // Only visible series has each data be visual encoded
+
+
+        if (ecModel.isSeriesFiltered(seriesModel)) {
+          return;
+        }
+
+        var data = seriesModel.getData();
+
+        function dataEach(data, idx) {
+          var itemModel = data.getItemModel(idx);
+          var itemSymbolType = itemModel.getShallow('symbol', true);
+          var itemSymbolSize = itemModel.getShallow('symbolSize', true);
+          var itemSymbolRotate = itemModel.getShallow('symbolRotate', true);
+          var itemSymbolKeepAspect = itemModel.getShallow('symbolKeepAspect', true); // If has item symbol
+
+          if (itemSymbolType != null) {
+            data.setItemVisual(idx, 'symbol', itemSymbolType);
+          }
+
+          if (itemSymbolSize != null) {
+            // PENDING Transform symbolSize ?
+            data.setItemVisual(idx, 'symbolSize', itemSymbolSize);
+          }
+
+          if (itemSymbolRotate != null) {
+            data.setItemVisual(idx, 'symbolRotate', itemSymbolRotate);
+          }
+
+          if (itemSymbolKeepAspect != null) {
+            data.setItemVisual(idx, 'symbolKeepAspect', itemSymbolKeepAspect);
+          }
+        }
+
+        return {
+          dataEach: data.hasItemOption ? dataEach : null
+        };
+      }
+    };
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function getItemVisualFromData(data, dataIndex, key) {
+      switch (key) {
+        case 'color':
+          var style = data.getItemVisual(dataIndex, 'style');
+          return style[data.getVisual('drawType')];
+
+        case 'opacity':
+          return data.getItemVisual(dataIndex, 'style').opacity;
+
+        case 'symbol':
+        case 'symbolSize':
+        case 'liftZ':
+          return data.getItemVisual(dataIndex, key);
+
+        default:
+          if ("development" !== 'production') {
+            console.warn("Unknown visual type " + key);
+          }
+
+      }
+    }
+    function getVisualFromData(data, key) {
+      switch (key) {
+        case 'color':
+          var style = data.getVisual('style');
+          return style[data.getVisual('drawType')];
+
+        case 'opacity':
+          return data.getVisual('style').opacity;
+
+        case 'symbol':
+        case 'symbolSize':
+        case 'liftZ':
+          return data.getVisual(key);
+
+        default:
+          if ("development" !== 'production') {
+            console.warn("Unknown visual type " + key);
+          }
+
+      }
+    }
+    function setItemVisualFromData(data, dataIndex, key, value) {
+      switch (key) {
+        case 'color':
+          // Make sure not sharing style object.
+          var style = data.ensureUniqueItemVisual(dataIndex, 'style');
+          style[data.getVisual('drawType')] = value; // Mark the color has been changed, not from palette anymore
+
+          data.setItemVisual(dataIndex, 'colorFromPalette', false);
+          break;
+
+        case 'opacity':
+          data.ensureUniqueItemVisual(dataIndex, 'style').opacity = value;
+          break;
+
+        case 'symbol':
+        case 'symbolSize':
+        case 'liftZ':
+          data.setItemVisual(dataIndex, key, value);
+          break;
+
+        default:
+          if ("development" !== 'production') {
+            console.warn("Unknown visual type " + key);
+          }
+
+      }
+    }
+
+    var PI2$6 = Math.PI * 2;
+    var CMD$3 = PathProxy.CMD;
+    var DEFAULT_SEARCH_SPACE = ['top', 'right', 'bottom', 'left'];
+
+    function getCandidateAnchor(pos, distance, rect, outPt, outDir) {
+      var width = rect.width;
+      var height = rect.height;
+
+      switch (pos) {
+        case 'top':
+          outPt.set(rect.x + width / 2, rect.y - distance);
+          outDir.set(0, -1);
+          break;
+
+        case 'bottom':
+          outPt.set(rect.x + width / 2, rect.y + height + distance);
+          outDir.set(0, 1);
+          break;
+
+        case 'left':
+          outPt.set(rect.x - distance, rect.y + height / 2);
+          outDir.set(-1, 0);
+          break;
+
+        case 'right':
+          outPt.set(rect.x + width + distance, rect.y + height / 2);
+          outDir.set(1, 0);
+          break;
+      }
+    }
+
+    function projectPointToArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y, out) {
+      x -= cx;
+      y -= cy;
+      var d = Math.sqrt(x * x + y * y);
+      x /= d;
+      y /= d; // Intersect point.
+
+      var ox = x * r + cx;
+      var oy = y * r + cy;
+
+      if (Math.abs(startAngle - endAngle) % PI2$6 < 1e-4) {
+        // Is a circle
+        out[0] = ox;
+        out[1] = oy;
+        return d - r;
+      }
+
+      if (anticlockwise) {
+        var tmp = startAngle;
+        startAngle = normalizeRadian(endAngle);
+        endAngle = normalizeRadian(tmp);
+      } else {
+        startAngle = normalizeRadian(startAngle);
+        endAngle = normalizeRadian(endAngle);
+      }
+
+      if (startAngle > endAngle) {
+        endAngle += PI2$6;
+      }
+
+      var angle = Math.atan2(y, x);
+
+      if (angle < 0) {
+        angle += PI2$6;
+      }
+
+      if (angle >= startAngle && angle <= endAngle || angle + PI2$6 >= startAngle && angle + PI2$6 <= endAngle) {
+        // Project point is on the arc.
+        out[0] = ox;
+        out[1] = oy;
+        return d - r;
+      }
+
+      var x1 = r * Math.cos(startAngle) + cx;
+      var y1 = r * Math.sin(startAngle) + cy;
+      var x2 = r * Math.cos(endAngle) + cx;
+      var y2 = r * Math.sin(endAngle) + cy;
+      var d1 = (x1 - x) * (x1 - x) + (y1 - y) * (y1 - y);
+      var d2 = (x2 - x) * (x2 - x) + (y2 - y) * (y2 - y);
+
+      if (d1 < d2) {
+        out[0] = x1;
+        out[1] = y1;
+        return Math.sqrt(d1);
+      } else {
+        out[0] = x2;
+        out[1] = y2;
+        return Math.sqrt(d2);
+      }
+    }
+
+    function projectPointToLine(x1, y1, x2, y2, x, y, out, limitToEnds) {
+      var dx = x - x1;
+      var dy = y - y1;
+      var dx1 = x2 - x1;
+      var dy1 = y2 - y1;
+      var lineLen = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+      dx1 /= lineLen;
+      dy1 /= lineLen; // dot product
+
+      var projectedLen = dx * dx1 + dy * dy1;
+      var t = projectedLen / lineLen;
+
+      if (limitToEnds) {
+        t = Math.min(Math.max(t, 0), 1);
+      }
+
+      t *= lineLen;
+      var ox = out[0] = x1 + t * dx1;
+      var oy = out[1] = y1 + t * dy1;
+      return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
+    }
+
+    function projectPointToRect(x1, y1, width, height, x, y, out) {
+      if (width < 0) {
+        x1 = x1 + width;
+        width = -width;
+      }
+
+      if (height < 0) {
+        y1 = y1 + height;
+        height = -height;
+      }
+
+      var x2 = x1 + width;
+      var y2 = y1 + height;
+      var ox = out[0] = Math.min(Math.max(x, x1), x2);
+      var oy = out[1] = Math.min(Math.max(y, y1), y2);
+      return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
+    }
+
+    var tmpPt = [];
+
+    function nearestPointOnRect(pt, rect, out) {
+      var dist = projectPointToRect(rect.x, rect.y, rect.width, rect.height, pt.x, pt.y, tmpPt);
+      out.set(tmpPt[0], tmpPt[1]);
+      return dist;
+    }
+    /**
+     * Calculate min distance corresponding point.
+     * This method won't evaluate if point is in the path.
+     */
+
+
+    function nearestPointOnPath(pt, path, out) {
+      var xi = 0;
+      var yi = 0;
+      var x0 = 0;
+      var y0 = 0;
+      var x1;
+      var y1;
+      var minDist = Infinity;
+      var data = path.data;
+      var x = pt.x;
+      var y = pt.y;
+
+      for (var i = 0; i < data.length;) {
+        var cmd = data[i++];
+
+        if (i === 1) {
+          xi = data[i];
+          yi = data[i + 1];
+          x0 = xi;
+          y0 = yi;
+        }
+
+        var d = minDist;
+
+        switch (cmd) {
+          case CMD$3.M:
+            // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点
+            // 在 closePath 的时候使用
+            x0 = data[i++];
+            y0 = data[i++];
+            xi = x0;
+            yi = y0;
+            break;
+
+          case CMD$3.L:
+            d = projectPointToLine(xi, yi, data[i], data[i + 1], x, y, tmpPt, true);
+            xi = data[i++];
+            yi = data[i++];
+            break;
+
+          case CMD$3.C:
+            d = cubicProjectPoint(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
+            xi = data[i++];
+            yi = data[i++];
+            break;
+
+          case CMD$3.Q:
+            d = quadraticProjectPoint(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
+            xi = data[i++];
+            yi = data[i++];
+            break;
+
+          case CMD$3.A:
+            // TODO Arc 判断的开销比较大
+            var cx = data[i++];
+            var cy = data[i++];
+            var rx = data[i++];
+            var ry = data[i++];
+            var theta = data[i++];
+            var dTheta = data[i++]; // TODO Arc 旋转
+
+            i += 1;
+            var anticlockwise = !!(1 - data[i++]);
+            x1 = Math.cos(theta) * rx + cx;
+            y1 = Math.sin(theta) * ry + cy; // 不是直接使用 arc 命令
+
+            if (i <= 1) {
+              // 第一个命令起点还未定义
+              x0 = x1;
+              y0 = y1;
+            } // zr 使用scale来模拟椭圆, 这里也对x做一定的缩放
+
+
+            var _x = (x - cx) * ry / rx + cx;
+
+            d = projectPointToArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y, tmpPt);
+            xi = Math.cos(theta + dTheta) * rx + cx;
+            yi = Math.sin(theta + dTheta) * ry + cy;
+            break;
+
+          case CMD$3.R:
+            x0 = xi = data[i++];
+            y0 = yi = data[i++];
+            var width = data[i++];
+            var height = data[i++];
+            d = projectPointToRect(x0, y0, width, height, x, y, tmpPt);
+            break;
+
+          case CMD$3.Z:
+            d = projectPointToLine(xi, yi, x0, y0, x, y, tmpPt, true);
+            xi = x0;
+            yi = y0;
+            break;
+        }
+
+        if (d < minDist) {
+          minDist = d;
+          out.set(tmpPt[0], tmpPt[1]);
+        }
+      }
+
+      return minDist;
+    } // Temporal varible for intermediate usage.
+
+
+    var pt0 = new Point();
+    var pt1 = new Point();
+    var pt2 = new Point();
+    var dir = new Point();
+    var dir2 = new Point();
+    /**
+     * Calculate a proper guide line based on the label position and graphic element definition
+     * @param label
+     * @param labelRect
+     * @param target
+     * @param targetRect
+     */
+
+    function updateLabelLinePoints(target, labelLineModel) {
+      if (!target) {
+        return;
+      }
+
+      var labelLine = target.getTextGuideLine();
+      var label = target.getTextContent(); // Needs to create text guide in each charts.
+
+      if (!(label && labelLine)) {
+        return;
+      }
+
+      var labelGuideConfig = target.textGuideLineConfig || {};
+      var points = [[0, 0], [0, 0], [0, 0]];
+      var searchSpace = labelGuideConfig.candidates || DEFAULT_SEARCH_SPACE;
+      var labelRect = label.getBoundingRect().clone();
+      labelRect.applyTransform(label.getComputedTransform());
+      var minDist = Infinity;
+      var anchorPoint = labelGuideConfig.anchor;
+      var targetTransform = target.getComputedTransform();
+      var targetInversedTransform = targetTransform && invert([], targetTransform);
+      var len = labelLineModel.get('length2') || 0;
+
+      if (anchorPoint) {
+        pt2.copy(anchorPoint);
+      }
+
+      for (var i = 0; i < searchSpace.length; i++) {
+        var candidate = searchSpace[i];
+        getCandidateAnchor(candidate, 0, labelRect, pt0, dir);
+        Point.scaleAndAdd(pt1, pt0, dir, len); // Transform to target coord space.
+
+        pt1.transform(targetInversedTransform); // Note: getBoundingRect will ensure the `path` being created.
+
+        var boundingRect = target.getBoundingRect();
+        var dist = anchorPoint ? anchorPoint.distance(pt1) : target instanceof Path ? nearestPointOnPath(pt1, target.path, pt2) : nearestPointOnRect(pt1, boundingRect, pt2); // TODO pt2 is in the path
+
+        if (dist < minDist) {
+          minDist = dist; // Transform back to global space.
+
+          pt1.transform(targetTransform);
+          pt2.transform(targetTransform);
+          pt2.toArray(points[0]);
+          pt1.toArray(points[1]);
+          pt0.toArray(points[2]);
+        }
+      }
+
+      limitTurnAngle(points, labelLineModel.get('minTurnAngle'));
+      labelLine.setShape({
+        points: points
+      });
+    } // Temporal variable for the limitTurnAngle function
+
+    var tmpArr = [];
+    var tmpProjPoint = new Point();
+    /**
+     * Reduce the line segment attached to the label to limit the turn angle between two segments.
+     * @param linePoints
+     * @param minTurnAngle Radian of minimum turn angle. 0 - 180
+     */
+
+    function limitTurnAngle(linePoints, minTurnAngle) {
+      if (!(minTurnAngle <= 180 && minTurnAngle > 0)) {
+        return;
+      }
+
+      minTurnAngle = minTurnAngle / 180 * Math.PI; // The line points can be
+      //      /pt1----pt2 (label)
+      //     /
+      // pt0/
+
+      pt0.fromArray(linePoints[0]);
+      pt1.fromArray(linePoints[1]);
+      pt2.fromArray(linePoints[2]);
+      Point.sub(dir, pt0, pt1);
+      Point.sub(dir2, pt2, pt1);
+      var len1 = dir.len();
+      var len2 = dir2.len();
+
+      if (len1 < 1e-3 || len2 < 1e-3) {
+        return;
+      }
+
+      dir.scale(1 / len1);
+      dir2.scale(1 / len2);
+      var angleCos = dir.dot(dir2);
+      var minTurnAngleCos = Math.cos(minTurnAngle);
+
+      if (minTurnAngleCos < angleCos) {
+        // Smaller than minTurnAngle
+        // Calculate project point of pt0 on pt1-pt2
+        var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
+        tmpProjPoint.fromArray(tmpArr); // Calculate new projected length with limited minTurnAngle and get the new connect point
+
+        tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI - minTurnAngle)); // Limit the new calculated connect point between pt1 and pt2.
+
+        var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
+
+        if (isNaN(t)) {
+          return;
+        }
+
+        if (t < 0) {
+          Point.copy(tmpProjPoint, pt1);
+        } else if (t > 1) {
+          Point.copy(tmpProjPoint, pt2);
+        }
+
+        tmpProjPoint.toArray(linePoints[1]);
+      }
+    }
+    /**
+     * Limit the angle of line and the surface
+     * @param maxSurfaceAngle Radian of minimum turn angle. 0 - 180. 0 is same direction to normal. 180 is opposite
+     */
+
+    function limitSurfaceAngle(linePoints, surfaceNormal, maxSurfaceAngle) {
+      if (!(maxSurfaceAngle <= 180 && maxSurfaceAngle > 0)) {
+        return;
+      }
+
+      maxSurfaceAngle = maxSurfaceAngle / 180 * Math.PI;
+      pt0.fromArray(linePoints[0]);
+      pt1.fromArray(linePoints[1]);
+      pt2.fromArray(linePoints[2]);
+      Point.sub(dir, pt1, pt0);
+      Point.sub(dir2, pt2, pt1);
+      var len1 = dir.len();
+      var len2 = dir2.len();
+
+      if (len1 < 1e-3 || len2 < 1e-3) {
+        return;
+      }
+
+      dir.scale(1 / len1);
+      dir2.scale(1 / len2);
+      var angleCos = dir.dot(surfaceNormal);
+      var maxSurfaceAngleCos = Math.cos(maxSurfaceAngle);
+
+      if (angleCos < maxSurfaceAngleCos) {
+        // Calculate project point of pt0 on pt1-pt2
+        var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
+        tmpProjPoint.fromArray(tmpArr);
+        var HALF_PI = Math.PI / 2;
+        var angle2 = Math.acos(dir2.dot(surfaceNormal));
+        var newAngle = HALF_PI + angle2 - maxSurfaceAngle;
+
+        if (newAngle >= HALF_PI) {
+          // parallel
+          Point.copy(tmpProjPoint, pt2);
+        } else {
+          // Calculate new projected length with limited minTurnAngle and get the new connect point
+          tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI / 2 - newAngle)); // Limit the new calculated connect point between pt1 and pt2.
+
+          var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
+
+          if (isNaN(t)) {
+            return;
+          }
+
+          if (t < 0) {
+            Point.copy(tmpProjPoint, pt1);
+          } else if (t > 1) {
+            Point.copy(tmpProjPoint, pt2);
+          }
+        }
+
+        tmpProjPoint.toArray(linePoints[1]);
+      }
+    }
+
+    function setLabelLineState(labelLine, ignore, stateName, stateModel) {
+      var isNormal = stateName === 'normal';
+      var stateObj = isNormal ? labelLine : labelLine.ensureState(stateName); // Make sure display.
+
+      stateObj.ignore = ignore; // Set smooth
+
+      var smooth = stateModel.get('smooth');
+
+      if (smooth && smooth === true) {
+        smooth = 0.3;
+      }
+
+      stateObj.shape = stateObj.shape || {};
+
+      if (smooth > 0) {
+        stateObj.shape.smooth = smooth;
+      }
+
+      var styleObj = stateModel.getModel('lineStyle').getLineStyle();
+      isNormal ? labelLine.useStyle(styleObj) : stateObj.style = styleObj;
+    }
+
+    function buildLabelLinePath(path, shape) {
+      var smooth = shape.smooth;
+      var points = shape.points;
+
+      if (!points) {
+        return;
+      }
+
+      path.moveTo(points[0][0], points[0][1]);
+
+      if (smooth > 0 && points.length >= 3) {
+        var len1 = dist(points[0], points[1]);
+        var len2 = dist(points[1], points[2]);
+
+        if (!len1 || !len2) {
+          path.lineTo(points[1][0], points[1][1]);
+          path.lineTo(points[2][0], points[2][1]);
+          return;
+        }
+
+        var moveLen = Math.min(len1, len2) * smooth;
+        var midPoint0 = lerp([], points[1], points[0], moveLen / len1);
+        var midPoint2 = lerp([], points[1], points[2], moveLen / len2);
+        var midPoint1 = lerp([], midPoint0, midPoint2, 0.5);
+        path.bezierCurveTo(midPoint0[0], midPoint0[1], midPoint0[0], midPoint0[1], midPoint1[0], midPoint1[1]);
+        path.bezierCurveTo(midPoint2[0], midPoint2[1], midPoint2[0], midPoint2[1], points[2][0], points[2][1]);
+      } else {
+        for (var i = 1; i < points.length; i++) {
+          path.lineTo(points[i][0], points[i][1]);
+        }
+      }
+    }
+    /**
+     * Create a label line if necessary and set it's style.
+     */
+
+
+    function setLabelLineStyle(targetEl, statesModels, defaultStyle) {
+      var labelLine = targetEl.getTextGuideLine();
+      var label = targetEl.getTextContent();
+
+      if (!label) {
+        // Not show label line if there is no label.
+        if (labelLine) {
+          targetEl.removeTextGuideLine();
+        }
+
+        return;
+      }
+
+      var normalModel = statesModels.normal;
+      var showNormal = normalModel.get('show');
+      var labelIgnoreNormal = label.ignore;
+
+      for (var i = 0; i < DISPLAY_STATES.length; i++) {
+        var stateName = DISPLAY_STATES[i];
+        var stateModel = statesModels[stateName];
+        var isNormal = stateName === 'normal';
+
+        if (stateModel) {
+          var stateShow = stateModel.get('show');
+          var isLabelIgnored = isNormal ? labelIgnoreNormal : retrieve2(label.states[stateName] && label.states[stateName].ignore, labelIgnoreNormal);
+
+          if (isLabelIgnored // Not show when label is not shown in this state.
+          || !retrieve2(stateShow, showNormal) // Use normal state by default if not set.
+          ) {
+              var stateObj = isNormal ? labelLine : labelLine && labelLine.states.normal;
+
+              if (stateObj) {
+                stateObj.ignore = true;
+              }
+
+              continue;
+            } // Create labelLine if not exists
+
+
+          if (!labelLine) {
+            labelLine = new Polyline();
+            targetEl.setTextGuideLine(labelLine); // Reset state of normal because it's new created.
+            // NOTE: NORMAL should always been the first!
+
+            if (!isNormal && (labelIgnoreNormal || !showNormal)) {
+              setLabelLineState(labelLine, true, 'normal', statesModels.normal);
+            } // Use same state proxy.
+
+
+            if (targetEl.stateProxy) {
+              labelLine.stateProxy = targetEl.stateProxy;
+            }
+          }
+
+          setLabelLineState(labelLine, false, stateName, stateModel);
+        }
+      }
+
+      if (labelLine) {
+        defaults(labelLine.style, defaultStyle); // Not fill.
+
+        labelLine.style.fill = null;
+        var showAbove = normalModel.get('showAbove');
+        var labelLineConfig = targetEl.textGuideLineConfig = targetEl.textGuideLineConfig || {};
+        labelLineConfig.showAbove = showAbove || false; // Custom the buildPath.
+
+        labelLine.buildPath = buildLabelLinePath;
+      }
+    }
+    function getLabelLineStatesModels(itemModel, labelLineName) {
+      labelLineName = labelLineName || 'labelLine';
+      var statesModels = {
+        normal: itemModel.getModel(labelLineName)
+      };
+
+      for (var i = 0; i < SPECIAL_STATES.length; i++) {
+        var stateName = SPECIAL_STATES[i];
+        statesModels[stateName] = itemModel.getModel([stateName, labelLineName]);
+      }
+
+      return statesModels;
+    }
+
+    function prepareLayoutList(input) {
+      var list = [];
+
+      for (var i = 0; i < input.length; i++) {
+        var rawItem = input[i];
+
+        if (rawItem.defaultAttr.ignore) {
+          continue;
+        }
+
+        var label = rawItem.label;
+        var transform = label.getComputedTransform(); // NOTE: Get bounding rect after getComputedTransform, or label may not been updated by the host el.
+
+        var localRect = label.getBoundingRect();
+        var isAxisAligned = !transform || transform[1] < 1e-5 && transform[2] < 1e-5;
+        var minMargin = label.style.margin || 0;
+        var globalRect = localRect.clone();
+        globalRect.applyTransform(transform);
+        globalRect.x -= minMargin / 2;
+        globalRect.y -= minMargin / 2;
+        globalRect.width += minMargin;
+        globalRect.height += minMargin;
+        var obb = isAxisAligned ? new OrientedBoundingRect(localRect, transform) : null;
+        list.push({
+          label: label,
+          labelLine: rawItem.labelLine,
+          rect: globalRect,
+          localRect: localRect,
+          obb: obb,
+          priority: rawItem.priority,
+          defaultAttr: rawItem.defaultAttr,
+          layoutOption: rawItem.computedLayoutOption,
+          axisAligned: isAxisAligned,
+          transform: transform
+        });
+      }
+
+      return list;
+    }
+
+    function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) {
+      var len = list.length;
+
+      if (len < 2) {
+        return;
+      }
+
+      list.sort(function (a, b) {
+        return a.rect[xyDim] - b.rect[xyDim];
+      });
+      var lastPos = 0;
+      var delta;
+      var adjusted = false;
+      var totalShifts = 0;
+
+      for (var i = 0; i < len; i++) {
+        var item = list[i];
+        var rect = item.rect;
+        delta = rect[xyDim] - lastPos;
+
+        if (delta < 0) {
+          // shiftForward(i, len, -delta);
+          rect[xyDim] -= delta;
+          item.label[xyDim] -= delta;
+          adjusted = true;
+        }
+
+        var shift = Math.max(-delta, 0);
+        totalShifts += shift;
+        lastPos = rect[xyDim] + rect[sizeDim];
+      }
+
+      if (totalShifts > 0 && balanceShift) {
+        // Shift back to make the distribution more equally.
+        shiftList(-totalShifts / len, 0, len);
+      } // TODO bleedMargin?
+
+
+      var first = list[0];
+      var last = list[len - 1];
+      var minGap;
+      var maxGap;
+      updateMinMaxGap(); // If ends exceed two bounds, squeeze at most 80%, then take the gap of two bounds.
+
+      minGap < 0 && squeezeGaps(-minGap, 0.8);
+      maxGap < 0 && squeezeGaps(maxGap, 0.8);
+      updateMinMaxGap();
+      takeBoundsGap(minGap, maxGap, 1);
+      takeBoundsGap(maxGap, minGap, -1); // Handle bailout when there is not enough space.
+
+      updateMinMaxGap();
+
+      if (minGap < 0) {
+        squeezeWhenBailout(-minGap);
+      }
+
+      if (maxGap < 0) {
+        squeezeWhenBailout(maxGap);
+      }
+
+      function updateMinMaxGap() {
+        minGap = first.rect[xyDim] - minBound;
+        maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim];
+      }
+
+      function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) {
+        if (gapThisBound < 0) {
+          // Move from other gap if can.
+          var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound);
+
+          if (moveFromMaxGap > 0) {
+            shiftList(moveFromMaxGap * moveDir, 0, len);
+            var remained = moveFromMaxGap + gapThisBound;
+
+            if (remained < 0) {
+              squeezeGaps(-remained * moveDir, 1);
+            }
+          } else {
+            squeezeGaps(-gapThisBound * moveDir, 1);
+          }
+        }
+      }
+
+      function shiftList(delta, start, end) {
+        if (delta !== 0) {
+          adjusted = true;
+        }
+
+        for (var i = start; i < end; i++) {
+          var item = list[i];
+          var rect = item.rect;
+          rect[xyDim] += delta;
+          item.label[xyDim] += delta;
+        }
+      } // Squeeze gaps if the labels exceed margin.
+
+
+      function squeezeGaps(delta, maxSqeezePercent) {
+        var gaps = [];
+        var totalGaps = 0;
+
+        for (var i = 1; i < len; i++) {
+          var prevItemRect = list[i - 1].rect;
+          var gap = Math.max(list[i].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim], 0);
+          gaps.push(gap);
+          totalGaps += gap;
+        }
+
+        if (!totalGaps) {
+          return;
+        }
+
+        var squeezePercent = Math.min(Math.abs(delta) / totalGaps, maxSqeezePercent);
+
+        if (delta > 0) {
+          for (var i = 0; i < len - 1; i++) {
+            // Distribute the shift delta to all gaps.
+            var movement = gaps[i] * squeezePercent; // Forward
+
+            shiftList(movement, 0, i + 1);
+          }
+        } else {
+          // Backward
+          for (var i = len - 1; i > 0; i--) {
+            // Distribute the shift delta to all gaps.
+            var movement = gaps[i - 1] * squeezePercent;
+            shiftList(-movement, i, len);
+          }
+        }
+      }
+      /**
+       * Squeeze to allow overlap if there is no more space available.
+       * Let other overlapping strategy like hideOverlap do the job instead of keep exceeding the bounds.
+       */
+
+
+      function squeezeWhenBailout(delta) {
+        var dir = delta < 0 ? -1 : 1;
+        delta = Math.abs(delta);
+        var moveForEachLabel = Math.ceil(delta / (len - 1));
+
+        for (var i = 0; i < len - 1; i++) {
+          if (dir > 0) {
+            // Forward
+            shiftList(moveForEachLabel, 0, i + 1);
+          } else {
+            // Backward
+            shiftList(-moveForEachLabel, len - i - 1, len);
+          }
+
+          delta -= moveForEachLabel;
+
+          if (delta <= 0) {
+            return;
+          }
+        }
+      }
+
+      return adjusted;
+    }
+    /**
+     * Adjust labels on x direction to avoid overlap.
+     */
+
+
+    function shiftLayoutOnX(list, leftBound, rightBound, // If average the shifts on all labels and add them to 0
+    // TODO: Not sure if should enable it.
+    // Pros: The angle of lines will distribute more equally
+    // Cons: In some layout. It may not what user wanted. like in pie. the label of last sector is usually changed unexpectedly.
+    balanceShift) {
+      return shiftLayout(list, 'x', 'width', leftBound, rightBound, balanceShift);
+    }
+    /**
+     * Adjust labels on y direction to avoid overlap.
+     */
+
+    function shiftLayoutOnY(list, topBound, bottomBound, // If average the shifts on all labels and add them to 0
+    balanceShift) {
+      return shiftLayout(list, 'y', 'height', topBound, bottomBound, balanceShift);
+    }
+    function hideOverlap(labelList) {
+      var displayedLabels = []; // TODO, render overflow visible first, put in the displayedLabels.
+
+      labelList.sort(function (a, b) {
+        return b.priority - a.priority;
+      });
+      var globalRect = new BoundingRect(0, 0, 0, 0);
+
+      function hideEl(el) {
+        if (!el.ignore) {
+          // Show on emphasis.
+          var emphasisState = el.ensureState('emphasis');
+
+          if (emphasisState.ignore == null) {
+            emphasisState.ignore = false;
+          }
+        }
+
+        el.ignore = true;
+      }
+
+      for (var i = 0; i < labelList.length; i++) {
+        var labelItem = labelList[i];
+        var isAxisAligned = labelItem.axisAligned;
+        var localRect = labelItem.localRect;
+        var transform = labelItem.transform;
+        var label = labelItem.label;
+        var labelLine = labelItem.labelLine;
+        globalRect.copy(labelItem.rect); // Add a threshold because layout may be aligned precisely.
+
+        globalRect.width -= 0.1;
+        globalRect.height -= 0.1;
+        globalRect.x += 0.05;
+        globalRect.y += 0.05;
+        var obb = labelItem.obb;
+        var overlapped = false;
+
+        for (var j = 0; j < displayedLabels.length; j++) {
+          var existsTextCfg = displayedLabels[j]; // Fast rejection.
+
+          if (!globalRect.intersect(existsTextCfg.rect)) {
+            continue;
+          }
+
+          if (isAxisAligned && existsTextCfg.axisAligned) {
+            // Is overlapped
+            overlapped = true;
+            break;
+          }
+
+          if (!existsTextCfg.obb) {
+            // If self is not axis aligned. But other is.
+            existsTextCfg.obb = new OrientedBoundingRect(existsTextCfg.localRect, existsTextCfg.transform);
+          }
+
+          if (!obb) {
+            // If self is axis aligned. But other is not.
+            obb = new OrientedBoundingRect(localRect, transform);
+          }
+
+          if (obb.intersect(existsTextCfg.obb)) {
+            overlapped = true;
+            break;
+          }
+        } // TODO Callback to determine if this overlap should be handled?
+
+
+        if (overlapped) {
+          hideEl(label);
+          labelLine && hideEl(labelLine);
+        } else {
+          label.attr('ignore', labelItem.defaultAttr.ignore);
+          labelLine && labelLine.attr('ignore', labelItem.defaultAttr.labelGuideIgnore);
+          displayedLabels.push(labelItem);
+        }
+      }
+    }
+
+    function cloneArr(points) {
+      if (points) {
+        var newPoints = [];
+
+        for (var i = 0; i < points.length; i++) {
+          newPoints.push(points[i].slice());
+        }
+
+        return newPoints;
+      }
+    }
+
+    function prepareLayoutCallbackParams(labelItem, hostEl) {
+      var label = labelItem.label;
+      var labelLine = hostEl && hostEl.getTextGuideLine();
+      return {
+        dataIndex: labelItem.dataIndex,
+        dataType: labelItem.dataType,
+        seriesIndex: labelItem.seriesModel.seriesIndex,
+        text: labelItem.label.style.text,
+        rect: labelItem.hostRect,
+        labelRect: labelItem.rect,
+        // x: labelAttr.x,
+        // y: labelAttr.y,
+        align: label.style.align,
+        verticalAlign: label.style.verticalAlign,
+        labelLinePoints: cloneArr(labelLine && labelLine.shape.points)
+      };
+    }
+
+    var LABEL_OPTION_TO_STYLE_KEYS = ['align', 'verticalAlign', 'width', 'height', 'fontSize'];
+    var dummyTransformable = new Transformable();
+    var labelLayoutInnerStore = makeInner();
+    var labelLineAnimationStore = makeInner();
+
+    function extendWithKeys(target, source, keys) {
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+
+        if (source[key] != null) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    var LABEL_LAYOUT_PROPS = ['x', 'y', 'rotation'];
+
+    var LabelManager =
+    /** @class */
+    function () {
+      function LabelManager() {
+        this._labelList = [];
+        this._chartViewList = [];
+      }
+
+      LabelManager.prototype.clearLabels = function () {
+        this._labelList = [];
+        this._chartViewList = [];
+      };
+      /**
+       * Add label to manager
+       */
+
+
+      LabelManager.prototype._addLabel = function (dataIndex, dataType, seriesModel, label, layoutOption) {
+        var labelStyle = label.style;
+        var hostEl = label.__hostTarget;
+        var textConfig = hostEl.textConfig || {}; // TODO: If label is in other state.
+
+        var labelTransform = label.getComputedTransform();
+        var labelRect = label.getBoundingRect().plain();
+        BoundingRect.applyTransform(labelRect, labelRect, labelTransform);
+
+        if (labelTransform) {
+          dummyTransformable.setLocalTransform(labelTransform);
+        } else {
+          // Identity transform.
+          dummyTransformable.x = dummyTransformable.y = dummyTransformable.rotation = dummyTransformable.originX = dummyTransformable.originY = 0;
+          dummyTransformable.scaleX = dummyTransformable.scaleY = 1;
+        }
+
+        var host = label.__hostTarget;
+        var hostRect;
+
+        if (host) {
+          hostRect = host.getBoundingRect().plain();
+          var transform = host.getComputedTransform();
+          BoundingRect.applyTransform(hostRect, hostRect, transform);
+        }
+
+        var labelGuide = hostRect && host.getTextGuideLine();
+
+        this._labelList.push({
+          label: label,
+          labelLine: labelGuide,
+          seriesModel: seriesModel,
+          dataIndex: dataIndex,
+          dataType: dataType,
+          layoutOption: layoutOption,
+          computedLayoutOption: null,
+          rect: labelRect,
+          hostRect: hostRect,
+          // Label with lower priority will be hidden when overlapped
+          // Use rect size as default priority
+          priority: hostRect ? hostRect.width * hostRect.height : 0,
+          // Save default label attributes.
+          // For restore if developers want get back to default value in callback.
+          defaultAttr: {
+            ignore: label.ignore,
+            labelGuideIgnore: labelGuide && labelGuide.ignore,
+            x: dummyTransformable.x,
+            y: dummyTransformable.y,
+            rotation: dummyTransformable.rotation,
+            style: {
+              x: labelStyle.x,
+              y: labelStyle.y,
+              align: labelStyle.align,
+              verticalAlign: labelStyle.verticalAlign,
+              width: labelStyle.width,
+              height: labelStyle.height,
+              fontSize: labelStyle.fontSize
+            },
+            cursor: label.cursor,
+            attachedPos: textConfig.position,
+            attachedRot: textConfig.rotation
+          }
+        });
+      };
+
+      LabelManager.prototype.addLabelsOfSeries = function (chartView) {
+        var _this = this;
+
+        this._chartViewList.push(chartView);
+
+        var seriesModel = chartView.__model;
+        var layoutOption = seriesModel.get('labelLayout');
+        /**
+         * Ignore layouting if it's not specified anything.
+         */
+
+        if (!(isFunction(layoutOption) || keys(layoutOption).length)) {
+          return;
+        }
+
+        chartView.group.traverse(function (child) {
+          if (child.ignore) {
+            return true; // Stop traverse descendants.
+          } // Only support label being hosted on graphic elements.
+
+
+          var textEl = child.getTextContent();
+          var ecData = getECData(child); // Can only attach the text on the element with dataIndex
+
+          if (textEl && !textEl.disableLabelLayout) {
+            _this._addLabel(ecData.dataIndex, ecData.dataType, seriesModel, textEl, layoutOption);
+          }
+        });
+      };
+
+      LabelManager.prototype.updateLayoutConfig = function (api) {
+        var width = api.getWidth();
+        var height = api.getHeight();
+
+        function createDragHandler(el, labelLineModel) {
+          return function () {
+            updateLabelLinePoints(el, labelLineModel);
+          };
+        }
+
+        for (var i = 0; i < this._labelList.length; i++) {
+          var labelItem = this._labelList[i];
+          var label = labelItem.label;
+          var hostEl = label.__hostTarget;
+          var defaultLabelAttr = labelItem.defaultAttr;
+          var layoutOption = void 0; // TODO A global layout option?
+
+          if (typeof labelItem.layoutOption === 'function') {
+            layoutOption = labelItem.layoutOption(prepareLayoutCallbackParams(labelItem, hostEl));
+          } else {
+            layoutOption = labelItem.layoutOption;
+          }
+
+          layoutOption = layoutOption || {};
+          labelItem.computedLayoutOption = layoutOption;
+          var degreeToRadian = Math.PI / 180;
+
+          if (hostEl) {
+            hostEl.setTextConfig({
+              // Force to set local false.
+              local: false,
+              // Ignore position and rotation config on the host el if x or y is changed.
+              position: layoutOption.x != null || layoutOption.y != null ? null : defaultLabelAttr.attachedPos,
+              // Ignore rotation config on the host el if rotation is changed.
+              rotation: layoutOption.rotate != null ? layoutOption.rotate * degreeToRadian : defaultLabelAttr.attachedRot,
+              offset: [layoutOption.dx || 0, layoutOption.dy || 0]
+            });
+          }
+
+          var needsUpdateLabelLine = false;
+
+          if (layoutOption.x != null) {
+            // TODO width of chart view.
+            label.x = parsePercent$1(layoutOption.x, width);
+            label.setStyle('x', 0); // Ignore movement in style. TODO: origin.
+
+            needsUpdateLabelLine = true;
+          } else {
+            label.x = defaultLabelAttr.x;
+            label.setStyle('x', defaultLabelAttr.style.x);
+          }
+
+          if (layoutOption.y != null) {
+            // TODO height of chart view.
+            label.y = parsePercent$1(layoutOption.y, height);
+            label.setStyle('y', 0); // Ignore movement in style.
+
+            needsUpdateLabelLine = true;
+          } else {
+            label.y = defaultLabelAttr.y;
+            label.setStyle('y', defaultLabelAttr.style.y);
+          }
+
+          if (layoutOption.labelLinePoints) {
+            var guideLine = hostEl.getTextGuideLine();
+
+            if (guideLine) {
+              guideLine.setShape({
+                points: layoutOption.labelLinePoints
+              }); // Not update
+
+              needsUpdateLabelLine = false;
+            }
+          }
+
+          var labelLayoutStore = labelLayoutInnerStore(label);
+          labelLayoutStore.needsUpdateLabelLine = needsUpdateLabelLine;
+          label.rotation = layoutOption.rotate != null ? layoutOption.rotate * degreeToRadian : defaultLabelAttr.rotation;
+
+          for (var k = 0; k < LABEL_OPTION_TO_STYLE_KEYS.length; k++) {
+            var key = LABEL_OPTION_TO_STYLE_KEYS[k];
+            label.setStyle(key, layoutOption[key] != null ? layoutOption[key] : defaultLabelAttr.style[key]);
+          }
+
+          if (layoutOption.draggable) {
+            label.draggable = true;
+            label.cursor = 'move';
+
+            if (hostEl) {
+              var hostModel = labelItem.seriesModel;
+
+              if (labelItem.dataIndex != null) {
+                var data = labelItem.seriesModel.getData(labelItem.dataType);
+                hostModel = data.getItemModel(labelItem.dataIndex);
+              }
+
+              label.on('drag', createDragHandler(hostEl, hostModel.getModel('labelLine')));
+            }
+          } else {
+            // TODO Other drag functions?
+            label.off('drag');
+            label.cursor = defaultLabelAttr.cursor;
+          }
+        }
+      };
+
+      LabelManager.prototype.layout = function (api) {
+        var width = api.getWidth();
+        var height = api.getHeight();
+        var labelList = prepareLayoutList(this._labelList);
+        var labelsNeedsAdjustOnX = filter(labelList, function (item) {
+          return item.layoutOption.moveOverlap === 'shiftX';
+        });
+        var labelsNeedsAdjustOnY = filter(labelList, function (item) {
+          return item.layoutOption.moveOverlap === 'shiftY';
+        });
+        shiftLayoutOnX(labelsNeedsAdjustOnX, 0, width);
+        shiftLayoutOnY(labelsNeedsAdjustOnY, 0, height);
+        var labelsNeedsHideOverlap = filter(labelList, function (item) {
+          return item.layoutOption.hideOverlap;
+        });
+        hideOverlap(labelsNeedsHideOverlap);
+      };
+      /**
+       * Process all labels. Not only labels with layoutOption.
+       */
+
+
+      LabelManager.prototype.processLabelsOverall = function () {
+        var _this = this;
+
+        each(this._chartViewList, function (chartView) {
+          var seriesModel = chartView.__model;
+          var ignoreLabelLineUpdate = chartView.ignoreLabelLineUpdate;
+          var animationEnabled = seriesModel.isAnimationEnabled();
+          chartView.group.traverse(function (child) {
+            if (child.ignore) {
+              return true; // Stop traverse descendants.
+            }
+
+            var needsUpdateLabelLine = !ignoreLabelLineUpdate;
+            var label = child.getTextContent();
+
+            if (!needsUpdateLabelLine && label) {
+              needsUpdateLabelLine = labelLayoutInnerStore(label).needsUpdateLabelLine;
+            }
+
+            if (needsUpdateLabelLine) {
+              _this._updateLabelLine(child, seriesModel);
+            }
+
+            if (animationEnabled) {
+              _this._animateLabels(child, seriesModel);
+            }
+          });
+        });
+      };
+
+      LabelManager.prototype._updateLabelLine = function (el, seriesModel) {
+        // Only support label being hosted on graphic elements.
+        var textEl = el.getTextContent(); // Update label line style.
+
+        var ecData = getECData(el);
+        var dataIndex = ecData.dataIndex; // Only support labelLine on the labels represent data.
+
+        if (textEl && dataIndex != null) {
+          var data = seriesModel.getData(ecData.dataType);
+          var itemModel = data.getItemModel(dataIndex);
+          var defaultStyle = {};
+          var visualStyle = data.getItemVisual(dataIndex, 'style');
+          var visualType = data.getVisual('drawType'); // Default to be same with main color
+
+          defaultStyle.stroke = visualStyle[visualType];
+          var labelLineModel = itemModel.getModel('labelLine');
+          setLabelLineStyle(el, getLabelLineStatesModels(itemModel), defaultStyle);
+          updateLabelLinePoints(el, labelLineModel);
+        }
+      };
+
+      LabelManager.prototype._animateLabels = function (el, seriesModel) {
+        var textEl = el.getTextContent();
+        var guideLine = el.getTextGuideLine(); // Animate
+
+        if (textEl && !textEl.ignore && !textEl.invisible && !el.disableLabelAnimation && !isElementRemoved(el)) {
+          var layoutStore = labelLayoutInnerStore(textEl);
+          var oldLayout = layoutStore.oldLayout;
+          var ecData = getECData(el);
+          var dataIndex = ecData.dataIndex;
+          var newProps = {
+            x: textEl.x,
+            y: textEl.y,
+            rotation: textEl.rotation
+          };
+          var data = seriesModel.getData(ecData.dataType);
+
+          if (!oldLayout) {
+            textEl.attr(newProps); // Disable fade in animation if value animation is enabled.
+
+            if (!labelInner(textEl).valueAnimation) {
+              var oldOpacity = retrieve2(textEl.style.opacity, 1); // Fade in animation
+
+              textEl.style.opacity = 0;
+              initProps(textEl, {
+                style: {
+                  opacity: oldOpacity
+                }
+              }, seriesModel, dataIndex);
+            }
+          } else {
+            textEl.attr(oldLayout); // Make sure the animation from is in the right status.
+
+            var prevStates = el.prevStates;
+
+            if (prevStates) {
+              if (indexOf(prevStates, 'select') >= 0) {
+                textEl.attr(layoutStore.oldLayoutSelect);
+              }
+
+              if (indexOf(prevStates, 'emphasis') >= 0) {
+                textEl.attr(layoutStore.oldLayoutEmphasis);
+              }
+            }
+
+            updateProps(textEl, newProps, seriesModel, dataIndex);
+          }
+
+          layoutStore.oldLayout = newProps;
+
+          if (textEl.states.select) {
+            var layoutSelect = layoutStore.oldLayoutSelect = {};
+            extendWithKeys(layoutSelect, newProps, LABEL_LAYOUT_PROPS);
+            extendWithKeys(layoutSelect, textEl.states.select, LABEL_LAYOUT_PROPS);
+          }
+
+          if (textEl.states.emphasis) {
+            var layoutEmphasis = layoutStore.oldLayoutEmphasis = {};
+            extendWithKeys(layoutEmphasis, newProps, LABEL_LAYOUT_PROPS);
+            extendWithKeys(layoutEmphasis, textEl.states.emphasis, LABEL_LAYOUT_PROPS);
+          }
+
+          animateLabelValue(textEl, dataIndex, data, seriesModel, seriesModel);
+        }
+
+        if (guideLine && !guideLine.ignore && !guideLine.invisible) {
+          var layoutStore = labelLineAnimationStore(guideLine);
+          var oldLayout = layoutStore.oldLayout;
+          var newLayout = {
+            points: guideLine.shape.points
+          };
+
+          if (!oldLayout) {
+            guideLine.setShape(newLayout);
+            guideLine.style.strokePercent = 0;
+            initProps(guideLine, {
+              style: {
+                strokePercent: 1
+              }
+            }, seriesModel);
+          } else {
+            guideLine.attr({
+              shape: oldLayout
+            });
+            updateProps(guideLine, {
+              shape: newLayout
+            }, seriesModel);
+          }
+
+          layoutStore.oldLayout = newLayout;
+        }
+      };
+
+      return LabelManager;
+    }();
+
+    // Inlucdes: pieSelect, pieUnSelect, pieToggleSelect, mapSelect, mapUnSelect, mapToggleSelect
+
+    function createLegacyDataSelectAction(seriesType, ecRegisterAction) {
+      function getSeriesIndices(ecModel, payload) {
+        var seriesIndices = [];
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: seriesType,
+          query: payload
+        }, function (seriesModel) {
+          seriesIndices.push(seriesModel.seriesIndex);
+        });
+        return seriesIndices;
+      }
+
+      each([[seriesType + 'ToggleSelect', 'toggleSelect'], [seriesType + 'Select', 'select'], [seriesType + 'UnSelect', 'unselect']], function (eventsMap) {
+        ecRegisterAction(eventsMap[0], function (payload, ecModel, api) {
+          payload = extend({}, payload);
+
+          if ("development" !== 'production') {
+            deprecateReplaceLog(payload.type, eventsMap[1]);
+          }
+
+          api.dispatchAction(extend(payload, {
+            type: eventsMap[1],
+            seriesIndex: getSeriesIndices(ecModel, payload)
+          }));
+        });
+      });
+    }
+
+    function handleSeriesLegacySelectEvents(type, eventPostfix, ecIns, ecModel, payload) {
+      var legacyEventName = type + eventPostfix;
+
+      if (!ecIns.isSilent(legacyEventName)) {
+        if ("development" !== 'production') {
+          deprecateLog("event " + legacyEventName + " is deprecated.");
+        }
+
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'pie'
+        }, function (seriesModel) {
+          var seriesIndex = seriesModel.seriesIndex;
+          var selected = payload.selected;
+
+          for (var i = 0; i < selected.length; i++) {
+            if (selected[i].seriesIndex === seriesIndex) {
+              var data = seriesModel.getData();
+              var dataIndex = queryDataIndex(data, payload.fromActionPayload);
+              ecIns.trigger(legacyEventName, {
+                type: legacyEventName,
+                seriesId: seriesModel.id,
+                name: isArray(dataIndex) ? data.getName(dataIndex[0]) : data.getName(dataIndex),
+                selected: extend({}, seriesModel.option.selectedMap)
+              });
+            }
+          }
+        });
+      }
+    }
+
+    function handleLegacySelectEvents(messageCenter, ecIns, api) {
+      messageCenter.on('selectchanged', function (params) {
+        var ecModel = api.getModel();
+
+        if (params.isFromClick) {
+          handleSeriesLegacySelectEvents('map', 'selectchanged', ecIns, ecModel, params);
+          handleSeriesLegacySelectEvents('pie', 'selectchanged', ecIns, ecModel, params);
+        } else if (params.fromAction === 'select') {
+          handleSeriesLegacySelectEvents('map', 'selected', ecIns, ecModel, params);
+          handleSeriesLegacySelectEvents('pie', 'selected', ecIns, ecModel, params);
+        } else if (params.fromAction === 'unselect') {
+          handleSeriesLegacySelectEvents('map', 'unselected', ecIns, ecModel, params);
+          handleSeriesLegacySelectEvents('pie', 'unselected', ecIns, ecModel, params);
+        }
+      });
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function findEventDispatcher(target, det, returnFirstMatch) {
+      var found;
+
+      while (target) {
+        if (det(target)) {
+          found = target;
+
+          if (returnFirstMatch) {
+            break;
+          }
+        }
+
+        target = target.__hostTarget || target.parent;
+      }
+
+      return found;
+    }
+
+    var wmUniqueIndex = Math.round(Math.random() * 9);
+    var WeakMap = (function () {
+        function WeakMap() {
+            this._id = '__ec_inner_' + wmUniqueIndex++;
+        }
+        WeakMap.prototype.get = function (key) {
+            return this._guard(key)[this._id];
+        };
+        WeakMap.prototype.set = function (key, value) {
+            var target = this._guard(key);
+            if (typeof Object.defineProperty === 'function') {
+                Object.defineProperty(target, this._id, {
+                    value: value,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            else {
+                target[this._id] = value;
+            }
+            return this;
+        };
+        WeakMap.prototype["delete"] = function (key) {
+            if (this.has(key)) {
+                delete this._guard(key)[this._id];
+                return true;
+            }
+            return false;
+        };
+        WeakMap.prototype.has = function (key) {
+            return !!this._guard(key)[this._id];
+        };
+        WeakMap.prototype._guard = function (key) {
+            if (key !== Object(key)) {
+                throw TypeError('Value of WeakMap is not a non-null object.');
+            }
+            return key;
+        };
+        return WeakMap;
+    }());
+
+    /**
+     * Triangle shape
+     * @inner
+     */
+
+    var Triangle = Path.extend({
+      type: 'triangle',
+      shape: {
+        cx: 0,
+        cy: 0,
+        width: 0,
+        height: 0
+      },
+      buildPath: function (path, shape) {
+        var cx = shape.cx;
+        var cy = shape.cy;
+        var width = shape.width / 2;
+        var height = shape.height / 2;
+        path.moveTo(cx, cy - height);
+        path.lineTo(cx + width, cy + height);
+        path.lineTo(cx - width, cy + height);
+        path.closePath();
+      }
+    });
+    /**
+     * Diamond shape
+     * @inner
+     */
+
+    var Diamond = Path.extend({
+      type: 'diamond',
+      shape: {
+        cx: 0,
+        cy: 0,
+        width: 0,
+        height: 0
+      },
+      buildPath: function (path, shape) {
+        var cx = shape.cx;
+        var cy = shape.cy;
+        var width = shape.width / 2;
+        var height = shape.height / 2;
+        path.moveTo(cx, cy - height);
+        path.lineTo(cx + width, cy);
+        path.lineTo(cx, cy + height);
+        path.lineTo(cx - width, cy);
+        path.closePath();
+      }
+    });
+    /**
+     * Pin shape
+     * @inner
+     */
+
+    var Pin = Path.extend({
+      type: 'pin',
+      shape: {
+        // x, y on the cusp
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      },
+      buildPath: function (path, shape) {
+        var x = shape.x;
+        var y = shape.y;
+        var w = shape.width / 5 * 3; // Height must be larger than width
+
+        var h = Math.max(w, shape.height);
+        var r = w / 2; // Dist on y with tangent point and circle center
+
+        var dy = r * r / (h - r);
+        var cy = y - h + r + dy;
+        var angle = Math.asin(dy / r); // Dist on x with tangent point and circle center
+
+        var dx = Math.cos(angle) * r;
+        var tanX = Math.sin(angle);
+        var tanY = Math.cos(angle);
+        var cpLen = r * 0.6;
+        var cpLen2 = r * 0.7;
+        path.moveTo(x - dx, cy + dy);
+        path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);
+        path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y);
+        path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy);
+        path.closePath();
+      }
+    });
+    /**
+     * Arrow shape
+     * @inner
+     */
+
+    var Arrow = Path.extend({
+      type: 'arrow',
+      shape: {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      },
+      buildPath: function (ctx, shape) {
+        var height = shape.height;
+        var width = shape.width;
+        var x = shape.x;
+        var y = shape.y;
+        var dx = width / 3 * 2;
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + dx, y + height);
+        ctx.lineTo(x, y + height / 4 * 3);
+        ctx.lineTo(x - dx, y + height);
+        ctx.lineTo(x, y);
+        ctx.closePath();
+      }
+    });
+    /**
+     * Map of path contructors
+     */
+    // TODO Use function to build symbol path.
+
+    var symbolCtors = {
+      // Use small height rect to simulate line.
+      // Avoid using stroke.
+      line: Rect,
+      rect: Rect,
+      roundRect: Rect,
+      square: Rect,
+      circle: Circle,
+      diamond: Diamond,
+      pin: Pin,
+      arrow: Arrow,
+      triangle: Triangle
+    }; // NOTICE Only use fill. No line!
+
+    var symbolShapeMakers = {
+      line: function (x, y, w, h, shape) {
+        var thickness = 2; // A thin line
+
+        shape.x = x;
+        shape.y = y + h / 2 - thickness / 2;
+        shape.width = w;
+        shape.height = thickness;
+      },
+      rect: function (x, y, w, h, shape) {
+        shape.x = x;
+        shape.y = y;
+        shape.width = w;
+        shape.height = h;
+      },
+      roundRect: function (x, y, w, h, shape) {
+        shape.x = x;
+        shape.y = y;
+        shape.width = w;
+        shape.height = h;
+        shape.r = Math.min(w, h) / 4;
+      },
+      square: function (x, y, w, h, shape) {
+        var size = Math.min(w, h);
+        shape.x = x;
+        shape.y = y;
+        shape.width = size;
+        shape.height = size;
+      },
+      circle: function (x, y, w, h, shape) {
+        // Put circle in the center of square
+        shape.cx = x + w / 2;
+        shape.cy = y + h / 2;
+        shape.r = Math.min(w, h) / 2;
+      },
+      diamond: function (x, y, w, h, shape) {
+        shape.cx = x + w / 2;
+        shape.cy = y + h / 2;
+        shape.width = w;
+        shape.height = h;
+      },
+      pin: function (x, y, w, h, shape) {
+        shape.x = x + w / 2;
+        shape.y = y + h / 2;
+        shape.width = w;
+        shape.height = h;
+      },
+      arrow: function (x, y, w, h, shape) {
+        shape.x = x + w / 2;
+        shape.y = y + h / 2;
+        shape.width = w;
+        shape.height = h;
+      },
+      triangle: function (x, y, w, h, shape) {
+        shape.cx = x + w / 2;
+        shape.cy = y + h / 2;
+        shape.width = w;
+        shape.height = h;
+      }
+    };
+    var symbolBuildProxies = {};
+    each(symbolCtors, function (Ctor, name) {
+      symbolBuildProxies[name] = new Ctor();
+    });
+    var SymbolClz = Path.extend({
+      type: 'symbol',
+      shape: {
+        symbolType: '',
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      },
+      calculateTextPosition: function (out, config, rect) {
+        var res = calculateTextPosition(out, config, rect);
+        var shape = this.shape;
+
+        if (shape && shape.symbolType === 'pin' && config.position === 'inside') {
+          res.y = rect.y + rect.height * 0.4;
+        }
+
+        return res;
+      },
+      buildPath: function (ctx, shape, inBundle) {
+        var symbolType = shape.symbolType;
+
+        if (symbolType !== 'none') {
+          var proxySymbol = symbolBuildProxies[symbolType];
+
+          if (!proxySymbol) {
+            // Default rect
+            symbolType = 'rect';
+            proxySymbol = symbolBuildProxies[symbolType];
+          }
+
+          symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape);
+          proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);
+        }
+      }
+    }); // Provide setColor helper method to avoid determine if set the fill or stroke outside
+
+    function symbolPathSetColor(color, innerColor) {
+      if (this.type !== 'image') {
+        var symbolStyle = this.style;
+
+        if (this.__isEmptyBrush) {
+          symbolStyle.stroke = color;
+          symbolStyle.fill = innerColor || '#fff'; // TODO Same width with lineStyle in LineView.
+
+          symbolStyle.lineWidth = 2;
+        } else {
+          symbolStyle.fill = color;
+        }
+
+        this.markRedraw();
+      }
+    }
+    /**
+     * Create a symbol element with given symbol configuration: shape, x, y, width, height, color
+     */
+
+
+    function createSymbol(symbolType, x, y, w, h, color, // whether to keep the ratio of w/h,
+    keepAspect) {
+      // TODO Support image object, DynamicImage.
+      var isEmpty = symbolType.indexOf('empty') === 0;
+
+      if (isEmpty) {
+        symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);
+      }
+
+      var symbolPath;
+
+      if (symbolType.indexOf('image://') === 0) {
+        symbolPath = makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');
+      } else if (symbolType.indexOf('path://') === 0) {
+        symbolPath = makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');
+      } else {
+        symbolPath = new SymbolClz({
+          shape: {
+            symbolType: symbolType,
+            x: x,
+            y: y,
+            width: w,
+            height: h
+          }
+        });
+      }
+
+      symbolPath.__isEmptyBrush = isEmpty; // TODO Should deprecate setColor
+
+      symbolPath.setColor = symbolPathSetColor;
+
+      if (color) {
+        symbolPath.setColor(color);
+      }
+
+      return symbolPath;
+    }
+
+    function createLinearGradient(ctx, obj, rect) {
+        var x = obj.x == null ? 0 : obj.x;
+        var x2 = obj.x2 == null ? 1 : obj.x2;
+        var y = obj.y == null ? 0 : obj.y;
+        var y2 = obj.y2 == null ? 0 : obj.y2;
+        if (!obj.global) {
+            x = x * rect.width + rect.x;
+            x2 = x2 * rect.width + rect.x;
+            y = y * rect.height + rect.y;
+            y2 = y2 * rect.height + rect.y;
+        }
+        x = isNaN(x) ? 0 : x;
+        x2 = isNaN(x2) ? 1 : x2;
+        y = isNaN(y) ? 0 : y;
+        y2 = isNaN(y2) ? 0 : y2;
+        var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);
+        return canvasGradient;
+    }
+    function createRadialGradient(ctx, obj, rect) {
+        var width = rect.width;
+        var height = rect.height;
+        var min = Math.min(width, height);
+        var x = obj.x == null ? 0.5 : obj.x;
+        var y = obj.y == null ? 0.5 : obj.y;
+        var r = obj.r == null ? 0.5 : obj.r;
+        if (!obj.global) {
+            x = x * width + rect.x;
+            y = y * height + rect.y;
+            r = r * min;
+        }
+        var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);
+        return canvasGradient;
+    }
+    function getCanvasGradient(ctx, obj, rect) {
+        var canvasGradient = obj.type === 'radial'
+            ? createRadialGradient(ctx, obj, rect)
+            : createLinearGradient(ctx, obj, rect);
+        var colorStops = obj.colorStops;
+        for (var i = 0; i < colorStops.length; i++) {
+            canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);
+        }
+        return canvasGradient;
+    }
+    function isClipPathChanged(clipPaths, prevClipPaths) {
+        if (clipPaths === prevClipPaths || (!clipPaths && !prevClipPaths)) {
+            return false;
+        }
+        if (!clipPaths || !prevClipPaths || (clipPaths.length !== prevClipPaths.length)) {
+            return true;
+        }
+        for (var i = 0; i < clipPaths.length; i++) {
+            if (clipPaths[i] !== prevClipPaths[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function normalizeLineDash(lineType, lineWidth) {
+        if (!lineType || lineType === 'solid' || !(lineWidth > 0)) {
+            return null;
+        }
+        lineWidth = lineWidth || 1;
+        return lineType === 'dashed'
+            ? [4 * lineWidth, 2 * lineWidth]
+            : lineType === 'dotted'
+                ? [lineWidth]
+                : isNumber(lineType)
+                    ? [lineType] : isArray(lineType) ? lineType : null;
+    }
+
+    var pathProxyForDraw = new PathProxy(true);
+    function styleHasStroke(style) {
+        var stroke = style.stroke;
+        return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0));
+    }
+    function styleHasFill(style) {
+        var fill = style.fill;
+        return fill != null && fill !== 'none';
+    }
+    function doFillPath(ctx, style) {
+        if (style.fillOpacity != null && style.fillOpacity !== 1) {
+            var originalGlobalAlpha = ctx.globalAlpha;
+            ctx.globalAlpha = style.fillOpacity * style.opacity;
+            ctx.fill();
+            ctx.globalAlpha = originalGlobalAlpha;
+        }
+        else {
+            ctx.fill();
+        }
+    }
+    function doStrokePath(ctx, style) {
+        if (style.strokeOpacity != null && style.strokeOpacity !== 1) {
+            var originalGlobalAlpha = ctx.globalAlpha;
+            ctx.globalAlpha = style.strokeOpacity * style.opacity;
+            ctx.stroke();
+            ctx.globalAlpha = originalGlobalAlpha;
+        }
+        else {
+            ctx.stroke();
+        }
+    }
+    function createCanvasPattern(ctx, pattern, el) {
+        var image = createOrUpdateImage(pattern.image, pattern.__image, el);
+        if (isImageReady(image)) {
+            var canvasPattern = ctx.createPattern(image, pattern.repeat || 'repeat');
+            if (typeof DOMMatrix === 'function') {
+                var matrix = new DOMMatrix();
+                matrix.rotateSelf(0, 0, (pattern.rotation || 0) / Math.PI * 180);
+                matrix.scaleSelf((pattern.scaleX || 1), (pattern.scaleY || 1));
+                matrix.translateSelf((pattern.x || 0), (pattern.y || 0));
+                canvasPattern.setTransform(matrix);
+            }
+            return canvasPattern;
+        }
+    }
+    function brushPath(ctx, el, style, inBatch) {
+        var hasStroke = styleHasStroke(style);
+        var hasFill = styleHasFill(style);
+        var strokePercent = style.strokePercent;
+        var strokePart = strokePercent < 1;
+        var firstDraw = !el.path;
+        if ((!el.silent || strokePart) && firstDraw) {
+            el.createPathProxy();
+        }
+        var path = el.path || pathProxyForDraw;
+        if (!inBatch) {
+            var fill = style.fill;
+            var stroke = style.stroke;
+            var hasFillGradient = hasFill && !!fill.colorStops;
+            var hasStrokeGradient = hasStroke && !!stroke.colorStops;
+            var hasFillPattern = hasFill && !!fill.image;
+            var hasStrokePattern = hasStroke && !!stroke.image;
+            var fillGradient = void 0;
+            var strokeGradient = void 0;
+            var fillPattern = void 0;
+            var strokePattern = void 0;
+            var rect = void 0;
+            if (hasFillGradient || hasStrokeGradient) {
+                rect = el.getBoundingRect();
+            }
+            if (hasFillGradient) {
+                fillGradient = el.__dirty
+                    ? getCanvasGradient(ctx, fill, rect)
+                    : el.__canvasFillGradient;
+                el.__canvasFillGradient = fillGradient;
+            }
+            if (hasStrokeGradient) {
+                strokeGradient = el.__dirty
+                    ? getCanvasGradient(ctx, stroke, rect)
+                    : el.__canvasStrokeGradient;
+                el.__canvasStrokeGradient = strokeGradient;
+            }
+            if (hasFillPattern) {
+                fillPattern = (el.__dirty || !el.__canvasFillPattern)
+                    ? createCanvasPattern(ctx, fill, el)
+                    : el.__canvasFillPattern;
+                el.__canvasFillPattern = fillPattern;
+            }
+            if (hasStrokePattern) {
+                strokePattern = (el.__dirty || !el.__canvasStrokePattern)
+                    ? createCanvasPattern(ctx, stroke, el)
+                    : el.__canvasStrokePattern;
+                el.__canvasStrokePattern = fillPattern;
+            }
+            if (hasFillGradient) {
+                ctx.fillStyle = fillGradient;
+            }
+            else if (hasFillPattern) {
+                if (fillPattern) {
+                    ctx.fillStyle = fillPattern;
+                }
+                else {
+                    hasFill = false;
+                }
+            }
+            if (hasStrokeGradient) {
+                ctx.strokeStyle = strokeGradient;
+            }
+            else if (hasStrokePattern) {
+                if (strokePattern) {
+                    ctx.strokeStyle = strokePattern;
+                }
+                else {
+                    hasStroke = false;
+                }
+            }
+        }
+        var lineDash = style.lineDash && style.lineWidth > 0 && normalizeLineDash(style.lineDash, style.lineWidth);
+        var lineDashOffset = style.lineDashOffset;
+        var ctxLineDash = !!ctx.setLineDash;
+        var scale = el.getGlobalScale();
+        path.setScale(scale[0], scale[1], el.segmentIgnoreThreshold);
+        if (lineDash) {
+            var lineScale_1 = (style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1;
+            if (lineScale_1 && lineScale_1 !== 1) {
+                lineDash = map(lineDash, function (rawVal) {
+                    return rawVal / lineScale_1;
+                });
+                lineDashOffset /= lineScale_1;
+            }
+        }
+        var needsRebuild = true;
+        if (firstDraw || (el.__dirty & Path.SHAPE_CHANGED_BIT)
+            || (lineDash && !ctxLineDash && hasStroke)) {
+            path.setDPR(ctx.dpr);
+            if (strokePart) {
+                path.setContext(null);
+            }
+            else {
+                path.setContext(ctx);
+                needsRebuild = false;
+            }
+            path.reset();
+            if (lineDash && !ctxLineDash) {
+                path.setLineDash(lineDash);
+                path.setLineDashOffset(lineDashOffset);
+            }
+            el.buildPath(path, el.shape, inBatch);
+            path.toStatic();
+            el.pathUpdated();
+        }
+        if (needsRebuild) {
+            path.rebuildPath(ctx, strokePart ? strokePercent : 1);
+        }
+        if (lineDash && ctxLineDash) {
+            ctx.setLineDash(lineDash);
+            ctx.lineDashOffset = lineDashOffset;
+        }
+        if (!inBatch) {
+            if (style.strokeFirst) {
+                if (hasStroke) {
+                    doStrokePath(ctx, style);
+                }
+                if (hasFill) {
+                    doFillPath(ctx, style);
+                }
+            }
+            else {
+                if (hasFill) {
+                    doFillPath(ctx, style);
+                }
+                if (hasStroke) {
+                    doStrokePath(ctx, style);
+                }
+            }
+        }
+        if (lineDash && ctxLineDash) {
+            ctx.setLineDash([]);
+        }
+    }
+    function brushImage(ctx, el, style) {
+        var image = el.__image = createOrUpdateImage(style.image, el.__image, el, el.onload);
+        if (!image || !isImageReady(image)) {
+            return;
+        }
+        var x = style.x || 0;
+        var y = style.y || 0;
+        var width = el.getWidth();
+        var height = el.getHeight();
+        var aspect = image.width / image.height;
+        if (width == null && height != null) {
+            width = height * aspect;
+        }
+        else if (height == null && width != null) {
+            height = width / aspect;
+        }
+        else if (width == null && height == null) {
+            width = image.width;
+            height = image.height;
+        }
+        if (style.sWidth && style.sHeight) {
+            var sx = style.sx || 0;
+            var sy = style.sy || 0;
+            ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);
+        }
+        else if (style.sx && style.sy) {
+            var sx = style.sx;
+            var sy = style.sy;
+            var sWidth = width - sx;
+            var sHeight = height - sy;
+            ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);
+        }
+        else {
+            ctx.drawImage(image, x, y, width, height);
+        }
+    }
+    function brushText(ctx, el, style) {
+        var text = style.text;
+        text != null && (text += '');
+        if (text) {
+            ctx.font = style.font || DEFAULT_FONT;
+            ctx.textAlign = style.textAlign;
+            ctx.textBaseline = style.textBaseline;
+            var hasLineDash = void 0;
+            if (ctx.setLineDash) {
+                var lineDash = style.lineDash && style.lineWidth > 0 && normalizeLineDash(style.lineDash, style.lineWidth);
+                var lineDashOffset = style.lineDashOffset;
+                if (lineDash) {
+                    var lineScale_2 = (style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1;
+                    if (lineScale_2 && lineScale_2 !== 1) {
+                        lineDash = map(lineDash, function (rawVal) {
+                            return rawVal / lineScale_2;
+                        });
+                        lineDashOffset /= lineScale_2;
+                    }
+                    ctx.setLineDash(lineDash);
+                    ctx.lineDashOffset = lineDashOffset;
+                    hasLineDash = true;
+                }
+            }
+            if (style.strokeFirst) {
+                if (styleHasStroke(style)) {
+                    ctx.strokeText(text, style.x, style.y);
+                }
+                if (styleHasFill(style)) {
+                    ctx.fillText(text, style.x, style.y);
+                }
+            }
+            else {
+                if (styleHasFill(style)) {
+                    ctx.fillText(text, style.x, style.y);
+                }
+                if (styleHasStroke(style)) {
+                    ctx.strokeText(text, style.x, style.y);
+                }
+            }
+            if (hasLineDash) {
+                ctx.setLineDash([]);
+            }
+        }
+    }
+    var SHADOW_NUMBER_PROPS = ['shadowBlur', 'shadowOffsetX', 'shadowOffsetY'];
+    var STROKE_PROPS = [
+        ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10]
+    ];
+    function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
+        var styleChanged = false;
+        if (!forceSetAll) {
+            prevStyle = prevStyle || {};
+            if (style === prevStyle) {
+                return false;
+            }
+        }
+        if (forceSetAll || style.opacity !== prevStyle.opacity) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.globalAlpha = style.opacity == null ? DEFAULT_COMMON_STYLE.opacity : style.opacity;
+        }
+        if (forceSetAll || style.blend !== prevStyle.blend) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend;
+        }
+        for (var i = 0; i < SHADOW_NUMBER_PROPS.length; i++) {
+            var propName = SHADOW_NUMBER_PROPS[i];
+            if (forceSetAll || style[propName] !== prevStyle[propName]) {
+                if (!styleChanged) {
+                    flushPathDrawn(ctx, scope);
+                    styleChanged = true;
+                }
+                ctx[propName] = ctx.dpr * (style[propName] || 0);
+            }
+        }
+        if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor;
+        }
+        return styleChanged;
+    }
+    function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
+        var style = getStyle(el, scope.inHover);
+        var prevStyle = forceSetAll
+            ? null
+            : (prevEl && getStyle(prevEl, scope.inHover) || {});
+        if (style === prevStyle) {
+            return false;
+        }
+        var styleChanged = bindCommonProps(ctx, style, prevStyle, forceSetAll, scope);
+        if (forceSetAll || style.fill !== prevStyle.fill) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.fillStyle = style.fill;
+        }
+        if (forceSetAll || style.stroke !== prevStyle.stroke) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.strokeStyle = style.stroke;
+        }
+        if (forceSetAll || style.opacity !== prevStyle.opacity) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;
+        }
+        if (el.hasStroke()) {
+            var lineWidth = style.lineWidth;
+            var newLineWidth = lineWidth / ((style.strokeNoScale && el && el.getLineScale) ? el.getLineScale() : 1);
+            if (ctx.lineWidth !== newLineWidth) {
+                if (!styleChanged) {
+                    flushPathDrawn(ctx, scope);
+                    styleChanged = true;
+                }
+                ctx.lineWidth = newLineWidth;
+            }
+        }
+        for (var i = 0; i < STROKE_PROPS.length; i++) {
+            var prop = STROKE_PROPS[i];
+            var propName = prop[0];
+            if (forceSetAll || style[propName] !== prevStyle[propName]) {
+                if (!styleChanged) {
+                    flushPathDrawn(ctx, scope);
+                    styleChanged = true;
+                }
+                ctx[propName] = style[propName] || prop[1];
+            }
+        }
+        return styleChanged;
+    }
+    function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) {
+        return bindCommonProps(ctx, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope);
+    }
+    function setContextTransform(ctx, el) {
+        var m = el.transform;
+        var dpr = ctx.dpr || 1;
+        if (m) {
+            ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);
+        }
+        else {
+            ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+        }
+    }
+    function updateClipStatus(clipPaths, ctx, scope) {
+        var allClipped = false;
+        for (var i = 0; i < clipPaths.length; i++) {
+            var clipPath = clipPaths[i];
+            allClipped = allClipped || clipPath.isZeroArea();
+            setContextTransform(ctx, clipPath);
+            ctx.beginPath();
+            clipPath.buildPath(ctx, clipPath.shape);
+            ctx.clip();
+        }
+        scope.allClipped = allClipped;
+    }
+    function isTransformChanged(m0, m1) {
+        if (m0 && m1) {
+            return m0[0] !== m1[0]
+                || m0[1] !== m1[1]
+                || m0[2] !== m1[2]
+                || m0[3] !== m1[3]
+                || m0[4] !== m1[4]
+                || m0[5] !== m1[5];
+        }
+        else if (!m0 && !m1) {
+            return false;
+        }
+        return true;
+    }
+    var DRAW_TYPE_PATH = 1;
+    var DRAW_TYPE_IMAGE = 2;
+    var DRAW_TYPE_TEXT = 3;
+    var DRAW_TYPE_INCREMENTAL = 4;
+    function canPathBatch(style) {
+        var hasFill = styleHasFill(style);
+        var hasStroke = styleHasStroke(style);
+        return !(style.lineDash
+            || !(+hasFill ^ +hasStroke)
+            || (hasFill && typeof style.fill !== 'string')
+            || (hasStroke && typeof style.stroke !== 'string')
+            || style.strokePercent < 1
+            || style.strokeOpacity < 1
+            || style.fillOpacity < 1);
+    }
+    function flushPathDrawn(ctx, scope) {
+        scope.batchFill && ctx.fill();
+        scope.batchStroke && ctx.stroke();
+        scope.batchFill = '';
+        scope.batchStroke = '';
+    }
+    function getStyle(el, inHover) {
+        return inHover ? (el.__hoverStyle || el.style) : el.style;
+    }
+    function brushSingle(ctx, el) {
+        brush(ctx, el, { inHover: false, viewWidth: 0, viewHeight: 0 }, true);
+    }
+    function brush(ctx, el, scope, isLast) {
+        var m = el.transform;
+        if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) {
+            el.__dirty &= ~Element.REDARAW_BIT;
+            el.__isRendered = false;
+            return;
+        }
+        var clipPaths = el.__clipPaths;
+        var prevElClipPaths = scope.prevElClipPaths;
+        var forceSetTransform = false;
+        var forceSetStyle = false;
+        if (!prevElClipPaths || isClipPathChanged(clipPaths, prevElClipPaths)) {
+            if (prevElClipPaths && prevElClipPaths.length) {
+                flushPathDrawn(ctx, scope);
+                ctx.restore();
+                forceSetStyle = forceSetTransform = true;
+                scope.prevElClipPaths = null;
+                scope.allClipped = false;
+                scope.prevEl = null;
+            }
+            if (clipPaths && clipPaths.length) {
+                flushPathDrawn(ctx, scope);
+                ctx.save();
+                updateClipStatus(clipPaths, ctx, scope);
+                forceSetTransform = true;
+            }
+            scope.prevElClipPaths = clipPaths;
+        }
+        if (scope.allClipped) {
+            el.__isRendered = false;
+            return;
+        }
+        el.beforeBrush && el.beforeBrush();
+        el.innerBeforeBrush();
+        var prevEl = scope.prevEl;
+        if (!prevEl) {
+            forceSetStyle = forceSetTransform = true;
+        }
+        var canBatchPath = el instanceof Path
+            && el.autoBatch
+            && canPathBatch(el.style);
+        if (forceSetTransform || isTransformChanged(m, prevEl.transform)) {
+            flushPathDrawn(ctx, scope);
+            setContextTransform(ctx, el);
+        }
+        else if (!canBatchPath) {
+            flushPathDrawn(ctx, scope);
+        }
+        var style = getStyle(el, scope.inHover);
+        if (el instanceof Path) {
+            if (scope.lastDrawType !== DRAW_TYPE_PATH) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_PATH;
+            }
+            bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+            if (!canBatchPath || (!scope.batchFill && !scope.batchStroke)) {
+                ctx.beginPath();
+            }
+            brushPath(ctx, el, style, canBatchPath);
+            if (canBatchPath) {
+                scope.batchFill = style.fill || '';
+                scope.batchStroke = style.stroke || '';
+            }
+        }
+        else {
+            if (el instanceof TSpan) {
+                if (scope.lastDrawType !== DRAW_TYPE_TEXT) {
+                    forceSetStyle = true;
+                    scope.lastDrawType = DRAW_TYPE_TEXT;
+                }
+                bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+                brushText(ctx, el, style);
+            }
+            else if (el instanceof ZRImage) {
+                if (scope.lastDrawType !== DRAW_TYPE_IMAGE) {
+                    forceSetStyle = true;
+                    scope.lastDrawType = DRAW_TYPE_IMAGE;
+                }
+                bindImageStyle(ctx, el, prevEl, forceSetStyle, scope);
+                brushImage(ctx, el, style);
+            }
+            else if (el instanceof IncrementalDisplayable) {
+                if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) {
+                    forceSetStyle = true;
+                    scope.lastDrawType = DRAW_TYPE_INCREMENTAL;
+                }
+                brushIncremental(ctx, el, scope);
+            }
+        }
+        if (canBatchPath && isLast) {
+            flushPathDrawn(ctx, scope);
+        }
+        el.innerAfterBrush();
+        el.afterBrush && el.afterBrush();
+        scope.prevEl = el;
+        el.__dirty = 0;
+        el.__isRendered = true;
+    }
+    function brushIncremental(ctx, el, scope) {
+        var displayables = el.getDisplayables();
+        var temporalDisplayables = el.getTemporalDisplayables();
+        ctx.save();
+        var innerScope = {
+            prevElClipPaths: null,
+            prevEl: null,
+            allClipped: false,
+            viewWidth: scope.viewWidth,
+            viewHeight: scope.viewHeight,
+            inHover: scope.inHover
+        };
+        var i;
+        var len;
+        for (i = el.getCursor(), len = displayables.length; i < len; i++) {
+            var displayable = displayables[i];
+            displayable.beforeBrush && displayable.beforeBrush();
+            displayable.innerBeforeBrush();
+            brush(ctx, displayable, innerScope, i === len - 1);
+            displayable.innerAfterBrush();
+            displayable.afterBrush && displayable.afterBrush();
+            innerScope.prevEl = displayable;
+        }
+        for (var i_1 = 0, len_1 = temporalDisplayables.length; i_1 < len_1; i_1++) {
+            var displayable = temporalDisplayables[i_1];
+            displayable.beforeBrush && displayable.beforeBrush();
+            displayable.innerBeforeBrush();
+            brush(ctx, displayable, innerScope, i_1 === len_1 - 1);
+            displayable.innerAfterBrush();
+            displayable.afterBrush && displayable.afterBrush();
+            innerScope.prevEl = displayable;
+        }
+        el.clearTemporalDisplayables();
+        el.notClear = true;
+        ctx.restore();
+    }
+
+    var decalMap = new WeakMap();
+    var decalCache = new LRU(100);
+    var decalKeys = ['symbol', 'symbolSize', 'symbolKeepAspect', 'color', 'backgroundColor', 'dashArrayX', 'dashArrayY', 'maxTileWidth', 'maxTileHeight'];
+    /**
+     * Create or update pattern image from decal options
+     *
+     * @param {InnerDecalObject | 'none'} decalObject decal options, 'none' if no decal
+     * @return {Pattern} pattern with generated image, null if no decal
+     */
+
+    function createOrUpdatePatternFromDecal(decalObject, api) {
+      if (decalObject === 'none') {
+        return null;
+      }
+
+      var dpr = api.getDevicePixelRatio();
+      var zr = api.getZr();
+      var isSVG = zr.painter.type === 'svg';
+
+      if (decalObject.dirty) {
+        decalMap["delete"](decalObject);
+      }
+
+      var oldPattern = decalMap.get(decalObject);
+
+      if (oldPattern) {
+        return oldPattern;
+      }
+
+      var decalOpt = defaults(decalObject, {
+        symbol: 'rect',
+        symbolSize: 1,
+        symbolKeepAspect: true,
+        color: 'rgba(0, 0, 0, 0.2)',
+        backgroundColor: null,
+        dashArrayX: 5,
+        dashArrayY: 5,
+        rotation: 0,
+        maxTileWidth: 512,
+        maxTileHeight: 512
+      });
+
+      if (decalOpt.backgroundColor === 'none') {
+        decalOpt.backgroundColor = null;
+      }
+
+      var pattern = {
+        repeat: 'repeat'
+      };
+      setPatternnSource(pattern);
+      pattern.rotation = decalOpt.rotation;
+      pattern.scaleX = pattern.scaleY = isSVG ? 1 : 1 / dpr;
+      decalMap.set(decalObject, pattern);
+      decalObject.dirty = false;
+      return pattern;
+
+      function setPatternnSource(pattern) {
+        var keys = [dpr];
+        var isValidKey = true;
+
+        for (var i = 0; i < decalKeys.length; ++i) {
+          var value = decalOpt[decalKeys[i]];
+          var valueType = typeof value;
+
+          if (value != null && !isArray(value) && valueType !== 'string' && valueType !== 'number' && valueType !== 'boolean') {
+            isValidKey = false;
+            break;
+          }
+
+          keys.push(value);
+        }
+
+        var cacheKey;
+
+        if (isValidKey) {
+          cacheKey = keys.join(',') + (isSVG ? '-svg' : '');
+          var cache = decalCache.get(cacheKey);
+
+          if (cache) {
+            isSVG ? pattern.svgElement = cache : pattern.image = cache;
+          }
+        }
+
+        var dashArrayX = normalizeDashArrayX(decalOpt.dashArrayX);
+        var dashArrayY = normalizeDashArrayY(decalOpt.dashArrayY);
+        var symbolArray = normalizeSymbolArray(decalOpt.symbol);
+        var lineBlockLengthsX = getLineBlockLengthX(dashArrayX);
+        var lineBlockLengthY = getLineBlockLengthY(dashArrayY);
+        var canvas = !isSVG && createCanvas();
+        var svgRoot = isSVG && zr.painter.createSVGElement('g');
+        var pSize = getPatternSize();
+        var ctx;
+
+        if (canvas) {
+          canvas.width = pSize.width * dpr;
+          canvas.height = pSize.height * dpr;
+          ctx = canvas.getContext('2d');
+        }
+
+        brushDecal();
+
+        if (isValidKey) {
+          decalCache.put(cacheKey, canvas || svgRoot);
+        }
+
+        pattern.image = canvas;
+        pattern.svgElement = svgRoot;
+        pattern.svgWidth = pSize.width;
+        pattern.svgHeight = pSize.height;
+        /**
+         * Get minumum length that can make a repeatable pattern.
+         *
+         * @return {Object} pattern width and height
+         */
+
+        function getPatternSize() {
+          /**
+           * For example, if dash is [[3, 2], [2, 1]] for X, it looks like
+           * |---  ---  ---  ---  --- ...
+           * |-- -- -- -- -- -- -- -- ...
+           * |---  ---  ---  ---  --- ...
+           * |-- -- -- -- -- -- -- -- ...
+           * So the minumum length of X is 15,
+           * which is the least common multiple of `3 + 2` and `2 + 1`
+           * |---  ---  ---  |---  --- ...
+           * |-- -- -- -- -- |-- -- -- ...
+           */
+          var width = 1;
+
+          for (var i = 0, xlen = lineBlockLengthsX.length; i < xlen; ++i) {
+            width = getLeastCommonMultiple(width, lineBlockLengthsX[i]);
+          }
+
+          var symbolRepeats = 1;
+
+          for (var i = 0, xlen = symbolArray.length; i < xlen; ++i) {
+            symbolRepeats = getLeastCommonMultiple(symbolRepeats, symbolArray[i].length);
+          }
+
+          width *= symbolRepeats;
+          var height = lineBlockLengthY * lineBlockLengthsX.length * symbolArray.length;
+
+          if ("development" !== 'production') {
+            var warn = function (attrName) {
+              /* eslint-disable-next-line */
+              console.warn("Calculated decal size is greater than " + attrName + " due to decal option settings so " + attrName + " is used for the decal size. Please consider changing the decal option to make a smaller decal or set " + attrName + " to be larger to avoid incontinuity.");
+            };
+
+            if (width > decalOpt.maxTileWidth) {
+              warn('maxTileWidth');
+            }
+
+            if (height > decalOpt.maxTileHeight) {
+              warn('maxTileHeight');
+            }
+          }
+
+          return {
+            width: Math.max(1, Math.min(width, decalOpt.maxTileWidth)),
+            height: Math.max(1, Math.min(height, decalOpt.maxTileHeight))
+          };
+        }
+
+        function brushDecal() {
+          if (ctx) {
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+            if (decalOpt.backgroundColor) {
+              ctx.fillStyle = decalOpt.backgroundColor;
+              ctx.fillRect(0, 0, canvas.width, canvas.height);
+            }
+          }
+
+          var ySum = 0;
+
+          for (var i = 0; i < dashArrayY.length; ++i) {
+            ySum += dashArrayY[i];
+          }
+
+          if (ySum <= 0) {
+            // dashArrayY is 0, draw nothing
+            return;
+          }
+
+          var y = -lineBlockLengthY;
+          var yId = 0;
+          var yIdTotal = 0;
+          var xId0 = 0;
+
+          while (y < pSize.height) {
+            if (yId % 2 === 0) {
+              var symbolYId = yIdTotal / 2 % symbolArray.length;
+              var x = 0;
+              var xId1 = 0;
+              var xId1Total = 0;
+
+              while (x < pSize.width * 2) {
+                var xSum = 0;
+
+                for (var i = 0; i < dashArrayX[xId0].length; ++i) {
+                  xSum += dashArrayX[xId0][i];
+                }
+
+                if (xSum <= 0) {
+                  // Skip empty line
+                  break;
+                } // E.g., [15, 5, 20, 5] draws only for 15 and 20
+
+
+                if (xId1 % 2 === 0) {
+                  var size = (1 - decalOpt.symbolSize) * 0.5;
+                  var left = x + dashArrayX[xId0][xId1] * size;
+                  var top_1 = y + dashArrayY[yId] * size;
+                  var width = dashArrayX[xId0][xId1] * decalOpt.symbolSize;
+                  var height = dashArrayY[yId] * decalOpt.symbolSize;
+                  var symbolXId = xId1Total / 2 % symbolArray[symbolYId].length;
+                  brushSymbol(left, top_1, width, height, symbolArray[symbolYId][symbolXId]);
+                }
+
+                x += dashArrayX[xId0][xId1];
+                ++xId1Total;
+                ++xId1;
+
+                if (xId1 === dashArrayX[xId0].length) {
+                  xId1 = 0;
+                }
+              }
+
+              ++xId0;
+
+              if (xId0 === dashArrayX.length) {
+                xId0 = 0;
+              }
+            }
+
+            y += dashArrayY[yId];
+            ++yIdTotal;
+            ++yId;
+
+            if (yId === dashArrayY.length) {
+              yId = 0;
+            }
+          }
+
+          function brushSymbol(x, y, width, height, symbolType) {
+            var scale = isSVG ? 1 : dpr;
+            var symbol = createSymbol(symbolType, x * scale, y * scale, width * scale, height * scale, decalOpt.color, decalOpt.symbolKeepAspect);
+
+            if (isSVG) {
+              svgRoot.appendChild(zr.painter.paintOne(symbol));
+            } else {
+              // Paint to canvas for all other renderers.
+              brushSingle(ctx, symbol);
+            }
+          }
+        }
+      }
+    }
+    /**
+     * Convert symbol array into normalized array
+     *
+     * @param {string | (string | string[])[]} symbol symbol input
+     * @return {string[][]} normolized symbol array
+     */
+
+    function normalizeSymbolArray(symbol) {
+      if (!symbol || symbol.length === 0) {
+        return [['rect']];
+      }
+
+      if (typeof symbol === 'string') {
+        return [[symbol]];
+      }
+
+      var isAllString = true;
+
+      for (var i = 0; i < symbol.length; ++i) {
+        if (typeof symbol[i] !== 'string') {
+          isAllString = false;
+          break;
+        }
+      }
+
+      if (isAllString) {
+        return normalizeSymbolArray([symbol]);
+      }
+
+      var result = [];
+
+      for (var i = 0; i < symbol.length; ++i) {
+        if (typeof symbol[i] === 'string') {
+          result.push([symbol[i]]);
+        } else {
+          result.push(symbol[i]);
+        }
+      }
+
+      return result;
+    }
+    /**
+     * Convert dash input into dashArray
+     *
+     * @param {DecalDashArrayX} dash dash input
+     * @return {number[][]} normolized dash array
+     */
+
+
+    function normalizeDashArrayX(dash) {
+      if (!dash || dash.length === 0) {
+        return [[0, 0]];
+      }
+
+      if (typeof dash === 'number') {
+        var dashValue = Math.ceil(dash);
+        return [[dashValue, dashValue]];
+      }
+      /**
+       * [20, 5] should be normalized into [[20, 5]],
+       * while [20, [5, 10]] should be normalized into [[20, 20], [5, 10]]
+       */
+
+
+      var isAllNumber = true;
+
+      for (var i = 0; i < dash.length; ++i) {
+        if (typeof dash[i] !== 'number') {
+          isAllNumber = false;
+          break;
+        }
+      }
+
+      if (isAllNumber) {
+        return normalizeDashArrayX([dash]);
+      }
+
+      var result = [];
+
+      for (var i = 0; i < dash.length; ++i) {
+        if (typeof dash[i] === 'number') {
+          var dashValue = Math.ceil(dash[i]);
+          result.push([dashValue, dashValue]);
+        } else {
+          var dashValue = map(dash[i], function (n) {
+            return Math.ceil(n);
+          });
+
+          if (dashValue.length % 2 === 1) {
+            // [4, 2, 1] means |----  -    -- |----  -    -- |
+            // so normalize it to be [4, 2, 1, 4, 2, 1]
+            result.push(dashValue.concat(dashValue));
+          } else {
+            result.push(dashValue);
+          }
+        }
+      }
+
+      return result;
+    }
+    /**
+     * Convert dash input into dashArray
+     *
+     * @param {DecalDashArrayY} dash dash input
+     * @return {number[]} normolized dash array
+     */
+
+
+    function normalizeDashArrayY(dash) {
+      if (!dash || typeof dash === 'object' && dash.length === 0) {
+        return [0, 0];
+      }
+
+      if (typeof dash === 'number') {
+        var dashValue_1 = Math.ceil(dash);
+        return [dashValue_1, dashValue_1];
+      }
+
+      var dashValue = map(dash, function (n) {
+        return Math.ceil(n);
+      });
+      return dash.length % 2 ? dashValue.concat(dashValue) : dashValue;
+    }
+    /**
+     * Get block length of each line. A block is the length of dash line and space.
+     * For example, a line with [4, 1] has a dash line of 4 and a space of 1 after
+     * that, so the block length of this line is 5.
+     *
+     * @param {number[][]} dash dash arrary of X or Y
+     * @return {number[]} block length of each line
+     */
+
+
+    function getLineBlockLengthX(dash) {
+      return map(dash, function (line) {
+        return getLineBlockLengthY(line);
+      });
+    }
+
+    function getLineBlockLengthY(dash) {
+      var blockLength = 0;
+
+      for (var i = 0; i < dash.length; ++i) {
+        blockLength += dash[i];
+      }
+
+      if (dash.length % 2 === 1) {
+        // [4, 2, 1] means |----  -    -- |----  -    -- |
+        // So total length is (4 + 2 + 1) * 2
+        return blockLength * 2;
+      }
+
+      return blockLength;
+    }
+
+    function decalVisual(ecModel, api) {
+      ecModel.eachRawSeries(function (seriesModel) {
+        if (ecModel.isSeriesFiltered(seriesModel)) {
+          return;
+        }
+
+        var data = seriesModel.getData();
+
+        if (data.hasItemVisual()) {
+          data.each(function (idx) {
+            var decal = data.getItemVisual(idx, 'decal');
+
+            if (decal) {
+              var itemStyle = data.ensureUniqueItemVisual(idx, 'style');
+              itemStyle.decal = createOrUpdatePatternFromDecal(decal, api);
+            }
+          });
+        }
+
+        var decal = data.getVisual('decal');
+
+        if (decal) {
+          var style = data.getVisual('style');
+          style.decal = createOrUpdatePatternFromDecal(decal, api);
+        }
+      });
+    }
+
+    var assert$1 = assert;
+    var each$3 = each;
+    var isFunction$1 = isFunction;
+    var isObject$2 = isObject;
+    var indexOf$1 = indexOf;
+    var hasWindow = typeof window !== 'undefined';
+    var version$1 = '5.0.2';
+    var dependencies = {
+      zrender: '5.0.4'
+    };
+    var TEST_FRAME_REMAIN_TIME = 1;
+    var PRIORITY_PROCESSOR_SERIES_FILTER = 800; // Some data processors depends on the stack result dimension (to calculate data extent).
+    // So data stack stage should be in front of data processing stage.
+
+    var PRIORITY_PROCESSOR_DATASTACK = 900; // "Data filter" will block the stream, so it should be
+    // put at the begining of data processing.
+
+    var PRIORITY_PROCESSOR_FILTER = 1000;
+    var PRIORITY_PROCESSOR_DEFAULT = 2000;
+    var PRIORITY_PROCESSOR_STATISTIC = 5000;
+    var PRIORITY_VISUAL_LAYOUT = 1000;
+    var PRIORITY_VISUAL_PROGRESSIVE_LAYOUT = 1100;
+    var PRIORITY_VISUAL_GLOBAL = 2000;
+    var PRIORITY_VISUAL_CHART = 3000;
+    var PRIORITY_VISUAL_COMPONENT = 4000; // Visual property in data. Greater than `PRIORITY_VISUAL_COMPONENT` to enable to
+    // overwrite the viusal result of component (like `visualMap`)
+    // using data item specific setting (like itemStyle.xxx on data item)
+
+    var PRIORITY_VISUAL_CHART_DATA_CUSTOM = 4500; // Greater than `PRIORITY_VISUAL_CHART_DATA_CUSTOM` to enable to layout based on
+    // visual result like `symbolSize`.
+
+    var PRIORITY_VISUAL_POST_CHART_LAYOUT = 4600;
+    var PRIORITY_VISUAL_BRUSH = 5000;
+    var PRIORITY_VISUAL_ARIA = 6000;
+    var PRIORITY_VISUAL_DECAL = 7000;
+    var PRIORITY = {
+      PROCESSOR: {
+        FILTER: PRIORITY_PROCESSOR_FILTER,
+        SERIES_FILTER: PRIORITY_PROCESSOR_SERIES_FILTER,
+        STATISTIC: PRIORITY_PROCESSOR_STATISTIC
+      },
+      VISUAL: {
+        LAYOUT: PRIORITY_VISUAL_LAYOUT,
+        PROGRESSIVE_LAYOUT: PRIORITY_VISUAL_PROGRESSIVE_LAYOUT,
+        GLOBAL: PRIORITY_VISUAL_GLOBAL,
+        CHART: PRIORITY_VISUAL_CHART,
+        POST_CHART_LAYOUT: PRIORITY_VISUAL_POST_CHART_LAYOUT,
+        COMPONENT: PRIORITY_VISUAL_COMPONENT,
+        BRUSH: PRIORITY_VISUAL_BRUSH,
+        CHART_ITEM: PRIORITY_VISUAL_CHART_DATA_CUSTOM,
+        ARIA: PRIORITY_VISUAL_ARIA,
+        DECAL: PRIORITY_VISUAL_DECAL
+      }
+    }; // Main process have three entries: `setOption`, `dispatchAction` and `resize`,
+    // where they must not be invoked nestedly, except the only case: invoke
+    // dispatchAction with updateMethod "none" in main process.
+    // This flag is used to carry out this rule.
+    // All events will be triggered out side main process (i.e. when !this[IN_MAIN_PROCESS]).
+
+    var IN_MAIN_PROCESS_KEY = '__flagInMainProcess';
+    var OPTION_UPDATED_KEY = '__optionUpdated';
+    var STATUS_NEEDS_UPDATE_KEY = '__needsUpdateStatus';
+    var ACTION_REG = /^[a-zA-Z0-9_]+$/;
+    var CONNECT_STATUS_KEY = '__connectUpdateStatus';
+    var CONNECT_STATUS_PENDING = 0;
+    var CONNECT_STATUS_UPDATING = 1;
+    var CONNECT_STATUS_UPDATED = 2;
+
+    function createRegisterEventWithLowercaseECharts(method) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+
+        if (this.isDisposed()) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        return toLowercaseNameAndCallEventful(this, method, args);
+      };
+    }
+
+    function createRegisterEventWithLowercaseMessageCenter(method) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+
+        return toLowercaseNameAndCallEventful(this, method, args);
+      };
+    }
+
+    function toLowercaseNameAndCallEventful(host, method, args) {
+      // `args[0]` is event name. Event name is all lowercase.
+      args[0] = args[0] && args[0].toLowerCase();
+      return Eventful.prototype[method].apply(host, args);
+    }
+
+    var MessageCenter =
+    /** @class */
+    function (_super) {
+      __extends(MessageCenter, _super);
+
+      function MessageCenter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      return MessageCenter;
+    }(Eventful);
+
+    var messageCenterProto = MessageCenter.prototype;
+    messageCenterProto.on = createRegisterEventWithLowercaseMessageCenter('on');
+    messageCenterProto.off = createRegisterEventWithLowercaseMessageCenter('off'); // ---------------------------------------
+    // Internal method names for class ECharts
+    // ---------------------------------------
+
+    var prepare;
+    var prepareView;
+    var updateDirectly;
+    var updateMethods;
+    var doConvertPixel;
+    var updateStreamModes;
+    var doDispatchAction;
+    var flushPendingActions;
+    var triggerUpdatedEvent;
+    var bindRenderedEvent;
+    var bindMouseEvent;
+    var clearColorPalette;
+    var render;
+    var renderComponents;
+    var renderSeries;
+    var performPostUpdateFuncs;
+    var createExtensionAPI;
+    var enableConnect;
+    var setTransitionOpt;
+    var markStatusToUpdate;
+    var applyChangedStates;
+
+    var ECharts =
+    /** @class */
+    function (_super) {
+      __extends(ECharts, _super);
+
+      function ECharts(dom, // Theme name or themeOption.
+      theme, opts) {
+        var _this = _super.call(this, new ECEventProcessor()) || this;
+
+        _this._chartsViews = [];
+        _this._chartsMap = {};
+        _this._componentsViews = [];
+        _this._componentsMap = {}; // Can't dispatch action during rendering procedure
+
+        _this._pendingActions = [];
+        opts = opts || {}; // Get theme by name
+
+        if (typeof theme === 'string') {
+          theme = themeStorage[theme];
+        }
+
+        _this._dom = dom;
+        var defaultRenderer = 'canvas';
+        var defaultUseDirtyRect = false;
+
+        if ("development" !== 'production') {
+          var root =
+          /* eslint-disable-next-line */
+          hasWindow ? window : global;
+          defaultRenderer = root.__ECHARTS__DEFAULT__RENDERER__ || defaultRenderer;
+          var devUseDirtyRect = root.__ECHARTS__DEFAULT__USE_DIRTY_RECT__;
+          defaultUseDirtyRect = devUseDirtyRect == null ? defaultUseDirtyRect : devUseDirtyRect;
+        }
+
+        var zr = _this._zr = init(dom, {
+          renderer: opts.renderer || defaultRenderer,
+          devicePixelRatio: opts.devicePixelRatio,
+          width: opts.width,
+          height: opts.height,
+          useDirtyRect: opts.useDirtyRect == null ? defaultUseDirtyRect : opts.useDirtyRect
+        }); // Expect 60 fps.
+
+        _this._throttledZrFlush = throttle(bind(zr.flush, zr), 17);
+        theme = clone(theme);
+        theme && globalBackwardCompat(theme, true);
+        _this._theme = theme;
+        _this._locale = createLocaleObject(opts.locale || SYSTEM_LANG);
+        _this._coordSysMgr = new CoordinateSystemManager();
+        var api = _this._api = createExtensionAPI(_this); // Sort on demand
+
+        function prioritySortFunc(a, b) {
+          return a.__prio - b.__prio;
+        }
+
+        sort(visualFuncs, prioritySortFunc);
+        sort(dataProcessorFuncs, prioritySortFunc);
+        _this._scheduler = new Scheduler(_this, api, dataProcessorFuncs, visualFuncs);
+        _this._messageCenter = new MessageCenter();
+        _this._labelManager = new LabelManager(); // Init mouse events
+
+        _this._initEvents(); // In case some people write `window.onresize = chart.resize`
+
+
+        _this.resize = bind(_this.resize, _this);
+        zr.animation.on('frame', _this._onframe, _this);
+        bindRenderedEvent(zr, _this);
+        bindMouseEvent(zr, _this); // ECharts instance can be used as value.
+
+        setAsPrimitive(_this);
+        return _this;
+      }
+
+      ECharts.prototype._onframe = function () {
+        if (this._disposed) {
+          return;
+        }
+
+        applyChangedStates(this);
+        var scheduler = this._scheduler; // Lazy update
+
+        if (this[OPTION_UPDATED_KEY]) {
+          var silent = this[OPTION_UPDATED_KEY].silent;
+          this[IN_MAIN_PROCESS_KEY] = true;
+          prepare(this);
+          updateMethods.update.call(this); // At present, in each frame, zrender performs:
+          //   (1) animation step forward.
+          //   (2) trigger('frame') (where this `_onframe` is called)
+          //   (3) zrender flush (render).
+          // If we do nothing here, since we use `setToFinal: true`, the step (3) above
+          // will render the final state of the elements before the real animation started.
+
+          this._zr.flush();
+
+          this[IN_MAIN_PROCESS_KEY] = false;
+          this[OPTION_UPDATED_KEY] = false;
+          flushPendingActions.call(this, silent);
+          triggerUpdatedEvent.call(this, silent);
+        } // Avoid do both lazy update and progress in one frame.
+        else if (scheduler.unfinished) {
+            // Stream progress.
+            var remainTime = TEST_FRAME_REMAIN_TIME;
+            var ecModel = this._model;
+            var api = this._api;
+            scheduler.unfinished = false;
+
+            do {
+              var startTime = +new Date();
+              scheduler.performSeriesTasks(ecModel); // Currently dataProcessorFuncs do not check threshold.
+
+              scheduler.performDataProcessorTasks(ecModel);
+              updateStreamModes(this, ecModel); // Do not update coordinate system here. Because that coord system update in
+              // each frame is not a good user experience. So we follow the rule that
+              // the extent of the coordinate system is determin in the first frame (the
+              // frame is executed immedietely after task reset.
+              // this._coordSysMgr.update(ecModel, api);
+              // console.log('--- ec frame visual ---', remainTime);
+
+              scheduler.performVisualTasks(ecModel);
+              renderSeries(this, this._model, api, 'remain');
+              remainTime -= +new Date() - startTime;
+            } while (remainTime > 0 && scheduler.unfinished); // Call flush explicitly for trigger finished event.
+
+
+            if (!scheduler.unfinished) {
+              this._zr.flush();
+            } // Else, zr flushing be ensue within the same frame,
+            // because zr flushing is after onframe event.
+
+          }
+      };
+
+      ECharts.prototype.getDom = function () {
+        return this._dom;
+      };
+
+      ECharts.prototype.getId = function () {
+        return this.id;
+      };
+
+      ECharts.prototype.getZr = function () {
+        return this._zr;
+      };
+      /* eslint-disable-next-line */
+
+
+      ECharts.prototype.setOption = function (option, notMerge, lazyUpdate) {
+        if ("development" !== 'production') {
+          assert$1(!this[IN_MAIN_PROCESS_KEY], '`setOption` should not be called during main process.');
+        }
+
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        var silent;
+        var replaceMerge;
+        var transitionOpt;
+
+        if (isObject$2(notMerge)) {
+          lazyUpdate = notMerge.lazyUpdate;
+          silent = notMerge.silent;
+          replaceMerge = notMerge.replaceMerge;
+          transitionOpt = notMerge.transition;
+          notMerge = notMerge.notMerge;
+        }
+
+        this[IN_MAIN_PROCESS_KEY] = true;
+
+        if (!this._model || notMerge) {
+          var optionManager = new OptionManager(this._api);
+          var theme = this._theme;
+          var ecModel = this._model = new GlobalModel();
+          ecModel.scheduler = this._scheduler;
+          ecModel.init(null, null, null, theme, this._locale, optionManager);
+        }
+
+        this._model.setOption(option, {
+          replaceMerge: replaceMerge
+        }, optionPreprocessorFuncs);
+
+        setTransitionOpt(this, transitionOpt);
+
+        if (lazyUpdate) {
+          this[OPTION_UPDATED_KEY] = {
+            silent: silent
+          };
+          this[IN_MAIN_PROCESS_KEY] = false; // `setOption(option, {lazyMode: true})` may be called when zrender has been slept.
+          // It should wake it up to make sure zrender start to render at the next frame.
+
+          this.getZr().wakeUp();
+        } else {
+          prepare(this);
+          updateMethods.update.call(this); // Ensure zr refresh sychronously, and then pixel in canvas can be
+          // fetched after `setOption`.
+
+          this._zr.flush();
+
+          this[OPTION_UPDATED_KEY] = false;
+          this[IN_MAIN_PROCESS_KEY] = false;
+          flushPendingActions.call(this, silent);
+          triggerUpdatedEvent.call(this, silent);
+        }
+      };
+      /**
+       * @DEPRECATED
+       */
+
+
+      ECharts.prototype.setTheme = function () {
+        console.error('ECharts#setTheme() is DEPRECATED in ECharts 3.0');
+      }; // We don't want developers to use getModel directly.
+
+
+      ECharts.prototype.getModel = function () {
+        return this._model;
+      };
+
+      ECharts.prototype.getOption = function () {
+        return this._model && this._model.getOption();
+      };
+
+      ECharts.prototype.getWidth = function () {
+        return this._zr.getWidth();
+      };
+
+      ECharts.prototype.getHeight = function () {
+        return this._zr.getHeight();
+      };
+
+      ECharts.prototype.getDevicePixelRatio = function () {
+        return this._zr.painter.dpr
+        /* eslint-disable-next-line */
+        || hasWindow && window.devicePixelRatio || 1;
+      };
+      /**
+       * Get canvas which has all thing rendered
+       */
+
+
+      ECharts.prototype.getRenderedCanvas = function (opts) {
+        if (!env.canvasSupported) {
+          return;
+        }
+
+        opts = extend({}, opts || {});
+        opts.pixelRatio = opts.pixelRatio || this.getDevicePixelRatio();
+        opts.backgroundColor = opts.backgroundColor || this._model.get('backgroundColor');
+        var zr = this._zr; // let list = zr.storage.getDisplayList();
+        // Stop animations
+        // Never works before in init animation, so remove it.
+        // zrUtil.each(list, function (el) {
+        //     el.stopAnimation(true);
+        // });
+
+        return zr.painter.getRenderedCanvas(opts);
+      };
+      /**
+       * Get svg data url
+       */
+
+
+      ECharts.prototype.getSvgDataURL = function () {
+        if (!env.svgSupported) {
+          return;
+        }
+
+        var zr = this._zr;
+        var list = zr.storage.getDisplayList(); // Stop animations
+
+        each(list, function (el) {
+          el.stopAnimation(null, true);
+        });
+        return zr.painter.toDataURL();
+      };
+
+      ECharts.prototype.getDataURL = function (opts) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        opts = opts || {};
+        var excludeComponents = opts.excludeComponents;
+        var ecModel = this._model;
+        var excludesComponentViews = [];
+        var self = this;
+        each$3(excludeComponents, function (componentType) {
+          ecModel.eachComponent({
+            mainType: componentType
+          }, function (component) {
+            var view = self._componentsMap[component.__viewId];
+
+            if (!view.group.ignore) {
+              excludesComponentViews.push(view);
+              view.group.ignore = true;
+            }
+          });
+        });
+        var url = this._zr.painter.getType() === 'svg' ? this.getSvgDataURL() : this.getRenderedCanvas(opts).toDataURL('image/' + (opts && opts.type || 'png'));
+        each$3(excludesComponentViews, function (view) {
+          view.group.ignore = false;
+        });
+        return url;
+      };
+
+      ECharts.prototype.getConnectedDataURL = function (opts) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        if (!env.canvasSupported) {
+          return;
+        }
+
+        var isSvg = opts.type === 'svg';
+        var groupId = this.group;
+        var mathMin = Math.min;
+        var mathMax = Math.max;
+        var MAX_NUMBER = Infinity;
+
+        if (connectedGroups[groupId]) {
+          var left_1 = MAX_NUMBER;
+          var top_1 = MAX_NUMBER;
+          var right_1 = -MAX_NUMBER;
+          var bottom_1 = -MAX_NUMBER;
+          var canvasList_1 = [];
+          var dpr_1 = opts && opts.pixelRatio || this.getDevicePixelRatio();
+          each(instances$1, function (chart, id) {
+            if (chart.group === groupId) {
+              var canvas = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.getRenderedCanvas(clone(opts));
+              var boundingRect = chart.getDom().getBoundingClientRect();
+              left_1 = mathMin(boundingRect.left, left_1);
+              top_1 = mathMin(boundingRect.top, top_1);
+              right_1 = mathMax(boundingRect.right, right_1);
+              bottom_1 = mathMax(boundingRect.bottom, bottom_1);
+              canvasList_1.push({
+                dom: canvas,
+                left: boundingRect.left,
+                top: boundingRect.top
+              });
+            }
+          });
+          left_1 *= dpr_1;
+          top_1 *= dpr_1;
+          right_1 *= dpr_1;
+          bottom_1 *= dpr_1;
+          var width = right_1 - left_1;
+          var height = bottom_1 - top_1;
+          var targetCanvas = createCanvas();
+          var zr_1 = init(targetCanvas, {
+            renderer: isSvg ? 'svg' : 'canvas'
+          });
+          zr_1.resize({
+            width: width,
+            height: height
+          });
+
+          if (isSvg) {
+            var content_1 = '';
+            each$3(canvasList_1, function (item) {
+              var x = item.left - left_1;
+              var y = item.top - top_1;
+              content_1 += '<g transform="translate(' + x + ',' + y + ')">' + item.dom + '</g>';
+            });
+            zr_1.painter.getSvgRoot().innerHTML = content_1;
+
+            if (opts.connectedBackgroundColor) {
+              zr_1.painter.setBackgroundColor(opts.connectedBackgroundColor);
+            }
+
+            zr_1.refreshImmediately();
+            return zr_1.painter.toDataURL();
+          } else {
+            // Background between the charts
+            if (opts.connectedBackgroundColor) {
+              zr_1.add(new Rect({
+                shape: {
+                  x: 0,
+                  y: 0,
+                  width: width,
+                  height: height
+                },
+                style: {
+                  fill: opts.connectedBackgroundColor
+                }
+              }));
+            }
+
+            each$3(canvasList_1, function (item) {
+              var img = new ZRImage({
+                style: {
+                  x: item.left * dpr_1 - left_1,
+                  y: item.top * dpr_1 - top_1,
+                  image: item.dom
+                }
+              });
+              zr_1.add(img);
+            });
+            zr_1.refreshImmediately();
+            return targetCanvas.toDataURL('image/' + (opts && opts.type || 'png'));
+          }
+        } else {
+          return this.getDataURL(opts);
+        }
+      };
+
+      ECharts.prototype.convertToPixel = function (finder, value) {
+        return doConvertPixel(this, 'convertToPixel', finder, value);
+      };
+
+      ECharts.prototype.convertFromPixel = function (finder, value) {
+        return doConvertPixel(this, 'convertFromPixel', finder, value);
+      };
+      /**
+       * Is the specified coordinate systems or components contain the given pixel point.
+       * @param {Array|number} value
+       * @return {boolean} result
+       */
+
+
+      ECharts.prototype.containPixel = function (finder, value) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        var ecModel = this._model;
+        var result;
+        var findResult = parseFinder(ecModel, finder);
+        each(findResult, function (models, key) {
+          key.indexOf('Models') >= 0 && each(models, function (model) {
+            var coordSys = model.coordinateSystem;
+
+            if (coordSys && coordSys.containPoint) {
+              result = result || !!coordSys.containPoint(value);
+            } else if (key === 'seriesModels') {
+              var view = this._chartsMap[model.__viewId];
+
+              if (view && view.containPoint) {
+                result = result || view.containPoint(value, model);
+              } else {
+                if ("development" !== 'production') {
+                  console.warn(key + ': ' + (view ? 'The found component do not support containPoint.' : 'No view mapping to the found component.'));
+                }
+              }
+            } else {
+              if ("development" !== 'production') {
+                console.warn(key + ': containPoint is not supported');
+              }
+            }
+          }, this);
+        }, this);
+        return !!result;
+      };
+      /**
+       * Get visual from series or data.
+       * @param finder
+       *        If string, e.g., 'series', means {seriesIndex: 0}.
+       *        If Object, could contain some of these properties below:
+       *        {
+       *            seriesIndex / seriesId / seriesName,
+       *            dataIndex / dataIndexInside
+       *        }
+       *        If dataIndex is not specified, series visual will be fetched,
+       *        but not data item visual.
+       *        If all of seriesIndex, seriesId, seriesName are not specified,
+       *        visual will be fetched from first series.
+       * @param visualType 'color', 'symbol', 'symbolSize'
+       */
+
+
+      ECharts.prototype.getVisual = function (finder, visualType) {
+        var ecModel = this._model;
+        var parsedFinder = parseFinder(ecModel, finder, {
+          defaultMainType: 'series'
+        });
+        var seriesModel = parsedFinder.seriesModel;
+
+        if ("development" !== 'production') {
+          if (!seriesModel) {
+            console.warn('There is no specified seires model');
+          }
+        }
+
+        var data = seriesModel.getData();
+        var dataIndexInside = parsedFinder.hasOwnProperty('dataIndexInside') ? parsedFinder.dataIndexInside : parsedFinder.hasOwnProperty('dataIndex') ? data.indexOfRawIndex(parsedFinder.dataIndex) : null;
+        return dataIndexInside != null ? getItemVisualFromData(data, dataIndexInside, visualType) : getVisualFromData(data, visualType);
+      };
+      /**
+       * Get view of corresponding component model
+       */
+
+
+      ECharts.prototype.getViewOfComponentModel = function (componentModel) {
+        return this._componentsMap[componentModel.__viewId];
+      };
+      /**
+       * Get view of corresponding series model
+       */
+
+
+      ECharts.prototype.getViewOfSeriesModel = function (seriesModel) {
+        return this._chartsMap[seriesModel.__viewId];
+      };
+
+      ECharts.prototype._initEvents = function () {
+        var _this = this;
+
+        each$3(MOUSE_EVENT_NAMES, function (eveName) {
+          var handler = function (e) {
+            var ecModel = _this.getModel();
+
+            var el = e.target;
+            var params;
+            var isGlobalOut = eveName === 'globalout'; // no e.target when 'globalout'.
+
+            if (isGlobalOut) {
+              params = {};
+            } else {
+              el && findEventDispatcher(el, function (parent) {
+                var ecData = getECData(parent);
+
+                if (ecData && ecData.dataIndex != null) {
+                  var dataModel = ecData.dataModel || ecModel.getSeriesByIndex(ecData.seriesIndex);
+                  params = dataModel && dataModel.getDataParams(ecData.dataIndex, ecData.dataType) || {};
+                  return true;
+                } // If element has custom eventData of components
+                else if (ecData.eventData) {
+                    params = extend({}, ecData.eventData);
+                    return true;
+                  }
+              }, true);
+            } // Contract: if params prepared in mouse event,
+            // these properties must be specified:
+            // {
+            //    componentType: string (component main type)
+            //    componentIndex: number
+            // }
+            // Otherwise event query can not work.
+
+
+            if (params) {
+              var componentType = params.componentType;
+              var componentIndex = params.componentIndex; // Special handling for historic reason: when trigger by
+              // markLine/markPoint/markArea, the componentType is
+              // 'markLine'/'markPoint'/'markArea', but we should better
+              // enable them to be queried by seriesIndex, since their
+              // option is set in each series.
+
+              if (componentType === 'markLine' || componentType === 'markPoint' || componentType === 'markArea') {
+                componentType = 'series';
+                componentIndex = params.seriesIndex;
+              }
+
+              var model = componentType && componentIndex != null && ecModel.getComponent(componentType, componentIndex);
+              var view = model && _this[model.mainType === 'series' ? '_chartsMap' : '_componentsMap'][model.__viewId];
+
+              if ("development" !== 'production') {
+                // `event.componentType` and `event[componentTpype + 'Index']` must not
+                // be missed, otherwise there is no way to distinguish source component.
+                // See `dataFormat.getDataParams`.
+                if (!isGlobalOut && !(model && view)) {
+                  console.warn('model or view can not be found by params');
+                }
+              }
+
+              params.event = e;
+              params.type = eveName;
+              _this._$eventProcessor.eventInfo = {
+                targetEl: el,
+                packedEvent: params,
+                model: model,
+                view: view
+              };
+
+              _this.trigger(eveName, params);
+            }
+          }; // Consider that some component (like tooltip, brush, ...)
+          // register zr event handler, but user event handler might
+          // do anything, such as call `setOption` or `dispatchAction`,
+          // which probably update any of the content and probably
+          // cause problem if it is called previous other inner handlers.
+
+
+          handler.zrEventfulCallAtLast = true;
+
+          _this._zr.on(eveName, handler, _this);
+        });
+        each$3(eventActionMap, function (actionType, eventType) {
+          _this._messageCenter.on(eventType, function (event) {
+            this.trigger(eventType, event);
+          }, _this);
+        }); // Extra events
+        // TODO register?
+
+        each$3(['selectchanged'], function (eventType) {
+          _this._messageCenter.on(eventType, function (event) {
+            this.trigger(eventType, event);
+          }, _this);
+        });
+        handleLegacySelectEvents(this._messageCenter, this, this._api);
+      };
+
+      ECharts.prototype.isDisposed = function () {
+        return this._disposed;
+      };
+
+      ECharts.prototype.clear = function () {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        this.setOption({
+          series: []
+        }, true);
+      };
+
+      ECharts.prototype.dispose = function () {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        this._disposed = true;
+        setAttribute(this.getDom(), DOM_ATTRIBUTE_KEY, '');
+        var api = this._api;
+        var ecModel = this._model;
+        each$3(this._componentsViews, function (component) {
+          component.dispose(ecModel, api);
+        });
+        each$3(this._chartsViews, function (chart) {
+          chart.dispose(ecModel, api);
+        }); // Dispose after all views disposed
+
+        this._zr.dispose();
+
+        delete instances$1[this.id];
+      };
+      /**
+       * Resize the chart
+       */
+
+
+      ECharts.prototype.resize = function (opts) {
+        if ("development" !== 'production') {
+          assert$1(!this[IN_MAIN_PROCESS_KEY], '`resize` should not be called during main process.');
+        }
+
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        this._zr.resize(opts);
+
+        var ecModel = this._model; // Resize loading effect
+
+        this._loadingFX && this._loadingFX.resize();
+
+        if (!ecModel) {
+          return;
+        }
+
+        var optionChanged = ecModel.resetOption('media');
+        var silent = opts && opts.silent;
+        this[IN_MAIN_PROCESS_KEY] = true;
+        optionChanged && prepare(this);
+        updateMethods.update.call(this, {
+          type: 'resize',
+          animation: {
+            // Disable animation
+            duration: 0
+          }
+        });
+        this[IN_MAIN_PROCESS_KEY] = false;
+        flushPendingActions.call(this, silent);
+        triggerUpdatedEvent.call(this, silent);
+      };
+
+      ECharts.prototype.showLoading = function (name, cfg) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        if (isObject$2(name)) {
+          cfg = name;
+          name = '';
+        }
+
+        name = name || 'default';
+        this.hideLoading();
+
+        if (!loadingEffects[name]) {
+          if ("development" !== 'production') {
+            console.warn('Loading effects ' + name + ' not exists.');
+          }
+
+          return;
+        }
+
+        var el = loadingEffects[name](this._api, cfg);
+        var zr = this._zr;
+        this._loadingFX = el;
+        zr.add(el);
+      };
+      /**
+       * Hide loading effect
+       */
+
+
+      ECharts.prototype.hideLoading = function () {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        this._loadingFX && this._zr.remove(this._loadingFX);
+        this._loadingFX = null;
+      };
+
+      ECharts.prototype.makeActionFromEvent = function (eventObj) {
+        var payload = extend({}, eventObj);
+        payload.type = eventActionMap[eventObj.type];
+        return payload;
+      };
+      /**
+       * @param opt If pass boolean, means opt.silent
+       * @param opt.silent Default `false`. Whether trigger events.
+       * @param opt.flush Default `undefined`.
+       *        true: Flush immediately, and then pixel in canvas can be fetched
+       *            immediately. Caution: it might affect performance.
+       *        false: Not flush.
+       *        undefined: Auto decide whether perform flush.
+       */
+
+
+      ECharts.prototype.dispatchAction = function (payload, opt) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        if (!isObject$2(opt)) {
+          opt = {
+            silent: !!opt
+          };
+        }
+
+        if (!actions[payload.type]) {
+          return;
+        } // Avoid dispatch action before setOption. Especially in `connect`.
+
+
+        if (!this._model) {
+          return;
+        } // May dispatchAction in rendering procedure
+
+
+        if (this[IN_MAIN_PROCESS_KEY]) {
+          this._pendingActions.push(payload);
+
+          return;
+        }
+
+        var silent = opt.silent;
+        doDispatchAction.call(this, payload, silent);
+        var flush = opt.flush;
+
+        if (flush) {
+          this._zr.flush();
+        } else if (flush !== false && env.browser.weChat) {
+          // In WeChat embeded browser, `requestAnimationFrame` and `setInterval`
+          // hang when sliding page (on touch event), which cause that zr does not
+          // refresh util user interaction finished, which is not expected.
+          // But `dispatchAction` may be called too frequently when pan on touch
+          // screen, which impacts performance if do not throttle them.
+          this._throttledZrFlush();
+        }
+
+        flushPendingActions.call(this, silent);
+        triggerUpdatedEvent.call(this, silent);
+      };
+
+      ECharts.prototype.updateLabelLayout = function () {
+        var labelManager = this._labelManager;
+        labelManager.updateLayoutConfig(this._api);
+        labelManager.layout(this._api);
+        labelManager.processLabelsOverall();
+      };
+
+      ECharts.prototype.appendData = function (params) {
+        if (this._disposed) {
+          disposedWarning(this.id);
+          return;
+        }
+
+        var seriesIndex = params.seriesIndex;
+        var ecModel = this.getModel();
+        var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
+
+        if ("development" !== 'production') {
+          assert$1(params.data && seriesModel);
+        }
+
+        seriesModel.appendData(params); // Note: `appendData` does not support that update extent of coordinate
+        // system, util some scenario require that. In the expected usage of
+        // `appendData`, the initial extent of coordinate system should better
+        // be fixed by axis `min`/`max` setting or initial data, otherwise if
+        // the extent changed while `appendData`, the location of the painted
+        // graphic elements have to be changed, which make the usage of
+        // `appendData` meaningless.
+
+        this._scheduler.unfinished = true;
+        this.getZr().wakeUp();
+      }; // A work around for no `internal` modifier in ts yet but
+      // need to strictly hide private methods to JS users.
+
+
+      ECharts.internalField = function () {
+        prepare = function (ecIns) {
+          var scheduler = ecIns._scheduler;
+          scheduler.restorePipelines(ecIns._model);
+          scheduler.prepareStageTasks();
+          prepareView(ecIns, true);
+          prepareView(ecIns, false);
+          scheduler.plan();
+        };
+        /**
+         * Prepare view instances of charts and components
+         */
+
+
+        prepareView = function (ecIns, isComponent) {
+          var ecModel = ecIns._model;
+          var scheduler = ecIns._scheduler;
+          var viewList = isComponent ? ecIns._componentsViews : ecIns._chartsViews;
+          var viewMap = isComponent ? ecIns._componentsMap : ecIns._chartsMap;
+          var zr = ecIns._zr;
+          var api = ecIns._api;
+
+          for (var i = 0; i < viewList.length; i++) {
+            viewList[i].__alive = false;
+          }
+
+          isComponent ? ecModel.eachComponent(function (componentType, model) {
+            componentType !== 'series' && doPrepare(model);
+          }) : ecModel.eachSeries(doPrepare);
+
+          function doPrepare(model) {
+            // By defaut view will be reused if possible for the case that `setOption` with "notMerge"
+            // mode and need to enable transition animation. (Usually, when they have the same id, or
+            // especially no id but have the same type & name & index. See the `model.id` generation
+            // rule in `makeIdAndName` and `viewId` generation rule here).
+            // But in `replaceMerge` mode, this feature should be able to disabled when it is clear that
+            // the new model has nothing to do with the old model.
+            var requireNewView = model.__requireNewView; // This command should not work twice.
+
+            model.__requireNewView = false; // Consider: id same and type changed.
+
+            var viewId = '_ec_' + model.id + '_' + model.type;
+            var view = !requireNewView && viewMap[viewId];
+
+            if (!view) {
+              var classType = parseClassType(model.type);
+              var Clazz = isComponent ? ComponentView.getClass(classType.main, classType.sub) : // FIXME:TS
+              // (ChartView as ChartViewConstructor).getClass('series', classType.sub)
+              // For backward compat, still support a chart type declared as only subType
+              // like "liquidfill", but recommend "series.liquidfill"
+              // But need a base class to make a type series.
+              ChartView.getClass(classType.sub);
+
+              if ("development" !== 'production') {
+                assert$1(Clazz, classType.sub + ' does not exist.');
+              }
+
+              view = new Clazz();
+              view.init(ecModel, api);
+              viewMap[viewId] = view;
+              viewList.push(view);
+              zr.add(view.group);
+            }
+
+            model.__viewId = view.__id = viewId;
+            view.__alive = true;
+            view.__model = model;
+            view.group.__ecComponentInfo = {
+              mainType: model.mainType,
+              index: model.componentIndex
+            };
+            !isComponent && scheduler.prepareView(view, model, ecModel, api);
+          }
+
+          for (var i = 0; i < viewList.length;) {
+            var view = viewList[i];
+
+            if (!view.__alive) {
+              !isComponent && view.renderTask.dispose();
+              zr.remove(view.group);
+              view.dispose(ecModel, api);
+              viewList.splice(i, 1);
+
+              if (viewMap[view.__id] === view) {
+                delete viewMap[view.__id];
+              }
+
+              view.__id = view.group.__ecComponentInfo = null;
+            } else {
+              i++;
+            }
+          }
+        };
+
+        updateDirectly = function (ecIns, method, payload, mainType, subType) {
+          var ecModel = ecIns._model;
+          ecModel.setUpdatePayload(payload); // broadcast
+
+          if (!mainType) {
+            // FIXME
+            // Chart will not be update directly here, except set dirty.
+            // But there is no such scenario now.
+            each$3([].concat(ecIns._componentsViews).concat(ecIns._chartsViews), callView);
+            return;
+          }
+
+          var query = {};
+          query[mainType + 'Id'] = payload[mainType + 'Id'];
+          query[mainType + 'Index'] = payload[mainType + 'Index'];
+          query[mainType + 'Name'] = payload[mainType + 'Name'];
+          var condition = {
+            mainType: mainType,
+            query: query
+          };
+          subType && (condition.subType = subType); // subType may be '' by parseClassType;
+
+          var excludeSeriesId = payload.excludeSeriesId;
+          var excludeSeriesIdMap;
+
+          if (excludeSeriesId != null) {
+            excludeSeriesIdMap = createHashMap();
+            each$3(normalizeToArray(excludeSeriesId), function (id) {
+              var modelId = convertOptionIdName(id, null);
+
+              if (modelId != null) {
+                excludeSeriesIdMap.set(modelId, true);
+              }
+            });
+          } // If dispatchAction before setOption, do nothing.
+
+
+          ecModel && ecModel.eachComponent(condition, function (model) {
+            if (!excludeSeriesIdMap || excludeSeriesIdMap.get(model.id) == null) {
+              if (isHighDownPayload(payload) && !payload.notBlur) {
+                if (model instanceof SeriesModel) {
+                  toggleSeriesBlurStateFromPayload(model, payload, ecIns._api);
+                }
+              } else if (isSelectChangePayload(payload)) {
+                // TODO geo
+                if (model instanceof SeriesModel) {
+                  toggleSelectionFromPayload(model, payload, ecIns._api);
+                  updateSeriesElementSelection(model);
+                  markStatusToUpdate(ecIns);
+                }
+              }
+
+              callView(ecIns[mainType === 'series' ? '_chartsMap' : '_componentsMap'][model.__viewId]);
+            }
+          }, ecIns);
+
+          function callView(view) {
+            view && view.__alive && view[method] && view[method](view.__model, ecModel, ecIns._api, payload);
+          }
+        };
+
+        updateMethods = {
+          prepareAndUpdate: function (payload) {
+            prepare(this);
+            updateMethods.update.call(this, payload);
+          },
+          update: function (payload) {
+            // console.profile && console.profile('update');
+            var ecModel = this._model;
+            var api = this._api;
+            var zr = this._zr;
+            var coordSysMgr = this._coordSysMgr;
+            var scheduler = this._scheduler; // update before setOption
+
+            if (!ecModel) {
+              return;
+            }
+
+            ecModel.setUpdatePayload(payload);
+            scheduler.restoreData(ecModel, payload);
+            scheduler.performSeriesTasks(ecModel); // TODO
+            // Save total ecModel here for undo/redo (after restoring data and before processing data).
+            // Undo (restoration of total ecModel) can be carried out in 'action' or outside API call.
+            // Create new coordinate system each update
+            // In LineView may save the old coordinate system and use it to get the orignal point
+
+            coordSysMgr.create(ecModel, api);
+            scheduler.performDataProcessorTasks(ecModel, payload); // Current stream render is not supported in data process. So we can update
+            // stream modes after data processing, where the filtered data is used to
+            // deteming whether use progressive rendering.
+
+            updateStreamModes(this, ecModel); // We update stream modes before coordinate system updated, then the modes info
+            // can be fetched when coord sys updating (consider the barGrid extent fix). But
+            // the drawback is the full coord info can not be fetched. Fortunately this full
+            // coord is not requied in stream mode updater currently.
+
+            coordSysMgr.update(ecModel, api);
+            clearColorPalette(ecModel);
+            scheduler.performVisualTasks(ecModel, payload);
+            render(this, ecModel, api, payload); // Set background
+
+            var backgroundColor = ecModel.get('backgroundColor') || 'transparent';
+            var darkMode = ecModel.get('darkMode'); // In IE8
+
+            if (!env.canvasSupported) {
+              var colorArr = parse(backgroundColor);
+              backgroundColor = stringify(colorArr, 'rgb');
+
+              if (colorArr[3] === 0) {
+                backgroundColor = 'transparent';
+              }
+            } else {
+              zr.setBackgroundColor(backgroundColor); // Force set dark mode.
+
+              if (darkMode != null && darkMode !== 'auto') {
+                zr.setDarkMode(darkMode);
+              }
+            }
+
+            performPostUpdateFuncs(ecModel, api); // console.profile && console.profileEnd('update');
+          },
+          updateTransform: function (payload) {
+            var _this = this;
+
+            var ecModel = this._model;
+            var api = this._api; // update before setOption
+
+            if (!ecModel) {
+              return;
+            }
+
+            ecModel.setUpdatePayload(payload); // ChartView.markUpdateMethod(payload, 'updateTransform');
+
+            var componentDirtyList = [];
+            ecModel.eachComponent(function (componentType, componentModel) {
+              if (componentType === 'series') {
+                return;
+              }
+
+              var componentView = _this.getViewOfComponentModel(componentModel);
+
+              if (componentView && componentView.__alive) {
+                if (componentView.updateTransform) {
+                  var result = componentView.updateTransform(componentModel, ecModel, api, payload);
+                  result && result.update && componentDirtyList.push(componentView);
+                } else {
+                  componentDirtyList.push(componentView);
+                }
+              }
+            });
+            var seriesDirtyMap = createHashMap();
+            ecModel.eachSeries(function (seriesModel) {
+              var chartView = _this._chartsMap[seriesModel.__viewId];
+
+              if (chartView.updateTransform) {
+                var result = chartView.updateTransform(seriesModel, ecModel, api, payload);
+                result && result.update && seriesDirtyMap.set(seriesModel.uid, 1);
+              } else {
+                seriesDirtyMap.set(seriesModel.uid, 1);
+              }
+            });
+            clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
+            // this._scheduler.performVisualTasks(ecModel, payload, 'layout', true);
+
+            this._scheduler.performVisualTasks(ecModel, payload, {
+              setDirty: true,
+              dirtyMap: seriesDirtyMap
+            }); // Currently, not call render of components. Geo render cost a lot.
+            // renderComponents(ecIns, ecModel, api, payload, componentDirtyList);
+
+
+            renderSeries(this, ecModel, api, payload, seriesDirtyMap);
+            performPostUpdateFuncs(ecModel, this._api);
+          },
+          updateView: function (payload) {
+            var ecModel = this._model; // update before setOption
+
+            if (!ecModel) {
+              return;
+            }
+
+            ecModel.setUpdatePayload(payload);
+            ChartView.markUpdateMethod(payload, 'updateView');
+            clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
+
+            this._scheduler.performVisualTasks(ecModel, payload, {
+              setDirty: true
+            });
+
+            render(this, this._model, this._api, payload);
+            performPostUpdateFuncs(ecModel, this._api);
+          },
+          updateVisual: function (payload) {
+            // updateMethods.update.call(this, payload);
+            var _this = this;
+
+            var ecModel = this._model; // update before setOption
+
+            if (!ecModel) {
+              return;
+            }
+
+            ecModel.setUpdatePayload(payload); // clear all visual
+
+            ecModel.eachSeries(function (seriesModel) {
+              seriesModel.getData().clearAllVisual();
+            }); // Perform visual
+
+            ChartView.markUpdateMethod(payload, 'updateVisual');
+            clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
+
+            this._scheduler.performVisualTasks(ecModel, payload, {
+              visualType: 'visual',
+              setDirty: true
+            });
+
+            ecModel.eachComponent(function (componentType, componentModel) {
+              if (componentType !== 'series') {
+                var componentView = _this.getViewOfComponentModel(componentModel);
+
+                componentView && componentView.__alive && componentView.updateVisual(componentModel, ecModel, _this._api, payload);
+              }
+            });
+            ecModel.eachSeries(function (seriesModel) {
+              var chartView = _this._chartsMap[seriesModel.__viewId];
+              chartView.updateVisual(seriesModel, ecModel, _this._api, payload);
+            });
+            performPostUpdateFuncs(ecModel, this._api);
+          },
+          updateLayout: function (payload) {
+            updateMethods.update.call(this, payload);
+          }
+        };
+
+        doConvertPixel = function (ecIns, methodName, finder, value) {
+          if (ecIns._disposed) {
+            disposedWarning(ecIns.id);
+            return;
+          }
+
+          var ecModel = ecIns._model;
+
+          var coordSysList = ecIns._coordSysMgr.getCoordinateSystems();
+
+          var result;
+          var parsedFinder = parseFinder(ecModel, finder);
+
+          for (var i = 0; i < coordSysList.length; i++) {
+            var coordSys = coordSysList[i];
+
+            if (coordSys[methodName] && (result = coordSys[methodName](ecModel, parsedFinder, value)) != null) {
+              return result;
+            }
+          }
+
+          if ("development" !== 'production') {
+            console.warn('No coordinate system that supports ' + methodName + ' found by the given finder.');
+          }
+        };
+
+        updateStreamModes = function (ecIns, ecModel) {
+          var chartsMap = ecIns._chartsMap;
+          var scheduler = ecIns._scheduler;
+          ecModel.eachSeries(function (seriesModel) {
+            scheduler.updateStreamModes(seriesModel, chartsMap[seriesModel.__viewId]);
+          });
+        };
+
+        doDispatchAction = function (payload, silent) {
+          var _this = this;
+
+          var ecModel = this.getModel();
+          var payloadType = payload.type;
+          var escapeConnect = payload.escapeConnect;
+          var actionWrap = actions[payloadType];
+          var actionInfo = actionWrap.actionInfo;
+          var cptTypeTmp = (actionInfo.update || 'update').split(':');
+          var updateMethod = cptTypeTmp.pop();
+          var cptType = cptTypeTmp[0] != null && parseClassType(cptTypeTmp[0]);
+          this[IN_MAIN_PROCESS_KEY] = true;
+          var payloads = [payload];
+          var batched = false; // Batch action
+
+          if (payload.batch) {
+            batched = true;
+            payloads = map(payload.batch, function (item) {
+              item = defaults(extend({}, item), payload);
+              item.batch = null;
+              return item;
+            });
+          }
+
+          var eventObjBatch = [];
+          var eventObj;
+          var isSelectChange = isSelectChangePayload(payload);
+          var isStatusChange = isHighDownPayload(payload) || isSelectChange;
+          each$3(payloads, function (batchItem) {
+            // Action can specify the event by return it.
+            eventObj = actionWrap.action(batchItem, _this._model, _this._api); // Emit event outside
+
+            eventObj = eventObj || extend({}, batchItem); // Convert type to eventType
+
+            eventObj.type = actionInfo.event || eventObj.type;
+            eventObjBatch.push(eventObj); // light update does not perform data process, layout and visual.
+
+            if (isStatusChange) {
+              // method, payload, mainType, subType
+              updateDirectly(_this, updateMethod, batchItem, 'series'); // Mark status to update
+
+              markStatusToUpdate(_this);
+            } else if (cptType) {
+              updateDirectly(_this, updateMethod, batchItem, cptType.main, cptType.sub);
+            }
+          });
+
+          if (updateMethod !== 'none' && !isStatusChange && !cptType) {
+            // Still dirty
+            if (this[OPTION_UPDATED_KEY]) {
+              prepare(this);
+              updateMethods.update.call(this, payload);
+              this[OPTION_UPDATED_KEY] = false;
+            } else {
+              updateMethods[updateMethod].call(this, payload);
+            }
+          } // Follow the rule of action batch
+
+
+          if (batched) {
+            eventObj = {
+              type: actionInfo.event || payloadType,
+              escapeConnect: escapeConnect,
+              batch: eventObjBatch
+            };
+          } else {
+            eventObj = eventObjBatch[0];
+          }
+
+          this[IN_MAIN_PROCESS_KEY] = false;
+
+          if (!silent) {
+            var messageCenter = this._messageCenter;
+            messageCenter.trigger(eventObj.type, eventObj); // Extra triggered 'selectchanged' event
+
+            if (isSelectChange) {
+              var newObj = {
+                type: 'selectchanged',
+                escapeConnect: escapeConnect,
+                selected: getAllSelectedIndices(ecModel),
+                isFromClick: payload.isFromClick || false,
+                fromAction: payload.type,
+                fromActionPayload: payload
+              };
+              messageCenter.trigger(newObj.type, newObj);
+            }
+          }
+        };
+
+        flushPendingActions = function (silent) {
+          var pendingActions = this._pendingActions;
+
+          while (pendingActions.length) {
+            var payload = pendingActions.shift();
+            doDispatchAction.call(this, payload, silent);
+          }
+        };
+
+        triggerUpdatedEvent = function (silent) {
+          !silent && this.trigger('updated');
+        };
+        /**
+         * Event `rendered` is triggered when zr
+         * rendered. It is useful for realtime
+         * snapshot (reflect animation).
+         *
+         * Event `finished` is triggered when:
+         * (1) zrender rendering finished.
+         * (2) initial animation finished.
+         * (3) progressive rendering finished.
+         * (4) no pending action.
+         * (5) no delayed setOption needs to be processed.
+         */
+
+
+        bindRenderedEvent = function (zr, ecIns) {
+          zr.on('rendered', function (params) {
+            ecIns.trigger('rendered', params); // The `finished` event should not be triggered repeatly,
+            // so it should only be triggered when rendering indeed happend
+            // in zrender. (Consider the case that dipatchAction is keep
+            // triggering when mouse move).
+
+            if ( // Although zr is dirty if initial animation is not finished
+            // and this checking is called on frame, we also check
+            // animation finished for robustness.
+            zr.animation.isFinished() && !ecIns[OPTION_UPDATED_KEY] && !ecIns._scheduler.unfinished && !ecIns._pendingActions.length) {
+              ecIns.trigger('finished');
+            }
+          });
+        };
+
+        bindMouseEvent = function (zr, ecIns) {
+          zr.on('mouseover', function (e) {
+            var el = e.target;
+            var dispatcher = findEventDispatcher(el, isHighDownDispatcher);
+
+            if (dispatcher) {
+              var ecData = getECData(dispatcher); // Try blur all in the related series. Then emphasis the hoverred.
+              // TODO. progressive mode.
+
+              toggleSeriesBlurState(ecData.seriesIndex, ecData.focus, ecData.blurScope, ecIns._api, true);
+              enterEmphasisWhenMouseOver(dispatcher, e);
+              markStatusToUpdate(ecIns);
+            }
+          }).on('mouseout', function (e) {
+            var el = e.target;
+            var dispatcher = findEventDispatcher(el, isHighDownDispatcher);
+
+            if (dispatcher) {
+              var ecData = getECData(dispatcher);
+              toggleSeriesBlurState(ecData.seriesIndex, ecData.focus, ecData.blurScope, ecIns._api, false);
+              leaveEmphasisWhenMouseOut(dispatcher, e);
+              markStatusToUpdate(ecIns);
+            }
+          }).on('click', function (e) {
+            var el = e.target;
+            var dispatcher = findEventDispatcher(el, function (target) {
+              return getECData(target).dataIndex != null;
+            }, true);
+
+            if (dispatcher) {
+              var actionType = dispatcher.selected ? 'unselect' : 'select';
+              var ecData = getECData(dispatcher);
+
+              ecIns._api.dispatchAction({
+                type: actionType,
+                dataType: ecData.dataType,
+                dataIndexInside: ecData.dataIndex,
+                seriesIndex: ecData.seriesIndex,
+                isFromClick: true
+              });
+            }
+          });
+        };
+
+        clearColorPalette = function (ecModel) {
+          ecModel.clearColorPalette();
+          ecModel.eachSeries(function (seriesModel) {
+            seriesModel.clearColorPalette();
+          });
+        };
+
+        render = function (ecIns, ecModel, api, payload) {
+          renderComponents(ecIns, ecModel, api, payload);
+          each$3(ecIns._chartsViews, function (chart) {
+            chart.__alive = false;
+          });
+          renderSeries(ecIns, ecModel, api, payload); // Remove groups of unrendered charts
+
+          each$3(ecIns._chartsViews, function (chart) {
+            if (!chart.__alive) {
+              chart.remove(ecModel, api);
+            }
+          });
+        };
+
+        renderComponents = function (ecIns, ecModel, api, payload, dirtyList) {
+          each$3(dirtyList || ecIns._componentsViews, function (componentView) {
+            var componentModel = componentView.__model;
+            clearStates(componentModel, componentView);
+            componentView.render(componentModel, ecModel, api, payload);
+            updateZ(componentModel, componentView);
+            updateStates(componentModel, componentView);
+          });
+        };
+        /**
+         * Render each chart and component
+         */
+
+
+        renderSeries = function (ecIns, ecModel, api, payload, dirtyMap) {
+          // Render all charts
+          var scheduler = ecIns._scheduler;
+          var labelManager = ecIns._labelManager;
+          labelManager.clearLabels();
+          var unfinished = false;
+          ecModel.eachSeries(function (seriesModel) {
+            var chartView = ecIns._chartsMap[seriesModel.__viewId];
+            chartView.__alive = true;
+            var renderTask = chartView.renderTask;
+            scheduler.updatePayload(renderTask, payload); // TODO states on marker.
+
+            clearStates(seriesModel, chartView);
+
+            if (dirtyMap && dirtyMap.get(seriesModel.uid)) {
+              renderTask.dirty();
+            }
+
+            if (renderTask.perform(scheduler.getPerformArgs(renderTask))) {
+              unfinished = true;
+            }
+
+            seriesModel.__transientTransitionOpt = null;
+            chartView.group.silent = !!seriesModel.get('silent'); // Should not call markRedraw on group, because it will disable zrender
+            // increamental render (alway render from the __startIndex each frame)
+            // chartView.group.markRedraw();
+
+            updateBlend(seriesModel, chartView);
+            updateSeriesElementSelection(seriesModel); // Add labels.
+
+            labelManager.addLabelsOfSeries(chartView);
+          });
+          scheduler.unfinished = unfinished || scheduler.unfinished;
+          labelManager.updateLayoutConfig(api);
+          labelManager.layout(api);
+          labelManager.processLabelsOverall();
+          ecModel.eachSeries(function (seriesModel) {
+            var chartView = ecIns._chartsMap[seriesModel.__viewId]; // Update Z after labels updated. Before applying states.
+
+            updateZ(seriesModel, chartView); // NOTE: Update states after label is updated.
+            // label should be in normal status when layouting.
+
+            updateStates(seriesModel, chartView);
+          }); // If use hover layer
+
+          updateHoverLayerStatus(ecIns, ecModel);
+        };
+
+        performPostUpdateFuncs = function (ecModel, api) {
+          each$3(postUpdateFuncs, function (func) {
+            func(ecModel, api);
+          });
+        };
+
+        markStatusToUpdate = function (ecIns) {
+          ecIns[STATUS_NEEDS_UPDATE_KEY] = true; // Wake up zrender if it's sleep. Let it update states in the next frame.
+
+          ecIns.getZr().wakeUp();
+        };
+
+        applyChangedStates = function (ecIns) {
+          if (!ecIns[STATUS_NEEDS_UPDATE_KEY]) {
+            return;
+          }
+
+          ecIns.getZr().storage.traverse(function (el) {
+            // Not applied on removed elements, it may still in fading.
+            if (isElementRemoved(el)) {
+              return;
+            }
+
+            applyElementStates(el);
+          });
+          ecIns[STATUS_NEEDS_UPDATE_KEY] = false;
+        };
+
+        function applyElementStates(el) {
+          var newStates = [];
+          var oldStates = el.currentStates; // Keep other states.
+
+          for (var i = 0; i < oldStates.length; i++) {
+            var stateName = oldStates[i];
+
+            if (!(stateName === 'emphasis' || stateName === 'blur' || stateName === 'select')) {
+              newStates.push(stateName);
+            }
+          } // Only use states when it's exists.
+
+
+          if (el.selected && el.states.select) {
+            newStates.push('select');
+          }
+
+          if (el.hoverState === HOVER_STATE_EMPHASIS && el.states.emphasis) {
+            newStates.push('emphasis');
+          } else if (el.hoverState === HOVER_STATE_BLUR && el.states.blur) {
+            newStates.push('blur');
+          }
+
+          el.useStates(newStates);
+        }
+
+        function updateHoverLayerStatus(ecIns, ecModel) {
+          var zr = ecIns._zr;
+          var storage = zr.storage;
+          var elCount = 0;
+          storage.traverse(function (el) {
+            if (!el.isGroup) {
+              elCount++;
+            }
+          });
+
+          if (elCount > ecModel.get('hoverLayerThreshold') && !env.node && !env.worker) {
+            ecModel.eachSeries(function (seriesModel) {
+              if (seriesModel.preventUsingHoverLayer) {
+                return;
+              }
+
+              var chartView = ecIns._chartsMap[seriesModel.__viewId];
+
+              if (chartView.__alive) {
+                chartView.group.traverse(function (el) {
+                  if (el.states.emphasis) {
+                    el.states.emphasis.hoverLayer = true;
+                  }
+                });
+              }
+            });
+          }
+        }
+        /**
+         * Update chart and blend.
+         */
+
+        function updateBlend(seriesModel, chartView) {
+          var blendMode = seriesModel.get('blendMode') || null;
+
+          if ("development" !== 'production') {
+            if (!env.canvasSupported && blendMode && blendMode !== 'source-over') {
+              console.warn('Only canvas support blendMode');
+            }
+          }
+
+          chartView.group.traverse(function (el) {
+            // FIXME marker and other components
+            if (!el.isGroup) {
+              // DONT mark the element dirty. In case element is incremental and don't wan't to rerender.
+              el.style.blend = blendMode;
+            }
+
+            if (el.eachPendingDisplayable) {
+              el.eachPendingDisplayable(function (displayable) {
+                displayable.style.blend = blendMode;
+              });
+            }
+          });
+        }
+
+        function updateZ(model, view) {
+          if (model.preventAutoZ) {
+            return;
+          }
+
+          var z = model.get('z');
+          var zlevel = model.get('zlevel'); // Set z and zlevel
+
+          view.group.traverse(function (el) {
+            if (!el.isGroup) {
+              z != null && (el.z = z);
+              zlevel != null && (el.zlevel = zlevel); // TODO if textContent is on group.
+
+              var label = el.getTextContent();
+              var labelLine = el.getTextGuideLine();
+
+              if (label) {
+                label.z = el.z;
+                label.zlevel = el.zlevel; // lift z2 of text content
+                // TODO if el.emphasis.z2 is spcefied, what about textContent.
+
+                label.z2 = el.z2 + 2;
+              }
+
+              if (labelLine) {
+                var showAbove = el.textGuideLineConfig && el.textGuideLineConfig.showAbove;
+                labelLine.z = el.z;
+                labelLine.zlevel = el.zlevel;
+                labelLine.z2 = el.z2 + (showAbove ? 1 : -1);
+              }
+            }
+          });
+        }
+        // TODO States on component.
+
+        function clearStates(model, view) {
+          view.group.traverse(function (el) {
+            // Not applied on removed elements, it may still in fading.
+            if (isElementRemoved(el)) {
+              return;
+            }
+
+            var textContent = el.getTextContent();
+            var textGuide = el.getTextGuideLine();
+
+            if (el.stateTransition) {
+              el.stateTransition = null;
+            }
+
+            if (textContent && textContent.stateTransition) {
+              textContent.stateTransition = null;
+            }
+
+            if (textGuide && textGuide.stateTransition) {
+              textGuide.stateTransition = null;
+            } // TODO If el is incremental.
+
+
+            if (el.hasState()) {
+              el.prevStates = el.currentStates;
+              el.clearStates();
+            } else if (el.prevStates) {
+              el.prevStates = null;
+            }
+          });
+        }
+
+        function updateStates(model, view) {
+          var stateAnimationModel = model.getModel('stateAnimation');
+          var enableAnimation = model.isAnimationEnabled();
+          var duration = stateAnimationModel.get('duration');
+          var stateTransition = duration > 0 ? {
+            duration: duration,
+            delay: stateAnimationModel.get('delay'),
+            easing: stateAnimationModel.get('easing') // additive: stateAnimationModel.get('additive')
+
+          } : null;
+          view.group.traverse(function (el) {
+            if (el.states && el.states.emphasis) {
+              // Not applied on removed elements, it may still in fading.
+              if (isElementRemoved(el)) {
+                return;
+              }
+
+              if (el instanceof Path) {
+                savePathStates(el);
+              } // Only updated on changed element. In case element is incremental and don't wan't to rerender.
+              // TODO, a more proper way?
+
+
+              if (el.__dirty) {
+                var prevStates = el.prevStates; // Restore states without animation
+
+                if (prevStates) {
+                  el.useStates(prevStates);
+                }
+              } // Update state transition and enable animation again.
+
+
+              if (enableAnimation) {
+                el.stateTransition = stateTransition;
+                var textContent = el.getTextContent();
+                var textGuide = el.getTextGuideLine(); // TODO Is it necessary to animate label?
+
+                if (textContent) {
+                  textContent.stateTransition = stateTransition;
+                }
+
+                if (textGuide) {
+                  textGuide.stateTransition = stateTransition;
+                }
+              } // The use higlighted and selected flag to toggle states.
+
+
+              if (el.__dirty) {
+                applyElementStates(el);
+              }
+            }
+          });
+        }
+
+        createExtensionAPI = function (ecIns) {
+          return new (
+          /** @class */
+          function (_super) {
+            __extends(class_1, _super);
+
+            function class_1() {
+              return _super !== null && _super.apply(this, arguments) || this;
+            }
+
+            class_1.prototype.getCoordinateSystems = function () {
+              return ecIns._coordSysMgr.getCoordinateSystems();
+            };
+
+            class_1.prototype.getComponentByElement = function (el) {
+              while (el) {
+                var modelInfo = el.__ecComponentInfo;
+
+                if (modelInfo != null) {
+                  return ecIns._model.getComponent(modelInfo.mainType, modelInfo.index);
+                }
+
+                el = el.parent;
+              }
+            };
+
+            class_1.prototype.enterEmphasis = function (el, highlightDigit) {
+              enterEmphasis(el, highlightDigit);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.leaveEmphasis = function (el, highlightDigit) {
+              leaveEmphasis(el, highlightDigit);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.enterBlur = function (el) {
+              enterBlur(el);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.leaveBlur = function (el) {
+              leaveBlur(el);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.enterSelect = function (el) {
+              enterSelect(el);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.leaveSelect = function (el) {
+              leaveSelect(el);
+              markStatusToUpdate(ecIns);
+            };
+
+            class_1.prototype.getModel = function () {
+              return ecIns.getModel();
+            };
+
+            class_1.prototype.getViewOfComponentModel = function (componentModel) {
+              return ecIns.getViewOfComponentModel(componentModel);
+            };
+
+            class_1.prototype.getViewOfSeriesModel = function (seriesModel) {
+              return ecIns.getViewOfSeriesModel(seriesModel);
+            };
+
+            return class_1;
+          }(ExtensionAPI))(ecIns);
+        };
+
+        enableConnect = function (chart) {
+          function updateConnectedChartsStatus(charts, status) {
+            for (var i = 0; i < charts.length; i++) {
+              var otherChart = charts[i];
+              otherChart[CONNECT_STATUS_KEY] = status;
+            }
+          }
+
+          each$3(eventActionMap, function (actionType, eventType) {
+            chart._messageCenter.on(eventType, function (event) {
+              if (connectedGroups[chart.group] && chart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_PENDING) {
+                if (event && event.escapeConnect) {
+                  return;
+                }
+
+                var action_1 = chart.makeActionFromEvent(event);
+                var otherCharts_1 = [];
+                each$3(instances$1, function (otherChart) {
+                  if (otherChart !== chart && otherChart.group === chart.group) {
+                    otherCharts_1.push(otherChart);
+                  }
+                });
+                updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_PENDING);
+                each$3(otherCharts_1, function (otherChart) {
+                  if (otherChart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_UPDATING) {
+                    otherChart.dispatchAction(action_1);
+                  }
+                });
+                updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_UPDATED);
+              }
+            });
+          });
+        };
+
+        setTransitionOpt = function (chart, transitionOpt) {
+          var ecModel = chart._model;
+          each(normalizeToArray(transitionOpt), function (transOpt) {
+            var errMsg;
+            var fromOpt = transOpt.from;
+            var toOpt = transOpt.to;
+
+            if (toOpt == null) {
+              if ("development" !== 'production') {
+                errMsg = '`transition.to` must be specified.';
+              }
+
+              throwError(errMsg);
+            }
+
+            var finderOpt = {
+              includeMainTypes: ['series'],
+              enableAll: false,
+              enableNone: false
+            };
+            var fromResult = fromOpt ? parseFinder(ecModel, fromOpt, finderOpt) : null;
+            var toResult = parseFinder(ecModel, toOpt, finderOpt);
+            var toSeries = toResult.seriesModel;
+
+            if (toSeries == null) {
+              errMsg = '';
+
+              if ("development" !== 'production') {
+                errMsg = '`transition` is only supported on series.';
+              }
+            }
+
+            if (fromResult && fromResult.seriesModel !== toSeries) {
+              errMsg = '';
+
+              if ("development" !== 'production') {
+                errMsg = '`transition.from` and `transition.to` must be specified to the same series.';
+              }
+            }
+
+            if (errMsg != null) {
+              throwError(errMsg);
+            } // Just a temp solution: mount them on series.
+
+
+            toSeries.__transientTransitionOpt = {
+              from: fromOpt ? fromOpt.dimension : null,
+              to: toOpt.dimension,
+              dividingMethod: transOpt.dividingMethod
+            };
+          });
+        };
+      }();
+
+      return ECharts;
+    }(Eventful);
+
+    var echartsProto = ECharts.prototype;
+    echartsProto.on = createRegisterEventWithLowercaseECharts('on');
+    echartsProto.off = createRegisterEventWithLowercaseECharts('off');
+    /**
+     * @deprecated
+     */
+    // @ts-ignore
+
+    echartsProto.one = function (eventName, cb, ctx) {
+      var self = this;
+      deprecateLog('ECharts#one is deprecated.');
+
+      function wrapped() {
+        var args2 = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args2[_i] = arguments[_i];
+        }
+
+        cb && cb.apply && cb.apply(this, args2); // @ts-ignore
+
+        self.off(eventName, wrapped);
+      }
+
+      this.on.call(this, eventName, wrapped, ctx);
+    }; // /**
+    //  * Encode visual infomation from data after data processing
+    //  *
+    //  * @param {module:echarts/model/Global} ecModel
+    //  * @param {object} layout
+    //  * @param {boolean} [layoutFilter] `true`: only layout,
+    //  *                                 `false`: only not layout,
+    //  *                                 `null`/`undefined`: all.
+    //  * @param {string} taskBaseTag
+    //  * @private
+    //  */
+    // function startVisualEncoding(ecIns, ecModel, api, payload, layoutFilter) {
+    //     each(visualFuncs, function (visual, index) {
+    //         let isLayout = visual.isLayout;
+    //         if (layoutFilter == null
+    //             || (layoutFilter === false && !isLayout)
+    //             || (layoutFilter === true && isLayout)
+    //         ) {
+    //             visual.func(ecModel, api, payload);
+    //         }
+    //     });
+    // }
+
+
+    var MOUSE_EVENT_NAMES = ['click', 'dblclick', 'mouseover', 'mouseout', 'mousemove', 'mousedown', 'mouseup', 'globalout', 'contextmenu'];
+
+    function disposedWarning(id) {
+      if ("development" !== 'production') {
+        console.warn('Instance ' + id + ' has been disposed');
+      }
+    }
+
+    var actions = {};
+    /**
+     * Map eventType to actionType
+     */
+
+    var eventActionMap = {};
+    var dataProcessorFuncs = [];
+    var optionPreprocessorFuncs = [];
+    var postInitFuncs = [];
+    var postUpdateFuncs = [];
+    var visualFuncs = [];
+    var themeStorage = {};
+    var loadingEffects = {};
+    var instances$1 = {};
+    var connectedGroups = {};
+    var idBase = +new Date() - 0;
+    var groupIdBase = +new Date() - 0;
+    var DOM_ATTRIBUTE_KEY = '_echarts_instance_';
+    /**
+     * @param opts.devicePixelRatio Use window.devicePixelRatio by default
+     * @param opts.renderer Can choose 'canvas' or 'svg' to render the chart.
+     * @param opts.width Use clientWidth of the input `dom` by default.
+     *        Can be 'auto' (the same as null/undefined)
+     * @param opts.height Use clientHeight of the input `dom` by default.
+     *        Can be 'auto' (the same as null/undefined)
+     */
+
+    function init$1(dom, theme, opts) {
+      if ("development" !== 'production') {
+        if (!dom) {
+          throw new Error('Initialize failed: invalid dom.');
+        }
+      }
+
+      var existInstance = getInstanceByDom(dom);
+
+      if (existInstance) {
+        if ("development" !== 'production') {
+          console.warn('There is a chart instance already initialized on the dom.');
+        }
+
+        return existInstance;
+      }
+
+      if ("development" !== 'production') {
+        if (isDom(dom) && dom.nodeName.toUpperCase() !== 'CANVAS' && (!dom.clientWidth && (!opts || opts.width == null) || !dom.clientHeight && (!opts || opts.height == null))) {
+          console.warn('Can\'t get DOM width or height. Please check ' + 'dom.clientWidth and dom.clientHeight. They should not be 0.' + 'For example, you may need to call this in the callback ' + 'of window.onload.');
+        }
+      }
+
+      var chart = new ECharts(dom, theme, opts);
+      chart.id = 'ec_' + idBase++;
+      instances$1[chart.id] = chart;
+      setAttribute(dom, DOM_ATTRIBUTE_KEY, chart.id);
+      enableConnect(chart);
+      each$3(postInitFuncs, function (postInitFunc) {
+        postInitFunc(chart);
+      });
+      return chart;
+    }
+    /**
+     * @usage
+     * (A)
+     * ```js
+     * let chart1 = echarts.init(dom1);
+     * let chart2 = echarts.init(dom2);
+     * chart1.group = 'xxx';
+     * chart2.group = 'xxx';
+     * echarts.connect('xxx');
+     * ```
+     * (B)
+     * ```js
+     * let chart1 = echarts.init(dom1);
+     * let chart2 = echarts.init(dom2);
+     * echarts.connect('xxx', [chart1, chart2]);
+     * ```
+     */
+
+    function connect(groupId) {
+      // Is array of charts
+      if (isArray(groupId)) {
+        var charts = groupId;
+        groupId = null; // If any chart has group
+
+        each$3(charts, function (chart) {
+          if (chart.group != null) {
+            groupId = chart.group;
+          }
+        });
+        groupId = groupId || 'g_' + groupIdBase++;
+        each$3(charts, function (chart) {
+          chart.group = groupId;
+        });
+      }
+
+      connectedGroups[groupId] = true;
+      return groupId;
+    }
+    /**
+     * @deprecated
+     */
+
+    function disConnect(groupId) {
+      connectedGroups[groupId] = false;
+    }
+    /**
+     * Alias and backword compat
+     */
+
+    var disconnect = disConnect;
+    /**
+     * Dispose a chart instance
+     */
+
+    function dispose$1(chart) {
+      if (typeof chart === 'string') {
+        chart = instances$1[chart];
+      } else if (!(chart instanceof ECharts)) {
+        // Try to treat as dom
+        chart = getInstanceByDom(chart);
+      }
+
+      if (chart instanceof ECharts && !chart.isDisposed()) {
+        chart.dispose();
+      }
+    }
+    function getInstanceByDom(dom) {
+      return instances$1[getAttribute(dom, DOM_ATTRIBUTE_KEY)];
+    }
+    function getInstanceById(key) {
+      return instances$1[key];
+    }
+    /**
+     * Register theme
+     */
+
+    function registerTheme(name, theme) {
+      themeStorage[name] = theme;
+    }
+    /**
+     * Register option preprocessor
+     */
+
+    function registerPreprocessor(preprocessorFunc) {
+      if (indexOf$1(optionPreprocessorFuncs, preprocessorFunc) < 0) {
+        optionPreprocessorFuncs.push(preprocessorFunc);
+      }
+    }
+    function registerProcessor(priority, processor) {
+      normalizeRegister(dataProcessorFuncs, priority, processor, PRIORITY_PROCESSOR_DEFAULT);
+    }
+    /**
+     * Register postIniter
+     * @param {Function} postInitFunc
+     */
+
+    function registerPostInit(postInitFunc) {
+      if (indexOf$1(postInitFuncs, postInitFunc) < 0) {
+        postInitFunc && postInitFuncs.push(postInitFunc);
+      }
+    }
+    /**
+     * Register postUpdater
+     * @param {Function} postUpdateFunc
+     */
+
+    function registerPostUpdate(postUpdateFunc) {
+      if (indexOf$1(postUpdateFuncs, postUpdateFunc) < 0) {
+        postUpdateFunc && postUpdateFuncs.push(postUpdateFunc);
+      }
+    }
+    function registerAction(actionInfo, eventName, action) {
+      if (typeof eventName === 'function') {
+        action = eventName;
+        eventName = '';
+      }
+
+      var actionType = isObject$2(actionInfo) ? actionInfo.type : [actionInfo, actionInfo = {
+        event: eventName
+      }][0]; // Event name is all lowercase
+
+      actionInfo.event = (actionInfo.event || actionType).toLowerCase();
+      eventName = actionInfo.event;
+
+      if (eventActionMap[eventName]) {
+        // Already registered.
+        return;
+      } // Validate action type and event name.
+
+
+      assert$1(ACTION_REG.test(actionType) && ACTION_REG.test(eventName));
+
+      if (!actions[actionType]) {
+        actions[actionType] = {
+          action: action,
+          actionInfo: actionInfo
+        };
+      }
+
+      eventActionMap[eventName] = actionType;
+    }
+    function registerCoordinateSystem(type, coordSysCreator) {
+      CoordinateSystemManager.register(type, coordSysCreator);
+    }
+    /**
+     * Get dimensions of specified coordinate system.
+     * @param {string} type
+     * @return {Array.<string|Object>}
+     */
+
+    function getCoordinateSystemDimensions(type) {
+      var coordSysCreator = CoordinateSystemManager.get(type);
+
+      if (coordSysCreator) {
+        return coordSysCreator.getDimensionsInfo ? coordSysCreator.getDimensionsInfo() : coordSysCreator.dimensions.slice();
+      }
+    }
+
+    function registerLayout(priority, layoutTask) {
+      normalizeRegister(visualFuncs, priority, layoutTask, PRIORITY_VISUAL_LAYOUT, 'layout');
+    }
+
+    function registerVisual(priority, visualTask) {
+      normalizeRegister(visualFuncs, priority, visualTask, PRIORITY_VISUAL_CHART, 'visual');
+    }
+    var registeredTasks = [];
+
+    function normalizeRegister(targetList, priority, fn, defaultPriority, visualType) {
+      if (isFunction$1(priority) || isObject$2(priority)) {
+        fn = priority;
+        priority = defaultPriority;
+      }
+
+      if ("development" !== 'production') {
+        if (isNaN(priority) || priority == null) {
+          throw new Error('Illegal priority');
+        } // Check duplicate
+
+
+        each$3(targetList, function (wrap) {
+          assert$1(wrap.__raw !== fn);
+        });
+      } // Already registered
+
+
+      if (indexOf$1(registeredTasks, fn) >= 0) {
+        return;
+      }
+
+      registeredTasks.push(fn);
+      var stageHandler = Scheduler.wrapStageHandler(fn, visualType);
+      stageHandler.__prio = priority;
+      stageHandler.__raw = fn;
+      targetList.push(stageHandler);
+    }
+
+    function registerLoading(name, loadingFx) {
+      loadingEffects[name] = loadingFx;
+    }
+    /**
+     * ZRender need a canvas context to do measureText.
+     * But in node environment canvas may be created by node-canvas.
+     * So we need to specify how to create a canvas instead of using document.createElement('canvas')
+     *
+     * Be careful of using it in the browser.
+     *
+     * @example
+     *     let Canvas = require('canvas');
+     *     let echarts = require('echarts');
+     *     echarts.setCanvasCreator(function () {
+     *         // Small size is enough.
+     *         return new Canvas(32, 32);
+     *     });
+     */
+
+    function setCanvasCreator(creator) {
+      $override('createCanvas', creator);
+    }
+    /**
+     * The parameters and usage: see `mapDataStorage.registerMap`.
+     * Compatible with previous `echarts.registerMap`.
+     */
+
+    function registerMap(mapName, geoJson, specialAreas) {
+      mapDataStorage.registerMap(mapName, geoJson, specialAreas);
+    }
+    function getMap(mapName) {
+      // For backward compatibility, only return the first one.
+      var records = mapDataStorage.retrieveMap(mapName); // FIXME support SVG, where return not only records[0].
+
+      return records && records[0] && {
+        // @ts-ignore
+        geoJson: records[0].geoJSON,
+        specialAreas: records[0].specialAreas
+      };
+    }
+    var registerTransform = registerExternalTransform;
+    /**
+     * Globa dispatchAction to a specified chart instance.
+     */
+    // export function dispatchAction(payload: { chartId: string } & Payload, opt?: Parameters<ECharts['dispatchAction']>[1]) {
+    //     if (!payload || !payload.chartId) {
+    //         // Must have chartId to find chart
+    //         return;
+    //     }
+    //     const chart = instances[payload.chartId];
+    //     if (chart) {
+    //         chart.dispatchAction(payload, opt);
+    //     }
+    // }
+    // Buitlin global visual
+
+    registerVisual(PRIORITY_VISUAL_GLOBAL, seriesStyleTask);
+    registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataStyleTask);
+    registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataColorPaletteTask);
+    registerVisual(PRIORITY_VISUAL_GLOBAL, seriesSymbolTask);
+    registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataSymbolTask);
+    registerVisual(PRIORITY_VISUAL_DECAL, decalVisual);
+    registerPreprocessor(globalBackwardCompat);
+    registerProcessor(PRIORITY_PROCESSOR_DATASTACK, dataStack);
+    registerLoading('default', defaultLoading); // Default actions
+
+    registerAction({
+      type: HIGHLIGHT_ACTION_TYPE,
+      event: HIGHLIGHT_ACTION_TYPE,
+      update: HIGHLIGHT_ACTION_TYPE
+    }, noop);
+    registerAction({
+      type: DOWNPLAY_ACTION_TYPE,
+      event: DOWNPLAY_ACTION_TYPE,
+      update: DOWNPLAY_ACTION_TYPE
+    }, noop);
+    registerAction({
+      type: SELECT_ACTION_TYPE,
+      event: SELECT_ACTION_TYPE,
+      update: SELECT_ACTION_TYPE
+    }, noop);
+    registerAction({
+      type: UNSELECT_ACTION_TYPE,
+      event: UNSELECT_ACTION_TYPE,
+      update: UNSELECT_ACTION_TYPE
+    }, noop);
+    registerAction({
+      type: TOGGLE_SELECT_ACTION_TYPE,
+      event: TOGGLE_SELECT_ACTION_TYPE,
+      update: TOGGLE_SELECT_ACTION_TYPE
+    }, noop); // Default theme
+
+    registerTheme('light', lightTheme);
+    registerTheme('dark', theme); // For backward compatibility, where the namespace `dataTool` will
+    // be mounted on `echarts` is the extension `dataTool` is imported.
+
+    var dataTool = {};
+
+    var extensions = [];
+    var extensionRegisters = {
+      registerPreprocessor: registerPreprocessor,
+      registerProcessor: registerProcessor,
+      registerPostInit: registerPostInit,
+      registerPostUpdate: registerPostUpdate,
+      registerAction: registerAction,
+      registerCoordinateSystem: registerCoordinateSystem,
+      registerLayout: registerLayout,
+      registerVisual: registerVisual,
+      registerTransform: registerTransform,
+      registerLoading: registerLoading,
+      registerMap: registerMap,
+      PRIORITY: PRIORITY,
+      ComponentModel: ComponentModel,
+      ComponentView: ComponentView,
+      SeriesModel: SeriesModel,
+      ChartView: ChartView,
+      // TODO Use ComponentModel and SeriesModel instead of Constructor
+      registerComponentModel: function (ComponentModelClass) {
+        ComponentModel.registerClass(ComponentModelClass);
+      },
+      registerComponentView: function (ComponentViewClass) {
+        ComponentView.registerClass(ComponentViewClass);
+      },
+      registerSeriesModel: function (SeriesModelClass) {
+        SeriesModel.registerClass(SeriesModelClass);
+      },
+      registerChartView: function (ChartViewClass) {
+        ChartView.registerClass(ChartViewClass);
+      },
+      registerSubTypeDefaulter: function (componentType, defaulter) {
+        ComponentModel.registerSubTypeDefaulter(componentType, defaulter);
+      },
+      registerPainter: function (painterType, PainterCtor) {
+        registerPainter(painterType, PainterCtor);
+      }
+    };
+    function use(ext) {
+      if (isArray(ext)) {
+        // use([ChartLine, ChartBar]);
+        each(ext, function (singleExt) {
+          use(singleExt);
+        });
+        return;
+      }
+
+      if (indexOf(extensions, ext) >= 0) {
+        return;
+      }
+
+      extensions.push(ext);
+
+      if (isFunction(ext)) {
+        ext = {
+          install: ext
+        };
+      }
+
+      ext.install(extensionRegisters);
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function dataIndexMapValueLength(valNumOrArrLengthMoreThan2) {
+      return valNumOrArrLengthMoreThan2 == null ? 0 : valNumOrArrLengthMoreThan2.length || 1;
+    }
+
+    function defaultKeyGetter(item) {
+      return item;
+    }
+
+    var DataDiffer =
+    /** @class */
+    function () {
+      /**
+       * @param context Can be visited by this.context in callback.
+       */
+      function DataDiffer(oldArr, newArr, oldKeyGetter, newKeyGetter, context, // By default: 'oneToOne'.
+      diffMode) {
+        this._old = oldArr;
+        this._new = newArr;
+        this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;
+        this._newKeyGetter = newKeyGetter || defaultKeyGetter; // Visible in callback via `this.context`;
+
+        this.context = context;
+        this._diffModeMultiple = diffMode === 'multiple';
+      }
+      /**
+       * Callback function when add a data
+       */
+
+
+      DataDiffer.prototype.add = function (func) {
+        this._add = func;
+        return this;
+      };
+      /**
+       * Callback function when update a data
+       */
+
+
+      DataDiffer.prototype.update = function (func) {
+        this._update = func;
+        return this;
+      };
+      /**
+       * Callback function when update a data and only work in `cbMode: 'byKey'`.
+       */
+
+
+      DataDiffer.prototype.updateManyToOne = function (func) {
+        this._updateManyToOne = func;
+        return this;
+      };
+      /**
+       * Callback function when update a data and only work in `cbMode: 'byKey'`.
+       */
+
+
+      DataDiffer.prototype.updateOneToMany = function (func) {
+        this._updateOneToMany = func;
+        return this;
+      };
+      /**
+       * Callback function when remove a data
+       */
+
+
+      DataDiffer.prototype.remove = function (func) {
+        this._remove = func;
+        return this;
+      };
+
+      DataDiffer.prototype.execute = function () {
+        this[this._diffModeMultiple ? '_executeMultiple' : '_executeOneToOne']();
+      };
+
+      DataDiffer.prototype._executeOneToOne = function () {
+        var oldArr = this._old;
+        var newArr = this._new;
+        var newDataIndexMap = {};
+        var oldDataKeyArr = new Array(oldArr.length);
+        var newDataKeyArr = new Array(newArr.length);
+
+        this._initIndexMap(oldArr, null, oldDataKeyArr, '_oldKeyGetter');
+
+        this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');
+
+        for (var i = 0; i < oldArr.length; i++) {
+          var oldKey = oldDataKeyArr[i];
+          var newIdxMapVal = newDataIndexMap[oldKey];
+          var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal); // idx can never be empty array here. see 'set null' logic below.
+
+          if (newIdxMapValLen > 1) {
+            // Consider there is duplicate key (for example, use dataItem.name as key).
+            // We should make sure every item in newArr and oldArr can be visited.
+            var newIdx = newIdxMapVal.shift();
+
+            if (newIdxMapVal.length === 1) {
+              newDataIndexMap[oldKey] = newIdxMapVal[0];
+            }
+
+            this._update && this._update(newIdx, i);
+          } else if (newIdxMapValLen === 1) {
+            newDataIndexMap[oldKey] = null;
+            this._update && this._update(newIdxMapVal, i);
+          } else {
+            this._remove && this._remove(i);
+          }
+        }
+
+        this._performRestAdd(newDataKeyArr, newDataIndexMap);
+      };
+      /**
+       * For example, consider the case:
+       * oldData: [o0, o1, o2, o3, o4, o5, o6, o7],
+       * newData: [n0, n1, n2, n3, n4, n5, n6, n7, n8],
+       * Where:
+       *     o0, o1, n0 has key 'a' (many to one)
+       *     o5, n4, n5, n6 has key 'b' (one to many)
+       *     o2, n1 has key 'c' (one to one)
+       *     n2, n3 has key 'd' (add)
+       *     o3, o4 has key 'e' (remove)
+       *     o6, o7, n7, n8 has key 'f' (many to many, treated as add and remove)
+       * Then:
+       *     (The order of the following directives are not ensured.)
+       *     this._updateManyToOne(n0, [o0, o1]);
+       *     this._updateOneToMany([n4, n5, n6], o5);
+       *     this._update(n1, o2);
+       *     this._remove(o3);
+       *     this._remove(o4);
+       *     this._remove(o6);
+       *     this._remove(o7);
+       *     this._add(n2);
+       *     this._add(n3);
+       *     this._add(n7);
+       *     this._add(n8);
+       */
+
+
+      DataDiffer.prototype._executeMultiple = function () {
+        var oldArr = this._old;
+        var newArr = this._new;
+        var oldDataIndexMap = {};
+        var newDataIndexMap = {};
+        var oldDataKeyArr = [];
+        var newDataKeyArr = [];
+
+        this._initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, '_oldKeyGetter');
+
+        this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');
+
+        for (var i = 0; i < oldDataKeyArr.length; i++) {
+          var oldKey = oldDataKeyArr[i];
+          var oldIdxMapVal = oldDataIndexMap[oldKey];
+          var newIdxMapVal = newDataIndexMap[oldKey];
+          var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal);
+          var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+
+          if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) {
+            this._updateManyToOne && this._updateManyToOne(newIdxMapVal, oldIdxMapVal);
+            newDataIndexMap[oldKey] = null;
+          } else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) {
+            this._updateOneToMany && this._updateOneToMany(newIdxMapVal, oldIdxMapVal);
+            newDataIndexMap[oldKey] = null;
+          } else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) {
+            this._update && this._update(newIdxMapVal, oldIdxMapVal);
+            newDataIndexMap[oldKey] = null;
+          } else if (oldIdxMapValLen > 1) {
+            for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) {
+              this._remove && this._remove(oldIdxMapVal[i_1]);
+            }
+          } else {
+            this._remove && this._remove(oldIdxMapVal);
+          }
+        }
+
+        this._performRestAdd(newDataKeyArr, newDataIndexMap);
+      };
+
+      DataDiffer.prototype._performRestAdd = function (newDataKeyArr, newDataIndexMap) {
+        for (var i = 0; i < newDataKeyArr.length; i++) {
+          var newKey = newDataKeyArr[i];
+          var newIdxMapVal = newDataIndexMap[newKey];
+          var idxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+
+          if (idxMapValLen > 1) {
+            for (var j = 0; j < idxMapValLen; j++) {
+              this._add && this._add(newIdxMapVal[j]);
+            }
+          } else if (idxMapValLen === 1) {
+            this._add && this._add(newIdxMapVal);
+          } // Support both `newDataKeyArr` are duplication removed or not removed.
+
+
+          newDataIndexMap[newKey] = null;
+        }
+      };
+
+      DataDiffer.prototype._initIndexMap = function (arr, // Can be null.
+      map, // In 'byKey', the output `keyArr` is duplication removed.
+      // In 'byIndex', the output `keyArr` is not duplication removed and
+      //     its indices are accurately corresponding to `arr`.
+      keyArr, keyGetterName) {
+        var cbModeMultiple = this._diffModeMultiple;
+
+        for (var i = 0; i < arr.length; i++) {
+          // Add prefix to avoid conflict with Object.prototype.
+          var key = '_ec_' + this[keyGetterName](arr[i], i);
+
+          if (!cbModeMultiple) {
+            keyArr[i] = key;
+          }
+
+          if (!map) {
+            continue;
+          }
+
+          var idxMapVal = map[key];
+          var idxMapValLen = dataIndexMapValueLength(idxMapVal);
+
+          if (idxMapValLen === 0) {
+            // Simple optimize: in most cases, one index has one key,
+            // do not need array.
+            map[key] = i;
+
+            if (cbModeMultiple) {
+              keyArr.push(key);
+            }
+          } else if (idxMapValLen === 1) {
+            map[key] = [idxMapVal, i];
+          } else {
+            idxMapVal.push(i);
+          }
+        }
+      };
+
+      return DataDiffer;
+    }();
+
+    function summarizeDimensions(data) {
+      var summary = {};
+      var encode = summary.encode = {};
+      var notExtraCoordDimMap = createHashMap();
+      var defaultedLabel = [];
+      var defaultedTooltip = []; // See the comment of `List.js#userOutput`.
+
+      var userOutput = summary.userOutput = {
+        dimensionNames: data.dimensions.slice(),
+        encode: {}
+      };
+      each(data.dimensions, function (dimName) {
+        var dimItem = data.getDimensionInfo(dimName);
+        var coordDim = dimItem.coordDim;
+
+        if (coordDim) {
+          if ("development" !== 'production') {
+            assert(VISUAL_DIMENSIONS.get(coordDim) == null);
+          }
+
+          var coordDimIndex = dimItem.coordDimIndex;
+          getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;
+
+          if (!dimItem.isExtraCoord) {
+            notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,
+            // because when dataset is used, it is hard to guess which dimension
+            // can be value dimension. If both show x, y on label is not look good,
+            // and conventionally y axis is focused more.
+
+            if (mayLabelDimType(dimItem.type)) {
+              defaultedLabel[0] = dimName;
+            } // User output encode do not contain generated coords.
+            // And it only has index. User can use index to retrieve value from the raw item array.
+
+
+            getOrCreateEncodeArr(userOutput.encode, coordDim)[coordDimIndex] = dimItem.index;
+          }
+
+          if (dimItem.defaultTooltip) {
+            defaultedTooltip.push(dimName);
+          }
+        }
+
+        VISUAL_DIMENSIONS.each(function (v, otherDim) {
+          var encodeArr = getOrCreateEncodeArr(encode, otherDim);
+          var dimIndex = dimItem.otherDims[otherDim];
+
+          if (dimIndex != null && dimIndex !== false) {
+            encodeArr[dimIndex] = dimItem.name;
+          }
+        });
+      });
+      var dataDimsOnCoord = [];
+      var encodeFirstDimNotExtra = {};
+      notExtraCoordDimMap.each(function (v, coordDim) {
+        var dimArr = encode[coordDim];
+        encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data
+        // dim canot on more than one coordDim.
+
+        dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);
+      });
+      summary.dataDimsOnCoord = dataDimsOnCoord;
+      summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;
+      var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set
+      // in this way. Use label.formatter instead. May be remove this approach someday.
+
+      if (encodeLabel && encodeLabel.length) {
+        defaultedLabel = encodeLabel.slice();
+      }
+
+      var encodeTooltip = encode.tooltip;
+
+      if (encodeTooltip && encodeTooltip.length) {
+        defaultedTooltip = encodeTooltip.slice();
+      } else if (!defaultedTooltip.length) {
+        defaultedTooltip = defaultedLabel.slice();
+      }
+
+      encode.defaultedLabel = defaultedLabel;
+      encode.defaultedTooltip = defaultedTooltip;
+      return summary;
+    }
+
+    function getOrCreateEncodeArr(encode, dim) {
+      if (!encode.hasOwnProperty(dim)) {
+        encode[dim] = [];
+      }
+
+      return encode[dim];
+    } // FIXME:TS should be type `AxisType`
+
+
+    function getDimensionTypeByAxis(axisType) {
+      return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';
+    }
+
+    function mayLabelDimType(dimType) {
+      // In most cases, ordinal and time do not suitable for label.
+      // Ordinal info can be displayed on axis. Time is too long.
+      return !(dimType === 'ordinal' || dimType === 'time');
+    } // function findTheLastDimMayLabel(data) {
+    //     // Get last value dim
+    //     let dimensions = data.dimensions.slice();
+    //     let valueType;
+    //     let valueDim;
+    //     while (dimensions.length && (
+    //         valueDim = dimensions.pop(),
+    //         valueType = data.getDimensionInfo(valueDim).type,
+    //         valueType === 'ordinal' || valueType === 'time'
+    //     )) {} // jshint ignore:line
+    //     return valueDim;
+    // }
+
+    var DataDimensionInfo =
+    /** @class */
+    function () {
+      /**
+       * @param opt All of the fields will be shallow copied.
+       */
+      function DataDimensionInfo(opt) {
+        /**
+         * The format of `otherDims` is:
+         * ```js
+         * {
+         *     tooltip: number optional,
+         *     label: number optional,
+         *     itemName: number optional,
+         *     seriesName: number optional,
+         * }
+         * ```
+         *
+         * A `series.encode` can specified these fields:
+         * ```js
+         * encode: {
+         *     // "3, 1, 5" is the index of data dimension.
+         *     tooltip: [3, 1, 5],
+         *     label: [0, 3],
+         *     ...
+         * }
+         * ```
+         * `otherDims` is the parse result of the `series.encode` above, like:
+         * ```js
+         * // Suppose the index of this data dimension is `3`.
+         * this.otherDims = {
+         *     // `3` is at the index `0` of the `encode.tooltip`
+         *     tooltip: 0,
+         *     // `3` is at the index `1` of the `encode.tooltip`
+         *     label: 1
+         * };
+         * ```
+         *
+         * This prop should never be `null`/`undefined` after initialized.
+         */
+        this.otherDims = {};
+
+        if (opt != null) {
+          extend(this, opt);
+        }
+      }
+
+      return DataDimensionInfo;
+    }();
+
+    var mathFloor = Math.floor;
+    var isObject$3 = isObject;
+    var map$1 = map;
+    var UNDEFINED = 'undefined';
+    var INDEX_NOT_FOUND = -1; // Use prefix to avoid index to be the same as otherIdList[idx],
+    // which will cause weird udpate animation.
+
+    var ID_PREFIX = 'e\0\0';
+    var dataCtors = {
+      'float': typeof Float64Array === UNDEFINED ? Array : Float64Array,
+      'int': typeof Int32Array === UNDEFINED ? Array : Int32Array,
+      // Ordinal data type can be string or int
+      'ordinal': Array,
+      'number': Array,
+      'time': Array
+    }; // Caution: MUST not use `new CtorUint32Array(arr, 0, len)`, because the Ctor of array is
+    // different from the Ctor of typed array.
+
+    var CtorUint32Array = typeof Uint32Array === UNDEFINED ? Array : Uint32Array;
+    var CtorInt32Array = typeof Int32Array === UNDEFINED ? Array : Int32Array;
+    var CtorUint16Array = typeof Uint16Array === UNDEFINED ? Array : Uint16Array;
+    var TRANSFERABLE_PROPERTIES = ['hasItemOption', '_nameList', '_idList', '_invertedIndicesMap', '_rawData', '_dimValueGetter', '_count', '_rawCount', '_nameDimIdx', '_idDimIdx', '_nameRepeatCount'];
+    var CLONE_PROPERTIES = ['_extent', '_approximateExtent', '_rawExtent']; // -----------------------------
+    // Internal method declarations:
+    // -----------------------------
+
+    var defaultDimValueGetters;
+    var prepareInvertedIndex;
+    var getIndicesCtor;
+    var prepareStorage;
+    var getRawIndexWithoutIndices;
+    var getRawIndexWithIndices;
+    var getId;
+    var getIdNameFromStore;
+    var makeIdFromName;
+    var normalizeDimensions;
+    var validateDimensions;
+    var cloneListForMapAndSample;
+    var getInitialExtent;
+    var setItemDataAndSeriesIndex;
+    var transferProperties;
+
+    var List =
+    /** @class */
+    function () {
+      /**
+       * @param dimensions
+       *        For example, ['someDimName', {name: 'someDimName', type: 'someDimType'}, ...].
+       *        Dimensions should be concrete names like x, y, z, lng, lat, angle, radius
+       */
+      function List(dimensions, hostModel) {
+        this.type = 'list';
+        this._count = 0;
+        this._rawCount = 0;
+        this._storage = {}; // We have an extra array store here. It's faster to be acessed than KV structured `_storage`.
+        // We profile the code `storage[dim]` and it seems to be KeyedLoadIC_Megamorphic instead of fast property access.
+        // Not sure why this happens. But using an extra array seems leads to faster `initData`
+        // See https://github.com/apache/incubator-echarts/pull/13314 for more explanation.
+
+        this._storageArr = [];
+        this._nameList = [];
+        this._idList = []; // Models of data option is stored sparse for optimizing memory cost
+        // Never used yet (not used yet).
+        // private _optionModels: Model[] = [];
+        // Global visual properties after visual coding
+
+        this._visual = {}; // Globel layout properties.
+
+        this._layout = {}; // Item visual properties after visual coding
+
+        this._itemVisuals = []; // Item layout properties after layout
+
+        this._itemLayouts = []; // Graphic elemnents
+
+        this._graphicEls = []; // Raw extent will not be cloned, but only transfered.
+        // It will not be calculated util needed.
+
+        this._rawExtent = {};
+        this._extent = {}; // key: dim, value: extent
+
+        this._approximateExtent = {};
+        this._calculationInfo = {}; // Having detected that there is data item is non primitive type
+        // (in type `OptionDataItemObject`).
+        // Like `data: [ { value: xx, itemStyle: {...} }, ...]`
+        // At present it only happen in `SOURCE_FORMAT_ORIGINAL`.
+
+        this.hasItemOption = true; // Methods that create a new list based on this list should be listed here.
+        // Notice that those method should `RETURN` the new list.
+
+        this.TRANSFERABLE_METHODS = ['cloneShallow', 'downSample', 'lttbDownSample', 'map']; // Methods that change indices of this list should be listed here.
+
+        this.CHANGABLE_METHODS = ['filterSelf', 'selectRange'];
+        this.DOWNSAMPLE_METHODS = ['downSample', 'lttbDownSample'];
+        /**
+         * Get raw data index.
+         * Do not initialize.
+         * Default `getRawIndex`. And it can be changed.
+         */
+
+        this.getRawIndex = getRawIndexWithoutIndices;
+        dimensions = dimensions || ['x', 'y'];
+        var dimensionInfos = {};
+        var dimensionNames = [];
+        var invertedIndicesMap = {};
+
+        for (var i = 0; i < dimensions.length; i++) {
+          // Use the original dimensions[i], where other flag props may exists.
+          var dimInfoInput = dimensions[i];
+          var dimensionInfo = isString(dimInfoInput) ? new DataDimensionInfo({
+            name: dimInfoInput
+          }) : !(dimInfoInput instanceof DataDimensionInfo) ? new DataDimensionInfo(dimInfoInput) : dimInfoInput;
+          var dimensionName = dimensionInfo.name;
+          dimensionInfo.type = dimensionInfo.type || 'float';
+
+          if (!dimensionInfo.coordDim) {
+            dimensionInfo.coordDim = dimensionName;
+            dimensionInfo.coordDimIndex = 0;
+          }
+
+          var otherDims = dimensionInfo.otherDims = dimensionInfo.otherDims || {};
+          dimensionNames.push(dimensionName);
+          dimensionInfos[dimensionName] = dimensionInfo;
+          dimensionInfo.index = i;
+
+          if (dimensionInfo.createInvertedIndices) {
+            invertedIndicesMap[dimensionName] = [];
+          }
+
+          if (otherDims.itemName === 0) {
+            this._nameDimIdx = i;
+            this._nameOrdinalMeta = dimensionInfo.ordinalMeta;
+          }
+
+          if (otherDims.itemId === 0) {
+            this._idDimIdx = i;
+            this._idOrdinalMeta = dimensionInfo.ordinalMeta;
+          }
+        }
+
+        this.dimensions = dimensionNames;
+        this._dimensionInfos = dimensionInfos;
+        this.hostModel = hostModel; // Cache summary info for fast visit. See "dimensionHelper".
+
+        this._dimensionsSummary = summarizeDimensions(this);
+        this._invertedIndicesMap = invertedIndicesMap;
+        this.userOutput = this._dimensionsSummary.userOutput;
+      }
+      /**
+       * The meanings of the input parameter `dim`:
+       *
+       * + If dim is a number (e.g., `1`), it means the index of the dimension.
+       *   For example, `getDimension(0)` will return 'x' or 'lng' or 'radius'.
+       * + If dim is a number-like string (e.g., `"1"`):
+       *     + If there is the same concrete dim name defined in `this.dimensions`, it means that concrete name.
+       *     + If not, it will be converted to a number, which means the index of the dimension.
+       *        (why? because of the backward compatbility. We have been tolerating number-like string in
+       *        dimension setting, although now it seems that it is not a good idea.)
+       *     For example, `visualMap[i].dimension: "1"` is the same meaning as `visualMap[i].dimension: 1`,
+       *     if no dimension name is defined as `"1"`.
+       * + If dim is a not-number-like string, it means the concrete dim name.
+       *   For example, it can be be default name `"x"`, `"y"`, `"z"`, `"lng"`, `"lat"`, `"angle"`, `"radius"`,
+       *   or customized in `dimensions` property of option like `"age"`.
+       *
+       * Get dimension name
+       * @param dim See above.
+       * @return Concrete dim name.
+       */
+
+
+      List.prototype.getDimension = function (dim) {
+        if (typeof dim === 'number' // If being a number-like string but not being defined a dimension name.
+        || !isNaN(dim) && !this._dimensionInfos.hasOwnProperty(dim)) {
+          dim = this.dimensions[dim];
+        }
+
+        return dim;
+      };
+      /**
+       * Get type and calculation info of particular dimension
+       * @param dim
+       *        Dimension can be concrete names like x, y, z, lng, lat, angle, radius
+       *        Or a ordinal number. For example getDimensionInfo(0) will return 'x' or 'lng' or 'radius'
+       */
+
+
+      List.prototype.getDimensionInfo = function (dim) {
+        // Do not clone, because there may be categories in dimInfo.
+        return this._dimensionInfos[this.getDimension(dim)];
+      };
+      /**
+       * concrete dimension name list on coord.
+       */
+
+
+      List.prototype.getDimensionsOnCoord = function () {
+        return this._dimensionsSummary.dataDimsOnCoord.slice();
+      };
+
+      List.prototype.mapDimension = function (coordDim, idx) {
+        var dimensionsSummary = this._dimensionsSummary;
+
+        if (idx == null) {
+          return dimensionsSummary.encodeFirstDimNotExtra[coordDim];
+        }
+
+        var dims = dimensionsSummary.encode[coordDim];
+        return dims ? dims[idx] : null;
+      };
+
+      List.prototype.mapDimensionsAll = function (coordDim) {
+        var dimensionsSummary = this._dimensionsSummary;
+        var dims = dimensionsSummary.encode[coordDim];
+        return (dims || []).slice();
+      };
+      /**
+       * Initialize from data
+       * @param data source or data or data provider.
+       * @param nameList The name of a datum is used on data diff and
+       *        default label/tooltip.
+       *        A name can be specified in encode.itemName,
+       *        or dataItem.name (only for series option data),
+       *        or provided in nameList from outside.
+       */
+
+
+      List.prototype.initData = function (data, nameList, dimValueGetter) {
+        var notProvider = isSourceInstance(data) || isArrayLike(data);
+        var provider = notProvider ? new DefaultDataProvider(data, this.dimensions.length) : data;
+
+        if ("development" !== 'production') {
+          assert(notProvider || isFunction(provider.getItem) && isFunction(provider.count), 'Inavlid data provider.');
+        }
+
+        this._rawData = provider;
+        var sourceFormat = provider.getSource().sourceFormat; // Clear
+
+        this._storage = {};
+        this._indices = null;
+        this._dontMakeIdFromName = this._idDimIdx != null || sourceFormat === SOURCE_FORMAT_TYPED_ARRAY // Cosndier performance.
+        || !!provider.fillStorage;
+        this._nameList = (nameList || []).slice();
+        this._idList = [];
+        this._nameRepeatCount = {};
+
+        if (!dimValueGetter) {
+          this.hasItemOption = false;
+        }
+
+        this.defaultDimValueGetter = defaultDimValueGetters[sourceFormat]; // Default dim value getter
+
+        this._dimValueGetter = dimValueGetter = dimValueGetter || this.defaultDimValueGetter;
+        this._dimValueGetterArrayRows = defaultDimValueGetters.arrayRows; // Reset raw extent.
+
+        this._rawExtent = {};
+
+        this._initDataFromProvider(0, provider.count()); // If data has no item option.
+
+
+        if (provider.pure) {
+          this.hasItemOption = false;
+        }
+      };
+
+      List.prototype.getProvider = function () {
+        return this._rawData;
+      };
+      /**
+       * Caution: Can be only called on raw data (before `this._indices` created).
+       */
+
+
+      List.prototype.appendData = function (data) {
+        if ("development" !== 'production') {
+          assert(!this._indices, 'appendData can only be called on raw data.');
+        }
+
+        var rawData = this._rawData;
+        var start = this.count();
+        rawData.appendData(data);
+        var end = rawData.count();
+
+        if (!rawData.persistent) {
+          end += start;
+        }
+
+        this._initDataFromProvider(start, end, true);
+      };
+      /**
+       * Caution: Can be only called on raw data (before `this._indices` created).
+       * This method does not modify `rawData` (`dataProvider`), but only
+       * add values to storage.
+       *
+       * The final count will be increased by `Math.max(values.length, names.length)`.
+       *
+       * @param values That is the SourceType: 'arrayRows', like
+       *        [
+       *            [12, 33, 44],
+       *            [NaN, 43, 1],
+       *            ['-', 'asdf', 0]
+       *        ]
+       *        Each item is exaclty cooresponding to a dimension.
+       */
+
+
+      List.prototype.appendValues = function (values, names) {
+        var storage = this._storage;
+        var dimensions = this.dimensions;
+        var dimLen = dimensions.length;
+        var rawExtent = this._rawExtent;
+        var start = this.count();
+        var end = start + Math.max(values.length, names ? names.length : 0);
+
+        for (var i = 0; i < dimLen; i++) {
+          var dim = dimensions[i];
+
+          if (!rawExtent[dim]) {
+            rawExtent[dim] = getInitialExtent();
+          }
+
+          prepareStorage(storage, this._dimensionInfos[dim], end, true);
+        }
+
+        var rawExtentArr = map$1(dimensions, function (dim) {
+          return rawExtent[dim];
+        });
+        var storageArr = this._storageArr = map$1(dimensions, function (dim) {
+          return storage[dim];
+        });
+        var emptyDataItem = [];
+
+        for (var idx = start; idx < end; idx++) {
+          var sourceIdx = idx - start; // Store the data by dimensions
+
+          for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) {
+            var dim = dimensions[dimIdx];
+
+            var val = this._dimValueGetterArrayRows(values[sourceIdx] || emptyDataItem, dim, sourceIdx, dimIdx);
+
+            storageArr[dimIdx][idx] = val;
+            var dimRawExtent = rawExtentArr[dimIdx];
+            val < dimRawExtent[0] && (dimRawExtent[0] = val);
+            val > dimRawExtent[1] && (dimRawExtent[1] = val);
+          }
+
+          if (names) {
+            this._nameList[idx] = names[sourceIdx];
+
+            if (!this._dontMakeIdFromName) {
+              makeIdFromName(this, idx);
+            }
+          }
+        }
+
+        this._rawCount = this._count = end; // Reset data extent
+
+        this._extent = {};
+        prepareInvertedIndex(this);
+      };
+
+      List.prototype._initDataFromProvider = function (start, end, append) {
+        if (start >= end) {
+          return;
+        }
+
+        var rawData = this._rawData;
+        var storage = this._storage;
+        var dimensions = this.dimensions;
+        var dimLen = dimensions.length;
+        var dimensionInfoMap = this._dimensionInfos;
+        var nameList = this._nameList;
+        var idList = this._idList;
+        var rawExtent = this._rawExtent;
+        var sourceFormat = rawData.getSource().sourceFormat;
+        var isFormatOriginal = sourceFormat === SOURCE_FORMAT_ORIGINAL;
+
+        for (var i = 0; i < dimLen; i++) {
+          var dim = dimensions[i];
+
+          if (!rawExtent[dim]) {
+            rawExtent[dim] = getInitialExtent();
+          }
+
+          prepareStorage(storage, dimensionInfoMap[dim], end, append);
+        }
+
+        var storageArr = this._storageArr = map$1(dimensions, function (dim) {
+          return storage[dim];
+        });
+        var rawExtentArr = map$1(dimensions, function (dim) {
+          return rawExtent[dim];
+        });
+
+        if (rawData.fillStorage) {
+          rawData.fillStorage(start, end, storageArr, rawExtentArr);
+        } else {
+          var dataItem = [];
+
+          for (var idx = start; idx < end; idx++) {
+            // NOTICE: Try not to write things into dataItem
+            dataItem = rawData.getItem(idx, dataItem); // Each data item is value
+            // [1, 2]
+            // 2
+            // Bar chart, line chart which uses category axis
+            // only gives the 'y' value. 'x' value is the indices of category
+            // Use a tempValue to normalize the value to be a (x, y) value
+            // Store the data by dimensions
+
+            for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) {
+              var dim = dimensions[dimIdx];
+              var dimStorage = storageArr[dimIdx]; // PENDING NULL is empty or zero
+
+              var val = this._dimValueGetter(dataItem, dim, idx, dimIdx);
+
+              dimStorage[idx] = val;
+              var dimRawExtent = rawExtentArr[dimIdx];
+              val < dimRawExtent[0] && (dimRawExtent[0] = val);
+              val > dimRawExtent[1] && (dimRawExtent[1] = val);
+            } // If dataItem is {name: ...} or {id: ...}, it has highest priority.
+            // This kind of ids and names are always stored `_nameList` and `_idList`.
+
+
+            if (isFormatOriginal && !rawData.pure && dataItem) {
+              var itemName = dataItem.name;
+
+              if (nameList[idx] == null && itemName != null) {
+                nameList[idx] = convertOptionIdName(itemName, null);
+              }
+
+              var itemId = dataItem.id;
+
+              if (idList[idx] == null && itemId != null) {
+                idList[idx] = convertOptionIdName(itemId, null);
+              }
+            }
+
+            if (!this._dontMakeIdFromName) {
+              makeIdFromName(this, idx);
+            }
+          }
+        }
+
+        if (!rawData.persistent && rawData.clean) {
+          // Clean unused data if data source is typed array.
+          rawData.clean();
+        }
+
+        this._rawCount = this._count = end; // Reset data extent
+
+        this._extent = {};
+        prepareInvertedIndex(this);
+      };
+
+      List.prototype.count = function () {
+        return this._count;
+      };
+
+      List.prototype.getIndices = function () {
+        var newIndices;
+        var indices = this._indices;
+
+        if (indices) {
+          var Ctor = indices.constructor;
+          var thisCount = this._count; // `new Array(a, b, c)` is different from `new Uint32Array(a, b, c)`.
+
+          if (Ctor === Array) {
+            newIndices = new Ctor(thisCount);
+
+            for (var i = 0; i < thisCount; i++) {
+              newIndices[i] = indices[i];
+            }
+          } else {
+            newIndices = new Ctor(indices.buffer, 0, thisCount);
+          }
+        } else {
+          var Ctor = getIndicesCtor(this);
+          newIndices = new Ctor(this.count());
+
+          for (var i = 0; i < newIndices.length; i++) {
+            newIndices[i] = i;
+          }
+        }
+
+        return newIndices;
+      }; // Get data by index of dimension.
+      // Because in v8 access array by number variable is faster than access object by string variable
+      // Not sure why but the optimization just works.
+
+
+      List.prototype.getByDimIdx = function (dimIdx, idx) {
+        if (!(idx >= 0 && idx < this._count)) {
+          return NaN;
+        }
+
+        var dimStore = this._storageArr[dimIdx];
+        return dimStore ? dimStore[this.getRawIndex(idx)] : NaN;
+      };
+      /**
+       * Get value. Return NaN if idx is out of range.
+       * @param dim Dim must be concrete name.
+       */
+
+
+      List.prototype.get = function (dim, idx) {
+        if (!(idx >= 0 && idx < this._count)) {
+          return NaN;
+        }
+
+        var dimStore = this._storage[dim];
+        return dimStore ? dimStore[this.getRawIndex(idx)] : NaN;
+      };
+      /**
+       * @param dim concrete dim
+       */
+
+
+      List.prototype.getByRawIndex = function (dim, rawIdx) {
+        if (!(rawIdx >= 0 && rawIdx < this._rawCount)) {
+          return NaN;
+        }
+
+        var dimStore = this._storage[dim];
+        return dimStore ? dimStore[rawIdx] : NaN;
+      };
+
+      List.prototype.getValues = function (dimensions, idx) {
+        var values = [];
+
+        if (!isArray(dimensions)) {
+          // stack = idx;
+          idx = dimensions;
+          dimensions = this.dimensions;
+        }
+
+        for (var i = 0, len = dimensions.length; i < len; i++) {
+          values.push(this.get(dimensions[i], idx
+          /*, stack */
+          ));
+        }
+
+        return values;
+      };
+      /**
+       * If value is NaN. Inlcuding '-'
+       * Only check the coord dimensions.
+       */
+
+
+      List.prototype.hasValue = function (idx) {
+        var dataDimsOnCoord = this._dimensionsSummary.dataDimsOnCoord;
+
+        for (var i = 0, len = dataDimsOnCoord.length; i < len; i++) {
+          // Ordinal type originally can be string or number.
+          // But when an ordinal type is used on coord, it can
+          // not be string but only number. So we can also use isNaN.
+          if (isNaN(this.get(dataDimsOnCoord[i], idx))) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+      /**
+       * Get extent of data in one dimension
+       */
+
+
+      List.prototype.getDataExtent = function (dim) {
+        // Make sure use concrete dim as cache name.
+        dim = this.getDimension(dim);
+        var dimData = this._storage[dim];
+        var initialExtent = getInitialExtent(); // stack = !!((stack || false) && this.getCalculationInfo(dim));
+
+        if (!dimData) {
+          return initialExtent;
+        } // Make more strict checkings to ensure hitting cache.
+
+
+        var currEnd = this.count(); // let cacheName = [dim, !!stack].join('_');
+        // let cacheName = dim;
+        // Consider the most cases when using data zoom, `getDataExtent`
+        // happened before filtering. We cache raw extent, which is not
+        // necessary to be cleared and recalculated when restore data.
+
+        var useRaw = !this._indices; // && !stack;
+
+        var dimExtent;
+
+        if (useRaw) {
+          return this._rawExtent[dim].slice();
+        }
+
+        dimExtent = this._extent[dim];
+
+        if (dimExtent) {
+          return dimExtent.slice();
+        }
+
+        dimExtent = initialExtent;
+        var min = dimExtent[0];
+        var max = dimExtent[1];
+
+        for (var i = 0; i < currEnd; i++) {
+          var rawIdx = this.getRawIndex(i);
+          var value = dimData[rawIdx];
+          value < min && (min = value);
+          value > max && (max = value);
+        }
+
+        dimExtent = [min, max];
+        this._extent[dim] = dimExtent;
+        return dimExtent;
+      };
+      /**
+       * PENDING: In fact currently this function is only used to short-circuit
+       * the calling of `scale.unionExtentFromData` when data have been filtered by modules
+       * like "dataZoom". `scale.unionExtentFromData` is used to calculate data extent for series on
+       * an axis, but if a "axis related data filter module" is used, the extent of the axis have
+       * been fixed and no need to calling `scale.unionExtentFromData` actually.
+       * But if we add "custom data filter" in future, which is not "axis related", this method may
+       * be still needed.
+       *
+       * Optimize for the scenario that data is filtered by a given extent.
+       * Consider that if data amount is more than hundreds of thousand,
+       * extent calculation will cost more than 10ms and the cache will
+       * be erased because of the filtering.
+       */
+
+
+      List.prototype.getApproximateExtent = function (dim) {
+        dim = this.getDimension(dim);
+        return this._approximateExtent[dim] || this.getDataExtent(dim);
+      };
+      /**
+       * Calculate extent on a filtered data might be time consuming.
+       * Approximate extent is only used for: calculte extent of filtered data outside.
+       */
+
+
+      List.prototype.setApproximateExtent = function (extent, dim) {
+        dim = this.getDimension(dim);
+        this._approximateExtent[dim] = extent.slice();
+      };
+
+      List.prototype.getCalculationInfo = function (key) {
+        return this._calculationInfo[key];
+      };
+
+      List.prototype.setCalculationInfo = function (key, value) {
+        isObject$3(key) ? extend(this._calculationInfo, key) : this._calculationInfo[key] = value;
+      };
+      /**
+       * Get sum of data in one dimension
+       */
+
+
+      List.prototype.getSum = function (dim) {
+        var dimData = this._storage[dim];
+        var sum = 0;
+
+        if (dimData) {
+          for (var i = 0, len = this.count(); i < len; i++) {
+            var value = this.get(dim, i);
+
+            if (!isNaN(value)) {
+              sum += value;
+            }
+          }
+        }
+
+        return sum;
+      };
+      /**
+       * Get median of data in one dimension
+       */
+
+
+      List.prototype.getMedian = function (dim) {
+        var dimDataArray = []; // map all data of one dimension
+
+        this.each(dim, function (val) {
+          if (!isNaN(val)) {
+            dimDataArray.push(val);
+          }
+        }); // TODO
+        // Use quick select?
+
+        var sortedDimDataArray = dimDataArray.sort(function (a, b) {
+          return a - b;
+        });
+        var len = this.count(); // calculate median
+
+        return len === 0 ? 0 : len % 2 === 1 ? sortedDimDataArray[(len - 1) / 2] : (sortedDimDataArray[len / 2] + sortedDimDataArray[len / 2 - 1]) / 2;
+      }; // /**
+      //  * Retreive the index with given value
+      //  * @param {string} dim Concrete dimension.
+      //  * @param {number} value
+      //  * @return {number}
+      //  */
+      // Currently incorrect: should return dataIndex but not rawIndex.
+      // Do not fix it until this method is to be used somewhere.
+      // FIXME Precision of float value
+      // indexOf(dim, value) {
+      //     let storage = this._storage;
+      //     let dimData = storage[dim];
+      //     let chunkSize = this._chunkSize;
+      //     if (dimData) {
+      //         for (let i = 0, len = this.count(); i < len; i++) {
+      //             let chunkIndex = mathFloor(i / chunkSize);
+      //             let chunkOffset = i % chunkSize;
+      //             if (dimData[chunkIndex][chunkOffset] === value) {
+      //                 return i;
+      //             }
+      //         }
+      //     }
+      //     return -1;
+      // }
+
+      /**
+       * Only support the dimension which inverted index created.
+       * Do not support other cases until required.
+       * @param dim concrete dim
+       * @param value ordinal index
+       * @return rawIndex
+       */
+
+
+      List.prototype.rawIndexOf = function (dim, value) {
+        var invertedIndices = dim && this._invertedIndicesMap[dim];
+
+        if ("development" !== 'production') {
+          if (!invertedIndices) {
+            throw new Error('Do not supported yet');
+          }
+        }
+
+        var rawIndex = invertedIndices[value];
+
+        if (rawIndex == null || isNaN(rawIndex)) {
+          return INDEX_NOT_FOUND;
+        }
+
+        return rawIndex;
+      };
+      /**
+       * Retreive the index with given name
+       */
+
+
+      List.prototype.indexOfName = function (name) {
+        for (var i = 0, len = this.count(); i < len; i++) {
+          if (this.getName(i) === name) {
+            return i;
+          }
+        }
+
+        return -1;
+      };
+      /**
+       * Retreive the index with given raw data index
+       */
+
+
+      List.prototype.indexOfRawIndex = function (rawIndex) {
+        if (rawIndex >= this._rawCount || rawIndex < 0) {
+          return -1;
+        }
+
+        if (!this._indices) {
+          return rawIndex;
+        } // Indices are ascending
+
+
+        var indices = this._indices; // If rawIndex === dataIndex
+
+        var rawDataIndex = indices[rawIndex];
+
+        if (rawDataIndex != null && rawDataIndex < this._count && rawDataIndex === rawIndex) {
+          return rawIndex;
+        }
+
+        var left = 0;
+        var right = this._count - 1;
+
+        while (left <= right) {
+          var mid = (left + right) / 2 | 0;
+
+          if (indices[mid] < rawIndex) {
+            left = mid + 1;
+          } else if (indices[mid] > rawIndex) {
+            right = mid - 1;
+          } else {
+            return mid;
+          }
+        }
+
+        return -1;
+      };
+      /**
+       * Retreive the index of nearest value
+       * @param dim
+       * @param value
+       * @param [maxDistance=Infinity]
+       * @return If and only if multiple indices has
+       *         the same value, they are put to the result.
+       */
+
+
+      List.prototype.indicesOfNearest = function (dim, value, maxDistance) {
+        var storage = this._storage;
+        var dimData = storage[dim];
+        var nearestIndices = [];
+
+        if (!dimData) {
+          return nearestIndices;
+        }
+
+        if (maxDistance == null) {
+          maxDistance = Infinity;
+        }
+
+        var minDist = Infinity;
+        var minDiff = -1;
+        var nearestIndicesLen = 0; // Check the test case of `test/ut/spec/data/List.js`.
+
+        for (var i = 0, len = this.count(); i < len; i++) {
+          var dataIndex = this.getRawIndex(i);
+          var diff = value - dimData[dataIndex];
+          var dist = Math.abs(diff);
+
+          if (dist <= maxDistance) {
+            // When the `value` is at the middle of `this.get(dim, i)` and `this.get(dim, i+1)`,
+            // we'd better not push both of them to `nearestIndices`, otherwise it is easy to
+            // get more than one item in `nearestIndices` (more specifically, in `tooltip`).
+            // So we chose the one that `diff >= 0` in this csae.
+            // But if `this.get(dim, i)` and `this.get(dim, j)` get the same value, both of them
+            // should be push to `nearestIndices`.
+            if (dist < minDist || dist === minDist && diff >= 0 && minDiff < 0) {
+              minDist = dist;
+              minDiff = diff;
+              nearestIndicesLen = 0;
+            }
+
+            if (diff === minDiff) {
+              nearestIndices[nearestIndicesLen++] = i;
+            }
+          }
+        }
+
+        nearestIndices.length = nearestIndicesLen;
+        return nearestIndices;
+      };
+      /**
+       * Get raw data item
+       */
+
+
+      List.prototype.getRawDataItem = function (idx) {
+        if (!this._rawData.persistent) {
+          var val = [];
+
+          for (var i = 0; i < this.dimensions.length; i++) {
+            var dim = this.dimensions[i];
+            val.push(this.get(dim, idx));
+          }
+
+          return val;
+        } else {
+          return this._rawData.getItem(this.getRawIndex(idx));
+        }
+      };
+      /**
+       * @return Never be null/undefined. `number` will be converted to string. Becuase:
+       * In most cases, name is used in display, where returning a string is more convenient.
+       * In other cases, name is used in query (see `indexOfName`), where we can keep the
+       * rule that name `2` equals to name `'2'`.
+       */
+
+
+      List.prototype.getName = function (idx) {
+        var rawIndex = this.getRawIndex(idx);
+        var name = this._nameList[rawIndex];
+
+        if (name == null && this._nameDimIdx != null) {
+          name = getIdNameFromStore(this, this._nameDimIdx, this._nameOrdinalMeta, rawIndex);
+        }
+
+        if (name == null) {
+          name = '';
+        }
+
+        return name;
+      };
+      /**
+       * @return Never null/undefined. `number` will be converted to string. Becuase:
+       * In all cases having encountered at present, id is used in making diff comparison, which
+       * are usually based on hash map. We can keep the rule that the internal id are always string
+       * (treat `2` is the same as `'2'`) to make the related logic simple.
+       */
+
+
+      List.prototype.getId = function (idx) {
+        return getId(this, this.getRawIndex(idx));
+      };
+
+      List.prototype.each = function (dims, cb, ctx, ctxCompat) {
+
+        var _this = this;
+
+        if (!this._count) {
+          return;
+        }
+
+        if (typeof dims === 'function') {
+          ctxCompat = ctx;
+          ctx = cb;
+          cb = dims;
+          dims = [];
+        } // ctxCompat just for compat echarts3
+
+
+        var fCtx = ctx || ctxCompat || this;
+        var dimNames = map$1(normalizeDimensions(dims), this.getDimension, this);
+
+        if ("development" !== 'production') {
+          validateDimensions(this, dimNames);
+        }
+
+        var dimSize = dimNames.length;
+        var dimIndices = map$1(dimNames, function (dimName) {
+          return _this._dimensionInfos[dimName].index;
+        });
+        var storageArr = this._storageArr;
+
+        for (var i = 0, len = this.count(); i < len; i++) {
+          var rawIdx = this.getRawIndex(i); // Simple optimization
+
+          switch (dimSize) {
+            case 0:
+              cb.call(fCtx, i);
+              break;
+
+            case 1:
+              cb.call(fCtx, storageArr[dimIndices[0]][rawIdx], i);
+              break;
+
+            case 2:
+              cb.call(fCtx, storageArr[dimIndices[0]][rawIdx], storageArr[dimIndices[1]][rawIdx], i);
+              break;
+
+            default:
+              var k = 0;
+              var value = [];
+
+              for (; k < dimSize; k++) {
+                value[k] = storageArr[dimIndices[k]][rawIdx];
+              } // Index
+
+
+              value[k] = i;
+              cb.apply(fCtx, value);
+          }
+        }
+      };
+
+      List.prototype.filterSelf = function (dims, cb, ctx, ctxCompat) {
+
+        var _this = this;
+
+        if (!this._count) {
+          return;
+        }
+
+        if (typeof dims === 'function') {
+          ctxCompat = ctx;
+          ctx = cb;
+          cb = dims;
+          dims = [];
+        } // ctxCompat just for compat echarts3
+
+
+        var fCtx = ctx || ctxCompat || this;
+        var dimNames = map$1(normalizeDimensions(dims), this.getDimension, this);
+
+        if ("development" !== 'production') {
+          validateDimensions(this, dimNames);
+        }
+
+        var count = this.count();
+        var Ctor = getIndicesCtor(this);
+        var newIndices = new Ctor(count);
+        var value = [];
+        var dimSize = dimNames.length;
+        var offset = 0;
+        var dimIndices = map$1(dimNames, function (dimName) {
+          return _this._dimensionInfos[dimName].index;
+        });
+        var dim0 = dimIndices[0];
+        var storageArr = this._storageArr;
+
+        for (var i = 0; i < count; i++) {
+          var keep = void 0;
+          var rawIdx = this.getRawIndex(i); // Simple optimization
+
+          if (dimSize === 0) {
+            keep = cb.call(fCtx, i);
+          } else if (dimSize === 1) {
+            var val = storageArr[dim0][rawIdx];
+            keep = cb.call(fCtx, val, i);
+          } else {
+            var k = 0;
+
+            for (; k < dimSize; k++) {
+              value[k] = storageArr[dimIndices[k]][rawIdx];
+            }
+
+            value[k] = i;
+            keep = cb.apply(fCtx, value);
+          }
+
+          if (keep) {
+            newIndices[offset++] = rawIdx;
+          }
+        } // Set indices after filtered.
+
+
+        if (offset < count) {
+          this._indices = newIndices;
+        }
+
+        this._count = offset; // Reset data extent
+
+        this._extent = {};
+        this.getRawIndex = this._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;
+        return this;
+      };
+      /**
+       * Select data in range. (For optimization of filter)
+       * (Manually inline code, support 5 million data filtering in data zoom.)
+       */
+
+
+      List.prototype.selectRange = function (range) {
+
+        var _this = this;
+
+        var len = this._count;
+
+        if (!len) {
+          return;
+        }
+
+        var dimensions = [];
+
+        for (var dim in range) {
+          if (range.hasOwnProperty(dim)) {
+            dimensions.push(dim);
+          }
+        }
+
+        if ("development" !== 'production') {
+          validateDimensions(this, dimensions);
+        }
+
+        var dimSize = dimensions.length;
+
+        if (!dimSize) {
+          return;
+        }
+
+        var originalCount = this.count();
+        var Ctor = getIndicesCtor(this);
+        var newIndices = new Ctor(originalCount);
+        var offset = 0;
+        var dim0 = dimensions[0];
+        var dimIndices = map$1(dimensions, function (dimName) {
+          return _this._dimensionInfos[dimName].index;
+        });
+        var min = range[dim0][0];
+        var max = range[dim0][1];
+        var storageArr = this._storageArr;
+        var quickFinished = false;
+
+        if (!this._indices) {
+          // Extreme optimization for common case. About 2x faster in chrome.
+          var idx = 0;
+
+          if (dimSize === 1) {
+            var dimStorage = storageArr[dimIndices[0]];
+
+            for (var i = 0; i < len; i++) {
+              var val = dimStorage[i]; // NaN will not be filtered. Consider the case, in line chart, empty
+              // value indicates the line should be broken. But for the case like
+              // scatter plot, a data item with empty value will not be rendered,
+              // but the axis extent may be effected if some other dim of the data
+              // item has value. Fortunately it is not a significant negative effect.
+
+              if (val >= min && val <= max || isNaN(val)) {
+                newIndices[offset++] = idx;
+              }
+
+              idx++;
+            }
+
+            quickFinished = true;
+          } else if (dimSize === 2) {
+            var dimStorage = storageArr[dimIndices[0]];
+            var dimStorage2 = storageArr[dimIndices[1]];
+            var min2 = range[dimensions[1]][0];
+            var max2 = range[dimensions[1]][1];
+
+            for (var i = 0; i < len; i++) {
+              var val = dimStorage[i];
+              var val2 = dimStorage2[i]; // Do not filter NaN, see comment above.
+
+              if ((val >= min && val <= max || isNaN(val)) && (val2 >= min2 && val2 <= max2 || isNaN(val2))) {
+                newIndices[offset++] = idx;
+              }
+
+              idx++;
+            }
+
+            quickFinished = true;
+          }
+        }
+
+        if (!quickFinished) {
+          if (dimSize === 1) {
+            for (var i = 0; i < originalCount; i++) {
+              var rawIndex = this.getRawIndex(i);
+              var val = storageArr[dimIndices[0]][rawIndex]; // Do not filter NaN, see comment above.
+
+              if (val >= min && val <= max || isNaN(val)) {
+                newIndices[offset++] = rawIndex;
+              }
+            }
+          } else {
+            for (var i = 0; i < originalCount; i++) {
+              var keep = true;
+              var rawIndex = this.getRawIndex(i);
+
+              for (var k = 0; k < dimSize; k++) {
+                var dimk = dimensions[k];
+                var val = storageArr[dimIndices[k]][rawIndex]; // Do not filter NaN, see comment above.
+
+                if (val < range[dimk][0] || val > range[dimk][1]) {
+                  keep = false;
+                }
+              }
+
+              if (keep) {
+                newIndices[offset++] = this.getRawIndex(i);
+              }
+            }
+          }
+        } // Set indices after filtered.
+
+
+        if (offset < originalCount) {
+          this._indices = newIndices;
+        }
+
+        this._count = offset; // Reset data extent
+
+        this._extent = {};
+        this.getRawIndex = this._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;
+        return this;
+      };
+      /* eslint-enable */
+
+
+      List.prototype.mapArray = function (dims, cb, ctx, ctxCompat) {
+
+        if (typeof dims === 'function') {
+          ctxCompat = ctx;
+          ctx = cb;
+          cb = dims;
+          dims = [];
+        } // ctxCompat just for compat echarts3
+
+
+        ctx = ctx || ctxCompat || this;
+        var result = [];
+        this.each(dims, function () {
+          result.push(cb && cb.apply(this, arguments));
+        }, ctx);
+        return result;
+      };
+
+      List.prototype.map = function (dims, cb, ctx, ctxCompat) {
+
+        var fCtx = ctx || ctxCompat || this;
+        var dimNames = map$1(normalizeDimensions(dims), this.getDimension, this);
+
+        if ("development" !== 'production') {
+          validateDimensions(this, dimNames);
+        }
+
+        var list = cloneListForMapAndSample(this, dimNames);
+        var storage = list._storage; // Following properties are all immutable.
+        // So we can reference to the same value
+
+        list._indices = this._indices;
+        list.getRawIndex = list._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;
+        var tmpRetValue = [];
+        var dimSize = dimNames.length;
+        var dataCount = this.count();
+        var values = [];
+        var rawExtent = list._rawExtent;
+
+        for (var dataIndex = 0; dataIndex < dataCount; dataIndex++) {
+          for (var dimIndex = 0; dimIndex < dimSize; dimIndex++) {
+            values[dimIndex] = this.get(dimNames[dimIndex], dataIndex);
+          }
+
+          values[dimSize] = dataIndex;
+          var retValue = cb && cb.apply(fCtx, values);
+
+          if (retValue != null) {
+            // a number or string (in oridinal dimension)?
+            if (typeof retValue !== 'object') {
+              tmpRetValue[0] = retValue;
+              retValue = tmpRetValue;
+            }
+
+            var rawIndex = this.getRawIndex(dataIndex);
+
+            for (var i = 0; i < retValue.length; i++) {
+              var dim = dimNames[i];
+              var val = retValue[i];
+              var rawExtentOnDim = rawExtent[dim];
+              var dimStore = storage[dim];
+
+              if (dimStore) {
+                dimStore[rawIndex] = val;
+              }
+
+              if (val < rawExtentOnDim[0]) {
+                rawExtentOnDim[0] = val;
+              }
+
+              if (val > rawExtentOnDim[1]) {
+                rawExtentOnDim[1] = val;
+              }
+            }
+          }
+        }
+
+        return list;
+      };
+      /**
+       * Large data down sampling on given dimension
+       * @param sampleIndex Sample index for name and id
+       */
+
+
+      List.prototype.downSample = function (dimension, rate, sampleValue, sampleIndex) {
+        var list = cloneListForMapAndSample(this, [dimension]);
+        var targetStorage = list._storage;
+        var frameValues = [];
+        var frameSize = mathFloor(1 / rate);
+        var dimStore = targetStorage[dimension];
+        var len = this.count();
+        var rawExtentOnDim = list._rawExtent[dimension];
+        var newIndices = new (getIndicesCtor(this))(len);
+        var offset = 0;
+
+        for (var i = 0; i < len; i += frameSize) {
+          // Last frame
+          if (frameSize > len - i) {
+            frameSize = len - i;
+            frameValues.length = frameSize;
+          }
+
+          for (var k = 0; k < frameSize; k++) {
+            var dataIdx = this.getRawIndex(i + k);
+            frameValues[k] = dimStore[dataIdx];
+          }
+
+          var value = sampleValue(frameValues);
+          var sampleFrameIdx = this.getRawIndex(Math.min(i + sampleIndex(frameValues, value) || 0, len - 1)); // Only write value on the filtered data
+
+          dimStore[sampleFrameIdx] = value;
+
+          if (value < rawExtentOnDim[0]) {
+            rawExtentOnDim[0] = value;
+          }
+
+          if (value > rawExtentOnDim[1]) {
+            rawExtentOnDim[1] = value;
+          }
+
+          newIndices[offset++] = sampleFrameIdx;
+        }
+
+        list._count = offset;
+        list._indices = newIndices;
+        list.getRawIndex = getRawIndexWithIndices;
+        return list;
+      };
+      /**
+       * Large data down sampling using largest-triangle-three-buckets
+       * @param {string} valueDimension
+       * @param {number} targetCount
+       */
+
+
+      List.prototype.lttbDownSample = function (valueDimension, rate) {
+        var list = cloneListForMapAndSample(this, []);
+        var targetStorage = list._storage;
+        var dimStore = targetStorage[valueDimension];
+        var len = this.count();
+        var newIndices = new (getIndicesCtor(this))(len);
+        var sampledIndex = 0;
+        var frameSize = mathFloor(1 / rate);
+        var currentRawIndex = this.getRawIndex(0);
+        var maxArea;
+        var area;
+        var nextRawIndex; // First frame use the first data.
+
+        newIndices[sampledIndex++] = currentRawIndex;
+
+        for (var i = 1; i < len - 1; i += frameSize) {
+          var nextFrameStart = Math.min(i + frameSize, len - 1);
+          var nextFrameEnd = Math.min(i + frameSize * 2, len);
+          var avgX = (nextFrameEnd + nextFrameStart) / 2;
+          var avgY = 0;
+
+          for (var idx = nextFrameStart; idx < nextFrameEnd; idx++) {
+            var rawIndex = this.getRawIndex(idx);
+            var y = dimStore[rawIndex];
+
+            if (isNaN(y)) {
+              continue;
+            }
+
+            avgY += y;
+          }
+
+          avgY /= nextFrameEnd - nextFrameStart;
+          var frameStart = i;
+          var frameEnd = Math.min(i + frameSize, len);
+          var pointAX = i - 1;
+          var pointAY = dimStore[currentRawIndex];
+          maxArea = -1;
+          nextRawIndex = frameStart; // Find a point from current frame that construct a triangel with largest area with previous selected point
+          // And the average of next frame.
+
+          for (var idx = frameStart; idx < frameEnd; idx++) {
+            var rawIndex = this.getRawIndex(idx);
+            var y = dimStore[rawIndex];
+
+            if (isNaN(y)) {
+              continue;
+            } // Calculate triangle area over three buckets
+
+
+            area = Math.abs((pointAX - avgX) * (y - pointAY) - (pointAX - idx) * (avgY - pointAY));
+
+            if (area > maxArea) {
+              maxArea = area;
+              nextRawIndex = rawIndex; // Next a is this b
+            }
+          }
+
+          newIndices[sampledIndex++] = nextRawIndex;
+          currentRawIndex = nextRawIndex; // This a is the next a (chosen b)
+        } // First frame use the last data.
+
+
+        newIndices[sampledIndex++] = this.getRawIndex(len - 1);
+        list._count = sampledIndex;
+        list._indices = newIndices;
+        list.getRawIndex = getRawIndexWithIndices;
+        return list;
+      };
+      /**
+       * Get model of one data item.
+       */
+      // TODO: Type of data item
+
+
+      List.prototype.getItemModel = function (idx) {
+        var hostModel = this.hostModel;
+        var dataItem = this.getRawDataItem(idx);
+        return new Model(dataItem, hostModel, hostModel && hostModel.ecModel);
+      };
+      /**
+       * Create a data differ
+       */
+
+
+      List.prototype.diff = function (otherList) {
+        var thisList = this;
+        return new DataDiffer(otherList ? otherList.getIndices() : [], this.getIndices(), function (idx) {
+          return getId(otherList, idx);
+        }, function (idx) {
+          return getId(thisList, idx);
+        });
+      };
+      /**
+       * Get visual property.
+       */
+
+
+      List.prototype.getVisual = function (key) {
+        var visual = this._visual;
+        return visual && visual[key];
+      };
+
+      List.prototype.setVisual = function (kvObj, val) {
+        this._visual = this._visual || {};
+
+        if (isObject$3(kvObj)) {
+          extend(this._visual, kvObj);
+        } else {
+          this._visual[kvObj] = val;
+        }
+      };
+      /**
+       * Get visual property of single data item
+       */
+      // eslint-disable-next-line
+
+
+      List.prototype.getItemVisual = function (idx, key) {
+        var itemVisual = this._itemVisuals[idx];
+        var val = itemVisual && itemVisual[key];
+
+        if (val == null) {
+          // Use global visual property
+          return this.getVisual(key);
+        }
+
+        return val;
+      };
+      /**
+       * If exists visual property of single data item
+       */
+
+
+      List.prototype.hasItemVisual = function () {
+        return this._itemVisuals.length > 0;
+      };
+      /**
+       * Make sure itemVisual property is unique
+       */
+      // TODO: use key to save visual to reduce memory.
+
+
+      List.prototype.ensureUniqueItemVisual = function (idx, key) {
+        var itemVisuals = this._itemVisuals;
+        var itemVisual = itemVisuals[idx];
+
+        if (!itemVisual) {
+          itemVisual = itemVisuals[idx] = {};
+        }
+
+        var val = itemVisual[key];
+
+        if (val == null) {
+          val = this.getVisual(key); // TODO Performance?
+
+          if (isArray(val)) {
+            val = val.slice();
+          } else if (isObject$3(val)) {
+            val = extend({}, val);
+          }
+
+          itemVisual[key] = val;
+        }
+
+        return val;
+      }; // eslint-disable-next-line
+
+
+      List.prototype.setItemVisual = function (idx, key, value) {
+        var itemVisual = this._itemVisuals[idx] || {};
+        this._itemVisuals[idx] = itemVisual;
+
+        if (isObject$3(key)) {
+          extend(itemVisual, key);
+        } else {
+          itemVisual[key] = value;
+        }
+      };
+      /**
+       * Clear itemVisuals and list visual.
+       */
+
+
+      List.prototype.clearAllVisual = function () {
+        this._visual = {};
+        this._itemVisuals = [];
+      };
+
+      List.prototype.setLayout = function (key, val) {
+        if (isObject$3(key)) {
+          for (var name_1 in key) {
+            if (key.hasOwnProperty(name_1)) {
+              this.setLayout(name_1, key[name_1]);
+            }
+          }
+
+          return;
+        }
+
+        this._layout[key] = val;
+      };
+      /**
+       * Get layout property.
+       */
+
+
+      List.prototype.getLayout = function (key) {
+        return this._layout[key];
+      };
+      /**
+       * Get layout of single data item
+       */
+
+
+      List.prototype.getItemLayout = function (idx) {
+        return this._itemLayouts[idx];
+      };
+      /**
+       * Set layout of single data item
+       */
+
+
+      List.prototype.setItemLayout = function (idx, layout, merge) {
+        this._itemLayouts[idx] = merge ? extend(this._itemLayouts[idx] || {}, layout) : layout;
+      };
+      /**
+       * Clear all layout of single data item
+       */
+
+
+      List.prototype.clearItemLayouts = function () {
+        this._itemLayouts.length = 0;
+      };
+      /**
+       * Set graphic element relative to data. It can be set as null
+       */
+
+
+      List.prototype.setItemGraphicEl = function (idx, el) {
+        var hostModel = this.hostModel;
+
+        if (el) {
+          var ecData = getECData(el); // Add data index and series index for indexing the data by element
+          // Useful in tooltip
+
+          ecData.dataIndex = idx;
+          ecData.dataType = this.dataType;
+          ecData.seriesIndex = hostModel && hostModel.seriesIndex; // TODO: not store dataIndex on children.
+
+          if (el.type === 'group') {
+            el.traverse(setItemDataAndSeriesIndex, el);
+          }
+        }
+
+        this._graphicEls[idx] = el;
+      };
+
+      List.prototype.getItemGraphicEl = function (idx) {
+        return this._graphicEls[idx];
+      };
+
+      List.prototype.eachItemGraphicEl = function (cb, context) {
+        each(this._graphicEls, function (el, idx) {
+          if (el) {
+            cb && cb.call(context, el, idx);
+          }
+        });
+      };
+      /**
+       * Shallow clone a new list except visual and layout properties, and graph elements.
+       * New list only change the indices.
+       */
+
+
+      List.prototype.cloneShallow = function (list) {
+        if (!list) {
+          var dimensionInfoList = map$1(this.dimensions, this.getDimensionInfo, this);
+          list = new List(dimensionInfoList, this.hostModel);
+        } // FIXME
+
+
+        list._storage = this._storage;
+        list._storageArr = this._storageArr;
+        transferProperties(list, this); // Clone will not change the data extent and indices
+
+        if (this._indices) {
+          var Ctor = this._indices.constructor;
+
+          if (Ctor === Array) {
+            var thisCount = this._indices.length;
+            list._indices = new Ctor(thisCount);
+
+            for (var i = 0; i < thisCount; i++) {
+              list._indices[i] = this._indices[i];
+            }
+          } else {
+            list._indices = new Ctor(this._indices);
+          }
+        } else {
+          list._indices = null;
+        }
+
+        list.getRawIndex = list._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;
+        return list;
+      };
+      /**
+       * Wrap some method to add more feature
+       */
+
+
+      List.prototype.wrapMethod = function (methodName, injectFunction) {
+        var originalMethod = this[methodName];
+
+        if (typeof originalMethod !== 'function') {
+          return;
+        }
+
+        this.__wrappedMethods = this.__wrappedMethods || [];
+
+        this.__wrappedMethods.push(methodName);
+
+        this[methodName] = function () {
+          var res = originalMethod.apply(this, arguments);
+          return injectFunction.apply(this, [res].concat(slice(arguments)));
+        };
+      }; // ----------------------------------------------------------
+      // A work around for internal method visiting private member.
+      // ----------------------------------------------------------
+
+
+      List.internalField = function () {
+        defaultDimValueGetters = {
+          arrayRows: getDimValueSimply,
+          objectRows: function (dataItem, dimName, dataIndex, dimIndex) {
+            return parseDataValue(dataItem[dimName], this._dimensionInfos[dimName]);
+          },
+          keyedColumns: getDimValueSimply,
+          original: function (dataItem, dimName, dataIndex, dimIndex) {
+            // Performance sensitive, do not use modelUtil.getDataItemValue.
+            // If dataItem is an plain object with no value field, the let `value`
+            // will be assigned with the object, but it will be tread correctly
+            // in the `convertValue`.
+            var value = dataItem && (dataItem.value == null ? dataItem : dataItem.value); // If any dataItem is like { value: 10 }
+
+            if (!this._rawData.pure && isDataItemOption(dataItem)) {
+              this.hasItemOption = true;
+            }
+
+            return parseDataValue(value instanceof Array ? value[dimIndex] // If value is a single number or something else not array.
+            : value, this._dimensionInfos[dimName]);
+          },
+          typedArray: function (dataItem, dimName, dataIndex, dimIndex) {
+            return dataItem[dimIndex];
+          }
+        };
+
+        function getDimValueSimply(dataItem, dimName, dataIndex, dimIndex) {
+          return parseDataValue(dataItem[dimIndex], this._dimensionInfos[dimName]);
+        }
+
+        prepareInvertedIndex = function (list) {
+          var invertedIndicesMap = list._invertedIndicesMap;
+          each(invertedIndicesMap, function (invertedIndices, dim) {
+            var dimInfo = list._dimensionInfos[dim]; // Currently, only dimensions that has ordinalMeta can create inverted indices.
+
+            var ordinalMeta = dimInfo.ordinalMeta;
+
+            if (ordinalMeta) {
+              invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array(ordinalMeta.categories.length); // The default value of TypedArray is 0. To avoid miss
+              // mapping to 0, we should set it as INDEX_NOT_FOUND.
+
+              for (var i = 0; i < invertedIndices.length; i++) {
+                invertedIndices[i] = INDEX_NOT_FOUND;
+              }
+
+              for (var i = 0; i < list._count; i++) {
+                // Only support the case that all values are distinct.
+                invertedIndices[list.get(dim, i)] = i;
+              }
+            }
+          });
+        };
+
+        getIdNameFromStore = function (list, dimIdx, ordinalMeta, rawIndex) {
+          var val;
+          var chunk = list._storageArr[dimIdx];
+
+          if (chunk) {
+            val = chunk[rawIndex];
+
+            if (ordinalMeta && ordinalMeta.categories.length) {
+              val = ordinalMeta.categories[val];
+            }
+          }
+
+          return convertOptionIdName(val, null);
+        };
+
+        getIndicesCtor = function (list) {
+          // The possible max value in this._indicies is always this._rawCount despite of filtering.
+          return list._rawCount > 65535 ? CtorUint32Array : CtorUint16Array;
+        };
+
+        prepareStorage = function (storage, dimInfo, end, append) {
+          var DataCtor = dataCtors[dimInfo.type];
+          var dim = dimInfo.name;
+
+          if (append) {
+            var oldStore = storage[dim];
+            var oldLen = oldStore && oldStore.length;
+
+            if (!(oldLen === end)) {
+              var newStore = new DataCtor(end); // The cost of the copy is probably inconsiderable
+              // within the initial chunkSize.
+
+              for (var j = 0; j < oldLen; j++) {
+                newStore[j] = oldStore[j];
+              }
+
+              storage[dim] = newStore;
+            }
+          } else {
+            storage[dim] = new DataCtor(end);
+          }
+        };
+
+        getRawIndexWithoutIndices = function (idx) {
+          return idx;
+        };
+
+        getRawIndexWithIndices = function (idx) {
+          if (idx < this._count && idx >= 0) {
+            return this._indices[idx];
+          }
+
+          return -1;
+        };
+        /**
+         * @see the comment of `List['getId']`.
+         */
+
+
+        getId = function (list, rawIndex) {
+          var id = list._idList[rawIndex];
+
+          if (id == null && list._idDimIdx != null) {
+            id = getIdNameFromStore(list, list._idDimIdx, list._idOrdinalMeta, rawIndex);
+          }
+
+          if (id == null) {
+            id = ID_PREFIX + rawIndex;
+          }
+
+          return id;
+        };
+
+        normalizeDimensions = function (dimensions) {
+          if (!isArray(dimensions)) {
+            dimensions = dimensions != null ? [dimensions] : [];
+          }
+
+          return dimensions;
+        };
+
+        validateDimensions = function (list, dims) {
+          for (var i = 0; i < dims.length; i++) {
+            // stroage may be empty when no data, so use
+            // dimensionInfos to check.
+            if (!list._dimensionInfos[dims[i]]) {
+              console.error('Unkown dimension ' + dims[i]);
+            }
+          }
+        }; // Data in excludeDimensions is copied, otherwise transfered.
+
+
+        cloneListForMapAndSample = function (original, excludeDimensions) {
+          var allDimensions = original.dimensions;
+          var list = new List(map$1(allDimensions, original.getDimensionInfo, original), original.hostModel); // FIXME If needs stackedOn, value may already been stacked
+
+          transferProperties(list, original);
+          var storage = list._storage = {};
+          var originalStorage = original._storage;
+          var storageArr = list._storageArr = []; // Init storage
+
+          for (var i = 0; i < allDimensions.length; i++) {
+            var dim = allDimensions[i];
+
+            if (originalStorage[dim]) {
+              // Notice that we do not reset invertedIndicesMap here, becuase
+              // there is no scenario of mapping or sampling ordinal dimension.
+              if (indexOf(excludeDimensions, dim) >= 0) {
+                storage[dim] = cloneChunk(originalStorage[dim]);
+                list._rawExtent[dim] = getInitialExtent();
+                list._extent[dim] = null;
+              } else {
+                // Direct reference for other dimensions
+                storage[dim] = originalStorage[dim];
+              }
+
+              storageArr.push(storage[dim]);
+            }
+          }
+
+          return list;
+        };
+
+        function cloneChunk(originalChunk) {
+          var Ctor = originalChunk.constructor; // Only shallow clone is enough when Array.
+
+          return Ctor === Array ? originalChunk.slice() : new Ctor(originalChunk);
+        }
+
+        getInitialExtent = function () {
+          return [Infinity, -Infinity];
+        };
+
+        setItemDataAndSeriesIndex = function (child) {
+          var childECData = getECData(child);
+          var thisECData = getECData(this);
+          childECData.seriesIndex = thisECData.seriesIndex;
+          childECData.dataIndex = thisECData.dataIndex;
+          childECData.dataType = thisECData.dataType;
+        };
+
+        transferProperties = function (target, source) {
+          each(TRANSFERABLE_PROPERTIES.concat(source.__wrappedMethods || []), function (propName) {
+            if (source.hasOwnProperty(propName)) {
+              target[propName] = source[propName];
+            }
+          });
+          target.__wrappedMethods = source.__wrappedMethods;
+          each(CLONE_PROPERTIES, function (propName) {
+            target[propName] = clone(source[propName]);
+          });
+          target._calculationInfo = extend({}, source._calculationInfo);
+        };
+
+        makeIdFromName = function (list, idx) {
+          var nameList = list._nameList;
+          var idList = list._idList;
+          var nameDimIdx = list._nameDimIdx;
+          var idDimIdx = list._idDimIdx;
+          var name = nameList[idx];
+          var id = idList[idx];
+
+          if (name == null && nameDimIdx != null) {
+            nameList[idx] = name = getIdNameFromStore(list, nameDimIdx, list._nameOrdinalMeta, idx);
+          }
+
+          if (id == null && idDimIdx != null) {
+            idList[idx] = id = getIdNameFromStore(list, idDimIdx, list._idOrdinalMeta, idx);
+          }
+
+          if (id == null && name != null) {
+            var nameRepeatCount = list._nameRepeatCount;
+            var nmCnt = nameRepeatCount[name] = (nameRepeatCount[name] || 0) + 1;
+            id = name;
+
+            if (nmCnt > 1) {
+              id += '__ec__' + nmCnt;
+            }
+
+            idList[idx] = id;
+          }
+        };
+      }();
+
+      return List;
+    }();
+
+    /**
+     * @see {module:echarts/test/ut/spec/data/completeDimensions}
+     *
+     * This method builds the relationship between:
+     * + "what the coord sys or series requires (see `sysDims`)",
+     * + "what the user defines (in `encode` and `dimensions`, see `opt.dimsDef` and `opt.encodeDef`)"
+     * + "what the data source provids (see `source`)".
+     *
+     * Some guess strategy will be adapted if user does not define something.
+     * If no 'value' dimension specified, the first no-named dimension will be
+     * named as 'value'.
+     *
+     * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which
+     *      provides not only dim template, but also default order.
+     *      properties: 'name', 'type', 'displayName'.
+     *      `name` of each item provides default coord name.
+     *      [{dimsDef: [string|Object, ...]}, ...] dimsDef of sysDim item provides default dim name, and
+     *                                    provide dims count that the sysDim required.
+     *      [{ordinalMeta}] can be specified.
+     * @param {module:echarts/data/Source|Array|Object} source or data (for compatibal with pervious)
+     * @param {Object} [opt]
+     * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions
+     *      For example: ['asdf', {name, type}, ...].
+     * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}
+     * @param {Function} [opt.encodeDefaulter] Called if no `opt.encodeDef` exists.
+     *      If not specified, auto find the next available data dim.
+     *      param source {module:data/Source}
+     *      param dimCount {number}
+     *      return {Object} encode Never be `null/undefined`.
+     * @param {string} [opt.generateCoord] Generate coord dim with the given name.
+     *      If not specified, extra dim names will be:
+     *      'value', 'value0', 'value1', ...
+     * @param {number} [opt.generateCoordCount] By default, the generated dim name is `generateCoord`.
+     *      If `generateCoordCount` specified, the generated dim names will be:
+     *      `generateCoord` + 0, `generateCoord` + 1, ...
+     *      can be Infinity, indicate that use all of the remain columns.
+     * @param {number} [opt.dimCount] If not specified, guess by the first data item.
+     * @return {Array.<module:data/DataDimensionInfo>}
+     */
+
+    function completeDimensions(sysDims, source, opt) {
+      if (!isSourceInstance(source)) {
+        source = createSourceFromSeriesDataOption(source);
+      }
+
+      opt = opt || {};
+      sysDims = (sysDims || []).slice();
+      var dimsDef = (opt.dimsDef || []).slice();
+      var dataDimNameMap = createHashMap();
+      var coordDimNameMap = createHashMap(); // let valueCandidate;
+
+      var result = [];
+      var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimCount); // Apply user defined dims (`name` and `type`) and init result.
+
+      for (var i = 0; i < dimCount; i++) {
+        var dimDefItemRaw = dimsDef[i];
+        var dimDefItem = dimsDef[i] = extend({}, isObject(dimDefItemRaw) ? dimDefItemRaw : {
+          name: dimDefItemRaw
+        });
+        var userDimName = dimDefItem.name;
+        var resultItem = result[i] = new DataDimensionInfo(); // Name will be applied later for avoiding duplication.
+
+        if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
+          // Only if `series.dimensions` is defined in option
+          // displayName, will be set, and dimension will be diplayed vertically in
+          // tooltip by default.
+          resultItem.name = resultItem.displayName = userDimName;
+          dataDimNameMap.set(userDimName, i);
+        }
+
+        dimDefItem.type != null && (resultItem.type = dimDefItem.type);
+        dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);
+      }
+
+      var encodeDef = opt.encodeDef;
+
+      if (!encodeDef && opt.encodeDefaulter) {
+        encodeDef = opt.encodeDefaulter(source, dimCount);
+      }
+
+      var encodeDefMap = createHashMap(encodeDef); // Set `coordDim` and `coordDimIndex` by `encodeDefMap` and normalize `encodeDefMap`.
+
+      encodeDefMap.each(function (dataDimsRaw, coordDim) {
+        var dataDims = normalizeToArray(dataDimsRaw).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is
+        // `{encode: {x: -1, y: 1}}`. Should not filter anything in
+        // this case.
+
+        if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {
+          encodeDefMap.set(coordDim, false);
+          return;
+        }
+
+        var validDataDims = encodeDefMap.set(coordDim, []);
+        each(dataDims, function (resultDimIdxOrName, idx) {
+          // The input resultDimIdx can be dim name or index.
+          var resultDimIdx = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
+
+          if (resultDimIdx != null && resultDimIdx < dimCount) {
+            validDataDims[idx] = resultDimIdx;
+            applyDim(result[resultDimIdx], coordDim, idx);
+          }
+        });
+      }); // Apply templetes and default order from `sysDims`.
+
+      var availDimIdx = 0;
+      each(sysDims, function (sysDimItemRaw) {
+        var coordDim;
+        var sysDimItemDimsDef;
+        var sysDimItemOtherDims;
+        var sysDimItem;
+
+        if (isString(sysDimItemRaw)) {
+          coordDim = sysDimItemRaw;
+          sysDimItem = {};
+        } else {
+          sysDimItem = sysDimItemRaw;
+          coordDim = sysDimItem.name;
+          var ordinalMeta = sysDimItem.ordinalMeta;
+          sysDimItem.ordinalMeta = null;
+          sysDimItem = clone(sysDimItem);
+          sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.
+
+          sysDimItemDimsDef = sysDimItem.dimsDef;
+          sysDimItemOtherDims = sysDimItem.otherDims;
+          sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+        }
+
+        var dataDims = encodeDefMap.get(coordDim); // negative resultDimIdx means no need to mapping.
+
+        if (dataDims === false) {
+          return;
+        }
+
+        dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.
+
+        if (!dataDims.length) {
+          for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {
+            while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {
+              availDimIdx++;
+            }
+
+            availDimIdx < result.length && dataDims.push(availDimIdx++);
+          }
+        } // Apply templates.
+
+
+        each(dataDims, function (resultDimIdx, coordDimIndex) {
+          var resultItem = result[resultDimIdx];
+          applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
+
+          if (resultItem.name == null && sysDimItemDimsDef) {
+            var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
+            !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {
+              name: sysDimItemDimsDefItem
+            });
+            resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;
+            resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
+          } // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}
+
+
+          sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);
+        });
+      });
+
+      function applyDim(resultItem, coordDim, coordDimIndex) {
+        if (VISUAL_DIMENSIONS.get(coordDim) != null) {
+          resultItem.otherDims[coordDim] = coordDimIndex;
+        } else {
+          resultItem.coordDim = coordDim;
+          resultItem.coordDimIndex = coordDimIndex;
+          coordDimNameMap.set(coordDim, true);
+        }
+      } // Make sure the first extra dim is 'value'.
+
+
+      var generateCoord = opt.generateCoord;
+      var generateCoordCount = opt.generateCoordCount;
+      var fromZero = generateCoordCount != null;
+      generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
+      var extra = generateCoord || 'value'; // Set dim `name` and other `coordDim` and other props.
+
+      for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+        var resultItem = result[resultDimIdx] = result[resultDimIdx] || new DataDimensionInfo();
+        var coordDim = resultItem.coordDim;
+
+        if (coordDim == null) {
+          resultItem.coordDim = genName(extra, coordDimNameMap, fromZero);
+          resultItem.coordDimIndex = 0;
+
+          if (!generateCoord || generateCoordCount <= 0) {
+            resultItem.isExtraCoord = true;
+          }
+
+          generateCoordCount--;
+        }
+
+        resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap, false));
+
+        if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must // Consider the case:
+        // {
+        //    dataset: {source: [
+        //        ['2001', 123],
+        //        ['2002', 456],
+        //        ...
+        //        ['The others', 987],
+        //    ]},
+        //    series: {type: 'pie'}
+        // }
+        // The first colum should better be treated as a "ordinal" although it
+        // might not able to be detected as an "ordinal" by `guessOrdinal`.
+        || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
+          resultItem.type = 'ordinal';
+        }
+      }
+
+      return result;
+    } // ??? TODO
+    // Originally detect dimCount by data[0]. Should we
+    // optimize it to only by sysDims and dimensions and encode.
+    // So only necessary dims will be initialized.
+    // But
+    // (1) custom series should be considered. where other dims
+    // may be visited.
+    // (2) sometimes user need to calcualte bubble size or use visualMap
+    // on other dimensions besides coordSys needed.
+    // So, dims that is not used by system, should be shared in storage?
+
+
+    function getDimCount(source, sysDims, dimsDef, optDimCount) {
+      // Note that the result dimCount should not small than columns count
+      // of data, otherwise `dataDimNameMap` checking will be incorrect.
+      var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);
+      each(sysDims, function (sysDimItem) {
+        var sysDimItemDimsDef;
+
+        if (isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {
+          dimCount = Math.max(dimCount, sysDimItemDimsDef.length);
+        }
+      });
+      return dimCount;
+    }
+
+    function genName(name, map, fromZero) {
+      if (fromZero || map.get(name) != null) {
+        var i = 0;
+
+        while (map.get(name + i) != null) {
+          i++;
+        }
+
+        name += i;
+      }
+
+      map.set(name, true);
+      return name;
+    }
+
+    /**
+     * @param opt.coordDimensions
+     * @param opt.dimensionsDefine By default `source.dimensionsDefine` Overwrite source define.
+     * @param opt.encodeDefine By default `source.encodeDefine` Overwrite source define.
+     * @param opt.encodeDefaulter Make default encode if user not specified.
+     */
+
+    function createDimensions( // TODO: TYPE completeDimensions type
+    source, opt) {
+      opt = opt || {};
+      return completeDimensions(opt.coordDimensions || [], source, {
+        // FIXME:TS detect whether source then call `.dimensionsDefine` and `.encodeDefine`?
+        dimsDef: opt.dimensionsDefine || source.dimensionsDefine,
+        encodeDef: opt.encodeDefine || source.encodeDefine,
+        dimCount: opt.dimensionsCount,
+        encodeDefaulter: opt.encodeDefaulter,
+        generateCoord: opt.generateCoord,
+        generateCoordCount: opt.generateCoordCount
+      });
+    }
+
+    /**
+     * @class
+     * For example:
+     * {
+     *     coordSysName: 'cartesian2d',
+     *     coordSysDims: ['x', 'y', ...],
+     *     axisMap: HashMap({
+     *         x: xAxisModel,
+     *         y: yAxisModel
+     *     }),
+     *     categoryAxisMap: HashMap({
+     *         x: xAxisModel,
+     *         y: undefined
+     *     }),
+     *     // The index of the first category axis in `coordSysDims`.
+     *     // `null/undefined` means no category axis exists.
+     *     firstCategoryDimIndex: 1,
+     *     // To replace user specified encode.
+     * }
+     */
+
+    var CoordSysInfo =
+    /** @class */
+    function () {
+      function CoordSysInfo(coordSysName) {
+        this.coordSysDims = [];
+        this.axisMap = createHashMap();
+        this.categoryAxisMap = createHashMap();
+        this.coordSysName = coordSysName;
+      }
+
+      return CoordSysInfo;
+    }();
+
+    function getCoordSysInfoBySeries(seriesModel) {
+      var coordSysName = seriesModel.get('coordinateSystem');
+      var result = new CoordSysInfo(coordSysName);
+      var fetch = fetchers[coordSysName];
+
+      if (fetch) {
+        fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
+        return result;
+      }
+    }
+    var fetchers = {
+      cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {
+        var xAxisModel = seriesModel.getReferringComponents('xAxis', SINGLE_REFERRING).models[0];
+        var yAxisModel = seriesModel.getReferringComponents('yAxis', SINGLE_REFERRING).models[0];
+
+        if ("development" !== 'production') {
+          if (!xAxisModel) {
+            throw new Error('xAxis "' + retrieve(seriesModel.get('xAxisIndex'), seriesModel.get('xAxisId'), 0) + '" not found');
+          }
+
+          if (!yAxisModel) {
+            throw new Error('yAxis "' + retrieve(seriesModel.get('xAxisIndex'), seriesModel.get('yAxisId'), 0) + '" not found');
+          }
+        }
+
+        result.coordSysDims = ['x', 'y'];
+        axisMap.set('x', xAxisModel);
+        axisMap.set('y', yAxisModel);
+
+        if (isCategory(xAxisModel)) {
+          categoryAxisMap.set('x', xAxisModel);
+          result.firstCategoryDimIndex = 0;
+        }
+
+        if (isCategory(yAxisModel)) {
+          categoryAxisMap.set('y', yAxisModel);
+          result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+        }
+      },
+      singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {
+        var singleAxisModel = seriesModel.getReferringComponents('singleAxis', SINGLE_REFERRING).models[0];
+
+        if ("development" !== 'production') {
+          if (!singleAxisModel) {
+            throw new Error('singleAxis should be specified.');
+          }
+        }
+
+        result.coordSysDims = ['single'];
+        axisMap.set('single', singleAxisModel);
+
+        if (isCategory(singleAxisModel)) {
+          categoryAxisMap.set('single', singleAxisModel);
+          result.firstCategoryDimIndex = 0;
+        }
+      },
+      polar: function (seriesModel, result, axisMap, categoryAxisMap) {
+        var polarModel = seriesModel.getReferringComponents('polar', SINGLE_REFERRING).models[0];
+        var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+        var angleAxisModel = polarModel.findAxisModel('angleAxis');
+
+        if ("development" !== 'production') {
+          if (!angleAxisModel) {
+            throw new Error('angleAxis option not found');
+          }
+
+          if (!radiusAxisModel) {
+            throw new Error('radiusAxis option not found');
+          }
+        }
+
+        result.coordSysDims = ['radius', 'angle'];
+        axisMap.set('radius', radiusAxisModel);
+        axisMap.set('angle', angleAxisModel);
+
+        if (isCategory(radiusAxisModel)) {
+          categoryAxisMap.set('radius', radiusAxisModel);
+          result.firstCategoryDimIndex = 0;
+        }
+
+        if (isCategory(angleAxisModel)) {
+          categoryAxisMap.set('angle', angleAxisModel);
+          result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+        }
+      },
+      geo: function (seriesModel, result, axisMap, categoryAxisMap) {
+        result.coordSysDims = ['lng', 'lat'];
+      },
+      parallel: function (seriesModel, result, axisMap, categoryAxisMap) {
+        var ecModel = seriesModel.ecModel;
+        var parallelModel = ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));
+        var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();
+        each(parallelModel.parallelAxisIndex, function (axisIndex, index) {
+          var axisModel = ecModel.getComponent('parallelAxis', axisIndex);
+          var axisDim = coordSysDims[index];
+          axisMap.set(axisDim, axisModel);
+
+          if (isCategory(axisModel)) {
+            categoryAxisMap.set(axisDim, axisModel);
+
+            if (result.firstCategoryDimIndex == null) {
+              result.firstCategoryDimIndex = index;
+            }
+          }
+        });
+      }
+    };
+
+    function isCategory(axisModel) {
+      return axisModel.get('type') === 'category';
+    }
+
+    /**
+     * Note that it is too complicated to support 3d stack by value
+     * (have to create two-dimension inverted index), so in 3d case
+     * we just support that stacked by index.
+     *
+     * @param seriesModel
+     * @param dimensionInfoList The same as the input of <module:echarts/data/List>.
+     *        The input dimensionInfoList will be modified.
+     * @param opt
+     * @param opt.stackedCoordDimension Specify a coord dimension if needed.
+     * @param opt.byIndex=false
+     * @return calculationInfo
+     * {
+     *     stackedDimension: string
+     *     stackedByDimension: string
+     *     isStackedByIndex: boolean
+     *     stackedOverDimension: string
+     *     stackResultDimension: string
+     * }
+     */
+
+    function enableDataStack(seriesModel, dimensionInfoList, opt) {
+      opt = opt || {};
+      var byIndex = opt.byIndex;
+      var stackedCoordDimension = opt.stackedCoordDimension; // Compatibal: when `stack` is set as '', do not stack.
+
+      var mayStack = !!(seriesModel && seriesModel.get('stack'));
+      var stackedByDimInfo;
+      var stackedDimInfo;
+      var stackResultDimension;
+      var stackedOverDimension;
+      each(dimensionInfoList, function (dimensionInfo, index) {
+        if (isString(dimensionInfo)) {
+          dimensionInfoList[index] = dimensionInfo = {
+            name: dimensionInfo
+          };
+        }
+
+        if (mayStack && !dimensionInfo.isExtraCoord) {
+          // Find the first ordinal dimension as the stackedByDimInfo.
+          if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {
+            stackedByDimInfo = dimensionInfo;
+          } // Find the first stackable dimension as the stackedDimInfo.
+
+
+          if (!stackedDimInfo && dimensionInfo.type !== 'ordinal' && dimensionInfo.type !== 'time' && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) {
+            stackedDimInfo = dimensionInfo;
+          }
+        }
+      });
+
+      if (stackedDimInfo && !byIndex && !stackedByDimInfo) {
+        // Compatible with previous design, value axis (time axis) only stack by index.
+        // It may make sense if the user provides elaborately constructed data.
+        byIndex = true;
+      } // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.
+      // That put stack logic in List is for using conveniently in echarts extensions, but it
+      // might not be a good way.
+
+
+      if (stackedDimInfo) {
+        // Use a weird name that not duplicated with other names.
+        stackResultDimension = '__\0ecstackresult';
+        stackedOverDimension = '__\0ecstackedover'; // Create inverted index to fast query index by value.
+
+        if (stackedByDimInfo) {
+          stackedByDimInfo.createInvertedIndices = true;
+        }
+
+        var stackedDimCoordDim_1 = stackedDimInfo.coordDim;
+        var stackedDimType = stackedDimInfo.type;
+        var stackedDimCoordIndex_1 = 0;
+        each(dimensionInfoList, function (dimensionInfo) {
+          if (dimensionInfo.coordDim === stackedDimCoordDim_1) {
+            stackedDimCoordIndex_1++;
+          }
+        });
+        dimensionInfoList.push({
+          name: stackResultDimension,
+          coordDim: stackedDimCoordDim_1,
+          coordDimIndex: stackedDimCoordIndex_1,
+          type: stackedDimType,
+          isExtraCoord: true,
+          isCalculationCoord: true
+        });
+        stackedDimCoordIndex_1++;
+        dimensionInfoList.push({
+          name: stackedOverDimension,
+          // This dimension contains stack base (generally, 0), so do not set it as
+          // `stackedDimCoordDim` to avoid extent calculation, consider log scale.
+          coordDim: stackedOverDimension,
+          coordDimIndex: stackedDimCoordIndex_1,
+          type: stackedDimType,
+          isExtraCoord: true,
+          isCalculationCoord: true
+        });
+      }
+
+      return {
+        stackedDimension: stackedDimInfo && stackedDimInfo.name,
+        stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,
+        isStackedByIndex: byIndex,
+        stackedOverDimension: stackedOverDimension,
+        stackResultDimension: stackResultDimension
+      };
+    }
+    function isDimensionStacked(data, stackedDim
+    /*, stackedByDim*/
+    ) {
+      // Each single series only maps to one pair of axis. So we do not need to
+      // check stackByDim, whatever stacked by a dimension or stacked by index.
+      return !!stackedDim && stackedDim === data.getCalculationInfo('stackedDimension'); // && (
+      //     stackedByDim != null
+      //         ? stackedByDim === data.getCalculationInfo('stackedByDimension')
+      //         : data.getCalculationInfo('isStackedByIndex')
+      // );
+    }
+    function getStackedDimension(data, targetDim) {
+      return isDimensionStacked(data, targetDim) ? data.getCalculationInfo('stackResultDimension') : targetDim;
+    }
+
+    function createListFromArray(source, seriesModel, opt) {
+      opt = opt || {};
+
+      if (!isSourceInstance(source)) {
+        source = createSourceFromSeriesDataOption(source);
+      }
+
+      var coordSysName = seriesModel.get('coordinateSystem');
+      var registeredCoordSys = CoordinateSystemManager.get(coordSysName);
+      var coordSysInfo = getCoordSysInfoBySeries(seriesModel);
+      var coordSysDimDefs;
+
+      if (coordSysInfo && coordSysInfo.coordSysDims) {
+        coordSysDimDefs = map(coordSysInfo.coordSysDims, function (dim) {
+          var dimInfo = {
+            name: dim
+          };
+          var axisModel = coordSysInfo.axisMap.get(dim);
+
+          if (axisModel) {
+            var axisType = axisModel.get('type');
+            dimInfo.type = getDimensionTypeByAxis(axisType); // dimInfo.stackable = isStackable(axisType);
+          }
+
+          return dimInfo;
+        });
+      }
+
+      if (!coordSysDimDefs) {
+        // Get dimensions from registered coordinate system
+        coordSysDimDefs = registeredCoordSys && (registeredCoordSys.getDimensionsInfo ? registeredCoordSys.getDimensionsInfo() : registeredCoordSys.dimensions.slice()) || ['x', 'y'];
+      }
+
+      var useEncodeDefaulter = opt.useEncodeDefaulter;
+      var dimInfoList = createDimensions(source, {
+        coordDimensions: coordSysDimDefs,
+        generateCoord: opt.generateCoord,
+        encodeDefaulter: isFunction(useEncodeDefaulter) ? useEncodeDefaulter : useEncodeDefaulter ? curry(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null
+      });
+      var firstCategoryDimIndex;
+      var hasNameEncode;
+      coordSysInfo && each(dimInfoList, function (dimInfo, dimIndex) {
+        var coordDim = dimInfo.coordDim;
+        var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
+
+        if (categoryAxisModel) {
+          if (firstCategoryDimIndex == null) {
+            firstCategoryDimIndex = dimIndex;
+          }
+
+          dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta();
+
+          if (opt.createInvertedIndices) {
+            dimInfo.createInvertedIndices = true;
+          }
+        }
+
+        if (dimInfo.otherDims.itemName != null) {
+          hasNameEncode = true;
+        }
+      });
+
+      if (!hasNameEncode && firstCategoryDimIndex != null) {
+        dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
+      }
+
+      var stackCalculationInfo = enableDataStack(seriesModel, dimInfoList);
+      var list = new List(dimInfoList, seriesModel);
+      list.setCalculationInfo(stackCalculationInfo);
+      var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source) ? function (itemOpt, dimName, dataIndex, dimIndex) {
+        // Use dataIndex as ordinal value in categoryAxis
+        return dimIndex === firstCategoryDimIndex ? dataIndex : this.defaultDimValueGetter(itemOpt, dimName, dataIndex, dimIndex);
+      } : null;
+      list.hasItemOption = false;
+      list.initData(source, null, dimValueGetter);
+      return list;
+    }
+
+    function isNeedCompleteOrdinalData(source) {
+      if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) {
+        var sampleItem = firstDataNotNull(source.data || []);
+        return sampleItem != null && !isArray(getDataItemValue(sampleItem));
+      }
+    }
+
+    function firstDataNotNull(data) {
+      var i = 0;
+
+      while (i < data.length && data[i] == null) {
+        i++;
+      }
+
+      return data[i];
+    }
+
+    var Scale =
+    /** @class */
+    function () {
+      function Scale(setting) {
+        this._setting = setting || {};
+        this._extent = [Infinity, -Infinity];
+      }
+
+      Scale.prototype.getSetting = function (name) {
+        return this._setting[name];
+      };
+      /**
+       * Set extent from data
+       */
+
+
+      Scale.prototype.unionExtent = function (other) {
+        var extent = this._extent;
+        other[0] < extent[0] && (extent[0] = other[0]);
+        other[1] > extent[1] && (extent[1] = other[1]); // not setExtent because in log axis it may transformed to power
+        // this.setExtent(extent[0], extent[1]);
+      };
+      /**
+       * Set extent from data
+       */
+
+
+      Scale.prototype.unionExtentFromData = function (data, dim) {
+        this.unionExtent(data.getApproximateExtent(dim));
+      };
+      /**
+       * Get extent
+       *
+       * Extent is always in increase order.
+       */
+
+
+      Scale.prototype.getExtent = function () {
+        return this._extent.slice();
+      };
+      /**
+       * Set extent
+       */
+
+
+      Scale.prototype.setExtent = function (start, end) {
+        var thisExtent = this._extent;
+
+        if (!isNaN(start)) {
+          thisExtent[0] = start;
+        }
+
+        if (!isNaN(end)) {
+          thisExtent[1] = end;
+        }
+      };
+      /**
+       * If value is in extent range
+       */
+
+
+      Scale.prototype.isInExtentRange = function (value) {
+        return this._extent[0] <= value && this._extent[1] >= value;
+      };
+      /**
+       * When axis extent depends on data and no data exists,
+       * axis ticks should not be drawn, which is named 'blank'.
+       */
+
+
+      Scale.prototype.isBlank = function () {
+        return this._isBlank;
+      };
+      /**
+       * When axis extent depends on data and no data exists,
+       * axis ticks should not be drawn, which is named 'blank'.
+       */
+
+
+      Scale.prototype.setBlank = function (isBlank) {
+        this._isBlank = isBlank;
+      };
+
+      return Scale;
+    }();
+
+    enableClassManagement(Scale);
+
+    var OrdinalMeta =
+    /** @class */
+    function () {
+      function OrdinalMeta(opt) {
+        this.categories = opt.categories || [];
+        this._needCollect = opt.needCollect;
+        this._deduplication = opt.deduplication;
+      }
+
+      OrdinalMeta.createByAxisModel = function (axisModel) {
+        var option = axisModel.option;
+        var data = option.data;
+        var categories = data && map(data, getName);
+        return new OrdinalMeta({
+          categories: categories,
+          needCollect: !categories,
+          // deduplication is default in axis.
+          deduplication: option.dedplication !== false
+        });
+      };
+
+      OrdinalMeta.prototype.getOrdinal = function (category) {
+        // @ts-ignore
+        return this._getOrCreateMap().get(category);
+      };
+      /**
+       * @return The ordinal. If not found, return NaN.
+       */
+
+
+      OrdinalMeta.prototype.parseAndCollect = function (category) {
+        var index;
+        var needCollect = this._needCollect; // The value of category dim can be the index of the given category set.
+        // This feature is only supported when !needCollect, because we should
+        // consider a common case: a value is 2017, which is a number but is
+        // expected to be tread as a category. This case usually happen in dataset,
+        // where it happent to be no need of the index feature.
+
+        if (typeof category !== 'string' && !needCollect) {
+          return category;
+        } // Optimize for the scenario:
+        // category is ['2012-01-01', '2012-01-02', ...], where the input
+        // data has been ensured not duplicate and is large data.
+        // Notice, if a dataset dimension provide categroies, usually echarts
+        // should remove duplication except user tell echarts dont do that
+        // (set axis.deduplication = false), because echarts do not know whether
+        // the values in the category dimension has duplication (consider the
+        // parallel-aqi example)
+
+
+        if (needCollect && !this._deduplication) {
+          index = this.categories.length;
+          this.categories[index] = category;
+          return index;
+        }
+
+        var map = this._getOrCreateMap(); // @ts-ignore
+
+
+        index = map.get(category);
+
+        if (index == null) {
+          if (needCollect) {
+            index = this.categories.length;
+            this.categories[index] = category; // @ts-ignore
+
+            map.set(category, index);
+          } else {
+            index = NaN;
+          }
+        }
+
+        return index;
+      }; // Consider big data, do not create map until needed.
+
+
+      OrdinalMeta.prototype._getOrCreateMap = function () {
+        return this._map || (this._map = createHashMap(this.categories));
+      };
+
+      return OrdinalMeta;
+    }();
+
+    function getName(obj) {
+      if (isObject(obj) && obj.value != null) {
+        return obj.value;
+      } else {
+        return obj + '';
+      }
+    }
+
+    var roundNumber = round;
+    /**
+     * @param extent Both extent[0] and extent[1] should be valid number.
+     *               Should be extent[0] < extent[1].
+     * @param splitNumber splitNumber should be >= 1.
+     */
+
+    function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) {
+      var result = {};
+      var span = extent[1] - extent[0];
+      var interval = result.interval = nice(span / splitNumber, true);
+
+      if (minInterval != null && interval < minInterval) {
+        interval = result.interval = minInterval;
+      }
+
+      if (maxInterval != null && interval > maxInterval) {
+        interval = result.interval = maxInterval;
+      } // Tow more digital for tick.
+
+
+      var precision = result.intervalPrecision = getIntervalPrecision(interval); // Niced extent inside original extent
+
+      var niceTickExtent = result.niceTickExtent = [roundNumber(Math.ceil(extent[0] / interval) * interval, precision), roundNumber(Math.floor(extent[1] / interval) * interval, precision)];
+      fixExtent(niceTickExtent, extent);
+      return result;
+    }
+    /**
+     * @return interval precision
+     */
+
+    function getIntervalPrecision(interval) {
+      // Tow more digital for tick.
+      return getPrecisionSafe(interval) + 2;
+    }
+
+    function clamp(niceTickExtent, idx, extent) {
+      niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);
+    } // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.
+
+
+    function fixExtent(niceTickExtent, extent) {
+      !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);
+      !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);
+      clamp(niceTickExtent, 0, extent);
+      clamp(niceTickExtent, 1, extent);
+
+      if (niceTickExtent[0] > niceTickExtent[1]) {
+        niceTickExtent[0] = niceTickExtent[1];
+      }
+    }
+    function contain$1(val, extent) {
+      return val >= extent[0] && val <= extent[1];
+    }
+    function normalize$1(val, extent) {
+      if (extent[1] === extent[0]) {
+        return 0.5;
+      }
+
+      return (val - extent[0]) / (extent[1] - extent[0]);
+    }
+    function scale$2(val, extent) {
+      return val * (extent[1] - extent[0]) + extent[0];
+    }
+
+    var OrdinalScale =
+    /** @class */
+    function (_super) {
+      __extends(OrdinalScale, _super);
+
+      function OrdinalScale(setting) {
+        var _this = _super.call(this, setting) || this;
+
+        _this.type = 'ordinal';
+
+        var ordinalMeta = _this.getSetting('ordinalMeta'); // Caution: Should not use instanceof, consider ec-extensions using
+        // import approach to get OrdinalMeta class.
+
+
+        if (!ordinalMeta) {
+          ordinalMeta = new OrdinalMeta({});
+        }
+
+        if (isArray(ordinalMeta)) {
+          ordinalMeta = new OrdinalMeta({
+            categories: map(ordinalMeta, function (item) {
+              return isObject(item) ? item.value : item;
+            })
+          });
+        }
+
+        _this._ordinalMeta = ordinalMeta;
+        _this._extent = _this.getSetting('extent') || [0, ordinalMeta.categories.length - 1];
+        return _this;
+      }
+
+      OrdinalScale.prototype.parse = function (val) {
+        return typeof val === 'string' ? this._ordinalMeta.getOrdinal(val) // val might be float.
+        : Math.round(val);
+      };
+
+      OrdinalScale.prototype.contain = function (rank) {
+        rank = this.parse(rank);
+        return contain$1(rank, this._extent) && this._ordinalMeta.categories[rank] != null;
+      };
+      /**
+       * Normalize given rank or name to linear [0, 1]
+       * @param val raw ordinal number.
+       * @return normalized value in [0, 1].
+       */
+
+
+      OrdinalScale.prototype.normalize = function (val) {
+        val = this._getTickNumber(this.parse(val));
+        return normalize$1(val, this._extent);
+      };
+      /**
+       * @param val normalized value in [0, 1].
+       * @return raw ordinal number.
+       */
+
+
+      OrdinalScale.prototype.scale = function (val) {
+        val = Math.round(scale$2(val, this._extent));
+        return this.getRawOrdinalNumber(val);
+      };
+
+      OrdinalScale.prototype.getTicks = function () {
+        var ticks = [];
+        var extent = this._extent;
+        var rank = extent[0];
+
+        while (rank <= extent[1]) {
+          ticks.push({
+            value: rank
+          });
+          rank++;
+        }
+
+        return ticks;
+      };
+
+      OrdinalScale.prototype.getMinorTicks = function (splitNumber) {
+        // Not support.
+        return;
+      };
+      /**
+       * @see `Ordinal['_ordinalNumbersByTick']`
+       */
+
+
+      OrdinalScale.prototype.setSortInfo = function (info) {
+        if (info == null) {
+          this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
+          return;
+        }
+
+        var infoOrdinalNumbers = info.ordinalNumbers;
+        var ordinalsByTick = this._ordinalNumbersByTick = [];
+        var ticksByOrdinal = this._ticksByOrdinalNumber = []; // Unnecessary support negative tick in `realtimeSort`.
+
+        var tickNum = 0;
+        var allCategoryLen = this._ordinalMeta.categories.length;
+
+        for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) {
+          var ordinalNumber = infoOrdinalNumbers[tickNum];
+          ordinalsByTick[tickNum] = ordinalNumber;
+          ticksByOrdinal[ordinalNumber] = tickNum;
+        } // Handle that `series.data` only covers part of the `axis.category.data`.
+
+
+        var unusedOrdinal = 0;
+
+        for (; tickNum < allCategoryLen; ++tickNum) {
+          while (ticksByOrdinal[unusedOrdinal] != null) {
+            unusedOrdinal++;
+          }
+          ordinalsByTick.push(unusedOrdinal);
+          ticksByOrdinal[unusedOrdinal] = tickNum;
+        }
+      };
+
+      OrdinalScale.prototype._getTickNumber = function (ordinal) {
+        var ticksByOrdinalNumber = this._ticksByOrdinalNumber; // also support ordinal out of range of `ordinalMeta.categories.length`,
+        // where ordinal numbers are used as tick value directly.
+
+        return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal;
+      };
+      /**
+       * @usage
+       * ```js
+       * const ordinalNumber = ordinalScale.getRawOrdinalNumber(tickVal);
+       *
+       * // case0
+       * const rawOrdinalValue = axisModel.getCategories()[ordinalNumber];
+       * // case1
+       * const rawOrdinalValue = this._ordinalMeta.categories[ordinalNumber];
+       * // case2
+       * const coord = axis.dataToCoord(ordinalNumber);
+       * ```
+       *
+       * @param {OrdinalNumber} tickNumber index of display
+       */
+
+
+      OrdinalScale.prototype.getRawOrdinalNumber = function (tickNumber) {
+        var ordinalNumbersByTick = this._ordinalNumbersByTick; // tickNumber may be out of range, e.g., when axis max is larger than `ordinalMeta.categories.length`.,
+        // where ordinal numbers are used as tick value directly.
+
+        return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber;
+      };
+      /**
+       * Get item on tick
+       */
+
+
+      OrdinalScale.prototype.getLabel = function (tick) {
+        if (!this.isBlank()) {
+          var ordinalNumber = this.getRawOrdinalNumber(tick.value);
+          var cateogry = this._ordinalMeta.categories[ordinalNumber]; // Note that if no data, ordinalMeta.categories is an empty array.
+          // Return empty if it's not exist.
+
+          return cateogry == null ? '' : cateogry + '';
+        }
+      };
+
+      OrdinalScale.prototype.count = function () {
+        return this._extent[1] - this._extent[0] + 1;
+      };
+
+      OrdinalScale.prototype.unionExtentFromData = function (data, dim) {
+        this.unionExtent(data.getApproximateExtent(dim));
+      };
+      /**
+       * @override
+       * If value is in extent range
+       */
+
+
+      OrdinalScale.prototype.isInExtentRange = function (value) {
+        value = this._getTickNumber(value);
+        return this._extent[0] <= value && this._extent[1] >= value;
+      };
+
+      OrdinalScale.prototype.getOrdinalMeta = function () {
+        return this._ordinalMeta;
+      };
+
+      OrdinalScale.prototype.niceTicks = function () {};
+
+      OrdinalScale.prototype.niceExtent = function () {};
+
+      OrdinalScale.type = 'ordinal';
+      return OrdinalScale;
+    }(Scale);
+
+    Scale.registerClass(OrdinalScale);
+
+    var roundNumber$1 = round;
+
+    var IntervalScale =
+    /** @class */
+    function (_super) {
+      __extends(IntervalScale, _super);
+
+      function IntervalScale() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'interval'; // Step is calculated in adjustExtent.
+
+        _this._interval = 0;
+        _this._intervalPrecision = 2;
+        return _this;
+      }
+
+      IntervalScale.prototype.parse = function (val) {
+        return val;
+      };
+
+      IntervalScale.prototype.contain = function (val) {
+        return contain$1(val, this._extent);
+      };
+
+      IntervalScale.prototype.normalize = function (val) {
+        return normalize$1(val, this._extent);
+      };
+
+      IntervalScale.prototype.scale = function (val) {
+        return scale$2(val, this._extent);
+      };
+
+      IntervalScale.prototype.setExtent = function (start, end) {
+        var thisExtent = this._extent; // start,end may be a Number like '25',so...
+
+        if (!isNaN(start)) {
+          thisExtent[0] = parseFloat(start);
+        }
+
+        if (!isNaN(end)) {
+          thisExtent[1] = parseFloat(end);
+        }
+      };
+
+      IntervalScale.prototype.unionExtent = function (other) {
+        var extent = this._extent;
+        other[0] < extent[0] && (extent[0] = other[0]);
+        other[1] > extent[1] && (extent[1] = other[1]); // unionExtent may called by it's sub classes
+
+        this.setExtent(extent[0], extent[1]);
+      };
+
+      IntervalScale.prototype.getInterval = function () {
+        return this._interval;
+      };
+
+      IntervalScale.prototype.setInterval = function (interval) {
+        this._interval = interval; // Dropped auto calculated niceExtent and use user setted extent
+        // We assume user wan't to set both interval, min, max to get a better result
+
+        this._niceExtent = this._extent.slice();
+        this._intervalPrecision = getIntervalPrecision(interval);
+      };
+      /**
+       * @param expandToNicedExtent Whether expand the ticks to niced extent.
+       */
+
+
+      IntervalScale.prototype.getTicks = function (expandToNicedExtent) {
+        var interval = this._interval;
+        var extent = this._extent;
+        var niceTickExtent = this._niceExtent;
+        var intervalPrecision = this._intervalPrecision;
+        var ticks = []; // If interval is 0, return [];
+
+        if (!interval) {
+          return ticks;
+        } // Consider this case: using dataZoom toolbox, zoom and zoom.
+
+
+        var safeLimit = 10000;
+
+        if (extent[0] < niceTickExtent[0]) {
+          if (expandToNicedExtent) {
+            ticks.push({
+              value: roundNumber$1(niceTickExtent[0] - interval, intervalPrecision)
+            });
+          } else {
+            ticks.push({
+              value: extent[0]
+            });
+          }
+        }
+
+        var tick = niceTickExtent[0];
+
+        while (tick <= niceTickExtent[1]) {
+          ticks.push({
+            value: tick
+          }); // Avoid rounding error
+
+          tick = roundNumber$1(tick + interval, intervalPrecision);
+
+          if (tick === ticks[ticks.length - 1].value) {
+            // Consider out of safe float point, e.g.,
+            // -3711126.9907707 + 2e-10 === -3711126.9907707
+            break;
+          }
+
+          if (ticks.length > safeLimit) {
+            return [];
+          }
+        } // Consider this case: the last item of ticks is smaller
+        // than niceTickExtent[1] and niceTickExtent[1] === extent[1].
+
+
+        var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
+
+        if (extent[1] > lastNiceTick) {
+          if (expandToNicedExtent) {
+            ticks.push({
+              value: roundNumber$1(lastNiceTick + interval, intervalPrecision)
+            });
+          } else {
+            ticks.push({
+              value: extent[1]
+            });
+          }
+        }
+
+        return ticks;
+      };
+
+      IntervalScale.prototype.getMinorTicks = function (splitNumber) {
+        var ticks = this.getTicks(true);
+        var minorTicks = [];
+        var extent = this.getExtent();
+
+        for (var i = 1; i < ticks.length; i++) {
+          var nextTick = ticks[i];
+          var prevTick = ticks[i - 1];
+          var count = 0;
+          var minorTicksGroup = [];
+          var interval = nextTick.value - prevTick.value;
+          var minorInterval = interval / splitNumber;
+
+          while (count < splitNumber - 1) {
+            var minorTick = roundNumber$1(prevTick.value + (count + 1) * minorInterval); // For the first and last interval. The count may be less than splitNumber.
+
+            if (minorTick > extent[0] && minorTick < extent[1]) {
+              minorTicksGroup.push(minorTick);
+            }
+
+            count++;
+          }
+
+          minorTicks.push(minorTicksGroup);
+        }
+
+        return minorTicks;
+      };
+      /**
+       * @param opt.precision If 'auto', use nice presision.
+       * @param opt.pad returns 1.50 but not 1.5 if precision is 2.
+       */
+
+
+      IntervalScale.prototype.getLabel = function (data, opt) {
+        if (data == null) {
+          return '';
+        }
+
+        var precision = opt && opt.precision;
+
+        if (precision == null) {
+          precision = getPrecisionSafe(data.value) || 0;
+        } else if (precision === 'auto') {
+          // Should be more precise then tick.
+          precision = this._intervalPrecision;
+        } // (1) If `precision` is set, 12.005 should be display as '12.00500'.
+        // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
+
+
+        var dataNum = roundNumber$1(data.value, precision, true);
+        return addCommas(dataNum);
+      };
+      /**
+       * @param splitNumber By default `5`.
+       */
+
+
+      IntervalScale.prototype.niceTicks = function (splitNumber, minInterval, maxInterval) {
+        splitNumber = splitNumber || 5;
+        var extent = this._extent;
+        var span = extent[1] - extent[0];
+
+        if (!isFinite(span)) {
+          return;
+        } // User may set axis min 0 and data are all negative
+        // FIXME If it needs to reverse ?
+
+
+        if (span < 0) {
+          span = -span;
+          extent.reverse();
+        }
+
+        var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
+        this._intervalPrecision = result.intervalPrecision;
+        this._interval = result.interval;
+        this._niceExtent = result.niceTickExtent;
+      };
+
+      IntervalScale.prototype.niceExtent = function (opt) {
+        var extent = this._extent; // If extent start and end are same, expand them
+
+        if (extent[0] === extent[1]) {
+          if (extent[0] !== 0) {
+            // Expand extent
+            var expandSize = extent[0]; // In the fowllowing case
+            //      Axis has been fixed max 100
+            //      Plus data are all 100 and axis extent are [100, 100].
+            // Extend to the both side will cause expanded max is larger than fixed max.
+            // So only expand to the smaller side.
+
+            if (!opt.fixMax) {
+              extent[1] += expandSize / 2;
+              extent[0] -= expandSize / 2;
+            } else {
+              extent[0] -= expandSize / 2;
+            }
+          } else {
+            extent[1] = 1;
+          }
+        }
+
+        var span = extent[1] - extent[0]; // If there are no data and extent are [Infinity, -Infinity]
+
+        if (!isFinite(span)) {
+          extent[0] = 0;
+          extent[1] = 1;
+        }
+
+        this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); // let extent = this._extent;
+
+        var interval = this._interval;
+
+        if (!opt.fixMin) {
+          extent[0] = roundNumber$1(Math.floor(extent[0] / interval) * interval);
+        }
+
+        if (!opt.fixMax) {
+          extent[1] = roundNumber$1(Math.ceil(extent[1] / interval) * interval);
+        }
+      };
+
+      IntervalScale.type = 'interval';
+      return IntervalScale;
+    }(Scale);
+
+    Scale.registerClass(IntervalScale);
+
+    var STACK_PREFIX = '__ec_stack_';
+    var LARGE_BAR_MIN_WIDTH = 0.5;
+    var LargeArr = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+
+    function getSeriesStackId(seriesModel) {
+      return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex;
+    }
+
+    function getAxisKey(axis) {
+      return axis.dim + axis.index;
+    }
+    /**
+     * @return {Object} {width, offset, offsetCenter} If axis.type is not 'category', return undefined.
+     */
+
+
+    function getLayoutOnAxis(opt) {
+      var params = [];
+      var baseAxis = opt.axis;
+      var axisKey = 'axis0';
+
+      if (baseAxis.type !== 'category') {
+        return;
+      }
+
+      var bandWidth = baseAxis.getBandWidth();
+
+      for (var i = 0; i < opt.count || 0; i++) {
+        params.push(defaults({
+          bandWidth: bandWidth,
+          axisKey: axisKey,
+          stackId: STACK_PREFIX + i
+        }, opt));
+      }
+
+      var widthAndOffsets = doCalBarWidthAndOffset(params);
+      var result = [];
+
+      for (var i = 0; i < opt.count; i++) {
+        var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
+        item.offsetCenter = item.offset + item.width / 2;
+        result.push(item);
+      }
+
+      return result;
+    }
+    function prepareLayoutBarSeries(seriesType, ecModel) {
+      var seriesModels = [];
+      ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+        // Check series coordinate, do layout for cartesian2d only
+        if (isOnCartesian(seriesModel) && !isInLargeMode(seriesModel)) {
+          seriesModels.push(seriesModel);
+        }
+      });
+      return seriesModels;
+    }
+    /**
+     * Map from (baseAxis.dim + '_' + baseAxis.index) to min gap of two adjacent
+     * values.
+     * This works for time axes, value axes, and log axes.
+     * For a single time axis, return value is in the form like
+     * {'x_0': [1000000]}.
+     * The value of 1000000 is in milliseconds.
+     */
+
+    function getValueAxesMinGaps(barSeries) {
+      /**
+       * Map from axis.index to values.
+       * For a single time axis, axisValues is in the form like
+       * {'x_0': [1495555200000, 1495641600000, 1495728000000]}.
+       * Items in axisValues[x], e.g. 1495555200000, are time values of all
+       * series.
+       */
+      var axisValues = {};
+      each(barSeries, function (seriesModel) {
+        var cartesian = seriesModel.coordinateSystem;
+        var baseAxis = cartesian.getBaseAxis();
+
+        if (baseAxis.type !== 'time' && baseAxis.type !== 'value') {
+          return;
+        }
+
+        var data = seriesModel.getData();
+        var key = baseAxis.dim + '_' + baseAxis.index;
+        var dim = data.mapDimension(baseAxis.dim);
+
+        for (var i = 0, cnt = data.count(); i < cnt; ++i) {
+          var value = data.get(dim, i);
+
+          if (!axisValues[key]) {
+            // No previous data for the axis
+            axisValues[key] = [value];
+          } else {
+            // No value in previous series
+            axisValues[key].push(value);
+          } // Ignore duplicated time values in the same axis
+
+        }
+      });
+      var axisMinGaps = {};
+
+      for (var key in axisValues) {
+        if (axisValues.hasOwnProperty(key)) {
+          var valuesInAxis = axisValues[key];
+
+          if (valuesInAxis) {
+            // Sort axis values into ascending order to calculate gaps
+            valuesInAxis.sort(function (a, b) {
+              return a - b;
+            });
+            var min = null;
+
+            for (var j = 1; j < valuesInAxis.length; ++j) {
+              var delta = valuesInAxis[j] - valuesInAxis[j - 1];
+
+              if (delta > 0) {
+                // Ignore 0 delta because they are of the same axis value
+                min = min === null ? delta : Math.min(min, delta);
+              }
+            } // Set to null if only have one data
+
+
+            axisMinGaps[key] = min;
+          }
+        }
+      }
+
+      return axisMinGaps;
+    }
+
+    function makeColumnLayout(barSeries) {
+      var axisMinGaps = getValueAxesMinGaps(barSeries);
+      var seriesInfoList = [];
+      each(barSeries, function (seriesModel) {
+        var cartesian = seriesModel.coordinateSystem;
+        var baseAxis = cartesian.getBaseAxis();
+        var axisExtent = baseAxis.getExtent();
+        var bandWidth;
+
+        if (baseAxis.type === 'category') {
+          bandWidth = baseAxis.getBandWidth();
+        } else if (baseAxis.type === 'value' || baseAxis.type === 'time') {
+          var key = baseAxis.dim + '_' + baseAxis.index;
+          var minGap = axisMinGaps[key];
+          var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]);
+          var scale = baseAxis.scale.getExtent();
+          var scaleSpan = Math.abs(scale[1] - scale[0]);
+          bandWidth = minGap ? extentSpan / scaleSpan * minGap : extentSpan; // When there is only one data value
+        } else {
+          var data = seriesModel.getData();
+          bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
+        }
+
+        var barWidth = parsePercent$1(seriesModel.get('barWidth'), bandWidth);
+        var barMaxWidth = parsePercent$1(seriesModel.get('barMaxWidth'), bandWidth);
+        var barMinWidth = parsePercent$1( // barMinWidth by default is 1 in cartesian. Because in value axis,
+        // the auto-calculated bar width might be less than 1.
+        seriesModel.get('barMinWidth') || 1, bandWidth);
+        var barGap = seriesModel.get('barGap');
+        var barCategoryGap = seriesModel.get('barCategoryGap');
+        seriesInfoList.push({
+          bandWidth: bandWidth,
+          barWidth: barWidth,
+          barMaxWidth: barMaxWidth,
+          barMinWidth: barMinWidth,
+          barGap: barGap,
+          barCategoryGap: barCategoryGap,
+          axisKey: getAxisKey(baseAxis),
+          stackId: getSeriesStackId(seriesModel)
+        });
+      });
+      return doCalBarWidthAndOffset(seriesInfoList);
+    }
+
+    function doCalBarWidthAndOffset(seriesInfoList) {
+      // Columns info on each category axis. Key is cartesian name
+      var columnsMap = {};
+      each(seriesInfoList, function (seriesInfo, idx) {
+        var axisKey = seriesInfo.axisKey;
+        var bandWidth = seriesInfo.bandWidth;
+        var columnsOnAxis = columnsMap[axisKey] || {
+          bandWidth: bandWidth,
+          remainedWidth: bandWidth,
+          autoWidthCount: 0,
+          categoryGap: null,
+          gap: '20%',
+          stacks: {}
+        };
+        var stacks = columnsOnAxis.stacks;
+        columnsMap[axisKey] = columnsOnAxis;
+        var stackId = seriesInfo.stackId;
+
+        if (!stacks[stackId]) {
+          columnsOnAxis.autoWidthCount++;
+        }
+
+        stacks[stackId] = stacks[stackId] || {
+          width: 0,
+          maxWidth: 0
+        }; // Caution: In a single coordinate system, these barGrid attributes
+        // will be shared by series. Consider that they have default values,
+        // only the attributes set on the last series will work.
+        // Do not change this fact unless there will be a break change.
+
+        var barWidth = seriesInfo.barWidth;
+
+        if (barWidth && !stacks[stackId].width) {
+          // See #6312, do not restrict width.
+          stacks[stackId].width = barWidth;
+          barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+          columnsOnAxis.remainedWidth -= barWidth;
+        }
+
+        var barMaxWidth = seriesInfo.barMaxWidth;
+        barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+        var barMinWidth = seriesInfo.barMinWidth;
+        barMinWidth && (stacks[stackId].minWidth = barMinWidth);
+        var barGap = seriesInfo.barGap;
+        barGap != null && (columnsOnAxis.gap = barGap);
+        var barCategoryGap = seriesInfo.barCategoryGap;
+        barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+      });
+      var result = {};
+      each(columnsMap, function (columnsOnAxis, coordSysName) {
+        result[coordSysName] = {};
+        var stacks = columnsOnAxis.stacks;
+        var bandWidth = columnsOnAxis.bandWidth;
+        var categoryGapPercent = columnsOnAxis.categoryGap;
+
+        if (categoryGapPercent == null) {
+          var columnCount = keys(stacks).length; // More columns in one group
+          // the spaces between group is smaller. Or the column will be too thin.
+
+          categoryGapPercent = Math.max(35 - columnCount * 4, 15) + '%';
+        }
+
+        var categoryGap = parsePercent$1(categoryGapPercent, bandWidth);
+        var barGapPercent = parsePercent$1(columnsOnAxis.gap, 1);
+        var remainedWidth = columnsOnAxis.remainedWidth;
+        var autoWidthCount = columnsOnAxis.autoWidthCount;
+        var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+        autoWidth = Math.max(autoWidth, 0); // Find if any auto calculated bar exceeded maxBarWidth
+
+        each(stacks, function (column) {
+          var maxWidth = column.maxWidth;
+          var minWidth = column.minWidth;
+
+          if (!column.width) {
+            var finalWidth = autoWidth;
+
+            if (maxWidth && maxWidth < finalWidth) {
+              finalWidth = Math.min(maxWidth, remainedWidth);
+            } // `minWidth` has higher priority. `minWidth` decide that wheter the
+            // bar is able to be visible. So `minWidth` should not be restricted
+            // by `maxWidth` or `remainedWidth` (which is from `bandWidth`). In
+            // the extreme cases for `value` axis, bars are allowed to overlap
+            // with each other if `minWidth` specified.
+
+
+            if (minWidth && minWidth > finalWidth) {
+              finalWidth = minWidth;
+            }
+
+            if (finalWidth !== autoWidth) {
+              column.width = finalWidth;
+              remainedWidth -= finalWidth + barGapPercent * finalWidth;
+              autoWidthCount--;
+            }
+          } else {
+            // `barMinWidth/barMaxWidth` has higher priority than `barWidth`, as
+            // CSS does. Becuase barWidth can be a percent value, where
+            // `barMaxWidth` can be used to restrict the final width.
+            var finalWidth = column.width;
+
+            if (maxWidth) {
+              finalWidth = Math.min(finalWidth, maxWidth);
+            } // `minWidth` has higher priority, as described above
+
+
+            if (minWidth) {
+              finalWidth = Math.max(finalWidth, minWidth);
+            }
+
+            column.width = finalWidth;
+            remainedWidth -= finalWidth + barGapPercent * finalWidth;
+            autoWidthCount--;
+          }
+        }); // Recalculate width again
+
+        autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+        autoWidth = Math.max(autoWidth, 0);
+        var widthSum = 0;
+        var lastColumn;
+        each(stacks, function (column, idx) {
+          if (!column.width) {
+            column.width = autoWidth;
+          }
+
+          lastColumn = column;
+          widthSum += column.width * (1 + barGapPercent);
+        });
+
+        if (lastColumn) {
+          widthSum -= lastColumn.width * barGapPercent;
+        }
+
+        var offset = -widthSum / 2;
+        each(stacks, function (column, stackId) {
+          result[coordSysName][stackId] = result[coordSysName][stackId] || {
+            bandWidth: bandWidth,
+            offset: offset,
+            width: column.width
+          };
+          offset += column.width * (1 + barGapPercent);
+        });
+      });
+      return result;
+    }
+
+    function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
+      if (barWidthAndOffset && axis) {
+        var result = barWidthAndOffset[getAxisKey(axis)];
+
+        if (result != null && seriesModel != null) {
+          return result[getSeriesStackId(seriesModel)];
+        }
+
+        return result;
+      }
+    }
+    function layout(seriesType, ecModel) {
+      var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
+      var barWidthAndOffset = makeColumnLayout(seriesModels);
+      var lastStackCoords = {};
+      each(seriesModels, function (seriesModel) {
+        var data = seriesModel.getData();
+        var cartesian = seriesModel.coordinateSystem;
+        var baseAxis = cartesian.getBaseAxis();
+        var stackId = getSeriesStackId(seriesModel);
+        var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
+        var columnOffset = columnLayoutInfo.offset;
+        var columnWidth = columnLayoutInfo.width;
+        var valueAxis = cartesian.getOtherAxis(baseAxis);
+        var barMinHeight = seriesModel.get('barMinHeight') || 0;
+        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
+        data.setLayout({
+          bandWidth: columnLayoutInfo.bandWidth,
+          offset: columnOffset,
+          size: columnWidth
+        });
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim
+        /*, baseDim*/
+        );
+        var isValueAxisH = valueAxis.isHorizontal();
+        var valueAxisStart = getValueAxisStart(baseAxis, valueAxis);
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+          var value = data.get(valueDim, idx);
+          var baseValue = data.get(baseDim, idx);
+          var sign = value >= 0 ? 'p' : 'n';
+          var baseCoord = valueAxisStart; // Because of the barMinHeight, we can not use the value in
+          // stackResultDimension directly.
+
+          if (stacked) {
+            // Only ordinal axis can be stacked.
+            if (!lastStackCoords[stackId][baseValue]) {
+              lastStackCoords[stackId][baseValue] = {
+                p: valueAxisStart,
+                n: valueAxisStart // Negative stack
+
+              };
+            } // Should also consider #4243
+
+
+            baseCoord = lastStackCoords[stackId][baseValue][sign];
+          }
+
+          var x = void 0;
+          var y = void 0;
+          var width = void 0;
+          var height = void 0;
+
+          if (isValueAxisH) {
+            var coord = cartesian.dataToPoint([value, baseValue]);
+            x = baseCoord;
+            y = coord[1] + columnOffset;
+            width = coord[0] - valueAxisStart;
+            height = columnWidth;
+
+            if (Math.abs(width) < barMinHeight) {
+              width = (width < 0 ? -1 : 1) * barMinHeight;
+            } // Ignore stack from NaN value
+
+
+            if (!isNaN(width)) {
+              stacked && (lastStackCoords[stackId][baseValue][sign] += width);
+            }
+          } else {
+            var coord = cartesian.dataToPoint([baseValue, value]);
+            x = coord[0] + columnOffset;
+            y = baseCoord;
+            width = columnWidth;
+            height = coord[1] - valueAxisStart;
+
+            if (Math.abs(height) < barMinHeight) {
+              // Include zero to has a positive bar
+              height = (height <= 0 ? -1 : 1) * barMinHeight;
+            } // Ignore stack from NaN value
+
+
+            if (!isNaN(height)) {
+              stacked && (lastStackCoords[stackId][baseValue][sign] += height);
+            }
+          }
+
+          data.setItemLayout(idx, {
+            x: x,
+            y: y,
+            width: width,
+            height: height
+          });
+        }
+      });
+    } // TODO: Do not support stack in large mode yet.
+
+    var largeLayout = {
+      seriesType: 'bar',
+      plan: createRenderPlanner(),
+      reset: function (seriesModel) {
+        if (!isOnCartesian(seriesModel) || !isInLargeMode(seriesModel)) {
+          return;
+        }
+
+        var data = seriesModel.getData();
+        var cartesian = seriesModel.coordinateSystem;
+        var coordLayout = cartesian.master.getRect();
+        var baseAxis = cartesian.getBaseAxis();
+        var valueAxis = cartesian.getOtherAxis(baseAxis);
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var valueAxisHorizontal = valueAxis.isHorizontal();
+        var valueDimIdx = valueAxisHorizontal ? 0 : 1;
+        var barWidth = retrieveColumnLayout(makeColumnLayout([seriesModel]), baseAxis, seriesModel).width;
+
+        if (!(barWidth > LARGE_BAR_MIN_WIDTH)) {
+          // jshint ignore:line
+          barWidth = LARGE_BAR_MIN_WIDTH;
+        }
+
+        return {
+          progress: function (params, data) {
+            var count = params.count;
+            var largePoints = new LargeArr(count * 2);
+            var largeBackgroundPoints = new LargeArr(count * 2);
+            var largeDataIndices = new LargeArr(count);
+            var dataIndex;
+            var coord = [];
+            var valuePair = [];
+            var pointsOffset = 0;
+            var idxOffset = 0;
+
+            while ((dataIndex = params.next()) != null) {
+              valuePair[valueDimIdx] = data.get(valueDim, dataIndex);
+              valuePair[1 - valueDimIdx] = data.get(baseDim, dataIndex);
+              coord = cartesian.dataToPoint(valuePair, null, coord); // Data index might not be in order, depends on `progressiveChunkMode`.
+
+              largeBackgroundPoints[pointsOffset] = valueAxisHorizontal ? coordLayout.x + coordLayout.width : coord[0];
+              largePoints[pointsOffset++] = coord[0];
+              largeBackgroundPoints[pointsOffset] = valueAxisHorizontal ? coord[1] : coordLayout.y + coordLayout.height;
+              largePoints[pointsOffset++] = coord[1];
+              largeDataIndices[idxOffset++] = dataIndex;
+            }
+
+            data.setLayout({
+              largePoints: largePoints,
+              largeDataIndices: largeDataIndices,
+              largeBackgroundPoints: largeBackgroundPoints,
+              barWidth: barWidth,
+              valueAxisStart: getValueAxisStart(baseAxis, valueAxis),
+              backgroundStart: valueAxisHorizontal ? coordLayout.x : coordLayout.y,
+              valueAxisHorizontal: valueAxisHorizontal
+            });
+          }
+        };
+      }
+    };
+
+    function isOnCartesian(seriesModel) {
+      return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d';
+    }
+
+    function isInLargeMode(seriesModel) {
+      return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
+    } // See cases in `test/bar-start.html` and `#7412`, `#8747`.
+
+
+    function getValueAxisStart(baseAxis, valueAxis, stacked) {
+      return valueAxis.toGlobalCoord(valueAxis.dataToCoord(valueAxis.type === 'log' ? 1 : 0));
+    }
+
+    var bisect = function (a, x, lo, hi) {
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+
+        if (a[mid][1] < x) {
+          lo = mid + 1;
+        } else {
+          hi = mid;
+        }
+      }
+
+      return lo;
+    };
+
+    var TimeScale =
+    /** @class */
+    function (_super) {
+      __extends(TimeScale, _super);
+
+      function TimeScale(settings) {
+        var _this = _super.call(this, settings) || this;
+
+        _this.type = 'time';
+        return _this;
+      }
+      /**
+       * Get label is mainly for other components like dataZoom, tooltip.
+       */
+
+
+      TimeScale.prototype.getLabel = function (tick) {
+        var useUTC = this.getSetting('useUTC');
+        return format(tick.value, fullLeveledFormatter[getDefaultFormatPrecisionOfInterval(getPrimaryTimeUnit(this._minLevelUnit))] || fullLeveledFormatter.second, useUTC, this.getSetting('locale'));
+      };
+
+      TimeScale.prototype.getFormattedLabel = function (tick, idx, labelFormatter) {
+        var isUTC = this.getSetting('useUTC');
+        var lang = this.getSetting('locale');
+        return leveledFormat(tick, idx, labelFormatter, lang, isUTC);
+      };
+      /**
+       * @override
+       * @param expandToNicedExtent Whether expand the ticks to niced extent.
+       */
+
+
+      TimeScale.prototype.getTicks = function (expandToNicedExtent) {
+        var interval = this._interval;
+        var extent = this._extent;
+        var ticks = []; // If interval is 0, return [];
+
+        if (!interval) {
+          return ticks;
+        }
+
+        ticks.push({
+          value: extent[0],
+          level: 0
+        });
+        var useUTC = this.getSetting('useUTC');
+        var innerTicks = getIntervalTicks(this._minLevelUnit, this._approxInterval, useUTC, extent);
+        ticks = ticks.concat(innerTicks);
+        ticks.push({
+          value: extent[1],
+          level: 0
+        });
+        return ticks;
+      };
+
+      TimeScale.prototype.niceExtent = function (opt) {
+        var extent = this._extent; // If extent start and end are same, expand them
+
+        if (extent[0] === extent[1]) {
+          // Expand extent
+          extent[0] -= ONE_DAY;
+          extent[1] += ONE_DAY;
+        } // If there are no data and extent are [Infinity, -Infinity]
+
+
+        if (extent[1] === -Infinity && extent[0] === Infinity) {
+          var d = new Date();
+          extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());
+          extent[0] = extent[1] - ONE_DAY;
+        }
+
+        this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+      };
+
+      TimeScale.prototype.niceTicks = function (approxTickNum, minInterval, maxInterval) {
+        approxTickNum = approxTickNum || 10;
+        var extent = this._extent;
+        var span = extent[1] - extent[0];
+        this._approxInterval = span / approxTickNum;
+
+        if (minInterval != null && this._approxInterval < minInterval) {
+          this._approxInterval = minInterval;
+        }
+
+        if (maxInterval != null && this._approxInterval > maxInterval) {
+          this._approxInterval = maxInterval;
+        }
+
+        var scaleIntervalsLen = scaleIntervals.length;
+        var idx = Math.min(bisect(scaleIntervals, this._approxInterval, 0, scaleIntervalsLen), scaleIntervalsLen - 1); // Interval that can be used to calculate ticks
+
+        this._interval = scaleIntervals[idx][1]; // Min level used when picking ticks from top down.
+        // We check one more level to avoid the ticks are to sparse in some case.
+
+        this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0];
+      };
+
+      TimeScale.prototype.parse = function (val) {
+        // val might be float.
+        return typeof val === 'number' ? val : +parseDate(val);
+      };
+
+      TimeScale.prototype.contain = function (val) {
+        return contain$1(this.parse(val), this._extent);
+      };
+
+      TimeScale.prototype.normalize = function (val) {
+        return normalize$1(this.parse(val), this._extent);
+      };
+
+      TimeScale.prototype.scale = function (val) {
+        return scale$2(val, this._extent);
+      };
+
+      TimeScale.type = 'time';
+      return TimeScale;
+    }(IntervalScale);
+    /**
+     * This implementation was originally copied from "d3.js"
+     * <https://github.com/d3/d3/blob/b516d77fb8566b576088e73410437494717ada26/src/time/scale.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     */
+
+
+    var scaleIntervals = [// Format                           interval
+    ['second', ONE_SECOND], ['minute', ONE_MINUTE], ['hour', ONE_HOUR], ['quarter-day', ONE_HOUR * 6], ['half-day', ONE_HOUR * 12], ['day', ONE_DAY * 1.2], ['half-week', ONE_DAY * 3.5], ['week', ONE_DAY * 7], ['month', ONE_DAY * 31], ['quarter', ONE_DAY * 95], ['half-year', ONE_YEAR / 2], ['year', ONE_YEAR] // 1Y
+    ];
+
+    function isUnitValueSame(unit, valueA, valueB, isUTC) {
+      var dateA = parseDate(valueA);
+      var dateB = parseDate(valueB);
+
+      var isSame = function (unit) {
+        return getUnitValue(dateA, unit, isUTC) === getUnitValue(dateB, unit, isUTC);
+      };
+
+      var isSameYear = function () {
+        return isSame('year');
+      }; // const isSameHalfYear = () => isSameYear() && isSame('half-year');
+      // const isSameQuater = () => isSameYear() && isSame('quarter');
+
+
+      var isSameMonth = function () {
+        return isSameYear() && isSame('month');
+      };
+
+      var isSameDay = function () {
+        return isSameMonth() && isSame('day');
+      }; // const isSameHalfDay = () => isSameDay() && isSame('half-day');
+
+
+      var isSameHour = function () {
+        return isSameDay() && isSame('hour');
+      };
+
+      var isSameMinute = function () {
+        return isSameHour() && isSame('minute');
+      };
+
+      var isSameSecond = function () {
+        return isSameMinute() && isSame('second');
+      };
+
+      var isSameMilliSecond = function () {
+        return isSameSecond() && isSame('millisecond');
+      };
+
+      switch (unit) {
+        case 'year':
+          return isSameYear();
+
+        case 'month':
+          return isSameMonth();
+
+        case 'day':
+          return isSameDay();
+
+        case 'hour':
+          return isSameHour();
+
+        case 'minute':
+          return isSameMinute();
+
+        case 'second':
+          return isSameSecond();
+
+        case 'millisecond':
+          return isSameMilliSecond();
+      }
+    } // const primaryUnitGetters = {
+    //     year: fullYearGetterName(),
+    //     month: monthGetterName(),
+    //     day: dateGetterName(),
+    //     hour: hoursGetterName(),
+    //     minute: minutesGetterName(),
+    //     second: secondsGetterName(),
+    //     millisecond: millisecondsGetterName()
+    // };
+    // const primaryUnitUTCGetters = {
+    //     year: fullYearGetterName(true),
+    //     month: monthGetterName(true),
+    //     day: dateGetterName(true),
+    //     hour: hoursGetterName(true),
+    //     minute: minutesGetterName(true),
+    //     second: secondsGetterName(true),
+    //     millisecond: millisecondsGetterName(true)
+    // };
+    // function moveTick(date: Date, unitName: TimeUnit, step: number, isUTC: boolean) {
+    //     step = step || 1;
+    //     switch (getPrimaryTimeUnit(unitName)) {
+    //         case 'year':
+    //             date[fullYearSetterName(isUTC)](date[fullYearGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'month':
+    //             date[monthSetterName(isUTC)](date[monthGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'day':
+    //             date[dateSetterName(isUTC)](date[dateGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'hour':
+    //             date[hoursSetterName(isUTC)](date[hoursGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'minute':
+    //             date[minutesSetterName(isUTC)](date[minutesGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'second':
+    //             date[secondsSetterName(isUTC)](date[secondsGetterName(isUTC)]() + step);
+    //             break;
+    //         case 'millisecond':
+    //             date[millisecondsSetterName(isUTC)](date[millisecondsGetterName(isUTC)]() + step);
+    //             break;
+    //     }
+    //     return date.getTime();
+    // }
+    // const DATE_INTERVALS = [[8, 7.5], [4, 3.5], [2, 1.5]];
+    // const MONTH_INTERVALS = [[6, 5.5], [3, 2.5], [2, 1.5]];
+    // const MINUTES_SECONDS_INTERVALS = [[30, 30], [20, 20], [15, 15], [10, 10], [5, 5], [2, 2]];
+
+
+    function getDateInterval(approxInterval, daysInMonth) {
+      approxInterval /= ONE_DAY;
+      return approxInterval > 16 ? 16 // Math.floor(daysInMonth / 2) + 1  // In this case we only want one tick betwen two month.
+      : approxInterval > 7.5 ? 7 // TODO week 7 or day 8?
+      : approxInterval > 3.5 ? 4 : approxInterval > 1.5 ? 2 : 1;
+    }
+
+    function getMonthInterval(approxInterval) {
+      var APPROX_ONE_MONTH = 30 * ONE_DAY;
+      approxInterval /= APPROX_ONE_MONTH;
+      return approxInterval > 6 ? 6 : approxInterval > 3 ? 3 : approxInterval > 2 ? 2 : 1;
+    }
+
+    function getHourInterval(approxInterval) {
+      approxInterval /= ONE_HOUR;
+      return approxInterval > 12 ? 12 : approxInterval > 6 ? 6 : approxInterval > 3.5 ? 4 : approxInterval > 2 ? 2 : 1;
+    }
+
+    function getMinutesAndSecondsInterval(approxInterval, isMinutes) {
+      approxInterval /= isMinutes ? ONE_MINUTE : ONE_SECOND;
+      return approxInterval > 30 ? 30 : approxInterval > 20 ? 20 : approxInterval > 15 ? 15 : approxInterval > 10 ? 10 : approxInterval > 5 ? 5 : approxInterval > 2 ? 2 : 1;
+    }
+
+    function getMillisecondsInterval(approxInterval) {
+      return nice(approxInterval, true);
+    }
+
+    function getFirstTimestampOfUnit(date, unitName, isUTC) {
+      var outDate = new Date(date);
+
+      switch (getPrimaryTimeUnit(unitName)) {
+        case 'year':
+        case 'month':
+          outDate[monthSetterName(isUTC)](0);
+
+        case 'day':
+          outDate[dateSetterName(isUTC)](1);
+
+        case 'hour':
+          outDate[hoursSetterName(isUTC)](0);
+
+        case 'minute':
+          outDate[minutesSetterName(isUTC)](0);
+
+        case 'second':
+          outDate[secondsSetterName(isUTC)](0);
+          outDate[millisecondsSetterName(isUTC)](0);
+      }
+
+      return outDate.getTime();
+    }
+
+    function getIntervalTicks(bottomUnitName, approxInterval, isUTC, extent) {
+      var safeLimit = 10000;
+      var unitNames = timeUnits;
+      var iter = 0;
+
+      function addTicksInSpan(interval, minTimestamp, maxTimestamp, getMethodName, setMethodName, isDate, out) {
+        var date = new Date(minTimestamp);
+        var dateTime = minTimestamp;
+        var d = date[getMethodName](); // if (isDate) {
+        //     d -= 1; // Starts with 0;   PENDING
+        // }
+
+        while (dateTime < maxTimestamp && dateTime <= extent[1]) {
+          out.push({
+            value: dateTime
+          });
+          d += interval;
+          date[setMethodName](d);
+          dateTime = date.getTime();
+        } // This extra tick is for calcuating ticks of next level. Will not been added to the final result
+
+
+        out.push({
+          value: dateTime,
+          notAdd: true
+        });
+      }
+
+      function addLevelTicks(unitName, lastLevelTicks, levelTicks) {
+        var newAddedTicks = [];
+        var isFirstLevel = !lastLevelTicks.length;
+
+        if (isUnitValueSame(getPrimaryTimeUnit(unitName), extent[0], extent[1], isUTC)) {
+          return;
+        }
+
+        if (isFirstLevel) {
+          lastLevelTicks = [{
+            // TODO Optimize. Not include so may ticks.
+            value: getFirstTimestampOfUnit(new Date(extent[0]), unitName, isUTC)
+          }, {
+            value: extent[1]
+          }];
+        }
+
+        for (var i = 0; i < lastLevelTicks.length - 1; i++) {
+          var startTick = lastLevelTicks[i].value;
+          var endTick = lastLevelTicks[i + 1].value;
+
+          if (startTick === endTick) {
+            continue;
+          }
+
+          var interval = void 0;
+          var getterName = void 0;
+          var setterName = void 0;
+          var isDate = false;
+
+          switch (unitName) {
+            case 'year':
+              interval = Math.max(1, Math.round(approxInterval / ONE_DAY / 365));
+              getterName = fullYearGetterName(isUTC);
+              setterName = fullYearSetterName(isUTC);
+              break;
+
+            case 'half-year':
+            case 'quarter':
+            case 'month':
+              interval = getMonthInterval(approxInterval);
+              getterName = monthGetterName(isUTC);
+              setterName = monthSetterName(isUTC);
+              break;
+
+            case 'week': // PENDING If week is added. Ignore day.
+
+            case 'half-week':
+            case 'day':
+              interval = getDateInterval(approxInterval); // Use 32 days and let interval been 16
+
+              getterName = dateGetterName(isUTC);
+              setterName = dateSetterName(isUTC);
+              isDate = true;
+              break;
+
+            case 'half-day':
+            case 'quarter-day':
+            case 'hour':
+              interval = getHourInterval(approxInterval);
+              getterName = hoursGetterName(isUTC);
+              setterName = hoursSetterName(isUTC);
+              break;
+
+            case 'minute':
+              interval = getMinutesAndSecondsInterval(approxInterval, true);
+              getterName = minutesGetterName(isUTC);
+              setterName = minutesSetterName(isUTC);
+              break;
+
+            case 'second':
+              interval = getMinutesAndSecondsInterval(approxInterval, false);
+              getterName = secondsGetterName(isUTC);
+              setterName = secondsSetterName(isUTC);
+              break;
+
+            case 'millisecond':
+              interval = getMillisecondsInterval(approxInterval);
+              getterName = millisecondsGetterName(isUTC);
+              setterName = millisecondsSetterName(isUTC);
+              break;
+          }
+
+          addTicksInSpan(interval, startTick, endTick, getterName, setterName, isDate, newAddedTicks);
+
+          if (unitName === 'year' && levelTicks.length > 1 && i === 0) {
+            // Add nearest years to the left extent.
+            levelTicks.unshift({
+              value: levelTicks[0].value - interval
+            });
+          }
+        }
+
+        for (var i = 0; i < newAddedTicks.length; i++) {
+          levelTicks.push(newAddedTicks[i]);
+        } // newAddedTicks.length && console.log(unitName, newAddedTicks);
+
+
+        return newAddedTicks;
+      }
+
+      var levelsTicks = [];
+      var currentLevelTicks = [];
+      var tickCount = 0;
+      var lastLevelTickCount = 0;
+
+      for (var i = 0; i < unitNames.length && iter++ < safeLimit; ++i) {
+        var primaryTimeUnit = getPrimaryTimeUnit(unitNames[i]);
+
+        if (!isPrimaryTimeUnit(unitNames[i])) {
+          // TODO
+          continue;
+        }
+
+        addLevelTicks(unitNames[i], levelsTicks[levelsTicks.length - 1] || [], currentLevelTicks);
+        var nextPrimaryTimeUnit = unitNames[i + 1] ? getPrimaryTimeUnit(unitNames[i + 1]) : null;
+
+        if (primaryTimeUnit !== nextPrimaryTimeUnit) {
+          if (currentLevelTicks.length) {
+            lastLevelTickCount = tickCount; // Remove the duplicate so the tick count can be precisely.
+
+            currentLevelTicks.sort(function (a, b) {
+              return a.value - b.value;
+            });
+            var levelTicksRemoveDuplicated = [];
+
+            for (var i_1 = 0; i_1 < currentLevelTicks.length; ++i_1) {
+              var tickValue = currentLevelTicks[i_1].value;
+
+              if (i_1 === 0 || currentLevelTicks[i_1 - 1].value !== tickValue) {
+                levelTicksRemoveDuplicated.push(currentLevelTicks[i_1]);
+
+                if (tickValue >= extent[0] && tickValue <= extent[1]) {
+                  tickCount++;
+                }
+              }
+            }
+
+            var targetTickNum = (extent[1] - extent[0]) / approxInterval; // Added too much in this level and not too less in last level
+
+            if (tickCount > targetTickNum * 1.5 && lastLevelTickCount > targetTickNum / 1.5) {
+              break;
+            } // Only treat primary time unit as one level.
+
+
+            levelsTicks.push(levelTicksRemoveDuplicated);
+
+            if (tickCount > targetTickNum || bottomUnitName === unitNames[i]) {
+              break;
+            }
+          } // Reset if next unitName is primary
+
+
+          currentLevelTicks = [];
+        }
+      }
+
+      if ("development" !== 'production') {
+        if (iter >= safeLimit) {
+          warn('Exceed safe limit.');
+        }
+      }
+
+      var levelsTicksInExtent = filter(map(levelsTicks, function (levelTicks) {
+        return filter(levelTicks, function (tick) {
+          return tick.value >= extent[0] && tick.value <= extent[1] && !tick.notAdd;
+        });
+      }), function (levelTicks) {
+        return levelTicks.length > 0;
+      });
+      var ticks = [];
+      var maxLevel = levelsTicksInExtent.length - 1;
+
+      for (var i = 0; i < levelsTicksInExtent.length; ++i) {
+        var levelTicks = levelsTicksInExtent[i];
+
+        for (var k = 0; k < levelTicks.length; ++k) {
+          ticks.push({
+            value: levelTicks[k].value,
+            level: maxLevel - i
+          });
+        }
+      }
+
+      ticks.sort(function (a, b) {
+        return a.value - b.value;
+      }); // Remove duplicates
+
+      var result = [];
+
+      for (var i = 0; i < ticks.length; ++i) {
+        if (i === 0 || ticks[i].value !== ticks[i - 1].value) {
+          result.push(ticks[i]);
+        }
+      }
+
+      return result;
+    }
+
+    Scale.registerClass(TimeScale);
+
+    var scaleProto = Scale.prototype; // FIXME:TS refactor: not good to call it directly with `this`?
+
+    var intervalScaleProto = IntervalScale.prototype;
+    var getPrecisionSafe$1 = getPrecisionSafe;
+    var roundingErrorFix = round;
+    var mathFloor$1 = Math.floor;
+    var mathCeil = Math.ceil;
+    var mathPow$1 = Math.pow;
+    var mathLog = Math.log;
+
+    var LogScale =
+    /** @class */
+    function (_super) {
+      __extends(LogScale, _super);
+
+      function LogScale() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'log';
+        _this.base = 10;
+        _this._originalScale = new IntervalScale(); // FIXME:TS actually used by `IntervalScale`
+
+        _this._interval = 0;
+        return _this;
+      }
+      /**
+       * @param Whether expand the ticks to niced extent.
+       */
+
+
+      LogScale.prototype.getTicks = function (expandToNicedExtent) {
+        var originalScale = this._originalScale;
+        var extent = this._extent;
+        var originalExtent = originalScale.getExtent();
+        var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
+        return map(ticks, function (tick) {
+          var val = tick.value;
+          var powVal = round(mathPow$1(this.base, val)); // Fix #4158
+
+          powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
+          powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
+          return {
+            value: powVal
+          };
+        }, this);
+      };
+
+      LogScale.prototype.setExtent = function (start, end) {
+        var base = this.base;
+        start = mathLog(start) / mathLog(base);
+        end = mathLog(end) / mathLog(base);
+        intervalScaleProto.setExtent.call(this, start, end);
+      };
+      /**
+       * @return {number} end
+       */
+
+
+      LogScale.prototype.getExtent = function () {
+        var base = this.base;
+        var extent = scaleProto.getExtent.call(this);
+        extent[0] = mathPow$1(base, extent[0]);
+        extent[1] = mathPow$1(base, extent[1]); // Fix #4158
+
+        var originalScale = this._originalScale;
+        var originalExtent = originalScale.getExtent();
+        this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
+        this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
+        return extent;
+      };
+
+      LogScale.prototype.unionExtent = function (extent) {
+        this._originalScale.unionExtent(extent);
+
+        var base = this.base;
+        extent[0] = mathLog(extent[0]) / mathLog(base);
+        extent[1] = mathLog(extent[1]) / mathLog(base);
+        scaleProto.unionExtent.call(this, extent);
+      };
+
+      LogScale.prototype.unionExtentFromData = function (data, dim) {
+        // TODO
+        // filter value that <= 0
+        this.unionExtent(data.getApproximateExtent(dim));
+      };
+      /**
+       * Update interval and extent of intervals for nice ticks
+       * @param approxTickNum default 10 Given approx tick number
+       */
+
+
+      LogScale.prototype.niceTicks = function (approxTickNum) {
+        approxTickNum = approxTickNum || 10;
+        var extent = this._extent;
+        var span = extent[1] - extent[0];
+
+        if (span === Infinity || span <= 0) {
+          return;
+        }
+
+        var interval = quantity(span);
+        var err = approxTickNum / span * interval; // Filter ticks to get closer to the desired count.
+
+        if (err <= 0.5) {
+          interval *= 10;
+        } // Interval should be integer
+
+
+        while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
+          interval *= 10;
+        }
+
+        var niceExtent = [round(mathCeil(extent[0] / interval) * interval), round(mathFloor$1(extent[1] / interval) * interval)];
+        this._interval = interval;
+        this._niceExtent = niceExtent;
+      };
+
+      LogScale.prototype.niceExtent = function (opt) {
+        intervalScaleProto.niceExtent.call(this, opt);
+        this._fixMin = opt.fixMin;
+        this._fixMax = opt.fixMax;
+      };
+
+      LogScale.prototype.parse = function (val) {
+        return val;
+      };
+
+      LogScale.prototype.contain = function (val) {
+        val = mathLog(val) / mathLog(this.base);
+        return contain$1(val, this._extent);
+      };
+
+      LogScale.prototype.normalize = function (val) {
+        val = mathLog(val) / mathLog(this.base);
+        return normalize$1(val, this._extent);
+      };
+
+      LogScale.prototype.scale = function (val) {
+        val = scale$2(val, this._extent);
+        return mathPow$1(this.base, val);
+      };
+
+      LogScale.type = 'log';
+      return LogScale;
+    }(Scale);
+
+    var proto = LogScale.prototype;
+    proto.getMinorTicks = intervalScaleProto.getMinorTicks;
+    proto.getLabel = intervalScaleProto.getLabel;
+
+    function fixRoundingError(val, originalVal) {
+      return roundingErrorFix(val, getPrecisionSafe$1(originalVal));
+    }
+
+    Scale.registerClass(LogScale);
+
+    var ScaleRawExtentInfo =
+    /** @class */
+    function () {
+      function ScaleRawExtentInfo(scale, model, // Usually: data extent from all series on this axis.
+      originalExtent) {
+        this._prepareParams(scale, model, originalExtent);
+      }
+      /**
+       * Parameters depending on ouside (like model, user callback)
+       * are prepared and fixed here.
+       */
+
+
+      ScaleRawExtentInfo.prototype._prepareParams = function (scale, model, // Usually: data extent from all series on this axis.
+      dataExtent) {
+        if (dataExtent[1] < dataExtent[0]) {
+          dataExtent = [NaN, NaN];
+        }
+
+        this._dataMin = dataExtent[0];
+        this._dataMax = dataExtent[1];
+        var isOrdinal = this._isOrdinal = scale.type === 'ordinal';
+        this._needCrossZero = model.getNeedCrossZero && model.getNeedCrossZero();
+        var modelMinRaw = this._modelMinRaw = model.get('min', true);
+
+        if (isFunction(modelMinRaw)) {
+          // This callback alway provide users the full data extent (before data filtered).
+          this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw({
+            min: dataExtent[0],
+            max: dataExtent[1]
+          }));
+        } else if (modelMinRaw !== 'dataMin') {
+          this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw);
+        }
+
+        var modelMaxRaw = this._modelMaxRaw = model.get('max', true);
+
+        if (isFunction(modelMaxRaw)) {
+          // This callback alway provide users the full data extent (before data filtered).
+          this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw({
+            min: dataExtent[0],
+            max: dataExtent[1]
+          }));
+        } else if (modelMaxRaw !== 'dataMax') {
+          this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw);
+        }
+
+        if (isOrdinal) {
+          // FIXME: there is a flaw here: if there is no "block" data processor like `dataZoom`,
+          // and progressive rendering is using, here the category result might just only contain
+          // the processed chunk rather than the entire result.
+          this._axisDataLen = model.getCategories().length;
+        } else {
+          var boundaryGap = model.get('boundaryGap');
+          var boundaryGapArr = isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0];
+
+          if (typeof boundaryGapArr[0] === 'boolean' || typeof boundaryGapArr[1] === 'boolean') {
+            if ("development" !== 'production') {
+              console.warn('Boolean type for boundaryGap is only ' + 'allowed for ordinal axis. Please use string in ' + 'percentage instead, e.g., "20%". Currently, ' + 'boundaryGap is set to be 0.');
+            }
+
+            this._boundaryGapInner = [0, 0];
+          } else {
+            this._boundaryGapInner = [parsePercent(boundaryGapArr[0], 1), parsePercent(boundaryGapArr[1], 1)];
+          }
+        }
+      };
+      /**
+       * Calculate extent by prepared parameters.
+       * This method has no external dependency and can be called duplicatedly,
+       * getting the same result.
+       * If parameters changed, should call this method to recalcuate.
+       */
+
+
+      ScaleRawExtentInfo.prototype.calculate = function () {
+        // Notice: When min/max is not set (that is, when there are null/undefined,
+        // which is the most common case), these cases should be ensured:
+        // (1) For 'ordinal', show all axis.data.
+        // (2) For others:
+        //      + `boundaryGap` is applied (if min/max set, boundaryGap is
+        //      disabled).
+        //      + If `needCrossZero`, min/max should be zero, otherwise, min/max should
+        //      be the result that originalExtent enlarged by boundaryGap.
+        // (3) If no data, it should be ensured that `scale.setBlank` is set.
+        var isOrdinal = this._isOrdinal;
+        var dataMin = this._dataMin;
+        var dataMax = this._dataMax;
+        var axisDataLen = this._axisDataLen;
+        var boundaryGapInner = this._boundaryGapInner;
+        var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null; // Currently if a `'value'` axis model min is specified as 'dataMin'/'dataMax',
+        // `boundaryGap` will not be used. It's the different from specifying as `null`/`undefined`.
+
+        var min = this._modelMinRaw === 'dataMin' ? dataMin : this._modelMinNum;
+        var max = this._modelMaxRaw === 'dataMax' ? dataMax : this._modelMaxNum; // If `_modelMinNum`/`_modelMaxNum` is `null`/`undefined`, should not be fixed.
+
+        var minFixed = min != null;
+        var maxFixed = max != null;
+
+        if (min == null) {
+          min = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span;
+        }
+
+        if (max == null) {
+          max = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span;
+        }
+
+        (min == null || !isFinite(min)) && (min = NaN);
+        (max == null || !isFinite(max)) && (max = NaN);
+
+        if (min > max) {
+          min = NaN;
+          max = NaN;
+        }
+
+        var isBlank = eqNaN(min) || eqNaN(max) || isOrdinal && !axisDataLen; // If data extent modified, need to recalculated to ensure cross zero.
+
+        if (this._needCrossZero) {
+          // Axis is over zero and min is not set
+          if (min > 0 && max > 0 && !minFixed) {
+            min = 0; // minFixed = true;
+          } // Axis is under zero and max is not set
+
+
+          if (min < 0 && max < 0 && !maxFixed) {
+            max = 0; // maxFixed = true;
+          } // PENDING:
+          // When `needCrossZero` and all data is positive/negative, should it be ensured
+          // that the results processed by boundaryGap are positive/negative?
+          // If so, here `minFixed`/`maxFixed` need to be set.
+
+        }
+
+        var determinedMin = this._determinedMin;
+        var determinedMax = this._determinedMax;
+
+        if (determinedMin != null) {
+          min = determinedMin;
+          minFixed = true;
+        }
+
+        if (determinedMax != null) {
+          max = determinedMax;
+          maxFixed = true;
+        } // Ensure min/max be finite number or NaN here. (not to be null/undefined)
+        // `NaN` means min/max axis is blank.
+
+
+        return {
+          min: min,
+          max: max,
+          minFixed: minFixed,
+          maxFixed: maxFixed,
+          isBlank: isBlank
+        };
+      };
+
+      ScaleRawExtentInfo.prototype.modifyDataMinMax = function (minMaxName, val) {
+        if ("development" !== 'production') {
+          assert(!this.frozen);
+        }
+
+        this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
+      };
+
+      ScaleRawExtentInfo.prototype.setDeterminedMinMax = function (minMaxName, val) {
+        var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
+
+        if ("development" !== 'production') {
+          assert(!this.frozen // Earse them usually means logic flaw.
+          && this[attr] == null);
+        }
+
+        this[attr] = val;
+      };
+
+      ScaleRawExtentInfo.prototype.freeze = function () {
+        // @ts-ignore
+        this.frozen = true;
+      };
+
+      return ScaleRawExtentInfo;
+    }();
+    var DETERMINED_MIN_MAX_ATTR = {
+      min: '_determinedMin',
+      max: '_determinedMax'
+    };
+    var DATA_MIN_MAX_ATTR = {
+      min: '_dataMin',
+      max: '_dataMax'
+    };
+    /**
+     * Get scale min max and related info only depends on model settings.
+     * This method can be called after coordinate system created.
+     * For example, in data processing stage.
+     *
+     * Scale extent info probably be required multiple times during a workflow.
+     * For example:
+     * (1) `dataZoom` depends it to get the axis extent in "100%" state.
+     * (2) `processor/extentCalculator` depends it to make sure whether axis extent is specified.
+     * (3) `coordSys.update` use it to finally decide the scale extent.
+     * But the callback of `min`/`max` should not be called multiple times.
+     * The code below should not be implemented repeatedly either.
+     * So we cache the result in the scale instance, which will be recreated at the begining
+     * of the workflow (because `scale` instance will be recreated each round of the workflow).
+     */
+
+    function ensureScaleRawExtentInfo(scale, model, // Usually: data extent from all series on this axis.
+    originalExtent) {
+      // Do not permit to recreate.
+      var rawExtentInfo = scale.rawExtentInfo;
+
+      if (rawExtentInfo) {
+        return rawExtentInfo;
+      }
+
+      rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent); // @ts-ignore
+
+      scale.rawExtentInfo = rawExtentInfo;
+      return rawExtentInfo;
+    }
+    function parseAxisModelMinMax(scale, minMax) {
+      return minMax == null ? null : eqNaN(minMax) ? NaN : scale.parse(minMax);
+    }
+
+    /**
+     * Get axis scale extent before niced.
+     * Item of returned array can only be number (including Infinity and NaN).
+     *
+     * Caution:
+     * Precondition of calling this method:
+     * The scale extent has been initialized using series data extent via
+     * `scale.setExtent` or `scale.unionExtentFromData`;
+     */
+
+    function getScaleExtent(scale, model) {
+      var scaleType = scale.type;
+      var rawExtentResult = ensureScaleRawExtentInfo(scale, model, scale.getExtent()).calculate();
+      scale.setBlank(rawExtentResult.isBlank);
+      var min = rawExtentResult.min;
+      var max = rawExtentResult.max; // If bars are placed on a base axis of type time or interval account for axis boundary overflow and current axis
+      // is base axis
+      // FIXME
+      // (1) Consider support value axis, where below zero and axis `onZero` should be handled properly.
+      // (2) Refactor the logic with `barGrid`. Is it not need to `makeBarWidthAndOffsetInfo` twice with different extent?
+      //     Should not depend on series type `bar`?
+      // (3) Fix that might overlap when using dataZoom.
+      // (4) Consider other chart types using `barGrid`?
+      // See #6728, #4862, `test/bar-overflow-time-plot.html`
+
+      var ecModel = model.ecModel;
+
+      if (ecModel && scaleType === 'time'
+      /*|| scaleType === 'interval' */
+      ) {
+        var barSeriesModels = prepareLayoutBarSeries('bar', ecModel);
+        var isBaseAxisAndHasBarSeries_1 = false;
+        each(barSeriesModels, function (seriesModel) {
+          isBaseAxisAndHasBarSeries_1 = isBaseAxisAndHasBarSeries_1 || seriesModel.getBaseAxis() === model.axis;
+        });
+
+        if (isBaseAxisAndHasBarSeries_1) {
+          // Calculate placement of bars on axis. TODO should be decoupled
+          // with barLayout
+          var barWidthAndOffset = makeColumnLayout(barSeriesModels); // Adjust axis min and max to account for overflow
+
+          var adjustedScale = adjustScaleForOverflow(min, max, model, barWidthAndOffset);
+          min = adjustedScale.min;
+          max = adjustedScale.max;
+        }
+      }
+
+      return {
+        extent: [min, max],
+        // "fix" means "fixed", the value should not be
+        // changed in the subsequent steps.
+        fixMin: rawExtentResult.minFixed,
+        fixMax: rawExtentResult.maxFixed
+      };
+    }
+
+    function adjustScaleForOverflow(min, max, model, // Only support cartesian coord yet.
+    barWidthAndOffset) {
+      // Get Axis Length
+      var axisExtent = model.axis.getExtent();
+      var axisLength = axisExtent[1] - axisExtent[0]; // Get bars on current base axis and calculate min and max overflow
+
+      var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis);
+
+      if (barsOnCurrentAxis === undefined) {
+        return {
+          min: min,
+          max: max
+        };
+      }
+
+      var minOverflow = Infinity;
+      each(barsOnCurrentAxis, function (item) {
+        minOverflow = Math.min(item.offset, minOverflow);
+      });
+      var maxOverflow = -Infinity;
+      each(barsOnCurrentAxis, function (item) {
+        maxOverflow = Math.max(item.offset + item.width, maxOverflow);
+      });
+      minOverflow = Math.abs(minOverflow);
+      maxOverflow = Math.abs(maxOverflow);
+      var totalOverFlow = minOverflow + maxOverflow; // Calculate required buffer based on old range and overflow
+
+      var oldRange = max - min;
+      var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength;
+      var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange;
+      max += overflowBuffer * (maxOverflow / totalOverFlow);
+      min -= overflowBuffer * (minOverflow / totalOverFlow);
+      return {
+        min: min,
+        max: max
+      };
+    } // Precondition of calling this method:
+    // The scale extent has been initailized using series data extent via
+    // `scale.setExtent` or `scale.unionExtentFromData`;
+
+
+    function niceScaleExtent(scale, model) {
+      var extentInfo = getScaleExtent(scale, model);
+      var extent = extentInfo.extent;
+      var splitNumber = model.get('splitNumber');
+
+      if (scale instanceof LogScale) {
+        scale.base = model.get('logBase');
+      }
+
+      var scaleType = scale.type;
+      scale.setExtent(extent[0], extent[1]);
+      scale.niceExtent({
+        splitNumber: splitNumber,
+        fixMin: extentInfo.fixMin,
+        fixMax: extentInfo.fixMax,
+        minInterval: scaleType === 'interval' || scaleType === 'time' ? model.get('minInterval') : null,
+        maxInterval: scaleType === 'interval' || scaleType === 'time' ? model.get('maxInterval') : null
+      }); // If some one specified the min, max. And the default calculated interval
+      // is not good enough. He can specify the interval. It is often appeared
+      // in angle axis with angle 0 - 360. Interval calculated in interval scale is hard
+      // to be 60.
+      // FIXME
+
+      var interval = model.get('interval');
+
+      if (interval != null) {
+        scale.setInterval && scale.setInterval(interval);
+      }
+    }
+    /**
+     * @param axisType Default retrieve from model.type
+     */
+
+    function createScaleByModel(model, axisType) {
+      axisType = axisType || model.get('type');
+
+      if (axisType) {
+        switch (axisType) {
+          // Buildin scale
+          case 'category':
+            return new OrdinalScale({
+              ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(),
+              extent: [Infinity, -Infinity]
+            });
+
+          case 'time':
+            return new TimeScale({
+              locale: model.ecModel.getLocaleModel(),
+              useUTC: model.ecModel.get('useUTC')
+            });
+
+          default:
+            // case 'value'/'interval', 'log', or others.
+            return new (Scale.getClass(axisType) || IntervalScale)();
+        }
+      }
+    }
+    /**
+     * Check if the axis cross 0
+     */
+
+    function ifAxisCrossZero(axis) {
+      var dataExtent = axis.scale.getExtent();
+      var min = dataExtent[0];
+      var max = dataExtent[1];
+      return !(min > 0 && max > 0 || min < 0 && max < 0);
+    }
+    /**
+     * @param axis
+     * @return Label formatter function.
+     *         param: {number} tickValue,
+     *         param: {number} idx, the index in all ticks.
+     *                         If category axis, this param is not required.
+     *         return: {string} label string.
+     */
+
+    function makeLabelFormatter(axis) {
+      var labelFormatter = axis.getLabelModel().get('formatter');
+      var categoryTickStart = axis.type === 'category' ? axis.scale.getExtent()[0] : null;
+
+      if (axis.scale.type === 'time') {
+        return function (tpl) {
+          return function (tick, idx) {
+            return axis.scale.getFormattedLabel(tick, idx, tpl);
+          };
+        }(labelFormatter);
+      } else if (typeof labelFormatter === 'string') {
+        return function (tpl) {
+          return function (tick) {
+            // For category axis, get raw value; for numeric axis,
+            // get formatted label like '1,333,444'.
+            var label = axis.scale.getLabel(tick);
+            var text = tpl.replace('{value}', label != null ? label : '');
+            return text;
+          };
+        }(labelFormatter);
+      } else if (typeof labelFormatter === 'function') {
+        return function (cb) {
+          return function (tick, idx) {
+            // The original intention of `idx` is "the index of the tick in all ticks".
+            // But the previous implementation of category axis do not consider the
+            // `axisLabel.interval`, which cause that, for example, the `interval` is
+            // `1`, then the ticks "name5", "name7", "name9" are displayed, where the
+            // corresponding `idx` are `0`, `2`, `4`, but not `0`, `1`, `2`. So we keep
+            // the definition here for back compatibility.
+            if (categoryTickStart != null) {
+              idx = tick.value - categoryTickStart;
+            }
+
+            return cb(getAxisRawValue(axis, tick), idx, tick.level != null ? {
+              level: tick.level
+            } : null);
+          };
+        }(labelFormatter);
+      } else {
+        return function (tick) {
+          return axis.scale.getLabel(tick);
+        };
+      }
+    }
+    function getAxisRawValue(axis, tick) {
+      // In category axis with data zoom, tick is not the original
+      // index of axis.data. So tick should not be exposed to user
+      // in category axis.
+      return axis.type === 'category' ? axis.scale.getLabel(tick) : tick.value;
+    }
+    /**
+     * @param axis
+     * @return Be null/undefined if no labels.
+     */
+
+    function estimateLabelUnionRect(axis) {
+      var axisModel = axis.model;
+      var scale = axis.scale;
+
+      if (!axisModel.get(['axisLabel', 'show']) || scale.isBlank()) {
+        return;
+      }
+
+      var realNumberScaleTicks;
+      var tickCount;
+      var categoryScaleExtent = scale.getExtent(); // Optimize for large category data, avoid call `getTicks()`.
+
+      if (scale instanceof OrdinalScale) {
+        tickCount = scale.count();
+      } else {
+        realNumberScaleTicks = scale.getTicks();
+        tickCount = realNumberScaleTicks.length;
+      }
+
+      var axisLabelModel = axis.getLabelModel();
+      var labelFormatter = makeLabelFormatter(axis);
+      var rect;
+      var step = 1; // Simple optimization for large amount of labels
+
+      if (tickCount > 40) {
+        step = Math.ceil(tickCount / 40);
+      }
+
+      for (var i = 0; i < tickCount; i += step) {
+        var tick = realNumberScaleTicks ? realNumberScaleTicks[i] : {
+          value: categoryScaleExtent[0] + i
+        };
+        var label = labelFormatter(tick, i);
+        var unrotatedSingleRect = axisLabelModel.getTextRect(label);
+        var singleRect = rotateTextRect(unrotatedSingleRect, axisLabelModel.get('rotate') || 0);
+        rect ? rect.union(singleRect) : rect = singleRect;
+      }
+
+      return rect;
+    }
+
+    function rotateTextRect(textRect, rotate) {
+      var rotateRadians = rotate * Math.PI / 180;
+      var beforeWidth = textRect.width;
+      var beforeHeight = textRect.height;
+      var afterWidth = beforeWidth * Math.abs(Math.cos(rotateRadians)) + Math.abs(beforeHeight * Math.sin(rotateRadians));
+      var afterHeight = beforeWidth * Math.abs(Math.sin(rotateRadians)) + Math.abs(beforeHeight * Math.cos(rotateRadians));
+      var rotatedRect = new BoundingRect(textRect.x, textRect.y, afterWidth, afterHeight);
+      return rotatedRect;
+    }
+    /**
+     * @param model axisLabelModel or axisTickModel
+     * @return {number|String} Can be null|'auto'|number|function
+     */
+
+
+    function getOptionCategoryInterval(model) {
+      var interval = model.get('interval');
+      return interval == null ? 'auto' : interval;
+    }
+    /**
+     * Set `categoryInterval` as 0 implicitly indicates that
+     * show all labels reguardless of overlap.
+     * @param {Object} axis axisModel.axis
+     */
+
+    function shouldShowAllLabels(axis) {
+      return axis.type === 'category' && getOptionCategoryInterval(axis.getLabelModel()) === 0;
+    }
+    function getDataDimensionsOnAxis(data, axisDim) {
+      // Remove duplicated dat dimensions caused by `getStackedDimension`.
+      var dataDimMap = {}; // Currently `mapDimensionsAll` will contain stack result dimension ('__\0ecstackresult').
+      // PENDING: is it reasonable? Do we need to remove the original dim from "coord dim" since
+      // there has been stacked result dim?
+
+      each(data.mapDimensionsAll(axisDim), function (dataDim) {
+        // For example, the extent of the original dimension
+        // is [0.1, 0.5], the extent of the `stackResultDimension`
+        // is [7, 9], the final extent should NOT include [0.1, 0.5],
+        // because there is no graphic corresponding to [0.1, 0.5].
+        // See the case in `test/area-stack.html` `main1`, where area line
+        // stack needs `yAxis` not start from 0.
+        dataDimMap[getStackedDimension(data, dataDim)] = true;
+      });
+      return keys(dataDimMap);
+    }
+    function unionAxisExtentFromData(dataExtent, data, axisDim) {
+      if (data) {
+        each(getDataDimensionsOnAxis(data, axisDim), function (dim) {
+          var seriesExtent = data.getApproximateExtent(dim);
+          seriesExtent[0] < dataExtent[0] && (dataExtent[0] = seriesExtent[0]);
+          seriesExtent[1] > dataExtent[1] && (dataExtent[1] = seriesExtent[1]);
+        });
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var AxisModelCommonMixin =
+    /** @class */
+    function () {
+      function AxisModelCommonMixin() {}
+
+      AxisModelCommonMixin.prototype.getNeedCrossZero = function () {
+        var option = this.option;
+        return !option.scale;
+      };
+      /**
+       * Should be implemented by each axis model if necessary.
+       * @return coordinate system model
+       */
+
+
+      AxisModelCommonMixin.prototype.getCoordSysModel = function () {
+        return;
+      };
+
+      return AxisModelCommonMixin;
+    }();
+
+    /**
+     * Create a muti dimension List structure from seriesModel.
+     */
+
+    function createList(seriesModel) {
+      return createListFromArray(seriesModel.getSource(), seriesModel);
+    } // export function createGraph(seriesModel) {
+    var dataStack$1 = {
+      isDimensionStacked: isDimensionStacked,
+      enableDataStack: enableDataStack,
+      getStackedDimension: getStackedDimension
+    };
+    /**
+     * Create scale
+     * @param {Array.<number>} dataExtent
+     * @param {Object|module:echarts/Model} option If `optoin.type`
+     *        is secified, it can only be `'value'` currently.
+     */
+
+    function createScale(dataExtent, option) {
+      var axisModel = option;
+
+      if (!(option instanceof Model)) {
+        axisModel = new Model(option); // FIXME
+        // Currently AxisModelCommonMixin has nothing to do with the
+        // the requirements of `axisHelper.createScaleByModel`. For
+        // example the method `getCategories` and `getOrdinalMeta`
+        // are required for `'category'` axis, and ecModel are required
+        // for `'time'` axis. But occationally echarts-gl happened
+        // to only use `'value'` axis.
+        // zrUtil.mixin(axisModel, AxisModelCommonMixin);
+      }
+
+      var scale = createScaleByModel(axisModel);
+      scale.setExtent(dataExtent[0], dataExtent[1]);
+      niceScaleExtent(scale, axisModel);
+      return scale;
+    }
+    /**
+     * Mixin common methods to axis model,
+     *
+     * Inlcude methods
+     * `getFormattedLabels() => Array.<string>`
+     * `getCategories() => Array.<string>`
+     * `getMin(origin: boolean) => number`
+     * `getMax(origin: boolean) => number`
+     * `getNeedCrossZero() => boolean`
+     */
+
+    function mixinAxisModelCommonMethods(Model) {
+      mixin(Model, AxisModelCommonMixin);
+    }
+    function createTextStyle$1(textStyleModel, opts) {
+      opts = opts || {};
+      return createTextStyle(textStyleModel, null, null, opts.state !== 'normal');
+    }
+
+    var helper = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        createList: createList,
+        getLayoutRect: getLayoutRect,
+        dataStack: dataStack$1,
+        createScale: createScale,
+        mixinAxisModelCommonMethods: mixinAxisModelCommonMethods,
+        getECData: getECData,
+        createTextStyle: createTextStyle$1,
+        createDimensions: createDimensions,
+        createSymbol: createSymbol,
+        enableHoverEmphasis: enableHoverEmphasis
+    });
+
+    var EPSILON$3 = 1e-8;
+    function isAroundEqual$1(a, b) {
+        return Math.abs(a - b) < EPSILON$3;
+    }
+    function contain$2(points, x, y) {
+        var w = 0;
+        var p = points[0];
+        if (!p) {
+            return false;
+        }
+        for (var i = 1; i < points.length; i++) {
+            var p2 = points[i];
+            w += windingLine(p[0], p[1], p2[0], p2[1], x, y);
+            p = p2;
+        }
+        var p0 = points[0];
+        if (!isAroundEqual$1(p[0], p0[0]) || !isAroundEqual$1(p[1], p0[1])) {
+            w += windingLine(p[0], p[1], p0[0], p0[1], x, y);
+        }
+        return w !== 0;
+    }
+
+    var Region =
+    /** @class */
+    function () {
+      function Region(name, geometries, cp) {
+        this.name = name;
+        this.geometries = geometries;
+
+        if (!cp) {
+          var rect = this.getBoundingRect();
+          cp = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+        } else {
+          cp = [cp[0], cp[1]];
+        }
+
+        this.center = cp;
+      }
+
+      Region.prototype.getBoundingRect = function () {
+        var rect = this._rect;
+
+        if (rect) {
+          return rect;
+        }
+
+        var MAX_NUMBER = Number.MAX_VALUE;
+        var min$1 = [MAX_NUMBER, MAX_NUMBER];
+        var max$1 = [-MAX_NUMBER, -MAX_NUMBER];
+        var min2 = [];
+        var max2 = [];
+        var geometries = this.geometries;
+        var i = 0;
+
+        for (; i < geometries.length; i++) {
+          // Only support polygon
+          if (geometries[i].type !== 'polygon') {
+            continue;
+          } // Doesn't consider hole
+
+
+          var exterior = geometries[i].exterior;
+          fromPoints(exterior, min2, max2);
+          min(min$1, min$1, min2);
+          max(max$1, max$1, max2);
+        } // No data
+
+
+        if (i === 0) {
+          min$1[0] = min$1[1] = max$1[0] = max$1[1] = 0;
+        }
+
+        return this._rect = new BoundingRect(min$1[0], min$1[1], max$1[0] - min$1[0], max$1[1] - min$1[1]);
+      };
+
+      Region.prototype.contain = function (coord) {
+        var rect = this.getBoundingRect();
+        var geometries = this.geometries;
+
+        if (!rect.contain(coord[0], coord[1])) {
+          return false;
+        }
+
+        loopGeo: for (var i = 0, len = geometries.length; i < len; i++) {
+          // Only support polygon.
+          if (geometries[i].type !== 'polygon') {
+            continue;
+          }
+
+          var exterior = geometries[i].exterior;
+          var interiors = geometries[i].interiors;
+
+          if (contain$2(exterior, coord[0], coord[1])) {
+            // Not in the region if point is in the hole.
+            for (var k = 0; k < (interiors ? interiors.length : 0); k++) {
+              if (contain$2(interiors[k], coord[0], coord[1])) {
+                continue loopGeo;
+              }
+            }
+
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      Region.prototype.transformTo = function (x, y, width, height) {
+        var rect = this.getBoundingRect();
+        var aspect = rect.width / rect.height;
+
+        if (!width) {
+          width = aspect * height;
+        } else if (!height) {
+          height = width / aspect;
+        }
+
+        var target = new BoundingRect(x, y, width, height);
+        var transform = rect.calculateTransform(target);
+        var geometries = this.geometries;
+
+        for (var i = 0; i < geometries.length; i++) {
+          // Only support polygon.
+          if (geometries[i].type !== 'polygon') {
+            continue;
+          }
+
+          var exterior = geometries[i].exterior;
+          var interiors = geometries[i].interiors;
+
+          for (var p = 0; p < exterior.length; p++) {
+            applyTransform(exterior[p], exterior[p], transform);
+          }
+
+          for (var h = 0; h < (interiors ? interiors.length : 0); h++) {
+            for (var p = 0; p < interiors[h].length; p++) {
+              applyTransform(interiors[h][p], interiors[h][p], transform);
+            }
+          }
+        }
+
+        rect = this._rect;
+        rect.copy(target); // Update center
+
+        this.center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+      };
+
+      Region.prototype.cloneShallow = function (name) {
+        name == null && (name = this.name);
+        var newRegion = new Region(name, this.geometries, this.center);
+        newRegion._rect = this._rect;
+        newRegion.transformTo = null; // Simply avoid to be called.
+
+        return newRegion;
+      };
+
+      return Region;
+    }();
+
+    function decode(json) {
+      if (!json.UTF8Encoding) {
+        return json;
+      }
+
+      var jsonCompressed = json;
+      var encodeScale = jsonCompressed.UTF8Scale;
+
+      if (encodeScale == null) {
+        encodeScale = 1024;
+      }
+
+      var features = jsonCompressed.features;
+
+      for (var f = 0; f < features.length; f++) {
+        var feature = features[f];
+        var geometry = feature.geometry;
+
+        if (geometry.type === 'Polygon') {
+          var coordinates = geometry.coordinates;
+
+          for (var c = 0; c < coordinates.length; c++) {
+            coordinates[c] = decodePolygon(coordinates[c], geometry.encodeOffsets[c], encodeScale);
+          }
+        } else if (geometry.type === 'MultiPolygon') {
+          var coordinates = geometry.coordinates;
+
+          for (var c = 0; c < coordinates.length; c++) {
+            var coordinate = coordinates[c];
+
+            for (var c2 = 0; c2 < coordinate.length; c2++) {
+              coordinate[c2] = decodePolygon(coordinate[c2], geometry.encodeOffsets[c][c2], encodeScale);
+            }
+          }
+        }
+      } // Has been decoded
+
+
+      jsonCompressed.UTF8Encoding = false;
+      return jsonCompressed;
+    }
+
+    function decodePolygon(coordinate, encodeOffsets, encodeScale) {
+      var result = [];
+      var prevX = encodeOffsets[0];
+      var prevY = encodeOffsets[1];
+
+      for (var i = 0; i < coordinate.length; i += 2) {
+        var x = coordinate.charCodeAt(i) - 64;
+        var y = coordinate.charCodeAt(i + 1) - 64; // ZigZag decoding
+
+        x = x >> 1 ^ -(x & 1);
+        y = y >> 1 ^ -(y & 1); // Delta deocding
+
+        x += prevX;
+        y += prevY;
+        prevX = x;
+        prevY = y; // Dequantize
+
+        result.push([x / encodeScale, y / encodeScale]);
+      }
+
+      return result;
+    }
+
+    function parseGeoJSON(geoJson, nameProperty) {
+      geoJson = decode(geoJson);
+      return map(filter(geoJson.features, function (featureObj) {
+        // Output of mapshaper may have geometry null
+        return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
+      }), function (featureObj) {
+        var properties = featureObj.properties;
+        var geo = featureObj.geometry;
+        var geometries = [];
+
+        if (geo.type === 'Polygon') {
+          var coordinates = geo.coordinates;
+          geometries.push({
+            type: 'polygon',
+            // According to the GeoJSON specification.
+            // First must be exterior, and the rest are all interior(holes).
+            exterior: coordinates[0],
+            interiors: coordinates.slice(1)
+          });
+        }
+
+        if (geo.type === 'MultiPolygon') {
+          var coordinates = geo.coordinates;
+          each(coordinates, function (item) {
+            if (item[0]) {
+              geometries.push({
+                type: 'polygon',
+                exterior: item[0],
+                interiors: item.slice(1)
+              });
+            }
+          });
+        }
+
+        var region = new Region(properties[nameProperty || 'name'], geometries, properties.cp);
+        region.properties = properties;
+        return region;
+      });
+    }
+
+    var number = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        linearMap: linearMap,
+        round: round,
+        asc: asc,
+        getPrecision: getPrecision,
+        getPrecisionSafe: getPrecisionSafe,
+        getPixelPrecision: getPixelPrecision,
+        getPercentWithPrecision: getPercentWithPrecision,
+        MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
+        remRadian: remRadian,
+        isRadianAroundZero: isRadianAroundZero,
+        parseDate: parseDate,
+        quantity: quantity,
+        quantityExponent: quantityExponent,
+        nice: nice,
+        quantile: quantile,
+        reformIntervals: reformIntervals,
+        isNumeric: isNumeric,
+        numericToNumber: numericToNumber
+    });
+
+    var time = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        parse: parseDate,
+        format: format
+    });
+
+    var graphic$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        extendShape: extendShape,
+        extendPath: extendPath,
+        makePath: makePath,
+        makeImage: makeImage,
+        mergePath: mergePath$1,
+        resizePath: resizePath,
+        createIcon: createIcon,
+        updateProps: updateProps,
+        initProps: initProps,
+        getTransform: getTransform,
+        clipPointsByRect: clipPointsByRect,
+        clipRectByRect: clipRectByRect,
+        registerShape: registerShape,
+        getShapeClass: getShapeClass,
+        Group: Group,
+        Image: ZRImage,
+        Text: ZRText,
+        Circle: Circle,
+        Ellipse: Ellipse,
+        Sector: Sector,
+        Ring: Ring,
+        Polygon: Polygon,
+        Polyline: Polyline,
+        Rect: Rect,
+        Line: Line,
+        BezierCurve: BezierCurve,
+        Arc: Arc,
+        IncrementalDisplayable: IncrementalDisplayable,
+        CompoundPath: CompoundPath,
+        LinearGradient: LinearGradient,
+        RadialGradient: RadialGradient,
+        BoundingRect: BoundingRect
+    });
+
+    var format$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        addCommas: addCommas,
+        toCamelCase: toCamelCase,
+        normalizeCssArray: normalizeCssArray$1,
+        encodeHTML: encodeHTML,
+        formatTpl: formatTpl,
+        getTooltipMarker: getTooltipMarker,
+        formatTime: formatTime,
+        capitalFirst: capitalFirst,
+        truncateText: truncateText,
+        getTextRect: getTextRect
+    });
+
+    var util$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        map: map,
+        each: each,
+        indexOf: indexOf,
+        inherits: inherits,
+        reduce: reduce,
+        filter: filter,
+        bind: bind,
+        curry: curry,
+        isArray: isArray,
+        isString: isString,
+        isObject: isObject,
+        isFunction: isFunction,
+        extend: extend,
+        defaults: defaults,
+        clone: clone,
+        merge: merge
+    });
+
+    var inner$4 = makeInner();
+    function createAxisLabels(axis) {
+      // Only ordinal scale support tick interval
+      return axis.type === 'category' ? makeCategoryLabels(axis) : makeRealNumberLabels(axis);
+    }
+    /**
+     * @param {module:echats/coord/Axis} axis
+     * @param {module:echarts/model/Model} tickModel For example, can be axisTick, splitLine, splitArea.
+     * @return {Object} {
+     *     ticks: Array.<number>
+     *     tickCategoryInterval: number
+     * }
+     */
+
+    function createAxisTicks(axis, tickModel) {
+      // Only ordinal scale support tick interval
+      return axis.type === 'category' ? makeCategoryTicks(axis, tickModel) : {
+        ticks: map(axis.scale.getTicks(), function (tick) {
+          return tick.value;
+        })
+      };
+    }
+
+    function makeCategoryLabels(axis) {
+      var labelModel = axis.getLabelModel();
+      var result = makeCategoryLabelsActually(axis, labelModel);
+      return !labelModel.get('show') || axis.scale.isBlank() ? {
+        labels: [],
+        labelCategoryInterval: result.labelCategoryInterval
+      } : result;
+    }
+
+    function makeCategoryLabelsActually(axis, labelModel) {
+      var labelsCache = getListCache(axis, 'labels');
+      var optionLabelInterval = getOptionCategoryInterval(labelModel);
+      var result = listCacheGet(labelsCache, optionLabelInterval);
+
+      if (result) {
+        return result;
+      }
+
+      var labels;
+      var numericLabelInterval;
+
+      if (isFunction(optionLabelInterval)) {
+        labels = makeLabelsByCustomizedCategoryInterval(axis, optionLabelInterval);
+      } else {
+        numericLabelInterval = optionLabelInterval === 'auto' ? makeAutoCategoryInterval(axis) : optionLabelInterval;
+        labels = makeLabelsByNumericCategoryInterval(axis, numericLabelInterval);
+      } // Cache to avoid calling interval function repeatly.
+
+
+      return listCacheSet(labelsCache, optionLabelInterval, {
+        labels: labels,
+        labelCategoryInterval: numericLabelInterval
+      });
+    }
+
+    function makeCategoryTicks(axis, tickModel) {
+      var ticksCache = getListCache(axis, 'ticks');
+      var optionTickInterval = getOptionCategoryInterval(tickModel);
+      var result = listCacheGet(ticksCache, optionTickInterval);
+
+      if (result) {
+        return result;
+      }
+
+      var ticks;
+      var tickCategoryInterval; // Optimize for the case that large category data and no label displayed,
+      // we should not return all ticks.
+
+      if (!tickModel.get('show') || axis.scale.isBlank()) {
+        ticks = [];
+      }
+
+      if (isFunction(optionTickInterval)) {
+        ticks = makeLabelsByCustomizedCategoryInterval(axis, optionTickInterval, true);
+      } // Always use label interval by default despite label show. Consider this
+      // scenario, Use multiple grid with the xAxis sync, and only one xAxis shows
+      // labels. `splitLine` and `axisTick` should be consistent in this case.
+      else if (optionTickInterval === 'auto') {
+          var labelsResult = makeCategoryLabelsActually(axis, axis.getLabelModel());
+          tickCategoryInterval = labelsResult.labelCategoryInterval;
+          ticks = map(labelsResult.labels, function (labelItem) {
+            return labelItem.tickValue;
+          });
+        } else {
+          tickCategoryInterval = optionTickInterval;
+          ticks = makeLabelsByNumericCategoryInterval(axis, tickCategoryInterval, true);
+        } // Cache to avoid calling interval function repeatly.
+
+
+      return listCacheSet(ticksCache, optionTickInterval, {
+        ticks: ticks,
+        tickCategoryInterval: tickCategoryInterval
+      });
+    }
+
+    function makeRealNumberLabels(axis) {
+      var ticks = axis.scale.getTicks();
+      var labelFormatter = makeLabelFormatter(axis);
+      return {
+        labels: map(ticks, function (tick, idx) {
+          return {
+            formattedLabel: labelFormatter(tick, idx),
+            rawLabel: axis.scale.getLabel(tick),
+            tickValue: tick.value
+          };
+        })
+      };
+    }
+
+    function getListCache(axis, prop) {
+      // Because key can be funciton, and cache size always be small, we use array cache.
+      return inner$4(axis)[prop] || (inner$4(axis)[prop] = []);
+    }
+
+    function listCacheGet(cache, key) {
+      for (var i = 0; i < cache.length; i++) {
+        if (cache[i].key === key) {
+          return cache[i].value;
+        }
+      }
+    }
+
+    function listCacheSet(cache, key, value) {
+      cache.push({
+        key: key,
+        value: value
+      });
+      return value;
+    }
+
+    function makeAutoCategoryInterval(axis) {
+      var result = inner$4(axis).autoInterval;
+      return result != null ? result : inner$4(axis).autoInterval = axis.calculateCategoryInterval();
+    }
+    /**
+     * Calculate interval for category axis ticks and labels.
+     * To get precise result, at least one of `getRotate` and `isHorizontal`
+     * should be implemented in axis.
+     */
+
+
+    function calculateCategoryInterval(axis) {
+      var params = fetchAutoCategoryIntervalCalculationParams(axis);
+      var labelFormatter = makeLabelFormatter(axis);
+      var rotation = (params.axisRotate - params.labelRotate) / 180 * Math.PI;
+      var ordinalScale = axis.scale;
+      var ordinalExtent = ordinalScale.getExtent(); // Providing this method is for optimization:
+      // avoid generating a long array by `getTicks`
+      // in large category data case.
+
+      var tickCount = ordinalScale.count();
+
+      if (ordinalExtent[1] - ordinalExtent[0] < 1) {
+        return 0;
+      }
+
+      var step = 1; // Simple optimization. Empirical value: tick count should less than 40.
+
+      if (tickCount > 40) {
+        step = Math.max(1, Math.floor(tickCount / 40));
+      }
+
+      var tickValue = ordinalExtent[0];
+      var unitSpan = axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue);
+      var unitW = Math.abs(unitSpan * Math.cos(rotation));
+      var unitH = Math.abs(unitSpan * Math.sin(rotation));
+      var maxW = 0;
+      var maxH = 0; // Caution: Performance sensitive for large category data.
+      // Consider dataZoom, we should make appropriate step to avoid O(n) loop.
+
+      for (; tickValue <= ordinalExtent[1]; tickValue += step) {
+        var width = 0;
+        var height = 0; // Not precise, do not consider align and vertical align
+        // and each distance from axis line yet.
+
+        var rect = getBoundingRect(labelFormatter({
+          value: tickValue
+        }), params.font, 'center', 'top'); // Magic number
+
+        width = rect.width * 1.3;
+        height = rect.height * 1.3; // Min size, void long loop.
+
+        maxW = Math.max(maxW, width, 7);
+        maxH = Math.max(maxH, height, 7);
+      }
+
+      var dw = maxW / unitW;
+      var dh = maxH / unitH; // 0/0 is NaN, 1/0 is Infinity.
+
+      isNaN(dw) && (dw = Infinity);
+      isNaN(dh) && (dh = Infinity);
+      var interval = Math.max(0, Math.floor(Math.min(dw, dh)));
+      var cache = inner$4(axis.model);
+      var axisExtent = axis.getExtent();
+      var lastAutoInterval = cache.lastAutoInterval;
+      var lastTickCount = cache.lastTickCount; // Use cache to keep interval stable while moving zoom window,
+      // otherwise the calculated interval might jitter when the zoom
+      // window size is close to the interval-changing size.
+      // For example, if all of the axis labels are `a, b, c, d, e, f, g`.
+      // The jitter will cause that sometimes the displayed labels are
+      // `a, d, g` (interval: 2) sometimes `a, c, e`(interval: 1).
+
+      if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 // Always choose the bigger one, otherwise the critical
+      // point is not the same when zooming in or zooming out.
+      && lastAutoInterval > interval // If the axis change is caused by chart resize, the cache should not
+      // be used. Otherwise some hiden labels might not be shown again.
+      && cache.axisExtent0 === axisExtent[0] && cache.axisExtent1 === axisExtent[1]) {
+        interval = lastAutoInterval;
+      } // Only update cache if cache not used, otherwise the
+      // changing of interval is too insensitive.
+      else {
+          cache.lastTickCount = tickCount;
+          cache.lastAutoInterval = interval;
+          cache.axisExtent0 = axisExtent[0];
+          cache.axisExtent1 = axisExtent[1];
+        }
+
+      return interval;
+    }
+
+    function fetchAutoCategoryIntervalCalculationParams(axis) {
+      var labelModel = axis.getLabelModel();
+      return {
+        axisRotate: axis.getRotate ? axis.getRotate() : axis.isHorizontal && !axis.isHorizontal() ? 90 : 0,
+        labelRotate: labelModel.get('rotate') || 0,
+        font: labelModel.getFont()
+      };
+    }
+
+    function makeLabelsByNumericCategoryInterval(axis, categoryInterval, onlyTick) {
+      var labelFormatter = makeLabelFormatter(axis);
+      var ordinalScale = axis.scale;
+      var ordinalExtent = ordinalScale.getExtent();
+      var labelModel = axis.getLabelModel();
+      var result = []; // TODO: axisType: ordinalTime, pick the tick from each month/day/year/...
+
+      var step = Math.max((categoryInterval || 0) + 1, 1);
+      var startTick = ordinalExtent[0];
+      var tickCount = ordinalScale.count(); // Calculate start tick based on zero if possible to keep label consistent
+      // while zooming and moving while interval > 0. Otherwise the selection
+      // of displayable ticks and symbols probably keep changing.
+      // 3 is empirical value.
+
+      if (startTick !== 0 && step > 1 && tickCount / step > 2) {
+        startTick = Math.round(Math.ceil(startTick / step) * step);
+      } // (1) Only add min max label here but leave overlap checking
+      // to render stage, which also ensure the returned list
+      // suitable for splitLine and splitArea rendering.
+      // (2) Scales except category always contain min max label so
+      // do not need to perform this process.
+
+
+      var showAllLabel = shouldShowAllLabels(axis);
+      var includeMinLabel = labelModel.get('showMinLabel') || showAllLabel;
+      var includeMaxLabel = labelModel.get('showMaxLabel') || showAllLabel;
+
+      if (includeMinLabel && startTick !== ordinalExtent[0]) {
+        addItem(ordinalExtent[0]);
+      } // Optimize: avoid generating large array by `ordinalScale.getTicks()`.
+
+
+      var tickValue = startTick;
+
+      for (; tickValue <= ordinalExtent[1]; tickValue += step) {
+        addItem(tickValue);
+      }
+
+      if (includeMaxLabel && tickValue - step !== ordinalExtent[1]) {
+        addItem(ordinalExtent[1]);
+      }
+
+      function addItem(tickValue) {
+        var tickObj = {
+          value: tickValue
+        };
+        result.push(onlyTick ? tickValue : {
+          formattedLabel: labelFormatter(tickObj),
+          rawLabel: ordinalScale.getLabel(tickObj),
+          tickValue: tickValue
+        });
+      }
+
+      return result;
+    }
+
+    function makeLabelsByCustomizedCategoryInterval(axis, categoryInterval, onlyTick) {
+      var ordinalScale = axis.scale;
+      var labelFormatter = makeLabelFormatter(axis);
+      var result = [];
+      each(ordinalScale.getTicks(), function (tick) {
+        var rawLabel = ordinalScale.getLabel(tick);
+        var tickValue = tick.value;
+
+        if (categoryInterval(tick.value, rawLabel)) {
+          result.push(onlyTick ? tickValue : {
+            formattedLabel: labelFormatter(tick),
+            rawLabel: rawLabel,
+            tickValue: tickValue
+          });
+        }
+      });
+      return result;
+    }
+
+    var NORMALIZED_EXTENT = [0, 1];
+    /**
+     * Base class of Axis.
+     */
+
+    var Axis =
+    /** @class */
+    function () {
+      function Axis(dim, scale, extent) {
+        this.onBand = false;
+        this.inverse = false;
+        this.dim = dim;
+        this.scale = scale;
+        this._extent = extent || [0, 0];
+      }
+      /**
+       * If axis extent contain given coord
+       */
+
+
+      Axis.prototype.contain = function (coord) {
+        var extent = this._extent;
+        var min = Math.min(extent[0], extent[1]);
+        var max = Math.max(extent[0], extent[1]);
+        return coord >= min && coord <= max;
+      };
+      /**
+       * If axis extent contain given data
+       */
+
+
+      Axis.prototype.containData = function (data) {
+        return this.scale.contain(data);
+      };
+      /**
+       * Get coord extent.
+       */
+
+
+      Axis.prototype.getExtent = function () {
+        return this._extent.slice();
+      };
+      /**
+       * Get precision used for formatting
+       */
+
+
+      Axis.prototype.getPixelPrecision = function (dataExtent) {
+        return getPixelPrecision(dataExtent || this.scale.getExtent(), this._extent);
+      };
+      /**
+       * Set coord extent
+       */
+
+
+      Axis.prototype.setExtent = function (start, end) {
+        var extent = this._extent;
+        extent[0] = start;
+        extent[1] = end;
+      };
+      /**
+       * Convert data to coord. Data is the rank if it has an ordinal scale
+       */
+
+
+      Axis.prototype.dataToCoord = function (data, clamp) {
+        var extent = this._extent;
+        var scale = this.scale;
+        data = scale.normalize(data);
+
+        if (this.onBand && scale.type === 'ordinal') {
+          extent = extent.slice();
+          fixExtentWithBands(extent, scale.count());
+        }
+
+        return linearMap(data, NORMALIZED_EXTENT, extent, clamp);
+      };
+      /**
+       * Convert coord to data. Data is the rank if it has an ordinal scale
+       */
+
+
+      Axis.prototype.coordToData = function (coord, clamp) {
+        var extent = this._extent;
+        var scale = this.scale;
+
+        if (this.onBand && scale.type === 'ordinal') {
+          extent = extent.slice();
+          fixExtentWithBands(extent, scale.count());
+        }
+
+        var t = linearMap(coord, extent, NORMALIZED_EXTENT, clamp);
+        return this.scale.scale(t);
+      };
+      /**
+       * Convert pixel point to data in axis
+       */
+
+
+      Axis.prototype.pointToData = function (point, clamp) {
+        // Should be implemented in derived class if necessary.
+        return;
+      };
+      /**
+       * Different from `zrUtil.map(axis.getTicks(), axis.dataToCoord, axis)`,
+       * `axis.getTicksCoords` considers `onBand`, which is used by
+       * `boundaryGap:true` of category axis and splitLine and splitArea.
+       * @param opt.tickModel default: axis.model.getModel('axisTick')
+       * @param opt.clamp If `true`, the first and the last
+       *        tick must be at the axis end points. Otherwise, clip ticks
+       *        that outside the axis extent.
+       */
+
+
+      Axis.prototype.getTicksCoords = function (opt) {
+        opt = opt || {};
+        var tickModel = opt.tickModel || this.getTickModel();
+        var result = createAxisTicks(this, tickModel);
+        var ticks = result.ticks;
+        var ticksCoords = map(ticks, function (tickVal) {
+          return {
+            coord: this.dataToCoord(this.scale.type === 'ordinal' ? this.scale.getRawOrdinalNumber(tickVal) : tickVal),
+            tickValue: tickVal
+          };
+        }, this);
+        var alignWithLabel = tickModel.get('alignWithLabel');
+        fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp);
+        return ticksCoords;
+      };
+
+      Axis.prototype.getMinorTicksCoords = function () {
+        if (this.scale.type === 'ordinal') {
+          // Category axis doesn't support minor ticks
+          return [];
+        }
+
+        var minorTickModel = this.model.getModel('minorTick');
+        var splitNumber = minorTickModel.get('splitNumber'); // Protection.
+
+        if (!(splitNumber > 0 && splitNumber < 100)) {
+          splitNumber = 5;
+        }
+
+        var minorTicks = this.scale.getMinorTicks(splitNumber);
+        var minorTicksCoords = map(minorTicks, function (minorTicksGroup) {
+          return map(minorTicksGroup, function (minorTick) {
+            return {
+              coord: this.dataToCoord(minorTick),
+              tickValue: minorTick
+            };
+          }, this);
+        }, this);
+        return minorTicksCoords;
+      };
+
+      Axis.prototype.getViewLabels = function () {
+        return createAxisLabels(this).labels;
+      };
+
+      Axis.prototype.getLabelModel = function () {
+        return this.model.getModel('axisLabel');
+      };
+      /**
+       * Notice here we only get the default tick model. For splitLine
+       * or splitArea, we should pass the splitLineModel or splitAreaModel
+       * manually when calling `getTicksCoords`.
+       * In GL, this method may be overrided to:
+       * `axisModel.getModel('axisTick', grid3DModel.getModel('axisTick'));`
+       */
+
+
+      Axis.prototype.getTickModel = function () {
+        return this.model.getModel('axisTick');
+      };
+      /**
+       * Get width of band
+       */
+
+
+      Axis.prototype.getBandWidth = function () {
+        var axisExtent = this._extent;
+        var dataExtent = this.scale.getExtent();
+        var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0); // Fix #2728, avoid NaN when only one data.
+
+        len === 0 && (len = 1);
+        var size = Math.abs(axisExtent[1] - axisExtent[0]);
+        return Math.abs(size) / len;
+      };
+      /**
+       * Only be called in category axis.
+       * Can be overrided, consider other axes like in 3D.
+       * @return Auto interval for cateogry axis tick and label
+       */
+
+
+      Axis.prototype.calculateCategoryInterval = function () {
+        return calculateCategoryInterval(this);
+      };
+
+      return Axis;
+    }();
+
+    function fixExtentWithBands(extent, nTick) {
+      var size = extent[1] - extent[0];
+      var len = nTick;
+      var margin = size / len / 2;
+      extent[0] += margin;
+      extent[1] -= margin;
+    } // If axis has labels [1, 2, 3, 4]. Bands on the axis are
+    // |---1---|---2---|---3---|---4---|.
+    // So the displayed ticks and splitLine/splitArea should between
+    // each data item, otherwise cause misleading (e.g., split tow bars
+    // of a single data item when there are two bar series).
+    // Also consider if tickCategoryInterval > 0 and onBand, ticks and
+    // splitLine/spliteArea should layout appropriately corresponding
+    // to displayed labels. (So we should not use `getBandWidth` in this
+    // case).
+
+
+    function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp) {
+      var ticksLen = ticksCoords.length;
+
+      if (!axis.onBand || alignWithLabel || !ticksLen) {
+        return;
+      }
+
+      var axisExtent = axis.getExtent();
+      var last;
+      var diffSize;
+
+      if (ticksLen === 1) {
+        ticksCoords[0].coord = axisExtent[0];
+        last = ticksCoords[1] = {
+          coord: axisExtent[0]
+        };
+      } else {
+        var crossLen = ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue;
+        var shift_1 = (ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen;
+        each(ticksCoords, function (ticksItem) {
+          ticksItem.coord -= shift_1 / 2;
+        });
+        var dataExtent = axis.scale.getExtent();
+        diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue;
+        last = {
+          coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize
+        };
+        ticksCoords.push(last);
+      }
+
+      var inverse = axisExtent[0] > axisExtent[1]; // Handling clamp.
+
+      if (littleThan(ticksCoords[0].coord, axisExtent[0])) {
+        clamp ? ticksCoords[0].coord = axisExtent[0] : ticksCoords.shift();
+      }
+
+      if (clamp && littleThan(axisExtent[0], ticksCoords[0].coord)) {
+        ticksCoords.unshift({
+          coord: axisExtent[0]
+        });
+      }
+
+      if (littleThan(axisExtent[1], last.coord)) {
+        clamp ? last.coord = axisExtent[1] : ticksCoords.pop();
+      }
+
+      if (clamp && littleThan(last.coord, axisExtent[1])) {
+        ticksCoords.push({
+          coord: axisExtent[1]
+        });
+      }
+
+      function littleThan(a, b) {
+        // Avoid rounding error cause calculated tick coord different with extent.
+        // It may cause an extra unecessary tick added.
+        a = round(a);
+        b = round(b);
+        return inverse ? a > b : a < b;
+      }
+    }
+
+    // Should use `ComponentModel.extend` or `class XXXX extend ComponentModel` to create class.
+    // Then use `registerComponentModel` in `install` parameter when `use` this extension. For example:
+    // class Bar3DModel extends ComponentModel {}
+    // export function install(registers) { regsiters.registerComponentModel(Bar3DModel); }
+    // echarts.use(install);
+
+    function extendComponentModel(proto) {
+      var Model = ComponentModel.extend(proto);
+      ComponentModel.registerClass(Model);
+      return Model;
+    }
+    function extendComponentView(proto) {
+      var View = ComponentView.extend(proto);
+      ComponentView.registerClass(View);
+      return View;
+    }
+    function extendSeriesModel(proto) {
+      var Model = SeriesModel.extend(proto);
+      SeriesModel.registerClass(Model);
+      return Model;
+    }
+    function extendChartView(proto) {
+      var View = ChartView.extend(proto);
+      ChartView.registerClass(View);
+      return View;
+    }
+
+    function createElement(name) {
+        return document.createElementNS('http://www.w3.org/2000/svg', name);
+    }
+
+    function diff(oldArr, newArr, equals) {
+        if (!equals) {
+            equals = function (a, b) {
+                return a === b;
+            };
+        }
+        oldArr = oldArr.slice();
+        newArr = newArr.slice();
+        var newLen = newArr.length;
+        var oldLen = oldArr.length;
+        var editLength = 1;
+        var maxEditLength = newLen + oldLen;
+        var bestPath = [{ newPos: -1, components: [] }];
+        var oldPos = extractCommon(bestPath[0], newArr, oldArr, 0, equals);
+        if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+            var indices = [];
+            for (var i = 0; i < newArr.length; i++) {
+                indices.push(i);
+            }
+            return [{
+                    indices: indices,
+                    count: newArr.length,
+                    added: false,
+                    removed: false
+                }];
+        }
+        function execEditLength() {
+            for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+                var basePath;
+                var addPath = bestPath[diagonalPath - 1];
+                var removePath = bestPath[diagonalPath + 1];
+                var oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+                if (addPath) {
+                    bestPath[diagonalPath - 1] = undefined;
+                }
+                var canAdd = addPath && addPath.newPos + 1 < newLen;
+                var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
+                if (!canAdd && !canRemove) {
+                    bestPath[diagonalPath] = undefined;
+                    continue;
+                }
+                if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
+                    basePath = clonePath(removePath);
+                    pushComponent(basePath.components, false, true);
+                }
+                else {
+                    basePath = addPath;
+                    basePath.newPos++;
+                    pushComponent(basePath.components, true, false);
+                }
+                oldPos = extractCommon(basePath, newArr, oldArr, diagonalPath, equals);
+                if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+                    return buildValues(basePath.components);
+                }
+                else {
+                    bestPath[diagonalPath] = basePath;
+                }
+            }
+            editLength++;
+        }
+        while (editLength <= maxEditLength) {
+            var ret = execEditLength();
+            if (ret) {
+                return ret;
+            }
+        }
+    }
+    function extractCommon(basePath, newArr, oldArr, diagonalPath, equals) {
+        var newLen = newArr.length;
+        var oldLen = oldArr.length;
+        var newPos = basePath.newPos;
+        var oldPos = newPos - diagonalPath;
+        var commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && equals(newArr[newPos + 1], oldArr[oldPos + 1])) {
+            newPos++;
+            oldPos++;
+            commonCount++;
+        }
+        if (commonCount) {
+            basePath.components.push({
+                count: commonCount,
+                added: false,
+                removed: false,
+                indices: []
+            });
+        }
+        basePath.newPos = newPos;
+        return oldPos;
+    }
+    function pushComponent(components, added, removed) {
+        var last = components[components.length - 1];
+        if (last && last.added === added && last.removed === removed) {
+            components[components.length - 1] = {
+                count: last.count + 1,
+                added: added,
+                removed: removed,
+                indices: []
+            };
+        }
+        else {
+            components.push({
+                count: 1,
+                added: added,
+                removed: removed,
+                indices: []
+            });
+        }
+    }
+    function buildValues(components) {
+        var componentPos = 0;
+        var componentLen = components.length;
+        var newPos = 0;
+        var oldPos = 0;
+        for (; componentPos < componentLen; componentPos++) {
+            var component = components[componentPos];
+            if (!component.removed) {
+                var indices = [];
+                for (var i = newPos; i < newPos + component.count; i++) {
+                    indices.push(i);
+                }
+                component.indices = indices;
+                newPos += component.count;
+                if (!component.added) {
+                    oldPos += component.count;
+                }
+            }
+            else {
+                for (var i = oldPos; i < oldPos + component.count; i++) {
+                    component.indices.push(i);
+                }
+                oldPos += component.count;
+            }
+        }
+        return components;
+    }
+    function clonePath(path) {
+        return { newPos: path.newPos, components: path.components.slice(0) };
+    }
+    function arrayDiff(oldArr, newArr, equal) {
+        return diff(oldArr, newArr, equal);
+    }
+
+    var NONE = 'none';
+    var mathRound = Math.round;
+    var mathSin$4 = Math.sin;
+    var mathCos$4 = Math.cos;
+    var PI$4 = Math.PI;
+    var PI2$7 = Math.PI * 2;
+    var degree = 180 / PI$4;
+    var EPSILON$4 = 1e-4;
+    function round3(val) {
+        return mathRound(val * 1e3) / 1e3;
+    }
+    function round4(val) {
+        return mathRound(val * 1e4) / 1e4;
+    }
+    function isAroundZero$1(val) {
+        return val < EPSILON$4 && val > -EPSILON$4;
+    }
+    function pathHasFill(style) {
+        var fill = style.fill;
+        return fill != null && fill !== NONE;
+    }
+    function pathHasStroke(style) {
+        var stroke = style.stroke;
+        return stroke != null && stroke !== NONE;
+    }
+    function setTransform(svgEl, m) {
+        if (m) {
+            attr(svgEl, 'transform', 'matrix('
+                + round3(m[0]) + ','
+                + round3(m[1]) + ','
+                + round3(m[2]) + ','
+                + round3(m[3]) + ','
+                + round4(m[4]) + ','
+                + round4(m[5])
+                + ')');
+        }
+    }
+    function attr(el, key, val) {
+        if (!val || val.type !== 'linear' && val.type !== 'radial') {
+            el.setAttribute(key, val);
+        }
+    }
+    function attrXLink(el, key, val) {
+        el.setAttributeNS('http://www.w3.org/1999/xlink', key, val);
+    }
+    function attrXML(el, key, val) {
+        el.setAttributeNS('http://www.w3.org/XML/1998/namespace', key, val);
+    }
+    function bindStyle(svgEl, style, el) {
+        var opacity = style.opacity == null ? 1 : style.opacity;
+        if (el instanceof ZRImage) {
+            svgEl.style.opacity = opacity + '';
+            return;
+        }
+        if (pathHasFill(style)) {
+            var fill = style.fill;
+            fill = fill === 'transparent' ? NONE : fill;
+            attr(svgEl, 'fill', fill);
+            attr(svgEl, 'fill-opacity', (style.fillOpacity != null ? style.fillOpacity * opacity : opacity) + '');
+        }
+        else {
+            attr(svgEl, 'fill', NONE);
+        }
+        if (pathHasStroke(style)) {
+            var stroke = style.stroke;
+            stroke = stroke === 'transparent' ? NONE : stroke;
+            attr(svgEl, 'stroke', stroke);
+            var strokeWidth = style.lineWidth;
+            var strokeScale_1 = style.strokeNoScale
+                ? el.getLineScale()
+                : 1;
+            attr(svgEl, 'stroke-width', (strokeScale_1 ? strokeWidth / strokeScale_1 : 0) + '');
+            attr(svgEl, 'paint-order', style.strokeFirst ? 'stroke' : 'fill');
+            attr(svgEl, 'stroke-opacity', (style.strokeOpacity != null ? style.strokeOpacity * opacity : opacity) + '');
+            var lineDash = style.lineDash && strokeWidth > 0 && normalizeLineDash(style.lineDash, strokeWidth);
+            if (lineDash) {
+                var lineDashOffset = style.lineDashOffset;
+                if (strokeScale_1 && strokeScale_1 !== 1) {
+                    lineDash = map(lineDash, function (rawVal) {
+                        return rawVal / strokeScale_1;
+                    });
+                    if (lineDashOffset) {
+                        lineDashOffset /= strokeScale_1;
+                        lineDashOffset = mathRound(lineDashOffset);
+                    }
+                }
+                attr(svgEl, 'stroke-dasharray', lineDash.join(','));
+                attr(svgEl, 'stroke-dashoffset', (lineDashOffset || 0) + '');
+            }
+            else {
+                attr(svgEl, 'stroke-dasharray', '');
+            }
+            style.lineCap && attr(svgEl, 'stroke-linecap', style.lineCap);
+            style.lineJoin && attr(svgEl, 'stroke-linejoin', style.lineJoin);
+            style.miterLimit && attr(svgEl, 'stroke-miterlimit', style.miterLimit + '');
+        }
+        else {
+            attr(svgEl, 'stroke', NONE);
+        }
+    }
+    var SVGPathRebuilder = (function () {
+        function SVGPathRebuilder() {
+        }
+        SVGPathRebuilder.prototype.reset = function () {
+            this._d = [];
+            this._str = '';
+        };
+        SVGPathRebuilder.prototype.moveTo = function (x, y) {
+            this._add('M', x, y);
+        };
+        SVGPathRebuilder.prototype.lineTo = function (x, y) {
+            this._add('L', x, y);
+        };
+        SVGPathRebuilder.prototype.bezierCurveTo = function (x, y, x2, y2, x3, y3) {
+            this._add('C', x, y, x2, y2, x3, y3);
+        };
+        SVGPathRebuilder.prototype.quadraticCurveTo = function (x, y, x2, y2) {
+            this._add('Q', x, y, x2, y2);
+        };
+        SVGPathRebuilder.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) {
+            this.ellipse(cx, cy, r, r, 0, startAngle, endAngle, anticlockwise);
+        };
+        SVGPathRebuilder.prototype.ellipse = function (cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise) {
+            var firstCmd = this._d.length === 0;
+            var dTheta = endAngle - startAngle;
+            var clockwise = !anticlockwise;
+            var dThetaPositive = Math.abs(dTheta);
+            var isCircle = isAroundZero$1(dThetaPositive - PI2$7)
+                || (clockwise ? dTheta >= PI2$7 : -dTheta >= PI2$7);
+            var unifiedTheta = dTheta > 0 ? dTheta % PI2$7 : (dTheta % PI2$7 + PI2$7);
+            var large = false;
+            if (isCircle) {
+                large = true;
+            }
+            else if (isAroundZero$1(dThetaPositive)) {
+                large = false;
+            }
+            else {
+                large = (unifiedTheta >= PI$4) === !!clockwise;
+            }
+            var x0 = round4(cx + rx * mathCos$4(startAngle));
+            var y0 = round4(cy + ry * mathSin$4(startAngle));
+            if (isCircle) {
+                if (clockwise) {
+                    dTheta = PI2$7 - 1e-4;
+                }
+                else {
+                    dTheta = -PI2$7 + 1e-4;
+                }
+                large = true;
+                if (firstCmd) {
+                    this._d.push('M', x0, y0);
+                }
+            }
+            var x = round4(cx + rx * mathCos$4(startAngle + dTheta));
+            var y = round4(cy + ry * mathSin$4(startAngle + dTheta));
+            if (isNaN(x0) || isNaN(y0) || isNaN(rx) || isNaN(ry) || isNaN(psi) || isNaN(degree) || isNaN(x) || isNaN(y)) {
+                return '';
+            }
+            this._d.push('A', round4(rx), round4(ry), mathRound(psi * degree), +large, +clockwise, x, y);
+        };
+        SVGPathRebuilder.prototype.rect = function (x, y, w, h) {
+            this._add('M', x, y);
+            this._add('L', x + w, y);
+            this._add('L', x + w, y + h);
+            this._add('L', x, y + h);
+            this._add('L', x, y);
+        };
+        SVGPathRebuilder.prototype.closePath = function () {
+            if (this._d.length > 0) {
+                this._add('Z');
+            }
+        };
+        SVGPathRebuilder.prototype._add = function (cmd, a, b, c, d, e, f, g, h) {
+            this._d.push(cmd);
+            for (var i = 1; i < arguments.length; i++) {
+                var val = arguments[i];
+                if (isNaN(val)) {
+                    this._invalid = true;
+                    return;
+                }
+                this._d.push(round4(val));
+            }
+        };
+        SVGPathRebuilder.prototype.generateStr = function () {
+            this._str = this._invalid ? '' : this._d.join(' ');
+            this._d = [];
+        };
+        SVGPathRebuilder.prototype.getStr = function () {
+            return this._str;
+        };
+        return SVGPathRebuilder;
+    }());
+    var svgPath = {
+        brush: function (el) {
+            var style = el.style;
+            var svgEl = el.__svgEl;
+            if (!svgEl) {
+                svgEl = createElement('path');
+                el.__svgEl = svgEl;
+            }
+            if (!el.path) {
+                el.createPathProxy();
+            }
+            var path = el.path;
+            if (el.shapeChanged()) {
+                path.beginPath();
+                el.buildPath(path, el.shape);
+                el.pathUpdated();
+            }
+            var pathVersion = path.getVersion();
+            var elExt = el;
+            var svgPathBuilder = elExt.__svgPathBuilder;
+            if (elExt.__svgPathVersion !== pathVersion || !svgPathBuilder || el.style.strokePercent < 1) {
+                if (!svgPathBuilder) {
+                    svgPathBuilder = elExt.__svgPathBuilder = new SVGPathRebuilder();
+                }
+                svgPathBuilder.reset();
+                path.rebuildPath(svgPathBuilder, el.style.strokePercent);
+                svgPathBuilder.generateStr();
+                elExt.__svgPathVersion = pathVersion;
+            }
+            attr(svgEl, 'd', svgPathBuilder.getStr());
+            bindStyle(svgEl, style, el);
+            setTransform(svgEl, el.transform);
+        }
+    };
+    var svgImage = {
+        brush: function (el) {
+            var style = el.style;
+            var image = style.image;
+            if (image instanceof HTMLImageElement) {
+                image = image.src;
+            }
+            else if (image instanceof HTMLCanvasElement) {
+                image = image.toDataURL();
+            }
+            if (!image) {
+                return;
+            }
+            var x = style.x || 0;
+            var y = style.y || 0;
+            var dw = style.width;
+            var dh = style.height;
+            var svgEl = el.__svgEl;
+            if (!svgEl) {
+                svgEl = createElement('image');
+                el.__svgEl = svgEl;
+            }
+            if (image !== el.__imageSrc) {
+                attrXLink(svgEl, 'href', image);
+                el.__imageSrc = image;
+            }
+            attr(svgEl, 'width', dw + '');
+            attr(svgEl, 'height', dh + '');
+            attr(svgEl, 'x', x + '');
+            attr(svgEl, 'y', y + '');
+            bindStyle(svgEl, style, el);
+            setTransform(svgEl, el.transform);
+        }
+    };
+    var TEXT_ALIGN_TO_ANCHOR = {
+        left: 'start',
+        right: 'end',
+        center: 'middle',
+        middle: 'middle'
+    };
+    function adjustTextY$1(y, lineHeight, textBaseline) {
+        if (textBaseline === 'top') {
+            y += lineHeight / 2;
+        }
+        else if (textBaseline === 'bottom') {
+            y -= lineHeight / 2;
+        }
+        return y;
+    }
+    var svgText = {
+        brush: function (el) {
+            var style = el.style;
+            var text = style.text;
+            text != null && (text += '');
+            if (!text || isNaN(style.x) || isNaN(style.y)) {
+                return;
+            }
+            var textSvgEl = el.__svgEl;
+            if (!textSvgEl) {
+                textSvgEl = createElement('text');
+                attrXML(textSvgEl, 'xml:space', 'preserve');
+                el.__svgEl = textSvgEl;
+            }
+            var font = style.font || DEFAULT_FONT;
+            var textSvgElStyle = textSvgEl.style;
+            textSvgElStyle.font = font;
+            textSvgEl.textContent = text;
+            bindStyle(textSvgEl, style, el);
+            setTransform(textSvgEl, el.transform);
+            var x = style.x || 0;
+            var y = adjustTextY$1(style.y || 0, getLineHeight(font), style.textBaseline);
+            var textAlign = TEXT_ALIGN_TO_ANCHOR[style.textAlign]
+                || style.textAlign;
+            attr(textSvgEl, 'dominant-baseline', 'central');
+            attr(textSvgEl, 'text-anchor', textAlign);
+            attr(textSvgEl, 'x', x + '');
+            attr(textSvgEl, 'y', y + '');
+        }
+    };
+
+    var MARK_UNUSED = '0';
+    var MARK_USED = '1';
+    var Definable = (function () {
+        function Definable(zrId, svgRoot, tagNames, markLabel, domName) {
+            this.nextId = 0;
+            this._domName = '_dom';
+            this.createElement = createElement;
+            this._zrId = zrId;
+            this._svgRoot = svgRoot;
+            this._tagNames = typeof tagNames === 'string' ? [tagNames] : tagNames;
+            this._markLabel = markLabel;
+            if (domName) {
+                this._domName = domName;
+            }
+        }
+        Definable.prototype.getDefs = function (isForceCreating) {
+            var svgRoot = this._svgRoot;
+            var defs = this._svgRoot.getElementsByTagName('defs');
+            if (defs.length === 0) {
+                if (isForceCreating) {
+                    var defs_1 = svgRoot.insertBefore(this.createElement('defs'), svgRoot.firstChild);
+                    if (!defs_1.contains) {
+                        defs_1.contains = function (el) {
+                            var children = defs_1.children;
+                            if (!children) {
+                                return false;
+                            }
+                            for (var i = children.length - 1; i >= 0; --i) {
+                                if (children[i] === el) {
+                                    return true;
+                                }
+                            }
+                            return false;
+                        };
+                    }
+                    return defs_1;
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return defs[0];
+            }
+        };
+        Definable.prototype.doUpdate = function (target, onUpdate) {
+            if (!target) {
+                return;
+            }
+            var defs = this.getDefs(false);
+            if (target[this._domName] && defs.contains(target[this._domName])) {
+                if (typeof onUpdate === 'function') {
+                    onUpdate(target);
+                }
+            }
+            else {
+                var dom = this.add(target);
+                if (dom) {
+                    target[this._domName] = dom;
+                }
+            }
+        };
+        Definable.prototype.add = function (target) {
+            return null;
+        };
+        Definable.prototype.addDom = function (dom) {
+            var defs = this.getDefs(true);
+            if (dom.parentNode !== defs) {
+                defs.appendChild(dom);
+            }
+        };
+        Definable.prototype.removeDom = function (target) {
+            var defs = this.getDefs(false);
+            if (defs && target[this._domName]) {
+                defs.removeChild(target[this._domName]);
+                target[this._domName] = null;
+            }
+        };
+        Definable.prototype.getDoms = function () {
+            var defs = this.getDefs(false);
+            if (!defs) {
+                return [];
+            }
+            var doms = [];
+            each(this._tagNames, function (tagName) {
+                var tags = defs.getElementsByTagName(tagName);
+                for (var i = 0; i < tags.length; i++) {
+                    doms.push(tags[i]);
+                }
+            });
+            return doms;
+        };
+        Definable.prototype.markAllUnused = function () {
+            var doms = this.getDoms();
+            var that = this;
+            each(doms, function (dom) {
+                dom[that._markLabel] = MARK_UNUSED;
+            });
+        };
+        Definable.prototype.markDomUsed = function (dom) {
+            dom && (dom[this._markLabel] = MARK_USED);
+        };
+        Definable.prototype.markDomUnused = function (dom) {
+            dom && (dom[this._markLabel] = MARK_UNUSED);
+        };
+        Definable.prototype.isDomUnused = function (dom) {
+            return dom && dom[this._markLabel] !== MARK_USED;
+        };
+        Definable.prototype.removeUnused = function () {
+            var _this = this;
+            var defs = this.getDefs(false);
+            if (!defs) {
+                return;
+            }
+            var doms = this.getDoms();
+            each(doms, function (dom) {
+                if (_this.isDomUnused(dom)) {
+                    defs.removeChild(dom);
+                }
+            });
+        };
+        Definable.prototype.getSvgProxy = function (displayable) {
+            if (displayable instanceof Path) {
+                return svgPath;
+            }
+            else if (displayable instanceof ZRImage) {
+                return svgImage;
+            }
+            else if (displayable instanceof TSpan) {
+                return svgText;
+            }
+            else {
+                return svgPath;
+            }
+        };
+        Definable.prototype.getSvgElement = function (displayable) {
+            return displayable.__svgEl;
+        };
+        return Definable;
+    }());
+
+    function isLinearGradient(value) {
+        return value.type === 'linear';
+    }
+    function isRadialGradient(value) {
+        return value.type === 'radial';
+    }
+    function isGradient(value) {
+        return value && (value.type === 'linear'
+            || value.type === 'radial');
+    }
+    var GradientManager = (function (_super) {
+        __extends(GradientManager, _super);
+        function GradientManager(zrId, svgRoot) {
+            return _super.call(this, zrId, svgRoot, ['linearGradient', 'radialGradient'], '__gradient_in_use__') || this;
+        }
+        GradientManager.prototype.addWithoutUpdate = function (svgElement, displayable) {
+            if (displayable && displayable.style) {
+                var that_1 = this;
+                each(['fill', 'stroke'], function (fillOrStroke) {
+                    var value = displayable.style[fillOrStroke];
+                    if (isGradient(value)) {
+                        var gradient = value;
+                        var defs = that_1.getDefs(true);
+                        var dom = void 0;
+                        if (gradient.__dom) {
+                            dom = gradient.__dom;
+                            if (!defs.contains(gradient.__dom)) {
+                                that_1.addDom(dom);
+                            }
+                        }
+                        else {
+                            dom = that_1.add(gradient);
+                        }
+                        that_1.markUsed(displayable);
+                        var id = dom.getAttribute('id');
+                        svgElement.setAttribute(fillOrStroke, 'url(#' + id + ')');
+                    }
+                });
+            }
+        };
+        GradientManager.prototype.add = function (gradient) {
+            var dom;
+            if (isLinearGradient(gradient)) {
+                dom = this.createElement('linearGradient');
+            }
+            else if (isRadialGradient(gradient)) {
+                dom = this.createElement('radialGradient');
+            }
+            else {
+                logError('Illegal gradient type.');
+                return null;
+            }
+            gradient.id = gradient.id || this.nextId++;
+            dom.setAttribute('id', 'zr' + this._zrId
+                + '-gradient-' + gradient.id);
+            this.updateDom(gradient, dom);
+            this.addDom(dom);
+            return dom;
+        };
+        GradientManager.prototype.update = function (gradient) {
+            if (!isGradient(gradient)) {
+                return;
+            }
+            var that = this;
+            this.doUpdate(gradient, function () {
+                var dom = gradient.__dom;
+                if (!dom) {
+                    return;
+                }
+                var tagName = dom.tagName;
+                var type = gradient.type;
+                if (type === 'linear' && tagName === 'linearGradient'
+                    || type === 'radial' && tagName === 'radialGradient') {
+                    that.updateDom(gradient, gradient.__dom);
+                }
+                else {
+                    that.removeDom(gradient);
+                    that.add(gradient);
+                }
+            });
+        };
+        GradientManager.prototype.updateDom = function (gradient, dom) {
+            if (isLinearGradient(gradient)) {
+                dom.setAttribute('x1', gradient.x + '');
+                dom.setAttribute('y1', gradient.y + '');
+                dom.setAttribute('x2', gradient.x2 + '');
+                dom.setAttribute('y2', gradient.y2 + '');
+            }
+            else if (isRadialGradient(gradient)) {
+                dom.setAttribute('cx', gradient.x + '');
+                dom.setAttribute('cy', gradient.y + '');
+                dom.setAttribute('r', gradient.r + '');
+            }
+            else {
+                logError('Illegal gradient type.');
+                return;
+            }
+            if (gradient.global) {
+                dom.setAttribute('gradientUnits', 'userSpaceOnUse');
+            }
+            else {
+                dom.setAttribute('gradientUnits', 'objectBoundingBox');
+            }
+            dom.innerHTML = '';
+            var colors = gradient.colorStops;
+            for (var i = 0, len = colors.length; i < len; ++i) {
+                var stop_1 = this.createElement('stop');
+                stop_1.setAttribute('offset', colors[i].offset * 100 + '%');
+                var color$1 = colors[i].color;
+                if (color$1.indexOf('rgba') > -1) {
+                    var opacity = parse(color$1)[3];
+                    var hex = toHex(color$1);
+                    stop_1.setAttribute('stop-color', '#' + hex);
+                    stop_1.setAttribute('stop-opacity', opacity + '');
+                }
+                else {
+                    stop_1.setAttribute('stop-color', colors[i].color);
+                }
+                dom.appendChild(stop_1);
+            }
+            gradient.__dom = dom;
+        };
+        GradientManager.prototype.markUsed = function (displayable) {
+            if (displayable.style) {
+                var gradient = displayable.style.fill;
+                if (gradient && gradient.__dom) {
+                    _super.prototype.markDomUsed.call(this, gradient.__dom);
+                }
+                gradient = displayable.style.stroke;
+                if (gradient && gradient.__dom) {
+                    _super.prototype.markDomUsed.call(this, gradient.__dom);
+                }
+            }
+        };
+        return GradientManager;
+    }(Definable));
+
+    function isPattern(value) {
+        return value && (!!value.image || !!value.svgElement);
+    }
+    var patternDomMap = new WeakMap();
+    var PatternManager = (function (_super) {
+        __extends(PatternManager, _super);
+        function PatternManager(zrId, svgRoot) {
+            return _super.call(this, zrId, svgRoot, ['pattern'], '__pattern_in_use__') || this;
+        }
+        PatternManager.prototype.addWithoutUpdate = function (svgElement, displayable) {
+            if (displayable && displayable.style) {
+                var that_1 = this;
+                each(['fill', 'stroke'], function (fillOrStroke) {
+                    var pattern = displayable.style[fillOrStroke];
+                    if (isPattern(pattern)) {
+                        var defs = that_1.getDefs(true);
+                        var dom = patternDomMap.get(pattern);
+                        if (dom) {
+                            if (!defs.contains(dom)) {
+                                that_1.addDom(dom);
+                            }
+                        }
+                        else {
+                            dom = that_1.add(pattern);
+                        }
+                        that_1.markUsed(displayable);
+                        var id = dom.getAttribute('id');
+                        svgElement.setAttribute(fillOrStroke, 'url(#' + id + ')');
+                    }
+                });
+            }
+        };
+        PatternManager.prototype.add = function (pattern) {
+            if (!isPattern(pattern)) {
+                return;
+            }
+            var dom = this.createElement('pattern');
+            pattern.id = pattern.id == null ? this.nextId++ : pattern.id;
+            dom.setAttribute('id', 'zr' + this._zrId
+                + '-pattern-' + pattern.id);
+            dom.setAttribute('x', '0');
+            dom.setAttribute('y', '0');
+            dom.setAttribute('patternUnits', 'userSpaceOnUse');
+            this.updateDom(pattern, dom);
+            this.addDom(dom);
+            return dom;
+        };
+        PatternManager.prototype.update = function (pattern) {
+            if (!isPattern(pattern)) {
+                return;
+            }
+            var that = this;
+            this.doUpdate(pattern, function () {
+                var dom = patternDomMap.get(pattern);
+                that.updateDom(pattern, dom);
+            });
+        };
+        PatternManager.prototype.updateDom = function (pattern, patternDom) {
+            var svgElement = pattern.svgElement;
+            if (svgElement instanceof SVGElement) {
+                if (svgElement.parentNode !== patternDom) {
+                    patternDom.innerHTML = '';
+                    patternDom.appendChild(svgElement);
+                    patternDom.setAttribute('width', pattern.svgWidth + '');
+                    patternDom.setAttribute('height', pattern.svgHeight + '');
+                }
+            }
+            else {
+                var img = void 0;
+                var prevImage = patternDom.getElementsByTagName('image');
+                if (prevImage.length) {
+                    if (pattern.image) {
+                        img = prevImage[0];
+                    }
+                    else {
+                        patternDom.removeChild(prevImage[0]);
+                        return;
+                    }
+                }
+                else if (pattern.image) {
+                    img = this.createElement('image');
+                }
+                if (img) {
+                    var imageSrc = void 0;
+                    if (typeof pattern.image === 'string') {
+                        imageSrc = pattern.image;
+                    }
+                    else if (pattern.image instanceof HTMLImageElement) {
+                        imageSrc = pattern.image.src;
+                    }
+                    else if (pattern.image instanceof HTMLCanvasElement) {
+                        imageSrc = pattern.image.toDataURL();
+                    }
+                    if (imageSrc) {
+                        img.setAttribute('href', imageSrc);
+                        img.setAttribute('x', '0');
+                        img.setAttribute('y', '0');
+                        var hostEl = {
+                            dirty: function () { }
+                        };
+                        var createdImage = createOrUpdateImage(imageSrc, img, hostEl, function (img) {
+                            patternDom.setAttribute('width', img.width + '');
+                            patternDom.setAttribute('height', img.height + '');
+                        });
+                        if (createdImage && createdImage.width && createdImage.height) {
+                            patternDom.setAttribute('width', createdImage.width + '');
+                            patternDom.setAttribute('height', createdImage.height + '');
+                        }
+                        patternDom.appendChild(img);
+                    }
+                }
+            }
+            var x = pattern.x || 0;
+            var y = pattern.y || 0;
+            var rotation = (pattern.rotation || 0) / Math.PI * 180;
+            var scaleX = pattern.scaleX || 1;
+            var scaleY = pattern.scaleY || 1;
+            var transform = "translate(" + x + ", " + y + ") rotate(" + rotation + ") scale(" + scaleX + ", " + scaleY + ")";
+            patternDom.setAttribute('patternTransform', transform);
+            patternDomMap.set(pattern, patternDom);
+        };
+        PatternManager.prototype.markUsed = function (displayable) {
+            if (displayable.style) {
+                if (isPattern(displayable.style.fill)) {
+                    _super.prototype.markDomUsed.call(this, patternDomMap.get(displayable.style.fill));
+                }
+                if (isPattern(displayable.style.stroke)) {
+                    _super.prototype.markDomUsed.call(this, patternDomMap.get(displayable.style.stroke));
+                }
+            }
+        };
+        return PatternManager;
+    }(Definable));
+
+    function generateClipPathsKey(clipPaths) {
+        var key = [];
+        if (clipPaths) {
+            for (var i = 0; i < clipPaths.length; i++) {
+                var clipPath = clipPaths[i];
+                key.push(clipPath.id);
+            }
+        }
+        return key.join(',');
+    }
+    function hasClipPath(displayable) {
+        var clipPaths = displayable.__clipPaths;
+        return clipPaths && clipPaths.length > 0;
+    }
+    var ClippathManager = (function (_super) {
+        __extends(ClippathManager, _super);
+        function ClippathManager(zrId, svgRoot) {
+            var _this = _super.call(this, zrId, svgRoot, 'clipPath', '__clippath_in_use__') || this;
+            _this._refGroups = {};
+            _this._keyDuplicateCount = {};
+            return _this;
+        }
+        ClippathManager.prototype.markAllUnused = function () {
+            _super.prototype.markAllUnused.call(this);
+            for (var key in this._refGroups) {
+                this.markDomUnused(this._refGroups[key]);
+            }
+            this._keyDuplicateCount = {};
+        };
+        ClippathManager.prototype._getClipPathGroup = function (displayable, prevDisplayable) {
+            if (!hasClipPath(displayable)) {
+                return;
+            }
+            var clipPaths = displayable.__clipPaths;
+            var keyDuplicateCount = this._keyDuplicateCount;
+            var clipPathKey = generateClipPathsKey(clipPaths);
+            if (isClipPathChanged(clipPaths, prevDisplayable && prevDisplayable.__clipPaths)) {
+                keyDuplicateCount[clipPathKey] = keyDuplicateCount[clipPathKey] || 0;
+                keyDuplicateCount[clipPathKey] && (clipPathKey += '-' + keyDuplicateCount[clipPathKey]);
+                keyDuplicateCount[clipPathKey]++;
+            }
+            return this._refGroups[clipPathKey]
+                || (this._refGroups[clipPathKey] = this.createElement('g'));
+        };
+        ClippathManager.prototype.update = function (displayable, prevDisplayable) {
+            var clipGroup = this._getClipPathGroup(displayable, prevDisplayable);
+            if (clipGroup) {
+                this.markDomUsed(clipGroup);
+                this.updateDom(clipGroup, displayable.__clipPaths);
+            }
+            return clipGroup;
+        };
+        ClippathManager.prototype.updateDom = function (parentEl, clipPaths) {
+            if (clipPaths && clipPaths.length > 0) {
+                var defs = this.getDefs(true);
+                var clipPath = clipPaths[0];
+                var clipPathEl = void 0;
+                var id = void 0;
+                if (clipPath._dom) {
+                    id = clipPath._dom.getAttribute('id');
+                    clipPathEl = clipPath._dom;
+                    if (!defs.contains(clipPathEl)) {
+                        defs.appendChild(clipPathEl);
+                    }
+                }
+                else {
+                    id = 'zr' + this._zrId + '-clip-' + this.nextId;
+                    ++this.nextId;
+                    clipPathEl = this.createElement('clipPath');
+                    clipPathEl.setAttribute('id', id);
+                    defs.appendChild(clipPathEl);
+                    clipPath._dom = clipPathEl;
+                }
+                var svgProxy = this.getSvgProxy(clipPath);
+                svgProxy.brush(clipPath);
+                var pathEl = this.getSvgElement(clipPath);
+                clipPathEl.innerHTML = '';
+                clipPathEl.appendChild(pathEl);
+                parentEl.setAttribute('clip-path', 'url(#' + id + ')');
+                if (clipPaths.length > 1) {
+                    this.updateDom(clipPathEl, clipPaths.slice(1));
+                }
+            }
+            else {
+                if (parentEl) {
+                    parentEl.setAttribute('clip-path', 'none');
+                }
+            }
+        };
+        ClippathManager.prototype.markUsed = function (displayable) {
+            var _this = this;
+            if (displayable.__clipPaths) {
+                each(displayable.__clipPaths, function (clipPath) {
+                    if (clipPath._dom) {
+                        _super.prototype.markDomUsed.call(_this, clipPath._dom);
+                    }
+                });
+            }
+        };
+        ClippathManager.prototype.removeUnused = function () {
+            _super.prototype.removeUnused.call(this);
+            var newRefGroupsMap = {};
+            for (var key in this._refGroups) {
+                var group = this._refGroups[key];
+                if (!this.isDomUnused(group)) {
+                    newRefGroupsMap[key] = group;
+                }
+                else if (group.parentNode) {
+                    group.parentNode.removeChild(group);
+                }
+            }
+            this._refGroups = newRefGroupsMap;
+        };
+        return ClippathManager;
+    }(Definable));
+
+    var ShadowManager = (function (_super) {
+        __extends(ShadowManager, _super);
+        function ShadowManager(zrId, svgRoot) {
+            var _this = _super.call(this, zrId, svgRoot, ['filter'], '__filter_in_use__', '_shadowDom') || this;
+            _this._shadowDomMap = {};
+            _this._shadowDomPool = [];
+            return _this;
+        }
+        ShadowManager.prototype._getFromPool = function () {
+            var shadowDom = this._shadowDomPool.pop();
+            if (!shadowDom) {
+                shadowDom = this.createElement('filter');
+                shadowDom.setAttribute('id', 'zr' + this._zrId + '-shadow-' + this.nextId++);
+                var domChild = this.createElement('feDropShadow');
+                shadowDom.appendChild(domChild);
+                this.addDom(shadowDom);
+            }
+            return shadowDom;
+        };
+        ShadowManager.prototype.update = function (svgElement, displayable) {
+            var style = displayable.style;
+            if (hasShadow(style)) {
+                var shadowKey = getShadowKey(displayable);
+                var shadowDom = displayable._shadowDom = this._shadowDomMap[shadowKey];
+                if (!shadowDom) {
+                    shadowDom = this._getFromPool();
+                    this._shadowDomMap[shadowKey] = shadowDom;
+                }
+                this.updateDom(svgElement, displayable, shadowDom);
+            }
+            else {
+                this.remove(svgElement, displayable);
+            }
+        };
+        ShadowManager.prototype.remove = function (svgElement, displayable) {
+            if (displayable._shadowDom != null) {
+                displayable._shadowDom = null;
+                svgElement.style.filter = '';
+            }
+        };
+        ShadowManager.prototype.updateDom = function (svgElement, displayable, shadowDom) {
+            var domChild = shadowDom.children[0];
+            var style = displayable.style;
+            var globalScale = displayable.getGlobalScale();
+            var scaleX = globalScale[0];
+            var scaleY = globalScale[1];
+            if (!scaleX || !scaleY) {
+                return;
+            }
+            var offsetX = style.shadowOffsetX || 0;
+            var offsetY = style.shadowOffsetY || 0;
+            var blur = style.shadowBlur;
+            var color = style.shadowColor;
+            domChild.setAttribute('dx', offsetX / scaleX + '');
+            domChild.setAttribute('dy', offsetY / scaleY + '');
+            domChild.setAttribute('flood-color', color);
+            var stdDx = blur / 2 / scaleX;
+            var stdDy = blur / 2 / scaleY;
+            var stdDeviation = stdDx + ' ' + stdDy;
+            domChild.setAttribute('stdDeviation', stdDeviation);
+            shadowDom.setAttribute('x', '-100%');
+            shadowDom.setAttribute('y', '-100%');
+            shadowDom.setAttribute('width', '300%');
+            shadowDom.setAttribute('height', '300%');
+            displayable._shadowDom = shadowDom;
+            var id = shadowDom.getAttribute('id');
+            svgElement.style.filter = 'url(#' + id + ')';
+        };
+        ShadowManager.prototype.removeUnused = function () {
+            var defs = this.getDefs(false);
+            if (!defs) {
+                return;
+            }
+            var shadowDomsPool = this._shadowDomPool;
+            for (var key in this._shadowDomMap) {
+                var dom = this._shadowDomMap[key];
+                shadowDomsPool.push(dom);
+            }
+            this._shadowDomMap = {};
+        };
+        return ShadowManager;
+    }(Definable));
+    function hasShadow(style) {
+        return style
+            && (style.shadowBlur || style.shadowOffsetX || style.shadowOffsetY);
+    }
+    function getShadowKey(displayable) {
+        var style = displayable.style;
+        var globalScale = displayable.getGlobalScale();
+        return [
+            style.shadowColor,
+            (style.shadowBlur || 0).toFixed(2),
+            (style.shadowOffsetX || 0).toFixed(2),
+            (style.shadowOffsetY || 0).toFixed(2),
+            globalScale[0],
+            globalScale[1]
+        ].join(',');
+    }
+
+    function parseInt10(val) {
+        return parseInt(val, 10);
+    }
+    function getSvgProxy(el) {
+        if (el instanceof Path) {
+            return svgPath;
+        }
+        else if (el instanceof ZRImage) {
+            return svgImage;
+        }
+        else if (el instanceof TSpan) {
+            return svgText;
+        }
+        else {
+            return svgPath;
+        }
+    }
+    function checkParentAvailable(parent, child) {
+        return child && parent && child.parentNode !== parent;
+    }
+    function insertAfter(parent, child, prevSibling) {
+        if (checkParentAvailable(parent, child) && prevSibling) {
+            var nextSibling = prevSibling.nextSibling;
+            nextSibling ? parent.insertBefore(child, nextSibling)
+                : parent.appendChild(child);
+        }
+    }
+    function prepend(parent, child) {
+        if (checkParentAvailable(parent, child)) {
+            var firstChild = parent.firstChild;
+            firstChild ? parent.insertBefore(child, firstChild)
+                : parent.appendChild(child);
+        }
+    }
+    function remove(parent, child) {
+        if (child && parent && child.parentNode === parent) {
+            parent.removeChild(child);
+        }
+    }
+    function removeFromMyParent(child) {
+        if (child && child.parentNode) {
+            child.parentNode.removeChild(child);
+        }
+    }
+    function getSvgElement(displayable) {
+        return displayable.__svgEl;
+    }
+    var SVGPainter = (function () {
+        function SVGPainter(root, storage, opts, zrId) {
+            this.type = 'svg';
+            this.refreshHover = createMethodNotSupport('refreshHover');
+            this.pathToImage = createMethodNotSupport('pathToImage');
+            this.configLayer = createMethodNotSupport('configLayer');
+            this.root = root;
+            this.storage = storage;
+            this._opts = opts = extend({}, opts || {});
+            var svgDom = createElement('svg');
+            svgDom.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns', 'http://www.w3.org/2000/svg');
+            svgDom.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:xlink', 'http://www.w3.org/1999/xlink');
+            svgDom.setAttribute('version', '1.1');
+            svgDom.setAttribute('baseProfile', 'full');
+            svgDom.style.cssText = 'user-select:none;position:absolute;left:0;top:0;';
+            var bgRoot = createElement('g');
+            svgDom.appendChild(bgRoot);
+            var svgRoot = createElement('g');
+            svgDom.appendChild(svgRoot);
+            this._gradientManager = new GradientManager(zrId, svgRoot);
+            this._patternManager = new PatternManager(zrId, svgRoot);
+            this._clipPathManager = new ClippathManager(zrId, svgRoot);
+            this._shadowManager = new ShadowManager(zrId, svgRoot);
+            var viewport = document.createElement('div');
+            viewport.style.cssText = 'overflow:hidden;position:relative';
+            this._svgDom = svgDom;
+            this._svgRoot = svgRoot;
+            this._backgroundRoot = bgRoot;
+            this._viewport = viewport;
+            root.appendChild(viewport);
+            viewport.appendChild(svgDom);
+            this.resize(opts.width, opts.height);
+            this._visibleList = [];
+        }
+        SVGPainter.prototype.getType = function () {
+            return 'svg';
+        };
+        SVGPainter.prototype.getViewportRoot = function () {
+            return this._viewport;
+        };
+        SVGPainter.prototype.getSvgDom = function () {
+            return this._svgDom;
+        };
+        SVGPainter.prototype.getSvgRoot = function () {
+            return this._svgRoot;
+        };
+        SVGPainter.prototype.getViewportRootOffset = function () {
+            var viewportRoot = this.getViewportRoot();
+            if (viewportRoot) {
+                return {
+                    offsetLeft: viewportRoot.offsetLeft || 0,
+                    offsetTop: viewportRoot.offsetTop || 0
+                };
+            }
+        };
+        SVGPainter.prototype.refresh = function () {
+            var list = this.storage.getDisplayList(true);
+            this._paintList(list);
+        };
+        SVGPainter.prototype.setBackgroundColor = function (backgroundColor) {
+            if (this._backgroundRoot && this._backgroundNode) {
+                this._backgroundRoot.removeChild(this._backgroundNode);
+            }
+            var bgNode = createElement('rect');
+            bgNode.setAttribute('width', this.getWidth());
+            bgNode.setAttribute('height', this.getHeight());
+            bgNode.setAttribute('x', 0);
+            bgNode.setAttribute('y', 0);
+            bgNode.setAttribute('id', 0);
+            bgNode.style.fill = backgroundColor;
+            this._backgroundRoot.appendChild(bgNode);
+            this._backgroundNode = bgNode;
+        };
+        SVGPainter.prototype.createSVGElement = function (tag) {
+            return createElement(tag);
+        };
+        SVGPainter.prototype.paintOne = function (el) {
+            var svgProxy = getSvgProxy(el);
+            svgProxy && svgProxy.brush(el);
+            return getSvgElement(el);
+        };
+        SVGPainter.prototype._paintList = function (list) {
+            var gradientManager = this._gradientManager;
+            var patternManager = this._patternManager;
+            var clipPathManager = this._clipPathManager;
+            var shadowManager = this._shadowManager;
+            gradientManager.markAllUnused();
+            patternManager.markAllUnused();
+            clipPathManager.markAllUnused();
+            shadowManager.markAllUnused();
+            var svgRoot = this._svgRoot;
+            var visibleList = this._visibleList;
+            var listLen = list.length;
+            var newVisibleList = [];
+            for (var i = 0; i < listLen; i++) {
+                var displayable = list[i];
+                var svgProxy = getSvgProxy(displayable);
+                var svgElement = getSvgElement(displayable);
+                if (!displayable.invisible) {
+                    if (displayable.__dirty || !svgElement) {
+                        svgProxy && svgProxy.brush(displayable);
+                        svgElement = getSvgElement(displayable);
+                        if (svgElement && displayable.style) {
+                            gradientManager.update(displayable.style.fill);
+                            gradientManager.update(displayable.style.stroke);
+                            patternManager.update(displayable.style.fill);
+                            patternManager.update(displayable.style.stroke);
+                            shadowManager.update(svgElement, displayable);
+                        }
+                        displayable.__dirty = 0;
+                    }
+                    if (svgElement) {
+                        newVisibleList.push(displayable);
+                    }
+                }
+            }
+            var diff = arrayDiff(visibleList, newVisibleList);
+            var prevSvgElement;
+            var topPrevSvgElement;
+            for (var i = 0; i < diff.length; i++) {
+                var item = diff[i];
+                if (item.removed) {
+                    for (var k = 0; k < item.count; k++) {
+                        var displayable = visibleList[item.indices[k]];
+                        var svgElement = getSvgElement(displayable);
+                        hasClipPath(displayable) ? removeFromMyParent(svgElement)
+                            : remove(svgRoot, svgElement);
+                    }
+                }
+            }
+            var prevDisplayable;
+            var currentClipGroup;
+            for (var i = 0; i < diff.length; i++) {
+                var item = diff[i];
+                if (item.removed) {
+                    continue;
+                }
+                for (var k = 0; k < item.count; k++) {
+                    var displayable = newVisibleList[item.indices[k]];
+                    var clipGroup = clipPathManager.update(displayable, prevDisplayable);
+                    if (clipGroup !== currentClipGroup) {
+                        prevSvgElement = topPrevSvgElement;
+                        if (clipGroup) {
+                            prevSvgElement ? insertAfter(svgRoot, clipGroup, prevSvgElement)
+                                : prepend(svgRoot, clipGroup);
+                            topPrevSvgElement = clipGroup;
+                            prevSvgElement = null;
+                        }
+                        currentClipGroup = clipGroup;
+                    }
+                    var svgElement = getSvgElement(displayable);
+                    prevSvgElement
+                        ? insertAfter(currentClipGroup || svgRoot, svgElement, prevSvgElement)
+                        : prepend(currentClipGroup || svgRoot, svgElement);
+                    prevSvgElement = svgElement || prevSvgElement;
+                    if (!currentClipGroup) {
+                        topPrevSvgElement = prevSvgElement;
+                    }
+                    gradientManager.markUsed(displayable);
+                    gradientManager.addWithoutUpdate(svgElement, displayable);
+                    patternManager.markUsed(displayable);
+                    patternManager.addWithoutUpdate(svgElement, displayable);
+                    clipPathManager.markUsed(displayable);
+                    prevDisplayable = displayable;
+                }
+            }
+            gradientManager.removeUnused();
+            patternManager.removeUnused();
+            clipPathManager.removeUnused();
+            shadowManager.removeUnused();
+            this._visibleList = newVisibleList;
+        };
+        SVGPainter.prototype._getDefs = function (isForceCreating) {
+            var svgRoot = this._svgDom;
+            var defs = svgRoot.getElementsByTagName('defs');
+            if (defs.length === 0) {
+                if (isForceCreating) {
+                    var defs_1 = svgRoot.insertBefore(createElement('defs'), svgRoot.firstChild);
+                    if (!defs_1.contains) {
+                        defs_1.contains = function (el) {
+                            var children = defs_1.children;
+                            if (!children) {
+                                return false;
+                            }
+                            for (var i = children.length - 1; i >= 0; --i) {
+                                if (children[i] === el) {
+                                    return true;
+                                }
+                            }
+                            return false;
+                        };
+                    }
+                    return defs_1;
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return defs[0];
+            }
+        };
+        SVGPainter.prototype.resize = function (width, height) {
+            var viewport = this._viewport;
+            viewport.style.display = 'none';
+            var opts = this._opts;
+            width != null && (opts.width = width);
+            height != null && (opts.height = height);
+            width = this._getSize(0);
+            height = this._getSize(1);
+            viewport.style.display = '';
+            if (this._width !== width || this._height !== height) {
+                this._width = width;
+                this._height = height;
+                var viewportStyle = viewport.style;
+                viewportStyle.width = width + 'px';
+                viewportStyle.height = height + 'px';
+                var svgRoot = this._svgDom;
+                svgRoot.setAttribute('width', width + '');
+                svgRoot.setAttribute('height', height + '');
+            }
+            if (this._backgroundNode) {
+                this._backgroundNode.setAttribute('width', width);
+                this._backgroundNode.setAttribute('height', height);
+            }
+        };
+        SVGPainter.prototype.getWidth = function () {
+            return this._width;
+        };
+        SVGPainter.prototype.getHeight = function () {
+            return this._height;
+        };
+        SVGPainter.prototype._getSize = function (whIdx) {
+            var opts = this._opts;
+            var wh = ['width', 'height'][whIdx];
+            var cwh = ['clientWidth', 'clientHeight'][whIdx];
+            var plt = ['paddingLeft', 'paddingTop'][whIdx];
+            var prb = ['paddingRight', 'paddingBottom'][whIdx];
+            if (opts[wh] != null && opts[wh] !== 'auto') {
+                return parseFloat(opts[wh]);
+            }
+            var root = this.root;
+            var stl = document.defaultView.getComputedStyle(root);
+            return ((root[cwh] || parseInt10(stl[wh]) || parseInt10(root.style[wh]))
+                - (parseInt10(stl[plt]) || 0)
+                - (parseInt10(stl[prb]) || 0)) | 0;
+        };
+        SVGPainter.prototype.dispose = function () {
+            this.root.innerHTML = '';
+            this._svgRoot
+                = this._backgroundRoot
+                    = this._svgDom
+                        = this._backgroundNode
+                            = this._viewport
+                                = this.storage
+                                    = null;
+        };
+        SVGPainter.prototype.clear = function () {
+            var viewportNode = this._viewport;
+            if (viewportNode && viewportNode.parentNode) {
+                viewportNode.parentNode.removeChild(viewportNode);
+            }
+        };
+        SVGPainter.prototype.toDataURL = function () {
+            this.refresh();
+            var svgDom = this._svgDom;
+            var outerHTML = svgDom.outerHTML
+                || (svgDom.parentNode && svgDom.parentNode).innerHTML;
+            var html = encodeURIComponent(outerHTML.replace(/></g, '>\n\r<'));
+            return 'data:image/svg+xml;charset=UTF-8,' + html;
+        };
+        return SVGPainter;
+    }());
+    function createMethodNotSupport(method) {
+        return function () {
+            logError('In SVG mode painter not support method "' + method + '"');
+        };
+    }
+
+    function install(registers) {
+      registers.registerPainter('svg', SVGPainter);
+    }
+
+    function returnFalse() {
+        return false;
+    }
+    function createDom(id, painter, dpr) {
+        var newDom = createCanvas();
+        var width = painter.getWidth();
+        var height = painter.getHeight();
+        var newDomStyle = newDom.style;
+        if (newDomStyle) {
+            newDomStyle.position = 'absolute';
+            newDomStyle.left = '0';
+            newDomStyle.top = '0';
+            newDomStyle.width = width + 'px';
+            newDomStyle.height = height + 'px';
+            newDom.setAttribute('data-zr-dom-id', id);
+        }
+        newDom.width = width * dpr;
+        newDom.height = height * dpr;
+        return newDom;
+    }
+    var Layer = (function (_super) {
+        __extends(Layer, _super);
+        function Layer(id, painter, dpr) {
+            var _this = _super.call(this) || this;
+            _this.motionBlur = false;
+            _this.lastFrameAlpha = 0.7;
+            _this.dpr = 1;
+            _this.virtual = false;
+            _this.config = {};
+            _this.incremental = false;
+            _this.zlevel = 0;
+            _this.maxRepaintRectCount = 5;
+            _this.__dirty = true;
+            _this.__firstTimePaint = true;
+            _this.__used = false;
+            _this.__drawIndex = 0;
+            _this.__startIndex = 0;
+            _this.__endIndex = 0;
+            _this.__prevStartIndex = null;
+            _this.__prevEndIndex = null;
+            var dom;
+            dpr = dpr || devicePixelRatio;
+            if (typeof id === 'string') {
+                dom = createDom(id, painter, dpr);
+            }
+            else if (isObject(id)) {
+                dom = id;
+                id = dom.id;
+            }
+            _this.id = id;
+            _this.dom = dom;
+            var domStyle = dom.style;
+            if (domStyle) {
+                dom.onselectstart = returnFalse;
+                domStyle.webkitUserSelect = 'none';
+                domStyle.userSelect = 'none';
+                domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)';
+                domStyle['-webkit-touch-callout'] = 'none';
+                domStyle.padding = '0';
+                domStyle.margin = '0';
+                domStyle.borderWidth = '0';
+            }
+            _this.domBack = null;
+            _this.ctxBack = null;
+            _this.painter = painter;
+            _this.config = null;
+            _this.dpr = dpr;
+            return _this;
+        }
+        Layer.prototype.getElementCount = function () {
+            return this.__endIndex - this.__startIndex;
+        };
+        Layer.prototype.afterBrush = function () {
+            this.__prevStartIndex = this.__startIndex;
+            this.__prevEndIndex = this.__endIndex;
+        };
+        Layer.prototype.initContext = function () {
+            this.ctx = this.dom.getContext('2d');
+            this.ctx.dpr = this.dpr;
+        };
+        Layer.prototype.setUnpainted = function () {
+            this.__firstTimePaint = true;
+        };
+        Layer.prototype.createBackBuffer = function () {
+            var dpr = this.dpr;
+            this.domBack = createDom('back-' + this.id, this.painter, dpr);
+            this.ctxBack = this.domBack.getContext('2d');
+            if (dpr !== 1) {
+                this.ctxBack.scale(dpr, dpr);
+            }
+        };
+        Layer.prototype.createRepaintRects = function (displayList, prevList, viewWidth, viewHeight) {
+            if (this.__firstTimePaint) {
+                this.__firstTimePaint = false;
+                return null;
+            }
+            var mergedRepaintRects = [];
+            var maxRepaintRectCount = this.maxRepaintRectCount;
+            var full = false;
+            var pendingRect = new BoundingRect(0, 0, 0, 0);
+            function addRectToMergePool(rect) {
+                if (!rect.isFinite() || rect.isZero()) {
+                    return;
+                }
+                if (mergedRepaintRects.length === 0) {
+                    var boundingRect = new BoundingRect(0, 0, 0, 0);
+                    boundingRect.copy(rect);
+                    mergedRepaintRects.push(boundingRect);
+                }
+                else {
+                    var isMerged = false;
+                    var minDeltaArea = Infinity;
+                    var bestRectToMergeIdx = 0;
+                    for (var i = 0; i < mergedRepaintRects.length; ++i) {
+                        var mergedRect = mergedRepaintRects[i];
+                        if (mergedRect.intersect(rect)) {
+                            var pendingRect_1 = new BoundingRect(0, 0, 0, 0);
+                            pendingRect_1.copy(mergedRect);
+                            pendingRect_1.union(rect);
+                            mergedRepaintRects[i] = pendingRect_1;
+                            isMerged = true;
+                            break;
+                        }
+                        else if (full) {
+                            pendingRect.copy(rect);
+                            pendingRect.union(mergedRect);
+                            var aArea = rect.width * rect.height;
+                            var bArea = mergedRect.width * mergedRect.height;
+                            var pendingArea = pendingRect.width * pendingRect.height;
+                            var deltaArea = pendingArea - aArea - bArea;
+                            if (deltaArea < minDeltaArea) {
+                                minDeltaArea = deltaArea;
+                                bestRectToMergeIdx = i;
+                            }
+                        }
+                    }
+                    if (full) {
+                        mergedRepaintRects[bestRectToMergeIdx].union(rect);
+                        isMerged = true;
+                    }
+                    if (!isMerged) {
+                        var boundingRect = new BoundingRect(0, 0, 0, 0);
+                        boundingRect.copy(rect);
+                        mergedRepaintRects.push(boundingRect);
+                    }
+                    if (!full) {
+                        full = mergedRepaintRects.length >= maxRepaintRectCount;
+                    }
+                }
+            }
+            for (var i = this.__startIndex; i < this.__endIndex; ++i) {
+                var el = displayList[i];
+                if (el) {
+                    var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+                    var prevRect = el.__isRendered && ((el.__dirty & Element.REDARAW_BIT) || !shouldPaint)
+                        ? el.getPrevPaintRect()
+                        : null;
+                    if (prevRect) {
+                        addRectToMergePool(prevRect);
+                    }
+                    var curRect = shouldPaint && ((el.__dirty & Element.REDARAW_BIT) || !el.__isRendered)
+                        ? el.getPaintRect()
+                        : null;
+                    if (curRect) {
+                        addRectToMergePool(curRect);
+                    }
+                }
+            }
+            for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) {
+                var el = prevList[i];
+                var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+                if (el && (!shouldPaint || !el.__zr) && el.__isRendered) {
+                    var prevRect = el.getPrevPaintRect();
+                    if (prevRect) {
+                        addRectToMergePool(prevRect);
+                    }
+                }
+            }
+            var hasIntersections;
+            do {
+                hasIntersections = false;
+                for (var i = 0; i < mergedRepaintRects.length;) {
+                    if (mergedRepaintRects[i].isZero()) {
+                        mergedRepaintRects.splice(i, 1);
+                        continue;
+                    }
+                    for (var j = i + 1; j < mergedRepaintRects.length;) {
+                        if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) {
+                            hasIntersections = true;
+                            mergedRepaintRects[i].union(mergedRepaintRects[j]);
+                            mergedRepaintRects.splice(j, 1);
+                        }
+                        else {
+                            j++;
+                        }
+                    }
+                    i++;
+                }
+            } while (hasIntersections);
+            this._paintRects = mergedRepaintRects;
+            return mergedRepaintRects;
+        };
+        Layer.prototype.debugGetPaintRects = function () {
+            return (this._paintRects || []).slice();
+        };
+        Layer.prototype.resize = function (width, height) {
+            var dpr = this.dpr;
+            var dom = this.dom;
+            var domStyle = dom.style;
+            var domBack = this.domBack;
+            if (domStyle) {
+                domStyle.width = width + 'px';
+                domStyle.height = height + 'px';
+            }
+            dom.width = width * dpr;
+            dom.height = height * dpr;
+            if (domBack) {
+                domBack.width = width * dpr;
+                domBack.height = height * dpr;
+                if (dpr !== 1) {
+                    this.ctxBack.scale(dpr, dpr);
+                }
+            }
+        };
+        Layer.prototype.clear = function (clearAll, clearColor, repaintRects) {
+            var dom = this.dom;
+            var ctx = this.ctx;
+            var width = dom.width;
+            var height = dom.height;
+            clearColor = clearColor || this.clearColor;
+            var haveMotionBLur = this.motionBlur && !clearAll;
+            var lastFrameAlpha = this.lastFrameAlpha;
+            var dpr = this.dpr;
+            var self = this;
+            if (haveMotionBLur) {
+                if (!this.domBack) {
+                    this.createBackBuffer();
+                }
+                this.ctxBack.globalCompositeOperation = 'copy';
+                this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr);
+            }
+            var domBack = this.domBack;
+            function doClear(x, y, width, height) {
+                ctx.clearRect(x, y, width, height);
+                if (clearColor && clearColor !== 'transparent') {
+                    var clearColorGradientOrPattern = void 0;
+                    if (isGradientObject(clearColor)) {
+                        clearColorGradientOrPattern = clearColor.__canvasGradient
+                            || getCanvasGradient(ctx, clearColor, {
+                                x: 0,
+                                y: 0,
+                                width: width,
+                                height: height
+                            });
+                        clearColor.__canvasGradient = clearColorGradientOrPattern;
+                    }
+                    else if (isPatternObject(clearColor)) {
+                        clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, {
+                            dirty: function () {
+                                self.setUnpainted();
+                                self.__painter.refresh();
+                            }
+                        });
+                    }
+                    ctx.save();
+                    ctx.fillStyle = clearColorGradientOrPattern || clearColor;
+                    ctx.fillRect(x, y, width, height);
+                    ctx.restore();
+                }
+                if (haveMotionBLur) {
+                    ctx.save();
+                    ctx.globalAlpha = lastFrameAlpha;
+                    ctx.drawImage(domBack, x, y, width, height);
+                    ctx.restore();
+                }
+            }
+            if (!repaintRects || haveMotionBLur) {
+                doClear(0, 0, width, height);
+            }
+            else if (repaintRects.length) {
+                each(repaintRects, function (rect) {
+                    doClear(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+                });
+            }
+        };
+        return Layer;
+    }(Eventful));
+
+    var HOVER_LAYER_ZLEVEL = 1e5;
+    var CANVAS_ZLEVEL = 314159;
+    var EL_AFTER_INCREMENTAL_INC = 0.01;
+    var INCREMENTAL_INC = 0.001;
+    function parseInt10$1(val) {
+        return parseInt(val, 10);
+    }
+    function isLayerValid(layer) {
+        if (!layer) {
+            return false;
+        }
+        if (layer.__builtin__) {
+            return true;
+        }
+        if (typeof (layer.resize) !== 'function'
+            || typeof (layer.refresh) !== 'function') {
+            return false;
+        }
+        return true;
+    }
+    function createRoot(width, height) {
+        var domRoot = document.createElement('div');
+        domRoot.style.cssText = [
+            'position:relative',
+            'width:' + width + 'px',
+            'height:' + height + 'px',
+            'padding:0',
+            'margin:0',
+            'border-width:0'
+        ].join(';') + ';';
+        return domRoot;
+    }
+    var CanvasPainter = (function () {
+        function CanvasPainter(root, storage, opts, id) {
+            this.type = 'canvas';
+            this._zlevelList = [];
+            this._prevDisplayList = [];
+            this._layers = {};
+            this._layerConfig = {};
+            this._needsManuallyCompositing = false;
+            this.type = 'canvas';
+            var singleCanvas = !root.nodeName
+                || root.nodeName.toUpperCase() === 'CANVAS';
+            this._opts = opts = extend({}, opts || {});
+            this.dpr = opts.devicePixelRatio || devicePixelRatio;
+            this._singleCanvas = singleCanvas;
+            this.root = root;
+            var rootStyle = root.style;
+            if (rootStyle) {
+                rootStyle.webkitTapHighlightColor = 'transparent';
+                rootStyle.webkitUserSelect = 'none';
+                rootStyle.userSelect = 'none';
+                rootStyle['-webkit-touch-callout'] = 'none';
+                root.innerHTML = '';
+            }
+            this.storage = storage;
+            var zlevelList = this._zlevelList;
+            this._prevDisplayList = [];
+            var layers = this._layers;
+            if (!singleCanvas) {
+                this._width = this._getSize(0);
+                this._height = this._getSize(1);
+                var domRoot = this._domRoot = createRoot(this._width, this._height);
+                root.appendChild(domRoot);
+            }
+            else {
+                var rootCanvas = root;
+                var width = rootCanvas.width;
+                var height = rootCanvas.height;
+                if (opts.width != null) {
+                    width = opts.width;
+                }
+                if (opts.height != null) {
+                    height = opts.height;
+                }
+                this.dpr = opts.devicePixelRatio || 1;
+                rootCanvas.width = width * this.dpr;
+                rootCanvas.height = height * this.dpr;
+                this._width = width;
+                this._height = height;
+                var mainLayer = new Layer(rootCanvas, this, this.dpr);
+                mainLayer.__builtin__ = true;
+                mainLayer.initContext();
+                layers[CANVAS_ZLEVEL] = mainLayer;
+                mainLayer.zlevel = CANVAS_ZLEVEL;
+                zlevelList.push(CANVAS_ZLEVEL);
+                this._domRoot = root;
+            }
+        }
+        CanvasPainter.prototype.getType = function () {
+            return 'canvas';
+        };
+        CanvasPainter.prototype.isSingleCanvas = function () {
+            return this._singleCanvas;
+        };
+        CanvasPainter.prototype.getViewportRoot = function () {
+            return this._domRoot;
+        };
+        CanvasPainter.prototype.getViewportRootOffset = function () {
+            var viewportRoot = this.getViewportRoot();
+            if (viewportRoot) {
+                return {
+                    offsetLeft: viewportRoot.offsetLeft || 0,
+                    offsetTop: viewportRoot.offsetTop || 0
+                };
+            }
+        };
+        CanvasPainter.prototype.refresh = function (paintAll) {
+            var list = this.storage.getDisplayList(true);
+            var prevList = this._prevDisplayList;
+            var zlevelList = this._zlevelList;
+            this._redrawId = Math.random();
+            this._paintList(list, prevList, paintAll, this._redrawId);
+            for (var i = 0; i < zlevelList.length; i++) {
+                var z = zlevelList[i];
+                var layer = this._layers[z];
+                if (!layer.__builtin__ && layer.refresh) {
+                    var clearColor = i === 0 ? this._backgroundColor : null;
+                    layer.refresh(clearColor);
+                }
+            }
+            if (this._opts.useDirtyRect) {
+                this._prevDisplayList = list.slice();
+            }
+            return this;
+        };
+        CanvasPainter.prototype.refreshHover = function () {
+            this._paintHoverList(this.storage.getDisplayList(false));
+        };
+        CanvasPainter.prototype._paintHoverList = function (list) {
+            var len = list.length;
+            var hoverLayer = this._hoverlayer;
+            hoverLayer && hoverLayer.clear();
+            if (!len) {
+                return;
+            }
+            var scope = {
+                inHover: true,
+                viewWidth: this._width,
+                viewHeight: this._height
+            };
+            var ctx;
+            for (var i = 0; i < len; i++) {
+                var el = list[i];
+                if (el.__inHover) {
+                    if (!hoverLayer) {
+                        hoverLayer = this._hoverlayer = this.getLayer(HOVER_LAYER_ZLEVEL);
+                    }
+                    if (!ctx) {
+                        ctx = hoverLayer.ctx;
+                        ctx.save();
+                    }
+                    brush(ctx, el, scope, i === len - 1);
+                }
+            }
+            if (ctx) {
+                ctx.restore();
+            }
+        };
+        CanvasPainter.prototype.getHoverLayer = function () {
+            return this.getLayer(HOVER_LAYER_ZLEVEL);
+        };
+        CanvasPainter.prototype.paintOne = function (ctx, el) {
+            brushSingle(ctx, el);
+        };
+        CanvasPainter.prototype._paintList = function (list, prevList, paintAll, redrawId) {
+            if (this._redrawId !== redrawId) {
+                return;
+            }
+            paintAll = paintAll || false;
+            this._updateLayerStatus(list);
+            var _a = this._doPaintList(list, prevList, paintAll), finished = _a.finished, needsRefreshHover = _a.needsRefreshHover;
+            if (this._needsManuallyCompositing) {
+                this._compositeManually();
+            }
+            if (needsRefreshHover) {
+                this._paintHoverList(list);
+            }
+            if (!finished) {
+                var self_1 = this;
+                requestAnimationFrame$1(function () {
+                    self_1._paintList(list, prevList, paintAll, redrawId);
+                });
+            }
+            else {
+                this.eachLayer(function (layer) {
+                    layer.afterBrush && layer.afterBrush();
+                });
+            }
+        };
+        CanvasPainter.prototype._compositeManually = function () {
+            var ctx = this.getLayer(CANVAS_ZLEVEL).ctx;
+            var width = this._domRoot.width;
+            var height = this._domRoot.height;
+            ctx.clearRect(0, 0, width, height);
+            this.eachBuiltinLayer(function (layer) {
+                if (layer.virtual) {
+                    ctx.drawImage(layer.dom, 0, 0, width, height);
+                }
+            });
+        };
+        CanvasPainter.prototype._doPaintList = function (list, prevList, paintAll) {
+            var _this = this;
+            var layerList = [];
+            var useDirtyRect = this._opts.useDirtyRect;
+            for (var zi = 0; zi < this._zlevelList.length; zi++) {
+                var zlevel = this._zlevelList[zi];
+                var layer = this._layers[zlevel];
+                if (layer.__builtin__
+                    && layer !== this._hoverlayer
+                    && (layer.__dirty || paintAll)) {
+                    layerList.push(layer);
+                }
+            }
+            var finished = true;
+            var needsRefreshHover = false;
+            var _loop_1 = function (k) {
+                var layer = layerList[k];
+                var ctx = layer.ctx;
+                var repaintRects = useDirtyRect
+                    && layer.createRepaintRects(list, prevList, this_1._width, this_1._height);
+                ctx.save();
+                var start = paintAll ? layer.__startIndex : layer.__drawIndex;
+                var useTimer = !paintAll && layer.incremental && Date.now;
+                var startTime = useTimer && Date.now();
+                var clearColor = layer.zlevel === this_1._zlevelList[0]
+                    ? this_1._backgroundColor : null;
+                if (layer.__startIndex === layer.__endIndex) {
+                    layer.clear(false, clearColor, repaintRects);
+                }
+                else if (start === layer.__startIndex) {
+                    var firstEl = list[start];
+                    if (!firstEl.incremental || !firstEl.notClear || paintAll) {
+                        layer.clear(false, clearColor, repaintRects);
+                    }
+                }
+                if (start === -1) {
+                    console.error('For some unknown reason. drawIndex is -1');
+                    start = layer.__startIndex;
+                }
+                var i;
+                var repaint = function (repaintRect) {
+                    var scope = {
+                        inHover: false,
+                        allClipped: false,
+                        prevEl: null,
+                        viewWidth: _this._width,
+                        viewHeight: _this._height
+                    };
+                    for (i = start; i < layer.__endIndex; i++) {
+                        var el = list[i];
+                        if (el.__inHover) {
+                            needsRefreshHover = true;
+                        }
+                        _this._doPaintEl(el, layer, useDirtyRect, repaintRect, scope, i === layer.__endIndex - 1);
+                        if (useTimer) {
+                            var dTime = Date.now() - startTime;
+                            if (dTime > 15) {
+                                break;
+                            }
+                        }
+                    }
+                    if (scope.prevElClipPaths) {
+                        ctx.restore();
+                    }
+                };
+                if (repaintRects) {
+                    if (repaintRects.length === 0) {
+                        i = layer.__endIndex;
+                    }
+                    else {
+                        var dpr = this_1.dpr;
+                        for (var r = 0; r < repaintRects.length; ++r) {
+                            var rect = repaintRects[r];
+                            ctx.save();
+                            ctx.beginPath();
+                            ctx.rect(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+                            ctx.clip();
+                            repaint(rect);
+                            ctx.restore();
+                        }
+                    }
+                }
+                else {
+                    ctx.save();
+                    repaint();
+                    ctx.restore();
+                }
+                layer.__drawIndex = i;
+                if (layer.__drawIndex < layer.__endIndex) {
+                    finished = false;
+                }
+            };
+            var this_1 = this;
+            for (var k = 0; k < layerList.length; k++) {
+                _loop_1(k);
+            }
+            if (env.wxa) {
+                each(this._layers, function (layer) {
+                    if (layer && layer.ctx && layer.ctx.draw) {
+                        layer.ctx.draw();
+                    }
+                });
+            }
+            return {
+                finished: finished,
+                needsRefreshHover: needsRefreshHover
+            };
+        };
+        CanvasPainter.prototype._doPaintEl = function (el, currentLayer, useDirtyRect, repaintRect, scope, isLast) {
+            var ctx = currentLayer.ctx;
+            if (useDirtyRect) {
+                var paintRect = el.getPaintRect();
+                if (!repaintRect || paintRect && paintRect.intersect(repaintRect)) {
+                    brush(ctx, el, scope, isLast);
+                    el.setPrevPaintRect(paintRect);
+                }
+            }
+            else {
+                brush(ctx, el, scope, isLast);
+            }
+        };
+        CanvasPainter.prototype.getLayer = function (zlevel, virtual) {
+            if (this._singleCanvas && !this._needsManuallyCompositing) {
+                zlevel = CANVAS_ZLEVEL;
+            }
+            var layer = this._layers[zlevel];
+            if (!layer) {
+                layer = new Layer('zr_' + zlevel, this, this.dpr);
+                layer.zlevel = zlevel;
+                layer.__builtin__ = true;
+                if (this._layerConfig[zlevel]) {
+                    merge(layer, this._layerConfig[zlevel], true);
+                }
+                else if (this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC]) {
+                    merge(layer, this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC], true);
+                }
+                if (virtual) {
+                    layer.virtual = virtual;
+                }
+                this.insertLayer(zlevel, layer);
+                layer.initContext();
+            }
+            return layer;
+        };
+        CanvasPainter.prototype.insertLayer = function (zlevel, layer) {
+            var layersMap = this._layers;
+            var zlevelList = this._zlevelList;
+            var len = zlevelList.length;
+            var domRoot = this._domRoot;
+            var prevLayer = null;
+            var i = -1;
+            if (layersMap[zlevel]) {
+                logError('ZLevel ' + zlevel + ' has been used already');
+                return;
+            }
+            if (!isLayerValid(layer)) {
+                logError('Layer of zlevel ' + zlevel + ' is not valid');
+                return;
+            }
+            if (len > 0 && zlevel > zlevelList[0]) {
+                for (i = 0; i < len - 1; i++) {
+                    if (zlevelList[i] < zlevel
+                        && zlevelList[i + 1] > zlevel) {
+                        break;
+                    }
+                }
+                prevLayer = layersMap[zlevelList[i]];
+            }
+            zlevelList.splice(i + 1, 0, zlevel);
+            layersMap[zlevel] = layer;
+            if (!layer.virtual) {
+                if (prevLayer) {
+                    var prevDom = prevLayer.dom;
+                    if (prevDom.nextSibling) {
+                        domRoot.insertBefore(layer.dom, prevDom.nextSibling);
+                    }
+                    else {
+                        domRoot.appendChild(layer.dom);
+                    }
+                }
+                else {
+                    if (domRoot.firstChild) {
+                        domRoot.insertBefore(layer.dom, domRoot.firstChild);
+                    }
+                    else {
+                        domRoot.appendChild(layer.dom);
+                    }
+                }
+            }
+            layer.__painter = this;
+        };
+        CanvasPainter.prototype.eachLayer = function (cb, context) {
+            var zlevelList = this._zlevelList;
+            for (var i = 0; i < zlevelList.length; i++) {
+                var z = zlevelList[i];
+                cb.call(context, this._layers[z], z);
+            }
+        };
+        CanvasPainter.prototype.eachBuiltinLayer = function (cb, context) {
+            var zlevelList = this._zlevelList;
+            for (var i = 0; i < zlevelList.length; i++) {
+                var z = zlevelList[i];
+                var layer = this._layers[z];
+                if (layer.__builtin__) {
+                    cb.call(context, layer, z);
+                }
+            }
+        };
+        CanvasPainter.prototype.eachOtherLayer = function (cb, context) {
+            var zlevelList = this._zlevelList;
+            for (var i = 0; i < zlevelList.length; i++) {
+                var z = zlevelList[i];
+                var layer = this._layers[z];
+                if (!layer.__builtin__) {
+                    cb.call(context, layer, z);
+                }
+            }
+        };
+        CanvasPainter.prototype.getLayers = function () {
+            return this._layers;
+        };
+        CanvasPainter.prototype._updateLayerStatus = function (list) {
+            this.eachBuiltinLayer(function (layer, z) {
+                layer.__dirty = layer.__used = false;
+            });
+            function updatePrevLayer(idx) {
+                if (prevLayer) {
+                    if (prevLayer.__endIndex !== idx) {
+                        prevLayer.__dirty = true;
+                    }
+                    prevLayer.__endIndex = idx;
+                }
+            }
+            if (this._singleCanvas) {
+                for (var i_1 = 1; i_1 < list.length; i_1++) {
+                    var el = list[i_1];
+                    if (el.zlevel !== list[i_1 - 1].zlevel || el.incremental) {
+                        this._needsManuallyCompositing = true;
+                        break;
+                    }
+                }
+            }
+            var prevLayer = null;
+            var incrementalLayerCount = 0;
+            var prevZlevel;
+            var i;
+            for (i = 0; i < list.length; i++) {
+                var el = list[i];
+                var zlevel = el.zlevel;
+                var layer = void 0;
+                if (prevZlevel !== zlevel) {
+                    prevZlevel = zlevel;
+                    incrementalLayerCount = 0;
+                }
+                if (el.incremental) {
+                    layer = this.getLayer(zlevel + INCREMENTAL_INC, this._needsManuallyCompositing);
+                    layer.incremental = true;
+                    incrementalLayerCount = 1;
+                }
+                else {
+                    layer = this.getLayer(zlevel + (incrementalLayerCount > 0 ? EL_AFTER_INCREMENTAL_INC : 0), this._needsManuallyCompositing);
+                }
+                if (!layer.__builtin__) {
+                    logError('ZLevel ' + zlevel + ' has been used by unkown layer ' + layer.id);
+                }
+                if (layer !== prevLayer) {
+                    layer.__used = true;
+                    if (layer.__startIndex !== i) {
+                        layer.__dirty = true;
+                    }
+                    layer.__startIndex = i;
+                    if (!layer.incremental) {
+                        layer.__drawIndex = i;
+                    }
+                    else {
+                        layer.__drawIndex = -1;
+                    }
+                    updatePrevLayer(i);
+                    prevLayer = layer;
+                }
+                if ((el.__dirty & Element.REDARAW_BIT) && !el.__inHover) {
+                    layer.__dirty = true;
+                    if (layer.incremental && layer.__drawIndex < 0) {
+                        layer.__drawIndex = i;
+                    }
+                }
+            }
+            updatePrevLayer(i);
+            this.eachBuiltinLayer(function (layer, z) {
+                if (!layer.__used && layer.getElementCount() > 0) {
+                    layer.__dirty = true;
+                    layer.__startIndex = layer.__endIndex = layer.__drawIndex = 0;
+                }
+                if (layer.__dirty && layer.__drawIndex < 0) {
+                    layer.__drawIndex = layer.__startIndex;
+                }
+            });
+        };
+        CanvasPainter.prototype.clear = function () {
+            this.eachBuiltinLayer(this._clearLayer);
+            return this;
+        };
+        CanvasPainter.prototype._clearLayer = function (layer) {
+            layer.clear();
+        };
+        CanvasPainter.prototype.setBackgroundColor = function (backgroundColor) {
+            this._backgroundColor = backgroundColor;
+            each(this._layers, function (layer) {
+                layer.setUnpainted();
+            });
+        };
+        CanvasPainter.prototype.configLayer = function (zlevel, config) {
+            if (config) {
+                var layerConfig = this._layerConfig;
+                if (!layerConfig[zlevel]) {
+                    layerConfig[zlevel] = config;
+                }
+                else {
+                    merge(layerConfig[zlevel], config, true);
+                }
+                for (var i = 0; i < this._zlevelList.length; i++) {
+                    var _zlevel = this._zlevelList[i];
+                    if (_zlevel === zlevel || _zlevel === zlevel + EL_AFTER_INCREMENTAL_INC) {
+                        var layer = this._layers[_zlevel];
+                        merge(layer, layerConfig[zlevel], true);
+                    }
+                }
+            }
+        };
+        CanvasPainter.prototype.delLayer = function (zlevel) {
+            var layers = this._layers;
+            var zlevelList = this._zlevelList;
+            var layer = layers[zlevel];
+            if (!layer) {
+                return;
+            }
+            layer.dom.parentNode.removeChild(layer.dom);
+            delete layers[zlevel];
+            zlevelList.splice(indexOf(zlevelList, zlevel), 1);
+        };
+        CanvasPainter.prototype.resize = function (width, height) {
+            if (!this._domRoot.style) {
+                if (width == null || height == null) {
+                    return;
+                }
+                this._width = width;
+                this._height = height;
+                this.getLayer(CANVAS_ZLEVEL).resize(width, height);
+            }
+            else {
+                var domRoot = this._domRoot;
+                domRoot.style.display = 'none';
+                var opts = this._opts;
+                width != null && (opts.width = width);
+                height != null && (opts.height = height);
+                width = this._getSize(0);
+                height = this._getSize(1);
+                domRoot.style.display = '';
+                if (this._width !== width || height !== this._height) {
+                    domRoot.style.width = width + 'px';
+                    domRoot.style.height = height + 'px';
+                    for (var id in this._layers) {
+                        if (this._layers.hasOwnProperty(id)) {
+                            this._layers[id].resize(width, height);
+                        }
+                    }
+                    this.refresh(true);
+                }
+                this._width = width;
+                this._height = height;
+            }
+            return this;
+        };
+        CanvasPainter.prototype.clearLayer = function (zlevel) {
+            var layer = this._layers[zlevel];
+            if (layer) {
+                layer.clear();
+            }
+        };
+        CanvasPainter.prototype.dispose = function () {
+            this.root.innerHTML = '';
+            this.root =
+                this.storage =
+                    this._domRoot =
+                        this._layers = null;
+        };
+        CanvasPainter.prototype.getRenderedCanvas = function (opts) {
+            opts = opts || {};
+            if (this._singleCanvas && !this._compositeManually) {
+                return this._layers[CANVAS_ZLEVEL].dom;
+            }
+            var imageLayer = new Layer('image', this, opts.pixelRatio || this.dpr);
+            imageLayer.initContext();
+            imageLayer.clear(false, opts.backgroundColor || this._backgroundColor);
+            var ctx = imageLayer.ctx;
+            if (opts.pixelRatio <= this.dpr) {
+                this.refresh();
+                var width_1 = imageLayer.dom.width;
+                var height_1 = imageLayer.dom.height;
+                this.eachLayer(function (layer) {
+                    if (layer.__builtin__) {
+                        ctx.drawImage(layer.dom, 0, 0, width_1, height_1);
+                    }
+                    else if (layer.renderToCanvas) {
+                        ctx.save();
+                        layer.renderToCanvas(ctx);
+                        ctx.restore();
+                    }
+                });
+            }
+            else {
+                var scope = {
+                    inHover: false,
+                    viewWidth: this._width,
+                    viewHeight: this._height
+                };
+                var displayList = this.storage.getDisplayList(true);
+                for (var i = 0, len = displayList.length; i < len; i++) {
+                    var el = displayList[i];
+                    brush(ctx, el, scope, i === len - 1);
+                }
+            }
+            return imageLayer.dom;
+        };
+        CanvasPainter.prototype.getWidth = function () {
+            return this._width;
+        };
+        CanvasPainter.prototype.getHeight = function () {
+            return this._height;
+        };
+        CanvasPainter.prototype._getSize = function (whIdx) {
+            var opts = this._opts;
+            var wh = ['width', 'height'][whIdx];
+            var cwh = ['clientWidth', 'clientHeight'][whIdx];
+            var plt = ['paddingLeft', 'paddingTop'][whIdx];
+            var prb = ['paddingRight', 'paddingBottom'][whIdx];
+            if (opts[wh] != null && opts[wh] !== 'auto') {
+                return parseFloat(opts[wh]);
+            }
+            var root = this.root;
+            var stl = document.defaultView.getComputedStyle(root);
+            return ((root[cwh] || parseInt10$1(stl[wh]) || parseInt10$1(root.style[wh]))
+                - (parseInt10$1(stl[plt]) || 0)
+                - (parseInt10$1(stl[prb]) || 0)) | 0;
+        };
+        CanvasPainter.prototype.pathToImage = function (path, dpr) {
+            dpr = dpr || this.dpr;
+            var canvas = document.createElement('canvas');
+            var ctx = canvas.getContext('2d');
+            var rect = path.getBoundingRect();
+            var style = path.style;
+            var shadowBlurSize = style.shadowBlur * dpr;
+            var shadowOffsetX = style.shadowOffsetX * dpr;
+            var shadowOffsetY = style.shadowOffsetY * dpr;
+            var lineWidth = path.hasStroke() ? style.lineWidth : 0;
+            var leftMargin = Math.max(lineWidth / 2, -shadowOffsetX + shadowBlurSize);
+            var rightMargin = Math.max(lineWidth / 2, shadowOffsetX + shadowBlurSize);
+            var topMargin = Math.max(lineWidth / 2, -shadowOffsetY + shadowBlurSize);
+            var bottomMargin = Math.max(lineWidth / 2, shadowOffsetY + shadowBlurSize);
+            var width = rect.width + leftMargin + rightMargin;
+            var height = rect.height + topMargin + bottomMargin;
+            canvas.width = width * dpr;
+            canvas.height = height * dpr;
+            ctx.scale(dpr, dpr);
+            ctx.clearRect(0, 0, width, height);
+            ctx.dpr = dpr;
+            var pathTransform = {
+                x: path.x,
+                y: path.y,
+                scaleX: path.scaleX,
+                scaleY: path.scaleY,
+                rotation: path.rotation,
+                originX: path.originX,
+                originY: path.originY
+            };
+            path.x = leftMargin - rect.x;
+            path.y = topMargin - rect.y;
+            path.rotation = 0;
+            path.scaleX = 1;
+            path.scaleY = 1;
+            path.updateTransform();
+            if (path) {
+                brush(ctx, path, {
+                    inHover: false,
+                    viewWidth: this._width,
+                    viewHeight: this._height
+                }, true);
+            }
+            var imgShape = new ZRImage({
+                style: {
+                    x: 0,
+                    y: 0,
+                    image: canvas
+                }
+            });
+            extend(path, pathTransform);
+            return imgShape;
+        };
+        return CanvasPainter;
+    }());
+
+    function install$1(registers) {
+      registers.registerPainter('canvas', CanvasPainter);
+    }
+
+    var LineSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(LineSeriesModel, _super);
+
+      function LineSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = LineSeriesModel.type;
+        _this.hasSymbolVisual = true;
+        _this.legendSymbol = 'line';
+        return _this;
+      }
+
+      LineSeriesModel.prototype.getInitialData = function (option) {
+        if ("development" !== 'production') {
+          var coordSys = option.coordinateSystem;
+
+          if (coordSys !== 'polar' && coordSys !== 'cartesian2d') {
+            throw new Error('Line not support coordinateSystem besides cartesian and polar');
+          }
+        }
+
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: true
+        });
+      };
+
+      LineSeriesModel.type = 'series.line';
+      LineSeriesModel.dependencies = ['grid', 'polar'];
+      LineSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 3,
+        coordinateSystem: 'cartesian2d',
+        legendHoverLink: true,
+        clip: true,
+        label: {
+          position: 'top'
+        },
+        endLabel: {
+          show: false,
+          valueAnimation: true,
+          distance: 8
+        },
+        lineStyle: {
+          width: 2,
+          type: 'solid'
+        },
+        emphasis: {
+          scale: true,
+          lineStyle: {
+            width: 'bolder'
+          }
+        },
+        // areaStyle: {
+        // origin of areaStyle. Valid values:
+        // `'auto'/null/undefined`: from axisLine to data
+        // `'start'`: from min to data
+        // `'end'`: from data to max
+        // origin: 'auto'
+        // },
+        // false, 'start', 'end', 'middle'
+        step: false,
+        // Disabled if step is true
+        smooth: false,
+        smoothMonotone: null,
+        symbol: 'emptyCircle',
+        symbolSize: 4,
+        symbolRotate: null,
+        showSymbol: true,
+        // `false`: follow the label interval strategy.
+        // `true`: show all symbols.
+        // `'auto'`: If possible, show all symbols, otherwise
+        //           follow the label interval strategy.
+        showAllSymbol: 'auto',
+        // Whether to connect break point.
+        connectNulls: false,
+        // Sampling for large data. Can be: 'average', 'max', 'min', 'sum', 'lttb'.
+        sampling: 'none',
+        animationEasing: 'linear',
+        // Disable progressive
+        progressive: 0,
+        hoverLayerThreshold: Infinity
+      };
+      return LineSeriesModel;
+    }(SeriesModel);
+
+    /**
+     * @return label string. Not null/undefined
+     */
+
+    function getDefaultLabel(data, dataIndex) {
+      var labelDims = data.mapDimensionsAll('defaultedLabel');
+      var len = labelDims.length; // Simple optimization (in lots of cases, label dims length is 1)
+
+      if (len === 1) {
+        var rawVal = retrieveRawValue(data, dataIndex, labelDims[0]);
+        return rawVal != null ? rawVal + '' : null;
+      } else if (len) {
+        var vals = [];
+
+        for (var i = 0; i < labelDims.length; i++) {
+          vals.push(retrieveRawValue(data, dataIndex, labelDims[i]));
+        }
+
+        return vals.join(' ');
+      }
+    }
+    function getDefaultInterpolatedLabel(data, interpolatedValue) {
+      var labelDims = data.mapDimensionsAll('defaultedLabel');
+
+      if (!isArray(interpolatedValue)) {
+        return interpolatedValue + '';
+      }
+
+      var vals = [];
+
+      for (var i = 0; i < labelDims.length; i++) {
+        var dimInfo = data.getDimensionInfo(labelDims[i]);
+
+        if (dimInfo) {
+          vals.push(interpolatedValue[dimInfo.index]);
+        }
+      }
+
+      return vals.join(' ');
+    }
+
+    var Symbol =
+    /** @class */
+    function (_super) {
+      __extends(Symbol, _super);
+
+      function Symbol(data, idx, seriesScope, opts) {
+        var _this = _super.call(this) || this;
+
+        _this.updateData(data, idx, seriesScope, opts);
+
+        return _this;
+      }
+
+      Symbol.prototype._createSymbol = function (symbolType, data, idx, symbolSize, keepAspect) {
+        // Remove paths created before
+        this.removeAll(); // let symbolPath = createSymbol(
+        //     symbolType, -0.5, -0.5, 1, 1, color
+        // );
+        // If width/height are set too small (e.g., set to 1) on ios10
+        // and macOS Sierra, a circle stroke become a rect, no matter what
+        // the scale is set. So we set width/height as 2. See #4150.
+
+        var symbolPath = createSymbol(symbolType, -1, -1, 2, 2, null, keepAspect);
+        symbolPath.attr({
+          z2: 100,
+          culling: true,
+          scaleX: symbolSize[0] / 2,
+          scaleY: symbolSize[1] / 2
+        }); // Rewrite drift method
+
+        symbolPath.drift = driftSymbol;
+        this._symbolType = symbolType;
+        this.add(symbolPath);
+      };
+      /**
+       * Stop animation
+       * @param {boolean} toLastFrame
+       */
+
+
+      Symbol.prototype.stopSymbolAnimation = function (toLastFrame) {
+        this.childAt(0).stopAnimation(null, toLastFrame);
+      };
+      /**
+       * FIXME:
+       * Caution: This method breaks the encapsulation of this module,
+       * but it indeed brings convenience. So do not use the method
+       * unless you detailedly know all the implements of `Symbol`,
+       * especially animation.
+       *
+       * Get symbol path element.
+       */
+
+
+      Symbol.prototype.getSymbolPath = function () {
+        return this.childAt(0);
+      };
+      /**
+       * Highlight symbol
+       */
+
+
+      Symbol.prototype.highlight = function () {
+        enterEmphasis(this.childAt(0));
+      };
+      /**
+       * Downplay symbol
+       */
+
+
+      Symbol.prototype.downplay = function () {
+        leaveEmphasis(this.childAt(0));
+      };
+      /**
+       * @param {number} zlevel
+       * @param {number} z
+       */
+
+
+      Symbol.prototype.setZ = function (zlevel, z) {
+        var symbolPath = this.childAt(0);
+        symbolPath.zlevel = zlevel;
+        symbolPath.z = z;
+      };
+
+      Symbol.prototype.setDraggable = function (draggable) {
+        var symbolPath = this.childAt(0);
+        symbolPath.draggable = draggable;
+        symbolPath.cursor = draggable ? 'move' : symbolPath.cursor;
+      };
+      /**
+       * Update symbol properties
+       */
+
+
+      Symbol.prototype.updateData = function (data, idx, seriesScope, opts) {
+        this.silent = false;
+        var symbolType = data.getItemVisual(idx, 'symbol') || 'circle';
+        var seriesModel = data.hostModel;
+        var symbolSize = Symbol.getSymbolSize(data, idx);
+        var isInit = symbolType !== this._symbolType;
+        var disableAnimation = opts && opts.disableAnimation;
+
+        if (isInit) {
+          var keepAspect = data.getItemVisual(idx, 'symbolKeepAspect');
+
+          this._createSymbol(symbolType, data, idx, symbolSize, keepAspect);
+        } else {
+          var symbolPath = this.childAt(0);
+          symbolPath.silent = false;
+          var target = {
+            scaleX: symbolSize[0] / 2,
+            scaleY: symbolSize[1] / 2
+          };
+          disableAnimation ? symbolPath.attr(target) : updateProps(symbolPath, target, seriesModel, idx);
+        }
+
+        this._updateCommon(data, idx, symbolSize, seriesScope, opts);
+
+        if (isInit) {
+          var symbolPath = this.childAt(0);
+
+          if (!disableAnimation) {
+            var target = {
+              scaleX: this._sizeX,
+              scaleY: this._sizeY,
+              style: {
+                // Always fadeIn. Because it has fadeOut animation when symbol is removed..
+                opacity: symbolPath.style.opacity
+              }
+            };
+            symbolPath.scaleX = symbolPath.scaleY = 0;
+            symbolPath.style.opacity = 0;
+            initProps(symbolPath, target, seriesModel, idx);
+          }
+        }
+
+        if (disableAnimation) {
+          // Must stop remove animation manually if don't call initProps or updateProps.
+          this.childAt(0).stopAnimation('remove');
+        }
+
+        this._seriesModel = seriesModel;
+      };
+
+      Symbol.prototype._updateCommon = function (data, idx, symbolSize, seriesScope, opts) {
+        var symbolPath = this.childAt(0);
+        var seriesModel = data.hostModel;
+        var emphasisItemStyle;
+        var blurItemStyle;
+        var selectItemStyle;
+        var focus;
+        var blurScope;
+        var symbolOffset;
+        var labelStatesModels;
+        var hoverScale;
+        var cursorStyle;
+
+        if (seriesScope) {
+          emphasisItemStyle = seriesScope.emphasisItemStyle;
+          blurItemStyle = seriesScope.blurItemStyle;
+          selectItemStyle = seriesScope.selectItemStyle;
+          focus = seriesScope.focus;
+          blurScope = seriesScope.blurScope;
+          symbolOffset = seriesScope.symbolOffset;
+          labelStatesModels = seriesScope.labelStatesModels;
+          hoverScale = seriesScope.hoverScale;
+          cursorStyle = seriesScope.cursorStyle;
+        }
+
+        if (!seriesScope || data.hasItemOption) {
+          var itemModel = seriesScope && seriesScope.itemModel ? seriesScope.itemModel : data.getItemModel(idx);
+          var emphasisModel = itemModel.getModel('emphasis');
+          emphasisItemStyle = emphasisModel.getModel('itemStyle').getItemStyle();
+          selectItemStyle = itemModel.getModel(['select', 'itemStyle']).getItemStyle();
+          blurItemStyle = itemModel.getModel(['blur', 'itemStyle']).getItemStyle();
+          focus = emphasisModel.get('focus');
+          blurScope = emphasisModel.get('blurScope');
+          symbolOffset = itemModel.getShallow('symbolOffset');
+          labelStatesModels = getLabelStatesModels(itemModel);
+          hoverScale = emphasisModel.getShallow('scale');
+          cursorStyle = itemModel.getShallow('cursor');
+        }
+
+        var symbolRotate = data.getItemVisual(idx, 'symbolRotate');
+        symbolPath.attr('rotation', (symbolRotate || 0) * Math.PI / 180 || 0);
+
+        if (symbolOffset) {
+          symbolPath.x = parsePercent$1(symbolOffset[0], symbolSize[0]);
+          symbolPath.y = parsePercent$1(symbolOffset[1], symbolSize[1]);
+        }
+
+        cursorStyle && symbolPath.attr('cursor', cursorStyle);
+        var symbolStyle = data.getItemVisual(idx, 'style');
+        var visualColor = symbolStyle.fill;
+
+        if (symbolPath instanceof ZRImage) {
+          var pathStyle = symbolPath.style;
+          symbolPath.useStyle(extend({
+            // TODO other properties like x, y ?
+            image: pathStyle.image,
+            x: pathStyle.x,
+            y: pathStyle.y,
+            width: pathStyle.width,
+            height: pathStyle.height
+          }, symbolStyle));
+        } else {
+          if (symbolPath.__isEmptyBrush) {
+            // fill and stroke will be swapped if it's empty.
+            // So we cloned a new style to avoid it affecting the original style in visual storage.
+            // TODO Better implementation. No empty logic!
+            symbolPath.useStyle(extend({}, symbolStyle));
+          } else {
+            symbolPath.useStyle(symbolStyle);
+          } // Disable decal because symbol scale will been applied on the decal.
+
+
+          symbolPath.style.decal = null;
+          symbolPath.setColor(visualColor, opts && opts.symbolInnerColor);
+          symbolPath.style.strokeNoScale = true;
+        }
+
+        var liftZ = data.getItemVisual(idx, 'liftZ');
+        var z2Origin = this._z2;
+
+        if (liftZ != null) {
+          if (z2Origin == null) {
+            this._z2 = symbolPath.z2;
+            symbolPath.z2 += liftZ;
+          }
+        } else if (z2Origin != null) {
+          symbolPath.z2 = z2Origin;
+          this._z2 = null;
+        }
+
+        var useNameLabel = opts && opts.useNameLabel;
+        setLabelStyle(symbolPath, labelStatesModels, {
+          labelFetcher: seriesModel,
+          labelDataIndex: idx,
+          defaultText: getLabelDefaultText,
+          inheritColor: visualColor,
+          defaultOpacity: symbolStyle.opacity
+        }); // Do not execute util needed.
+
+        function getLabelDefaultText(idx) {
+          return useNameLabel ? data.getName(idx) : getDefaultLabel(data, idx);
+        }
+
+        this._sizeX = symbolSize[0] / 2;
+        this._sizeY = symbolSize[1] / 2;
+        var emphasisState = symbolPath.ensureState('emphasis');
+        emphasisState.style = emphasisItemStyle;
+        symbolPath.ensureState('select').style = selectItemStyle;
+        symbolPath.ensureState('blur').style = blurItemStyle;
+
+        if (hoverScale) {
+          var scaleRatio = Math.max(1.1, 3 / this._sizeY);
+          emphasisState.scaleX = this._sizeX * scaleRatio;
+          emphasisState.scaleY = this._sizeY * scaleRatio;
+        }
+
+        this.setSymbolScale(1);
+        enableHoverEmphasis(this, focus, blurScope);
+      };
+
+      Symbol.prototype.setSymbolScale = function (scale) {
+        this.scaleX = this.scaleY = scale;
+      };
+
+      Symbol.prototype.fadeOut = function (cb, opt) {
+        var symbolPath = this.childAt(0);
+        var seriesModel = this._seriesModel;
+        var dataIndex = getECData(this).dataIndex;
+        var animationOpt = opt && opt.animation; // Avoid mistaken hover when fading out
+
+        this.silent = symbolPath.silent = true; // Not show text when animating
+
+        if (opt && opt.fadeLabel) {
+          var textContent = symbolPath.getTextContent();
+
+          if (textContent) {
+            removeElement(textContent, {
+              style: {
+                opacity: 0
+              }
+            }, seriesModel, {
+              dataIndex: dataIndex,
+              removeOpt: animationOpt,
+              cb: function () {
+                symbolPath.removeTextContent();
+              }
+            });
+          }
+        } else {
+          symbolPath.removeTextContent();
+        }
+
+        removeElement(symbolPath, {
+          style: {
+            opacity: 0
+          },
+          scaleX: 0,
+          scaleY: 0
+        }, seriesModel, {
+          dataIndex: dataIndex,
+          cb: cb,
+          removeOpt: animationOpt
+        });
+      };
+
+      Symbol.getSymbolSize = function (data, idx) {
+        var symbolSize = data.getItemVisual(idx, 'symbolSize');
+        return symbolSize instanceof Array ? symbolSize.slice() : [+symbolSize, +symbolSize];
+      };
+
+      return Symbol;
+    }(Group);
+
+    function driftSymbol(dx, dy) {
+      this.parent.drift(dx, dy);
+    }
+
+    function symbolNeedsDraw(data, point, idx, opt) {
+      return point && !isNaN(point[0]) && !isNaN(point[1]) && !(opt.isIgnore && opt.isIgnore(idx)) // We do not set clipShape on group, because it will cut part of
+      // the symbol element shape. We use the same clip shape here as
+      // the line clip.
+      && !(opt.clipShape && !opt.clipShape.contain(point[0], point[1])) && data.getItemVisual(idx, 'symbol') !== 'none';
+    }
+
+    function normalizeUpdateOpt(opt) {
+      if (opt != null && !isObject(opt)) {
+        opt = {
+          isIgnore: opt
+        };
+      }
+
+      return opt || {};
+    }
+
+    function makeSeriesScope(data) {
+      var seriesModel = data.hostModel;
+      var emphasisModel = seriesModel.getModel('emphasis');
+      return {
+        emphasisItemStyle: emphasisModel.getModel('itemStyle').getItemStyle(),
+        blurItemStyle: seriesModel.getModel(['blur', 'itemStyle']).getItemStyle(),
+        selectItemStyle: seriesModel.getModel(['select', 'itemStyle']).getItemStyle(),
+        focus: emphasisModel.get('focus'),
+        blurScope: emphasisModel.get('blurScope'),
+        symbolRotate: seriesModel.get('symbolRotate'),
+        symbolOffset: seriesModel.get('symbolOffset'),
+        hoverScale: emphasisModel.get('scale'),
+        labelStatesModels: getLabelStatesModels(seriesModel),
+        cursorStyle: seriesModel.get('cursor')
+      };
+    }
+
+    var SymbolDraw =
+    /** @class */
+    function () {
+      function SymbolDraw(SymbolCtor) {
+        this.group = new Group();
+        this._SymbolCtor = SymbolCtor || Symbol;
+      }
+      /**
+       * Update symbols draw by new data
+       */
+
+
+      SymbolDraw.prototype.updateData = function (data, opt) {
+        opt = normalizeUpdateOpt(opt);
+        var group = this.group;
+        var seriesModel = data.hostModel;
+        var oldData = this._data;
+        var SymbolCtor = this._SymbolCtor;
+        var disableAnimation = opt.disableAnimation;
+        var seriesScope = makeSeriesScope(data);
+        var symbolUpdateOpt = {
+          disableAnimation: disableAnimation
+        };
+
+        var getSymbolPoint = opt.getSymbolPoint || function (idx) {
+          return data.getItemLayout(idx);
+        }; // There is no oldLineData only when first rendering or switching from
+        // stream mode to normal mode, where previous elements should be removed.
+
+
+        if (!oldData) {
+          group.removeAll();
+        }
+
+        data.diff(oldData).add(function (newIdx) {
+          var point = getSymbolPoint(newIdx);
+
+          if (symbolNeedsDraw(data, point, newIdx, opt)) {
+            var symbolEl = new SymbolCtor(data, newIdx, seriesScope, symbolUpdateOpt);
+            symbolEl.setPosition(point);
+            data.setItemGraphicEl(newIdx, symbolEl);
+            group.add(symbolEl);
+          }
+        }).update(function (newIdx, oldIdx) {
+          var symbolEl = oldData.getItemGraphicEl(oldIdx);
+          var point = getSymbolPoint(newIdx);
+
+          if (!symbolNeedsDraw(data, point, newIdx, opt)) {
+            group.remove(symbolEl);
+            return;
+          }
+
+          if (!symbolEl) {
+            symbolEl = new SymbolCtor(data, newIdx);
+            symbolEl.setPosition(point);
+          } else {
+            symbolEl.updateData(data, newIdx, seriesScope, symbolUpdateOpt);
+            var target = {
+              x: point[0],
+              y: point[1]
+            };
+            disableAnimation ? symbolEl.attr(target) : updateProps(symbolEl, target, seriesModel);
+          } // Add back
+
+
+          group.add(symbolEl);
+          data.setItemGraphicEl(newIdx, symbolEl);
+        }).remove(function (oldIdx) {
+          var el = oldData.getItemGraphicEl(oldIdx);
+          el && el.fadeOut(function () {
+            group.remove(el);
+          });
+        }).execute();
+        this._getSymbolPoint = getSymbolPoint;
+        this._data = data;
+      };
+
+      SymbolDraw.prototype.isPersistent = function () {
+        return true;
+      };
+
+      SymbolDraw.prototype.updateLayout = function () {
+        var _this = this;
+
+        var data = this._data;
+
+        if (data) {
+          // Not use animation
+          data.eachItemGraphicEl(function (el, idx) {
+            var point = _this._getSymbolPoint(idx);
+
+            el.setPosition(point);
+            el.markRedraw();
+          });
+        }
+      };
+
+      SymbolDraw.prototype.incrementalPrepareUpdate = function (data) {
+        this._seriesScope = makeSeriesScope(data);
+        this._data = null;
+        this.group.removeAll();
+      };
+      /**
+       * Update symbols draw by new data
+       */
+
+      SymbolDraw.prototype.incrementalUpdate = function (taskParams, data, opt) {
+        opt = normalizeUpdateOpt(opt);
+
+        function updateIncrementalAndHover(el) {
+          if (!el.isGroup) {
+            el.incremental = true;
+            el.ensureState('emphasis').hoverLayer = true;
+          }
+        }
+
+        for (var idx = taskParams.start; idx < taskParams.end; idx++) {
+          var point = data.getItemLayout(idx);
+
+          if (symbolNeedsDraw(data, point, idx, opt)) {
+            var el = new this._SymbolCtor(data, idx, this._seriesScope);
+            el.traverse(updateIncrementalAndHover);
+            el.setPosition(point);
+            this.group.add(el);
+            data.setItemGraphicEl(idx, el);
+          }
+        }
+      };
+
+      SymbolDraw.prototype.remove = function (enableAnimation) {
+        var group = this.group;
+        var data = this._data; // Incremental model do not have this._data.
+
+        if (data && enableAnimation) {
+          data.eachItemGraphicEl(function (el) {
+            el.fadeOut(function () {
+              group.remove(el);
+            });
+          });
+        } else {
+          group.removeAll();
+        }
+      };
+      return SymbolDraw;
+    }();
+
+    function prepareDataCoordInfo(coordSys, data, valueOrigin) {
+      var baseAxis = coordSys.getBaseAxis();
+      var valueAxis = coordSys.getOtherAxis(baseAxis);
+      var valueStart = getValueStart(valueAxis, valueOrigin);
+      var baseAxisDim = baseAxis.dim;
+      var valueAxisDim = valueAxis.dim;
+      var valueDim = data.mapDimension(valueAxisDim);
+      var baseDim = data.mapDimension(baseAxisDim);
+      var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0;
+      var dims = map(coordSys.dimensions, function (coordDim) {
+        return data.mapDimension(coordDim);
+      });
+      var stacked = false;
+      var stackResultDim = data.getCalculationInfo('stackResultDimension');
+
+      if (isDimensionStacked(data, dims[0]
+      /*, dims[1]*/
+      )) {
+        // jshint ignore:line
+        stacked = true;
+        dims[0] = stackResultDim;
+      }
+
+      if (isDimensionStacked(data, dims[1]
+      /*, dims[0]*/
+      )) {
+        // jshint ignore:line
+        stacked = true;
+        dims[1] = stackResultDim;
+      }
+
+      return {
+        dataDimsForPoint: dims,
+        valueStart: valueStart,
+        valueAxisDim: valueAxisDim,
+        baseAxisDim: baseAxisDim,
+        stacked: !!stacked,
+        valueDim: valueDim,
+        baseDim: baseDim,
+        baseDataOffset: baseDataOffset,
+        stackedOverDimension: data.getCalculationInfo('stackedOverDimension')
+      };
+    }
+
+    function getValueStart(valueAxis, valueOrigin) {
+      var valueStart = 0;
+      var extent = valueAxis.scale.getExtent();
+
+      if (valueOrigin === 'start') {
+        valueStart = extent[0];
+      } else if (valueOrigin === 'end') {
+        valueStart = extent[1];
+      } // auto
+      else {
+          // Both positive
+          if (extent[0] > 0) {
+            valueStart = extent[0];
+          } // Both negative
+          else if (extent[1] < 0) {
+              valueStart = extent[1];
+            } // If is one positive, and one negative, onZero shall be true
+
+        }
+
+      return valueStart;
+    }
+
+    function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
+      var value = NaN;
+
+      if (dataCoordInfo.stacked) {
+        value = data.get(data.getCalculationInfo('stackedOverDimension'), idx);
+      }
+
+      if (isNaN(value)) {
+        value = dataCoordInfo.valueStart;
+      }
+
+      var baseDataOffset = dataCoordInfo.baseDataOffset;
+      var stackedData = [];
+      stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
+      stackedData[1 - baseDataOffset] = value;
+      return coordSys.dataToPoint(stackedData);
+    }
+
+    /* global Float32Array */
+
+    var supportFloat32Array = typeof Float32Array !== 'undefined';
+    var Float32ArrayCtor = !supportFloat32Array ? Array : Float32Array;
+    function createFloat32Array(arg) {
+      if (isArray(arg)) {
+        // Return self directly if don't support TypedArray.
+        return supportFloat32Array ? new Float32Array(arg) : arg;
+      } // Else is number
+
+
+      return new Float32ArrayCtor(arg);
+    }
+
+    function diffData(oldData, newData) {
+      var diffResult = [];
+      newData.diff(oldData).add(function (idx) {
+        diffResult.push({
+          cmd: '+',
+          idx: idx
+        });
+      }).update(function (newIdx, oldIdx) {
+        diffResult.push({
+          cmd: '=',
+          idx: oldIdx,
+          idx1: newIdx
+        });
+      }).remove(function (idx) {
+        diffResult.push({
+          cmd: '-',
+          idx: idx
+        });
+      }).execute();
+      return diffResult;
+    }
+
+    function lineAnimationDiff(oldData, newData, oldStackedOnPoints, newStackedOnPoints, oldCoordSys, newCoordSys, oldValueOrigin, newValueOrigin) {
+      var diff = diffData(oldData, newData); // let newIdList = newData.mapArray(newData.getId);
+      // let oldIdList = oldData.mapArray(oldData.getId);
+      // convertToIntId(newIdList, oldIdList);
+      // // FIXME One data ?
+      // diff = arrayDiff(oldIdList, newIdList);
+
+      var currPoints = [];
+      var nextPoints = []; // Points for stacking base line
+
+      var currStackedPoints = [];
+      var nextStackedPoints = [];
+      var status = [];
+      var sortedIndices = [];
+      var rawIndices = [];
+      var newDataOldCoordInfo = prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin);
+      var oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin);
+      var oldPoints = oldData.getLayout('points') || [];
+      var newPoints = newData.getLayout('points') || [];
+
+      for (var i = 0; i < diff.length; i++) {
+        var diffItem = diff[i];
+        var pointAdded = true;
+        var oldIdx2 = void 0;
+        var newIdx2 = void 0; // FIXME, animation is not so perfect when dataZoom window moves fast
+        // Which is in case remvoing or add more than one data in the tail or head
+
+        switch (diffItem.cmd) {
+          case '=':
+            oldIdx2 = diffItem.idx * 2;
+            newIdx2 = diffItem.idx1 * 2;
+            var currentX = oldPoints[oldIdx2];
+            var currentY = oldPoints[oldIdx2 + 1];
+            var nextX = newPoints[newIdx2];
+            var nextY = newPoints[newIdx2 + 1]; // If previous data is NaN, use next point directly
+
+            if (isNaN(currentX) || isNaN(currentY)) {
+              currentX = nextX;
+              currentY = nextY;
+            }
+
+            currPoints.push(currentX, currentY);
+            nextPoints.push(nextX, nextY);
+            currStackedPoints.push(oldStackedOnPoints[oldIdx2], oldStackedOnPoints[oldIdx2 + 1]);
+            nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]);
+            rawIndices.push(newData.getRawIndex(diffItem.idx1));
+            break;
+
+          case '+':
+            var newIdx = diffItem.idx;
+            var newDataDimsForPoint = newDataOldCoordInfo.dataDimsForPoint;
+            var oldPt = oldCoordSys.dataToPoint([newData.get(newDataDimsForPoint[0], newIdx), newData.get(newDataDimsForPoint[1], newIdx)]);
+            newIdx2 = newIdx * 2;
+            currPoints.push(oldPt[0], oldPt[1]);
+            nextPoints.push(newPoints[newIdx2], newPoints[newIdx2 + 1]);
+            var stackedOnPoint = getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, newIdx);
+            currStackedPoints.push(stackedOnPoint[0], stackedOnPoint[1]);
+            nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]);
+            rawIndices.push(newData.getRawIndex(newIdx));
+            break;
+
+          case '-':
+            var oldIdx = diffItem.idx;
+            var rawIndex = oldData.getRawIndex(oldIdx);
+            var oldDataDimsForPoint = oldDataNewCoordInfo.dataDimsForPoint;
+            oldIdx2 = oldIdx * 2; // Data is replaced. In the case of dynamic data queue
+            // FIXME FIXME FIXME
+
+            if (rawIndex !== oldIdx) {
+              var newPt = newCoordSys.dataToPoint([oldData.get(oldDataDimsForPoint[0], oldIdx), oldData.get(oldDataDimsForPoint[1], oldIdx)]);
+              var newStackedOnPt = getStackedOnPoint(oldDataNewCoordInfo, newCoordSys, oldData, oldIdx);
+              currPoints.push(oldPoints[oldIdx2], oldPoints[oldIdx2 + 1]);
+              nextPoints.push(newPt[0], newPt[1]);
+              currStackedPoints.push(oldStackedOnPoints[oldIdx2], oldStackedOnPoints[oldIdx2 + 1]);
+              nextStackedPoints.push(newStackedOnPt[0], newStackedOnPt[1]);
+              rawIndices.push(rawIndex);
+            } else {
+              pointAdded = false;
+            }
+
+        } // Original indices
+
+
+        if (pointAdded) {
+          status.push(diffItem);
+          sortedIndices.push(sortedIndices.length);
+        }
+      } // Diff result may be crossed if all items are changed
+      // Sort by data index
+
+
+      sortedIndices.sort(function (a, b) {
+        return rawIndices[a] - rawIndices[b];
+      });
+      var len = currPoints.length;
+      var sortedCurrPoints = createFloat32Array(len);
+      var sortedNextPoints = createFloat32Array(len);
+      var sortedCurrStackedPoints = createFloat32Array(len);
+      var sortedNextStackedPoints = createFloat32Array(len);
+      var sortedStatus = [];
+
+      for (var i = 0; i < sortedIndices.length; i++) {
+        var idx = sortedIndices[i];
+        var i2 = i * 2;
+        var idx2 = idx * 2;
+        sortedCurrPoints[i2] = currPoints[idx2];
+        sortedCurrPoints[i2 + 1] = currPoints[idx2 + 1];
+        sortedNextPoints[i2] = nextPoints[idx2];
+        sortedNextPoints[i2 + 1] = nextPoints[idx2 + 1];
+        sortedCurrStackedPoints[i2] = currStackedPoints[idx2];
+        sortedCurrStackedPoints[i2 + 1] = currStackedPoints[idx2 + 1];
+        sortedNextStackedPoints[i2] = nextStackedPoints[idx2];
+        sortedNextStackedPoints[i2 + 1] = nextStackedPoints[idx2 + 1];
+        sortedStatus[i] = status[idx];
+      }
+
+      return {
+        current: sortedCurrPoints,
+        next: sortedNextPoints,
+        stackedOnCurrent: sortedCurrStackedPoints,
+        stackedOnNext: sortedNextStackedPoints,
+        status: sortedStatus
+      };
+    }
+
+    var mathMin$5 = Math.min;
+    var mathMax$5 = Math.max;
+
+    function isPointNull(x, y) {
+      return isNaN(x) || isNaN(y);
+    }
+    /**
+     * Draw smoothed line in non-monotone, in may cause undesired curve in extreme
+     * situations. This should be used when points are non-monotone neither in x or
+     * y dimension.
+     */
+
+
+    function drawSegment(ctx, points, start, segLen, allLen, dir, smooth, smoothMonotone, connectNulls) {
+      var prevX;
+      var prevY;
+      var cpx0;
+      var cpy0;
+      var cpx1;
+      var cpy1;
+      var idx = start;
+      var k = 0;
+
+      for (; k < segLen; k++) {
+        var x = points[idx * 2];
+        var y = points[idx * 2 + 1];
+
+        if (idx >= allLen || idx < 0) {
+          break;
+        }
+
+        if (isPointNull(x, y)) {
+          if (connectNulls) {
+            idx += dir;
+            continue;
+          }
+
+          break;
+        }
+
+        if (idx === start) {
+          ctx[dir > 0 ? 'moveTo' : 'lineTo'](x, y);
+          cpx0 = x;
+          cpy0 = y;
+        } else {
+          var dx = x - prevX;
+          var dy = y - prevY; // Ignore tiny segment.
+
+          if (dx * dx + dy * dy < 0.5) {
+            idx += dir;
+            continue;
+          }
+
+          if (smooth > 0) {
+            var nextIdx = idx + dir;
+            var nextX = points[nextIdx * 2];
+            var nextY = points[nextIdx * 2 + 1];
+            var tmpK = k + 1;
+
+            if (connectNulls) {
+              // Find next point not null
+              while (isPointNull(nextX, nextY) && tmpK < segLen) {
+                tmpK++;
+                nextIdx += dir;
+                nextX = points[nextIdx * 2];
+                nextY = points[nextIdx * 2 + 1];
+              }
+            }
+
+            var ratioNextSeg = 0.5;
+            var vx = 0;
+            var vy = 0;
+            var nextCpx0 = void 0;
+            var nextCpy0 = void 0; // Is last point
+
+            if (tmpK >= segLen || isPointNull(nextX, nextY)) {
+              cpx1 = x;
+              cpy1 = y;
+            } else {
+              vx = nextX - prevX;
+              vy = nextY - prevY;
+              var dx0 = x - prevX;
+              var dx1 = nextX - x;
+              var dy0 = y - prevY;
+              var dy1 = nextY - y;
+              var lenPrevSeg = void 0;
+              var lenNextSeg = void 0;
+
+              if (smoothMonotone === 'x') {
+                lenPrevSeg = Math.abs(dx0);
+                lenNextSeg = Math.abs(dx1);
+                cpx1 = x - lenPrevSeg * smooth;
+                cpy1 = y;
+                nextCpx0 = x + lenPrevSeg * smooth;
+                nextCpy0 = y;
+              } else if (smoothMonotone === 'y') {
+                lenPrevSeg = Math.abs(dy0);
+                lenNextSeg = Math.abs(dy1);
+                cpx1 = x;
+                cpy1 = y - lenPrevSeg * smooth;
+                nextCpx0 = x;
+                nextCpy0 = y + lenPrevSeg * smooth;
+              } else {
+                lenPrevSeg = Math.sqrt(dx0 * dx0 + dy0 * dy0);
+                lenNextSeg = Math.sqrt(dx1 * dx1 + dy1 * dy1); // Use ratio of seg length
+
+                ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg);
+                cpx1 = x - vx * smooth * (1 - ratioNextSeg);
+                cpy1 = y - vy * smooth * (1 - ratioNextSeg); // cp0 of next segment
+
+                nextCpx0 = x + vx * smooth * ratioNextSeg;
+                nextCpy0 = y + vy * smooth * ratioNextSeg; // Smooth constraint between point and next point.
+                // Avoid exceeding extreme after smoothing.
+
+                nextCpx0 = mathMin$5(nextCpx0, mathMax$5(nextX, x));
+                nextCpy0 = mathMin$5(nextCpy0, mathMax$5(nextY, y));
+                nextCpx0 = mathMax$5(nextCpx0, mathMin$5(nextX, x));
+                nextCpy0 = mathMax$5(nextCpy0, mathMin$5(nextY, y)); // Reclaculate cp1 based on the adjusted cp0 of next seg.
+
+                vx = nextCpx0 - x;
+                vy = nextCpy0 - y;
+                cpx1 = x - vx * lenPrevSeg / lenNextSeg;
+                cpy1 = y - vy * lenPrevSeg / lenNextSeg; // Smooth constraint between point and prev point.
+                // Avoid exceeding extreme after smoothing.
+
+                cpx1 = mathMin$5(cpx1, mathMax$5(prevX, x));
+                cpy1 = mathMin$5(cpy1, mathMax$5(prevY, y));
+                cpx1 = mathMax$5(cpx1, mathMin$5(prevX, x));
+                cpy1 = mathMax$5(cpy1, mathMin$5(prevY, y)); // Adjust next cp0 again.
+
+                vx = x - cpx1;
+                vy = y - cpy1;
+                nextCpx0 = x + vx * lenNextSeg / lenPrevSeg;
+                nextCpy0 = y + vy * lenNextSeg / lenPrevSeg;
+              }
+            }
+
+            ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
+            cpx0 = nextCpx0;
+            cpy0 = nextCpy0;
+          } else {
+            ctx.lineTo(x, y);
+          }
+        }
+
+        prevX = x;
+        prevY = y;
+        idx += dir;
+      }
+
+      return k;
+    }
+
+    var ECPolylineShape =
+    /** @class */
+    function () {
+      function ECPolylineShape() {
+        this.smooth = 0;
+        this.smoothConstraint = true;
+      }
+
+      return ECPolylineShape;
+    }();
+
+    var ECPolyline =
+    /** @class */
+    function (_super) {
+      __extends(ECPolyline, _super);
+
+      function ECPolyline(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'ec-polyline';
+        return _this;
+      }
+
+      ECPolyline.prototype.getDefaultStyle = function () {
+        return {
+          stroke: '#000',
+          fill: null
+        };
+      };
+
+      ECPolyline.prototype.getDefaultShape = function () {
+        return new ECPolylineShape();
+      };
+
+      ECPolyline.prototype.buildPath = function (ctx, shape) {
+        var points = shape.points;
+        var i = 0;
+        var len = points.length / 2; // const result = getBoundingBox(points, shape.smoothConstraint);
+
+        if (shape.connectNulls) {
+          // Must remove first and last null values avoid draw error in polygon
+          for (; len > 0; len--) {
+            if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
+              break;
+            }
+          }
+
+          for (; i < len; i++) {
+            if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
+              break;
+            }
+          }
+        }
+
+        while (i < len) {
+          i += drawSegment(ctx, points, i, len, len, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1;
+        }
+      };
+
+      ECPolyline.prototype.getPointOn = function (xOrY, dim) {
+        if (!this.path) {
+          this.createPathProxy();
+          this.buildPath(this.path, this.shape);
+        }
+
+        var path = this.path;
+        var data = path.data;
+        var CMD = PathProxy.CMD;
+        var x0;
+        var y0;
+        var isDimX = dim === 'x';
+        var roots = [];
+
+        for (var i = 0; i < data.length;) {
+          var cmd = data[i++];
+          var x = void 0;
+          var y = void 0;
+          var x2 = void 0;
+          var y2 = void 0;
+          var x3 = void 0;
+          var y3 = void 0;
+          var t = void 0;
+
+          switch (cmd) {
+            case CMD.M:
+              x0 = data[i++];
+              y0 = data[i++];
+              break;
+
+            case CMD.L:
+              x = data[i++];
+              y = data[i++];
+              t = isDimX ? (xOrY - x0) / (x - x0) : (xOrY - y0) / (y - y0);
+
+              if (t <= 1 && t >= 0) {
+                var val = isDimX ? (y - y0) * t + y0 : (x - x0) * t + x0;
+                return isDimX ? [xOrY, val] : [val, xOrY];
+              }
+
+              x0 = x;
+              y0 = y;
+              break;
+
+            case CMD.C:
+              x = data[i++];
+              y = data[i++];
+              x2 = data[i++];
+              y2 = data[i++];
+              x3 = data[i++];
+              y3 = data[i++];
+              var nRoot = isDimX ? cubicRootAt(x0, x, x2, x3, xOrY, roots) : cubicRootAt(y0, y, y2, y3, xOrY, roots);
+
+              if (nRoot > 0) {
+                for (var i_1 = 0; i_1 < nRoot; i_1++) {
+                  var t_1 = roots[i_1];
+
+                  if (t_1 <= 1 && t_1 >= 0) {
+                    var val = isDimX ? cubicAt(y0, y, y2, y3, t_1) : cubicAt(x0, x, x2, x3, t_1);
+                    return isDimX ? [xOrY, val] : [val, xOrY];
+                  }
+                }
+              }
+
+              x0 = x3;
+              y0 = y3;
+              break;
+          }
+        }
+      };
+
+      return ECPolyline;
+    }(Path);
+
+    var ECPolygonShape =
+    /** @class */
+    function (_super) {
+      __extends(ECPolygonShape, _super);
+
+      function ECPolygonShape() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      return ECPolygonShape;
+    }(ECPolylineShape);
+
+    var ECPolygon =
+    /** @class */
+    function (_super) {
+      __extends(ECPolygon, _super);
+
+      function ECPolygon(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'ec-polygon';
+        return _this;
+      }
+
+      ECPolygon.prototype.getDefaultShape = function () {
+        return new ECPolygonShape();
+      };
+
+      ECPolygon.prototype.buildPath = function (ctx, shape) {
+        var points = shape.points;
+        var stackedOnPoints = shape.stackedOnPoints;
+        var i = 0;
+        var len = points.length / 2;
+        var smoothMonotone = shape.smoothMonotone;
+
+        if (shape.connectNulls) {
+          // Must remove first and last null values avoid draw error in polygon
+          for (; len > 0; len--) {
+            if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
+              break;
+            }
+          }
+
+          for (; i < len; i++) {
+            if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
+              break;
+            }
+          }
+        }
+
+        while (i < len) {
+          var k = drawSegment(ctx, points, i, len, len, 1, shape.smooth, smoothMonotone, shape.connectNulls);
+          drawSegment(ctx, stackedOnPoints, i + k - 1, k, len, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls);
+          i += k + 1;
+          ctx.closePath();
+        }
+      };
+
+      return ECPolygon;
+    }(Path);
+
+    function createGridClipPath(cartesian, hasAnimation, seriesModel, done, during) {
+      var rect = cartesian.getArea();
+      var x = rect.x;
+      var y = rect.y;
+      var width = rect.width;
+      var height = rect.height;
+      var lineWidth = seriesModel.get(['lineStyle', 'width']) || 2; // Expand the clip path a bit to avoid the border is clipped and looks thinner
+
+      x -= lineWidth / 2;
+      y -= lineWidth / 2;
+      width += lineWidth;
+      height += lineWidth; // fix: https://github.com/apache/incubator-echarts/issues/11369
+
+      x = Math.floor(x);
+      width = Math.round(width);
+      var clipPath = new Rect({
+        shape: {
+          x: x,
+          y: y,
+          width: width,
+          height: height
+        }
+      });
+
+      if (hasAnimation) {
+        var baseAxis = cartesian.getBaseAxis();
+        var isHorizontal = baseAxis.isHorizontal();
+        var isAxisInversed = baseAxis.inverse;
+
+        if (isHorizontal) {
+          if (isAxisInversed) {
+            clipPath.shape.x += width;
+          }
+
+          clipPath.shape.width = 0;
+        } else {
+          if (!isAxisInversed) {
+            clipPath.shape.y += height;
+          }
+
+          clipPath.shape.height = 0;
+        }
+
+        var duringCb = typeof during === 'function' ? function (percent) {
+          during(percent, clipPath);
+        } : null;
+        initProps(clipPath, {
+          shape: {
+            width: width,
+            height: height,
+            x: x,
+            y: y
+          }
+        }, seriesModel, null, done, duringCb);
+      }
+
+      return clipPath;
+    }
+
+    function createPolarClipPath(polar, hasAnimation, seriesModel) {
+      var sectorArea = polar.getArea(); // Avoid float number rounding error for symbol on the edge of axis extent.
+
+      var r0 = round(sectorArea.r0, 1);
+      var r = round(sectorArea.r, 1);
+      var clipPath = new Sector({
+        shape: {
+          cx: round(polar.cx, 1),
+          cy: round(polar.cy, 1),
+          r0: r0,
+          r: r,
+          startAngle: sectorArea.startAngle,
+          endAngle: sectorArea.endAngle,
+          clockwise: sectorArea.clockwise
+        }
+      });
+
+      if (hasAnimation) {
+        var isRadial = polar.getBaseAxis().dim === 'angle';
+
+        if (isRadial) {
+          clipPath.shape.endAngle = sectorArea.startAngle;
+        } else {
+          clipPath.shape.r = r0;
+        }
+
+        initProps(clipPath, {
+          shape: {
+            endAngle: sectorArea.endAngle,
+            r: r
+          }
+        }, seriesModel);
+      }
+
+      return clipPath;
+    }
+
+    function createClipPath(coordSys, hasAnimation, seriesModel, done, during) {
+      if (!coordSys) {
+        return null;
+      } else if (coordSys.type === 'polar') {
+        return createPolarClipPath(coordSys, hasAnimation, seriesModel);
+      } else if (coordSys.type === 'cartesian2d') {
+        return createGridClipPath(coordSys, hasAnimation, seriesModel, done, during);
+      }
+
+      return null;
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function isCoordinateSystemType(coordSys, type) {
+      return coordSys.type === type;
+    }
+
+    function isPointsSame(points1, points2) {
+      if (points1.length !== points2.length) {
+        return;
+      }
+
+      for (var i = 0; i < points1.length; i++) {
+        if (points1[i] !== points2[i]) {
+          return;
+        }
+      }
+
+      return true;
+    }
+
+    function bboxFromPoints(points) {
+      var minX = Infinity;
+      var minY = Infinity;
+      var maxX = -Infinity;
+      var maxY = -Infinity;
+
+      for (var i = 0; i < points.length;) {
+        var x = points[i++];
+        var y = points[i++];
+
+        if (!isNaN(x)) {
+          minX = Math.min(x, minX);
+          maxX = Math.max(x, maxX);
+        }
+
+        if (!isNaN(y)) {
+          minY = Math.min(y, minY);
+          maxY = Math.max(y, maxY);
+        }
+      }
+
+      return [[minX, minY], [maxX, maxY]];
+    }
+
+    function getBoundingDiff(points1, points2) {
+      var _a = bboxFromPoints(points1),
+          min1 = _a[0],
+          max1 = _a[1];
+
+      var _b = bboxFromPoints(points2),
+          min2 = _b[0],
+          max2 = _b[1]; // Get a max value from each corner of two boundings.
+
+
+      return Math.max(Math.abs(min1[0] - min2[0]), Math.abs(min1[1] - min2[1]), Math.abs(max1[0] - max2[0]), Math.abs(max1[1] - max2[1]));
+    }
+
+    function getSmooth(smooth) {
+      return typeof smooth === 'number' ? smooth : smooth ? 0.5 : 0;
+    }
+
+    function getStackedOnPoints(coordSys, data, dataCoordInfo) {
+      if (!dataCoordInfo.valueDim) {
+        return [];
+      }
+
+      var len = data.count();
+      var points = createFloat32Array(len * 2);
+
+      for (var idx = 0; idx < len; idx++) {
+        var pt = getStackedOnPoint(dataCoordInfo, coordSys, data, idx);
+        points[idx * 2] = pt[0];
+        points[idx * 2 + 1] = pt[1];
+      }
+
+      return points;
+    }
+
+    function turnPointsIntoStep(points, coordSys, stepTurnAt) {
+      var baseAxis = coordSys.getBaseAxis();
+      var baseIndex = baseAxis.dim === 'x' || baseAxis.dim === 'radius' ? 0 : 1;
+      var stepPoints = [];
+      var i = 0;
+      var stepPt = [];
+      var pt = [];
+      var nextPt = [];
+
+      for (; i < points.length - 2; i += 2) {
+        nextPt[0] = points[i + 2];
+        nextPt[1] = points[i + 3];
+        pt[0] = points[i];
+        pt[1] = points[i + 1];
+        stepPoints.push(pt[0], pt[1]);
+
+        switch (stepTurnAt) {
+          case 'end':
+            stepPt[baseIndex] = nextPt[baseIndex];
+            stepPt[1 - baseIndex] = pt[1 - baseIndex];
+            stepPoints.push(stepPt[0], stepPt[1]);
+            break;
+
+          case 'middle':
+            var middle = (pt[baseIndex] + nextPt[baseIndex]) / 2;
+            var stepPt2 = [];
+            stepPt[baseIndex] = stepPt2[baseIndex] = middle;
+            stepPt[1 - baseIndex] = pt[1 - baseIndex];
+            stepPt2[1 - baseIndex] = nextPt[1 - baseIndex];
+            stepPoints.push(stepPt[0], stepPt[1]);
+            stepPoints.push(stepPt2[0], stepPt2[1]);
+            break;
+
+          default:
+            // default is start
+            stepPt[baseIndex] = pt[baseIndex];
+            stepPt[1 - baseIndex] = nextPt[1 - baseIndex];
+            stepPoints.push(stepPt[0], stepPt[1]);
+        }
+      } // Last points
+
+
+      stepPoints.push(points[i++], points[i++]);
+      return stepPoints;
+    }
+
+    function getVisualGradient(data, coordSys) {
+      var visualMetaList = data.getVisual('visualMeta');
+
+      if (!visualMetaList || !visualMetaList.length || !data.count()) {
+        // When data.count() is 0, gradient range can not be calculated.
+        return;
+      }
+
+      if (coordSys.type !== 'cartesian2d') {
+        if ("development" !== 'production') {
+          console.warn('Visual map on line style is only supported on cartesian2d.');
+        }
+
+        return;
+      }
+
+      var coordDim;
+      var visualMeta;
+
+      for (var i = visualMetaList.length - 1; i >= 0; i--) {
+        var dimIndex = visualMetaList[i].dimension;
+        var dimName = data.dimensions[dimIndex];
+        var dimInfo = data.getDimensionInfo(dimName);
+        coordDim = dimInfo && dimInfo.coordDim; // Can only be x or y
+
+        if (coordDim === 'x' || coordDim === 'y') {
+          visualMeta = visualMetaList[i];
+          break;
+        }
+      }
+
+      if (!visualMeta) {
+        if ("development" !== 'production') {
+          console.warn('Visual map on line style only support x or y dimension.');
+        }
+
+        return;
+      } // If the area to be rendered is bigger than area defined by LinearGradient,
+      // the canvas spec prescribes that the color of the first stop and the last
+      // stop should be used. But if two stops are added at offset 0, in effect
+      // browsers use the color of the second stop to render area outside
+      // LinearGradient. So we can only infinitesimally extend area defined in
+      // LinearGradient to render `outerColors`.
+
+
+      var axis = coordSys.getAxis(coordDim); // dataToCoor mapping may not be linear, but must be monotonic.
+
+      var colorStops = map(visualMeta.stops, function (stop) {
+        return {
+          offset: 0,
+          coord: axis.toGlobalCoord(axis.dataToCoord(stop.value)),
+          color: stop.color
+        };
+      });
+      var stopLen = colorStops.length;
+      var outerColors = visualMeta.outerColors.slice();
+
+      if (stopLen && colorStops[0].coord > colorStops[stopLen - 1].coord) {
+        colorStops.reverse();
+        outerColors.reverse();
+      }
+
+      var tinyExtent = 10; // Arbitrary value: 10px
+
+      var minCoord = colorStops[0].coord - tinyExtent;
+      var maxCoord = colorStops[stopLen - 1].coord + tinyExtent;
+      var coordSpan = maxCoord - minCoord;
+
+      if (coordSpan < 1e-3) {
+        return 'transparent';
+      }
+
+      each(colorStops, function (stop) {
+        stop.offset = (stop.coord - minCoord) / coordSpan;
+      });
+      colorStops.push({
+        offset: stopLen ? colorStops[stopLen - 1].offset : 0.5,
+        color: outerColors[1] || 'transparent'
+      });
+      colorStops.unshift({
+        offset: stopLen ? colorStops[0].offset : 0.5,
+        color: outerColors[0] || 'transparent'
+      }); // zrUtil.each(colorStops, function (colorStop) {
+      //     // Make sure each offset has rounded px to avoid not sharp edge
+      //     colorStop.offset = (Math.round(colorStop.offset * (end - start) + start) - start) / (end - start);
+      // });
+
+      var gradient = new LinearGradient(0, 0, 0, 0, colorStops, true);
+      gradient[coordDim] = minCoord;
+      gradient[coordDim + '2'] = maxCoord;
+      return gradient;
+    }
+
+    function getIsIgnoreFunc(seriesModel, data, coordSys) {
+      var showAllSymbol = seriesModel.get('showAllSymbol');
+      var isAuto = showAllSymbol === 'auto';
+
+      if (showAllSymbol && !isAuto) {
+        return;
+      }
+
+      var categoryAxis = coordSys.getAxesByScale('ordinal')[0];
+
+      if (!categoryAxis) {
+        return;
+      } // Note that category label interval strategy might bring some weird effect
+      // in some scenario: users may wonder why some of the symbols are not
+      // displayed. So we show all symbols as possible as we can.
+
+
+      if (isAuto // Simplify the logic, do not determine label overlap here.
+      && canShowAllSymbolForCategory(categoryAxis, data)) {
+        return;
+      } // Otherwise follow the label interval strategy on category axis.
+
+
+      var categoryDataDim = data.mapDimension(categoryAxis.dim);
+      var labelMap = {};
+      each(categoryAxis.getViewLabels(), function (labelItem) {
+        var ordinalNumber = categoryAxis.scale.getRawOrdinalNumber(labelItem.tickValue);
+        labelMap[ordinalNumber] = 1;
+      });
+      return function (dataIndex) {
+        return !labelMap.hasOwnProperty(data.get(categoryDataDim, dataIndex));
+      };
+    }
+
+    function canShowAllSymbolForCategory(categoryAxis, data) {
+      // In mose cases, line is monotonous on category axis, and the label size
+      // is close with each other. So we check the symbol size and some of the
+      // label size alone with the category axis to estimate whether all symbol
+      // can be shown without overlap.
+      var axisExtent = categoryAxis.getExtent();
+      var availSize = Math.abs(axisExtent[1] - axisExtent[0]) / categoryAxis.scale.count();
+      isNaN(availSize) && (availSize = 0); // 0/0 is NaN.
+      // Sampling some points, max 5.
+
+      var dataLen = data.count();
+      var step = Math.max(1, Math.round(dataLen / 5));
+
+      for (var dataIndex = 0; dataIndex < dataLen; dataIndex += step) {
+        if (Symbol.getSymbolSize(data, dataIndex // Only for cartesian, where `isHorizontal` exists.
+        )[categoryAxis.isHorizontal() ? 1 : 0] // Empirical number
+        * 1.5 > availSize) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    function isPointNull$1(x, y) {
+      return isNaN(x) || isNaN(y);
+    }
+
+    function getLastIndexNotNull(points) {
+      var len = points.length / 2;
+
+      for (; len > 0; len--) {
+        if (!isPointNull$1(points[len * 2 - 2], points[len * 2 - 1])) {
+          break;
+        }
+      }
+
+      return len - 1;
+    }
+
+    function getPointAtIndex(points, idx) {
+      return [points[idx * 2], points[idx * 2 + 1]];
+    }
+
+    function getIndexRange(points, xOrY, dim) {
+      var len = points.length / 2;
+      var dimIdx = dim === 'x' ? 0 : 1;
+      var a;
+      var b;
+      var prevIndex = 0;
+      var nextIndex = -1;
+
+      for (var i = 0; i < len; i++) {
+        b = points[i * 2 + dimIdx];
+
+        if (isNaN(b) || isNaN(points[i * 2 + 1 - dimIdx])) {
+          continue;
+        }
+
+        if (i === 0) {
+          a = b;
+          continue;
+        }
+
+        if (a <= xOrY && b >= xOrY || a >= xOrY && b <= xOrY) {
+          nextIndex = i;
+          break;
+        }
+
+        prevIndex = i;
+        a = b;
+      }
+
+      return {
+        range: [prevIndex, nextIndex],
+        t: (xOrY - a) / (b - a)
+      };
+    }
+
+    function createLineClipPath(lineView, coordSys, hasAnimation, seriesModel) {
+      if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+        var endLabelModel_1 = seriesModel.getModel('endLabel');
+        var showEndLabel = endLabelModel_1.get('show');
+        var valueAnimation_1 = endLabelModel_1.get('valueAnimation');
+        var data_1 = seriesModel.getData();
+        var labelAnimationRecord_1 = {
+          lastFrameIndex: 0
+        };
+        var during = showEndLabel ? function (percent, clipRect) {
+          lineView._endLabelOnDuring(percent, clipRect, data_1, labelAnimationRecord_1, valueAnimation_1, endLabelModel_1, coordSys);
+        } : null;
+        var isHorizontal = coordSys.getBaseAxis().isHorizontal();
+        var clipPath = createGridClipPath(coordSys, hasAnimation, seriesModel, function () {
+          var endLabel = lineView._endLabel;
+
+          if (endLabel && hasAnimation) {
+            if (labelAnimationRecord_1.originalX != null) {
+              endLabel.attr({
+                x: labelAnimationRecord_1.originalX,
+                y: labelAnimationRecord_1.originalY
+              });
+            }
+          }
+        }, during); // Expand clip shape to avoid clipping when line value exceeds axis
+
+        if (!seriesModel.get('clip', true)) {
+          var rectShape = clipPath.shape;
+          var expandSize = Math.max(rectShape.width, rectShape.height);
+
+          if (isHorizontal) {
+            rectShape.y -= expandSize;
+            rectShape.height += expandSize * 2;
+          } else {
+            rectShape.x -= expandSize;
+            rectShape.width += expandSize * 2;
+          }
+        } // Set to the final frame. To make sure label layout is right.
+
+
+        if (during) {
+          during(1, clipPath);
+        }
+
+        return clipPath;
+      } else {
+        if ("development" !== 'production') {
+          if (seriesModel.get(['endLabel', 'show'])) {
+            console.warn('endLabel is not supported for lines in polar systems.');
+          }
+        }
+
+        return createPolarClipPath(coordSys, hasAnimation, seriesModel);
+      }
+    }
+
+    function getEndLabelStateSpecified(endLabelModel, coordSys) {
+      var baseAxis = coordSys.getBaseAxis();
+      var isHorizontal = baseAxis.isHorizontal();
+      var isBaseInversed = baseAxis.inverse;
+      var align = isHorizontal ? isBaseInversed ? 'right' : 'left' : 'center';
+      var verticalAlign = isHorizontal ? 'middle' : isBaseInversed ? 'top' : 'bottom';
+      return {
+        normal: {
+          align: endLabelModel.get('align') || align,
+          verticalAlign: endLabelModel.get('verticalAlign') || verticalAlign
+        }
+      };
+    }
+
+    var LineView =
+    /** @class */
+    function (_super) {
+      __extends(LineView, _super);
+
+      function LineView() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      LineView.prototype.init = function () {
+        var lineGroup = new Group();
+        var symbolDraw = new SymbolDraw();
+        this.group.add(symbolDraw.group);
+        this._symbolDraw = symbolDraw;
+        this._lineGroup = lineGroup;
+      };
+
+      LineView.prototype.render = function (seriesModel, ecModel, api) {
+        var _this = this;
+
+        var coordSys = seriesModel.coordinateSystem;
+        var group = this.group;
+        var data = seriesModel.getData();
+        var lineStyleModel = seriesModel.getModel('lineStyle');
+        var areaStyleModel = seriesModel.getModel('areaStyle');
+        var points = data.getLayout('points') || [];
+        var isCoordSysPolar = coordSys.type === 'polar';
+        var prevCoordSys = this._coordSys;
+        var symbolDraw = this._symbolDraw;
+        var polyline = this._polyline;
+        var polygon = this._polygon;
+        var lineGroup = this._lineGroup;
+        var hasAnimation = seriesModel.get('animation');
+        var isAreaChart = !areaStyleModel.isEmpty();
+        var valueOrigin = areaStyleModel.get('origin');
+        var dataCoordInfo = prepareDataCoordInfo(coordSys, data, valueOrigin);
+        var stackedOnPoints = isAreaChart && getStackedOnPoints(coordSys, data, dataCoordInfo);
+        var showSymbol = seriesModel.get('showSymbol');
+        var isIgnoreFunc = showSymbol && !isCoordSysPolar && getIsIgnoreFunc(seriesModel, data, coordSys); // Remove temporary symbols
+
+        var oldData = this._data;
+        oldData && oldData.eachItemGraphicEl(function (el, idx) {
+          if (el.__temp) {
+            group.remove(el);
+            oldData.setItemGraphicEl(idx, null);
+          }
+        }); // Remove previous created symbols if showSymbol changed to false
+
+        if (!showSymbol) {
+          symbolDraw.remove();
+        }
+
+        group.add(lineGroup); // FIXME step not support polar
+
+        var step = !isCoordSysPolar ? seriesModel.get('step') : false;
+        var clipShapeForSymbol;
+
+        if (coordSys && coordSys.getArea && seriesModel.get('clip', true)) {
+          clipShapeForSymbol = coordSys.getArea(); // Avoid float number rounding error for symbol on the edge of axis extent.
+          // See #7913 and `test/dataZoom-clip.html`.
+
+          if (clipShapeForSymbol.width != null) {
+            clipShapeForSymbol.x -= 0.1;
+            clipShapeForSymbol.y -= 0.1;
+            clipShapeForSymbol.width += 0.2;
+            clipShapeForSymbol.height += 0.2;
+          } else if (clipShapeForSymbol.r0) {
+            clipShapeForSymbol.r0 -= 0.5;
+            clipShapeForSymbol.r += 0.5;
+          }
+        }
+
+        this._clipShapeForSymbol = clipShapeForSymbol;
+        var visualColor = getVisualGradient(data, coordSys) || data.getVisual('style')[data.getVisual('drawType')]; // Initialization animation or coordinate system changed
+
+        if (!(polyline && prevCoordSys.type === coordSys.type && step === this._step)) {
+          showSymbol && symbolDraw.updateData(data, {
+            isIgnore: isIgnoreFunc,
+            clipShape: clipShapeForSymbol,
+            disableAnimation: true,
+            getSymbolPoint: function (idx) {
+              return [points[idx * 2], points[idx * 2 + 1]];
+            }
+          });
+          hasAnimation && this._initSymbolLabelAnimation(data, coordSys, clipShapeForSymbol);
+
+          if (step) {
+            // TODO If stacked series is not step
+            points = turnPointsIntoStep(points, coordSys, step);
+
+            if (stackedOnPoints) {
+              stackedOnPoints = turnPointsIntoStep(stackedOnPoints, coordSys, step);
+            }
+          }
+
+          polyline = this._newPolyline(points);
+
+          if (isAreaChart) {
+            polygon = this._newPolygon(points, stackedOnPoints);
+          } // NOTE: Must update _endLabel before setClipPath.
+
+
+          if (!isCoordSysPolar) {
+            this._initOrUpdateEndLabel(seriesModel, coordSys, convertToColorString(visualColor));
+          }
+
+          lineGroup.setClipPath(createLineClipPath(this, coordSys, true, seriesModel));
+        } else {
+          if (isAreaChart && !polygon) {
+            // If areaStyle is added
+            polygon = this._newPolygon(points, stackedOnPoints);
+          } else if (polygon && !isAreaChart) {
+            // If areaStyle is removed
+            lineGroup.remove(polygon);
+            polygon = this._polygon = null;
+          } // NOTE: Must update _endLabel before setClipPath.
+
+
+          if (!isCoordSysPolar) {
+            this._initOrUpdateEndLabel(seriesModel, coordSys, convertToColorString(visualColor));
+          } // Update clipPath
+
+
+          lineGroup.setClipPath(createLineClipPath(this, coordSys, false, seriesModel)); // Always update, or it is wrong in the case turning on legend
+          // because points are not changed
+
+          showSymbol && symbolDraw.updateData(data, {
+            isIgnore: isIgnoreFunc,
+            clipShape: clipShapeForSymbol,
+            disableAnimation: true,
+            getSymbolPoint: function (idx) {
+              return [points[idx * 2], points[idx * 2 + 1]];
+            }
+          }); // In the case data zoom triggerred refreshing frequently
+          // Data may not change if line has a category axis. So it should animate nothing
+
+          if (!isPointsSame(this._stackedOnPoints, stackedOnPoints) || !isPointsSame(this._points, points)) {
+            if (hasAnimation) {
+              this._doUpdateAnimation(data, stackedOnPoints, coordSys, api, step, valueOrigin);
+            } else {
+              // Not do it in update with animation
+              if (step) {
+                // TODO If stacked series is not step
+                points = turnPointsIntoStep(points, coordSys, step);
+
+                if (stackedOnPoints) {
+                  stackedOnPoints = turnPointsIntoStep(stackedOnPoints, coordSys, step);
+                }
+              }
+
+              polyline.setShape({
+                points: points
+              });
+              polygon && polygon.setShape({
+                points: points,
+                stackedOnPoints: stackedOnPoints
+              });
+            }
+          }
+        }
+
+        var focus = seriesModel.get(['emphasis', 'focus']);
+        var blurScope = seriesModel.get(['emphasis', 'blurScope']);
+        polyline.useStyle(defaults( // Use color in lineStyle first
+        lineStyleModel.getLineStyle(), {
+          fill: 'none',
+          stroke: visualColor,
+          lineJoin: 'bevel'
+        }));
+        setStatesStylesFromModel(polyline, seriesModel, 'lineStyle');
+
+        if (polyline.style.lineWidth > 0 && seriesModel.get(['emphasis', 'lineStyle', 'width']) === 'bolder') {
+          var emphasisLineStyle = polyline.getState('emphasis').style;
+          emphasisLineStyle.lineWidth = polyline.style.lineWidth + 1;
+        } // Needs seriesIndex for focus
+
+
+        getECData(polyline).seriesIndex = seriesModel.seriesIndex;
+        enableHoverEmphasis(polyline, focus, blurScope);
+        var smooth = getSmooth(seriesModel.get('smooth'));
+        var smoothMonotone = seriesModel.get('smoothMonotone');
+        var connectNulls = seriesModel.get('connectNulls');
+        polyline.setShape({
+          smooth: smooth,
+          smoothMonotone: smoothMonotone,
+          connectNulls: connectNulls
+        });
+
+        if (polygon) {
+          var stackedOnSeries = data.getCalculationInfo('stackedOnSeries');
+          var stackedOnSmooth = 0;
+          polygon.useStyle(defaults(areaStyleModel.getAreaStyle(), {
+            fill: visualColor,
+            opacity: 0.7,
+            lineJoin: 'bevel',
+            decal: data.getVisual('style').decal
+          }));
+
+          if (stackedOnSeries) {
+            stackedOnSmooth = getSmooth(stackedOnSeries.get('smooth'));
+          }
+
+          polygon.setShape({
+            smooth: smooth,
+            stackedOnSmooth: stackedOnSmooth,
+            smoothMonotone: smoothMonotone,
+            connectNulls: connectNulls
+          });
+          setStatesStylesFromModel(polygon, seriesModel, 'areaStyle'); // Needs seriesIndex for focus
+
+          getECData(polygon).seriesIndex = seriesModel.seriesIndex;
+          enableHoverEmphasis(polygon, focus, blurScope);
+        }
+
+        var changePolyState = function (toState) {
+          _this._changePolyState(toState);
+        };
+
+        data.eachItemGraphicEl(function (el) {
+          // Switch polyline / polygon state if element changed its state.
+          el && (el.onHoverStateChange = changePolyState);
+        });
+        this._polyline.onHoverStateChange = changePolyState;
+        this._data = data; // Save the coordinate system for transition animation when data changed
+
+        this._coordSys = coordSys;
+        this._stackedOnPoints = stackedOnPoints;
+        this._points = points;
+        this._step = step;
+        this._valueOrigin = valueOrigin;
+      };
+
+      LineView.prototype.dispose = function () {};
+
+      LineView.prototype.highlight = function (seriesModel, ecModel, api, payload) {
+        var data = seriesModel.getData();
+        var dataIndex = queryDataIndex(data, payload);
+
+        this._changePolyState('emphasis');
+
+        if (!(dataIndex instanceof Array) && dataIndex != null && dataIndex >= 0) {
+          var points = data.getLayout('points');
+          var symbol = data.getItemGraphicEl(dataIndex);
+
+          if (!symbol) {
+            // Create a temporary symbol if it is not exists
+            var x = points[dataIndex * 2];
+            var y = points[dataIndex * 2 + 1];
+
+            if (isNaN(x) || isNaN(y)) {
+              // Null data
+              return;
+            } // fix #11360: should't draw symbol outside clipShapeForSymbol
+
+
+            if (this._clipShapeForSymbol && !this._clipShapeForSymbol.contain(x, y)) {
+              return;
+            }
+
+            symbol = new Symbol(data, dataIndex);
+            symbol.x = x;
+            symbol.y = y;
+            symbol.setZ(seriesModel.get('zlevel'), seriesModel.get('z'));
+            symbol.__temp = true;
+            data.setItemGraphicEl(dataIndex, symbol); // Stop scale animation
+
+            symbol.stopSymbolAnimation(true);
+            this.group.add(symbol);
+          }
+
+          symbol.highlight();
+        } else {
+          // Highlight whole series
+          ChartView.prototype.highlight.call(this, seriesModel, ecModel, api, payload);
+        }
+      };
+
+      LineView.prototype.downplay = function (seriesModel, ecModel, api, payload) {
+        var data = seriesModel.getData();
+        var dataIndex = queryDataIndex(data, payload);
+
+        this._changePolyState('normal');
+
+        if (dataIndex != null && dataIndex >= 0) {
+          var symbol = data.getItemGraphicEl(dataIndex);
+
+          if (symbol) {
+            if (symbol.__temp) {
+              data.setItemGraphicEl(dataIndex, null);
+              this.group.remove(symbol);
+            } else {
+              symbol.downplay();
+            }
+          }
+        } else {
+          // FIXME
+          // can not downplay completely.
+          // Downplay whole series
+          ChartView.prototype.downplay.call(this, seriesModel, ecModel, api, payload);
+        }
+      };
+
+      LineView.prototype._changePolyState = function (toState) {
+        var polygon = this._polygon;
+        setStatesFlag(this._polyline, toState);
+        polygon && setStatesFlag(polygon, toState);
+      };
+
+      LineView.prototype._newPolyline = function (points) {
+        var polyline = this._polyline; // Remove previous created polyline
+
+        if (polyline) {
+          this._lineGroup.remove(polyline);
+        }
+
+        polyline = new ECPolyline({
+          shape: {
+            points: points
+          },
+          segmentIgnoreThreshold: 2,
+          z2: 10
+        });
+
+        this._lineGroup.add(polyline);
+
+        this._polyline = polyline;
+        return polyline;
+      };
+
+      LineView.prototype._newPolygon = function (points, stackedOnPoints) {
+        var polygon = this._polygon; // Remove previous created polygon
+
+        if (polygon) {
+          this._lineGroup.remove(polygon);
+        }
+
+        polygon = new ECPolygon({
+          shape: {
+            points: points,
+            stackedOnPoints: stackedOnPoints
+          },
+          segmentIgnoreThreshold: 2
+        });
+
+        this._lineGroup.add(polygon);
+
+        this._polygon = polygon;
+        return polygon;
+      };
+
+      LineView.prototype._initSymbolLabelAnimation = function (data, coordSys, clipShape) {
+        var isHorizontalOrRadial;
+        var isCoordSysPolar;
+        var baseAxis = coordSys.getBaseAxis();
+        var isAxisInverse = baseAxis.inverse;
+
+        if (coordSys.type === 'cartesian2d') {
+          isHorizontalOrRadial = baseAxis.isHorizontal();
+          isCoordSysPolar = false;
+        } else if (coordSys.type === 'polar') {
+          isHorizontalOrRadial = baseAxis.dim === 'angle';
+          isCoordSysPolar = true;
+        }
+
+        var seriesModel = data.hostModel;
+        var seriesDuration = seriesModel.get('animationDuration');
+
+        if (typeof seriesDuration === 'function') {
+          seriesDuration = seriesDuration(null);
+        }
+
+        var seriesDalay = seriesModel.get('animationDelay') || 0;
+        var seriesDalayValue = typeof seriesDalay === 'function' ? seriesDalay(null) : seriesDalay;
+        data.eachItemGraphicEl(function (symbol, idx) {
+          var el = symbol;
+
+          if (el) {
+            var point = [symbol.x, symbol.y];
+            var start = void 0;
+            var end = void 0;
+            var current = void 0;
+
+            if (isCoordSysPolar) {
+              var polarClip = clipShape;
+              var coord = coordSys.pointToCoord(point);
+
+              if (isHorizontalOrRadial) {
+                start = polarClip.startAngle;
+                end = polarClip.endAngle;
+                current = -coord[1] / 180 * Math.PI;
+              } else {
+                start = polarClip.r0;
+                end = polarClip.r;
+                current = coord[0];
+              }
+            } else {
+              var gridClip = clipShape;
+
+              if (isHorizontalOrRadial) {
+                start = gridClip.x;
+                end = gridClip.x + gridClip.width;
+                current = symbol.x;
+              } else {
+                start = gridClip.y + gridClip.height;
+                end = gridClip.y;
+                current = symbol.y;
+              }
+            }
+
+            var ratio = end === start ? 0 : (current - start) / (end - start);
+
+            if (isAxisInverse) {
+              ratio = 1 - ratio;
+            }
+
+            var delay = typeof seriesDalay === 'function' ? seriesDalay(idx) : seriesDuration * ratio + seriesDalayValue;
+            var symbolPath = el.getSymbolPath();
+            var text = symbolPath.getTextContent();
+            el.attr({
+              scaleX: 0,
+              scaleY: 0
+            });
+            el.animateTo({
+              scaleX: 1,
+              scaleY: 1
+            }, {
+              duration: 200,
+              delay: delay
+            });
+
+            if (text) {
+              text.animateFrom({
+                style: {
+                  opacity: 0
+                }
+              }, {
+                duration: 300,
+                delay: delay
+              });
+            }
+
+            symbolPath.disableLabelAnimation = true;
+          }
+        });
+      };
+
+      LineView.prototype._initOrUpdateEndLabel = function (seriesModel, coordSys, inheritColor) {
+        var endLabelModel = seriesModel.getModel('endLabel');
+
+        if (endLabelModel.get('show')) {
+          var data_2 = seriesModel.getData();
+          var polyline = this._polyline;
+          var endLabel = this._endLabel;
+
+          if (!endLabel) {
+            endLabel = this._endLabel = new ZRText({
+              z2: 200 // should be higher than item symbol
+
+            });
+            endLabel.ignoreClip = true;
+            polyline.setTextContent(this._endLabel);
+            polyline.disableLabelAnimation = true;
+          } // Find last non-NaN data to display data
+
+
+          var dataIndex = getLastIndexNotNull(data_2.getLayout('points'));
+
+          if (dataIndex >= 0) {
+            setLabelStyle(polyline, getLabelStatesModels(seriesModel, 'endLabel'), {
+              inheritColor: inheritColor,
+              labelFetcher: seriesModel,
+              labelDataIndex: dataIndex,
+              defaultText: function (dataIndex, opt, interpolatedValue) {
+                return interpolatedValue != null ? getDefaultInterpolatedLabel(data_2, interpolatedValue) : getDefaultLabel(data_2, dataIndex);
+              },
+              enableTextSetter: true
+            }, getEndLabelStateSpecified(endLabelModel, coordSys));
+            polyline.textConfig.position = null;
+          }
+        } else if (this._endLabel) {
+          this._polyline.removeTextContent();
+
+          this._endLabel = null;
+        }
+      };
+
+      LineView.prototype._endLabelOnDuring = function (percent, clipRect, data, animationRecord, valueAnimation, endLabelModel, coordSys) {
+        var endLabel = this._endLabel;
+        var polyline = this._polyline;
+
+        if (endLabel) {
+          // NOTE: Don't remove percent < 1. percent === 1 means the first frame during render.
+          // The label is not prepared at this time.
+          if (percent < 1 && animationRecord.originalX == null) {
+            animationRecord.originalX = endLabel.x;
+            animationRecord.originalY = endLabel.y;
+          }
+
+          var points = data.getLayout('points');
+          var seriesModel = data.hostModel;
+          var connectNulls = seriesModel.get('connectNulls');
+          var precision = endLabelModel.get('precision');
+          var distance = endLabelModel.get('distance') || 0;
+          var baseAxis = coordSys.getBaseAxis();
+          var isHorizontal = baseAxis.isHorizontal();
+          var isBaseInversed = baseAxis.inverse;
+          var clipShape = clipRect.shape;
+          var xOrY = isBaseInversed ? isHorizontal ? clipShape.x : clipShape.y + clipShape.height : isHorizontal ? clipShape.x + clipShape.width : clipShape.y;
+          var distanceX = (isHorizontal ? distance : 0) * (isBaseInversed ? -1 : 1);
+          var distanceY = (isHorizontal ? 0 : -distance) * (isBaseInversed ? -1 : 1);
+          var dim = isHorizontal ? 'x' : 'y';
+          var dataIndexRange = getIndexRange(points, xOrY, dim);
+          var indices = dataIndexRange.range;
+          var diff = indices[1] - indices[0];
+          var value = void 0;
+
+          if (diff >= 1) {
+            // diff > 1 && connectNulls, which is on the null data.
+            if (diff > 1 && !connectNulls) {
+              var pt = getPointAtIndex(points, indices[0]);
+              endLabel.attr({
+                x: pt[0] + distanceX,
+                y: pt[1] + distanceY
+              });
+              valueAnimation && (value = seriesModel.getRawValue(indices[0]));
+            } else {
+              var pt = polyline.getPointOn(xOrY, dim);
+              pt && endLabel.attr({
+                x: pt[0] + distanceX,
+                y: pt[1] + distanceY
+              });
+              var startValue = seriesModel.getRawValue(indices[0]);
+              var endValue = seriesModel.getRawValue(indices[1]);
+              valueAnimation && (value = interpolateRawValues(data, precision, startValue, endValue, dataIndexRange.t));
+            }
+
+            animationRecord.lastFrameIndex = indices[0];
+          } else {
+            // If diff <= 0, which is the range is not found(Include NaN)
+            // Choose the first point or last point.
+            var idx = percent === 1 || animationRecord.lastFrameIndex > 0 ? indices[0] : 0;
+            var pt = getPointAtIndex(points, idx);
+            valueAnimation && (value = seriesModel.getRawValue(idx));
+            endLabel.attr({
+              x: pt[0] + distanceX,
+              y: pt[1] + distanceY
+            });
+          }
+
+          if (valueAnimation) {
+            labelInner(endLabel).setLabelText(value);
+          }
+        }
+      };
+      /**
+       * @private
+       */
+      // FIXME Two value axis
+
+
+      LineView.prototype._doUpdateAnimation = function (data, stackedOnPoints, coordSys, api, step, valueOrigin) {
+        var polyline = this._polyline;
+        var polygon = this._polygon;
+        var seriesModel = data.hostModel;
+        var diff = lineAnimationDiff(this._data, data, this._stackedOnPoints, stackedOnPoints, this._coordSys, coordSys, this._valueOrigin, valueOrigin);
+        var current = diff.current;
+        var stackedOnCurrent = diff.stackedOnCurrent;
+        var next = diff.next;
+        var stackedOnNext = diff.stackedOnNext;
+
+        if (step) {
+          // TODO If stacked series is not step
+          current = turnPointsIntoStep(diff.current, coordSys, step);
+          stackedOnCurrent = turnPointsIntoStep(diff.stackedOnCurrent, coordSys, step);
+          next = turnPointsIntoStep(diff.next, coordSys, step);
+          stackedOnNext = turnPointsIntoStep(diff.stackedOnNext, coordSys, step);
+        } // Don't apply animation if diff is large.
+        // For better result and avoid memory explosion problems like
+        // https://github.com/apache/incubator-echarts/issues/12229
+
+
+        if (getBoundingDiff(current, next) > 3000 || polygon && getBoundingDiff(stackedOnCurrent, stackedOnNext) > 3000) {
+          polyline.setShape({
+            points: next
+          });
+
+          if (polygon) {
+            polygon.setShape({
+              points: next,
+              stackedOnPoints: stackedOnNext
+            });
+          }
+
+          return;
+        }
+
+        polyline.shape.__points = diff.current;
+        polyline.shape.points = current;
+        var target = {
+          shape: {
+            points: next
+          }
+        }; // Also animate the original points.
+        // If points reference is changed when turning into step line.
+
+        if (diff.current !== current) {
+          target.shape.__points = diff.next;
+        } // Stop previous animation.
+
+
+        polyline.stopAnimation();
+        updateProps(polyline, target, seriesModel);
+
+        if (polygon) {
+          polygon.setShape({
+            // Reuse the points with polyline.
+            points: current,
+            stackedOnPoints: stackedOnCurrent
+          });
+          polygon.stopAnimation();
+          updateProps(polygon, {
+            shape: {
+              stackedOnPoints: stackedOnNext
+            }
+          }, seriesModel); // If use attr directly in updateProps.
+
+          if (polyline.shape.points !== polygon.shape.points) {
+            polygon.shape.points = polyline.shape.points;
+          }
+        }
+
+        var updatedDataInfo = [];
+        var diffStatus = diff.status;
+
+        for (var i = 0; i < diffStatus.length; i++) {
+          var cmd = diffStatus[i].cmd;
+
+          if (cmd === '=') {
+            var el = data.getItemGraphicEl(diffStatus[i].idx1);
+
+            if (el) {
+              updatedDataInfo.push({
+                el: el,
+                ptIdx: i // Index of points
+
+              });
+            }
+          }
+        }
+
+        if (polyline.animators && polyline.animators.length) {
+          polyline.animators[0].during(function () {
+            polygon && polygon.dirtyShape();
+            var points = polyline.shape.__points;
+
+            for (var i = 0; i < updatedDataInfo.length; i++) {
+              var el = updatedDataInfo[i].el;
+              var offset = updatedDataInfo[i].ptIdx * 2;
+              el.x = points[offset];
+              el.y = points[offset + 1];
+              el.markRedraw();
+            }
+          });
+        }
+      };
+
+      LineView.prototype.remove = function (ecModel) {
+        var group = this.group;
+        var oldData = this._data;
+
+        this._lineGroup.removeAll();
+
+        this._symbolDraw.remove(true); // Remove temporary created elements when highlighting
+
+
+        oldData && oldData.eachItemGraphicEl(function (el, idx) {
+          if (el.__temp) {
+            group.remove(el);
+            oldData.setItemGraphicEl(idx, null);
+          }
+        });
+        this._polyline = this._polygon = this._coordSys = this._points = this._stackedOnPoints = this._endLabel = this._data = null;
+      };
+
+      LineView.type = 'line';
+      return LineView;
+    }(ChartView);
+
+    function pointsLayout(seriesType, forceStoreInTypedArray) {
+      return {
+        seriesType: seriesType,
+        plan: createRenderPlanner(),
+        reset: function (seriesModel) {
+          var data = seriesModel.getData();
+          var coordSys = seriesModel.coordinateSystem;
+          var pipelineContext = seriesModel.pipelineContext;
+          var useTypedArray = forceStoreInTypedArray || pipelineContext.large;
+
+          if (!coordSys) {
+            return;
+          }
+
+          var dims = map(coordSys.dimensions, function (dim) {
+            return data.mapDimension(dim);
+          }).slice(0, 2);
+          var dimLen = dims.length;
+          var stackResultDim = data.getCalculationInfo('stackResultDimension');
+
+          if (isDimensionStacked(data, dims[0]
+          /*, dims[1]*/
+          )) {
+            dims[0] = stackResultDim;
+          }
+
+          if (isDimensionStacked(data, dims[1]
+          /*, dims[0]*/
+          )) {
+            dims[1] = stackResultDim;
+          }
+
+          var dimInfo0 = data.getDimensionInfo(dims[0]);
+          var dimInfo1 = data.getDimensionInfo(dims[1]);
+          var dimIdx0 = dimInfo0 && dimInfo0.index;
+          var dimIdx1 = dimInfo1 && dimInfo1.index;
+          return dimLen && {
+            progress: function (params, data) {
+              var segCount = params.end - params.start;
+              var points = useTypedArray && createFloat32Array(segCount * dimLen);
+              var tmpIn = [];
+              var tmpOut = [];
+
+              for (var i = params.start, offset = 0; i < params.end; i++) {
+                var point = void 0;
+
+                if (dimLen === 1) {
+                  var x = data.getByDimIdx(dimIdx0, i); // NOTE: Make sure the second parameter is null to use default strategy.
+
+                  point = coordSys.dataToPoint(x, null, tmpOut);
+                } else {
+                  tmpIn[0] = data.getByDimIdx(dimIdx0, i);
+                  tmpIn[1] = data.getByDimIdx(dimIdx1, i); // Let coordinate system to handle the NaN data.
+
+                  point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+                }
+
+                if (useTypedArray) {
+                  points[offset++] = point[0];
+                  points[offset++] = point[1];
+                } else {
+                  data.setItemLayout(i, point.slice());
+                }
+              }
+
+              useTypedArray && data.setLayout('points', points);
+            }
+          };
+        }
+      };
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var samplers = {
+      average: function (frame) {
+        var sum = 0;
+        var count = 0;
+
+        for (var i = 0; i < frame.length; i++) {
+          if (!isNaN(frame[i])) {
+            sum += frame[i];
+            count++;
+          }
+        } // Return NaN if count is 0
+
+
+        return count === 0 ? NaN : sum / count;
+      },
+      sum: function (frame) {
+        var sum = 0;
+
+        for (var i = 0; i < frame.length; i++) {
+          // Ignore NaN
+          sum += frame[i] || 0;
+        }
+
+        return sum;
+      },
+      max: function (frame) {
+        var max = -Infinity;
+
+        for (var i = 0; i < frame.length; i++) {
+          frame[i] > max && (max = frame[i]);
+        } // NaN will cause illegal axis extent.
+
+
+        return isFinite(max) ? max : NaN;
+      },
+      min: function (frame) {
+        var min = Infinity;
+
+        for (var i = 0; i < frame.length; i++) {
+          frame[i] < min && (min = frame[i]);
+        } // NaN will cause illegal axis extent.
+
+
+        return isFinite(min) ? min : NaN;
+      },
+      // TODO
+      // Median
+      nearest: function (frame) {
+        return frame[0];
+      }
+    };
+
+    var indexSampler = function (frame) {
+      return Math.round(frame.length / 2);
+    };
+
+    function dataSample(seriesType) {
+      return {
+        seriesType: seriesType,
+        // FIXME:TS never used, so comment it
+        // modifyOutputEnd: true,
+        reset: function (seriesModel, ecModel, api) {
+          var data = seriesModel.getData();
+          var sampling = seriesModel.get('sampling');
+          var coordSys = seriesModel.coordinateSystem;
+          var count = data.count(); // Only cartesian2d support down sampling. Disable it when there is few data.
+
+          if (count > 10 && coordSys.type === 'cartesian2d' && sampling) {
+            var baseAxis = coordSys.getBaseAxis();
+            var valueAxis = coordSys.getOtherAxis(baseAxis);
+            var extent = baseAxis.getExtent();
+            var dpr = api.getDevicePixelRatio(); // Coordinste system has been resized
+
+            var size = Math.abs(extent[1] - extent[0]) * (dpr || 1);
+            var rate = Math.round(count / size);
+
+            if (rate > 1) {
+              if (sampling === 'lttb') {
+                seriesModel.setData(data.lttbDownSample(data.mapDimension(valueAxis.dim), 1 / rate));
+              }
+
+              var sampler = void 0;
+
+              if (typeof sampling === 'string') {
+                sampler = samplers[sampling];
+              } else if (typeof sampling === 'function') {
+                sampler = sampling;
+              }
+
+              if (sampler) {
+                // Only support sample the first dim mapped from value axis.
+                seriesModel.setData(data.downSample(data.mapDimension(valueAxis.dim), 1 / rate, sampler, indexSampler));
+              }
+            }
+          }
+        }
+      };
+    }
+
+    function install$2(registers) {
+      registers.registerChartView(LineView);
+      registers.registerSeriesModel(LineSeriesModel);
+      registers.registerLayout(pointsLayout('line', true)); // Down sample after filter
+
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, dataSample('line'));
+    }
+
+    var BaseBarSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(BaseBarSeriesModel, _super);
+
+      function BaseBarSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BaseBarSeriesModel.type;
+        return _this;
+      }
+
+      BaseBarSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: true
+        });
+      };
+
+      BaseBarSeriesModel.prototype.getMarkerPosition = function (value) {
+        var coordSys = this.coordinateSystem;
+
+        if (coordSys) {
+          // PENDING if clamp ?
+          var pt = coordSys.dataToPoint(coordSys.clampData(value));
+          var data = this.getData();
+          var offset = data.getLayout('offset');
+          var size = data.getLayout('size');
+          var offsetIndex = coordSys.getBaseAxis().isHorizontal() ? 0 : 1;
+          pt[offsetIndex] += offset + size / 2;
+          return pt;
+        }
+
+        return [NaN, NaN];
+      };
+
+      BaseBarSeriesModel.type = 'series.__base_bar__';
+      BaseBarSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'cartesian2d',
+        legendHoverLink: true,
+        // stack: null
+        // Cartesian coordinate system
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        barMinHeight: 0,
+        barMinAngle: 0,
+        // cursor: null,
+        large: false,
+        largeThreshold: 400,
+        progressive: 3e3,
+        progressiveChunkMode: 'mod'
+      };
+      return BaseBarSeriesModel;
+    }(SeriesModel);
+
+    SeriesModel.registerClass(BaseBarSeriesModel);
+
+    var BarSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(BarSeriesModel, _super);
+
+      function BarSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BarSeriesModel.type;
+        return _this;
+      }
+
+      BarSeriesModel.prototype.getInitialData = function () {
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: true,
+          createInvertedIndices: !!this.get('realtimeSort', true) || null
+        });
+      };
+      /**
+       * @override
+       */
+
+
+      BarSeriesModel.prototype.getProgressive = function () {
+        // Do not support progressive in normal mode.
+        return this.get('large') ? this.get('progressive') : false;
+      };
+      /**
+       * @override
+       */
+
+
+      BarSeriesModel.prototype.getProgressiveThreshold = function () {
+        // Do not support progressive in normal mode.
+        var progressiveThreshold = this.get('progressiveThreshold');
+        var largeThreshold = this.get('largeThreshold');
+
+        if (largeThreshold > progressiveThreshold) {
+          progressiveThreshold = largeThreshold;
+        }
+
+        return progressiveThreshold;
+      };
+
+      BarSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+        return selectors.rect(data.getItemLayout(dataIndex));
+      };
+
+      BarSeriesModel.type = 'series.bar';
+      BarSeriesModel.dependencies = ['grid', 'polar'];
+      BarSeriesModel.defaultOption = inheritDefaultOption(BaseBarSeriesModel.defaultOption, {
+        // If clipped
+        // Only available on cartesian2d
+        clip: true,
+        roundCap: false,
+        showBackground: false,
+        backgroundStyle: {
+          color: 'rgba(180, 180, 180, 0.2)',
+          borderColor: null,
+          borderWidth: 0,
+          borderType: 'solid',
+          borderRadius: 0,
+          shadowBlur: 0,
+          shadowColor: null,
+          shadowOffsetX: 0,
+          shadowOffsetY: 0,
+          opacity: 1
+        },
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        },
+        realtimeSort: false
+      });
+      return BarSeriesModel;
+    }(BaseBarSeriesModel);
+
+    /**
+     * Sausage: similar to sector, but have half circle on both sides
+     */
+
+    var SausageShape =
+    /** @class */
+    function () {
+      function SausageShape() {
+        this.cx = 0;
+        this.cy = 0;
+        this.r0 = 0;
+        this.r = 0;
+        this.startAngle = 0;
+        this.endAngle = Math.PI * 2;
+        this.clockwise = true;
+      }
+
+      return SausageShape;
+    }();
+
+    var SausagePath =
+    /** @class */
+    function (_super) {
+      __extends(SausagePath, _super);
+
+      function SausagePath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'sausage';
+        return _this;
+      }
+
+      SausagePath.prototype.getDefaultShape = function () {
+        return new SausageShape();
+      };
+
+      SausagePath.prototype.buildPath = function (ctx, shape) {
+        var x = shape.cx;
+        var y = shape.cy;
+        var r0 = Math.max(shape.r0 || 0, 0);
+        var r = Math.max(shape.r, 0);
+        var dr = (r - r0) * 0.5;
+        var rCenter = r0 + dr;
+        var startAngle = shape.startAngle;
+        var endAngle = shape.endAngle;
+        var clockwise = shape.clockwise;
+        var unitStartX = Math.cos(startAngle);
+        var unitStartY = Math.sin(startAngle);
+        var unitEndX = Math.cos(endAngle);
+        var unitEndY = Math.sin(endAngle);
+        var lessThanCircle = clockwise ? endAngle - startAngle < Math.PI * 2 : startAngle - endAngle < Math.PI * 2;
+
+        if (lessThanCircle) {
+          ctx.moveTo(unitStartX * r0 + x, unitStartY * r0 + y);
+          ctx.arc(unitStartX * rCenter + x, unitStartY * rCenter + y, dr, -Math.PI + startAngle, startAngle, !clockwise);
+        }
+
+        ctx.arc(x, y, r, startAngle, endAngle, !clockwise);
+        ctx.moveTo(unitEndX * r + x, unitEndY * r + y);
+        ctx.arc(unitEndX * rCenter + x, unitEndY * rCenter + y, dr, endAngle - Math.PI * 2, endAngle - Math.PI, !clockwise);
+
+        if (r0 !== 0) {
+          ctx.arc(x, y, r0, endAngle, startAngle, clockwise);
+          ctx.moveTo(unitStartX * r0 + x, unitEndY * r0 + y);
+        }
+
+        ctx.closePath();
+      };
+
+      return SausagePath;
+    }(Path);
+
+    var BAR_BORDER_WIDTH_QUERY = ['itemStyle', 'borderWidth'];
+    var BAR_BORDER_RADIUS_QUERY = ['itemStyle', 'borderRadius'];
+    var _eventPos = [0, 0];
+    var mathMax$6 = Math.max;
+    var mathMin$6 = Math.min;
+
+    function getClipArea(coord, data) {
+      var coordSysClipArea = coord.getArea && coord.getArea();
+
+      if (isCoordinateSystemType(coord, 'cartesian2d')) {
+        var baseAxis = coord.getBaseAxis(); // When boundaryGap is false or using time axis. bar may exceed the grid.
+        // We should not clip this part.
+        // See test/bar2.html
+
+        if (baseAxis.type !== 'category' || !baseAxis.onBand) {
+          var expandWidth = data.getLayout('bandWidth');
+
+          if (baseAxis.isHorizontal()) {
+            coordSysClipArea.x -= expandWidth;
+            coordSysClipArea.width += expandWidth * 2;
+          } else {
+            coordSysClipArea.y -= expandWidth;
+            coordSysClipArea.height += expandWidth * 2;
+          }
+        }
+      }
+
+      return coordSysClipArea;
+    }
+
+    var BarView =
+    /** @class */
+    function (_super) {
+      __extends(BarView, _super);
+
+      function BarView() {
+        var _this = _super.call(this) || this;
+
+        _this.type = BarView.type;
+        _this._isFirstFrame = true;
+        return _this;
+      }
+
+      BarView.prototype.render = function (seriesModel, ecModel, api, payload) {
+        this._model = seriesModel;
+
+        this._removeOnRenderedListener(api);
+
+        this._updateDrawMode(seriesModel);
+
+        var coordinateSystemType = seriesModel.get('coordinateSystem');
+
+        if (coordinateSystemType === 'cartesian2d' || coordinateSystemType === 'polar') {
+          this._isLargeDraw ? this._renderLarge(seriesModel, ecModel, api) : this._renderNormal(seriesModel, ecModel, api, payload);
+        } else if ("development" !== 'production') {
+          warn('Only cartesian2d and polar supported for bar.');
+        }
+      };
+
+      BarView.prototype.incrementalPrepareRender = function (seriesModel) {
+        this._clear();
+
+        this._updateDrawMode(seriesModel); // incremental also need to clip, otherwise might be overlow.
+        // But must not set clip in each frame, otherwise all of the children will be marked redraw.
+
+
+        this._updateLargeClip(seriesModel);
+      };
+
+      BarView.prototype.incrementalRender = function (params, seriesModel) {
+        // Do not support progressive in normal mode.
+        this._incrementalRenderLarge(params, seriesModel);
+      };
+
+      BarView.prototype._updateDrawMode = function (seriesModel) {
+        var isLargeDraw = seriesModel.pipelineContext.large;
+
+        if (this._isLargeDraw == null || isLargeDraw !== this._isLargeDraw) {
+          this._isLargeDraw = isLargeDraw;
+
+          this._clear();
+        }
+      };
+
+      BarView.prototype._renderNormal = function (seriesModel, ecModel, api, payload) {
+        var group = this.group;
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var coord = seriesModel.coordinateSystem;
+        var baseAxis = coord.getBaseAxis();
+        var isHorizontalOrRadial;
+
+        if (coord.type === 'cartesian2d') {
+          isHorizontalOrRadial = baseAxis.isHorizontal();
+        } else if (coord.type === 'polar') {
+          isHorizontalOrRadial = baseAxis.dim === 'angle';
+        }
+
+        var animationModel = seriesModel.isAnimationEnabled() ? seriesModel : null;
+        var realtimeSortCfg = shouldRealtimeSort(seriesModel, coord);
+
+        if (realtimeSortCfg) {
+          this._enableRealtimeSort(realtimeSortCfg, data, api);
+        }
+
+        var needsClip = seriesModel.get('clip', true) || realtimeSortCfg;
+        var coordSysClipArea = getClipArea(coord, data); // If there is clipPath created in large mode. Remove it.
+
+        group.removeClipPath(); // We don't use clipPath in normal mode because we needs a perfect animation
+        // And don't want the label are clipped.
+
+        var roundCap = seriesModel.get('roundCap', true);
+        var drawBackground = seriesModel.get('showBackground', true);
+        var backgroundModel = seriesModel.getModel('backgroundStyle');
+        var barBorderRadius = backgroundModel.get('borderRadius') || 0;
+        var bgEls = [];
+        var oldBgEls = this._backgroundEls;
+        var isInitSort = payload && payload.isInitSort;
+        var isChangeOrder = payload && payload.type === 'changeAxisOrder';
+
+        function createBackground(dataIndex) {
+          var bgLayout = getLayout[coord.type](data, dataIndex);
+          var bgEl = createBackgroundEl(coord, isHorizontalOrRadial, bgLayout);
+          bgEl.useStyle(backgroundModel.getItemStyle()); // Only cartesian2d support borderRadius.
+
+          if (coord.type === 'cartesian2d') {
+            bgEl.setShape('r', barBorderRadius);
+          }
+
+          bgEls[dataIndex] = bgEl;
+          return bgEl;
+        }
+        data.diff(oldData).add(function (dataIndex) {
+          var itemModel = data.getItemModel(dataIndex);
+          var layout = getLayout[coord.type](data, dataIndex, itemModel);
+
+          if (drawBackground) {
+            createBackground(dataIndex);
+          } // If dataZoom in filteMode: 'empty', the baseValue can be set as NaN in "axisProxy".
+
+
+          if (!data.hasValue(dataIndex)) {
+            return;
+          }
+
+          var isClipped = false;
+
+          if (needsClip) {
+            // Clip will modify the layout params.
+            // And return a boolean to determine if the shape are fully clipped.
+            isClipped = clip[coord.type](coordSysClipArea, layout);
+          }
+
+          var el = elementCreator[coord.type](seriesModel, data, dataIndex, layout, isHorizontalOrRadial, animationModel, baseAxis.model, false, roundCap);
+          updateStyle(el, data, dataIndex, itemModel, layout, seriesModel, isHorizontalOrRadial, coord.type === 'polar');
+
+          if (isInitSort) {
+            el.attr({
+              shape: layout
+            });
+          } else if (realtimeSortCfg) {
+            updateRealtimeAnimation(realtimeSortCfg, animationModel, el, layout, dataIndex, isHorizontalOrRadial, false, false);
+          } else {
+            initProps(el, {
+              shape: layout
+            }, seriesModel, dataIndex);
+          }
+
+          data.setItemGraphicEl(dataIndex, el);
+          group.add(el);
+          el.ignore = isClipped;
+        }).update(function (newIndex, oldIndex) {
+          var itemModel = data.getItemModel(newIndex);
+          var layout = getLayout[coord.type](data, newIndex, itemModel);
+
+          if (drawBackground) {
+            var bgEl = void 0;
+
+            if (oldBgEls.length === 0) {
+              bgEl = createBackground(oldIndex);
+            } else {
+              bgEl = oldBgEls[oldIndex];
+              bgEl.useStyle(backgroundModel.getItemStyle()); // Only cartesian2d support borderRadius.
+
+              if (coord.type === 'cartesian2d') {
+                bgEl.setShape('r', barBorderRadius);
+              }
+
+              bgEls[newIndex] = bgEl;
+            }
+
+            var bgLayout = getLayout[coord.type](data, newIndex);
+            var shape = createBackgroundShape(isHorizontalOrRadial, bgLayout, coord);
+            updateProps(bgEl, {
+              shape: shape
+            }, animationModel, newIndex);
+          }
+
+          var el = oldData.getItemGraphicEl(oldIndex);
+
+          if (!data.hasValue(newIndex)) {
+            group.remove(el);
+            el = null;
+            return;
+          }
+
+          var isClipped = false;
+
+          if (needsClip) {
+            isClipped = clip[coord.type](coordSysClipArea, layout);
+
+            if (isClipped) {
+              group.remove(el);
+            }
+          }
+
+          if (!el) {
+            el = elementCreator[coord.type](seriesModel, data, newIndex, layout, isHorizontalOrRadial, animationModel, baseAxis.model, !!el, roundCap);
+          } // Not change anything if only order changed.
+          // Especially not change label.
+
+
+          if (!isChangeOrder) {
+            updateStyle(el, data, newIndex, itemModel, layout, seriesModel, isHorizontalOrRadial, coord.type === 'polar');
+          }
+
+          if (isInitSort) {
+            el.attr({
+              shape: layout
+            });
+          } else if (realtimeSortCfg) {
+            updateRealtimeAnimation(realtimeSortCfg, animationModel, el, layout, newIndex, isHorizontalOrRadial, true, isChangeOrder);
+          } else {
+            updateProps(el, {
+              shape: layout
+            }, seriesModel, newIndex, null);
+          }
+
+          data.setItemGraphicEl(newIndex, el);
+          el.ignore = isClipped;
+          group.add(el);
+        }).remove(function (dataIndex) {
+          var el = oldData.getItemGraphicEl(dataIndex);
+          el && removeElementWithFadeOut(el, seriesModel, dataIndex);
+        }).execute();
+        var bgGroup = this._backgroundGroup || (this._backgroundGroup = new Group());
+        bgGroup.removeAll();
+
+        for (var i = 0; i < bgEls.length; ++i) {
+          bgGroup.add(bgEls[i]);
+        }
+
+        group.add(bgGroup);
+        this._backgroundEls = bgEls;
+        this._data = data;
+      };
+
+      BarView.prototype._renderLarge = function (seriesModel, ecModel, api) {
+        this._clear();
+
+        createLarge(seriesModel, this.group);
+
+        this._updateLargeClip(seriesModel);
+      };
+
+      BarView.prototype._incrementalRenderLarge = function (params, seriesModel) {
+        this._removeBackground();
+
+        createLarge(seriesModel, this.group, true);
+      };
+
+      BarView.prototype._updateLargeClip = function (seriesModel) {
+        // Use clipPath in large mode.
+        var clipPath = seriesModel.get('clip', true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+
+        if (clipPath) {
+          this.group.setClipPath(clipPath);
+        } else {
+          this.group.removeClipPath();
+        }
+      };
+
+      BarView.prototype._enableRealtimeSort = function (realtimeSortCfg, data, api) {
+        var _this = this; // If no data in the first frame, wait for data to initSort
+
+
+        if (!data.count()) {
+          return;
+        }
+
+        var baseAxis = realtimeSortCfg.baseAxis;
+
+        if (this._isFirstFrame) {
+          this._dispatchInitSort(data, realtimeSortCfg, api);
+
+          this._isFirstFrame = false;
+        } else {
+          var orderMapping_1 = function (idx) {
+            var el = data.getItemGraphicEl(idx);
+
+            if (el) {
+              var shape = el.shape; // If data is NaN, shape.xxx may be NaN, so use || 0 here in case
+
+              return (baseAxis.isHorizontal() // The result should be consistent with the initial sort by data value.
+              // Do not support the case that both positive and negative exist.
+              ? Math.abs(shape.height) : Math.abs(shape.width)) || 0;
+            } else {
+              return 0;
+            }
+          };
+
+          this._onRendered = function () {
+            _this._updateSortWithinSameData(data, orderMapping_1, baseAxis, api);
+          };
+
+          api.getZr().on('rendered', this._onRendered);
+        }
+      };
+
+      BarView.prototype._dataSort = function (data, baseAxis, orderMapping) {
+        var info = [];
+        data.each(data.mapDimension(baseAxis.dim), function (ordinalNumber, dataIdx) {
+          var mappedValue = orderMapping(dataIdx);
+          mappedValue = mappedValue == null ? NaN : mappedValue;
+          info.push({
+            dataIndex: dataIdx,
+            mappedValue: mappedValue,
+            ordinalNumber: ordinalNumber
+          });
+        });
+        info.sort(function (a, b) {
+          // If NaN, it will be treated as min val.
+          return b.mappedValue - a.mappedValue;
+        });
+        return {
+          ordinalNumbers: map(info, function (item) {
+            return item.ordinalNumber;
+          })
+        };
+      };
+
+      BarView.prototype._isOrderChangedWithinSameData = function (data, orderMapping, baseAxis) {
+        var scale = baseAxis.scale;
+        var ordinalDataDim = data.mapDimension(baseAxis.dim);
+        var lastValue = Number.MAX_VALUE;
+
+        for (var tickNum = 0, len = scale.getOrdinalMeta().categories.length; tickNum < len; ++tickNum) {
+          var rawIdx = data.rawIndexOf(ordinalDataDim, scale.getRawOrdinalNumber(tickNum));
+          var value = rawIdx < 0 // If some tick have no bar, the tick will be treated as min.
+          ? Number.MIN_VALUE // PENDING: if dataZoom on baseAxis exits, is it a performance issue?
+          : orderMapping(data.indexOfRawIndex(rawIdx));
+
+          if (value > lastValue) {
+            return true;
+          }
+
+          lastValue = value;
+        }
+
+        return false;
+      };
+      /*
+       * Consider the case when A and B changed order, whose representing
+       * bars are both out of sight, we don't wish to trigger reorder action
+       * as long as the order in the view doesn't change.
+       */
+
+
+      BarView.prototype._isOrderDifferentInView = function (orderInfo, baseAxis) {
+        var scale = baseAxis.scale;
+        var extent = scale.getExtent();
+        var tickNum = Math.max(0, extent[0]);
+        var tickMax = Math.min(extent[1], scale.getOrdinalMeta().categories.length - 1);
+
+        for (; tickNum <= tickMax; ++tickNum) {
+          if (orderInfo.ordinalNumbers[tickNum] !== scale.getRawOrdinalNumber(tickNum)) {
+            return true;
+          }
+        }
+      };
+
+      BarView.prototype._updateSortWithinSameData = function (data, orderMapping, baseAxis, api) {
+        if (!this._isOrderChangedWithinSameData(data, orderMapping, baseAxis)) {
+          return;
+        }
+
+        var sortInfo = this._dataSort(data, baseAxis, orderMapping);
+
+        if (this._isOrderDifferentInView(sortInfo, baseAxis)) {
+          this._removeOnRenderedListener(api);
+
+          api.dispatchAction({
+            type: 'changeAxisOrder',
+            componentType: baseAxis.dim + 'Axis',
+            axisId: baseAxis.index,
+            sortInfo: sortInfo
+          });
+        }
+      };
+
+      BarView.prototype._dispatchInitSort = function (data, realtimeSortCfg, api) {
+        var baseAxis = realtimeSortCfg.baseAxis;
+
+        var sortResult = this._dataSort(data, baseAxis, function (dataIdx) {
+          return data.get(data.mapDimension(realtimeSortCfg.otherAxis.dim), dataIdx);
+        });
+
+        api.dispatchAction({
+          type: 'changeAxisOrder',
+          componentType: baseAxis.dim + 'Axis',
+          isInitSort: true,
+          axisId: baseAxis.index,
+          sortInfo: sortResult,
+          animation: {
+            // Update the axis label from the natural initial layout to
+            // sorted layout should has no animation.
+            duration: 0
+          }
+        });
+      };
+
+      BarView.prototype.remove = function (ecModel, api) {
+        this._clear(this._model);
+
+        this._removeOnRenderedListener(api);
+      };
+
+      BarView.prototype.dispose = function (ecModel, api) {
+        this._removeOnRenderedListener(api);
+      };
+
+      BarView.prototype._removeOnRenderedListener = function (api) {
+        if (this._onRendered) {
+          api.getZr().off('rendered', this._onRendered);
+          this._onRendered = null;
+        }
+      };
+
+      BarView.prototype._clear = function (model) {
+        var group = this.group;
+        var data = this._data;
+
+        if (model && model.isAnimationEnabled() && data && !this._isLargeDraw) {
+          this._removeBackground();
+
+          this._backgroundEls = [];
+          data.eachItemGraphicEl(function (el) {
+            removeElementWithFadeOut(el, model, getECData(el).dataIndex);
+          });
+        } else {
+          group.removeAll();
+        }
+
+        this._data = null;
+        this._isFirstFrame = true;
+      };
+
+      BarView.prototype._removeBackground = function () {
+        this.group.remove(this._backgroundGroup);
+        this._backgroundGroup = null;
+      };
+
+      BarView.type = 'bar';
+      return BarView;
+    }(ChartView);
+
+    var clip = {
+      cartesian2d: function (coordSysBoundingRect, layout) {
+        var signWidth = layout.width < 0 ? -1 : 1;
+        var signHeight = layout.height < 0 ? -1 : 1; // Needs positive width and height
+
+        if (signWidth < 0) {
+          layout.x += layout.width;
+          layout.width = -layout.width;
+        }
+
+        if (signHeight < 0) {
+          layout.y += layout.height;
+          layout.height = -layout.height;
+        }
+
+        var coordSysX2 = coordSysBoundingRect.x + coordSysBoundingRect.width;
+        var coordSysY2 = coordSysBoundingRect.y + coordSysBoundingRect.height;
+        var x = mathMax$6(layout.x, coordSysBoundingRect.x);
+        var x2 = mathMin$6(layout.x + layout.width, coordSysX2);
+        var y = mathMax$6(layout.y, coordSysBoundingRect.y);
+        var y2 = mathMin$6(layout.y + layout.height, coordSysY2);
+        var xClipped = x2 < x;
+        var yClipped = y2 < y; // When xClipped or yClipped, the element will be marked as `ignore`.
+        // But we should also place the element at the edge of the coord sys bounding rect.
+        // Beause if data changed and the bar show again, its transition animaiton
+        // will begin at this place.
+
+        layout.x = xClipped && x > coordSysX2 ? x2 : x;
+        layout.y = yClipped && y > coordSysY2 ? y2 : y;
+        layout.width = xClipped ? 0 : x2 - x;
+        layout.height = yClipped ? 0 : y2 - y; // Reverse back
+
+        if (signWidth < 0) {
+          layout.x += layout.width;
+          layout.width = -layout.width;
+        }
+
+        if (signHeight < 0) {
+          layout.y += layout.height;
+          layout.height = -layout.height;
+        }
+
+        return xClipped || yClipped;
+      },
+      polar: function (coordSysClipArea, layout) {
+        var signR = layout.r0 <= layout.r ? 1 : -1; // Make sure r is larger than r0
+
+        if (signR < 0) {
+          var tmp = layout.r;
+          layout.r = layout.r0;
+          layout.r0 = tmp;
+        }
+
+        var r = mathMin$6(layout.r, coordSysClipArea.r);
+        var r0 = mathMax$6(layout.r0, coordSysClipArea.r0);
+        layout.r = r;
+        layout.r0 = r0;
+        var clipped = r - r0 < 0; // Reverse back
+
+        if (signR < 0) {
+          var tmp = layout.r;
+          layout.r = layout.r0;
+          layout.r0 = tmp;
+        }
+
+        return clipped;
+      }
+    };
+    var elementCreator = {
+      cartesian2d: function (seriesModel, data, newIndex, layout, isHorizontal, animationModel, axisModel, isUpdate, roundCap) {
+        var rect = new Rect({
+          shape: extend({}, layout),
+          z2: 1
+        });
+        rect.__dataIndex = newIndex;
+        rect.name = 'item';
+
+        if (animationModel) {
+          var rectShape = rect.shape;
+          var animateProperty = isHorizontal ? 'height' : 'width';
+          rectShape[animateProperty] = 0;
+        }
+
+        return rect;
+      },
+      polar: function (seriesModel, data, newIndex, layout, isRadial, animationModel, axisModel, isUpdate, roundCap) {
+        // Keep the same logic with bar in catesion: use end value to control
+        // direction. Notice that if clockwise is true (by default), the sector
+        // will always draw clockwisely, no matter whether endAngle is greater
+        // or less than startAngle.
+        var clockwise = layout.startAngle < layout.endAngle;
+        var ShapeClass = !isRadial && roundCap ? SausagePath : Sector;
+        var sector = new ShapeClass({
+          shape: defaults({
+            clockwise: clockwise
+          }, layout),
+          z2: 1
+        });
+        sector.name = 'item'; // Animation
+
+        if (animationModel) {
+          var sectorShape = sector.shape;
+          var animateProperty = isRadial ? 'r' : 'endAngle';
+          var animateTarget = {};
+          sectorShape[animateProperty] = isRadial ? 0 : layout.startAngle;
+          animateTarget[animateProperty] = layout[animateProperty];
+          (isUpdate ? updateProps : initProps)(sector, {
+            shape: animateTarget // __value: typeof dataValue === 'string' ? parseInt(dataValue, 10) : dataValue
+
+          }, animationModel);
+        }
+
+        return sector;
+      }
+    };
+
+    function shouldRealtimeSort(seriesModel, coordSys) {
+      var realtimeSortOption = seriesModel.get('realtimeSort', true);
+      var baseAxis = coordSys.getBaseAxis();
+
+      if ("development" !== 'production') {
+        if (realtimeSortOption) {
+          if (baseAxis.type !== 'category') {
+            warn('`realtimeSort` will not work because this bar series is not based on a category axis.');
+          }
+
+          if (coordSys.type !== 'cartesian2d') {
+            warn('`realtimeSort` will not work because this bar series is not on cartesian2d.');
+          }
+        }
+      }
+
+      if (realtimeSortOption && baseAxis.type === 'category' && coordSys.type === 'cartesian2d') {
+        return {
+          baseAxis: baseAxis,
+          otherAxis: coordSys.getOtherAxis(baseAxis)
+        };
+      }
+    }
+
+    function updateRealtimeAnimation(realtimeSortCfg, seriesAnimationModel, el, layout, newIndex, isHorizontal, isUpdate, isChangeOrder) {
+      var seriesTarget;
+      var axisTarget;
+
+      if (isHorizontal) {
+        axisTarget = {
+          x: layout.x,
+          width: layout.width
+        };
+        seriesTarget = {
+          y: layout.y,
+          height: layout.height
+        };
+      } else {
+        axisTarget = {
+          y: layout.y,
+          height: layout.height
+        };
+        seriesTarget = {
+          x: layout.x,
+          width: layout.width
+        };
+      }
+
+      if (!isChangeOrder) {
+        // Keep the original growth animation if only axis order changed.
+        // Not start a new animation.
+        (isUpdate ? updateProps : initProps)(el, {
+          shape: seriesTarget
+        }, seriesAnimationModel, newIndex, null);
+      }
+
+      var axisAnimationModel = seriesAnimationModel ? realtimeSortCfg.baseAxis.model : null;
+      (isUpdate ? updateProps : initProps)(el, {
+        shape: axisTarget
+      }, axisAnimationModel, newIndex);
+    }
+
+    var getLayout = {
+      // itemModel is only used to get borderWidth, which is not needed
+      // when calculating bar background layout.
+      cartesian2d: function (data, dataIndex, itemModel) {
+        var layout = data.getItemLayout(dataIndex);
+        var fixedLineWidth = itemModel ? getLineWidth(itemModel, layout) : 0; // fix layout with lineWidth
+
+        var signX = layout.width > 0 ? 1 : -1;
+        var signY = layout.height > 0 ? 1 : -1;
+        return {
+          x: layout.x + signX * fixedLineWidth / 2,
+          y: layout.y + signY * fixedLineWidth / 2,
+          width: layout.width - signX * fixedLineWidth,
+          height: layout.height - signY * fixedLineWidth
+        };
+      },
+      polar: function (data, dataIndex, itemModel) {
+        var layout = data.getItemLayout(dataIndex);
+        return {
+          cx: layout.cx,
+          cy: layout.cy,
+          r0: layout.r0,
+          r: layout.r,
+          startAngle: layout.startAngle,
+          endAngle: layout.endAngle
+        };
+      }
+    };
+
+    function isZeroOnPolar(layout) {
+      return layout.startAngle != null && layout.endAngle != null && layout.startAngle === layout.endAngle;
+    }
+
+    function updateStyle(el, data, dataIndex, itemModel, layout, seriesModel, isHorizontal, isPolar) {
+      var style = data.getItemVisual(dataIndex, 'style');
+
+      if (!isPolar) {
+        el.setShape('r', itemModel.get(BAR_BORDER_RADIUS_QUERY) || 0);
+      }
+
+      el.useStyle(style);
+      var cursorStyle = itemModel.getShallow('cursor');
+      cursorStyle && el.attr('cursor', cursorStyle);
+
+      if (!isPolar) {
+        var labelPositionOutside = isHorizontal ? layout.height > 0 ? 'bottom' : 'top' : layout.width > 0 ? 'left' : 'right';
+        var labelStatesModels = getLabelStatesModels(itemModel);
+        setLabelStyle(el, labelStatesModels, {
+          labelFetcher: seriesModel,
+          labelDataIndex: dataIndex,
+          defaultText: getDefaultLabel(seriesModel.getData(), dataIndex),
+          inheritColor: style.fill,
+          defaultOpacity: style.opacity,
+          defaultOutsidePosition: labelPositionOutside
+        });
+        var label = el.getTextContent();
+        setLabelValueAnimation(label, labelStatesModels, seriesModel.getRawValue(dataIndex), function (value) {
+          return getDefaultInterpolatedLabel(data, value);
+        });
+      }
+
+      var emphasisModel = itemModel.getModel(['emphasis']);
+      enableHoverEmphasis(el, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+      setStatesStylesFromModel(el, itemModel);
+
+      if (isZeroOnPolar(layout)) {
+        el.style.fill = 'none';
+        el.style.stroke = 'none';
+        each(el.states, function (state) {
+          if (state.style) {
+            state.style.fill = state.style.stroke = 'none';
+          }
+        });
+      }
+    } // In case width or height are too small.
+
+
+    function getLineWidth(itemModel, rawLayout) {
+      var lineWidth = itemModel.get(BAR_BORDER_WIDTH_QUERY) || 0; // width or height may be NaN for empty data
+
+      var width = isNaN(rawLayout.width) ? Number.MAX_VALUE : Math.abs(rawLayout.width);
+      var height = isNaN(rawLayout.height) ? Number.MAX_VALUE : Math.abs(rawLayout.height);
+      return Math.min(lineWidth, width, height);
+    }
+
+    var LagePathShape =
+    /** @class */
+    function () {
+      function LagePathShape() {}
+
+      return LagePathShape;
+    }();
+
+    var LargePath =
+    /** @class */
+    function (_super) {
+      __extends(LargePath, _super);
+
+      function LargePath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'largeBar';
+        return _this;
+      }
+
+      LargePath.prototype.getDefaultShape = function () {
+        return new LagePathShape();
+      };
+
+      LargePath.prototype.buildPath = function (ctx, shape) {
+        // Drawing lines is more efficient than drawing
+        // a whole line or drawing rects.
+        var points = shape.points;
+        var startPoint = this.__startPoint;
+        var baseDimIdx = this.__baseDimIdx;
+
+        for (var i = 0; i < points.length; i += 2) {
+          startPoint[baseDimIdx] = points[i + baseDimIdx];
+          ctx.moveTo(startPoint[0], startPoint[1]);
+          ctx.lineTo(points[i], points[i + 1]);
+        }
+      };
+
+      return LargePath;
+    }(Path);
+
+    function createLarge(seriesModel, group, incremental) {
+      // TODO support polar
+      var data = seriesModel.getData();
+      var startPoint = [];
+      var baseDimIdx = data.getLayout('valueAxisHorizontal') ? 1 : 0;
+      startPoint[1 - baseDimIdx] = data.getLayout('valueAxisStart');
+      var largeDataIndices = data.getLayout('largeDataIndices');
+      var barWidth = data.getLayout('barWidth');
+      var backgroundModel = seriesModel.getModel('backgroundStyle');
+      var drawBackground = seriesModel.get('showBackground', true);
+
+      if (drawBackground) {
+        var points = data.getLayout('largeBackgroundPoints');
+        var backgroundStartPoint = [];
+        backgroundStartPoint[1 - baseDimIdx] = data.getLayout('backgroundStart');
+        var bgEl = new LargePath({
+          shape: {
+            points: points
+          },
+          incremental: !!incremental,
+          silent: true,
+          z2: 0
+        });
+        bgEl.__startPoint = backgroundStartPoint;
+        bgEl.__baseDimIdx = baseDimIdx;
+        bgEl.__largeDataIndices = largeDataIndices;
+        bgEl.__barWidth = barWidth;
+        setLargeBackgroundStyle(bgEl, backgroundModel, data);
+        group.add(bgEl);
+      }
+
+      var el = new LargePath({
+        shape: {
+          points: data.getLayout('largePoints')
+        },
+        incremental: !!incremental
+      });
+      el.__startPoint = startPoint;
+      el.__baseDimIdx = baseDimIdx;
+      el.__largeDataIndices = largeDataIndices;
+      el.__barWidth = barWidth;
+      group.add(el);
+      setLargeStyle(el, seriesModel, data); // Enable tooltip and user mouse/touch event handlers.
+
+      getECData(el).seriesIndex = seriesModel.seriesIndex;
+
+      if (!seriesModel.get('silent')) {
+        el.on('mousedown', largePathUpdateDataIndex);
+        el.on('mousemove', largePathUpdateDataIndex);
+      }
+    } // Use throttle to avoid frequently traverse to find dataIndex.
+
+
+    var largePathUpdateDataIndex = throttle(function (event) {
+      var largePath = this;
+      var dataIndex = largePathFindDataIndex(largePath, event.offsetX, event.offsetY);
+      getECData(largePath).dataIndex = dataIndex >= 0 ? dataIndex : null;
+    }, 30, false);
+
+    function largePathFindDataIndex(largePath, x, y) {
+      var baseDimIdx = largePath.__baseDimIdx;
+      var valueDimIdx = 1 - baseDimIdx;
+      var points = largePath.shape.points;
+      var largeDataIndices = largePath.__largeDataIndices;
+      var barWidthHalf = Math.abs(largePath.__barWidth / 2);
+      var startValueVal = largePath.__startPoint[valueDimIdx];
+      _eventPos[0] = x;
+      _eventPos[1] = y;
+      var pointerBaseVal = _eventPos[baseDimIdx];
+      var pointerValueVal = _eventPos[1 - baseDimIdx];
+      var baseLowerBound = pointerBaseVal - barWidthHalf;
+      var baseUpperBound = pointerBaseVal + barWidthHalf;
+
+      for (var i = 0, len = points.length / 2; i < len; i++) {
+        var ii = i * 2;
+        var barBaseVal = points[ii + baseDimIdx];
+        var barValueVal = points[ii + valueDimIdx];
+
+        if (barBaseVal >= baseLowerBound && barBaseVal <= baseUpperBound && (startValueVal <= barValueVal ? pointerValueVal >= startValueVal && pointerValueVal <= barValueVal : pointerValueVal >= barValueVal && pointerValueVal <= startValueVal)) {
+          return largeDataIndices[i];
+        }
+      }
+
+      return -1;
+    }
+
+    function setLargeStyle(el, seriesModel, data) {
+      var globalStyle = data.getVisual('style');
+      el.useStyle(extend({}, globalStyle)); // Use stroke instead of fill.
+
+      el.style.fill = null;
+      el.style.stroke = globalStyle.fill;
+      el.style.lineWidth = data.getLayout('barWidth');
+    }
+
+    function setLargeBackgroundStyle(el, backgroundModel, data) {
+      var borderColor = backgroundModel.get('borderColor') || backgroundModel.get('color');
+      var itemStyle = backgroundModel.getItemStyle();
+      el.useStyle(itemStyle);
+      el.style.fill = null;
+      el.style.stroke = borderColor;
+      el.style.lineWidth = data.getLayout('barWidth');
+    }
+
+    function createBackgroundShape(isHorizontalOrRadial, layout, coord) {
+      if (isCoordinateSystemType(coord, 'cartesian2d')) {
+        var rectShape = layout;
+        var coordLayout = coord.getArea();
+        return {
+          x: isHorizontalOrRadial ? rectShape.x : coordLayout.x,
+          y: isHorizontalOrRadial ? coordLayout.y : rectShape.y,
+          width: isHorizontalOrRadial ? rectShape.width : coordLayout.width,
+          height: isHorizontalOrRadial ? coordLayout.height : rectShape.height
+        };
+      } else {
+        var coordLayout = coord.getArea();
+        var sectorShape = layout;
+        return {
+          cx: coordLayout.cx,
+          cy: coordLayout.cy,
+          r0: isHorizontalOrRadial ? coordLayout.r0 : sectorShape.r0,
+          r: isHorizontalOrRadial ? coordLayout.r : sectorShape.r,
+          startAngle: isHorizontalOrRadial ? sectorShape.startAngle : 0,
+          endAngle: isHorizontalOrRadial ? sectorShape.endAngle : Math.PI * 2
+        };
+      }
+    }
+
+    function createBackgroundEl(coord, isHorizontalOrRadial, layout) {
+      var ElementClz = coord.type === 'polar' ? Sector : Rect;
+      return new ElementClz({
+        shape: createBackgroundShape(isHorizontalOrRadial, layout, coord),
+        silent: true,
+        z2: 0
+      });
+    }
+
+    function install$3(registers) {
+      registers.registerChartView(BarView);
+      registers.registerSeriesModel(BarSeriesModel);
+      registers.registerLayout(registers.PRIORITY.VISUAL.LAYOUT, curry(layout, 'bar')); // Use higher prority to avoid to be blocked by other overall layout, which do not
+      // only exist in this module, but probably also exist in other modules, like `barPolar`.
+
+      registers.registerLayout(registers.PRIORITY.VISUAL.PROGRESSIVE_LAYOUT, largeLayout);
+      registers.registerVisual({
+        seriesType: 'bar',
+        reset: function (seriesModel) {
+          // Visual coding for legend
+          seriesModel.getData().setVisual('legendSymbol', 'roundRect');
+        }
+      }); // Down sample after filter
+
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, dataSample('bar'));
+      /**
+       * @payload
+       * @property {string} [componentType=series]
+       * @property {number} [dx]
+       * @property {number} [dy]
+       * @property {number} [zoom]
+       * @property {number} [originX]
+       * @property {number} [originY]
+       */
+
+      registers.registerAction({
+        type: 'changeAxisOrder',
+        event: 'changeAxisOrder',
+        update: 'update'
+      }, function (payload, ecModel) {
+        var componentType = payload.componentType || 'series';
+        ecModel.eachComponent({
+          mainType: componentType,
+          query: payload
+        }, function (componentModel) {
+          if (payload.sortInfo) {
+            componentModel.axis.setCategorySortInfo(payload.sortInfo);
+          }
+        });
+      });
+    }
+
+    var PI2$8 = Math.PI * 2;
+    var RADIAN = Math.PI / 180;
+
+    function getViewRect(seriesModel, api) {
+      return getLayoutRect(seriesModel.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+    }
+
+    function pieLayout(seriesType, ecModel, api) {
+      ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+        var data = seriesModel.getData();
+        var valueDim = data.mapDimension('value');
+        var viewRect = getViewRect(seriesModel, api);
+        var center = seriesModel.get('center');
+        var radius = seriesModel.get('radius');
+
+        if (!isArray(radius)) {
+          radius = [0, radius];
+        }
+
+        if (!isArray(center)) {
+          center = [center, center];
+        }
+
+        var width = parsePercent$1(viewRect.width, api.getWidth());
+        var height = parsePercent$1(viewRect.height, api.getHeight());
+        var size = Math.min(width, height);
+        var cx = parsePercent$1(center[0], width) + viewRect.x;
+        var cy = parsePercent$1(center[1], height) + viewRect.y;
+        var r0 = parsePercent$1(radius[0], size / 2);
+        var r = parsePercent$1(radius[1], size / 2);
+        var startAngle = -seriesModel.get('startAngle') * RADIAN;
+        var minAngle = seriesModel.get('minAngle') * RADIAN;
+        var validDataCount = 0;
+        data.each(valueDim, function (value) {
+          !isNaN(value) && validDataCount++;
+        });
+        var sum = data.getSum(valueDim); // Sum may be 0
+
+        var unitRadian = Math.PI / (sum || validDataCount) * 2;
+        var clockwise = seriesModel.get('clockwise');
+        var roseType = seriesModel.get('roseType');
+        var stillShowZeroSum = seriesModel.get('stillShowZeroSum'); // [0...max]
+
+        var extent = data.getDataExtent(valueDim);
+        extent[0] = 0; // In the case some sector angle is smaller than minAngle
+
+        var restAngle = PI2$8;
+        var valueSumLargerThanMinAngle = 0;
+        var currentAngle = startAngle;
+        var dir = clockwise ? 1 : -1;
+        data.setLayout({
+          viewRect: viewRect,
+          r: r
+        });
+        data.each(valueDim, function (value, idx) {
+          var angle;
+
+          if (isNaN(value)) {
+            data.setItemLayout(idx, {
+              angle: NaN,
+              startAngle: NaN,
+              endAngle: NaN,
+              clockwise: clockwise,
+              cx: cx,
+              cy: cy,
+              r0: r0,
+              r: roseType ? NaN : r
+            });
+            return;
+          } // FIXME 兼容 2.0 但是 roseType 是 area 的时候才是这样？
+
+
+          if (roseType !== 'area') {
+            angle = sum === 0 && stillShowZeroSum ? unitRadian : value * unitRadian;
+          } else {
+            angle = PI2$8 / validDataCount;
+          }
+
+          if (angle < minAngle) {
+            angle = minAngle;
+            restAngle -= minAngle;
+          } else {
+            valueSumLargerThanMinAngle += value;
+          }
+
+          var endAngle = currentAngle + dir * angle;
+          data.setItemLayout(idx, {
+            angle: angle,
+            startAngle: currentAngle,
+            endAngle: endAngle,
+            clockwise: clockwise,
+            cx: cx,
+            cy: cy,
+            r0: r0,
+            r: roseType ? linearMap(value, extent, [r0, r]) : r
+          });
+          currentAngle = endAngle;
+        }); // Some sector is constrained by minAngle
+        // Rest sectors needs recalculate angle
+
+        if (restAngle < PI2$8 && validDataCount) {
+          // Average the angle if rest angle is not enough after all angles is
+          // Constrained by minAngle
+          if (restAngle <= 1e-3) {
+            var angle_1 = PI2$8 / validDataCount;
+            data.each(valueDim, function (value, idx) {
+              if (!isNaN(value)) {
+                var layout_1 = data.getItemLayout(idx);
+                layout_1.angle = angle_1;
+                layout_1.startAngle = startAngle + dir * idx * angle_1;
+                layout_1.endAngle = startAngle + dir * (idx + 1) * angle_1;
+              }
+            });
+          } else {
+            unitRadian = restAngle / valueSumLargerThanMinAngle;
+            currentAngle = startAngle;
+            data.each(valueDim, function (value, idx) {
+              if (!isNaN(value)) {
+                var layout_2 = data.getItemLayout(idx);
+                var angle = layout_2.angle === minAngle ? minAngle : value * unitRadian;
+                layout_2.startAngle = currentAngle;
+                layout_2.endAngle = currentAngle + dir * angle;
+                currentAngle += dir * angle;
+              }
+            });
+          }
+        }
+      });
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function dataFilter(seriesType) {
+      return {
+        seriesType: seriesType,
+        reset: function (seriesModel, ecModel) {
+          var legendModels = ecModel.findComponents({
+            mainType: 'legend'
+          });
+
+          if (!legendModels || !legendModels.length) {
+            return;
+          }
+
+          var data = seriesModel.getData();
+          data.filterSelf(function (idx) {
+            var name = data.getName(idx); // If in any legend component the status is not selected.
+
+            for (var i = 0; i < legendModels.length; i++) {
+              // @ts-ignore FIXME: LegendModel
+              if (!legendModels[i].isSelected(name)) {
+                return false;
+              }
+            }
+
+            return true;
+          });
+        }
+      };
+    }
+
+    var RADIAN$1 = Math.PI / 180;
+
+    function adjustSingleSide(list, cx, cy, r, dir, viewWidth, viewHeight, viewLeft, viewTop, farthestX) {
+      if (list.length < 2) {
+        return;
+      }
+
+      function recalculateXOnSemiToAlignOnEllipseCurve(semi) {
+        var rB = semi.rB;
+        var rB2 = rB * rB;
+
+        for (var i = 0; i < semi.list.length; i++) {
+          var item = semi.list[i];
+          var dy = Math.abs(item.label.y - cy); // horizontal r is always same with original r because x is not changed.
+
+          var rA = r + item.len;
+          var rA2 = rA * rA; // Use ellipse implicit function to calculate x
+
+          var dx = Math.sqrt((1 - Math.abs(dy * dy / rB2)) * rA2);
+          item.label.x = cx + (dx + item.len2) * dir;
+        }
+      } // Adjust X based on the shifted y. Make tight labels aligned on an ellipse curve.
+
+
+      function recalculateX(items) {
+        // Extremes of
+        var topSemi = {
+          list: [],
+          maxY: 0
+        };
+        var bottomSemi = {
+          list: [],
+          maxY: 0
+        };
+
+        for (var i = 0; i < items.length; i++) {
+          if (items[i].labelAlignTo !== 'none') {
+            continue;
+          }
+
+          var item = items[i];
+          var semi = item.label.y > cy ? bottomSemi : topSemi;
+          var dy = Math.abs(item.label.y - cy);
+
+          if (dy > semi.maxY) {
+            var dx = item.label.x - cx - item.len2 * dir; // horizontal r is always same with original r because x is not changed.
+
+            var rA = r + item.len; // Canculate rB based on the topest / bottemest label.
+
+            var rB = Math.abs(dx) < rA ? Math.sqrt(dy * dy / (1 - dx * dx / rA / rA)) : rA;
+            semi.rB = rB;
+            semi.maxY = dy;
+          }
+
+          semi.list.push(item);
+        }
+
+        recalculateXOnSemiToAlignOnEllipseCurve(topSemi);
+        recalculateXOnSemiToAlignOnEllipseCurve(bottomSemi);
+      }
+
+      var len = list.length;
+
+      for (var i = 0; i < len; i++) {
+        if (list[i].position === 'outer' && list[i].labelAlignTo === 'labelLine') {
+          var dx = list[i].label.x - farthestX;
+          list[i].linePoints[1][0] += dx;
+          list[i].label.x = farthestX;
+        }
+      }
+
+      if (shiftLayoutOnY(list, viewTop, viewTop + viewHeight)) {
+        recalculateX(list);
+      }
+    }
+
+    function avoidOverlap(labelLayoutList, cx, cy, r, viewWidth, viewHeight, viewLeft, viewTop) {
+      var leftList = [];
+      var rightList = [];
+      var leftmostX = Number.MAX_VALUE;
+      var rightmostX = -Number.MAX_VALUE;
+
+      for (var i = 0; i < labelLayoutList.length; i++) {
+        var label = labelLayoutList[i].label;
+
+        if (isPositionCenter(labelLayoutList[i])) {
+          continue;
+        }
+
+        if (label.x < cx) {
+          leftmostX = Math.min(leftmostX, label.x);
+          leftList.push(labelLayoutList[i]);
+        } else {
+          rightmostX = Math.max(rightmostX, label.x);
+          rightList.push(labelLayoutList[i]);
+        }
+      }
+
+      adjustSingleSide(rightList, cx, cy, r, 1, viewWidth, viewHeight, viewLeft, viewTop, rightmostX);
+      adjustSingleSide(leftList, cx, cy, r, -1, viewWidth, viewHeight, viewLeft, viewTop, leftmostX);
+
+      for (var i = 0; i < labelLayoutList.length; i++) {
+        var layout = labelLayoutList[i];
+        var label = layout.label;
+
+        if (isPositionCenter(layout)) {
+          continue;
+        }
+
+        var linePoints = layout.linePoints;
+
+        if (linePoints) {
+          var isAlignToEdge = layout.labelAlignTo === 'edge';
+          var realTextWidth = layout.rect.width;
+          var targetTextWidth = void 0;
+
+          if (isAlignToEdge) {
+            if (label.x < cx) {
+              targetTextWidth = linePoints[2][0] - layout.labelDistance - viewLeft - layout.edgeDistance;
+            } else {
+              targetTextWidth = viewLeft + viewWidth - layout.edgeDistance - linePoints[2][0] - layout.labelDistance;
+            }
+          } else {
+            if (label.x < cx) {
+              targetTextWidth = label.x - viewLeft - layout.bleedMargin;
+            } else {
+              targetTextWidth = viewLeft + viewWidth - label.x - layout.bleedMargin;
+            }
+          }
+
+          if (targetTextWidth < layout.rect.width) {
+            // TODOTODO
+            // layout.text = textContain.truncateText(layout.text, targetTextWidth, layout.font);
+            layout.label.style.width = targetTextWidth;
+
+            if (layout.labelAlignTo === 'edge') {
+              realTextWidth = targetTextWidth; // realTextWidth = textContain.getWidth(layout.text, layout.font);
+            }
+          }
+
+          var dist = linePoints[1][0] - linePoints[2][0];
+
+          if (isAlignToEdge) {
+            if (label.x < cx) {
+              linePoints[2][0] = viewLeft + layout.edgeDistance + realTextWidth + layout.labelDistance;
+            } else {
+              linePoints[2][0] = viewLeft + viewWidth - layout.edgeDistance - realTextWidth - layout.labelDistance;
+            }
+          } else {
+            if (label.x < cx) {
+              linePoints[2][0] = label.x + layout.labelDistance;
+            } else {
+              linePoints[2][0] = label.x - layout.labelDistance;
+            }
+
+            linePoints[1][0] = linePoints[2][0] + dist;
+          }
+
+          linePoints[1][1] = linePoints[2][1] = label.y;
+        }
+      }
+    }
+
+    function isPositionCenter(sectorShape) {
+      // Not change x for center label
+      return sectorShape.position === 'center';
+    }
+
+    function pieLabelLayout(seriesModel) {
+      var data = seriesModel.getData();
+      var labelLayoutList = [];
+      var cx;
+      var cy;
+      var hasLabelRotate = false;
+      var minShowLabelRadian = (seriesModel.get('minShowLabelAngle') || 0) * RADIAN$1;
+      var viewRect = data.getLayout('viewRect');
+      var r = data.getLayout('r');
+      var viewWidth = viewRect.width;
+      var viewLeft = viewRect.x;
+      var viewTop = viewRect.y;
+      var viewHeight = viewRect.height;
+
+      function setNotShow(el) {
+        el.ignore = true;
+      }
+
+      function isLabelShown(label) {
+        if (!label.ignore) {
+          return true;
+        }
+
+        for (var key in label.states) {
+          if (label.states[key].ignore === false) {
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+      data.each(function (idx) {
+        var sector = data.getItemGraphicEl(idx);
+        var sectorShape = sector.shape;
+        var label = sector.getTextContent();
+        var labelLine = sector.getTextGuideLine();
+        var itemModel = data.getItemModel(idx);
+        var labelModel = itemModel.getModel('label'); // Use position in normal or emphasis
+
+        var labelPosition = labelModel.get('position') || itemModel.get(['emphasis', 'label', 'position']);
+        var labelDistance = labelModel.get('distanceToLabelLine');
+        var labelAlignTo = labelModel.get('alignTo');
+        var edgeDistance = parsePercent$1(labelModel.get('edgeDistance'), viewWidth);
+        var bleedMargin = labelModel.get('bleedMargin');
+        var labelLineModel = itemModel.getModel('labelLine');
+        var labelLineLen = labelLineModel.get('length');
+        labelLineLen = parsePercent$1(labelLineLen, viewWidth);
+        var labelLineLen2 = labelLineModel.get('length2');
+        labelLineLen2 = parsePercent$1(labelLineLen2, viewWidth);
+
+        if (Math.abs(sectorShape.endAngle - sectorShape.startAngle) < minShowLabelRadian) {
+          each(label.states, setNotShow);
+          label.ignore = true;
+          return;
+        }
+
+        if (!isLabelShown(label)) {
+          return;
+        }
+
+        var midAngle = (sectorShape.startAngle + sectorShape.endAngle) / 2;
+        var nx = Math.cos(midAngle);
+        var ny = Math.sin(midAngle);
+        var textX;
+        var textY;
+        var linePoints;
+        var textAlign;
+        cx = sectorShape.cx;
+        cy = sectorShape.cy;
+        var isLabelInside = labelPosition === 'inside' || labelPosition === 'inner';
+
+        if (labelPosition === 'center') {
+          textX = sectorShape.cx;
+          textY = sectorShape.cy;
+          textAlign = 'center';
+        } else {
+          var x1 = (isLabelInside ? (sectorShape.r + sectorShape.r0) / 2 * nx : sectorShape.r * nx) + cx;
+          var y1 = (isLabelInside ? (sectorShape.r + sectorShape.r0) / 2 * ny : sectorShape.r * ny) + cy;
+          textX = x1 + nx * 3;
+          textY = y1 + ny * 3;
+
+          if (!isLabelInside) {
+            // For roseType
+            var x2 = x1 + nx * (labelLineLen + r - sectorShape.r);
+            var y2 = y1 + ny * (labelLineLen + r - sectorShape.r);
+            var x3 = x2 + (nx < 0 ? -1 : 1) * labelLineLen2;
+            var y3 = y2;
+
+            if (labelAlignTo === 'edge') {
+              // Adjust textX because text align of edge is opposite
+              textX = nx < 0 ? viewLeft + edgeDistance : viewLeft + viewWidth - edgeDistance;
+            } else {
+              textX = x3 + (nx < 0 ? -labelDistance : labelDistance);
+            }
+
+            textY = y3;
+            linePoints = [[x1, y1], [x2, y2], [x3, y3]];
+          }
+
+          textAlign = isLabelInside ? 'center' : labelAlignTo === 'edge' ? nx > 0 ? 'right' : 'left' : nx > 0 ? 'left' : 'right';
+        }
+
+        var labelRotate;
+        var rotate = labelModel.get('rotate');
+
+        if (typeof rotate === 'number') {
+          labelRotate = rotate * (Math.PI / 180);
+        } else {
+          labelRotate = rotate ? nx < 0 ? -midAngle + Math.PI : -midAngle : 0;
+        }
+
+        hasLabelRotate = !!labelRotate;
+        label.x = textX;
+        label.y = textY;
+        label.rotation = labelRotate;
+        label.setStyle({
+          verticalAlign: 'middle'
+        }); // Not sectorShape the inside label
+
+        if (!isLabelInside) {
+          var textRect = label.getBoundingRect().clone();
+          textRect.applyTransform(label.getComputedTransform()); // Text has a default 1px stroke. Exclude this.
+
+          var margin = (label.style.margin || 0) + 2.1;
+          textRect.y -= margin / 2;
+          textRect.height += margin;
+          labelLayoutList.push({
+            label: label,
+            labelLine: labelLine,
+            position: labelPosition,
+            len: labelLineLen,
+            len2: labelLineLen2,
+            minTurnAngle: labelLineModel.get('minTurnAngle'),
+            maxSurfaceAngle: labelLineModel.get('maxSurfaceAngle'),
+            surfaceNormal: new Point(nx, ny),
+            linePoints: linePoints,
+            textAlign: textAlign,
+            labelDistance: labelDistance,
+            labelAlignTo: labelAlignTo,
+            edgeDistance: edgeDistance,
+            bleedMargin: bleedMargin,
+            rect: textRect
+          });
+        } else {
+          label.setStyle({
+            align: textAlign
+          });
+          var selectState = label.states.select;
+
+          if (selectState) {
+            selectState.x += label.x;
+            selectState.y += label.y;
+          }
+        }
+
+        sector.setTextConfig({
+          inside: isLabelInside
+        });
+      });
+
+      if (!hasLabelRotate && seriesModel.get('avoidLabelOverlap')) {
+        avoidOverlap(labelLayoutList, cx, cy, r, viewWidth, viewHeight, viewLeft, viewTop);
+      }
+
+      for (var i = 0; i < labelLayoutList.length; i++) {
+        var layout = labelLayoutList[i];
+        var label = layout.label;
+        var labelLine = layout.labelLine;
+        var notShowLabel = isNaN(label.x) || isNaN(label.y);
+
+        if (label) {
+          label.setStyle({
+            align: layout.textAlign
+          });
+
+          if (notShowLabel) {
+            each(label.states, setNotShow);
+            label.ignore = true;
+          }
+
+          var selectState = label.states.select;
+
+          if (selectState) {
+            selectState.x += label.x;
+            selectState.y += label.y;
+          }
+        }
+
+        if (labelLine) {
+          var linePoints = layout.linePoints;
+
+          if (notShowLabel || !linePoints) {
+            each(labelLine.states, setNotShow);
+            labelLine.ignore = true;
+          } else {
+            limitTurnAngle(linePoints, layout.minTurnAngle);
+            limitSurfaceAngle(linePoints, layout.surfaceNormal, layout.maxSurfaceAngle);
+            labelLine.setShape({
+              points: linePoints
+            }); // Set the anchor to the midpoint of sector
+
+            label.__hostTarget.textGuideLineConfig = {
+              anchor: new Point(linePoints[0][0], linePoints[0][1])
+            };
+          }
+        }
+      }
+    }
+
+    function getSectorCornerRadius(model, shape) {
+      var cornerRadius = model.get('borderRadius');
+
+      if (cornerRadius == null) {
+        return null;
+      }
+
+      if (!isArray(cornerRadius)) {
+        cornerRadius = [cornerRadius, cornerRadius];
+      }
+
+      return {
+        innerCornerRadius: parsePercent(cornerRadius[0], shape.r0),
+        cornerRadius: parsePercent(cornerRadius[1], shape.r)
+      };
+    }
+
+    /**
+     * Piece of pie including Sector, Label, LabelLine
+     */
+
+    var PiePiece =
+    /** @class */
+    function (_super) {
+      __extends(PiePiece, _super);
+
+      function PiePiece(data, idx, startAngle) {
+        var _this = _super.call(this) || this;
+
+        _this.z2 = 2;
+        var polyline = new Polyline();
+        var text = new ZRText();
+
+        _this.setTextGuideLine(polyline);
+
+        _this.setTextContent(text);
+
+        _this.updateData(data, idx, startAngle, true);
+
+        return _this;
+      }
+
+      PiePiece.prototype.updateData = function (data, idx, startAngle, firstCreate) {
+        var sector = this;
+        var seriesModel = data.hostModel;
+        var itemModel = data.getItemModel(idx);
+        var emphasisModel = itemModel.getModel('emphasis');
+        var layout = data.getItemLayout(idx);
+        var sectorShape = extend(getSectorCornerRadius(itemModel.getModel('itemStyle'), layout) || {}, layout);
+
+        if (firstCreate) {
+          sector.setShape(sectorShape);
+          var animationType = seriesModel.getShallow('animationType');
+
+          if (animationType === 'scale') {
+            sector.shape.r = layout.r0;
+            initProps(sector, {
+              shape: {
+                r: layout.r
+              }
+            }, seriesModel, idx);
+          } // Expansion
+          else {
+              if (startAngle != null) {
+                sector.setShape({
+                  startAngle: startAngle,
+                  endAngle: startAngle
+                });
+                initProps(sector, {
+                  shape: {
+                    startAngle: layout.startAngle,
+                    endAngle: layout.endAngle
+                  }
+                }, seriesModel, idx);
+              } else {
+                sector.shape.endAngle = layout.startAngle;
+                updateProps(sector, {
+                  shape: {
+                    endAngle: layout.endAngle
+                  }
+                }, seriesModel, idx);
+              }
+            }
+        } else {
+          // Transition animation from the old shape
+          updateProps(sector, {
+            shape: sectorShape
+          }, seriesModel, idx);
+        }
+
+        sector.useStyle(data.getItemVisual(idx, 'style'));
+        setStatesStylesFromModel(sector, itemModel);
+        var midAngle = (layout.startAngle + layout.endAngle) / 2;
+        var offset = seriesModel.get('selectedOffset');
+        var dx = Math.cos(midAngle) * offset;
+        var dy = Math.sin(midAngle) * offset;
+        var cursorStyle = itemModel.getShallow('cursor');
+        cursorStyle && sector.attr('cursor', cursorStyle);
+
+        this._updateLabel(seriesModel, data, idx);
+
+        sector.ensureState('emphasis').shape = __assign({
+          r: layout.r + (emphasisModel.get('scale') ? emphasisModel.get('scaleSize') || 0 : 0)
+        }, getSectorCornerRadius(emphasisModel.getModel('itemStyle'), layout));
+        extend(sector.ensureState('select'), {
+          x: dx,
+          y: dy,
+          shape: getSectorCornerRadius(itemModel.getModel(['select', 'itemStyle']), layout)
+        });
+        extend(sector.ensureState('blur'), {
+          shape: getSectorCornerRadius(itemModel.getModel(['blur', 'itemStyle']), layout)
+        });
+        var labelLine = sector.getTextGuideLine();
+        var labelText = sector.getTextContent();
+        labelLine && extend(labelLine.ensureState('select'), {
+          x: dx,
+          y: dy
+        }); // TODO: needs dx, dy in zrender?
+
+        extend(labelText.ensureState('select'), {
+          x: dx,
+          y: dy
+        });
+        enableHoverEmphasis(this, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+      };
+
+      PiePiece.prototype._updateLabel = function (seriesModel, data, idx) {
+        var _a;
+
+        var sector = this;
+        var itemModel = data.getItemModel(idx);
+        var labelLineModel = itemModel.getModel('labelLine');
+        var style = data.getItemVisual(idx, 'style');
+        var visualColor = style && style.fill;
+        var visualOpacity = style && style.opacity;
+        setLabelStyle(sector, getLabelStatesModels(itemModel), {
+          labelFetcher: data.hostModel,
+          labelDataIndex: idx,
+          inheritColor: visualColor,
+          defaultOpacity: visualOpacity,
+          defaultText: seriesModel.getFormattedLabel(idx, 'normal') || data.getName(idx)
+        });
+        var labelText = sector.getTextContent(); // Set textConfig on sector.
+
+        sector.setTextConfig({
+          // reset position, rotation
+          position: null,
+          rotation: null
+        }); // Make sure update style on labelText after setLabelStyle.
+        // Because setLabelStyle will replace a new style on it.
+
+        labelText.attr({
+          z2: 10
+        });
+        var labelPosition = seriesModel.get(['label', 'position']);
+
+        if (labelPosition !== 'outside' && labelPosition !== 'outer') {
+          (_a = sector.getTextGuideLine()) === null || _a === void 0 ? void 0 : _a.hide();
+          return;
+        } // Default use item visual color
+
+
+        setLabelLineStyle(this, getLabelLineStatesModels(itemModel), {
+          stroke: visualColor,
+          opacity: retrieve3(labelLineModel.get(['lineStyle', 'opacity']), visualOpacity, 1)
+        });
+      };
+
+      return PiePiece;
+    }(Sector); // Pie view
+
+
+    var PieView =
+    /** @class */
+    function (_super) {
+      __extends(PieView, _super);
+
+      function PieView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.ignoreLabelLineUpdate = true;
+        return _this;
+      }
+
+      PieView.prototype.init = function () {
+        var sectorGroup = new Group();
+        this._sectorGroup = sectorGroup;
+      };
+
+      PieView.prototype.render = function (seriesModel, ecModel, api, payload) {
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var group = this.group;
+        var startAngle; // First render
+
+        if (!oldData && data.count() > 0) {
+          var shape = data.getItemLayout(0);
+
+          for (var s = 1; isNaN(shape && shape.startAngle) && s < data.count(); ++s) {
+            shape = data.getItemLayout(s);
+          }
+
+          if (shape) {
+            startAngle = shape.startAngle;
+          }
+        }
+
+        data.diff(oldData).add(function (idx) {
+          var piePiece = new PiePiece(data, idx, startAngle);
+          data.setItemGraphicEl(idx, piePiece);
+          group.add(piePiece);
+        }).update(function (newIdx, oldIdx) {
+          var piePiece = oldData.getItemGraphicEl(oldIdx);
+          piePiece.updateData(data, newIdx, startAngle);
+          piePiece.off('click');
+          group.add(piePiece);
+          data.setItemGraphicEl(newIdx, piePiece);
+        }).remove(function (idx) {
+          var piePiece = oldData.getItemGraphicEl(idx);
+          removeElementWithFadeOut(piePiece, seriesModel, idx);
+        }).execute();
+        pieLabelLayout(seriesModel); // Always use initial animation.
+
+        if (seriesModel.get('animationTypeUpdate') !== 'expansion') {
+          this._data = data;
+        }
+      };
+
+      PieView.prototype.dispose = function () {};
+
+      PieView.prototype.containPoint = function (point, seriesModel) {
+        var data = seriesModel.getData();
+        var itemLayout = data.getItemLayout(0);
+
+        if (itemLayout) {
+          var dx = point[0] - itemLayout.cx;
+          var dy = point[1] - itemLayout.cy;
+          var radius = Math.sqrt(dx * dx + dy * dy);
+          return radius <= itemLayout.r && radius >= itemLayout.r0;
+        }
+      };
+
+      PieView.type = 'pie';
+      return PieView;
+    }(ChartView);
+
+    /**
+     * [Usage]:
+     * (1)
+     * createListSimply(seriesModel, ['value']);
+     * (2)
+     * createListSimply(seriesModel, {
+     *     coordDimensions: ['value'],
+     *     dimensionsCount: 5
+     * });
+     */
+
+    function createListSimply(seriesModel, opt, nameList) {
+      opt = isArray(opt) && {
+        coordDimensions: opt
+      } || extend({}, opt);
+      var source = seriesModel.getSource();
+      var dimensionsInfo = createDimensions(source, opt);
+      var list = new List(dimensionsInfo, seriesModel);
+      list.initData(source, nameList);
+      return list;
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * LegendVisualProvider is an bridge that pick encoded color from data and
+     * provide to the legend component.
+     */
+    var LegendVisualProvider =
+    /** @class */
+    function () {
+      function LegendVisualProvider( // Function to get data after filtered. It stores all the encoding info
+      getDataWithEncodedVisual, // Function to get raw data before filtered.
+      getRawData) {
+        this._getDataWithEncodedVisual = getDataWithEncodedVisual;
+        this._getRawData = getRawData;
+      }
+
+      LegendVisualProvider.prototype.getAllNames = function () {
+        var rawData = this._getRawData(); // We find the name from the raw data. In case it's filtered by the legend component.
+        // Normally, the name can be found in rawData, but can't be found in filtered data will display as gray.
+
+
+        return rawData.mapArray(rawData.getName);
+      };
+
+      LegendVisualProvider.prototype.containName = function (name) {
+        var rawData = this._getRawData();
+
+        return rawData.indexOfName(name) >= 0;
+      };
+
+      LegendVisualProvider.prototype.indexOfName = function (name) {
+        // Only get data when necessary.
+        // Because LegendVisualProvider constructor may be new in the stage that data is not prepared yet.
+        // Invoking Series#getData immediately will throw an error.
+        var dataWithEncodedVisual = this._getDataWithEncodedVisual();
+
+        return dataWithEncodedVisual.indexOfName(name);
+      };
+
+      LegendVisualProvider.prototype.getItemVisual = function (dataIndex, key) {
+        // Get encoded visual properties from final filtered data.
+        var dataWithEncodedVisual = this._getDataWithEncodedVisual();
+
+        return dataWithEncodedVisual.getItemVisual(dataIndex, key);
+      };
+
+      return LegendVisualProvider;
+    }();
+
+    var PieSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(PieSeriesModel, _super);
+
+      function PieSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.useColorPaletteOnData = true;
+        return _this;
+      }
+      /**
+       * @overwrite
+       */
+
+
+      PieSeriesModel.prototype.init = function (option) {
+        _super.prototype.init.apply(this, arguments); // Enable legend selection for each data item
+        // Use a function instead of direct access because data reference may changed
+
+
+        this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this));
+
+        this._defaultLabelLine(option);
+      };
+      /**
+       * @overwrite
+       */
+
+
+      PieSeriesModel.prototype.mergeOption = function () {
+        _super.prototype.mergeOption.apply(this, arguments);
+      };
+      /**
+       * @overwrite
+       */
+
+
+      PieSeriesModel.prototype.getInitialData = function () {
+        return createListSimply(this, {
+          coordDimensions: ['value'],
+          encodeDefaulter: curry(makeSeriesEncodeForNameBased, this)
+        });
+      };
+      /**
+       * @overwrite
+       */
+
+
+      PieSeriesModel.prototype.getDataParams = function (dataIndex) {
+        var data = this.getData();
+
+        var params = _super.prototype.getDataParams.call(this, dataIndex); // FIXME toFixed?
+
+
+        var valueList = [];
+        data.each(data.mapDimension('value'), function (value) {
+          valueList.push(value);
+        });
+        params.percent = getPercentWithPrecision(valueList, dataIndex, data.hostModel.get('percentPrecision'));
+        params.$vars.push('percent');
+        return params;
+      };
+
+      PieSeriesModel.prototype._defaultLabelLine = function (option) {
+        // Extend labelLine emphasis
+        defaultEmphasis(option, 'labelLine', ['show']);
+        var labelLineNormalOpt = option.labelLine;
+        var labelLineEmphasisOpt = option.emphasis.labelLine; // Not show label line if `label.normal.show = false`
+
+        labelLineNormalOpt.show = labelLineNormalOpt.show && option.label.show;
+        labelLineEmphasisOpt.show = labelLineEmphasisOpt.show && option.emphasis.label.show;
+      };
+
+      PieSeriesModel.type = 'series.pie';
+      PieSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        // 默认全局居中
+        center: ['50%', '50%'],
+        radius: [0, '75%'],
+        // 默认顺时针
+        clockwise: true,
+        startAngle: 90,
+        // 最小角度改为0
+        minAngle: 0,
+        // If the angle of a sector less than `minShowLabelAngle`,
+        // the label will not be displayed.
+        minShowLabelAngle: 0,
+        // 选中时扇区偏移量
+        selectedOffset: 10,
+        // 选择模式，默认关闭，可选single，multiple
+        // selectedMode: false,
+        // 南丁格尔玫瑰图模式，'radius'（半径） | 'area'（面积）
+        // roseType: null,
+        percentPrecision: 2,
+        // If still show when all data zero.
+        stillShowZeroSum: true,
+        // cursor: null,
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        width: null,
+        height: null,
+        label: {
+          // color: 'inherit',
+          // If rotate around circle
+          rotate: 0,
+          show: true,
+          overflow: 'truncate',
+          // 'outer', 'inside', 'center'
+          position: 'outer',
+          // 'none', 'labelLine', 'edge'. Works only when position is 'outer'
+          alignTo: 'none',
+          // Closest distance between label and chart edge.
+          // Works only position is 'outer' and alignTo is 'edge'.
+          edgeDistance: '25%',
+          // Works only position is 'outer' and alignTo is not 'edge'.
+          bleedMargin: 10,
+          // Distance between text and label line.
+          distanceToLabelLine: 5 // formatter: 标签文本格式器，同Tooltip.formatter，不支持异步回调
+          // 默认使用全局文本样式，详见TEXTSTYLE
+          // distance: 当position为inner时有效，为label位置到圆心的距离与圆半径(环状图为内外半径和)的比例系数
+
+        },
+        // Enabled when label.normal.position is 'outer'
+        labelLine: {
+          show: true,
+          // 引导线两段中的第一段长度
+          length: 15,
+          // 引导线两段中的第二段长度
+          length2: 15,
+          smooth: false,
+          minTurnAngle: 90,
+          maxSurfaceAngle: 90,
+          lineStyle: {
+            // color: 各异,
+            width: 1,
+            type: 'solid'
+          }
+        },
+        itemStyle: {
+          borderWidth: 1
+        },
+        labelLayout: {
+          // Hide the overlapped label.
+          hideOverlap: true
+        },
+        emphasis: {
+          scale: true,
+          scaleSize: 5
+        },
+        // If use strategy to avoid label overlapping
+        avoidLabelOverlap: true,
+        // Animation type. Valid values: expansion, scale
+        animationType: 'expansion',
+        animationDuration: 1000,
+        // Animation type when update. Valid values: transition, expansion
+        animationTypeUpdate: 'transition',
+        animationEasingUpdate: 'cubicInOut',
+        animationDurationUpdate: 500,
+        animationEasing: 'cubicInOut'
+      };
+      return PieSeriesModel;
+    }(SeriesModel);
+
+    function install$4(registers) {
+      registers.registerChartView(PieView);
+      registers.registerSeriesModel(PieSeriesModel);
+      createLegacyDataSelectAction('pie', registers.registerAction);
+      registers.registerLayout(curry(pieLayout, 'pie'));
+      registers.registerProcessor(dataFilter('pie'));
+    }
+
+    var ScatterSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(ScatterSeriesModel, _super);
+
+      function ScatterSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ScatterSeriesModel.type;
+        _this.hasSymbolVisual = true;
+        return _this;
+      }
+
+      ScatterSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: true
+        });
+      };
+
+      ScatterSeriesModel.prototype.getProgressive = function () {
+        var progressive = this.option.progressive;
+
+        if (progressive == null) {
+          // PENDING
+          return this.option.large ? 5e3 : this.get('progressive');
+        }
+
+        return progressive;
+      };
+
+      ScatterSeriesModel.prototype.getProgressiveThreshold = function () {
+        var progressiveThreshold = this.option.progressiveThreshold;
+
+        if (progressiveThreshold == null) {
+          // PENDING
+          return this.option.large ? 1e4 : this.get('progressiveThreshold');
+        }
+
+        return progressiveThreshold;
+      };
+
+      ScatterSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+        return selectors.point(data.getItemLayout(dataIndex));
+      };
+
+      ScatterSeriesModel.type = 'series.scatter';
+      ScatterSeriesModel.dependencies = ['grid', 'polar', 'geo', 'singleAxis', 'calendar'];
+      ScatterSeriesModel.defaultOption = {
+        coordinateSystem: 'cartesian2d',
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        symbolSize: 10,
+        // symbolRotate: null,  // 图形旋转控制
+        large: false,
+        // Available when large is true
+        largeThreshold: 2000,
+        // cursor: null,
+        itemStyle: {
+          opacity: 0.8 // color: 各异
+
+        },
+        emphasis: {
+          scale: true
+        },
+        // If clip the overflow graphics
+        // Works on cartesian / polar series
+        clip: true,
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        } // progressive: null
+
+      };
+      return ScatterSeriesModel;
+    }(SeriesModel);
+
+    var BOOST_SIZE_THRESHOLD = 4;
+
+    var LargeSymbolPathShape =
+    /** @class */
+    function () {
+      function LargeSymbolPathShape() {}
+
+      return LargeSymbolPathShape;
+    }();
+
+    var LargeSymbolPath =
+    /** @class */
+    function (_super) {
+      __extends(LargeSymbolPath, _super);
+
+      function LargeSymbolPath(opts) {
+        return _super.call(this, opts) || this;
+      }
+
+      LargeSymbolPath.prototype.getDefaultShape = function () {
+        return new LargeSymbolPathShape();
+      };
+
+      LargeSymbolPath.prototype.buildPath = function (path, shape) {
+        var points = shape.points;
+        var size = shape.size;
+        var symbolProxy = this.symbolProxy;
+        var symbolProxyShape = symbolProxy.shape;
+        var ctx = path.getContext ? path.getContext() : path;
+        var canBoost = ctx && size[0] < BOOST_SIZE_THRESHOLD; // Do draw in afterBrush.
+
+        if (canBoost) {
+          this._ctx = ctx;
+          return;
+        }
+
+        this._ctx = null;
+
+        for (var i = 0; i < points.length;) {
+          var x = points[i++];
+          var y = points[i++];
+
+          if (isNaN(x) || isNaN(y)) {
+            continue;
+          }
+
+          if (this.softClipShape && !this.softClipShape.contain(x, y)) {
+            continue;
+          }
+
+          symbolProxyShape.x = x - size[0] / 2;
+          symbolProxyShape.y = y - size[1] / 2;
+          symbolProxyShape.width = size[0];
+          symbolProxyShape.height = size[1];
+          symbolProxy.buildPath(path, symbolProxyShape, true);
+        }
+      };
+
+      LargeSymbolPath.prototype.afterBrush = function () {
+        var shape = this.shape;
+        var points = shape.points;
+        var size = shape.size;
+        var ctx = this._ctx;
+
+        if (!ctx) {
+          return;
+        } // PENDING If style or other canvas status changed?
+
+
+        for (var i = 0; i < points.length;) {
+          var x = points[i++];
+          var y = points[i++];
+
+          if (isNaN(x) || isNaN(y)) {
+            continue;
+          }
+
+          if (this.softClipShape && !this.softClipShape.contain(x, y)) {
+            continue;
+          } // fillRect is faster than building a rect path and draw.
+          // And it support light globalCompositeOperation.
+
+
+          ctx.fillRect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
+        }
+      };
+
+      LargeSymbolPath.prototype.findDataIndex = function (x, y) {
+        // TODO ???
+        // Consider transform
+        var shape = this.shape;
+        var points = shape.points;
+        var size = shape.size;
+        var w = Math.max(size[0], 4);
+        var h = Math.max(size[1], 4); // Not consider transform
+        // Treat each element as a rect
+        // top down traverse
+
+        for (var idx = points.length / 2 - 1; idx >= 0; idx--) {
+          var i = idx * 2;
+          var x0 = points[i] - w / 2;
+          var y0 = points[i + 1] - h / 2;
+
+          if (x >= x0 && y >= y0 && x <= x0 + w && y <= y0 + h) {
+            return idx;
+          }
+        }
+
+        return -1;
+      };
+
+      return LargeSymbolPath;
+    }(Path);
+
+    var LargeSymbolDraw =
+    /** @class */
+    function () {
+      function LargeSymbolDraw() {
+        this.group = new Group();
+      }
+
+      LargeSymbolDraw.prototype.isPersistent = function () {
+        return !this._incremental;
+      };
+      /**
+       * Update symbols draw by new data
+       */
+
+      LargeSymbolDraw.prototype.updateData = function (data, opt) {
+        this.group.removeAll();
+        var symbolEl = new LargeSymbolPath({
+          rectHover: true,
+          cursor: 'default'
+        });
+        symbolEl.setShape({
+          points: data.getLayout('points')
+        });
+
+        this._setCommon(symbolEl, data, false, opt);
+
+        this.group.add(symbolEl);
+        this._incremental = null;
+      };
+
+      LargeSymbolDraw.prototype.updateLayout = function (data) {
+        if (this._incremental) {
+          return;
+        }
+
+        var points = data.getLayout('points');
+        this.group.eachChild(function (child) {
+          if (child.startIndex != null) {
+            var len = (child.endIndex - child.startIndex) * 2;
+            var byteOffset = child.startIndex * 4 * 2;
+            points = new Float32Array(points.buffer, byteOffset, len);
+          }
+
+          child.setShape('points', points);
+        });
+      };
+
+      LargeSymbolDraw.prototype.incrementalPrepareUpdate = function (data) {
+        this.group.removeAll();
+
+        this._clearIncremental(); // Only use incremental displayables when data amount is larger than 2 million.
+        // PENDING Incremental data?
+
+
+        if (data.count() > 2e6) {
+          if (!this._incremental) {
+            this._incremental = new IncrementalDisplayable({
+              silent: true
+            });
+          }
+
+          this.group.add(this._incremental);
+        } else {
+          this._incremental = null;
+        }
+      };
+
+      LargeSymbolDraw.prototype.incrementalUpdate = function (taskParams, data, opt) {
+        var symbolEl;
+
+        if (this._incremental) {
+          symbolEl = new LargeSymbolPath();
+
+          this._incremental.addDisplayable(symbolEl, true);
+        } else {
+          symbolEl = new LargeSymbolPath({
+            rectHover: true,
+            cursor: 'default',
+            startIndex: taskParams.start,
+            endIndex: taskParams.end
+          });
+          symbolEl.incremental = true;
+          this.group.add(symbolEl);
+        }
+
+        symbolEl.setShape({
+          points: data.getLayout('points')
+        });
+
+        this._setCommon(symbolEl, data, !!this._incremental, opt);
+      };
+
+      LargeSymbolDraw.prototype._setCommon = function (symbolEl, data, isIncremental, opt) {
+        var hostModel = data.hostModel;
+        opt = opt || {};
+        var size = data.getVisual('symbolSize');
+        symbolEl.setShape('size', size instanceof Array ? size : [size, size]);
+        symbolEl.softClipShape = opt.clipShape || null; // Create symbolProxy to build path for each data
+
+        symbolEl.symbolProxy = createSymbol(data.getVisual('symbol'), 0, 0, 0, 0); // Use symbolProxy setColor method
+
+        symbolEl.setColor = symbolEl.symbolProxy.setColor;
+        var extrudeShadow = symbolEl.shape.size[0] < BOOST_SIZE_THRESHOLD;
+        symbolEl.useStyle( // Draw shadow when doing fillRect is extremely slow.
+        hostModel.getModel('itemStyle').getItemStyle(extrudeShadow ? ['color', 'shadowBlur', 'shadowColor'] : ['color']));
+        var globalStyle = data.getVisual('style');
+        var visualColor = globalStyle && globalStyle.fill;
+
+        if (visualColor) {
+          symbolEl.setColor(visualColor);
+        }
+
+        if (!isIncremental) {
+          var ecData_1 = getECData(symbolEl); // Enable tooltip
+          // PENDING May have performance issue when path is extremely large
+
+          ecData_1.seriesIndex = hostModel.seriesIndex;
+          symbolEl.on('mousemove', function (e) {
+            ecData_1.dataIndex = null;
+            var dataIndex = symbolEl.findDataIndex(e.offsetX, e.offsetY);
+
+            if (dataIndex >= 0) {
+              // Provide dataIndex for tooltip
+              ecData_1.dataIndex = dataIndex + (symbolEl.startIndex || 0);
+            }
+          });
+        }
+      };
+
+      LargeSymbolDraw.prototype.remove = function () {
+        this._clearIncremental();
+
+        this._incremental = null;
+        this.group.removeAll();
+      };
+
+      LargeSymbolDraw.prototype._clearIncremental = function () {
+        var incremental = this._incremental;
+
+        if (incremental) {
+          incremental.clearDisplaybles();
+        }
+      };
+
+      return LargeSymbolDraw;
+    }();
+
+    var ScatterView =
+    /** @class */
+    function (_super) {
+      __extends(ScatterView, _super);
+
+      function ScatterView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ScatterView.type;
+        return _this;
+      }
+
+      ScatterView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+
+        var symbolDraw = this._updateSymbolDraw(data, seriesModel);
+
+        symbolDraw.updateData(data, {
+          // TODO
+          // If this parameter should be a shape or a bounding volume
+          // shape will be more general.
+          // But bounding volume like bounding rect will be much faster in the contain calculation
+          clipShape: this._getClipShape(seriesModel)
+        });
+        this._finished = true;
+      };
+
+      ScatterView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+
+        var symbolDraw = this._updateSymbolDraw(data, seriesModel);
+
+        symbolDraw.incrementalPrepareUpdate(data);
+        this._finished = false;
+      };
+
+      ScatterView.prototype.incrementalRender = function (taskParams, seriesModel, ecModel) {
+        this._symbolDraw.incrementalUpdate(taskParams, seriesModel.getData(), {
+          clipShape: this._getClipShape(seriesModel)
+        });
+
+        this._finished = taskParams.end === seriesModel.getData().count();
+      };
+
+      ScatterView.prototype.updateTransform = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData(); // Must mark group dirty and make sure the incremental layer will be cleared
+        // PENDING
+
+        this.group.dirty();
+
+        if (!this._finished || data.count() > 1e4 || !this._symbolDraw.isPersistent()) {
+          return {
+            update: true
+          };
+        } else {
+          var res = pointsLayout('').reset(seriesModel, ecModel, api);
+
+          if (res.progress) {
+            res.progress({
+              start: 0,
+              end: data.count(),
+              count: data.count()
+            }, data);
+          }
+
+          this._symbolDraw.updateLayout(data);
+        }
+      };
+
+      ScatterView.prototype._getClipShape = function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+        var clipArea = coordSys && coordSys.getArea && coordSys.getArea();
+        return seriesModel.get('clip', true) ? clipArea : null;
+      };
+
+      ScatterView.prototype._updateSymbolDraw = function (data, seriesModel) {
+        var symbolDraw = this._symbolDraw;
+        var pipelineContext = seriesModel.pipelineContext;
+        var isLargeDraw = pipelineContext.large;
+
+        if (!symbolDraw || isLargeDraw !== this._isLargeDraw) {
+          symbolDraw && symbolDraw.remove();
+          symbolDraw = this._symbolDraw = isLargeDraw ? new LargeSymbolDraw() : new SymbolDraw();
+          this._isLargeDraw = isLargeDraw;
+          this.group.removeAll();
+        }
+
+        this.group.add(symbolDraw.group);
+        return symbolDraw;
+      };
+
+      ScatterView.prototype.remove = function (ecModel, api) {
+        this._symbolDraw && this._symbolDraw.remove(true);
+        this._symbolDraw = null;
+      };
+
+      ScatterView.prototype.dispose = function () {};
+
+      ScatterView.type = 'scatter';
+      return ScatterView;
+    }(ChartView);
+
+    var GridModel =
+    /** @class */
+    function (_super) {
+      __extends(GridModel, _super);
+
+      function GridModel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      GridModel.type = 'grid';
+      GridModel.dependencies = ['xAxis', 'yAxis'];
+      GridModel.layoutMode = 'box';
+      GridModel.defaultOption = {
+        show: false,
+        zlevel: 0,
+        z: 0,
+        left: '10%',
+        top: 60,
+        right: '10%',
+        bottom: 70,
+        // If grid size contain label
+        containLabel: false,
+        // width: {totalWidth} - left - right,
+        // height: {totalHeight} - top - bottom,
+        backgroundColor: 'rgba(0,0,0,0)',
+        borderWidth: 1,
+        borderColor: '#ccc'
+      };
+      return GridModel;
+    }(ComponentModel);
+
+    var CartesianAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(CartesianAxisModel, _super);
+
+      function CartesianAxisModel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      CartesianAxisModel.prototype.getCoordSysModel = function () {
+        return this.getReferringComponents('grid', SINGLE_REFERRING).models[0];
+      };
+
+      CartesianAxisModel.type = 'cartesian2dAxis';
+      return CartesianAxisModel;
+    }(ComponentModel);
+    mixin(CartesianAxisModel, AxisModelCommonMixin);
+
+    var defaultOption = {
+      show: true,
+      zlevel: 0,
+      z: 0,
+      // Inverse the axis.
+      inverse: false,
+      // Axis name displayed.
+      name: '',
+      // 'start' | 'middle' | 'end'
+      nameLocation: 'end',
+      // By degree. By default auto rotate by nameLocation.
+      nameRotate: null,
+      nameTruncate: {
+        maxWidth: null,
+        ellipsis: '...',
+        placeholder: '.'
+      },
+      // Use global text style by default.
+      nameTextStyle: {},
+      // The gap between axisName and axisLine.
+      nameGap: 15,
+      // Default `false` to support tooltip.
+      silent: false,
+      // Default `false` to avoid legacy user event listener fail.
+      triggerEvent: false,
+      tooltip: {
+        show: false
+      },
+      axisPointer: {},
+      axisLine: {
+        show: true,
+        onZero: true,
+        onZeroAxisIndex: null,
+        lineStyle: {
+          color: '#6E7079',
+          width: 1,
+          type: 'solid'
+        },
+        // The arrow at both ends the the axis.
+        symbol: ['none', 'none'],
+        symbolSize: [10, 15]
+      },
+      axisTick: {
+        show: true,
+        // Whether axisTick is inside the grid or outside the grid.
+        inside: false,
+        // The length of axisTick.
+        length: 5,
+        lineStyle: {
+          width: 1
+        }
+      },
+      axisLabel: {
+        show: true,
+        // Whether axisLabel is inside the grid or outside the grid.
+        inside: false,
+        rotate: 0,
+        // true | false | null/undefined (auto)
+        showMinLabel: null,
+        // true | false | null/undefined (auto)
+        showMaxLabel: null,
+        margin: 8,
+        // formatter: null,
+        fontSize: 12
+      },
+      splitLine: {
+        show: true,
+        lineStyle: {
+          color: ['#E0E6F1'],
+          width: 1,
+          type: 'solid'
+        }
+      },
+      splitArea: {
+        show: false,
+        areaStyle: {
+          color: ['rgba(250,250,250,0.2)', 'rgba(210,219,238,0.2)']
+        }
+      }
+    };
+    var categoryAxis = merge({
+      // The gap at both ends of the axis. For categoryAxis, boolean.
+      boundaryGap: true,
+      // Set false to faster category collection.
+      deduplication: null,
+      // splitArea: {
+      // show: false
+      // },
+      splitLine: {
+        show: false
+      },
+      axisTick: {
+        // If tick is align with label when boundaryGap is true
+        alignWithLabel: false,
+        interval: 'auto'
+      },
+      axisLabel: {
+        interval: 'auto'
+      }
+    }, defaultOption);
+    var valueAxis = merge({
+      boundaryGap: [0, 0],
+      axisLine: {
+        // Not shown when other axis is categoryAxis in cartesian
+        show: 'auto'
+      },
+      axisTick: {
+        // Not shown when other axis is categoryAxis in cartesian
+        show: 'auto'
+      },
+      // TODO
+      // min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60]
+      splitNumber: 5,
+      minorTick: {
+        // Minor tick, not available for cateogry axis.
+        show: false,
+        // Split number of minor ticks. The value should be in range of (0, 100)
+        splitNumber: 5,
+        // Lenght of minor tick
+        length: 3,
+        // Line style
+        lineStyle: {// Default to be same with axisTick
+        }
+      },
+      minorSplitLine: {
+        show: false,
+        lineStyle: {
+          color: '#F4F7FD',
+          width: 1
+        }
+      }
+    }, defaultOption);
+    var timeAxis = merge({
+      scale: true,
+      splitNumber: 6,
+      axisLabel: {
+        // To eliminate labels that are not nice
+        showMinLabel: false,
+        showMaxLabel: false,
+        rich: {
+          primary: {
+            fontWeight: 'bold'
+          }
+        }
+      },
+      splitLine: {
+        show: false
+      }
+    }, valueAxis);
+    var logAxis = defaults({
+      scale: true,
+      logBase: 10
+    }, valueAxis);
+    var axisDefault = {
+      category: categoryAxis,
+      value: valueAxis,
+      time: timeAxis,
+      log: logAxis
+    };
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var AXIS_TYPES = {
+      value: 1,
+      category: 1,
+      time: 1,
+      log: 1
+    };
+
+    /**
+     * Generate sub axis model class
+     * @param axisName 'x' 'y' 'radius' 'angle' 'parallel' ...
+     */
+
+    function axisModelCreator(registers, axisName, BaseAxisModelClass, extraDefaultOption) {
+      each(AXIS_TYPES, function (v, axisType) {
+        var defaultOption = merge(merge({}, axisDefault[axisType], true), extraDefaultOption, true);
+
+        var AxisModel =
+        /** @class */
+        function (_super) {
+          __extends(AxisModel, _super);
+
+          function AxisModel() {
+            var args = [];
+
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+
+            var _this = _super.apply(this, args) || this;
+
+            _this.type = axisName + 'Axis.' + axisType;
+            return _this;
+          }
+
+          AxisModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+            var layoutMode = fetchLayoutMode(this);
+            var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
+            var themeModel = ecModel.getTheme();
+            merge(option, themeModel.get(axisType + 'Axis'));
+            merge(option, this.getDefaultOption());
+            option.type = getAxisType(option);
+
+            if (layoutMode) {
+              mergeLayoutParam(option, inputPositionParams, layoutMode);
+            }
+          };
+
+          AxisModel.prototype.optionUpdated = function () {
+            var thisOption = this.option;
+
+            if (thisOption.type === 'category') {
+              this.__ordinalMeta = OrdinalMeta.createByAxisModel(this);
+            }
+          };
+          /**
+           * Should not be called before all of 'getInitailData' finished.
+           * Because categories are collected during initializing data.
+           */
+
+
+          AxisModel.prototype.getCategories = function (rawData) {
+            var option = this.option; // FIXME
+            // warning if called before all of 'getInitailData' finished.
+
+            if (option.type === 'category') {
+              if (rawData) {
+                return option.data;
+              }
+
+              return this.__ordinalMeta.categories;
+            }
+          };
+
+          AxisModel.prototype.getOrdinalMeta = function () {
+            return this.__ordinalMeta;
+          };
+
+          AxisModel.type = axisName + 'Axis.' + axisType;
+          AxisModel.defaultOption = defaultOption;
+          return AxisModel;
+        }(BaseAxisModelClass);
+
+        registers.registerComponentModel(AxisModel);
+      });
+      registers.registerSubTypeDefaulter(axisName + 'Axis', getAxisType);
+    }
+
+    function getAxisType(option) {
+      // Default axis with data is category axis
+      return option.type || (option.data ? 'category' : 'value');
+    }
+
+    var Cartesian =
+    /** @class */
+    function () {
+      function Cartesian(name) {
+        this.type = 'cartesian';
+        this._dimList = [];
+        this._axes = {};
+        this.name = name || '';
+      }
+
+      Cartesian.prototype.getAxis = function (dim) {
+        return this._axes[dim];
+      };
+
+      Cartesian.prototype.getAxes = function () {
+        return map(this._dimList, function (dim) {
+          return this._axes[dim];
+        }, this);
+      };
+
+      Cartesian.prototype.getAxesByScale = function (scaleType) {
+        scaleType = scaleType.toLowerCase();
+        return filter(this.getAxes(), function (axis) {
+          return axis.scale.type === scaleType;
+        });
+      };
+
+      Cartesian.prototype.addAxis = function (axis) {
+        var dim = axis.dim;
+        this._axes[dim] = axis;
+
+        this._dimList.push(dim);
+      };
+
+      return Cartesian;
+    }();
+
+    var cartesian2DDimensions = ['x', 'y'];
+
+    function canCalculateAffineTransform(scale) {
+      return scale.type === 'interval' || scale.type === 'time';
+    }
+
+    var Cartesian2D =
+    /** @class */
+    function (_super) {
+      __extends(Cartesian2D, _super);
+
+      function Cartesian2D() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'cartesian2d';
+        _this.dimensions = cartesian2DDimensions;
+        return _this;
+      }
+      /**
+       * Calculate an affine transform matrix if two axes are time or value.
+       * It's mainly for accelartion on the large time series data.
+       */
+
+
+      Cartesian2D.prototype.calcAffineTransform = function () {
+        this._transform = this._invTransform = null;
+        var xAxisScale = this.getAxis('x').scale;
+        var yAxisScale = this.getAxis('y').scale;
+
+        if (!canCalculateAffineTransform(xAxisScale) || !canCalculateAffineTransform(yAxisScale)) {
+          return;
+        }
+
+        var xScaleExtent = xAxisScale.getExtent();
+        var yScaleExtent = yAxisScale.getExtent();
+        var start = this.dataToPoint([xScaleExtent[0], yScaleExtent[0]]);
+        var end = this.dataToPoint([xScaleExtent[1], yScaleExtent[1]]);
+        var xScaleSpan = xScaleExtent[1] - xScaleExtent[0];
+        var yScaleSpan = yScaleExtent[1] - yScaleExtent[0];
+
+        if (!xScaleSpan || !yScaleSpan) {
+          return;
+        } // Accelerate data to point calculation on the special large time series data.
+
+
+        var scaleX = (end[0] - start[0]) / xScaleSpan;
+        var scaleY = (end[1] - start[1]) / yScaleSpan;
+        var translateX = start[0] - xScaleExtent[0] * scaleX;
+        var translateY = start[1] - yScaleExtent[0] * scaleY;
+        var m = this._transform = [scaleX, 0, 0, scaleY, translateX, translateY];
+        this._invTransform = invert([], m);
+      };
+      /**
+       * Base axis will be used on stacking.
+       */
+
+
+      Cartesian2D.prototype.getBaseAxis = function () {
+        return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAxis('x');
+      };
+
+      Cartesian2D.prototype.containPoint = function (point) {
+        var axisX = this.getAxis('x');
+        var axisY = this.getAxis('y');
+        return axisX.contain(axisX.toLocalCoord(point[0])) && axisY.contain(axisY.toLocalCoord(point[1]));
+      };
+
+      Cartesian2D.prototype.containData = function (data) {
+        return this.getAxis('x').containData(data[0]) && this.getAxis('y').containData(data[1]);
+      };
+
+      Cartesian2D.prototype.dataToPoint = function (data, reserved, out) {
+        out = out || [];
+        var xVal = data[0];
+        var yVal = data[1]; // Fast path
+
+        if (this._transform // It's supported that if data is like `[Inifity, 123]`, where only Y pixel calculated.
+        && xVal != null && isFinite(xVal) && yVal != null && isFinite(yVal)) {
+          return applyTransform(out, data, this._transform);
+        }
+
+        var xAxis = this.getAxis('x');
+        var yAxis = this.getAxis('y');
+        out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal));
+        out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal));
+        return out;
+      };
+
+      Cartesian2D.prototype.clampData = function (data, out) {
+        var xScale = this.getAxis('x').scale;
+        var yScale = this.getAxis('y').scale;
+        var xAxisExtent = xScale.getExtent();
+        var yAxisExtent = yScale.getExtent();
+        var x = xScale.parse(data[0]);
+        var y = yScale.parse(data[1]);
+        out = out || [];
+        out[0] = Math.min(Math.max(Math.min(xAxisExtent[0], xAxisExtent[1]), x), Math.max(xAxisExtent[0], xAxisExtent[1]));
+        out[1] = Math.min(Math.max(Math.min(yAxisExtent[0], yAxisExtent[1]), y), Math.max(yAxisExtent[0], yAxisExtent[1]));
+        return out;
+      };
+
+      Cartesian2D.prototype.pointToData = function (point, out) {
+        out = out || [];
+
+        if (this._invTransform) {
+          return applyTransform(out, point, this._invTransform);
+        }
+
+        var xAxis = this.getAxis('x');
+        var yAxis = this.getAxis('y');
+        out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]));
+        out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]));
+        return out;
+      };
+
+      Cartesian2D.prototype.getOtherAxis = function (axis) {
+        return this.getAxis(axis.dim === 'x' ? 'y' : 'x');
+      };
+      /**
+       * Get rect area of cartesian.
+       * Area will have a contain function to determine if a point is in the coordinate system.
+       */
+
+
+      Cartesian2D.prototype.getArea = function () {
+        var xExtent = this.getAxis('x').getGlobalExtent();
+        var yExtent = this.getAxis('y').getGlobalExtent();
+        var x = Math.min(xExtent[0], xExtent[1]);
+        var y = Math.min(yExtent[0], yExtent[1]);
+        var width = Math.max(xExtent[0], xExtent[1]) - x;
+        var height = Math.max(yExtent[0], yExtent[1]) - y;
+        return new BoundingRect(x, y, width, height);
+      };
+
+      return Cartesian2D;
+    }(Cartesian);
+
+    var Axis2D =
+    /** @class */
+    function (_super) {
+      __extends(Axis2D, _super);
+
+      function Axis2D(dim, scale, coordExtent, axisType, position) {
+        var _this = _super.call(this, dim, scale, coordExtent) || this;
+        /**
+         * Index of axis, can be used as key
+         * Injected outside.
+         */
+
+
+        _this.index = 0;
+        _this.type = axisType || 'value';
+        _this.position = position || 'bottom';
+        return _this;
+      }
+
+      Axis2D.prototype.isHorizontal = function () {
+        var position = this.position;
+        return position === 'top' || position === 'bottom';
+      };
+      /**
+       * Each item cooresponds to this.getExtent(), which
+       * means globalExtent[0] may greater than globalExtent[1],
+       * unless `asc` is input.
+       *
+       * @param {boolean} [asc]
+       * @return {Array.<number>}
+       */
+
+
+      Axis2D.prototype.getGlobalExtent = function (asc) {
+        var ret = this.getExtent();
+        ret[0] = this.toGlobalCoord(ret[0]);
+        ret[1] = this.toGlobalCoord(ret[1]);
+        asc && ret[0] > ret[1] && ret.reverse();
+        return ret;
+      };
+
+      Axis2D.prototype.pointToData = function (point, clamp) {
+        return this.coordToData(this.toLocalCoord(point[this.dim === 'x' ? 0 : 1]), clamp);
+      };
+      /**
+       * Set ordinalSortInfo
+       * @param info new OrdinalSortInfo
+       */
+
+
+      Axis2D.prototype.setCategorySortInfo = function (info) {
+        if (this.type !== 'category') {
+          return false;
+        }
+
+        this.model.option.categorySortInfo = info;
+        this.scale.setSortInfo(info);
+      };
+
+      return Axis2D;
+    }(Axis);
+
+    /**
+     * Can only be called after coordinate system creation stage.
+     * (Can be called before coordinate system update stage).
+     */
+
+    function layout$1(gridModel, axisModel, opt) {
+      opt = opt || {};
+      var grid = gridModel.coordinateSystem;
+      var axis = axisModel.axis;
+      var layout = {};
+      var otherAxisOnZeroOf = axis.getAxesOnZeroOf()[0];
+      var rawAxisPosition = axis.position;
+      var axisPosition = otherAxisOnZeroOf ? 'onZero' : rawAxisPosition;
+      var axisDim = axis.dim;
+      var rect = grid.getRect();
+      var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+      var idx = {
+        left: 0,
+        right: 1,
+        top: 0,
+        bottom: 1,
+        onZero: 2
+      };
+      var axisOffset = axisModel.get('offset') || 0;
+      var posBound = axisDim === 'x' ? [rectBound[2] - axisOffset, rectBound[3] + axisOffset] : [rectBound[0] - axisOffset, rectBound[1] + axisOffset];
+
+      if (otherAxisOnZeroOf) {
+        var onZeroCoord = otherAxisOnZeroOf.toGlobalCoord(otherAxisOnZeroOf.dataToCoord(0));
+        posBound[idx.onZero] = Math.max(Math.min(onZeroCoord, posBound[1]), posBound[0]);
+      } // Axis position
+
+
+      layout.position = [axisDim === 'y' ? posBound[idx[axisPosition]] : rectBound[0], axisDim === 'x' ? posBound[idx[axisPosition]] : rectBound[3]]; // Axis rotation
+
+      layout.rotation = Math.PI / 2 * (axisDim === 'x' ? 0 : 1); // Tick and label direction, x y is axisDim
+
+      var dirMap = {
+        top: -1,
+        bottom: 1,
+        left: -1,
+        right: 1
+      };
+      layout.labelDirection = layout.tickDirection = layout.nameDirection = dirMap[rawAxisPosition];
+      layout.labelOffset = otherAxisOnZeroOf ? posBound[idx[rawAxisPosition]] - posBound[idx.onZero] : 0;
+
+      if (axisModel.get(['axisTick', 'inside'])) {
+        layout.tickDirection = -layout.tickDirection;
+      }
+
+      if (retrieve(opt.labelInside, axisModel.get(['axisLabel', 'inside']))) {
+        layout.labelDirection = -layout.labelDirection;
+      } // Special label rotation
+
+
+      var labelRotate = axisModel.get(['axisLabel', 'rotate']);
+      layout.labelRotate = axisPosition === 'top' ? -labelRotate : labelRotate; // Over splitLine and splitArea
+
+      layout.z2 = 1;
+      return layout;
+    }
+    function isCartesian2DSeries(seriesModel) {
+      return seriesModel.get('coordinateSystem') === 'cartesian2d';
+    }
+    function findAxisModels(seriesModel) {
+      var axisModelMap = {
+        xAxisModel: null,
+        yAxisModel: null
+      };
+      each(axisModelMap, function (v, key) {
+        var axisType = key.replace(/Model$/, '');
+        var axisModel = seriesModel.getReferringComponents(axisType, SINGLE_REFERRING).models[0];
+
+        if ("development" !== 'production') {
+          if (!axisModel) {
+            throw new Error(axisType + ' "' + retrieve3(seriesModel.get(axisType + 'Index'), seriesModel.get(axisType + 'Id'), 0) + '" not found');
+          }
+        }
+
+        axisModelMap[key] = axisModel;
+      });
+      return axisModelMap;
+    }
+
+    var Grid =
+    /** @class */
+    function () {
+      function Grid(gridModel, ecModel, api) {
+        // FIXME:TS where used (different from registered type 'cartesian2d')?
+        this.type = 'grid';
+        this._coordsMap = {};
+        this._coordsList = [];
+        this._axesMap = {};
+        this._axesList = [];
+        this.axisPointerEnabled = true;
+        this.dimensions = cartesian2DDimensions;
+
+        this._initCartesian(gridModel, ecModel, api);
+
+        this.model = gridModel;
+      }
+
+      Grid.prototype.getRect = function () {
+        return this._rect;
+      };
+
+      Grid.prototype.update = function (ecModel, api) {
+        var axesMap = this._axesMap;
+
+        this._updateScale(ecModel, this.model);
+
+        each(axesMap.x, function (xAxis) {
+          niceScaleExtent(xAxis.scale, xAxis.model);
+        });
+        each(axesMap.y, function (yAxis) {
+          niceScaleExtent(yAxis.scale, yAxis.model);
+        }); // Key: axisDim_axisIndex, value: boolean, whether onZero target.
+
+        var onZeroRecords = {};
+        each(axesMap.x, function (xAxis) {
+          fixAxisOnZero(axesMap, 'y', xAxis, onZeroRecords);
+        });
+        each(axesMap.y, function (yAxis) {
+          fixAxisOnZero(axesMap, 'x', yAxis, onZeroRecords);
+        }); // Resize again if containLabel is enabled
+        // FIXME It may cause getting wrong grid size in data processing stage
+
+        this.resize(this.model, api);
+      };
+      /**
+       * Resize the grid
+       */
+
+
+      Grid.prototype.resize = function (gridModel, api, ignoreContainLabel) {
+        var boxLayoutParams = gridModel.getBoxLayoutParams();
+        var isContainLabel = !ignoreContainLabel && gridModel.get('containLabel');
+        var gridRect = getLayoutRect(boxLayoutParams, {
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+        this._rect = gridRect;
+        var axesList = this._axesList;
+        adjustAxes(); // Minus label size
+
+        if (isContainLabel) {
+          each(axesList, function (axis) {
+            if (!axis.model.get(['axisLabel', 'inside'])) {
+              var labelUnionRect = estimateLabelUnionRect(axis);
+
+              if (labelUnionRect) {
+                var dim = axis.isHorizontal() ? 'height' : 'width';
+                var margin = axis.model.get(['axisLabel', 'margin']);
+                gridRect[dim] -= labelUnionRect[dim] + margin;
+
+                if (axis.position === 'top') {
+                  gridRect.y += labelUnionRect.height + margin;
+                } else if (axis.position === 'left') {
+                  gridRect.x += labelUnionRect.width + margin;
+                }
+              }
+            }
+          });
+          adjustAxes();
+        }
+
+        each(this._coordsList, function (coord) {
+          // Calculate affine matrix to accelerate the data to point transform.
+          // If all the axes scales are time or value.
+          coord.calcAffineTransform();
+        });
+
+        function adjustAxes() {
+          each(axesList, function (axis) {
+            var isHorizontal = axis.isHorizontal();
+            var extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height];
+            var idx = axis.inverse ? 1 : 0;
+            axis.setExtent(extent[idx], extent[1 - idx]);
+            updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y);
+          });
+        }
+      };
+
+      Grid.prototype.getAxis = function (dim, axisIndex) {
+        var axesMapOnDim = this._axesMap[dim];
+
+        if (axesMapOnDim != null) {
+          return axesMapOnDim[axisIndex || 0]; // if (axisIndex == null) {
+          //     Find first axis
+          //     for (let name in axesMapOnDim) {
+          //         if (axesMapOnDim.hasOwnProperty(name)) {
+          //             return axesMapOnDim[name];
+          //         }
+          //     }
+          // }
+          // return axesMapOnDim[axisIndex];
+        }
+      };
+
+      Grid.prototype.getAxes = function () {
+        return this._axesList.slice();
+      };
+
+      Grid.prototype.getCartesian = function (xAxisIndex, yAxisIndex) {
+        if (xAxisIndex != null && yAxisIndex != null) {
+          var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+          return this._coordsMap[key];
+        }
+
+        if (isObject(xAxisIndex)) {
+          yAxisIndex = xAxisIndex.yAxisIndex;
+          xAxisIndex = xAxisIndex.xAxisIndex;
+        }
+
+        for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) {
+          if (coordList[i].getAxis('x').index === xAxisIndex || coordList[i].getAxis('y').index === yAxisIndex) {
+            return coordList[i];
+          }
+        }
+      };
+
+      Grid.prototype.getCartesians = function () {
+        return this._coordsList.slice();
+      };
+      /**
+       * @implements
+       */
+
+
+      Grid.prototype.convertToPixel = function (ecModel, finder, value) {
+        var target = this._findConvertTarget(finder);
+
+        return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null;
+      };
+      /**
+       * @implements
+       */
+
+
+      Grid.prototype.convertFromPixel = function (ecModel, finder, value) {
+        var target = this._findConvertTarget(finder);
+
+        return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null;
+      };
+
+      Grid.prototype._findConvertTarget = function (finder) {
+        var seriesModel = finder.seriesModel;
+        var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents('xAxis', SINGLE_REFERRING).models[0];
+        var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents('yAxis', SINGLE_REFERRING).models[0];
+        var gridModel = finder.gridModel;
+        var coordsList = this._coordsList;
+        var cartesian;
+        var axis;
+
+        if (seriesModel) {
+          cartesian = seriesModel.coordinateSystem;
+          indexOf(coordsList, cartesian) < 0 && (cartesian = null);
+        } else if (xAxisModel && yAxisModel) {
+          cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+        } else if (xAxisModel) {
+          axis = this.getAxis('x', xAxisModel.componentIndex);
+        } else if (yAxisModel) {
+          axis = this.getAxis('y', yAxisModel.componentIndex);
+        } // Lowest priority.
+        else if (gridModel) {
+            var grid = gridModel.coordinateSystem;
+
+            if (grid === this) {
+              cartesian = this._coordsList[0];
+            }
+          }
+
+        return {
+          cartesian: cartesian,
+          axis: axis
+        };
+      };
+      /**
+       * @implements
+       */
+
+
+      Grid.prototype.containPoint = function (point) {
+        var coord = this._coordsList[0];
+
+        if (coord) {
+          return coord.containPoint(point);
+        }
+      };
+      /**
+       * Initialize cartesian coordinate systems
+       */
+
+
+      Grid.prototype._initCartesian = function (gridModel, ecModel, api) {
+        var _this = this;
+
+        var grid = this;
+        var axisPositionUsed = {
+          left: false,
+          right: false,
+          top: false,
+          bottom: false
+        };
+        var axesMap = {
+          x: {},
+          y: {}
+        };
+        var axesCount = {
+          x: 0,
+          y: 0
+        }; /// Create axis
+
+        ecModel.eachComponent('xAxis', createAxisCreator('x'), this);
+        ecModel.eachComponent('yAxis', createAxisCreator('y'), this);
+
+        if (!axesCount.x || !axesCount.y) {
+          // Roll back when there no either x or y axis
+          this._axesMap = {};
+          this._axesList = [];
+          return;
+        }
+
+        this._axesMap = axesMap; /// Create cartesian2d
+
+        each(axesMap.x, function (xAxis, xAxisIndex) {
+          each(axesMap.y, function (yAxis, yAxisIndex) {
+            var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+            var cartesian = new Cartesian2D(key);
+            cartesian.master = _this;
+            cartesian.model = gridModel;
+            _this._coordsMap[key] = cartesian;
+
+            _this._coordsList.push(cartesian);
+
+            cartesian.addAxis(xAxis);
+            cartesian.addAxis(yAxis);
+          });
+        });
+
+        function createAxisCreator(dimName) {
+          return function (axisModel, idx) {
+            if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
+              return;
+            }
+
+            var axisPosition = axisModel.get('position');
+
+            if (dimName === 'x') {
+              // Fix position
+              if (axisPosition !== 'top' && axisPosition !== 'bottom') {
+                // Default bottom of X
+                axisPosition = axisPositionUsed.bottom ? 'top' : 'bottom';
+              }
+            } else {
+              // Fix position
+              if (axisPosition !== 'left' && axisPosition !== 'right') {
+                // Default left of Y
+                axisPosition = axisPositionUsed.left ? 'right' : 'left';
+              }
+            }
+
+            axisPositionUsed[axisPosition] = true;
+            var axis = new Axis2D(dimName, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisPosition);
+            var isCategory = axis.type === 'category';
+            axis.onBand = isCategory && axisModel.get('boundaryGap');
+            axis.inverse = axisModel.get('inverse'); // Inject axis into axisModel
+
+            axisModel.axis = axis; // Inject axisModel into axis
+
+            axis.model = axisModel; // Inject grid info axis
+
+            axis.grid = grid; // Index of axis, can be used as key
+
+            axis.index = idx;
+
+            grid._axesList.push(axis);
+
+            axesMap[dimName][idx] = axis;
+            axesCount[dimName]++;
+          };
+        }
+      };
+      /**
+       * Update cartesian properties from series.
+       */
+
+
+      Grid.prototype._updateScale = function (ecModel, gridModel) {
+        // Reset scale
+        each(this._axesList, function (axis) {
+          axis.scale.setExtent(Infinity, -Infinity);
+
+          if (axis.type === 'category') {
+            var categorySortInfo = axis.model.get('categorySortInfo');
+            axis.scale.setSortInfo(categorySortInfo);
+          }
+        });
+        ecModel.eachSeries(function (seriesModel) {
+          if (isCartesian2DSeries(seriesModel)) {
+            var axesModelMap = findAxisModels(seriesModel);
+            var xAxisModel = axesModelMap.xAxisModel;
+            var yAxisModel = axesModelMap.yAxisModel;
+
+            if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) {
+              return;
+            }
+
+            var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+            var data = seriesModel.getData();
+            var xAxis = cartesian.getAxis('x');
+            var yAxis = cartesian.getAxis('y');
+
+            if (data.type === 'list') {
+              unionExtent(data, xAxis);
+              unionExtent(data, yAxis);
+            }
+          }
+        }, this);
+
+        function unionExtent(data, axis) {
+          each(getDataDimensionsOnAxis(data, axis.dim), function (dim) {
+            axis.scale.unionExtentFromData(data, dim);
+          });
+        }
+      };
+      /**
+       * @param dim 'x' or 'y' or 'auto' or null/undefined
+       */
+
+
+      Grid.prototype.getTooltipAxes = function (dim) {
+        var baseAxes = [];
+        var otherAxes = [];
+        each(this.getCartesians(), function (cartesian) {
+          var baseAxis = dim != null && dim !== 'auto' ? cartesian.getAxis(dim) : cartesian.getBaseAxis();
+          var otherAxis = cartesian.getOtherAxis(baseAxis);
+          indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
+          indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
+        });
+        return {
+          baseAxes: baseAxes,
+          otherAxes: otherAxes
+        };
+      };
+
+      Grid.create = function (ecModel, api) {
+        var grids = [];
+        ecModel.eachComponent('grid', function (gridModel, idx) {
+          var grid = new Grid(gridModel, ecModel, api);
+          grid.name = 'grid_' + idx; // dataSampling requires axis extent, so resize
+          // should be performed in create stage.
+
+          grid.resize(gridModel, api, true);
+          gridModel.coordinateSystem = grid;
+          grids.push(grid);
+        }); // Inject the coordinateSystems into seriesModel
+
+        ecModel.eachSeries(function (seriesModel) {
+          if (!isCartesian2DSeries(seriesModel)) {
+            return;
+          }
+
+          var axesModelMap = findAxisModels(seriesModel);
+          var xAxisModel = axesModelMap.xAxisModel;
+          var yAxisModel = axesModelMap.yAxisModel;
+          var gridModel = xAxisModel.getCoordSysModel();
+
+          if ("development" !== 'production') {
+            if (!gridModel) {
+              throw new Error('Grid "' + retrieve3(xAxisModel.get('gridIndex'), xAxisModel.get('gridId'), 0) + '" not found');
+            }
+
+            if (xAxisModel.getCoordSysModel() !== yAxisModel.getCoordSysModel()) {
+              throw new Error('xAxis and yAxis must use the same grid');
+            }
+          }
+
+          var grid = gridModel.coordinateSystem;
+          seriesModel.coordinateSystem = grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+        });
+        return grids;
+      }; // For deciding which dimensions to use when creating list data
+
+
+      Grid.dimensions = cartesian2DDimensions;
+      return Grid;
+    }();
+    /**
+     * Check if the axis is used in the specified grid.
+     */
+
+
+    function isAxisUsedInTheGrid(axisModel, gridModel) {
+      return axisModel.getCoordSysModel() === gridModel;
+    }
+
+    function fixAxisOnZero(axesMap, otherAxisDim, axis, // Key: see `getOnZeroRecordKey`
+    onZeroRecords) {
+      axis.getAxesOnZeroOf = function () {
+        // TODO: onZero of multiple axes.
+        return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
+      }; // onZero can not be enabled in these two situations:
+      // 1. When any other axis is a category axis.
+      // 2. When no axis is cross 0 point.
+
+
+      var otherAxes = axesMap[otherAxisDim];
+      var otherAxisOnZeroOf;
+      var axisModel = axis.model;
+      var onZero = axisModel.get(['axisLine', 'onZero']);
+      var onZeroAxisIndex = axisModel.get(['axisLine', 'onZeroAxisIndex']);
+
+      if (!onZero) {
+        return;
+      } // If target axis is specified.
+
+
+      if (onZeroAxisIndex != null) {
+        if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
+          otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
+        }
+      } else {
+        // Find the first available other axis.
+        for (var idx in otherAxes) {
+          if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx]) // Consider that two Y axes on one value axis,
+          // if both onZero, the two Y axes overlap.
+          && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) {
+            otherAxisOnZeroOf = otherAxes[idx];
+            break;
+          }
+        }
+      }
+
+      if (otherAxisOnZeroOf) {
+        onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
+      }
+
+      function getOnZeroRecordKey(axis) {
+        return axis.dim + '_' + axis.index;
+      }
+    }
+
+    function canOnZeroToAxis(axis) {
+      return axis && axis.type !== 'category' && axis.type !== 'time' && ifAxisCrossZero(axis);
+    }
+
+    function updateAxisTransform(axis, coordBase) {
+      var axisExtent = axis.getExtent();
+      var axisExtentSum = axisExtent[0] + axisExtent[1]; // Fast transform
+
+      axis.toGlobalCoord = axis.dim === 'x' ? function (coord) {
+        return coord + coordBase;
+      } : function (coord) {
+        return axisExtentSum - coord + coordBase;
+      };
+      axis.toLocalCoord = axis.dim === 'x' ? function (coord) {
+        return coord - coordBase;
+      } : function (coord) {
+        return axisExtentSum - coord + coordBase;
+      };
+    }
+
+    var PI$5 = Math.PI;
+    /**
+     * A final axis is translated and rotated from a "standard axis".
+     * So opt.position and opt.rotation is required.
+     *
+     * A standard axis is and axis from [0, 0] to [0, axisExtent[1]],
+     * for example: (0, 0) ------------> (0, 50)
+     *
+     * nameDirection or tickDirection or labelDirection is 1 means tick
+     * or label is below the standard axis, whereas is -1 means above
+     * the standard axis. labelOffset means offset between label and axis,
+     * which is useful when 'onZero', where axisLabel is in the grid and
+     * label in outside grid.
+     *
+     * Tips: like always,
+     * positive rotation represents anticlockwise, and negative rotation
+     * represents clockwise.
+     * The direction of position coordinate is the same as the direction
+     * of screen coordinate.
+     *
+     * Do not need to consider axis 'inverse', which is auto processed by
+     * axis extent.
+     */
+
+    var AxisBuilder =
+    /** @class */
+    function () {
+      function AxisBuilder(axisModel, opt) {
+        this.group = new Group();
+        this.opt = opt;
+        this.axisModel = axisModel; // Default value
+
+        defaults(opt, {
+          labelOffset: 0,
+          nameDirection: 1,
+          tickDirection: 1,
+          labelDirection: 1,
+          silent: true,
+          handleAutoShown: function () {
+            return true;
+          }
+        }); // FIXME Not use a seperate text group?
+
+        var transformGroup = new Group({
+          x: opt.position[0],
+          y: opt.position[1],
+          rotation: opt.rotation
+        }); // this.group.add(transformGroup);
+        // this._transformGroup = transformGroup;
+
+        transformGroup.updateTransform();
+        this._transformGroup = transformGroup;
+      }
+
+      AxisBuilder.prototype.hasBuilder = function (name) {
+        return !!builders[name];
+      };
+
+      AxisBuilder.prototype.add = function (name) {
+        builders[name](this.opt, this.axisModel, this.group, this._transformGroup);
+      };
+
+      AxisBuilder.prototype.getGroup = function () {
+        return this.group;
+      };
+
+      AxisBuilder.innerTextLayout = function (axisRotation, textRotation, direction) {
+        var rotationDiff = remRadian(textRotation - axisRotation);
+        var textAlign;
+        var textVerticalAlign;
+
+        if (isRadianAroundZero(rotationDiff)) {
+          // Label is parallel with axis line.
+          textVerticalAlign = direction > 0 ? 'top' : 'bottom';
+          textAlign = 'center';
+        } else if (isRadianAroundZero(rotationDiff - PI$5)) {
+          // Label is inverse parallel with axis line.
+          textVerticalAlign = direction > 0 ? 'bottom' : 'top';
+          textAlign = 'center';
+        } else {
+          textVerticalAlign = 'middle';
+
+          if (rotationDiff > 0 && rotationDiff < PI$5) {
+            textAlign = direction > 0 ? 'right' : 'left';
+          } else {
+            textAlign = direction > 0 ? 'left' : 'right';
+          }
+        }
+
+        return {
+          rotation: rotationDiff,
+          textAlign: textAlign,
+          textVerticalAlign: textVerticalAlign
+        };
+      };
+
+      AxisBuilder.makeAxisEventDataBase = function (axisModel) {
+        var eventData = {
+          componentType: axisModel.mainType,
+          componentIndex: axisModel.componentIndex
+        };
+        eventData[axisModel.mainType + 'Index'] = axisModel.componentIndex;
+        return eventData;
+      };
+
+      AxisBuilder.isLabelSilent = function (axisModel) {
+        var tooltipOpt = axisModel.get('tooltip');
+        return axisModel.get('silent') // Consider mouse cursor, add these restrictions.
+        || !(axisModel.get('triggerEvent') || tooltipOpt && tooltipOpt.show);
+      };
+
+      return AxisBuilder;
+    }();
+    var builders = {
+      axisLine: function (opt, axisModel, group, transformGroup) {
+        var shown = axisModel.get(['axisLine', 'show']);
+
+        if (shown === 'auto' && opt.handleAutoShown) {
+          shown = opt.handleAutoShown('axisLine');
+        }
+
+        if (!shown) {
+          return;
+        }
+
+        var extent = axisModel.axis.getExtent();
+        var matrix = transformGroup.transform;
+        var pt1 = [extent[0], 0];
+        var pt2 = [extent[1], 0];
+
+        if (matrix) {
+          applyTransform(pt1, pt1, matrix);
+          applyTransform(pt2, pt2, matrix);
+        }
+
+        var lineStyle = extend({
+          lineCap: 'round'
+        }, axisModel.getModel(['axisLine', 'lineStyle']).getLineStyle());
+        var line = new Line({
+          // Id for animation
+          subPixelOptimize: true,
+          shape: {
+            x1: pt1[0],
+            y1: pt1[1],
+            x2: pt2[0],
+            y2: pt2[1]
+          },
+          style: lineStyle,
+          strokeContainThreshold: opt.strokeContainThreshold || 5,
+          silent: true,
+          z2: 1
+        });
+        line.anid = 'line';
+        group.add(line);
+        var arrows = axisModel.get(['axisLine', 'symbol']);
+        var arrowSize = axisModel.get(['axisLine', 'symbolSize']);
+        var arrowOffset = axisModel.get(['axisLine', 'symbolOffset']) || 0;
+
+        if (typeof arrowOffset === 'number') {
+          arrowOffset = [arrowOffset, arrowOffset];
+        }
+
+        if (arrows != null) {
+          if (typeof arrows === 'string') {
+            // Use the same arrow for start and end point
+            arrows = [arrows, arrows];
+          }
+
+          if (typeof arrowSize === 'string' || typeof arrowSize === 'number') {
+            // Use the same size for width and height
+            arrowSize = [arrowSize, arrowSize];
+          }
+
+          var symbolWidth_1 = arrowSize[0];
+          var symbolHeight_1 = arrowSize[1];
+          each([{
+            rotate: opt.rotation + Math.PI / 2,
+            offset: arrowOffset[0],
+            r: 0
+          }, {
+            rotate: opt.rotation - Math.PI / 2,
+            offset: arrowOffset[1],
+            r: Math.sqrt((pt1[0] - pt2[0]) * (pt1[0] - pt2[0]) + (pt1[1] - pt2[1]) * (pt1[1] - pt2[1]))
+          }], function (point, index) {
+            if (arrows[index] !== 'none' && arrows[index] != null) {
+              var symbol = createSymbol(arrows[index], -symbolWidth_1 / 2, -symbolHeight_1 / 2, symbolWidth_1, symbolHeight_1, lineStyle.stroke, true); // Calculate arrow position with offset
+
+              var r = point.r + point.offset;
+              symbol.attr({
+                rotation: point.rotate,
+                x: pt1[0] + r * Math.cos(opt.rotation),
+                y: pt1[1] - r * Math.sin(opt.rotation),
+                silent: true,
+                z2: 11
+              });
+              group.add(symbol);
+            }
+          });
+        }
+      },
+      axisTickLabel: function (opt, axisModel, group, transformGroup) {
+        var ticksEls = buildAxisMajorTicks(group, transformGroup, axisModel, opt);
+        var labelEls = buildAxisLabel(group, transformGroup, axisModel, opt);
+        fixMinMaxLabelShow(axisModel, labelEls, ticksEls);
+        buildAxisMinorTicks(group, transformGroup, axisModel, opt.tickDirection);
+      },
+      axisName: function (opt, axisModel, group, transformGroup) {
+        var name = retrieve(opt.axisName, axisModel.get('name'));
+
+        if (!name) {
+          return;
+        }
+
+        var nameLocation = axisModel.get('nameLocation');
+        var nameDirection = opt.nameDirection;
+        var textStyleModel = axisModel.getModel('nameTextStyle');
+        var gap = axisModel.get('nameGap') || 0;
+        var extent = axisModel.axis.getExtent();
+        var gapSignal = extent[0] > extent[1] ? -1 : 1;
+        var pos = [nameLocation === 'start' ? extent[0] - gapSignal * gap : nameLocation === 'end' ? extent[1] + gapSignal * gap : (extent[0] + extent[1]) / 2, // Reuse labelOffset.
+        isNameLocationCenter(nameLocation) ? opt.labelOffset + nameDirection * gap : 0];
+        var labelLayout;
+        var nameRotation = axisModel.get('nameRotate');
+
+        if (nameRotation != null) {
+          nameRotation = nameRotation * PI$5 / 180; // To radian.
+        }
+
+        var axisNameAvailableWidth;
+
+        if (isNameLocationCenter(nameLocation)) {
+          labelLayout = AxisBuilder.innerTextLayout(opt.rotation, nameRotation != null ? nameRotation : opt.rotation, // Adapt to axis.
+          nameDirection);
+        } else {
+          labelLayout = endTextLayout(opt.rotation, nameLocation, nameRotation || 0, extent);
+          axisNameAvailableWidth = opt.axisNameAvailableWidth;
+
+          if (axisNameAvailableWidth != null) {
+            axisNameAvailableWidth = Math.abs(axisNameAvailableWidth / Math.sin(labelLayout.rotation));
+            !isFinite(axisNameAvailableWidth) && (axisNameAvailableWidth = null);
+          }
+        }
+
+        var textFont = textStyleModel.getFont();
+        var truncateOpt = axisModel.get('nameTruncate', true) || {};
+        var ellipsis = truncateOpt.ellipsis;
+        var maxWidth = retrieve(opt.nameTruncateMaxWidth, truncateOpt.maxWidth, axisNameAvailableWidth);
+        var tooltipOpt = axisModel.get('tooltip', true);
+        var mainType = axisModel.mainType;
+        var formatterParams = {
+          componentType: mainType,
+          name: name,
+          $vars: ['name']
+        };
+        formatterParams[mainType + 'Index'] = axisModel.componentIndex;
+        var textEl = new ZRText({
+          x: pos[0],
+          y: pos[1],
+          rotation: labelLayout.rotation,
+          silent: AxisBuilder.isLabelSilent(axisModel),
+          style: createTextStyle(textStyleModel, {
+            text: name,
+            font: textFont,
+            overflow: 'truncate',
+            width: maxWidth,
+            ellipsis: ellipsis,
+            fill: textStyleModel.getTextColor() || axisModel.get(['axisLine', 'lineStyle', 'color']),
+            align: textStyleModel.get('align') || labelLayout.textAlign,
+            verticalAlign: textStyleModel.get('verticalAlign') || labelLayout.textVerticalAlign
+          }),
+          z2: 1
+        });
+        textEl.tooltip = tooltipOpt && tooltipOpt.show ? extend({
+          content: name,
+          formatter: function () {
+            return name;
+          },
+          formatterParams: formatterParams
+        }, tooltipOpt) : null;
+        textEl.__fullText = name; // Id for animation
+
+        textEl.anid = 'name';
+
+        if (axisModel.get('triggerEvent')) {
+          var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
+          eventData.targetType = 'axisName';
+          eventData.name = name;
+          getECData(textEl).eventData = eventData;
+        } // FIXME
+
+
+        transformGroup.add(textEl);
+        textEl.updateTransform();
+        group.add(textEl);
+        textEl.decomposeTransform();
+      }
+    };
+
+    function endTextLayout(rotation, textPosition, textRotate, extent) {
+      var rotationDiff = remRadian(textRotate - rotation);
+      var textAlign;
+      var textVerticalAlign;
+      var inverse = extent[0] > extent[1];
+      var onLeft = textPosition === 'start' && !inverse || textPosition !== 'start' && inverse;
+
+      if (isRadianAroundZero(rotationDiff - PI$5 / 2)) {
+        textVerticalAlign = onLeft ? 'bottom' : 'top';
+        textAlign = 'center';
+      } else if (isRadianAroundZero(rotationDiff - PI$5 * 1.5)) {
+        textVerticalAlign = onLeft ? 'top' : 'bottom';
+        textAlign = 'center';
+      } else {
+        textVerticalAlign = 'middle';
+
+        if (rotationDiff < PI$5 * 1.5 && rotationDiff > PI$5 / 2) {
+          textAlign = onLeft ? 'left' : 'right';
+        } else {
+          textAlign = onLeft ? 'right' : 'left';
+        }
+      }
+
+      return {
+        rotation: rotationDiff,
+        textAlign: textAlign,
+        textVerticalAlign: textVerticalAlign
+      };
+    }
+
+    function fixMinMaxLabelShow(axisModel, labelEls, tickEls) {
+      if (shouldShowAllLabels(axisModel.axis)) {
+        return;
+      } // If min or max are user set, we need to check
+      // If the tick on min(max) are overlap on their neighbour tick
+      // If they are overlapped, we need to hide the min(max) tick label
+
+
+      var showMinLabel = axisModel.get(['axisLabel', 'showMinLabel']);
+      var showMaxLabel = axisModel.get(['axisLabel', 'showMaxLabel']); // FIXME
+      // Have not consider onBand yet, where tick els is more than label els.
+
+      labelEls = labelEls || [];
+      tickEls = tickEls || [];
+      var firstLabel = labelEls[0];
+      var nextLabel = labelEls[1];
+      var lastLabel = labelEls[labelEls.length - 1];
+      var prevLabel = labelEls[labelEls.length - 2];
+      var firstTick = tickEls[0];
+      var nextTick = tickEls[1];
+      var lastTick = tickEls[tickEls.length - 1];
+      var prevTick = tickEls[tickEls.length - 2];
+
+      if (showMinLabel === false) {
+        ignoreEl(firstLabel);
+        ignoreEl(firstTick);
+      } else if (isTwoLabelOverlapped(firstLabel, nextLabel)) {
+        if (showMinLabel) {
+          ignoreEl(nextLabel);
+          ignoreEl(nextTick);
+        } else {
+          ignoreEl(firstLabel);
+          ignoreEl(firstTick);
+        }
+      }
+
+      if (showMaxLabel === false) {
+        ignoreEl(lastLabel);
+        ignoreEl(lastTick);
+      } else if (isTwoLabelOverlapped(prevLabel, lastLabel)) {
+        if (showMaxLabel) {
+          ignoreEl(prevLabel);
+          ignoreEl(prevTick);
+        } else {
+          ignoreEl(lastLabel);
+          ignoreEl(lastTick);
+        }
+      }
+    }
+
+    function ignoreEl(el) {
+      el && (el.ignore = true);
+    }
+
+    function isTwoLabelOverlapped(current, next) {
+      // current and next has the same rotation.
+      var firstRect = current && current.getBoundingRect().clone();
+      var nextRect = next && next.getBoundingRect().clone();
+
+      if (!firstRect || !nextRect) {
+        return;
+      } // When checking intersect of two rotated labels, we use mRotationBack
+      // to avoid that boundingRect is enlarge when using `boundingRect.applyTransform`.
+
+
+      var mRotationBack = identity([]);
+      rotate(mRotationBack, mRotationBack, -current.rotation);
+      firstRect.applyTransform(mul$1([], mRotationBack, current.getLocalTransform()));
+      nextRect.applyTransform(mul$1([], mRotationBack, next.getLocalTransform()));
+      return firstRect.intersect(nextRect);
+    }
+
+    function isNameLocationCenter(nameLocation) {
+      return nameLocation === 'middle' || nameLocation === 'center';
+    }
+
+    function createTicks(ticksCoords, tickTransform, tickEndCoord, tickLineStyle, anidPrefix) {
+      var tickEls = [];
+      var pt1 = [];
+      var pt2 = [];
+
+      for (var i = 0; i < ticksCoords.length; i++) {
+        var tickCoord = ticksCoords[i].coord;
+        pt1[0] = tickCoord;
+        pt1[1] = 0;
+        pt2[0] = tickCoord;
+        pt2[1] = tickEndCoord;
+
+        if (tickTransform) {
+          applyTransform(pt1, pt1, tickTransform);
+          applyTransform(pt2, pt2, tickTransform);
+        } // Tick line, Not use group transform to have better line draw
+
+
+        var tickEl = new Line({
+          subPixelOptimize: true,
+          shape: {
+            x1: pt1[0],
+            y1: pt1[1],
+            x2: pt2[0],
+            y2: pt2[1]
+          },
+          style: tickLineStyle,
+          z2: 2,
+          autoBatch: true,
+          silent: true
+        });
+        tickEl.anid = anidPrefix + '_' + ticksCoords[i].tickValue;
+        tickEls.push(tickEl);
+      }
+
+      return tickEls;
+    }
+
+    function buildAxisMajorTicks(group, transformGroup, axisModel, opt) {
+      var axis = axisModel.axis;
+      var tickModel = axisModel.getModel('axisTick');
+      var shown = tickModel.get('show');
+
+      if (shown === 'auto' && opt.handleAutoShown) {
+        shown = opt.handleAutoShown('axisTick');
+      }
+
+      if (!shown || axis.scale.isBlank()) {
+        return;
+      }
+
+      var lineStyleModel = tickModel.getModel('lineStyle');
+      var tickEndCoord = opt.tickDirection * tickModel.get('length');
+      var ticksCoords = axis.getTicksCoords();
+      var ticksEls = createTicks(ticksCoords, transformGroup.transform, tickEndCoord, defaults(lineStyleModel.getLineStyle(), {
+        stroke: axisModel.get(['axisLine', 'lineStyle', 'color'])
+      }), 'ticks');
+
+      for (var i = 0; i < ticksEls.length; i++) {
+        group.add(ticksEls[i]);
+      }
+
+      return ticksEls;
+    }
+
+    function buildAxisMinorTicks(group, transformGroup, axisModel, tickDirection) {
+      var axis = axisModel.axis;
+      var minorTickModel = axisModel.getModel('minorTick');
+
+      if (!minorTickModel.get('show') || axis.scale.isBlank()) {
+        return;
+      }
+
+      var minorTicksCoords = axis.getMinorTicksCoords();
+
+      if (!minorTicksCoords.length) {
+        return;
+      }
+
+      var lineStyleModel = minorTickModel.getModel('lineStyle');
+      var tickEndCoord = tickDirection * minorTickModel.get('length');
+      var minorTickLineStyle = defaults(lineStyleModel.getLineStyle(), defaults(axisModel.getModel('axisTick').getLineStyle(), {
+        stroke: axisModel.get(['axisLine', 'lineStyle', 'color'])
+      }));
+
+      for (var i = 0; i < minorTicksCoords.length; i++) {
+        var minorTicksEls = createTicks(minorTicksCoords[i], transformGroup.transform, tickEndCoord, minorTickLineStyle, 'minorticks_' + i);
+
+        for (var k = 0; k < minorTicksEls.length; k++) {
+          group.add(minorTicksEls[k]);
+        }
+      }
+    }
+
+    function buildAxisLabel(group, transformGroup, axisModel, opt) {
+      var axis = axisModel.axis;
+      var show = retrieve(opt.axisLabelShow, axisModel.get(['axisLabel', 'show']));
+
+      if (!show || axis.scale.isBlank()) {
+        return;
+      }
+
+      var labelModel = axisModel.getModel('axisLabel');
+      var labelMargin = labelModel.get('margin');
+      var labels = axis.getViewLabels(); // Special label rotate.
+
+      var labelRotation = (retrieve(opt.labelRotate, labelModel.get('rotate')) || 0) * PI$5 / 180;
+      var labelLayout = AxisBuilder.innerTextLayout(opt.rotation, labelRotation, opt.labelDirection);
+      var rawCategoryData = axisModel.getCategories && axisModel.getCategories(true);
+      var labelEls = [];
+      var silent = AxisBuilder.isLabelSilent(axisModel);
+      var triggerEvent = axisModel.get('triggerEvent');
+      each(labels, function (labelItem, index) {
+        var tickValue = axis.scale.type === 'ordinal' ? axis.scale.getRawOrdinalNumber(labelItem.tickValue) : labelItem.tickValue;
+        var formattedLabel = labelItem.formattedLabel;
+        var rawLabel = labelItem.rawLabel;
+        var itemLabelModel = labelModel;
+
+        if (rawCategoryData && rawCategoryData[tickValue]) {
+          var rawCategoryItem = rawCategoryData[tickValue];
+
+          if (isObject(rawCategoryItem) && rawCategoryItem.textStyle) {
+            itemLabelModel = new Model(rawCategoryItem.textStyle, labelModel, axisModel.ecModel);
+          }
+        }
+
+        var textColor = itemLabelModel.getTextColor() || axisModel.get(['axisLine', 'lineStyle', 'color']);
+        var tickCoord = axis.dataToCoord(tickValue);
+        var textEl = new ZRText({
+          x: tickCoord,
+          y: opt.labelOffset + opt.labelDirection * labelMargin,
+          rotation: labelLayout.rotation,
+          silent: silent,
+          z2: 10,
+          style: createTextStyle(itemLabelModel, {
+            text: formattedLabel,
+            align: itemLabelModel.getShallow('align', true) || labelLayout.textAlign,
+            verticalAlign: itemLabelModel.getShallow('verticalAlign', true) || itemLabelModel.getShallow('baseline', true) || labelLayout.textVerticalAlign,
+            fill: typeof textColor === 'function' ? textColor( // (1) In category axis with data zoom, tick is not the original
+            // index of axis.data. So tick should not be exposed to user
+            // in category axis.
+            // (2) Compatible with previous version, which always use formatted label as
+            // input. But in interval scale the formatted label is like '223,445', which
+            // maked user repalce ','. So we modify it to return original val but remain
+            // it as 'string' to avoid error in replacing.
+            axis.type === 'category' ? rawLabel : axis.type === 'value' ? tickValue + '' : tickValue, index) : textColor
+          })
+        });
+        textEl.anid = 'label_' + tickValue; // Pack data for mouse event
+
+        if (triggerEvent) {
+          var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
+          eventData.targetType = 'axisLabel';
+          eventData.value = rawLabel;
+          getECData(textEl).eventData = eventData;
+        } // FIXME
+
+
+        transformGroup.add(textEl);
+        textEl.updateTransform();
+        labelEls.push(textEl);
+        group.add(textEl);
+        textEl.decomposeTransform();
+      });
+      return labelEls;
+    }
+
+    // allAxesInfo should be updated when setOption performed.
+
+    function collect(ecModel, api) {
+      var result = {
+        /**
+         * key: makeKey(axis.model)
+         * value: {
+         *      axis,
+         *      coordSys,
+         *      axisPointerModel,
+         *      triggerTooltip,
+         *      involveSeries,
+         *      snap,
+         *      seriesModels,
+         *      seriesDataCount
+         * }
+         */
+        axesInfo: {},
+        seriesInvolved: false,
+
+        /**
+         * key: makeKey(coordSys.model)
+         * value: Object: key makeKey(axis.model), value: axisInfo
+         */
+        coordSysAxesInfo: {},
+        coordSysMap: {}
+      };
+      collectAxesInfo(result, ecModel, api); // Check seriesInvolved for performance, in case too many series in some chart.
+
+      result.seriesInvolved && collectSeriesInfo(result, ecModel);
+      return result;
+    }
+
+    function collectAxesInfo(result, ecModel, api) {
+      var globalTooltipModel = ecModel.getComponent('tooltip');
+      var globalAxisPointerModel = ecModel.getComponent('axisPointer'); // links can only be set on global.
+
+      var linksOption = globalAxisPointerModel.get('link', true) || [];
+      var linkGroups = []; // Collect axes info.
+
+      each(api.getCoordinateSystems(), function (coordSys) {
+        // Some coordinate system do not support axes, like geo.
+        if (!coordSys.axisPointerEnabled) {
+          return;
+        }
+
+        var coordSysKey = makeKey(coordSys.model);
+        var axesInfoInCoordSys = result.coordSysAxesInfo[coordSysKey] = {};
+        result.coordSysMap[coordSysKey] = coordSys; // Set tooltip (like 'cross') is a convienent way to show axisPointer
+        // for user. So we enable seting tooltip on coordSys model.
+
+        var coordSysModel = coordSys.model;
+        var baseTooltipModel = coordSysModel.getModel('tooltip', globalTooltipModel);
+        each(coordSys.getAxes(), curry(saveTooltipAxisInfo, false, null)); // If axis tooltip used, choose tooltip axis for each coordSys.
+        // Notice this case: coordSys is `grid` but not `cartesian2D` here.
+
+        if (coordSys.getTooltipAxes && globalTooltipModel // If tooltip.showContent is set as false, tooltip will not
+        // show but axisPointer will show as normal.
+        && baseTooltipModel.get('show')) {
+          // Compatible with previous logic. But series.tooltip.trigger: 'axis'
+          // or series.data[n].tooltip.trigger: 'axis' are not support any more.
+          var triggerAxis = baseTooltipModel.get('trigger') === 'axis';
+          var cross = baseTooltipModel.get(['axisPointer', 'type']) === 'cross';
+          var tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(['axisPointer', 'axis']));
+
+          if (triggerAxis || cross) {
+            each(tooltipAxes.baseAxes, curry(saveTooltipAxisInfo, cross ? 'cross' : true, triggerAxis));
+          }
+
+          if (cross) {
+            each(tooltipAxes.otherAxes, curry(saveTooltipAxisInfo, 'cross', false));
+          }
+        } // fromTooltip: true | false | 'cross'
+        // triggerTooltip: true | false | null
+
+
+        function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) {
+          var axisPointerModel = axis.model.getModel('axisPointer', globalAxisPointerModel);
+          var axisPointerShow = axisPointerModel.get('show');
+
+          if (!axisPointerShow || axisPointerShow === 'auto' && !fromTooltip && !isHandleTrigger(axisPointerModel)) {
+            return;
+          }
+
+          if (triggerTooltip == null) {
+            triggerTooltip = axisPointerModel.get('triggerTooltip');
+          }
+
+          axisPointerModel = fromTooltip ? makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) : axisPointerModel;
+          var snap = axisPointerModel.get('snap');
+          var axisKey = makeKey(axis.model);
+          var involveSeries = triggerTooltip || snap || axis.type === 'category'; // If result.axesInfo[key] exist, override it (tooltip has higher priority).
+
+          var axisInfo = result.axesInfo[axisKey] = {
+            key: axisKey,
+            axis: axis,
+            coordSys: coordSys,
+            axisPointerModel: axisPointerModel,
+            triggerTooltip: triggerTooltip,
+            involveSeries: involveSeries,
+            snap: snap,
+            useHandle: isHandleTrigger(axisPointerModel),
+            seriesModels: [],
+            linkGroup: null
+          };
+          axesInfoInCoordSys[axisKey] = axisInfo;
+          result.seriesInvolved = result.seriesInvolved || involveSeries;
+          var groupIndex = getLinkGroupIndex(linksOption, axis);
+
+          if (groupIndex != null) {
+            var linkGroup = linkGroups[groupIndex] || (linkGroups[groupIndex] = {
+              axesInfo: {}
+            });
+            linkGroup.axesInfo[axisKey] = axisInfo;
+            linkGroup.mapper = linksOption[groupIndex].mapper;
+            axisInfo.linkGroup = linkGroup;
+          }
+        }
+      });
+    }
+
+    function makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) {
+      var tooltipAxisPointerModel = baseTooltipModel.getModel('axisPointer');
+      var fields = ['type', 'snap', 'lineStyle', 'shadowStyle', 'label', 'animation', 'animationDurationUpdate', 'animationEasingUpdate', 'z'];
+      var volatileOption = {};
+      each(fields, function (field) {
+        volatileOption[field] = clone(tooltipAxisPointerModel.get(field));
+      }); // category axis do not auto snap, otherwise some tick that do not
+      // has value can not be hovered. value/time/log axis default snap if
+      // triggered from tooltip and trigger tooltip.
+
+      volatileOption.snap = axis.type !== 'category' && !!triggerTooltip; // Compatibel with previous behavior, tooltip axis do not show label by default.
+      // Only these properties can be overrided from tooltip to axisPointer.
+
+      if (tooltipAxisPointerModel.get('type') === 'cross') {
+        volatileOption.type = 'line';
+      }
+
+      var labelOption = volatileOption.label || (volatileOption.label = {}); // Follow the convention, do not show label when triggered by tooltip by default.
+
+      labelOption.show == null && (labelOption.show = false);
+
+      if (fromTooltip === 'cross') {
+        // When 'cross', both axes show labels.
+        var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(['label', 'show']);
+        labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true; // If triggerTooltip, this is a base axis, which should better not use cross style
+        // (cross style is dashed by default)
+
+        if (!triggerTooltip) {
+          var crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get('crossStyle');
+          crossStyle && defaults(labelOption, crossStyle.textStyle);
+        }
+      }
+
+      return axis.model.getModel('axisPointer', new Model(volatileOption, globalAxisPointerModel, ecModel));
+    }
+
+    function collectSeriesInfo(result, ecModel) {
+      // Prepare data for axis trigger
+      ecModel.eachSeries(function (seriesModel) {
+        // Notice this case: this coordSys is `cartesian2D` but not `grid`.
+        var coordSys = seriesModel.coordinateSystem;
+        var seriesTooltipTrigger = seriesModel.get(['tooltip', 'trigger'], true);
+        var seriesTooltipShow = seriesModel.get(['tooltip', 'show'], true);
+
+        if (!coordSys || seriesTooltipTrigger === 'none' || seriesTooltipTrigger === false || seriesTooltipTrigger === 'item' || seriesTooltipShow === false || seriesModel.get(['axisPointer', 'show'], true) === false) {
+          return;
+        }
+
+        each(result.coordSysAxesInfo[makeKey(coordSys.model)], function (axisInfo) {
+          var axis = axisInfo.axis;
+
+          if (coordSys.getAxis(axis.dim) === axis) {
+            axisInfo.seriesModels.push(seriesModel);
+            axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
+            axisInfo.seriesDataCount += seriesModel.getData().count();
+          }
+        });
+      });
+    }
+    /**
+     * For example:
+     * {
+     *     axisPointer: {
+     *         links: [{
+     *             xAxisIndex: [2, 4],
+     *             yAxisIndex: 'all'
+     *         }, {
+     *             xAxisId: ['a5', 'a7'],
+     *             xAxisName: 'xxx'
+     *         }]
+     *     }
+     * }
+     */
+
+
+    function getLinkGroupIndex(linksOption, axis) {
+      var axisModel = axis.model;
+      var dim = axis.dim;
+
+      for (var i = 0; i < linksOption.length; i++) {
+        var linkOption = linksOption[i] || {};
+
+        if (checkPropInLink(linkOption[dim + 'AxisId'], axisModel.id) || checkPropInLink(linkOption[dim + 'AxisIndex'], axisModel.componentIndex) || checkPropInLink(linkOption[dim + 'AxisName'], axisModel.name)) {
+          return i;
+        }
+      }
+    }
+
+    function checkPropInLink(linkPropValue, axisPropValue) {
+      return linkPropValue === 'all' || isArray(linkPropValue) && indexOf(linkPropValue, axisPropValue) >= 0 || linkPropValue === axisPropValue;
+    }
+
+    function fixValue(axisModel) {
+      var axisInfo = getAxisInfo(axisModel);
+
+      if (!axisInfo) {
+        return;
+      }
+
+      var axisPointerModel = axisInfo.axisPointerModel;
+      var scale = axisInfo.axis.scale;
+      var option = axisPointerModel.option;
+      var status = axisPointerModel.get('status');
+      var value = axisPointerModel.get('value'); // Parse init value for category and time axis.
+
+      if (value != null) {
+        value = scale.parse(value);
+      }
+
+      var useHandle = isHandleTrigger(axisPointerModel); // If `handle` used, `axisPointer` will always be displayed, so value
+      // and status should be initialized.
+
+      if (status == null) {
+        option.status = useHandle ? 'show' : 'hide';
+      }
+
+      var extent = scale.getExtent().slice();
+      extent[0] > extent[1] && extent.reverse();
+
+      if ( // Pick a value on axis when initializing.
+      value == null // If both `handle` and `dataZoom` are used, value may be out of axis extent,
+      // where we should re-pick a value to keep `handle` displaying normally.
+      || value > extent[1]) {
+        // Make handle displayed on the end of the axis when init, which looks better.
+        value = extent[1];
+      }
+
+      if (value < extent[0]) {
+        value = extent[0];
+      }
+
+      option.value = value;
+
+      if (useHandle) {
+        option.status = axisInfo.axis.scale.isBlank() ? 'hide' : 'show';
+      }
+    }
+    function getAxisInfo(axisModel) {
+      var coordSysAxesInfo = (axisModel.ecModel.getComponent('axisPointer') || {}).coordSysAxesInfo;
+      return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
+    }
+    function getAxisPointerModel(axisModel) {
+      var axisInfo = getAxisInfo(axisModel);
+      return axisInfo && axisInfo.axisPointerModel;
+    }
+
+    function isHandleTrigger(axisPointerModel) {
+      return !!axisPointerModel.get(['handle', 'show']);
+    }
+    /**
+     * @param {module:echarts/model/Model} model
+     * @return {string} unique key
+     */
+
+
+    function makeKey(model) {
+      return model.type + '||' + model.id;
+    }
+
+    var axisPointerClazz = {};
+    /**
+     * Base class of AxisView.
+     */
+
+    var AxisView =
+    /** @class */
+    function (_super) {
+      __extends(AxisView, _super);
+
+      function AxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = AxisView.type;
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      AxisView.prototype.render = function (axisModel, ecModel, api, payload) {
+        // FIXME
+        // This process should proformed after coordinate systems updated
+        // (axis scale updated), and should be performed each time update.
+        // So put it here temporarily, although it is not appropriate to
+        // put a model-writing procedure in `view`.
+        this.axisPointerClass && fixValue(axisModel);
+
+        _super.prototype.render.apply(this, arguments);
+
+        this._doUpdateAxisPointerClass(axisModel, api, true);
+      };
+      /**
+       * Action handler.
+       */
+
+
+      AxisView.prototype.updateAxisPointer = function (axisModel, ecModel, api, payload) {
+        this._doUpdateAxisPointerClass(axisModel, api, false);
+      };
+      /**
+       * @override
+       */
+
+
+      AxisView.prototype.remove = function (ecModel, api) {
+        var axisPointer = this._axisPointer;
+        axisPointer && axisPointer.remove(api);
+      };
+      /**
+       * @override
+       */
+
+
+      AxisView.prototype.dispose = function (ecModel, api) {
+        this._disposeAxisPointer(api);
+
+        _super.prototype.dispose.apply(this, arguments);
+      };
+
+      AxisView.prototype._doUpdateAxisPointerClass = function (axisModel, api, forceRender) {
+        var Clazz = AxisView.getAxisPointerClass(this.axisPointerClass);
+
+        if (!Clazz) {
+          return;
+        }
+
+        var axisPointerModel = getAxisPointerModel(axisModel);
+        axisPointerModel ? (this._axisPointer || (this._axisPointer = new Clazz())).render(axisModel, axisPointerModel, api, forceRender) : this._disposeAxisPointer(api);
+      };
+
+      AxisView.prototype._disposeAxisPointer = function (api) {
+        this._axisPointer && this._axisPointer.dispose(api);
+        this._axisPointer = null;
+      };
+
+      AxisView.registerAxisPointerClass = function (type, clazz) {
+        if ("development" !== 'production') {
+          if (axisPointerClazz[type]) {
+            throw new Error('axisPointer ' + type + ' exists');
+          }
+        }
+
+        axisPointerClazz[type] = clazz;
+      };
+
+      AxisView.getAxisPointerClass = function (type) {
+        return type && axisPointerClazz[type];
+      };
+      AxisView.type = 'axis';
+      return AxisView;
+    }(ComponentView);
+
+    var inner$5 = makeInner();
+    function rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel) {
+      var axis = axisModel.axis;
+
+      if (axis.scale.isBlank()) {
+        return;
+      } // TODO: TYPE
+
+
+      var splitAreaModel = axisModel.getModel('splitArea');
+      var areaStyleModel = splitAreaModel.getModel('areaStyle');
+      var areaColors = areaStyleModel.get('color');
+      var gridRect = gridModel.coordinateSystem.getRect();
+      var ticksCoords = axis.getTicksCoords({
+        tickModel: splitAreaModel,
+        clamp: true
+      });
+
+      if (!ticksCoords.length) {
+        return;
+      } // For Making appropriate splitArea animation, the color and anid
+      // should be corresponding to previous one if possible.
+
+
+      var areaColorsLen = areaColors.length;
+      var lastSplitAreaColors = inner$5(axisView).splitAreaColors;
+      var newSplitAreaColors = createHashMap();
+      var colorIndex = 0;
+
+      if (lastSplitAreaColors) {
+        for (var i = 0; i < ticksCoords.length; i++) {
+          var cIndex = lastSplitAreaColors.get(ticksCoords[i].tickValue);
+
+          if (cIndex != null) {
+            colorIndex = (cIndex + (areaColorsLen - 1) * i) % areaColorsLen;
+            break;
+          }
+        }
+      }
+
+      var prev = axis.toGlobalCoord(ticksCoords[0].coord);
+      var areaStyle = areaStyleModel.getAreaStyle();
+      areaColors = isArray(areaColors) ? areaColors : [areaColors];
+
+      for (var i = 1; i < ticksCoords.length; i++) {
+        var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
+        var x = void 0;
+        var y = void 0;
+        var width = void 0;
+        var height = void 0;
+
+        if (axis.isHorizontal()) {
+          x = prev;
+          y = gridRect.y;
+          width = tickCoord - x;
+          height = gridRect.height;
+          prev = x + width;
+        } else {
+          x = gridRect.x;
+          y = prev;
+          width = gridRect.width;
+          height = tickCoord - y;
+          prev = y + height;
+        }
+
+        var tickValue = ticksCoords[i - 1].tickValue;
+        tickValue != null && newSplitAreaColors.set(tickValue, colorIndex);
+        axisGroup.add(new Rect({
+          anid: tickValue != null ? 'area_' + tickValue : null,
+          shape: {
+            x: x,
+            y: y,
+            width: width,
+            height: height
+          },
+          style: defaults({
+            fill: areaColors[colorIndex]
+          }, areaStyle),
+          autoBatch: true,
+          silent: true
+        }));
+        colorIndex = (colorIndex + 1) % areaColorsLen;
+      }
+
+      inner$5(axisView).splitAreaColors = newSplitAreaColors;
+    }
+    function rectCoordAxisHandleRemove(axisView) {
+      inner$5(axisView).splitAreaColors = null;
+    }
+
+    var axisBuilderAttrs = ['axisLine', 'axisTickLabel', 'axisName'];
+    var selfBuilderAttrs = ['splitArea', 'splitLine', 'minorSplitLine'];
+
+    var CartesianAxisView =
+    /** @class */
+    function (_super) {
+      __extends(CartesianAxisView, _super);
+
+      function CartesianAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CartesianAxisView.type;
+        _this.axisPointerClass = 'CartesianAxisPointer';
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      CartesianAxisView.prototype.render = function (axisModel, ecModel, api, payload) {
+        this.group.removeAll();
+        var oldAxisGroup = this._axisGroup;
+        this._axisGroup = new Group();
+        this.group.add(this._axisGroup);
+
+        if (!axisModel.get('show')) {
+          return;
+        }
+
+        var gridModel = axisModel.getCoordSysModel();
+        var layout = layout$1(gridModel, axisModel);
+        var axisBuilder = new AxisBuilder(axisModel, extend({
+          handleAutoShown: function (elementType) {
+            var cartesians = gridModel.coordinateSystem.getCartesians();
+
+            for (var i = 0; i < cartesians.length; i++) {
+              var otherAxisType = cartesians[i].getOtherAxis(axisModel.axis).type;
+
+              if (otherAxisType === 'value' || otherAxisType === 'log') {
+                // Still show axis tick or axisLine if other axis is value / log
+                return true;
+              }
+            } // Not show axisTick or axisLine if other axis is category / time
+
+
+            return false;
+          }
+        }, layout));
+        each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
+
+        this._axisGroup.add(axisBuilder.getGroup());
+
+        each(selfBuilderAttrs, function (name) {
+          if (axisModel.get([name, 'show'])) {
+            axisElementBuilders[name](this, this._axisGroup, axisModel, gridModel);
+          }
+        }, this);
+        groupTransition(oldAxisGroup, this._axisGroup, axisModel);
+
+        _super.prototype.render.call(this, axisModel, ecModel, api, payload);
+      };
+
+      CartesianAxisView.prototype.remove = function () {
+        rectCoordAxisHandleRemove(this);
+      };
+
+      CartesianAxisView.type = 'cartesianAxis';
+      return CartesianAxisView;
+    }(AxisView);
+
+    var axisElementBuilders = {
+      splitLine: function (axisView, axisGroup, axisModel, gridModel) {
+        var axis = axisModel.axis;
+
+        if (axis.scale.isBlank()) {
+          return;
+        }
+
+        var splitLineModel = axisModel.getModel('splitLine');
+        var lineStyleModel = splitLineModel.getModel('lineStyle');
+        var lineColors = lineStyleModel.get('color');
+        lineColors = isArray(lineColors) ? lineColors : [lineColors];
+        var gridRect = gridModel.coordinateSystem.getRect();
+        var isHorizontal = axis.isHorizontal();
+        var lineCount = 0;
+        var ticksCoords = axis.getTicksCoords({
+          tickModel: splitLineModel
+        });
+        var p1 = [];
+        var p2 = [];
+        var lineStyle = lineStyleModel.getLineStyle();
+
+        for (var i = 0; i < ticksCoords.length; i++) {
+          var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
+
+          if (isHorizontal) {
+            p1[0] = tickCoord;
+            p1[1] = gridRect.y;
+            p2[0] = tickCoord;
+            p2[1] = gridRect.y + gridRect.height;
+          } else {
+            p1[0] = gridRect.x;
+            p1[1] = tickCoord;
+            p2[0] = gridRect.x + gridRect.width;
+            p2[1] = tickCoord;
+          }
+
+          var colorIndex = lineCount++ % lineColors.length;
+          var tickValue = ticksCoords[i].tickValue;
+          axisGroup.add(new Line({
+            anid: tickValue != null ? 'line_' + ticksCoords[i].tickValue : null,
+            subPixelOptimize: true,
+            autoBatch: true,
+            shape: {
+              x1: p1[0],
+              y1: p1[1],
+              x2: p2[0],
+              y2: p2[1]
+            },
+            style: defaults({
+              stroke: lineColors[colorIndex]
+            }, lineStyle),
+            silent: true
+          }));
+        }
+      },
+      minorSplitLine: function (axisView, axisGroup, axisModel, gridModel) {
+        var axis = axisModel.axis;
+        var minorSplitLineModel = axisModel.getModel('minorSplitLine');
+        var lineStyleModel = minorSplitLineModel.getModel('lineStyle');
+        var gridRect = gridModel.coordinateSystem.getRect();
+        var isHorizontal = axis.isHorizontal();
+        var minorTicksCoords = axis.getMinorTicksCoords();
+
+        if (!minorTicksCoords.length) {
+          return;
+        }
+
+        var p1 = [];
+        var p2 = [];
+        var lineStyle = lineStyleModel.getLineStyle();
+
+        for (var i = 0; i < minorTicksCoords.length; i++) {
+          for (var k = 0; k < minorTicksCoords[i].length; k++) {
+            var tickCoord = axis.toGlobalCoord(minorTicksCoords[i][k].coord);
+
+            if (isHorizontal) {
+              p1[0] = tickCoord;
+              p1[1] = gridRect.y;
+              p2[0] = tickCoord;
+              p2[1] = gridRect.y + gridRect.height;
+            } else {
+              p1[0] = gridRect.x;
+              p1[1] = tickCoord;
+              p2[0] = gridRect.x + gridRect.width;
+              p2[1] = tickCoord;
+            }
+
+            axisGroup.add(new Line({
+              anid: 'minor_line_' + minorTicksCoords[i][k].tickValue,
+              subPixelOptimize: true,
+              autoBatch: true,
+              shape: {
+                x1: p1[0],
+                y1: p1[1],
+                x2: p2[0],
+                y2: p2[1]
+              },
+              style: lineStyle,
+              silent: true
+            }));
+          }
+        }
+      },
+      splitArea: function (axisView, axisGroup, axisModel, gridModel) {
+        rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel);
+      }
+    };
+
+    var CartesianXAxisView =
+    /** @class */
+    function (_super) {
+      __extends(CartesianXAxisView, _super);
+
+      function CartesianXAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CartesianXAxisView.type;
+        return _this;
+      }
+
+      CartesianXAxisView.type = 'xAxis';
+      return CartesianXAxisView;
+    }(CartesianAxisView);
+
+    var CartesianYAxisView =
+    /** @class */
+    function (_super) {
+      __extends(CartesianYAxisView, _super);
+
+      function CartesianYAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CartesianXAxisView.type;
+        return _this;
+      }
+
+      CartesianYAxisView.type = 'yAxis';
+      return CartesianYAxisView;
+    }(CartesianAxisView);
+
+    var GridView =
+    /** @class */
+    function (_super) {
+      __extends(GridView, _super);
+
+      function GridView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'grid';
+        return _this;
+      }
+
+      GridView.prototype.render = function (gridModel, ecModel) {
+        this.group.removeAll();
+
+        if (gridModel.get('show')) {
+          this.group.add(new Rect({
+            shape: gridModel.coordinateSystem.getRect(),
+            style: defaults({
+              fill: gridModel.get('backgroundColor')
+            }, gridModel.getItemStyle()),
+            silent: true,
+            z2: -1
+          }));
+        }
+      };
+
+      GridView.type = 'grid';
+      return GridView;
+    }(ComponentView);
+
+    var extraOption = {
+      // gridIndex: 0,
+      // gridId: '',
+      offset: 0
+    };
+    function install$5(registers) {
+      registers.registerComponentView(GridView);
+      registers.registerComponentModel(GridModel);
+      registers.registerCoordinateSystem('cartesian2d', Grid);
+      axisModelCreator(registers, 'x', CartesianAxisModel, extraOption);
+      axisModelCreator(registers, 'y', CartesianAxisModel, extraOption);
+      registers.registerComponentView(CartesianXAxisView);
+      registers.registerComponentView(CartesianYAxisView);
+      registers.registerPreprocessor(function (option) {
+        // Only create grid when need
+        if (option.xAxis && option.yAxis && !option.grid) {
+          option.grid = {};
+        }
+      });
+    }
+
+    function install$6(registers) {
+      // In case developer forget to include grid component
+      use(install$5);
+      registers.registerSeriesModel(ScatterSeriesModel);
+      registers.registerChartView(ScatterView);
+      registers.registerLayout(pointsLayout('scatter'));
+    }
+
+    function radarLayout(ecModel) {
+      ecModel.eachSeriesByType('radar', function (seriesModel) {
+        var data = seriesModel.getData();
+        var points = [];
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (!coordSys) {
+          return;
+        }
+
+        var axes = coordSys.getIndicatorAxes();
+        each(axes, function (axis, axisIndex) {
+          data.each(data.mapDimension(axes[axisIndex].dim), function (val, dataIndex) {
+            points[dataIndex] = points[dataIndex] || [];
+            var point = coordSys.dataToPoint(val, axisIndex);
+            points[dataIndex][axisIndex] = isValidPoint(point) ? point : getValueMissingPoint(coordSys);
+          });
+        }); // Close polygon
+
+        data.each(function (idx) {
+          // TODO
+          // Is it appropriate to connect to the next data when some data is missing?
+          // Or, should trade it like `connectNull` in line chart?
+          var firstPoint = find(points[idx], function (point) {
+            return isValidPoint(point);
+          }) || getValueMissingPoint(coordSys); // Copy the first actual point to the end of the array
+
+          points[idx].push(firstPoint.slice());
+          data.setItemLayout(idx, points[idx]);
+        });
+      });
+    }
+
+    function isValidPoint(point) {
+      return !isNaN(point[0]) && !isNaN(point[1]);
+    }
+
+    function getValueMissingPoint(coordSys) {
+      // It is error-prone to input [NaN, NaN] into polygon, polygon.
+      // (probably cause problem when refreshing or animating)
+      return [coordSys.cx, coordSys.cy];
+    }
+
+    function radarBackwardCompat(option) {
+      var polarOptArr = option.polar;
+
+      if (polarOptArr) {
+        if (!isArray(polarOptArr)) {
+          polarOptArr = [polarOptArr];
+        }
+
+        var polarNotRadar_1 = [];
+        each(polarOptArr, function (polarOpt, idx) {
+          if (polarOpt.indicator) {
+            if (polarOpt.type && !polarOpt.shape) {
+              polarOpt.shape = polarOpt.type;
+            }
+
+            option.radar = option.radar || [];
+
+            if (!isArray(option.radar)) {
+              option.radar = [option.radar];
+            }
+
+            option.radar.push(polarOpt);
+          } else {
+            polarNotRadar_1.push(polarOpt);
+          }
+        });
+        option.polar = polarNotRadar_1;
+      }
+
+      each(option.series, function (seriesOpt) {
+        if (seriesOpt && seriesOpt.type === 'radar' && seriesOpt.polarIndex) {
+          seriesOpt.radarIndex = seriesOpt.polarIndex;
+        }
+      });
+    }
+
+    function normalizeSymbolSize(symbolSize) {
+      if (!isArray(symbolSize)) {
+        symbolSize = [+symbolSize, +symbolSize];
+      }
+
+      return symbolSize;
+    }
+
+    var RadarView =
+    /** @class */
+    function (_super) {
+      __extends(RadarView, _super);
+
+      function RadarView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadarView.type;
+        return _this;
+      }
+
+      RadarView.prototype.render = function (seriesModel, ecModel, api) {
+        var polar = seriesModel.coordinateSystem;
+        var group = this.group;
+        var data = seriesModel.getData();
+        var oldData = this._data;
+
+        function createSymbol$1(data, idx) {
+          var symbolType = data.getItemVisual(idx, 'symbol') || 'circle';
+
+          if (symbolType === 'none') {
+            return;
+          }
+
+          var symbolSize = normalizeSymbolSize(data.getItemVisual(idx, 'symbolSize'));
+          var symbolPath = createSymbol(symbolType, -1, -1, 2, 2);
+          var symbolRotate = data.getItemVisual(idx, 'symbolRotate') || 0;
+          symbolPath.attr({
+            style: {
+              strokeNoScale: true
+            },
+            z2: 100,
+            scaleX: symbolSize[0] / 2,
+            scaleY: symbolSize[1] / 2,
+            rotation: symbolRotate * Math.PI / 180 || 0
+          });
+          return symbolPath;
+        }
+
+        function updateSymbols(oldPoints, newPoints, symbolGroup, data, idx, isInit) {
+          // Simply rerender all
+          symbolGroup.removeAll();
+
+          for (var i = 0; i < newPoints.length - 1; i++) {
+            var symbolPath = createSymbol$1(data, idx);
+
+            if (symbolPath) {
+              symbolPath.__dimIdx = i;
+
+              if (oldPoints[i]) {
+                symbolPath.setPosition(oldPoints[i]);
+                graphic[isInit ? 'initProps' : 'updateProps'](symbolPath, {
+                  x: newPoints[i][0],
+                  y: newPoints[i][1]
+                }, seriesModel, idx);
+              } else {
+                symbolPath.setPosition(newPoints[i]);
+              }
+
+              symbolGroup.add(symbolPath);
+            }
+          }
+        }
+
+        function getInitialPoints(points) {
+          return map(points, function (pt) {
+            return [polar.cx, polar.cy];
+          });
+        }
+
+        data.diff(oldData).add(function (idx) {
+          var points = data.getItemLayout(idx);
+
+          if (!points) {
+            return;
+          }
+
+          var polygon = new Polygon();
+          var polyline = new Polyline();
+          var target = {
+            shape: {
+              points: points
+            }
+          };
+          polygon.shape.points = getInitialPoints(points);
+          polyline.shape.points = getInitialPoints(points);
+          initProps(polygon, target, seriesModel, idx);
+          initProps(polyline, target, seriesModel, idx);
+          var itemGroup = new Group();
+          var symbolGroup = new Group();
+          itemGroup.add(polyline);
+          itemGroup.add(polygon);
+          itemGroup.add(symbolGroup);
+          updateSymbols(polyline.shape.points, points, symbolGroup, data, idx, true);
+          data.setItemGraphicEl(idx, itemGroup);
+        }).update(function (newIdx, oldIdx) {
+          var itemGroup = oldData.getItemGraphicEl(oldIdx);
+          var polyline = itemGroup.childAt(0);
+          var polygon = itemGroup.childAt(1);
+          var symbolGroup = itemGroup.childAt(2);
+          var target = {
+            shape: {
+              points: data.getItemLayout(newIdx)
+            }
+          };
+
+          if (!target.shape.points) {
+            return;
+          }
+
+          updateSymbols(polyline.shape.points, target.shape.points, symbolGroup, data, newIdx, false);
+          updateProps(polyline, target, seriesModel);
+          updateProps(polygon, target, seriesModel);
+          data.setItemGraphicEl(newIdx, itemGroup);
+        }).remove(function (idx) {
+          group.remove(oldData.getItemGraphicEl(idx));
+        }).execute();
+        data.eachItemGraphicEl(function (itemGroup, idx) {
+          var itemModel = data.getItemModel(idx);
+          var polyline = itemGroup.childAt(0);
+          var polygon = itemGroup.childAt(1);
+          var symbolGroup = itemGroup.childAt(2); // Radar uses the visual encoded from itemStyle.
+
+          var itemStyle = data.getItemVisual(idx, 'style');
+          var color = itemStyle.fill;
+          group.add(itemGroup);
+          polyline.useStyle(defaults(itemModel.getModel('lineStyle').getLineStyle(), {
+            fill: 'none',
+            stroke: color
+          }));
+          setStatesStylesFromModel(polyline, itemModel, 'lineStyle');
+          setStatesStylesFromModel(polygon, itemModel, 'areaStyle');
+          var areaStyleModel = itemModel.getModel('areaStyle');
+          var polygonIgnore = areaStyleModel.isEmpty() && areaStyleModel.parentModel.isEmpty();
+          polygon.ignore = polygonIgnore;
+          each(['emphasis', 'select', 'blur'], function (stateName) {
+            var stateModel = itemModel.getModel([stateName, 'areaStyle']);
+            var stateIgnore = stateModel.isEmpty() && stateModel.parentModel.isEmpty(); // Won't be ignore if normal state is not ignore.
+
+            polygon.ensureState(stateName).ignore = stateIgnore && polygonIgnore;
+          });
+          polygon.useStyle(defaults(areaStyleModel.getAreaStyle(), {
+            fill: color,
+            opacity: 0.7,
+            decal: itemStyle.decal
+          }));
+          var emphasisModel = itemModel.getModel('emphasis');
+          var itemHoverStyle = emphasisModel.getModel('itemStyle').getItemStyle();
+          symbolGroup.eachChild(function (symbolPath) {
+            if (symbolPath instanceof ZRImage) {
+              var pathStyle = symbolPath.style;
+              symbolPath.useStyle(extend({
+                // TODO other properties like x, y ?
+                image: pathStyle.image,
+                x: pathStyle.x,
+                y: pathStyle.y,
+                width: pathStyle.width,
+                height: pathStyle.height
+              }, itemStyle));
+            } else {
+              symbolPath.useStyle(itemStyle);
+              symbolPath.setColor(color);
+            }
+
+            var pathEmphasisState = symbolPath.ensureState('emphasis');
+            pathEmphasisState.style = clone(itemHoverStyle);
+            var defaultText = data.get(data.dimensions[symbolPath.__dimIdx], idx);
+            (defaultText == null || isNaN(defaultText)) && (defaultText = '');
+            setLabelStyle(symbolPath, getLabelStatesModels(itemModel), {
+              labelFetcher: data.hostModel,
+              labelDataIndex: idx,
+              labelDimIndex: symbolPath.__dimIdx,
+              defaultText: defaultText,
+              inheritColor: color,
+              defaultOpacity: itemStyle.opacity
+            });
+          });
+          enableHoverEmphasis(itemGroup, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+        });
+        this._data = data;
+      };
+
+      RadarView.prototype.remove = function () {
+        this.group.removeAll();
+        this._data = null;
+      };
+
+      RadarView.type = 'radar';
+      return RadarView;
+    }(ChartView);
+
+    var RadarSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(RadarSeriesModel, _super);
+
+      function RadarSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadarSeriesModel.type;
+        _this.useColorPaletteOnData = true;
+        _this.hasSymbolVisual = true;
+        return _this;
+      } // Overwrite
+
+
+      RadarSeriesModel.prototype.init = function (option) {
+        _super.prototype.init.apply(this, arguments); // Enable legend selection for each data item
+        // Use a function instead of direct access because data reference may changed
+
+
+        this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this));
+      };
+
+      RadarSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListSimply(this, {
+          generateCoord: 'indicator_',
+          generateCoordCount: Infinity
+        });
+      };
+
+      RadarSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var data = this.getData();
+        var coordSys = this.coordinateSystem;
+        var indicatorAxes = coordSys.getIndicatorAxes();
+        var name = this.getData().getName(dataIndex);
+        var nameToDisplay = name === '' ? this.name : name;
+        var markerColor = retrieveVisualColorForTooltipMarker(this, dataIndex);
+        return createTooltipMarkup('section', {
+          header: nameToDisplay,
+          sortBlocks: true,
+          blocks: map(indicatorAxes, function (axis) {
+            var val = data.get(data.mapDimension(axis.dim), dataIndex);
+            return createTooltipMarkup('nameValue', {
+              markerType: 'subItem',
+              markerColor: markerColor,
+              name: axis.name,
+              value: val,
+              sortParam: val
+            });
+          })
+        });
+      };
+
+      RadarSeriesModel.prototype.getTooltipPosition = function (dataIndex) {
+        if (dataIndex != null) {
+          var data_1 = this.getData();
+          var coordSys = this.coordinateSystem;
+          var values = data_1.getValues(map(coordSys.dimensions, function (dim) {
+            return data_1.mapDimension(dim);
+          }), dataIndex);
+
+          for (var i = 0, len = values.length; i < len; i++) {
+            if (!isNaN(values[i])) {
+              var indicatorAxes = coordSys.getIndicatorAxes();
+              return coordSys.coordToPoint(indicatorAxes[i].dataToCoord(values[i]), i);
+            }
+          }
+        }
+      };
+
+      RadarSeriesModel.type = 'series.radar';
+      RadarSeriesModel.dependencies = ['radar'];
+      RadarSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'radar',
+        legendHoverLink: true,
+        radarIndex: 0,
+        lineStyle: {
+          width: 2,
+          type: 'solid'
+        },
+        label: {
+          position: 'top'
+        },
+        // areaStyle: {
+        // },
+        // itemStyle: {}
+        symbol: 'emptyCircle',
+        symbolSize: 4 // symbolRotate: null
+
+      };
+      return RadarSeriesModel;
+    }(SeriesModel);
+
+    var valueAxisDefault = axisDefault.value;
+
+    function defaultsShow(opt, show) {
+      return defaults({
+        show: show
+      }, opt);
+    }
+
+    var RadarModel =
+    /** @class */
+    function (_super) {
+      __extends(RadarModel, _super);
+
+      function RadarModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadarModel.type;
+        return _this;
+      }
+
+      RadarModel.prototype.optionUpdated = function () {
+        var boundaryGap = this.get('boundaryGap');
+        var splitNumber = this.get('splitNumber');
+        var scale = this.get('scale');
+        var axisLine = this.get('axisLine');
+        var axisTick = this.get('axisTick'); // let axisType = this.get('axisType');
+
+        var axisLabel = this.get('axisLabel');
+        var nameTextStyle = this.get('axisName');
+        var showName = this.get(['axisName', 'show']);
+        var nameFormatter = this.get(['axisName', 'formatter']);
+        var nameGap = this.get('axisNameGap');
+        var triggerEvent = this.get('triggerEvent');
+        var indicatorModels = map(this.get('indicator') || [], function (indicatorOpt) {
+          // PENDING
+          if (indicatorOpt.max != null && indicatorOpt.max > 0 && !indicatorOpt.min) {
+            indicatorOpt.min = 0;
+          } else if (indicatorOpt.min != null && indicatorOpt.min < 0 && !indicatorOpt.max) {
+            indicatorOpt.max = 0;
+          }
+
+          var iNameTextStyle = nameTextStyle;
+
+          if (indicatorOpt.color != null) {
+            iNameTextStyle = defaults({
+              color: indicatorOpt.color
+            }, nameTextStyle);
+          } // Use same configuration
+
+
+          var innerIndicatorOpt = merge(clone(indicatorOpt), {
+            boundaryGap: boundaryGap,
+            splitNumber: splitNumber,
+            scale: scale,
+            axisLine: axisLine,
+            axisTick: axisTick,
+            // axisType: axisType,
+            axisLabel: axisLabel,
+            // Compatible with 2 and use text
+            name: indicatorOpt.text,
+            nameLocation: 'end',
+            nameGap: nameGap,
+            // min: 0,
+            nameTextStyle: iNameTextStyle,
+            triggerEvent: triggerEvent
+          }, false);
+
+          if (!showName) {
+            innerIndicatorOpt.name = '';
+          }
+
+          if (typeof nameFormatter === 'string') {
+            var indName = innerIndicatorOpt.name;
+            innerIndicatorOpt.name = nameFormatter.replace('{value}', indName != null ? indName : '');
+          } else if (typeof nameFormatter === 'function') {
+            innerIndicatorOpt.name = nameFormatter(innerIndicatorOpt.name, innerIndicatorOpt);
+          }
+
+          var model = new Model(innerIndicatorOpt, null, this.ecModel);
+          mixin(model, AxisModelCommonMixin.prototype); // For triggerEvent.
+
+          model.mainType = 'radar';
+          model.componentIndex = this.componentIndex;
+          return model;
+        }, this);
+        this._indicatorModels = indicatorModels;
+      };
+
+      RadarModel.prototype.getIndicatorModels = function () {
+        return this._indicatorModels;
+      };
+
+      RadarModel.type = 'radar';
+      RadarModel.defaultOption = {
+        zlevel: 0,
+        z: 0,
+        center: ['50%', '50%'],
+        radius: '75%',
+        startAngle: 90,
+        axisName: {
+          show: true // formatter: null
+          // textStyle: {}
+
+        },
+        boundaryGap: [0, 0],
+        splitNumber: 5,
+        axisNameGap: 15,
+        scale: false,
+        // Polygon or circle
+        shape: 'polygon',
+        axisLine: merge({
+          lineStyle: {
+            color: '#bbb'
+          }
+        }, valueAxisDefault.axisLine),
+        axisLabel: defaultsShow(valueAxisDefault.axisLabel, false),
+        axisTick: defaultsShow(valueAxisDefault.axisTick, false),
+        // axisType: 'value',
+        splitLine: defaultsShow(valueAxisDefault.splitLine, true),
+        splitArea: defaultsShow(valueAxisDefault.splitArea, true),
+        // {text, min, max}
+        indicator: []
+      };
+      return RadarModel;
+    }(ComponentModel);
+
+    var axisBuilderAttrs$1 = ['axisLine', 'axisTickLabel', 'axisName'];
+
+    var RadarView$1 =
+    /** @class */
+    function (_super) {
+      __extends(RadarView, _super);
+
+      function RadarView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadarView.type;
+        return _this;
+      }
+
+      RadarView.prototype.render = function (radarModel, ecModel, api) {
+        var group = this.group;
+        group.removeAll();
+
+        this._buildAxes(radarModel);
+
+        this._buildSplitLineAndArea(radarModel);
+      };
+
+      RadarView.prototype._buildAxes = function (radarModel) {
+        var radar = radarModel.coordinateSystem;
+        var indicatorAxes = radar.getIndicatorAxes();
+        var axisBuilders = map(indicatorAxes, function (indicatorAxis) {
+          var axisBuilder = new AxisBuilder(indicatorAxis.model, {
+            position: [radar.cx, radar.cy],
+            rotation: indicatorAxis.angle,
+            labelDirection: -1,
+            tickDirection: -1,
+            nameDirection: 1
+          });
+          return axisBuilder;
+        });
+        each(axisBuilders, function (axisBuilder) {
+          each(axisBuilderAttrs$1, axisBuilder.add, axisBuilder);
+          this.group.add(axisBuilder.getGroup());
+        }, this);
+      };
+
+      RadarView.prototype._buildSplitLineAndArea = function (radarModel) {
+        var radar = radarModel.coordinateSystem;
+        var indicatorAxes = radar.getIndicatorAxes();
+
+        if (!indicatorAxes.length) {
+          return;
+        }
+
+        var shape = radarModel.get('shape');
+        var splitLineModel = radarModel.getModel('splitLine');
+        var splitAreaModel = radarModel.getModel('splitArea');
+        var lineStyleModel = splitLineModel.getModel('lineStyle');
+        var areaStyleModel = splitAreaModel.getModel('areaStyle');
+        var showSplitLine = splitLineModel.get('show');
+        var showSplitArea = splitAreaModel.get('show');
+        var splitLineColors = lineStyleModel.get('color');
+        var splitAreaColors = areaStyleModel.get('color');
+        var splitLineColorsArr = isArray(splitLineColors) ? splitLineColors : [splitLineColors];
+        var splitAreaColorsArr = isArray(splitAreaColors) ? splitAreaColors : [splitAreaColors];
+        var splitLines = [];
+        var splitAreas = [];
+
+        function getColorIndex(areaOrLine, areaOrLineColorList, idx) {
+          var colorIndex = idx % areaOrLineColorList.length;
+          areaOrLine[colorIndex] = areaOrLine[colorIndex] || [];
+          return colorIndex;
+        }
+
+        if (shape === 'circle') {
+          var ticksRadius = indicatorAxes[0].getTicksCoords();
+          var cx = radar.cx;
+          var cy = radar.cy;
+
+          for (var i = 0; i < ticksRadius.length; i++) {
+            if (showSplitLine) {
+              var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+              splitLines[colorIndex].push(new Circle({
+                shape: {
+                  cx: cx,
+                  cy: cy,
+                  r: ticksRadius[i].coord
+                }
+              }));
+            }
+
+            if (showSplitArea && i < ticksRadius.length - 1) {
+              var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i);
+              splitAreas[colorIndex].push(new Ring({
+                shape: {
+                  cx: cx,
+                  cy: cy,
+                  r0: ticksRadius[i].coord,
+                  r: ticksRadius[i + 1].coord
+                }
+              }));
+            }
+          }
+        } // Polyyon
+        else {
+            var realSplitNumber_1;
+            var axesTicksPoints = map(indicatorAxes, function (indicatorAxis, idx) {
+              var ticksCoords = indicatorAxis.getTicksCoords();
+              realSplitNumber_1 = realSplitNumber_1 == null ? ticksCoords.length - 1 : Math.min(ticksCoords.length - 1, realSplitNumber_1);
+              return map(ticksCoords, function (tickCoord) {
+                return radar.coordToPoint(tickCoord.coord, idx);
+              });
+            });
+            var prevPoints = [];
+
+            for (var i = 0; i <= realSplitNumber_1; i++) {
+              var points = [];
+
+              for (var j = 0; j < indicatorAxes.length; j++) {
+                points.push(axesTicksPoints[j][i]);
+              } // Close
+
+
+              if (points[0]) {
+                points.push(points[0].slice());
+              } else {
+                if ("development" !== 'production') {
+                  console.error('Can\'t draw value axis ' + i);
+                }
+              }
+
+              if (showSplitLine) {
+                var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+                splitLines[colorIndex].push(new Polyline({
+                  shape: {
+                    points: points
+                  }
+                }));
+              }
+
+              if (showSplitArea && prevPoints) {
+                var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i - 1);
+                splitAreas[colorIndex].push(new Polygon({
+                  shape: {
+                    points: points.concat(prevPoints)
+                  }
+                }));
+              }
+
+              prevPoints = points.slice().reverse();
+            }
+          }
+
+        var lineStyle = lineStyleModel.getLineStyle();
+        var areaStyle = areaStyleModel.getAreaStyle(); // Add splitArea before splitLine
+
+        each(splitAreas, function (splitAreas, idx) {
+          this.group.add(mergePath$1(splitAreas, {
+            style: defaults({
+              stroke: 'none',
+              fill: splitAreaColorsArr[idx % splitAreaColorsArr.length]
+            }, areaStyle),
+            silent: true
+          }));
+        }, this);
+        each(splitLines, function (splitLines, idx) {
+          this.group.add(mergePath$1(splitLines, {
+            style: defaults({
+              fill: 'none',
+              stroke: splitLineColorsArr[idx % splitLineColorsArr.length]
+            }, lineStyle),
+            silent: true
+          }));
+        }, this);
+      };
+
+      RadarView.type = 'radar';
+      return RadarView;
+    }(ComponentView);
+
+    var IndicatorAxis =
+    /** @class */
+    function (_super) {
+      __extends(IndicatorAxis, _super);
+
+      function IndicatorAxis(dim, scale, radiusExtent) {
+        var _this = _super.call(this, dim, scale, radiusExtent) || this;
+
+        _this.type = 'value';
+        _this.angle = 0;
+        _this.name = '';
+        return _this;
+      }
+
+      return IndicatorAxis;
+    }(Axis);
+
+    var Radar =
+    /** @class */
+    function () {
+      function Radar(radarModel, ecModel, api) {
+        /**
+         *
+         * Radar dimensions
+         */
+        this.dimensions = [];
+        this._model = radarModel;
+        this._indicatorAxes = map(radarModel.getIndicatorModels(), function (indicatorModel, idx) {
+          var dim = 'indicator_' + idx;
+          var indicatorAxis = new IndicatorAxis(dim, new IntervalScale() // (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
+          );
+          indicatorAxis.name = indicatorModel.get('name'); // Inject model and axis
+
+          indicatorAxis.model = indicatorModel;
+          indicatorModel.axis = indicatorAxis;
+          this.dimensions.push(dim);
+          return indicatorAxis;
+        }, this);
+        this.resize(radarModel, api);
+      }
+
+      Radar.prototype.getIndicatorAxes = function () {
+        return this._indicatorAxes;
+      };
+
+      Radar.prototype.dataToPoint = function (value, indicatorIndex) {
+        var indicatorAxis = this._indicatorAxes[indicatorIndex];
+        return this.coordToPoint(indicatorAxis.dataToCoord(value), indicatorIndex);
+      }; // TODO: API should be coordToPoint([coord, indicatorIndex])
+
+
+      Radar.prototype.coordToPoint = function (coord, indicatorIndex) {
+        var indicatorAxis = this._indicatorAxes[indicatorIndex];
+        var angle = indicatorAxis.angle;
+        var x = this.cx + coord * Math.cos(angle);
+        var y = this.cy - coord * Math.sin(angle);
+        return [x, y];
+      };
+
+      Radar.prototype.pointToData = function (pt) {
+        var dx = pt[0] - this.cx;
+        var dy = pt[1] - this.cy;
+        var radius = Math.sqrt(dx * dx + dy * dy);
+        dx /= radius;
+        dy /= radius;
+        var radian = Math.atan2(-dy, dx); // Find the closest angle
+        // FIXME index can calculated directly
+
+        var minRadianDiff = Infinity;
+        var closestAxis;
+        var closestAxisIdx = -1;
+
+        for (var i = 0; i < this._indicatorAxes.length; i++) {
+          var indicatorAxis = this._indicatorAxes[i];
+          var diff = Math.abs(radian - indicatorAxis.angle);
+
+          if (diff < minRadianDiff) {
+            closestAxis = indicatorAxis;
+            closestAxisIdx = i;
+            minRadianDiff = diff;
+          }
+        }
+
+        return [closestAxisIdx, +(closestAxis && closestAxis.coordToData(radius))];
+      };
+
+      Radar.prototype.resize = function (radarModel, api) {
+        var center = radarModel.get('center');
+        var viewWidth = api.getWidth();
+        var viewHeight = api.getHeight();
+        var viewSize = Math.min(viewWidth, viewHeight) / 2;
+        this.cx = parsePercent$1(center[0], viewWidth);
+        this.cy = parsePercent$1(center[1], viewHeight);
+        this.startAngle = radarModel.get('startAngle') * Math.PI / 180; // radius may be single value like `20`, `'80%'`, or array like `[10, '80%']`
+
+        var radius = radarModel.get('radius');
+
+        if (typeof radius === 'string' || typeof radius === 'number') {
+          radius = [0, radius];
+        }
+
+        this.r0 = parsePercent$1(radius[0], viewSize);
+        this.r = parsePercent$1(radius[1], viewSize);
+        each(this._indicatorAxes, function (indicatorAxis, idx) {
+          indicatorAxis.setExtent(this.r0, this.r);
+          var angle = this.startAngle + idx * Math.PI * 2 / this._indicatorAxes.length; // Normalize to [-PI, PI]
+
+          angle = Math.atan2(Math.sin(angle), Math.cos(angle));
+          indicatorAxis.angle = angle;
+        }, this);
+      };
+
+      Radar.prototype.update = function (ecModel, api) {
+        var indicatorAxes = this._indicatorAxes;
+        var radarModel = this._model;
+        each(indicatorAxes, function (indicatorAxis) {
+          indicatorAxis.scale.setExtent(Infinity, -Infinity);
+        });
+        ecModel.eachSeriesByType('radar', function (radarSeries, idx) {
+          if (radarSeries.get('coordinateSystem') !== 'radar' // @ts-ignore
+          || ecModel.getComponent('radar', radarSeries.get('radarIndex')) !== radarModel) {
+            return;
+          }
+
+          var data = radarSeries.getData();
+          each(indicatorAxes, function (indicatorAxis) {
+            indicatorAxis.scale.unionExtentFromData(data, data.mapDimension(indicatorAxis.dim));
+          });
+        }, this);
+        var splitNumber = radarModel.get('splitNumber');
+
+        function increaseInterval(interval) {
+          var exp10 = Math.pow(10, Math.floor(Math.log(interval) / Math.LN10)); // Increase interval
+
+          var f = interval / exp10;
+
+          if (f === 2) {
+            f = 5;
+          } else {
+            // f is 2 or 5
+            f *= 2;
+          }
+
+          return f * exp10;
+        } // Force all the axis fixing the maxSplitNumber.
+
+
+        each(indicatorAxes, function (indicatorAxis, idx) {
+          var rawExtent = getScaleExtent(indicatorAxis.scale, indicatorAxis.model).extent;
+          niceScaleExtent(indicatorAxis.scale, indicatorAxis.model);
+          var axisModel = indicatorAxis.model;
+          var scale = indicatorAxis.scale;
+          var fixedMin = parseAxisModelMinMax(scale, axisModel.get('min', true));
+          var fixedMax = parseAxisModelMinMax(scale, axisModel.get('max', true));
+          var interval = scale.getInterval();
+
+          if (fixedMin != null && fixedMax != null) {
+            // User set min, max, divide to get new interval
+            scale.setExtent(+fixedMin, +fixedMax);
+            scale.setInterval((fixedMax - fixedMin) / splitNumber);
+          } else if (fixedMin != null) {
+            var max = void 0; // User set min, expand extent on the other side
+
+            do {
+              max = fixedMin + interval * splitNumber;
+              scale.setExtent(+fixedMin, max); // Interval must been set after extent
+              // FIXME
+
+              scale.setInterval(interval);
+              interval = increaseInterval(interval);
+            } while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1]));
+          } else if (fixedMax != null) {
+            var min = void 0; // User set min, expand extent on the other side
+
+            do {
+              min = fixedMax - interval * splitNumber;
+              scale.setExtent(min, +fixedMax);
+              scale.setInterval(interval);
+              interval = increaseInterval(interval);
+            } while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0]));
+          } else {
+            var nicedSplitNumber = scale.getTicks().length - 1;
+
+            if (nicedSplitNumber > splitNumber) {
+              interval = increaseInterval(interval);
+            } // TODO
+
+
+            var max = Math.ceil(rawExtent[1] / interval) * interval;
+            var min = round(max - interval * splitNumber);
+            scale.setExtent(min, max);
+            scale.setInterval(interval);
+          }
+        });
+      };
+
+      Radar.prototype.convertToPixel = function (ecModel, finder, value) {
+        console.warn('Not implemented.');
+        return null;
+      };
+
+      Radar.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        console.warn('Not implemented.');
+        return null;
+      };
+
+      Radar.prototype.containPoint = function (point) {
+        console.warn('Not implemented.');
+        return false;
+      };
+
+      Radar.create = function (ecModel, api) {
+        var radarList = [];
+        ecModel.eachComponent('radar', function (radarModel) {
+          var radar = new Radar(radarModel, ecModel, api);
+          radarList.push(radar);
+          radarModel.coordinateSystem = radar;
+        });
+        ecModel.eachSeriesByType('radar', function (radarSeries) {
+          if (radarSeries.get('coordinateSystem') === 'radar') {
+            // Inject coordinate system
+            // @ts-ignore
+            radarSeries.coordinateSystem = radarList[radarSeries.get('radarIndex') || 0];
+          }
+        });
+        return radarList;
+      };
+      /**
+       * Radar dimensions is based on the data
+       */
+
+
+      Radar.dimensions = [];
+      return Radar;
+    }();
+
+    function install$7(registers) {
+      registers.registerCoordinateSystem('radar', Radar);
+      registers.registerComponentModel(RadarModel);
+      registers.registerComponentView(RadarView$1);
+    }
+
+    function install$8(registers) {
+      use(install$7);
+      registers.registerChartView(RadarView);
+      registers.registerSeriesModel(RadarSeriesModel);
+      registers.registerLayout(radarLayout);
+      registers.registerProcessor(dataFilter('radar'));
+      registers.registerPreprocessor(radarBackwardCompat);
+    }
+
+    var ATTR = '\0_ec_interaction_mutex';
+    function take(zr, resourceKey, userKey) {
+      var store = getStore(zr);
+      store[resourceKey] = userKey;
+    }
+    function release(zr, resourceKey, userKey) {
+      var store = getStore(zr);
+      var uKey = store[resourceKey];
+
+      if (uKey === userKey) {
+        store[resourceKey] = null;
+      }
+    }
+    function isTaken(zr, resourceKey) {
+      return !!getStore(zr)[resourceKey];
+    }
+
+    function getStore(zr) {
+      return zr[ATTR] || (zr[ATTR] = {});
+    }
+    /**
+     * payload: {
+     *     type: 'takeGlobalCursor',
+     *     key: 'dataZoomSelect', or 'brush', or ...,
+     *         If no userKey, release global cursor.
+     * }
+     */
+    // TODO: SELF REGISTERED.
+
+
+    registerAction({
+      type: 'takeGlobalCursor',
+      event: 'globalCursorTaken',
+      update: 'update'
+    }, function () {});
+
+    var RoamController =
+    /** @class */
+    function (_super) {
+      __extends(RoamController, _super);
+
+      function RoamController(zr) {
+        var _this = _super.call(this) || this;
+
+        _this._zr = zr; // Avoid two roamController bind the same handler
+
+        var mousedownHandler = bind(_this._mousedownHandler, _this);
+        var mousemoveHandler = bind(_this._mousemoveHandler, _this);
+        var mouseupHandler = bind(_this._mouseupHandler, _this);
+        var mousewheelHandler = bind(_this._mousewheelHandler, _this);
+        var pinchHandler = bind(_this._pinchHandler, _this);
+        /**
+         * Notice: only enable needed types. For example, if 'zoom'
+         * is not needed, 'zoom' should not be enabled, otherwise
+         * default mousewheel behaviour (scroll page) will be disabled.
+         */
+
+        _this.enable = function (controlType, opt) {
+          // Disable previous first
+          this.disable();
+          this._opt = defaults(clone(opt) || {}, {
+            zoomOnMouseWheel: true,
+            moveOnMouseMove: true,
+            // By default, wheel do not trigger move.
+            moveOnMouseWheel: false,
+            preventDefaultMouseMove: true
+          });
+
+          if (controlType == null) {
+            controlType = true;
+          }
+
+          if (controlType === true || controlType === 'move' || controlType === 'pan') {
+            zr.on('mousedown', mousedownHandler);
+            zr.on('mousemove', mousemoveHandler);
+            zr.on('mouseup', mouseupHandler);
+          }
+
+          if (controlType === true || controlType === 'scale' || controlType === 'zoom') {
+            zr.on('mousewheel', mousewheelHandler);
+            zr.on('pinch', pinchHandler);
+          }
+        };
+
+        _this.disable = function () {
+          zr.off('mousedown', mousedownHandler);
+          zr.off('mousemove', mousemoveHandler);
+          zr.off('mouseup', mouseupHandler);
+          zr.off('mousewheel', mousewheelHandler);
+          zr.off('pinch', pinchHandler);
+        };
+
+        return _this;
+      }
+
+      RoamController.prototype.isDragging = function () {
+        return this._dragging;
+      };
+
+      RoamController.prototype.isPinching = function () {
+        return this._pinching;
+      };
+
+      RoamController.prototype.setPointerChecker = function (pointerChecker) {
+        this.pointerChecker = pointerChecker;
+      };
+
+      RoamController.prototype.dispose = function () {
+        this.disable();
+      };
+
+      RoamController.prototype._mousedownHandler = function (e) {
+        if (isMiddleOrRightButtonOnMouseUpDown(e) || e.target && e.target.draggable) {
+          return;
+        }
+
+        var x = e.offsetX;
+        var y = e.offsetY; // Only check on mosedown, but not mousemove.
+        // Mouse can be out of target when mouse moving.
+
+        if (this.pointerChecker && this.pointerChecker(e, x, y)) {
+          this._x = x;
+          this._y = y;
+          this._dragging = true;
+        }
+      };
+
+      RoamController.prototype._mousemoveHandler = function (e) {
+        if (!this._dragging || !isAvailableBehavior('moveOnMouseMove', e, this._opt) || e.gestureEvent === 'pinch' || isTaken(this._zr, 'globalPan')) {
+          return;
+        }
+
+        var x = e.offsetX;
+        var y = e.offsetY;
+        var oldX = this._x;
+        var oldY = this._y;
+        var dx = x - oldX;
+        var dy = y - oldY;
+        this._x = x;
+        this._y = y;
+        this._opt.preventDefaultMouseMove && stop(e.event);
+        trigger(this, 'pan', 'moveOnMouseMove', e, {
+          dx: dx,
+          dy: dy,
+          oldX: oldX,
+          oldY: oldY,
+          newX: x,
+          newY: y,
+          isAvailableBehavior: null
+        });
+      };
+
+      RoamController.prototype._mouseupHandler = function (e) {
+        if (!isMiddleOrRightButtonOnMouseUpDown(e)) {
+          this._dragging = false;
+        }
+      };
+
+      RoamController.prototype._mousewheelHandler = function (e) {
+        var shouldZoom = isAvailableBehavior('zoomOnMouseWheel', e, this._opt);
+        var shouldMove = isAvailableBehavior('moveOnMouseWheel', e, this._opt);
+        var wheelDelta = e.wheelDelta;
+        var absWheelDeltaDelta = Math.abs(wheelDelta);
+        var originX = e.offsetX;
+        var originY = e.offsetY; // wheelDelta maybe -0 in chrome mac.
+
+        if (wheelDelta === 0 || !shouldZoom && !shouldMove) {
+          return;
+        } // If both `shouldZoom` and `shouldMove` is true, trigger
+        // their event both, and the final behavior is determined
+        // by event listener themselves.
+
+
+        if (shouldZoom) {
+          // Convenience:
+          // Mac and VM Windows on Mac: scroll up: zoom out.
+          // Windows: scroll up: zoom in.
+          // FIXME: Should do more test in different environment.
+          // wheelDelta is too complicated in difference nvironment
+          // (https://developer.mozilla.org/en-US/docs/Web/Events/mousewheel),
+          // although it has been normallized by zrender.
+          // wheelDelta of mouse wheel is bigger than touch pad.
+          var factor = absWheelDeltaDelta > 3 ? 1.4 : absWheelDeltaDelta > 1 ? 1.2 : 1.1;
+          var scale = wheelDelta > 0 ? factor : 1 / factor;
+          checkPointerAndTrigger(this, 'zoom', 'zoomOnMouseWheel', e, {
+            scale: scale,
+            originX: originX,
+            originY: originY,
+            isAvailableBehavior: null
+          });
+        }
+
+        if (shouldMove) {
+          // FIXME: Should do more test in different environment.
+          var absDelta = Math.abs(wheelDelta); // wheelDelta of mouse wheel is bigger than touch pad.
+
+          var scrollDelta = (wheelDelta > 0 ? 1 : -1) * (absDelta > 3 ? 0.4 : absDelta > 1 ? 0.15 : 0.05);
+          checkPointerAndTrigger(this, 'scrollMove', 'moveOnMouseWheel', e, {
+            scrollDelta: scrollDelta,
+            originX: originX,
+            originY: originY,
+            isAvailableBehavior: null
+          });
+        }
+      };
+
+      RoamController.prototype._pinchHandler = function (e) {
+        if (isTaken(this._zr, 'globalPan')) {
+          return;
+        }
+
+        var scale = e.pinchScale > 1 ? 1.1 : 1 / 1.1;
+        checkPointerAndTrigger(this, 'zoom', null, e, {
+          scale: scale,
+          originX: e.pinchX,
+          originY: e.pinchY,
+          isAvailableBehavior: null
+        });
+      };
+
+      return RoamController;
+    }(Eventful);
+
+    function checkPointerAndTrigger(controller, eventName, behaviorToCheck, e, contollerEvent) {
+      if (controller.pointerChecker && controller.pointerChecker(e, contollerEvent.originX, contollerEvent.originY)) {
+        // When mouse is out of roamController rect,
+        // default befavoius should not be be disabled, otherwise
+        // page sliding is disabled, contrary to expectation.
+        stop(e.event);
+        trigger(controller, eventName, behaviorToCheck, e, contollerEvent);
+      }
+    }
+
+    function trigger(controller, eventName, behaviorToCheck, e, contollerEvent) {
+      // Also provide behavior checker for event listener, for some case that
+      // multiple components share one listener.
+      contollerEvent.isAvailableBehavior = bind(isAvailableBehavior, null, behaviorToCheck, e);
+      controller.trigger(eventName, contollerEvent);
+    } // settings: {
+    //     zoomOnMouseWheel
+    //     moveOnMouseMove
+    //     moveOnMouseWheel
+    // }
+    // The value can be: true / false / 'shift' / 'ctrl' / 'alt'.
+
+
+    function isAvailableBehavior(behaviorToCheck, e, settings) {
+      var setting = settings[behaviorToCheck];
+      return !behaviorToCheck || setting && (!isString(setting) || e.event[setting + 'Key']);
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * For geo and graph.
+     */
+    function updateViewOnPan(controllerHost, dx, dy) {
+      var target = controllerHost.target;
+      target.x += dx;
+      target.y += dy;
+      target.dirty();
+    }
+    /**
+     * For geo and graph.
+     */
+
+    function updateViewOnZoom(controllerHost, zoomDelta, zoomX, zoomY) {
+      var target = controllerHost.target;
+      var zoomLimit = controllerHost.zoomLimit;
+      var newZoom = controllerHost.zoom = controllerHost.zoom || 1;
+      newZoom *= zoomDelta;
+
+      if (zoomLimit) {
+        var zoomMin = zoomLimit.min || 0;
+        var zoomMax = zoomLimit.max || Infinity;
+        newZoom = Math.max(Math.min(zoomMax, newZoom), zoomMin);
+      }
+
+      var zoomScale = newZoom / controllerHost.zoom;
+      controllerHost.zoom = newZoom; // Keep the mouse center when scaling
+
+      target.x -= (zoomX - target.x) * (zoomScale - 1);
+      target.y -= (zoomY - target.y) * (zoomScale - 1);
+      target.scaleX *= zoomScale;
+      target.scaleY *= zoomScale;
+      target.dirty();
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var IRRELEVANT_EXCLUDES = {
+      'axisPointer': 1,
+      'tooltip': 1,
+      'brush': 1
+    };
+    /**
+     * Avoid that: mouse click on a elements that is over geo or graph,
+     * but roam is triggered.
+     */
+
+    function onIrrelevantElement(e, api, targetCoordSysModel) {
+      var model = api.getComponentByElement(e.topTarget); // If model is axisModel, it works only if it is injected with coordinateSystem.
+
+      var coordSys = model && model.coordinateSystem;
+      return model && model !== targetCoordSysModel && !IRRELEVANT_EXCLUDES.hasOwnProperty(model.mainType) && coordSys && coordSys.model !== targetCoordSysModel;
+    }
+
+    var geoCoord = [126, 25];
+    var points$1 = [[[0, 3.5], [7, 11.2], [15, 11.9], [30, 7], [42, 0.7], [52, 0.7], [56, 7.7], [59, 0.7], [64, 0.7], [64, 0], [5, 0], [0, 3.5]], [[13, 16.1], [19, 14.7], [16, 21.7], [11, 23.1], [13, 16.1]], [[12, 32.2], [14, 38.5], [15, 38.5], [13, 32.2], [12, 32.2]], [[16, 47.6], [12, 53.2], [13, 53.2], [18, 47.6], [16, 47.6]], [[6, 64.4], [8, 70], [9, 70], [8, 64.4], [6, 64.4]], [[23, 82.6], [29, 79.8], [30, 79.8], [25, 82.6], [23, 82.6]], [[37, 70.7], [43, 62.3], [44, 62.3], [39, 70.7], [37, 70.7]], [[48, 51.1], [51, 45.5], [53, 45.5], [50, 51.1], [48, 51.1]], [[51, 35], [51, 28.7], [53, 28.7], [53, 35], [51, 35]], [[52, 22.4], [55, 17.5], [56, 17.5], [53, 22.4], [52, 22.4]], [[58, 12.6], [62, 7], [63, 7], [60, 12.6], [58, 12.6]], [[0, 3.5], [0, 93.1], [64, 93.1], [64, 0], [63, 0], [63, 92.4], [1, 92.4], [1, 3.5], [0, 3.5]]];
+
+    for (var i = 0; i < points$1.length; i++) {
+      for (var k = 0; k < points$1[i].length; k++) {
+        points$1[i][k][0] /= 10.5;
+        points$1[i][k][1] /= -10.5 / 0.75;
+        points$1[i][k][0] += geoCoord[0];
+        points$1[i][k][1] += geoCoord[1];
+      }
+    }
+
+    function fixNanhai(mapType, regions) {
+      if (mapType === 'china') {
+        regions.push(new Region('南海诸岛', map(points$1, function (exterior) {
+          return {
+            type: 'polygon',
+            exterior: exterior
+          };
+        }), geoCoord));
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var coordsOffsetMap = {
+      '南海诸岛': [32, 80],
+      // 全国
+      '广东': [0, -10],
+      '香港': [10, 5],
+      '澳门': [-10, 10],
+      //'北京': [-10, 0],
+      '天津': [5, 5]
+    };
+    function fixTextCoords(mapType, region) {
+      if (mapType === 'china') {
+        var coordFix = coordsOffsetMap[region.name];
+
+        if (coordFix) {
+          var cp = region.center;
+          cp[0] += coordFix[0] / 10.5;
+          cp[1] += -coordFix[1] / (10.5 / 0.75);
+        }
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var geoCoordMap = {
+      'Russia': [100, 60],
+      'United States': [-99, 38],
+      'United States of America': [-99, 38]
+    };
+    function fixGeoCoords(mapType, region) {
+      if (mapType === 'world') {
+        var geoCoord = geoCoordMap[region.name];
+
+        if (geoCoord) {
+          var cp = region.center;
+          cp[0] = geoCoord[0];
+          cp[1] = geoCoord[1];
+        }
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    // Fix for 钓鱼岛
+    // let Region = require('../Region');
+    // let zrUtil = require('zrender/lib/core/util');
+    // let geoCoord = [126, 25];
+    var points$2 = [[[123.45165252685547, 25.73527164402261], [123.49731445312499, 25.73527164402261], [123.49731445312499, 25.750734064600884], [123.45165252685547, 25.750734064600884], [123.45165252685547, 25.73527164402261]]];
+    function fixDiaoyuIsland(mapType, region) {
+      if (mapType === 'china' && region.name === '台湾') {
+        region.geometries.push({
+          type: 'polygon',
+          exterior: points$2[0]
+        });
+      }
+    }
+
+    var inner$6 = makeInner();
+    var geoJSONLoader = {
+      load: function (mapName, mapRecord, nameProperty) {
+        var parsed = inner$6(mapRecord).parsed;
+
+        if (parsed) {
+          return parsed;
+        }
+
+        var specialAreas = mapRecord.specialAreas || {};
+        var geoJSON = mapRecord.geoJSON;
+        var regions; // https://jsperf.com/try-catch-performance-overhead
+
+        try {
+          regions = geoJSON ? parseGeoJSON(geoJSON, nameProperty) : [];
+        } catch (e) {
+          throw new Error('Invalid geoJson format\n' + e.message);
+        }
+
+        fixNanhai(mapName, regions);
+        each(regions, function (region) {
+          var regionName = region.name;
+          fixTextCoords(mapName, region);
+          fixGeoCoords(mapName, region);
+          fixDiaoyuIsland(mapName, region); // Some area like Alaska in USA map needs to be tansformed
+          // to look better
+
+          var specialArea = specialAreas[regionName];
+
+          if (specialArea) {
+            region.transformTo(specialArea.left, specialArea.top, specialArea.width, specialArea.height);
+          }
+        });
+        return inner$6(mapRecord).parsed = {
+          regions: regions,
+          boundingRect: getBoundingRect$1(regions)
+        };
+      }
+    };
+
+    function getBoundingRect$1(regions) {
+      var rect;
+
+      for (var i = 0; i < regions.length; i++) {
+        var regionRect = regions[i].getBoundingRect();
+        rect = rect || regionRect.clone();
+        rect.union(regionRect);
+      }
+
+      return rect;
+    }
+
+    var DILIMITER_REG = /[\s,]+/;
+    var nodeParsers;
+    var SVGParser = (function () {
+        function SVGParser() {
+            this._defs = {};
+            this._root = null;
+            this._isDefine = false;
+            this._isText = false;
+        }
+        SVGParser.prototype.parse = function (xml, opt) {
+            opt = opt || {};
+            var svg = parseXML(xml);
+            if (!svg) {
+                throw new Error('Illegal svg');
+            }
+            var root = new Group();
+            this._root = root;
+            var viewBox = svg.getAttribute('viewBox') || '';
+            var width = parseFloat((svg.getAttribute('width') || opt.width));
+            var height = parseFloat((svg.getAttribute('height') || opt.height));
+            isNaN(width) && (width = null);
+            isNaN(height) && (height = null);
+            parseAttributes(svg, root, null, true);
+            var child = svg.firstChild;
+            while (child) {
+                this._parseNode(child, root);
+                child = child.nextSibling;
+            }
+            var viewBoxRect;
+            var viewBoxTransform;
+            if (viewBox) {
+                var viewBoxArr = trim(viewBox).split(DILIMITER_REG);
+                if (viewBoxArr.length >= 4) {
+                    viewBoxRect = {
+                        x: parseFloat((viewBoxArr[0] || 0)),
+                        y: parseFloat((viewBoxArr[1] || 0)),
+                        width: parseFloat(viewBoxArr[2]),
+                        height: parseFloat(viewBoxArr[3])
+                    };
+                }
+            }
+            if (viewBoxRect && width != null && height != null) {
+                viewBoxTransform = makeViewBoxTransform(viewBoxRect, width, height);
+                if (!opt.ignoreViewBox) {
+                    var elRoot = root;
+                    root = new Group();
+                    root.add(elRoot);
+                    elRoot.scaleX = elRoot.scaleY = viewBoxTransform.scale;
+                    elRoot.x = viewBoxTransform.x;
+                    elRoot.y = viewBoxTransform.y;
+                }
+            }
+            if (!opt.ignoreRootClip && width != null && height != null) {
+                root.setClipPath(new Rect({
+                    shape: { x: 0, y: 0, width: width, height: height }
+                }));
+            }
+            return {
+                root: root,
+                width: width,
+                height: height,
+                viewBoxRect: viewBoxRect,
+                viewBoxTransform: viewBoxTransform
+            };
+        };
+        SVGParser.prototype._parseNode = function (xmlNode, parentGroup) {
+            var nodeName = xmlNode.nodeName.toLowerCase();
+            if (nodeName === 'defs') {
+                this._isDefine = true;
+            }
+            else if (nodeName === 'text') {
+                this._isText = true;
+            }
+            var el;
+            if (this._isDefine) {
+                var parser = defineParsers[nodeName];
+                if (parser) {
+                    var def = parser.call(this, xmlNode);
+                    var id = xmlNode.getAttribute('id');
+                    if (id) {
+                        this._defs[id] = def;
+                    }
+                }
+            }
+            else {
+                var parser = nodeParsers[nodeName];
+                if (parser) {
+                    el = parser.call(this, xmlNode, parentGroup);
+                    parentGroup.add(el);
+                }
+            }
+            if (el) {
+                var child = xmlNode.firstChild;
+                while (child) {
+                    if (child.nodeType === 1) {
+                        this._parseNode(child, el);
+                    }
+                    if (child.nodeType === 3 && this._isText) {
+                        this._parseText(child, el);
+                    }
+                    child = child.nextSibling;
+                }
+            }
+            if (nodeName === 'defs') {
+                this._isDefine = false;
+            }
+            else if (nodeName === 'text') {
+                this._isText = false;
+            }
+        };
+        SVGParser.prototype._parseText = function (xmlNode, parentGroup) {
+            if (xmlNode.nodeType === 1) {
+                var dx = xmlNode.getAttribute('dx') || 0;
+                var dy = xmlNode.getAttribute('dy') || 0;
+                this._textX += parseFloat(dx);
+                this._textY += parseFloat(dy);
+            }
+            var text = new TSpan({
+                style: {
+                    text: xmlNode.textContent
+                },
+                x: this._textX || 0,
+                y: this._textY || 0
+            });
+            inheritStyle(parentGroup, text);
+            parseAttributes(xmlNode, text, this._defs);
+            var textStyle = text.style;
+            var fontSize = textStyle.fontSize;
+            if (fontSize && fontSize < 9) {
+                textStyle.fontSize = 9;
+                text.scaleX *= fontSize / 9;
+                text.scaleY *= fontSize / 9;
+            }
+            var font = (textStyle.fontSize || textStyle.fontFamily) && [
+                textStyle.fontStyle,
+                textStyle.fontWeight,
+                (textStyle.fontSize || 12) + 'px',
+                textStyle.fontFamily || 'sans-serif'
+            ].join(' ');
+            textStyle.font = font;
+            var rect = text.getBoundingRect();
+            this._textX += rect.width;
+            parentGroup.add(text);
+            return text;
+        };
+        SVGParser.internalField = (function () {
+            nodeParsers = {
+                'g': function (xmlNode, parentGroup) {
+                    var g = new Group();
+                    inheritStyle(parentGroup, g);
+                    parseAttributes(xmlNode, g, this._defs);
+                    return g;
+                },
+                'rect': function (xmlNode, parentGroup) {
+                    var rect = new Rect();
+                    inheritStyle(parentGroup, rect);
+                    parseAttributes(xmlNode, rect, this._defs);
+                    rect.setShape({
+                        x: parseFloat(xmlNode.getAttribute('x') || '0'),
+                        y: parseFloat(xmlNode.getAttribute('y') || '0'),
+                        width: parseFloat(xmlNode.getAttribute('width') || '0'),
+                        height: parseFloat(xmlNode.getAttribute('height') || '0')
+                    });
+                    return rect;
+                },
+                'circle': function (xmlNode, parentGroup) {
+                    var circle = new Circle();
+                    inheritStyle(parentGroup, circle);
+                    parseAttributes(xmlNode, circle, this._defs);
+                    circle.setShape({
+                        cx: parseFloat(xmlNode.getAttribute('cx') || '0'),
+                        cy: parseFloat(xmlNode.getAttribute('cy') || '0'),
+                        r: parseFloat(xmlNode.getAttribute('r') || '0')
+                    });
+                    return circle;
+                },
+                'line': function (xmlNode, parentGroup) {
+                    var line = new Line();
+                    inheritStyle(parentGroup, line);
+                    parseAttributes(xmlNode, line, this._defs);
+                    line.setShape({
+                        x1: parseFloat(xmlNode.getAttribute('x1') || '0'),
+                        y1: parseFloat(xmlNode.getAttribute('y1') || '0'),
+                        x2: parseFloat(xmlNode.getAttribute('x2') || '0'),
+                        y2: parseFloat(xmlNode.getAttribute('y2') || '0')
+                    });
+                    return line;
+                },
+                'ellipse': function (xmlNode, parentGroup) {
+                    var ellipse = new Ellipse();
+                    inheritStyle(parentGroup, ellipse);
+                    parseAttributes(xmlNode, ellipse, this._defs);
+                    ellipse.setShape({
+                        cx: parseFloat(xmlNode.getAttribute('cx') || '0'),
+                        cy: parseFloat(xmlNode.getAttribute('cy') || '0'),
+                        rx: parseFloat(xmlNode.getAttribute('rx') || '0'),
+                        ry: parseFloat(xmlNode.getAttribute('ry') || '0')
+                    });
+                    return ellipse;
+                },
+                'polygon': function (xmlNode, parentGroup) {
+                    var pointsStr = xmlNode.getAttribute('points');
+                    var pointsArr;
+                    if (pointsStr) {
+                        pointsArr = parsePoints(pointsStr);
+                    }
+                    var polygon = new Polygon({
+                        shape: {
+                            points: pointsArr || []
+                        }
+                    });
+                    inheritStyle(parentGroup, polygon);
+                    parseAttributes(xmlNode, polygon, this._defs);
+                    return polygon;
+                },
+                'polyline': function (xmlNode, parentGroup) {
+                    var path = new Path();
+                    inheritStyle(parentGroup, path);
+                    parseAttributes(xmlNode, path, this._defs);
+                    var pointsStr = xmlNode.getAttribute('points');
+                    var pointsArr;
+                    if (pointsStr) {
+                        pointsArr = parsePoints(pointsStr);
+                    }
+                    var polyline = new Polyline({
+                        shape: {
+                            points: pointsArr || []
+                        }
+                    });
+                    return polyline;
+                },
+                'image': function (xmlNode, parentGroup) {
+                    var img = new ZRImage();
+                    inheritStyle(parentGroup, img);
+                    parseAttributes(xmlNode, img, this._defs);
+                    img.setStyle({
+                        image: xmlNode.getAttribute('xlink:href'),
+                        x: +xmlNode.getAttribute('x'),
+                        y: +xmlNode.getAttribute('y'),
+                        width: +xmlNode.getAttribute('width'),
+                        height: +xmlNode.getAttribute('height')
+                    });
+                    return img;
+                },
+                'text': function (xmlNode, parentGroup) {
+                    var x = xmlNode.getAttribute('x') || '0';
+                    var y = xmlNode.getAttribute('y') || '0';
+                    var dx = xmlNode.getAttribute('dx') || '0';
+                    var dy = xmlNode.getAttribute('dy') || '0';
+                    this._textX = parseFloat(x) + parseFloat(dx);
+                    this._textY = parseFloat(y) + parseFloat(dy);
+                    var g = new Group();
+                    inheritStyle(parentGroup, g);
+                    parseAttributes(xmlNode, g, this._defs);
+                    return g;
+                },
+                'tspan': function (xmlNode, parentGroup) {
+                    var x = xmlNode.getAttribute('x');
+                    var y = xmlNode.getAttribute('y');
+                    if (x != null) {
+                        this._textX = parseFloat(x);
+                    }
+                    if (y != null) {
+                        this._textY = parseFloat(y);
+                    }
+                    var dx = xmlNode.getAttribute('dx') || 0;
+                    var dy = xmlNode.getAttribute('dy') || 0;
+                    var g = new Group();
+                    inheritStyle(parentGroup, g);
+                    parseAttributes(xmlNode, g, this._defs);
+                    this._textX += dx;
+                    this._textY += dy;
+                    return g;
+                },
+                'path': function (xmlNode, parentGroup) {
+                    var d = xmlNode.getAttribute('d') || '';
+                    var path = createFromString(d);
+                    inheritStyle(parentGroup, path);
+                    parseAttributes(xmlNode, path, this._defs);
+                    return path;
+                }
+            };
+        })();
+        return SVGParser;
+    }());
+    var defineParsers = {
+        'lineargradient': function (xmlNode) {
+            var x1 = parseInt(xmlNode.getAttribute('x1') || '0', 10);
+            var y1 = parseInt(xmlNode.getAttribute('y1') || '0', 10);
+            var x2 = parseInt(xmlNode.getAttribute('x2') || '10', 10);
+            var y2 = parseInt(xmlNode.getAttribute('y2') || '0', 10);
+            var gradient = new LinearGradient(x1, y1, x2, y2);
+            _parseGradientColorStops(xmlNode, gradient);
+            return gradient;
+        }
+    };
+    function _parseGradientColorStops(xmlNode, gradient) {
+        var stop = xmlNode.firstChild;
+        while (stop) {
+            if (stop.nodeType === 1) {
+                var offsetStr = stop.getAttribute('offset');
+                var offset = void 0;
+                if (offsetStr.indexOf('%') > 0) {
+                    offset = parseInt(offsetStr, 10) / 100;
+                }
+                else if (offsetStr) {
+                    offset = parseFloat(offsetStr);
+                }
+                else {
+                    offset = 0;
+                }
+                var stopColor = stop.getAttribute('stop-color') || '#000000';
+                gradient.colorStops.push({
+                    offset: offset,
+                    color: stopColor
+                });
+            }
+            stop = stop.nextSibling;
+        }
+    }
+    function inheritStyle(parent, child) {
+        if (parent && parent.__inheritedStyle) {
+            if (!child.__inheritedStyle) {
+                child.__inheritedStyle = {};
+            }
+            defaults(child.__inheritedStyle, parent.__inheritedStyle);
+        }
+    }
+    function parsePoints(pointsString) {
+        var list = trim(pointsString).split(DILIMITER_REG);
+        var points = [];
+        for (var i = 0; i < list.length; i += 2) {
+            var x = parseFloat(list[i]);
+            var y = parseFloat(list[i + 1]);
+            points.push([x, y]);
+        }
+        return points;
+    }
+    var attributesMap = {
+        'fill': 'fill',
+        'stroke': 'stroke',
+        'stroke-width': 'lineWidth',
+        'opacity': 'opacity',
+        'fill-opacity': 'fillOpacity',
+        'stroke-opacity': 'strokeOpacity',
+        'stroke-dasharray': 'lineDash',
+        'stroke-dashoffset': 'lineDashOffset',
+        'stroke-linecap': 'lineCap',
+        'stroke-linejoin': 'lineJoin',
+        'stroke-miterlimit': 'miterLimit',
+        'font-family': 'fontFamily',
+        'font-size': 'fontSize',
+        'font-style': 'fontStyle',
+        'font-weight': 'fontWeight',
+        'text-align': 'textAlign',
+        'alignment-baseline': 'textBaseline'
+    };
+    function parseAttributes(xmlNode, el, defs, onlyInlineStyle) {
+        var disp = el;
+        var zrStyle = disp.__inheritedStyle || {};
+        if (xmlNode.nodeType === 1) {
+            parseTransformAttribute(xmlNode, el);
+            extend(zrStyle, parseStyleAttribute(xmlNode));
+            if (!onlyInlineStyle) {
+                for (var svgAttrName in attributesMap) {
+                    if (attributesMap.hasOwnProperty(svgAttrName)) {
+                        var attrValue = xmlNode.getAttribute(svgAttrName);
+                        if (attrValue != null) {
+                            zrStyle[attributesMap[svgAttrName]] = attrValue;
+                        }
+                    }
+                }
+            }
+        }
+        disp.style = disp.style || {};
+        zrStyle.fill != null && (disp.style.fill = getPaint(zrStyle.fill, defs));
+        zrStyle.stroke != null && (disp.style.stroke = getPaint(zrStyle.stroke, defs));
+        each([
+            'lineWidth', 'opacity', 'fillOpacity', 'strokeOpacity', 'miterLimit', 'fontSize'
+        ], function (propName) {
+            zrStyle[propName] != null && (disp.style[propName] = parseFloat(zrStyle[propName]));
+        });
+        if (!zrStyle.textBaseline || zrStyle.textBaseline === 'auto') {
+            zrStyle.textBaseline = 'alphabetic';
+        }
+        if (zrStyle.textBaseline === 'alphabetic') {
+            zrStyle.textBaseline = 'bottom';
+        }
+        if (zrStyle.textAlign === 'start') {
+            zrStyle.textAlign = 'left';
+        }
+        if (zrStyle.textAlign === 'end') {
+            zrStyle.textAlign = 'right';
+        }
+        each(['lineDashOffset', 'lineCap', 'lineJoin',
+            'fontWeight', 'fontFamily', 'fontStyle', 'textAlign', 'textBaseline'
+        ], function (propName) {
+            zrStyle[propName] != null && (disp.style[propName] = zrStyle[propName]);
+        });
+        if (zrStyle.lineDash) {
+            disp.style.lineDash = map(trim(zrStyle.lineDash).split(DILIMITER_REG), function (str) {
+                return parseFloat(str);
+            });
+        }
+        disp.__inheritedStyle = zrStyle;
+    }
+    var urlRegex = /url\(\s*#(.*?)\)/;
+    function getPaint(str, defs) {
+        var urlMatch = defs && str && str.match(urlRegex);
+        if (urlMatch) {
+            var url = trim(urlMatch[1]);
+            var def = defs[url];
+            return def;
+        }
+        return str;
+    }
+    var transformRegex = /(translate|scale|rotate|skewX|skewY|matrix)\(([\-\s0-9\.e,]*)\)/g;
+    function parseTransformAttribute(xmlNode, node) {
+        var transform = xmlNode.getAttribute('transform');
+        if (transform) {
+            transform = transform.replace(/,/g, ' ');
+            var transformOps_1 = [];
+            var m = null;
+            transform.replace(transformRegex, function (str, type, value) {
+                transformOps_1.push(type, value);
+                return '';
+            });
+            for (var i = transformOps_1.length - 1; i > 0; i -= 2) {
+                var value = transformOps_1[i];
+                var type = transformOps_1[i - 1];
+                var valueArr = void 0;
+                m = m || create$1();
+                switch (type) {
+                    case 'translate':
+                        valueArr = trim(value).split(DILIMITER_REG);
+                        translate(m, m, [parseFloat(valueArr[0]), parseFloat(valueArr[1] || '0')]);
+                        break;
+                    case 'scale':
+                        valueArr = trim(value).split(DILIMITER_REG);
+                        scale$1(m, m, [parseFloat(valueArr[0]), parseFloat(valueArr[1] || valueArr[0])]);
+                        break;
+                    case 'rotate':
+                        valueArr = trim(value).split(DILIMITER_REG);
+                        rotate(m, m, parseFloat(valueArr[0]));
+                        break;
+                    case 'skew':
+                        valueArr = trim(value).split(DILIMITER_REG);
+                        console.warn('Skew transform is not supported yet');
+                        break;
+                    case 'matrix':
+                        valueArr = trim(value).split(DILIMITER_REG);
+                        m[0] = parseFloat(valueArr[0]);
+                        m[1] = parseFloat(valueArr[1]);
+                        m[2] = parseFloat(valueArr[2]);
+                        m[3] = parseFloat(valueArr[3]);
+                        m[4] = parseFloat(valueArr[4]);
+                        m[5] = parseFloat(valueArr[5]);
+                        break;
+                }
+            }
+            node.setLocalTransform(m);
+        }
+    }
+    var styleRegex = /([^\s:;]+)\s*:\s*([^:;]+)/g;
+    function parseStyleAttribute(xmlNode) {
+        var style = xmlNode.getAttribute('style');
+        var result = {};
+        if (!style) {
+            return result;
+        }
+        var styleList = {};
+        styleRegex.lastIndex = 0;
+        var styleRegResult;
+        while ((styleRegResult = styleRegex.exec(style)) != null) {
+            styleList[styleRegResult[1]] = styleRegResult[2];
+        }
+        for (var svgAttrName in attributesMap) {
+            if (attributesMap.hasOwnProperty(svgAttrName) && styleList[svgAttrName] != null) {
+                result[attributesMap[svgAttrName]] = styleList[svgAttrName];
+            }
+        }
+        return result;
+    }
+    function makeViewBoxTransform(viewBoxRect, width, height) {
+        var scaleX = width / viewBoxRect.width;
+        var scaleY = height / viewBoxRect.height;
+        var scale = Math.min(scaleX, scaleY);
+        return {
+            scale: scale,
+            x: -(viewBoxRect.x + viewBoxRect.width / 2) * scale + width / 2,
+            y: -(viewBoxRect.y + viewBoxRect.height / 2) * scale + height / 2
+        };
+    }
+    function parseSVG(xml, opt) {
+        var parser = new SVGParser();
+        return parser.parse(xml, opt);
+    }
+
+    var inner$7 = makeInner();
+    var geoSVGLoader = {
+      load: function (mapName, mapRecord) {
+        var originRoot = inner$7(mapRecord).originRoot;
+
+        if (originRoot) {
+          return {
+            root: originRoot,
+            boundingRect: inner$7(mapRecord).boundingRect
+          };
+        }
+
+        var graphic = buildGraphic(mapRecord);
+        inner$7(mapRecord).originRoot = graphic.root;
+        inner$7(mapRecord).boundingRect = graphic.boundingRect;
+        return graphic;
+      },
+      makeGraphic: function (mapName, mapRecord, hostKey) {
+        // For performance consideration (in large SVG), graphic only maked
+        // when necessary and reuse them according to hostKey.
+        var field = inner$7(mapRecord);
+        var rootMap = field.rootMap || (field.rootMap = createHashMap());
+        var root = rootMap.get(hostKey);
+
+        if (root) {
+          return root;
+        }
+
+        var originRoot = field.originRoot;
+        var boundingRect = field.boundingRect; // For performance, if originRoot is not used by a view,
+        // assign it to a view, but not reproduce graphic elements.
+
+        if (!field.originRootHostKey) {
+          field.originRootHostKey = hostKey;
+          root = originRoot;
+        } else {
+          root = buildGraphic(mapRecord, boundingRect).root;
+        }
+
+        return rootMap.set(hostKey, root);
+      },
+      removeGraphic: function (mapName, mapRecord, hostKey) {
+        var field = inner$7(mapRecord);
+        var rootMap = field.rootMap;
+        rootMap && rootMap.removeKey(hostKey);
+
+        if (hostKey === field.originRootHostKey) {
+          field.originRootHostKey = null;
+        }
+      }
+    };
+
+    function buildGraphic(mapRecord, boundingRect) {
+      var svgXML = mapRecord.svgXML;
+      var result;
+      var root;
+
+      try {
+        result = svgXML && parseSVG(svgXML, {
+          ignoreViewBox: true,
+          ignoreRootClip: true
+        }) || {};
+        root = result.root;
+        assert(root != null);
+      } catch (e) {
+        throw new Error('Invalid svg format\n' + e.message);
+      }
+
+      var svgWidth = result.width;
+      var svgHeight = result.height;
+      var viewBoxRect = result.viewBoxRect;
+
+      if (!boundingRect) {
+        boundingRect = svgWidth == null || svgHeight == null ? // If svg width / height not specified, calculate
+        // bounding rect as the width / height
+        root.getBoundingRect() : new BoundingRect(0, 0, 0, 0);
+
+        if (svgWidth != null) {
+          boundingRect.width = svgWidth;
+        }
+
+        if (svgHeight != null) {
+          boundingRect.height = svgHeight;
+        }
+      }
+
+      if (viewBoxRect) {
+        var viewBoxTransform = makeViewBoxTransform(viewBoxRect, boundingRect.width, boundingRect.height);
+        var elRoot = root;
+        root = new Group();
+        root.add(elRoot);
+        elRoot.scaleX = elRoot.scaleY = viewBoxTransform.scale;
+        elRoot.x = viewBoxTransform.x;
+        elRoot.y = viewBoxTransform.y;
+      }
+
+      root.setClipPath(new Rect({
+        shape: boundingRect.plain()
+      }));
+      return {
+        root: root,
+        boundingRect: boundingRect
+      };
+    }
+
+    var loaders = {
+      geoJSON: geoJSONLoader,
+      svg: geoSVGLoader
+    };
+    var geoSourceManager = {
+      load: function (mapName, nameMap, nameProperty) {
+        var regions = [];
+        var regionsMap = createHashMap();
+        var nameCoordMap = createHashMap();
+        var boundingRect;
+        var mapRecords = retrieveMap(mapName);
+        each(mapRecords, function (record) {
+          var singleSource = loaders[record.type].load(mapName, record, nameProperty);
+          each(singleSource.regions, function (region) {
+            var regionName = region.name; // Try use the alias in geoNameMap
+
+            if (nameMap && nameMap.hasOwnProperty(regionName)) {
+              region = region.cloneShallow(regionName = nameMap[regionName]);
+            }
+
+            regions.push(region);
+            regionsMap.set(regionName, region);
+            nameCoordMap.set(regionName, region.center);
+          });
+          var rect = singleSource.boundingRect;
+
+          if (rect) {
+            boundingRect ? boundingRect.union(rect) : boundingRect = rect.clone();
+          }
+        });
+        return {
+          regions: regions,
+          regionsMap: regionsMap,
+          nameCoordMap: nameCoordMap,
+          // FIXME Always return new ?
+          boundingRect: boundingRect || new BoundingRect(0, 0, 0, 0)
+        };
+      },
+
+      /**
+       * @param hostKey For cache.
+       * @return Roots.
+       */
+      makeGraphic: function (mapName, hostKey) {
+        var mapRecords = retrieveMap(mapName);
+        var results = [];
+        each(mapRecords, function (record) {
+          var method = loaders[record.type].makeGraphic;
+          method && results.push(method(mapName, record, hostKey));
+        });
+        return results;
+      },
+
+      /**
+       * @param hostKey For cache.
+       */
+      removeGraphic: function (mapName, hostKey) {
+        var mapRecords = retrieveMap(mapName);
+        each(mapRecords, function (record) {
+          var method = loaders[record.type].makeGraphic;
+          method && method(mapName, record, hostKey);
+        });
+      }
+    };
+
+    function mapNotExistsError(mapName) {
+      if ("development" !== 'production') {
+        console.error('Map ' + mapName + ' not exists. The GeoJSON of the map must be provided.');
+      }
+    }
+
+    function retrieveMap(mapName) {
+      var mapRecords = mapDataStorage.retrieveMap(mapName) || [];
+
+      if ("development" !== 'production') {
+        if (!mapRecords.length) {
+          mapNotExistsError(mapName);
+        }
+      }
+
+      return mapRecords;
+    }
+
+    function getFixedItemStyle(model) {
+      var itemStyle = model.getItemStyle();
+      var areaColor = model.get('areaColor'); // If user want the color not to be changed when hover,
+      // they should both set areaColor and color to be null.
+
+      if (areaColor != null) {
+        itemStyle.fill = areaColor;
+      }
+
+      return itemStyle;
+    }
+
+    var MapDraw =
+    /** @class */
+    function () {
+      function MapDraw(api) {
+        var group = new Group();
+        this.uid = getUID('ec_map_draw'); // @ts-ignore FIXME:TS
+
+        this._controller = new RoamController(api.getZr());
+        this._controllerHost = {
+          target: group
+        };
+        this.group = group;
+        group.add(this._regionsGroup = new Group());
+        group.add(this._backgroundGroup = new Group());
+      }
+
+      MapDraw.prototype.draw = function (mapOrGeoModel, ecModel, api, fromView, payload) {
+        var isGeo = mapOrGeoModel.mainType === 'geo'; // Map series has data. GEO model that controlled by map series
+        // will be assigned with map data. Other GEO model has no data.
+
+        var data = mapOrGeoModel.getData && mapOrGeoModel.getData();
+        isGeo && ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'map'
+        }, function (mapSeries) {
+          if (!data && mapSeries.getHostGeoModel() === mapOrGeoModel) {
+            data = mapSeries.getData();
+          }
+        });
+        var geo = mapOrGeoModel.coordinateSystem;
+
+        this._updateBackground(geo);
+
+        var regionsGroup = this._regionsGroup;
+        var group = this.group;
+        var transformInfo = geo.getTransformInfo(); // No animation when first draw or in action
+
+        var isFirstDraw = !regionsGroup.childAt(0) || payload;
+        var targetScaleX;
+        var targetScaleY;
+
+        if (isFirstDraw) {
+          group.transform = transformInfo.roamTransform;
+          group.decomposeTransform();
+          group.dirty();
+        } else {
+          var target = new Transformable();
+          target.transform = transformInfo.roamTransform;
+          target.decomposeTransform();
+          var props = {
+            scaleX: target.scaleX,
+            scaleY: target.scaleY,
+            x: target.x,
+            y: target.y
+          };
+          targetScaleX = target.scaleX;
+          targetScaleY = target.scaleY;
+          updateProps(group, props, mapOrGeoModel);
+        }
+
+        regionsGroup.removeAll();
+        var nameMap = createHashMap();
+        var isVisualEncodedByVisualMap = data && data.getVisual('visualMeta') && data.getVisual('visualMeta').length > 0;
+        each(geo.regions, function (region) {
+          // Consider in GeoJson properties.name may be duplicated, for example,
+          // there is multiple region named "United Kindom" or "France" (so many
+          // colonies). And it is not appropriate to merge them in geo, which
+          // will make them share the same label and bring trouble in label
+          // location calculation.
+          var regionGroup = nameMap.get(region.name) || nameMap.set(region.name, new Group());
+          var compoundPath = new CompoundPath({
+            segmentIgnoreThreshold: 1,
+            shape: {
+              paths: []
+            }
+          });
+          regionGroup.add(compoundPath);
+          var regionModel = mapOrGeoModel.getRegionModel(region.name) || mapOrGeoModel; // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+          var itemStyleModel = regionModel.getModel('itemStyle'); // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+          var emphasisModel = regionModel.getModel('emphasis');
+          var emphasisItemStyleModel = emphasisModel.getModel('itemStyle'); // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+          var blurItemStyleModel = regionModel.getModel(['blur', 'itemStyle']); // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+          var selectItemStyleModel = regionModel.getModel(['select', 'itemStyle']); // NOTE: DONT use 'style' in visual when drawing map.
+          // This component is used for drawing underlying map for both geo component and map series.
+
+          var itemStyle = getFixedItemStyle(itemStyleModel);
+          var emphasisItemStyle = getFixedItemStyle(emphasisItemStyleModel);
+          var blurItemStyle = getFixedItemStyle(blurItemStyleModel);
+          var selectItemStyle = getFixedItemStyle(selectItemStyleModel);
+          var dataIdx; // Use the itemStyle in data if has data
+
+          if (data) {
+            dataIdx = data.indexOfName(region.name); // Only visual color of each item will be used. It can be encoded by visualMap
+            // But visual color of series is used in symbol drawing
+            //
+            // Visual color for each series is for the symbol draw
+
+            var style = data.getItemVisual(dataIdx, 'style');
+            var decal = data.getItemVisual(dataIdx, 'decal');
+
+            if (isVisualEncodedByVisualMap && style.fill) {
+              itemStyle.fill = style.fill;
+            }
+
+            if (decal) {
+              itemStyle.decal = createOrUpdatePatternFromDecal(decal, api);
+            }
+          }
+
+          var sx = transformInfo.rawScaleX;
+          var sy = transformInfo.rawScaleY;
+          var offsetX = transformInfo.rawX;
+          var offsetY = transformInfo.rawY;
+
+          var transformPoint = function (point) {
+            return [point[0] * sx + offsetX, point[1] * sy + offsetY];
+          };
+
+          each(region.geometries, function (geometry) {
+            if (geometry.type !== 'polygon') {
+              return;
+            }
+
+            var points = [];
+
+            for (var i = 0; i < geometry.exterior.length; ++i) {
+              points.push(transformPoint(geometry.exterior[i]));
+            }
+
+            compoundPath.shape.paths.push(new Polygon({
+              segmentIgnoreThreshold: 1,
+              shape: {
+                points: points
+              }
+            }));
+
+            for (var i = 0; i < (geometry.interiors ? geometry.interiors.length : 0); ++i) {
+              var interior = geometry.interiors[i];
+              var points_1 = [];
+
+              for (var j = 0; j < interior.length; ++j) {
+                points_1.push(transformPoint(interior[j]));
+              }
+
+              compoundPath.shape.paths.push(new Polygon({
+                segmentIgnoreThreshold: 1,
+                shape: {
+                  points: points_1
+                }
+              }));
+            }
+          });
+          compoundPath.setStyle(itemStyle);
+          compoundPath.style.strokeNoScale = true;
+          compoundPath.culling = true;
+          compoundPath.ensureState('emphasis').style = emphasisItemStyle;
+          compoundPath.ensureState('blur').style = blurItemStyle;
+          compoundPath.ensureState('select').style = selectItemStyle;
+          var showLabel = false;
+
+          for (var i = 0; i < DISPLAY_STATES.length; i++) {
+            var stateName = DISPLAY_STATES[i]; // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+            if (regionModel.get(stateName === 'normal' ? ['label', 'show'] : [stateName, 'label', 'show'])) {
+              showLabel = true;
+              break;
+            }
+          }
+
+          var isDataNaN = data && isNaN(data.get(data.mapDimension('value'), dataIdx));
+          var itemLayout = data && data.getItemLayout(dataIdx); // In the following cases label will be drawn
+          // 1. In map series and data value is NaN
+          // 2. In geo component
+          // 4. Region has no series legendSymbol, which will be add a showLabel flag in mapSymbolLayout
+
+          if (isGeo || isDataNaN && showLabel || itemLayout && itemLayout.showLabel) {
+            var query = !isGeo ? dataIdx : region.name;
+            var labelFetcher = void 0; // Consider dataIdx not found.
+
+            if (!data || dataIdx >= 0) {
+              labelFetcher = mapOrGeoModel;
+            }
+
+            var centerPt = transformPoint(region.center);
+            var textEl = new ZRText({
+              x: centerPt[0],
+              y: centerPt[1],
+              // FIXME
+              // label rotation is not support yet in geo or regions of series-map
+              // that has no data. The rotation will be effected by this `scale`.
+              // So needed to change to RectText?
+              scaleX: 1 / group.scaleX,
+              scaleY: 1 / group.scaleY,
+              z2: 10,
+              silent: true
+            });
+            setLabelStyle(textEl, getLabelStatesModels(regionModel), {
+              labelFetcher: labelFetcher,
+              labelDataIndex: query,
+              defaultText: region.name
+            }, {
+              normal: {
+                align: 'center',
+                verticalAlign: 'middle'
+              }
+            });
+            compoundPath.setTextContent(textEl);
+            compoundPath.setTextConfig({
+              local: true
+            });
+            compoundPath.disableLabelAnimation = true;
+
+            if (!isFirstDraw) {
+              // Text animation
+              updateProps(textEl, {
+                scaleX: 1 / targetScaleX,
+                scaleY: 1 / targetScaleY
+              }, mapOrGeoModel);
+            }
+          } // setItemGraphicEl, setHoverStyle after all polygons and labels
+          // are added to the rigionGroup
+
+
+          if (data) {
+            data.setItemGraphicEl(dataIdx, regionGroup);
+          } else {
+            var regionModel_1 = mapOrGeoModel.getRegionModel(region.name); // Package custom mouse event for geo component
+
+            getECData(compoundPath).eventData = {
+              componentType: 'geo',
+              componentIndex: mapOrGeoModel.componentIndex,
+              geoIndex: mapOrGeoModel.componentIndex,
+              name: region.name,
+              region: regionModel_1 && regionModel_1.option || {}
+            };
+          }
+
+          var groupRegions = regionGroup.__regions || (regionGroup.__regions = []);
+          groupRegions.push(region); // @ts-ignore FIXME:TS fix the "compatible with each other"?
+
+          regionGroup.highDownSilentOnTouch = !!mapOrGeoModel.get('selectedMode');
+          enableHoverEmphasis(regionGroup, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+          regionsGroup.add(regionGroup);
+        });
+
+        this._updateController(mapOrGeoModel, ecModel, api);
+
+        this._updateMapSelectHandler(mapOrGeoModel, regionsGroup, api, fromView);
+      };
+
+      MapDraw.prototype.remove = function () {
+        this._regionsGroup.removeAll();
+
+        this._backgroundGroup.removeAll();
+
+        this._controller.dispose();
+
+        this._mapName && geoSourceManager.removeGraphic(this._mapName, this.uid);
+        this._mapName = null;
+        this._controllerHost = null;
+      };
+
+      MapDraw.prototype._updateBackground = function (geo) {
+        var mapName = geo.map;
+
+        if (this._mapName !== mapName) {
+          each(geoSourceManager.makeGraphic(mapName, this.uid), function (root) {
+            this._backgroundGroup.add(root);
+          }, this);
+        }
+
+        this._mapName = mapName;
+      };
+
+      MapDraw.prototype._updateController = function (mapOrGeoModel, ecModel, api) {
+        var geo = mapOrGeoModel.coordinateSystem;
+        var controller = this._controller;
+        var controllerHost = this._controllerHost; // @ts-ignore FIXME:TS
+
+        controllerHost.zoomLimit = mapOrGeoModel.get('scaleLimit');
+        controllerHost.zoom = geo.getZoom(); // roamType is will be set default true if it is null
+        // @ts-ignore FIXME:TS
+
+        controller.enable(mapOrGeoModel.get('roam') || false);
+        var mainType = mapOrGeoModel.mainType;
+
+        function makeActionBase() {
+          var action = {
+            type: 'geoRoam',
+            componentType: mainType
+          };
+          action[mainType + 'Id'] = mapOrGeoModel.id;
+          return action;
+        }
+
+        controller.off('pan').on('pan', function (e) {
+          this._mouseDownFlag = false;
+          updateViewOnPan(controllerHost, e.dx, e.dy);
+          api.dispatchAction(extend(makeActionBase(), {
+            dx: e.dx,
+            dy: e.dy
+          }));
+        }, this);
+        controller.off('zoom').on('zoom', function (e) {
+          this._mouseDownFlag = false;
+          updateViewOnZoom(controllerHost, e.scale, e.originX, e.originY);
+          api.dispatchAction(extend(makeActionBase(), {
+            zoom: e.scale,
+            originX: e.originX,
+            originY: e.originY
+          }));
+          var group = this.group;
+
+          this._regionsGroup.traverse(function (el) {
+            var textContent = el.getTextContent();
+
+            if (textContent) {
+              textContent.scaleX = 1 / group.scaleX;
+              textContent.scaleY = 1 / group.scaleY;
+              textContent.markRedraw();
+            }
+          });
+        }, this);
+        controller.setPointerChecker(function (e, x, y) {
+          return geo.getViewRectAfterRoam().contain(x, y) && !onIrrelevantElement(e, api, mapOrGeoModel);
+        });
+      };
+
+      MapDraw.prototype._updateMapSelectHandler = function (mapOrGeoModel, regionsGroup, api, fromView) {
+        var mapDraw = this;
+        regionsGroup.off('mousedown'); // @ts-ignore FIXME:TS resolve type conflict
+
+        if (mapOrGeoModel.get('selectedMode')) {
+          regionsGroup.on('mousedown', function () {
+            mapDraw._mouseDownFlag = true;
+          });
+          regionsGroup.on('click', function (e) {
+            if (!mapDraw._mouseDownFlag) {
+              return;
+            }
+
+            mapDraw._mouseDownFlag = false;
+          });
+        }
+      };
+
+      return MapDraw;
+    }();
+
+    var MapView =
+    /** @class */
+    function (_super) {
+      __extends(MapView, _super);
+
+      function MapView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MapView.type;
+        return _this;
+      }
+
+      MapView.prototype.render = function (mapModel, ecModel, api, payload) {
+        // Not render if it is an toggleSelect action from self
+        if (payload && payload.type === 'mapToggleSelect' && payload.from === this.uid) {
+          return;
+        }
+
+        var group = this.group;
+        group.removeAll();
+
+        if (mapModel.getHostGeoModel()) {
+          return;
+        } // Not update map if it is an roam action from self
+
+
+        if (!(payload && payload.type === 'geoRoam' && payload.componentType === 'series' && payload.seriesId === mapModel.id)) {
+          if (mapModel.needsDrawMap) {
+            var mapDraw = this._mapDraw || new MapDraw(api);
+            group.add(mapDraw.group);
+            mapDraw.draw(mapModel, ecModel, api, this, payload);
+            this._mapDraw = mapDraw;
+          } else {
+            // Remove drawed map
+            this._mapDraw && this._mapDraw.remove();
+            this._mapDraw = null;
+          }
+        } else {
+          var mapDraw = this._mapDraw;
+          mapDraw && group.add(mapDraw.group);
+        }
+
+        mapModel.get('showLegendSymbol') && ecModel.getComponent('legend') && this._renderSymbols(mapModel, ecModel, api);
+      };
+
+      MapView.prototype.remove = function () {
+        this._mapDraw && this._mapDraw.remove();
+        this._mapDraw = null;
+        this.group.removeAll();
+      };
+
+      MapView.prototype.dispose = function () {
+        this._mapDraw && this._mapDraw.remove();
+        this._mapDraw = null;
+      };
+
+      MapView.prototype._renderSymbols = function (mapModel, ecModel, api) {
+        var originalData = mapModel.originalData;
+        var group = this.group;
+        originalData.each(originalData.mapDimension('value'), function (value, originalDataIndex) {
+          if (isNaN(value)) {
+            return;
+          }
+
+          var layout = originalData.getItemLayout(originalDataIndex);
+
+          if (!layout || !layout.point) {
+            // Not exists in map
+            return;
+          }
+
+          var point = layout.point;
+          var offset = layout.offset;
+          var circle = new Circle({
+            style: {
+              // Because the special of map draw.
+              // Which needs statistic of multiple series and draw on one map.
+              // And each series also need a symbol with legend color
+              //
+              // Layout and visual are put one the different data
+              // TODO
+              fill: mapModel.getData().getVisual('style').fill
+            },
+            shape: {
+              cx: point[0] + offset * 9,
+              cy: point[1],
+              r: 3
+            },
+            silent: true,
+            // Do not overlap the first series, on which labels are displayed.
+            z2: 8 + (!offset ? Z2_EMPHASIS_LIFT + 1 : 0)
+          }); // Only the series that has the first value on the same region is in charge of rendering the label.
+          // But consider the case:
+          // series: [
+          //     {id: 'X', type: 'map', map: 'm', {data: [{name: 'A', value: 11}, {name: 'B', {value: 22}]},
+          //     {id: 'Y', type: 'map', map: 'm', {data: [{name: 'A', value: 21}, {name: 'C', {value: 33}]}
+          // ]
+          // The offset `0` of item `A` is at series `X`, but of item `C` is at series `Y`.
+          // For backward compatibility, we follow the rule that render label `A` by the
+          // settings on series `X` but render label `C` by the settings on series `Y`.
+
+          if (!offset) {
+            var fullData = mapModel.mainSeries.getData();
+            var name_1 = originalData.getName(originalDataIndex);
+            var fullIndex_1 = fullData.indexOfName(name_1);
+            var itemModel = originalData.getItemModel(originalDataIndex);
+            var labelModel = itemModel.getModel('label');
+            var regionGroup = fullData.getItemGraphicEl(fullIndex_1); // `getFormattedLabel` needs to use `getData` inside. Here
+            // `mapModel.getData()` is shallow cloned from `mainSeries.getData()`.
+            // FIXME
+            // If this is not the `mainSeries`, the item model (like label formatter)
+            // set on original data item will never get. But it has been working
+            // like that from the begining, and this scenario is rarely encountered.
+            // So it won't be fixed until have to.
+
+            setLabelStyle(circle, getLabelStatesModels(itemModel), {
+              labelFetcher: {
+                getFormattedLabel: function (idx, state) {
+                  return mapModel.getFormattedLabel(fullIndex_1, state);
+                }
+              }
+            });
+            circle.disableLabelAnimation = true;
+
+            if (!labelModel.get('position')) {
+              circle.setTextConfig({
+                position: 'bottom'
+              });
+            }
+
+            regionGroup.onHoverStateChange = function (toState) {
+              circle.useState(toState);
+            };
+          }
+
+          group.add(circle);
+        });
+      };
+
+      MapView.type = 'map';
+      return MapView;
+    }(ChartView);
+
+    var MapSeries =
+    /** @class */
+    function (_super) {
+      __extends(MapSeries, _super);
+
+      function MapSeries() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MapSeries.type; // Only first map series of same mapType will drawMap.
+
+        _this.needsDrawMap = false; // Group of all map series with same mapType
+
+        _this.seriesGroup = [];
+
+        _this.getTooltipPosition = function (dataIndex) {
+          if (dataIndex != null) {
+            var name_1 = this.getData().getName(dataIndex);
+            var geo = this.coordinateSystem;
+            var region = geo.getRegion(name_1);
+            return region && geo.dataToPoint(region.center);
+          }
+        };
+
+        return _this;
+      }
+
+      MapSeries.prototype.getInitialData = function (option) {
+        var data = createListSimply(this, {
+          coordDimensions: ['value'],
+          encodeDefaulter: curry(makeSeriesEncodeForNameBased, this)
+        });
+        var dataNameMap = createHashMap();
+        var toAppendNames = [];
+
+        for (var i = 0, len = data.count(); i < len; i++) {
+          var name_2 = data.getName(i);
+          dataNameMap.set(name_2, true);
+        }
+
+        var geoSource = geoSourceManager.load(this.getMapType(), this.option.nameMap, this.option.nameProperty);
+        each(geoSource.regions, function (region) {
+          var name = region.name;
+
+          if (!dataNameMap.get(name)) {
+            toAppendNames.push(name);
+          }
+        }); // Complete data with missing regions. The consequent processes (like visual
+        // map and render) can not be performed without a "full data". For example,
+        // find `dataIndex` by name.
+
+        data.appendValues([], toAppendNames);
+        return data;
+      };
+      /**
+       * If no host geo model, return null, which means using a
+       * inner exclusive geo model.
+       */
+
+
+      MapSeries.prototype.getHostGeoModel = function () {
+        var geoIndex = this.option.geoIndex;
+        return geoIndex != null ? this.ecModel.getComponent('geo', geoIndex) : null;
+      };
+
+      MapSeries.prototype.getMapType = function () {
+        return (this.getHostGeoModel() || this).option.map;
+      }; // _fillOption(option, mapName) {
+      // Shallow clone
+      // option = zrUtil.extend({}, option);
+      // option.data = geoCreator.getFilledRegions(option.data, mapName, option.nameMap);
+      // return option;
+      // }
+
+
+      MapSeries.prototype.getRawValue = function (dataIndex) {
+        // Use value stored in data instead because it is calculated from multiple series
+        // FIXME Provide all value of multiple series ?
+        var data = this.getData();
+        return data.get(data.mapDimension('value'), dataIndex);
+      };
+      /**
+       * Get model of region
+       */
+
+
+      MapSeries.prototype.getRegionModel = function (regionName) {
+        var data = this.getData();
+        return data.getItemModel(data.indexOfName(regionName));
+      };
+      /**
+       * Map tooltip formatter
+       */
+
+
+      MapSeries.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        // FIXME orignalData and data is a bit confusing
+        var data = this.getData();
+        var value = this.getRawValue(dataIndex);
+        var name = data.getName(dataIndex);
+        var seriesGroup = this.seriesGroup;
+        var seriesNames = [];
+
+        for (var i = 0; i < seriesGroup.length; i++) {
+          var otherIndex = seriesGroup[i].originalData.indexOfName(name);
+          var valueDim = data.mapDimension('value');
+
+          if (!isNaN(seriesGroup[i].originalData.get(valueDim, otherIndex))) {
+            seriesNames.push(seriesGroup[i].name);
+          }
+        }
+
+        return createTooltipMarkup('section', {
+          header: seriesNames.join(', '),
+          noHeader: !seriesNames.length,
+          blocks: [createTooltipMarkup('nameValue', {
+            name: name,
+            value: value
+          })]
+        });
+      };
+
+      MapSeries.prototype.setZoom = function (zoom) {
+        this.option.zoom = zoom;
+      };
+
+      MapSeries.prototype.setCenter = function (center) {
+        this.option.center = center;
+      };
+
+      MapSeries.type = 'series.map';
+      MapSeries.dependencies = ['geo'];
+      MapSeries.layoutMode = 'box';
+      MapSeries.defaultOption = {
+        // 一级层叠
+        zlevel: 0,
+        // 二级层叠
+        z: 2,
+        coordinateSystem: 'geo',
+        // map should be explicitly specified since ec3.
+        map: '',
+        // If `geoIndex` is not specified, a exclusive geo will be
+        // created. Otherwise use the specified geo component, and
+        // `map` and `mapType` are ignored.
+        // geoIndex: 0,
+        // 'center' | 'left' | 'right' | 'x%' | {number}
+        left: 'center',
+        // 'center' | 'top' | 'bottom' | 'x%' | {number}
+        top: 'center',
+        // right
+        // bottom
+        // width:
+        // height
+        // Aspect is width / height. Inited to be geoJson bbox aspect
+        // This parameter is used for scale this aspect
+        aspectScale: 0.75,
+        ///// Layout with center and size
+        // If you wan't to put map in a fixed size box with right aspect ratio
+        // This two properties may more conveninet
+        // layoutCenter: [50%, 50%]
+        // layoutSize: 100
+        showLegendSymbol: true,
+        // Define left-top, right-bottom coords to control view
+        // For example, [ [180, 90], [-180, -90] ],
+        // higher priority than center and zoom
+        boundingCoords: null,
+        // Default on center of map
+        center: null,
+        zoom: 1,
+        scaleLimit: null,
+        selectedMode: true,
+        label: {
+          show: false,
+          color: '#000'
+        },
+        // scaleLimit: null,
+        itemStyle: {
+          borderWidth: 0.5,
+          borderColor: '#444',
+          areaColor: '#eee'
+        },
+        emphasis: {
+          label: {
+            show: true,
+            color: 'rgb(100,0,0)'
+          },
+          itemStyle: {
+            areaColor: 'rgba(255,215,0,0.8)'
+          }
+        },
+        select: {
+          label: {
+            show: true,
+            color: 'rgb(100,0,0)'
+          },
+          itemStyle: {
+            color: 'rgba(255,215,0,0.8)'
+          }
+        },
+        nameProperty: 'name'
+      };
+      return MapSeries;
+    }(SeriesModel);
+
+    function dataStatistics(datas, statisticType) {
+      var dataNameMap = {};
+      each(datas, function (data) {
+        data.each(data.mapDimension('value'), function (value, idx) {
+          // Add prefix to avoid conflict with Object.prototype.
+          var mapKey = 'ec-' + data.getName(idx);
+          dataNameMap[mapKey] = dataNameMap[mapKey] || [];
+
+          if (!isNaN(value)) {
+            dataNameMap[mapKey].push(value);
+          }
+        });
+      });
+      return datas[0].map(datas[0].mapDimension('value'), function (value, idx) {
+        var mapKey = 'ec-' + datas[0].getName(idx);
+        var sum = 0;
+        var min = Infinity;
+        var max = -Infinity;
+        var len = dataNameMap[mapKey].length;
+
+        for (var i = 0; i < len; i++) {
+          min = Math.min(min, dataNameMap[mapKey][i]);
+          max = Math.max(max, dataNameMap[mapKey][i]);
+          sum += dataNameMap[mapKey][i];
+        }
+
+        var result;
+
+        if (statisticType === 'min') {
+          result = min;
+        } else if (statisticType === 'max') {
+          result = max;
+        } else if (statisticType === 'average') {
+          result = sum / len;
+        } else {
+          result = sum;
+        }
+
+        return len === 0 ? NaN : result;
+      });
+    }
+
+    function mapDataStatistic(ecModel) {
+      var seriesGroups = {};
+      ecModel.eachSeriesByType('map', function (seriesModel) {
+        var hostGeoModel = seriesModel.getHostGeoModel();
+        var key = hostGeoModel ? 'o' + hostGeoModel.id : 'i' + seriesModel.getMapType();
+        (seriesGroups[key] = seriesGroups[key] || []).push(seriesModel);
+      });
+      each(seriesGroups, function (seriesList, key) {
+        var data = dataStatistics(map(seriesList, function (seriesModel) {
+          return seriesModel.getData();
+        }), seriesList[0].get('mapValueCalculation'));
+
+        for (var i = 0; i < seriesList.length; i++) {
+          seriesList[i].originalData = seriesList[i].getData();
+        } // FIXME Put where?
+
+
+        for (var i = 0; i < seriesList.length; i++) {
+          seriesList[i].seriesGroup = seriesList;
+          seriesList[i].needsDrawMap = i === 0 && !seriesList[i].getHostGeoModel();
+          seriesList[i].setData(data.cloneShallow());
+          seriesList[i].mainSeries = seriesList[0];
+        }
+      });
+    }
+
+    function mapSymbolLayout(ecModel) {
+      var processedMapType = {};
+      ecModel.eachSeriesByType('map', function (mapSeries) {
+        var mapType = mapSeries.getMapType();
+
+        if (mapSeries.getHostGeoModel() || processedMapType[mapType]) {
+          return;
+        }
+
+        var mapSymbolOffsets = {};
+        each(mapSeries.seriesGroup, function (subMapSeries) {
+          var geo = subMapSeries.coordinateSystem;
+          var data = subMapSeries.originalData;
+
+          if (subMapSeries.get('showLegendSymbol') && ecModel.getComponent('legend')) {
+            data.each(data.mapDimension('value'), function (value, idx) {
+              var name = data.getName(idx);
+              var region = geo.getRegion(name); // If input series.data is [11, 22, '-'/null/undefined, 44],
+              // it will be filled with NaN: [11, 22, NaN, 44] and NaN will
+              // not be drawn. So here must validate if value is NaN.
+
+              if (!region || isNaN(value)) {
+                return;
+              }
+
+              var offset = mapSymbolOffsets[name] || 0;
+              var point = geo.dataToPoint(region.center);
+              mapSymbolOffsets[name] = offset + 1;
+              data.setItemLayout(idx, {
+                point: point,
+                offset: offset
+              });
+            });
+          }
+        }); // Show label of those region not has legendSymbol(which is offset 0)
+
+        var data = mapSeries.getData();
+        data.each(function (idx) {
+          var name = data.getName(idx);
+          var layout = data.getItemLayout(idx) || {};
+          layout.showLabel = !mapSymbolOffsets[name];
+          data.setItemLayout(idx, layout);
+        });
+        processedMapType[mapType] = true;
+      });
+    }
+
+    var v2ApplyTransform = applyTransform;
+
+    var View =
+    /** @class */
+    function (_super) {
+      __extends(View, _super);
+
+      function View(name) {
+        var _this = _super.call(this) || this;
+
+        _this.type = 'view';
+        _this.dimensions = ['x', 'y'];
+        _this._roamTransformable = new Transformable();
+        _this._rawTransformable = new Transformable();
+        _this.name = name;
+        return _this;
+      } // PENDING to getRect
+
+
+      View.prototype.setBoundingRect = function (x, y, width, height) {
+        this._rect = new BoundingRect(x, y, width, height);
+        return this._rect;
+      };
+      /**
+       * @return {module:zrender/core/BoundingRect}
+       */
+      // PENDING to getRect
+
+
+      View.prototype.getBoundingRect = function () {
+        return this._rect;
+      };
+
+      View.prototype.setViewRect = function (x, y, width, height) {
+        this.transformTo(x, y, width, height);
+        this._viewRect = new BoundingRect(x, y, width, height);
+      };
+      /**
+       * Transformed to particular position and size
+       */
+
+
+      View.prototype.transformTo = function (x, y, width, height) {
+        var rect = this.getBoundingRect();
+        var rawTransform = this._rawTransformable;
+        rawTransform.transform = rect.calculateTransform(new BoundingRect(x, y, width, height));
+        rawTransform.decomposeTransform();
+
+        this._updateTransform();
+      };
+      /**
+       * Set center of view
+       */
+
+
+      View.prototype.setCenter = function (centerCoord) {
+        if (!centerCoord) {
+          return;
+        }
+
+        this._center = centerCoord;
+
+        this._updateCenterAndZoom();
+      };
+
+      View.prototype.setZoom = function (zoom) {
+        zoom = zoom || 1;
+        var zoomLimit = this.zoomLimit;
+
+        if (zoomLimit) {
+          if (zoomLimit.max != null) {
+            zoom = Math.min(zoomLimit.max, zoom);
+          }
+
+          if (zoomLimit.min != null) {
+            zoom = Math.max(zoomLimit.min, zoom);
+          }
+        }
+
+        this._zoom = zoom;
+
+        this._updateCenterAndZoom();
+      };
+      /**
+       * Get default center without roam
+       */
+
+
+      View.prototype.getDefaultCenter = function () {
+        // Rect before any transform
+        var rawRect = this.getBoundingRect();
+        var cx = rawRect.x + rawRect.width / 2;
+        var cy = rawRect.y + rawRect.height / 2;
+        return [cx, cy];
+      };
+
+      View.prototype.getCenter = function () {
+        return this._center || this.getDefaultCenter();
+      };
+
+      View.prototype.getZoom = function () {
+        return this._zoom || 1;
+      };
+
+      View.prototype.getRoamTransform = function () {
+        return this._roamTransformable.getLocalTransform();
+      };
+      /**
+       * Remove roam
+       */
+
+
+      View.prototype._updateCenterAndZoom = function () {
+        // Must update after view transform updated
+        var rawTransformMatrix = this._rawTransformable.getLocalTransform();
+
+        var roamTransform = this._roamTransformable;
+        var defaultCenter = this.getDefaultCenter();
+        var center = this.getCenter();
+        var zoom = this.getZoom();
+        center = applyTransform([], center, rawTransformMatrix);
+        defaultCenter = applyTransform([], defaultCenter, rawTransformMatrix);
+        roamTransform.originX = center[0];
+        roamTransform.originY = center[1];
+        roamTransform.x = defaultCenter[0] - center[0];
+        roamTransform.y = defaultCenter[1] - center[1];
+        roamTransform.scaleX = roamTransform.scaleY = zoom;
+
+        this._updateTransform();
+      };
+      /**
+       * Update transform from roam and mapLocation
+       */
+
+
+      View.prototype._updateTransform = function () {
+        var roamTransformable = this._roamTransformable;
+        var rawTransformable = this._rawTransformable;
+        rawTransformable.parent = roamTransformable;
+        roamTransformable.updateTransform();
+        rawTransformable.updateTransform();
+        copy$1(this.transform || (this.transform = []), rawTransformable.transform || create$1());
+        this._rawTransform = rawTransformable.getLocalTransform();
+        this.invTransform = this.invTransform || [];
+        invert(this.invTransform, this.transform);
+        this.decomposeTransform();
+      };
+
+      View.prototype.getTransformInfo = function () {
+        var roamTransform = this._roamTransformable.transform;
+        var rawTransformable = this._rawTransformable;
+        return {
+          roamTransform: roamTransform ? slice(roamTransform) : create$1(),
+          rawScaleX: rawTransformable.scaleX,
+          rawScaleY: rawTransformable.scaleY,
+          rawX: rawTransformable.x,
+          rawY: rawTransformable.y
+        };
+      };
+
+      View.prototype.getViewRect = function () {
+        return this._viewRect;
+      };
+      /**
+       * Get view rect after roam transform
+       */
+
+
+      View.prototype.getViewRectAfterRoam = function () {
+        var rect = this.getBoundingRect().clone();
+        rect.applyTransform(this.transform);
+        return rect;
+      };
+      /**
+       * Convert a single (lon, lat) data item to (x, y) point.
+       */
+
+
+      View.prototype.dataToPoint = function (data, noRoam, out) {
+        var transform = noRoam ? this._rawTransform : this.transform;
+        out = out || [];
+        return transform ? v2ApplyTransform(out, data, transform) : copy(out, data);
+      };
+      /**
+       * Convert a (x, y) point to (lon, lat) data
+       */
+
+
+      View.prototype.pointToData = function (point) {
+        var invTransform = this.invTransform;
+        return invTransform ? v2ApplyTransform([], point, invTransform) : [point[0], point[1]];
+      };
+
+      View.prototype.convertToPixel = function (ecModel, finder, value) {
+        var coordSys = getCoordSys(finder);
+        return coordSys === this ? coordSys.dataToPoint(value) : null;
+      };
+
+      View.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        var coordSys = getCoordSys(finder);
+        return coordSys === this ? coordSys.pointToData(pixel) : null;
+      };
+      /**
+       * @implements
+       */
+
+
+      View.prototype.containPoint = function (point) {
+        return this.getViewRectAfterRoam().contain(point[0], point[1]);
+      };
+
+      View.dimensions = ['x', 'y'];
+      return View;
+    }(Transformable);
+
+    function getCoordSys(finder) {
+      var seriesModel = finder.seriesModel;
+      return seriesModel ? seriesModel.coordinateSystem : null; // e.g., graph.
+    }
+
+    var Geo =
+    /** @class */
+    function (_super) {
+      __extends(Geo, _super);
+      /**
+       * For backward compatibility, the orginal interface:
+       * `name, map, geoJson, specialAreas, nameMap` is kept.
+       *
+       * @param map Map type Specify the positioned areas by left, top, width, height.
+       * @param [nameMap] Specify name alias
+       */
+
+
+      function Geo(name, map, nameMap, invertLongitute) {
+        var _this = _super.call(this, name) || this;
+
+        _this.dimensions = ['lng', 'lat'];
+        _this.type = 'geo';
+        _this.map = map;
+        var source = geoSourceManager.load(map, nameMap);
+        _this._nameCoordMap = source.nameCoordMap;
+        _this._regionsMap = source.regionsMap;
+        _this._invertLongitute = invertLongitute == null ? true : invertLongitute;
+        _this.regions = source.regions;
+        _this._rect = source.boundingRect;
+        return _this;
+      }
+      /**
+       * Whether contain the given [lng, lat] coord.
+       */
+
+
+      Geo.prototype.containCoord = function (coord) {
+        var regions = this.regions;
+
+        for (var i = 0; i < regions.length; i++) {
+          if (regions[i].contain(coord)) {
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      Geo.prototype.transformTo = function (x, y, width, height) {
+        var rect = this.getBoundingRect();
+        var invertLongitute = this._invertLongitute;
+        rect = rect.clone();
+
+        if (invertLongitute) {
+          // Longitute is inverted
+          rect.y = -rect.y - rect.height;
+        }
+
+        var rawTransformable = this._rawTransformable;
+        rawTransformable.transform = rect.calculateTransform(new BoundingRect(x, y, width, height));
+        rawTransformable.decomposeTransform();
+
+        if (invertLongitute) {
+          rawTransformable.scaleY = -rawTransformable.scaleY;
+        }
+
+        rawTransformable.updateTransform();
+
+        this._updateTransform();
+      };
+
+      Geo.prototype.getRegion = function (name) {
+        return this._regionsMap.get(name);
+      };
+
+      Geo.prototype.getRegionByCoord = function (coord) {
+        var regions = this.regions;
+
+        for (var i = 0; i < regions.length; i++) {
+          if (regions[i].contain(coord)) {
+            return regions[i];
+          }
+        }
+      };
+      /**
+       * Add geoCoord for indexing by name
+       */
+
+
+      Geo.prototype.addGeoCoord = function (name, geoCoord) {
+        this._nameCoordMap.set(name, geoCoord);
+      };
+      /**
+       * Get geoCoord by name
+       */
+
+
+      Geo.prototype.getGeoCoord = function (name) {
+        return this._nameCoordMap.get(name);
+      };
+
+      Geo.prototype.getBoundingRect = function () {
+        return this._rect;
+      };
+
+      Geo.prototype.dataToPoint = function (data, noRoam, out) {
+        if (typeof data === 'string') {
+          // Map area name to geoCoord
+          data = this.getGeoCoord(data);
+        }
+
+        if (data) {
+          return View.prototype.dataToPoint.call(this, data, noRoam, out);
+        }
+      };
+
+      Geo.prototype.convertToPixel = function (ecModel, finder, value) {
+        var coordSys = getCoordSys$1(finder);
+        return coordSys === this ? coordSys.dataToPoint(value) : null;
+      };
+
+      Geo.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        var coordSys = getCoordSys$1(finder);
+        return coordSys === this ? coordSys.pointToData(pixel) : null;
+      };
+
+      return Geo;
+    }(View);
+    mixin(Geo, View);
+
+    function getCoordSys$1(finder) {
+      var geoModel = finder.geoModel;
+      var seriesModel = finder.seriesModel;
+      return geoModel ? geoModel.coordinateSystem : seriesModel ? seriesModel.coordinateSystem // For map series.
+      || (seriesModel.getReferringComponents('geo', SINGLE_REFERRING).models[0] || {}).coordinateSystem : null;
+    }
+
+    /**
+     * Resize method bound to the geo
+     */
+
+    function resizeGeo(geoModel, api) {
+      var boundingCoords = geoModel.get('boundingCoords');
+
+      if (boundingCoords != null) {
+        var leftTop = boundingCoords[0];
+        var rightBottom = boundingCoords[1];
+
+        if (isNaN(leftTop[0]) || isNaN(leftTop[1]) || isNaN(rightBottom[0]) || isNaN(rightBottom[1])) {
+          if ("development" !== 'production') {
+            console.error('Invalid boundingCoords');
+          }
+        } else {
+          this.setBoundingRect(leftTop[0], leftTop[1], rightBottom[0] - leftTop[0], rightBottom[1] - leftTop[1]);
+        }
+      }
+
+      var rect = this.getBoundingRect();
+      var centerOption = geoModel.get('layoutCenter');
+      var sizeOption = geoModel.get('layoutSize');
+      var viewWidth = api.getWidth();
+      var viewHeight = api.getHeight();
+      var aspect = rect.width / rect.height * this.aspectScale;
+      var useCenterAndSize = false;
+      var center;
+      var size;
+
+      if (centerOption && sizeOption) {
+        center = [parsePercent$1(centerOption[0], viewWidth), parsePercent$1(centerOption[1], viewHeight)];
+        size = parsePercent$1(sizeOption, Math.min(viewWidth, viewHeight));
+
+        if (!isNaN(center[0]) && !isNaN(center[1]) && !isNaN(size)) {
+          useCenterAndSize = true;
+        } else {
+          if ("development" !== 'production') {
+            console.warn('Given layoutCenter or layoutSize data are invalid. Use left/top/width/height instead.');
+          }
+        }
+      }
+
+      var viewRect;
+
+      if (useCenterAndSize) {
+        viewRect = {};
+
+        if (aspect > 1) {
+          // Width is same with size
+          viewRect.width = size;
+          viewRect.height = size / aspect;
+        } else {
+          viewRect.height = size;
+          viewRect.width = size * aspect;
+        }
+
+        viewRect.y = center[1] - viewRect.height / 2;
+        viewRect.x = center[0] - viewRect.width / 2;
+      } else {
+        // Use left/top/width/height
+        var boxLayoutOption = geoModel.getBoxLayoutParams(); // 0.75 rate
+
+        boxLayoutOption.aspect = aspect;
+        viewRect = getLayoutRect(boxLayoutOption, {
+          width: viewWidth,
+          height: viewHeight
+        });
+      }
+
+      this.setViewRect(viewRect.x, viewRect.y, viewRect.width, viewRect.height);
+      this.setCenter(geoModel.get('center'));
+      this.setZoom(geoModel.get('zoom'));
+    } // Back compat for ECharts2, where the coord map is set on map series:
+    // {type: 'map', geoCoord: {'cityA': [116.46,39.92], 'cityA': [119.12,24.61]}},
+
+
+    function setGeoCoords(geo, model) {
+      each(model.get('geoCoord'), function (geoCoord, name) {
+        geo.addGeoCoord(name, geoCoord);
+      });
+    }
+
+    var GeoCreator =
+    /** @class */
+    function () {
+      function GeoCreator() {
+        // For deciding which dimensions to use when creating list data
+        this.dimensions = Geo.prototype.dimensions;
+      }
+
+      GeoCreator.prototype.create = function (ecModel, api) {
+        var geoList = []; // FIXME Create each time may be slow
+
+        ecModel.eachComponent('geo', function (geoModel, idx) {
+          var name = geoModel.get('map');
+          var aspectScale = geoModel.get('aspectScale');
+          var invertLongitute = true;
+          var mapRecords = mapDataStorage.retrieveMap(name);
+
+          if (mapRecords && mapRecords[0] && mapRecords[0].type === 'svg') {
+            aspectScale == null && (aspectScale = 1);
+            invertLongitute = false;
+          } else {
+            aspectScale == null && (aspectScale = 0.75);
+          }
+
+          var geo = new Geo(name + idx, name, geoModel.get('nameMap'), invertLongitute);
+          geo.aspectScale = aspectScale;
+          geo.zoomLimit = geoModel.get('scaleLimit');
+          geoList.push(geo); // setGeoCoords(geo, geoModel);
+
+          geoModel.coordinateSystem = geo;
+          geo.model = geoModel; // Inject resize method
+
+          geo.resize = resizeGeo;
+          geo.resize(geoModel, api);
+        });
+        ecModel.eachSeries(function (seriesModel) {
+          var coordSys = seriesModel.get('coordinateSystem');
+
+          if (coordSys === 'geo') {
+            var geoIndex = seriesModel.get('geoIndex') || 0;
+            seriesModel.coordinateSystem = geoList[geoIndex];
+          }
+        }); // If has map series
+
+        var mapModelGroupBySeries = {};
+        ecModel.eachSeriesByType('map', function (seriesModel) {
+          if (!seriesModel.getHostGeoModel()) {
+            var mapType = seriesModel.getMapType();
+            mapModelGroupBySeries[mapType] = mapModelGroupBySeries[mapType] || [];
+            mapModelGroupBySeries[mapType].push(seriesModel);
+          }
+        });
+        each(mapModelGroupBySeries, function (mapSeries, mapType) {
+          var nameMapList = map(mapSeries, function (singleMapSeries) {
+            return singleMapSeries.get('nameMap');
+          });
+          var geo = new Geo(mapType, mapType, mergeAll(nameMapList));
+          geo.zoomLimit = retrieve.apply(null, map(mapSeries, function (singleMapSeries) {
+            return singleMapSeries.get('scaleLimit');
+          }));
+          geoList.push(geo); // Inject resize method
+
+          geo.resize = resizeGeo;
+          geo.aspectScale = mapSeries[0].get('aspectScale');
+          geo.resize(mapSeries[0], api);
+          each(mapSeries, function (singleMapSeries) {
+            singleMapSeries.coordinateSystem = geo;
+            setGeoCoords(geo, singleMapSeries);
+          });
+        });
+        return geoList;
+      };
+      /**
+       * Fill given regions array
+       */
+
+
+      GeoCreator.prototype.getFilledRegions = function (originRegionArr, mapName, nameMap) {
+        // Not use the original
+        var regionsArr = (originRegionArr || []).slice();
+        var dataNameMap = createHashMap();
+
+        for (var i = 0; i < regionsArr.length; i++) {
+          dataNameMap.set(regionsArr[i].name, regionsArr[i]);
+        }
+
+        var source = geoSourceManager.load(mapName, nameMap);
+        each(source.regions, function (region) {
+          var name = region.name;
+          !dataNameMap.get(name) && regionsArr.push({
+            name: name
+          });
+        });
+        return regionsArr;
+      };
+
+      return GeoCreator;
+    }();
+
+    var geoCreator = new GeoCreator();
+
+    var GeoModel =
+    /** @class */
+    function (_super) {
+      __extends(GeoModel, _super);
+
+      function GeoModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GeoModel.type;
+        return _this;
+      }
+
+      GeoModel.prototype.init = function (option, parentModel, ecModel) {
+        _super.prototype.init.call(this, option, parentModel, ecModel); // Default label emphasis `show`
+
+
+        defaultEmphasis(option, 'label', ['show']);
+      };
+
+      GeoModel.prototype.optionUpdated = function () {
+        var option = this.option;
+        var self = this;
+        option.regions = geoCreator.getFilledRegions(option.regions, option.map, option.nameMap);
+        var selectedMap = {};
+        this._optionModelMap = reduce(option.regions || [], function (optionModelMap, regionOpt) {
+          var regionName = regionOpt.name;
+
+          if (regionName) {
+            optionModelMap.set(regionName, new Model(regionOpt, self));
+
+            if (regionOpt.selected) {
+              selectedMap[regionName] = true;
+            }
+          }
+
+          return optionModelMap;
+        }, createHashMap());
+
+        if (!option.selectedMap) {
+          option.selectedMap = selectedMap;
+        }
+      };
+      /**
+       * Get model of region.
+       */
+
+
+      GeoModel.prototype.getRegionModel = function (name) {
+        return this._optionModelMap.get(name) || new Model(null, this, this.ecModel);
+      };
+      /**
+       * Format label
+       * @param name Region name
+       */
+
+
+      GeoModel.prototype.getFormattedLabel = function (name, status) {
+        var regionModel = this.getRegionModel(name);
+        var formatter = status === 'normal' ? regionModel.get(['label', 'formatter']) : regionModel.get(['emphasis', 'label', 'formatter']);
+        var params = {
+          name: name
+        };
+
+        if (typeof formatter === 'function') {
+          params.status = status;
+          return formatter(params);
+        } else if (typeof formatter === 'string') {
+          return formatter.replace('{a}', name != null ? name : '');
+        }
+      };
+
+      GeoModel.prototype.setZoom = function (zoom) {
+        this.option.zoom = zoom;
+      };
+
+      GeoModel.prototype.setCenter = function (center) {
+        this.option.center = center;
+      }; // PENGING If selectedMode is null ?
+
+
+      GeoModel.prototype.select = function (name) {
+        var option = this.option;
+        var selectedMode = option.selectedMode;
+
+        if (!selectedMode) {
+          return;
+        }
+
+        if (selectedMode !== 'multiple') {
+          option.selectedMap = null;
+        }
+
+        var selectedMap = option.selectedMap || (option.selectedMap = {});
+        selectedMap[name] = true;
+      };
+
+      GeoModel.prototype.unSelect = function (name) {
+        var selectedMap = this.option.selectedMap;
+
+        if (selectedMap) {
+          selectedMap[name] = false;
+        }
+      };
+
+      GeoModel.prototype.toggleSelected = function (name) {
+        this[this.isSelected(name) ? 'unSelect' : 'select'](name);
+      };
+
+      GeoModel.prototype.isSelected = function (name) {
+        var selectedMap = this.option.selectedMap;
+        return !!(selectedMap && selectedMap[name]);
+      };
+
+      GeoModel.prototype._initSelectedMapFromData = function () {};
+
+      GeoModel.type = 'geo';
+      GeoModel.layoutMode = 'box';
+      GeoModel.defaultOption = {
+        zlevel: 0,
+        z: 0,
+        show: true,
+        left: 'center',
+        top: 'center',
+        // If svg used, aspectScale is 1 by default.
+        // aspectScale: 0.75,
+        aspectScale: null,
+        ///// Layout with center and size
+        // If you wan't to put map in a fixed size box with right aspect ratio
+        // This two properties may more conveninet
+        // layoutCenter: [50%, 50%]
+        // layoutSize: 100
+        silent: false,
+        // Map type
+        map: '',
+        // Define left-top, right-bottom coords to control view
+        // For example, [ [180, 90], [-180, -90] ]
+        boundingCoords: null,
+        // Default on center of map
+        center: null,
+        zoom: 1,
+        scaleLimit: null,
+        // selectedMode: false
+        label: {
+          show: false,
+          color: '#000'
+        },
+        itemStyle: {
+          // color: 各异,
+          borderWidth: 0.5,
+          borderColor: '#444',
+          color: '#eee'
+        },
+        emphasis: {
+          label: {
+            show: true,
+            color: 'rgb(100,0,0)'
+          },
+          itemStyle: {
+            color: 'rgba(255,215,0,0.8)'
+          }
+        },
+        select: {
+          label: {
+            show: true,
+            color: 'rgb(100,0,0)'
+          },
+          itemStyle: {
+            color: 'rgba(255,215,0,0.8)'
+          }
+        },
+        regions: []
+      };
+      return GeoModel;
+    }(ComponentModel);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function updateCenterAndZoom(view, payload, zoomLimit) {
+      var previousZoom = view.getZoom();
+      var center = view.getCenter();
+      var zoom = payload.zoom;
+      var point = view.dataToPoint(center);
+
+      if (payload.dx != null && payload.dy != null) {
+        point[0] -= payload.dx;
+        point[1] -= payload.dy;
+        view.setCenter(view.pointToData(point));
+      }
+
+      if (zoom != null) {
+        if (zoomLimit) {
+          var zoomMin = zoomLimit.min || 0;
+          var zoomMax = zoomLimit.max || Infinity;
+          zoom = Math.max(Math.min(previousZoom * zoom, zoomMax), zoomMin) / previousZoom;
+        } // Zoom on given point(originX, originY)
+
+
+        view.scaleX *= zoom;
+        view.scaleY *= zoom;
+        var fixX = (payload.originX - view.x) * (zoom - 1);
+        var fixY = (payload.originY - view.y) * (zoom - 1);
+        view.x -= fixX;
+        view.y -= fixY;
+        view.updateTransform(); // Get the new center
+
+        view.setCenter(view.pointToData(point));
+        view.setZoom(zoom * previousZoom);
+      }
+
+      return {
+        center: view.getCenter(),
+        zoom: view.getZoom()
+      };
+    }
+
+    var GeoView =
+    /** @class */
+    function (_super) {
+      __extends(GeoView, _super);
+
+      function GeoView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GeoView.type;
+        return _this;
+      }
+
+      GeoView.prototype.init = function (ecModel, api) {
+        var mapDraw = new MapDraw(api);
+        this._mapDraw = mapDraw;
+        this.group.add(mapDraw.group);
+        this._api = api;
+      };
+
+      GeoView.prototype.render = function (geoModel, ecModel, api, payload) {
+        var mapDraw = this._mapDraw;
+
+        if (geoModel.get('show')) {
+          mapDraw.draw(geoModel, ecModel, api, this, payload);
+        } else {
+          this._mapDraw.group.removeAll();
+        }
+
+        mapDraw.group.on('click', this._handleRegionClick, this);
+        mapDraw.group.silent = geoModel.get('silent');
+        this._model = geoModel;
+        this.updateSelectStatus(geoModel, ecModel, api);
+      };
+
+      GeoView.prototype._handleRegionClick = function (e) {
+        var current = e.target;
+        var eventData; // TODO extract a util function
+
+        while (current && (eventData = getECData(current).eventData) == null) {
+          current = current.__hostTarget || current.parent;
+        }
+
+        if (eventData) {
+          this._api.dispatchAction({
+            type: 'geoToggleSelect',
+            geoId: this._model.id,
+            name: eventData.name
+          });
+        }
+      };
+
+      GeoView.prototype.updateSelectStatus = function (model, ecModel, api) {
+        var _this = this;
+
+        this._mapDraw.group.traverse(function (node) {
+          var eventData = getECData(node).eventData;
+
+          if (eventData) {
+            _this._model.isSelected(eventData.name) ? api.enterSelect(node) : api.leaveSelect(node); // No need to traverse children.
+
+            return true;
+          }
+        });
+      };
+
+      GeoView.prototype.dispose = function () {
+        this._mapDraw && this._mapDraw.remove();
+      };
+
+      GeoView.type = 'geo';
+      return GeoView;
+    }(ComponentView);
+
+    function install$9(registers) {
+      registers.registerCoordinateSystem('geo', geoCreator);
+      registers.registerComponentModel(GeoModel);
+      registers.registerComponentView(GeoView);
+
+      function makeAction(method, actionInfo) {
+        actionInfo.update = 'geo:updateSelectStatus';
+        registers.registerAction(actionInfo, function (payload, ecModel) {
+          var selected = {};
+          ecModel.eachComponent({
+            mainType: 'geo',
+            query: payload
+          }, function (geoModel) {
+            geoModel[method](payload.name);
+            var geo = geoModel.coordinateSystem;
+            each(geo.regions, function (region) {
+              selected[region.name] = geoModel.isSelected(region.name) || false;
+            });
+          });
+          return {
+            selected: selected,
+            name: payload.name
+          };
+        });
+      }
+
+      makeAction('toggleSelected', {
+        type: 'geoToggleSelect',
+        event: 'geoselectchanged'
+      });
+      makeAction('select', {
+        type: 'geoSelect',
+        event: 'geoselected'
+      });
+      makeAction('unSelect', {
+        type: 'geoUnSelect',
+        event: 'geounselected'
+      });
+      /**
+       * @payload
+       * @property {string} [componentType=series]
+       * @property {number} [dx]
+       * @property {number} [dy]
+       * @property {number} [zoom]
+       * @property {number} [originX]
+       * @property {number} [originY]
+       */
+
+      registers.registerAction({
+        type: 'geoRoam',
+        event: 'geoRoam',
+        update: 'updateTransform'
+      }, function (payload, ecModel) {
+        var componentType = payload.componentType || 'series';
+        ecModel.eachComponent({
+          mainType: componentType,
+          query: payload
+        }, function (componentModel) {
+          var geo = componentModel.coordinateSystem;
+
+          if (geo.type !== 'geo') {
+            return;
+          }
+
+          var res = updateCenterAndZoom(geo, payload, componentModel.get('scaleLimit'));
+          componentModel.setCenter && componentModel.setCenter(res.center);
+          componentModel.setZoom && componentModel.setZoom(res.zoom); // All map series with same `map` use the same geo coordinate system
+          // So the center and zoom must be in sync. Include the series not selected by legend
+
+          if (componentType === 'series') {
+            each(componentModel.seriesGroup, function (seriesModel) {
+              seriesModel.setCenter(res.center);
+              seriesModel.setZoom(res.zoom);
+            });
+          }
+        });
+      });
+    }
+
+    function install$a(registers) {
+      use(install$9);
+      registers.registerChartView(MapView);
+      registers.registerSeriesModel(MapSeries);
+      registers.registerLayout(mapSymbolLayout);
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, mapDataStatistic);
+      createLegacyDataSelectAction('map', registers.registerAction);
+    }
+
+    /**
+     * Initialize all computational message for following algorithm.
+     */
+
+    function init$2(inRoot) {
+      var root = inRoot;
+      root.hierNode = {
+        defaultAncestor: null,
+        ancestor: root,
+        prelim: 0,
+        modifier: 0,
+        change: 0,
+        shift: 0,
+        i: 0,
+        thread: null
+      };
+      var nodes = [root];
+      var node;
+      var children;
+
+      while (node = nodes.pop()) {
+        // jshint ignore:line
+        children = node.children;
+
+        if (node.isExpand && children.length) {
+          var n = children.length;
+
+          for (var i = n - 1; i >= 0; i--) {
+            var child = children[i];
+            child.hierNode = {
+              defaultAncestor: null,
+              ancestor: child,
+              prelim: 0,
+              modifier: 0,
+              change: 0,
+              shift: 0,
+              i: i,
+              thread: null
+            };
+            nodes.push(child);
+          }
+        }
+      }
+    }
+    /**
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     *
+     * Computes a preliminary x coordinate for node. Before that, this function is
+     * applied recursively to the children of node, as well as the function
+     * apportion(). After spacing out the children by calling executeShifts(), the
+     * node is placed to the midpoint of its outermost children.
+     */
+
+    function firstWalk(node, separation) {
+      var children = node.isExpand ? node.children : [];
+      var siblings = node.parentNode.children;
+      var subtreeW = node.hierNode.i ? siblings[node.hierNode.i - 1] : null;
+
+      if (children.length) {
+        executeShifts(node);
+        var midPoint = (children[0].hierNode.prelim + children[children.length - 1].hierNode.prelim) / 2;
+
+        if (subtreeW) {
+          node.hierNode.prelim = subtreeW.hierNode.prelim + separation(node, subtreeW);
+          node.hierNode.modifier = node.hierNode.prelim - midPoint;
+        } else {
+          node.hierNode.prelim = midPoint;
+        }
+      } else if (subtreeW) {
+        node.hierNode.prelim = subtreeW.hierNode.prelim + separation(node, subtreeW);
+      }
+
+      node.parentNode.hierNode.defaultAncestor = apportion(node, subtreeW, node.parentNode.hierNode.defaultAncestor || siblings[0], separation);
+    }
+    /**
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     *
+     * Computes all real x-coordinates by summing up the modifiers recursively.
+     */
+
+    function secondWalk(node) {
+      var nodeX = node.hierNode.prelim + node.parentNode.hierNode.modifier;
+      node.setLayout({
+        x: nodeX
+      }, true);
+      node.hierNode.modifier += node.parentNode.hierNode.modifier;
+    }
+    function separation(cb) {
+      return arguments.length ? cb : defaultSeparation;
+    }
+    /**
+     * Transform the common coordinate to radial coordinate.
+     */
+
+    function radialCoordinate(rad, r) {
+      rad -= Math.PI / 2;
+      return {
+        x: r * Math.cos(rad),
+        y: r * Math.sin(rad)
+      };
+    }
+    /**
+     * Get the layout position of the whole view.
+     */
+
+    function getViewRect$1(seriesModel, api) {
+      return getLayoutRect(seriesModel.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+    }
+    /**
+     * All other shifts, applied to the smaller subtrees between w- and w+, are
+     * performed by this function.
+     *
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     */
+
+    function executeShifts(node) {
+      var children = node.children;
+      var n = children.length;
+      var shift = 0;
+      var change = 0;
+
+      while (--n >= 0) {
+        var child = children[n];
+        child.hierNode.prelim += shift;
+        child.hierNode.modifier += shift;
+        change += child.hierNode.change;
+        shift += child.hierNode.shift + change;
+      }
+    }
+    /**
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     *
+     * The core of the algorithm. Here, a new subtree is combined with the
+     * previous subtrees. Threads are used to traverse the inside and outside
+     * contours of the left and right subtree up to the highest common level.
+     * Whenever two nodes of the inside contours conflict, we compute the left
+     * one of the greatest uncommon ancestors using the function nextAncestor()
+     * and call moveSubtree() to shift the subtree and prepare the shifts of
+     * smaller subtrees. Finally, we add a new thread (if necessary).
+     */
+
+
+    function apportion(subtreeV, subtreeW, ancestor, separation) {
+      if (subtreeW) {
+        var nodeOutRight = subtreeV;
+        var nodeInRight = subtreeV;
+        var nodeOutLeft = nodeInRight.parentNode.children[0];
+        var nodeInLeft = subtreeW;
+        var sumOutRight = nodeOutRight.hierNode.modifier;
+        var sumInRight = nodeInRight.hierNode.modifier;
+        var sumOutLeft = nodeOutLeft.hierNode.modifier;
+        var sumInLeft = nodeInLeft.hierNode.modifier;
+
+        while (nodeInLeft = nextRight(nodeInLeft), nodeInRight = nextLeft(nodeInRight), nodeInLeft && nodeInRight) {
+          nodeOutRight = nextRight(nodeOutRight);
+          nodeOutLeft = nextLeft(nodeOutLeft);
+          nodeOutRight.hierNode.ancestor = subtreeV;
+          var shift = nodeInLeft.hierNode.prelim + sumInLeft - nodeInRight.hierNode.prelim - sumInRight + separation(nodeInLeft, nodeInRight);
+
+          if (shift > 0) {
+            moveSubtree(nextAncestor(nodeInLeft, subtreeV, ancestor), subtreeV, shift);
+            sumInRight += shift;
+            sumOutRight += shift;
+          }
+
+          sumInLeft += nodeInLeft.hierNode.modifier;
+          sumInRight += nodeInRight.hierNode.modifier;
+          sumOutRight += nodeOutRight.hierNode.modifier;
+          sumOutLeft += nodeOutLeft.hierNode.modifier;
+        }
+
+        if (nodeInLeft && !nextRight(nodeOutRight)) {
+          nodeOutRight.hierNode.thread = nodeInLeft;
+          nodeOutRight.hierNode.modifier += sumInLeft - sumOutRight;
+        }
+
+        if (nodeInRight && !nextLeft(nodeOutLeft)) {
+          nodeOutLeft.hierNode.thread = nodeInRight;
+          nodeOutLeft.hierNode.modifier += sumInRight - sumOutLeft;
+          ancestor = subtreeV;
+        }
+      }
+
+      return ancestor;
+    }
+    /**
+     * This function is used to traverse the right contour of a subtree.
+     * It returns the rightmost child of node or the thread of node. The function
+     * returns null if and only if node is on the highest depth of its subtree.
+     */
+
+
+    function nextRight(node) {
+      var children = node.children;
+      return children.length && node.isExpand ? children[children.length - 1] : node.hierNode.thread;
+    }
+    /**
+     * This function is used to traverse the left contour of a subtree (or a subforest).
+     * It returns the leftmost child of node or the thread of node. The function
+     * returns null if and only if node is on the highest depth of its subtree.
+     */
+
+
+    function nextLeft(node) {
+      var children = node.children;
+      return children.length && node.isExpand ? children[0] : node.hierNode.thread;
+    }
+    /**
+     * If nodeInLeft’s ancestor is a sibling of node, returns nodeInLeft’s ancestor.
+     * Otherwise, returns the specified ancestor.
+     */
+
+
+    function nextAncestor(nodeInLeft, node, ancestor) {
+      return nodeInLeft.hierNode.ancestor.parentNode === node.parentNode ? nodeInLeft.hierNode.ancestor : ancestor;
+    }
+    /**
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     *
+     * Shifts the current subtree rooted at wr.
+     * This is done by increasing prelim(w+) and modifier(w+) by shift.
+     */
+
+
+    function moveSubtree(wl, wr, shift) {
+      var change = shift / (wr.hierNode.i - wl.hierNode.i);
+      wr.hierNode.change -= change;
+      wr.hierNode.shift += shift;
+      wr.hierNode.modifier += shift;
+      wr.hierNode.prelim += shift;
+      wl.hierNode.change += change;
+    }
+    /**
+     * The implementation of this function was originally copied from "d3.js"
+     * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     */
+
+
+    function defaultSeparation(node1, node2) {
+      return node1.parentNode === node2.parentNode ? 1 : 2;
+    }
+
+    var TreeEdgeShape =
+    /** @class */
+    function () {
+      function TreeEdgeShape() {
+        this.parentPoint = [];
+        this.childPoints = [];
+      }
+
+      return TreeEdgeShape;
+    }();
+
+    var TreePath =
+    /** @class */
+    function (_super) {
+      __extends(TreePath, _super);
+
+      function TreePath(opts) {
+        return _super.call(this, opts) || this;
+      }
+
+      TreePath.prototype.getDefaultStyle = function () {
+        return {
+          stroke: '#000',
+          fill: null
+        };
+      };
+
+      TreePath.prototype.getDefaultShape = function () {
+        return new TreeEdgeShape();
+      };
+
+      TreePath.prototype.buildPath = function (ctx, shape) {
+        var childPoints = shape.childPoints;
+        var childLen = childPoints.length;
+        var parentPoint = shape.parentPoint;
+        var firstChildPos = childPoints[0];
+        var lastChildPos = childPoints[childLen - 1];
+
+        if (childLen === 1) {
+          ctx.moveTo(parentPoint[0], parentPoint[1]);
+          ctx.lineTo(firstChildPos[0], firstChildPos[1]);
+          return;
+        }
+
+        var orient = shape.orient;
+        var forkDim = orient === 'TB' || orient === 'BT' ? 0 : 1;
+        var otherDim = 1 - forkDim;
+        var forkPosition = parsePercent$1(shape.forkPosition, 1);
+        var tmpPoint = [];
+        tmpPoint[forkDim] = parentPoint[forkDim];
+        tmpPoint[otherDim] = parentPoint[otherDim] + (lastChildPos[otherDim] - parentPoint[otherDim]) * forkPosition;
+        ctx.moveTo(parentPoint[0], parentPoint[1]);
+        ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+        ctx.moveTo(firstChildPos[0], firstChildPos[1]);
+        tmpPoint[forkDim] = firstChildPos[forkDim];
+        ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+        tmpPoint[forkDim] = lastChildPos[forkDim];
+        ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+        ctx.lineTo(lastChildPos[0], lastChildPos[1]);
+
+        for (var i = 1; i < childLen - 1; i++) {
+          var point = childPoints[i];
+          ctx.moveTo(point[0], point[1]);
+          tmpPoint[forkDim] = point[forkDim];
+          ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+        }
+      };
+
+      return TreePath;
+    }(Path);
+
+    var TreeView =
+    /** @class */
+    function (_super) {
+      __extends(TreeView, _super);
+
+      function TreeView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TreeView.type;
+        _this._mainGroup = new Group();
+        return _this;
+      }
+
+      TreeView.prototype.init = function (ecModel, api) {
+        this._controller = new RoamController(api.getZr());
+        this._controllerHost = {
+          target: this.group
+        };
+        this.group.add(this._mainGroup);
+      };
+
+      TreeView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var layoutInfo = seriesModel.layoutInfo;
+        var group = this._mainGroup;
+        var layout = seriesModel.get('layout');
+
+        if (layout === 'radial') {
+          group.x = layoutInfo.x + layoutInfo.width / 2;
+          group.y = layoutInfo.y + layoutInfo.height / 2;
+        } else {
+          group.x = layoutInfo.x;
+          group.y = layoutInfo.y;
+        }
+
+        this._updateViewCoordSys(seriesModel);
+
+        this._updateController(seriesModel, ecModel, api);
+
+        var oldData = this._data;
+        data.diff(oldData).add(function (newIdx) {
+          if (symbolNeedsDraw$1(data, newIdx)) {
+            // Create node and edge
+            updateNode(data, newIdx, null, group, seriesModel);
+          }
+        }).update(function (newIdx, oldIdx) {
+          var symbolEl = oldData.getItemGraphicEl(oldIdx);
+
+          if (!symbolNeedsDraw$1(data, newIdx)) {
+            symbolEl && removeNode(oldData, oldIdx, symbolEl, group, seriesModel);
+            return;
+          } // Update node and edge
+
+
+          updateNode(data, newIdx, symbolEl, group, seriesModel);
+        }).remove(function (oldIdx) {
+          var symbolEl = oldData.getItemGraphicEl(oldIdx); // When remove a collapsed node of subtree, since the collapsed
+          // node haven't been initialized with a symbol element,
+          // you can't found it's symbol element through index.
+          // so if we want to remove the symbol element we should insure
+          // that the symbol element is not null.
+
+          if (symbolEl) {
+            removeNode(oldData, oldIdx, symbolEl, group, seriesModel);
+          }
+        }).execute();
+        this._nodeScaleRatio = seriesModel.get('nodeScaleRatio');
+
+        this._updateNodeAndLinkScale(seriesModel);
+
+        if (seriesModel.get('expandAndCollapse') === true) {
+          data.eachItemGraphicEl(function (el, dataIndex) {
+            el.off('click').on('click', function () {
+              api.dispatchAction({
+                type: 'treeExpandAndCollapse',
+                seriesId: seriesModel.id,
+                dataIndex: dataIndex
+              });
+            });
+          });
+        }
+
+        this._data = data;
+      };
+
+      TreeView.prototype._updateViewCoordSys = function (seriesModel) {
+        var data = seriesModel.getData();
+        var points = [];
+        data.each(function (idx) {
+          var layout = data.getItemLayout(idx);
+
+          if (layout && !isNaN(layout.x) && !isNaN(layout.y)) {
+            points.push([+layout.x, +layout.y]);
+          }
+        });
+        var min = [];
+        var max = [];
+        fromPoints(points, min, max); // If don't Store min max when collapse the root node after roam,
+        // the root node will disappear.
+
+        var oldMin = this._min;
+        var oldMax = this._max; // If width or height is 0
+
+        if (max[0] - min[0] === 0) {
+          min[0] = oldMin ? oldMin[0] : min[0] - 1;
+          max[0] = oldMax ? oldMax[0] : max[0] + 1;
+        }
+
+        if (max[1] - min[1] === 0) {
+          min[1] = oldMin ? oldMin[1] : min[1] - 1;
+          max[1] = oldMax ? oldMax[1] : max[1] + 1;
+        }
+
+        var viewCoordSys = seriesModel.coordinateSystem = new View();
+        viewCoordSys.zoomLimit = seriesModel.get('scaleLimit');
+        viewCoordSys.setBoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+        viewCoordSys.setCenter(seriesModel.get('center'));
+        viewCoordSys.setZoom(seriesModel.get('zoom')); // Here we use viewCoordSys just for computing the 'position' and 'scale' of the group
+
+        this.group.attr({
+          x: viewCoordSys.x,
+          y: viewCoordSys.y,
+          scaleX: viewCoordSys.scaleX,
+          scaleY: viewCoordSys.scaleY
+        });
+        this._min = min;
+        this._max = max;
+      };
+
+      TreeView.prototype._updateController = function (seriesModel, ecModel, api) {
+        var _this = this;
+
+        var controller = this._controller;
+        var controllerHost = this._controllerHost;
+        var group = this.group;
+        controller.setPointerChecker(function (e, x, y) {
+          var rect = group.getBoundingRect();
+          rect.applyTransform(group.transform);
+          return rect.contain(x, y) && !onIrrelevantElement(e, api, seriesModel);
+        });
+        controller.enable(seriesModel.get('roam'));
+        controllerHost.zoomLimit = seriesModel.get('scaleLimit');
+        controllerHost.zoom = seriesModel.coordinateSystem.getZoom();
+        controller.off('pan').off('zoom').on('pan', function (e) {
+          updateViewOnPan(controllerHost, e.dx, e.dy);
+          api.dispatchAction({
+            seriesId: seriesModel.id,
+            type: 'treeRoam',
+            dx: e.dx,
+            dy: e.dy
+          });
+        }).on('zoom', function (e) {
+          updateViewOnZoom(controllerHost, e.scale, e.originX, e.originY);
+          api.dispatchAction({
+            seriesId: seriesModel.id,
+            type: 'treeRoam',
+            zoom: e.scale,
+            originX: e.originX,
+            originY: e.originY
+          });
+
+          _this._updateNodeAndLinkScale(seriesModel); // Only update label layout on zoom
+
+
+          api.updateLabelLayout();
+        });
+      };
+
+      TreeView.prototype._updateNodeAndLinkScale = function (seriesModel) {
+        var data = seriesModel.getData();
+
+        var nodeScale = this._getNodeGlobalScale(seriesModel);
+
+        data.eachItemGraphicEl(function (el, idx) {
+          el.setSymbolScale(nodeScale);
+        });
+      };
+
+      TreeView.prototype._getNodeGlobalScale = function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys.type !== 'view') {
+          return 1;
+        }
+
+        var nodeScaleRatio = this._nodeScaleRatio;
+        var groupZoom = coordSys.scaleX || 1; // Scale node when zoom changes
+
+        var roamZoom = coordSys.getZoom();
+        var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+        return nodeScale / groupZoom;
+      };
+
+      TreeView.prototype.dispose = function () {
+        this._controller && this._controller.dispose();
+        this._controllerHost = null;
+      };
+
+      TreeView.prototype.remove = function () {
+        this._mainGroup.removeAll();
+
+        this._data = null;
+      };
+
+      TreeView.type = 'tree';
+      return TreeView;
+    }(ChartView);
+
+    function symbolNeedsDraw$1(data, dataIndex) {
+      var layout = data.getItemLayout(dataIndex);
+      return layout && !isNaN(layout.x) && !isNaN(layout.y);
+    }
+
+    function updateNode(data, dataIndex, symbolEl, group, seriesModel) {
+      var isInit = !symbolEl;
+      var node = data.tree.getNodeByDataIndex(dataIndex);
+      var itemModel = node.getModel();
+      var visualColor = node.getVisual('style').fill;
+      var symbolInnerColor = node.isExpand === false && node.children.length !== 0 ? visualColor : '#fff';
+      var virtualRoot = data.tree.root;
+      var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
+      var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
+      var sourceLayout = source.getLayout();
+      var sourceOldLayout = sourceSymbolEl ? {
+        x: sourceSymbolEl.__oldX,
+        y: sourceSymbolEl.__oldY,
+        rawX: sourceSymbolEl.__radialOldRawX,
+        rawY: sourceSymbolEl.__radialOldRawY
+      } : sourceLayout;
+      var targetLayout = node.getLayout();
+
+      if (isInit) {
+        symbolEl = new Symbol(data, dataIndex, null, {
+          symbolInnerColor: symbolInnerColor,
+          useNameLabel: true
+        });
+        symbolEl.x = sourceOldLayout.x;
+        symbolEl.y = sourceOldLayout.y;
+      } else {
+        symbolEl.updateData(data, dataIndex, null, {
+          symbolInnerColor: symbolInnerColor,
+          useNameLabel: true
+        });
+      }
+
+      symbolEl.__radialOldRawX = symbolEl.__radialRawX;
+      symbolEl.__radialOldRawY = symbolEl.__radialRawY;
+      symbolEl.__radialRawX = targetLayout.rawX;
+      symbolEl.__radialRawY = targetLayout.rawY;
+      group.add(symbolEl);
+      data.setItemGraphicEl(dataIndex, symbolEl);
+      symbolEl.__oldX = symbolEl.x;
+      symbolEl.__oldY = symbolEl.y;
+      updateProps(symbolEl, {
+        x: targetLayout.x,
+        y: targetLayout.y
+      }, seriesModel);
+      var symbolPath = symbolEl.getSymbolPath();
+
+      if (seriesModel.get('layout') === 'radial') {
+        var realRoot = virtualRoot.children[0];
+        var rootLayout = realRoot.getLayout();
+        var length_1 = realRoot.children.length;
+        var rad = void 0;
+        var isLeft = void 0;
+
+        if (targetLayout.x === rootLayout.x && node.isExpand === true) {
+          var center = {
+            x: (realRoot.children[0].getLayout().x + realRoot.children[length_1 - 1].getLayout().x) / 2,
+            y: (realRoot.children[0].getLayout().y + realRoot.children[length_1 - 1].getLayout().y) / 2
+          };
+          rad = Math.atan2(center.y - rootLayout.y, center.x - rootLayout.x);
+
+          if (rad < 0) {
+            rad = Math.PI * 2 + rad;
+          }
+
+          isLeft = center.x < rootLayout.x;
+
+          if (isLeft) {
+            rad = rad - Math.PI;
+          }
+        } else {
+          rad = Math.atan2(targetLayout.y - rootLayout.y, targetLayout.x - rootLayout.x);
+
+          if (rad < 0) {
+            rad = Math.PI * 2 + rad;
+          }
+
+          if (node.children.length === 0 || node.children.length !== 0 && node.isExpand === false) {
+            isLeft = targetLayout.x < rootLayout.x;
+
+            if (isLeft) {
+              rad = rad - Math.PI;
+            }
+          } else {
+            isLeft = targetLayout.x > rootLayout.x;
+
+            if (!isLeft) {
+              rad = rad - Math.PI;
+            }
+          }
+        }
+
+        var textPosition = isLeft ? 'left' : 'right';
+        var normalLabelModel = itemModel.getModel('label');
+        var rotate = normalLabelModel.get('rotate');
+        var labelRotateRadian = rotate * (Math.PI / 180);
+        var textContent = symbolPath.getTextContent();
+
+        if (textContent) {
+          symbolPath.setTextConfig({
+            position: normalLabelModel.get('position') || textPosition,
+            rotation: rotate == null ? -rad : labelRotateRadian,
+            origin: 'center'
+          });
+          textContent.setStyle('verticalAlign', 'middle');
+        }
+      } // Handle status
+
+
+      var focus = itemModel.get(['emphasis', 'focus']);
+      var focusDataIndices = focus === 'ancestor' ? node.getAncestorsIndices() : focus === 'descendant' ? node.getDescendantIndices() : null;
+
+      if (focusDataIndices) {
+        // Modify the focus to data indices.
+        getECData(symbolEl).focus = focusDataIndices;
+      }
+
+      drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group);
+
+      if (symbolEl.__edge) {
+        symbolEl.onHoverStateChange = function (toState) {
+          if (toState !== 'blur') {
+            // NOTE: Ensure the parent elements will been blurred firstly.
+            // According to the return of getAncestorsIndices and getDescendantIndices
+            // TODO: A bit tricky.
+            var parentEl = node.parentNode && data.getItemGraphicEl(node.parentNode.dataIndex);
+
+            if (!(parentEl && parentEl.hoverState === HOVER_STATE_BLUR)) {
+              setStatesFlag(symbolEl.__edge, toState);
+            }
+          }
+        };
+      }
+    }
+
+    function drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group) {
+      var itemModel = node.getModel();
+      var edgeShape = seriesModel.get('edgeShape');
+      var layout = seriesModel.get('layout');
+      var orient = seriesModel.getOrient();
+      var curvature = seriesModel.get(['lineStyle', 'curveness']);
+      var edgeForkPosition = seriesModel.get('edgeForkPosition');
+      var lineStyle = itemModel.getModel('lineStyle').getLineStyle();
+      var edge = symbolEl.__edge;
+
+      if (edgeShape === 'curve') {
+        if (node.parentNode && node.parentNode !== virtualRoot) {
+          if (!edge) {
+            edge = symbolEl.__edge = new BezierCurve({
+              shape: getEdgeShape(layout, orient, curvature, sourceOldLayout, sourceOldLayout)
+            });
+          }
+
+          updateProps(edge, {
+            shape: getEdgeShape(layout, orient, curvature, sourceLayout, targetLayout)
+          }, seriesModel);
+        }
+      } else if (edgeShape === 'polyline') {
+        if (layout === 'orthogonal') {
+          if (node !== virtualRoot && node.children && node.children.length !== 0 && node.isExpand === true) {
+            var children = node.children;
+            var childPoints = [];
+
+            for (var i = 0; i < children.length; i++) {
+              var childLayout = children[i].getLayout();
+              childPoints.push([childLayout.x, childLayout.y]);
+            }
+
+            if (!edge) {
+              edge = symbolEl.__edge = new TreePath({
+                shape: {
+                  parentPoint: [targetLayout.x, targetLayout.y],
+                  childPoints: [[targetLayout.x, targetLayout.y]],
+                  orient: orient,
+                  forkPosition: edgeForkPosition
+                }
+              });
+            }
+
+            updateProps(edge, {
+              shape: {
+                parentPoint: [targetLayout.x, targetLayout.y],
+                childPoints: childPoints
+              }
+            }, seriesModel);
+          }
+        } else {
+          if ("development" !== 'production') {
+            throw new Error('The polyline edgeShape can only be used in orthogonal layout');
+          }
+        }
+      }
+
+      if (edge) {
+        edge.useStyle(defaults({
+          strokeNoScale: true,
+          fill: null
+        }, lineStyle));
+        setStatesStylesFromModel(edge, itemModel, 'lineStyle');
+        setDefaultStateProxy(edge);
+        group.add(edge);
+      }
+    }
+
+    function removeNode(data, dataIndex, symbolEl, group, seriesModel) {
+      var node = data.tree.getNodeByDataIndex(dataIndex);
+      var virtualRoot = data.tree.root;
+      var source = node.parentNode === virtualRoot ? node : node.parentNode || node; // let edgeShape = seriesScope.edgeShape;
+
+      var sourceLayout;
+
+      while (sourceLayout = source.getLayout(), sourceLayout == null) {
+        source = source.parentNode === virtualRoot ? source : source.parentNode || source;
+      } // Use same duration and easing with update to have more consistent animation.
+
+
+      var removeAnimationOpt = {
+        duration: seriesModel.get('animationDurationUpdate'),
+        easing: seriesModel.get('animationEasingUpdate')
+      };
+      removeElement(symbolEl, {
+        x: sourceLayout.x + 1,
+        y: sourceLayout.y + 1
+      }, seriesModel, {
+        cb: function () {
+          group.remove(symbolEl);
+          data.setItemGraphicEl(dataIndex, null);
+        },
+        removeOpt: removeAnimationOpt
+      });
+      symbolEl.fadeOut(null, {
+        fadeLabel: true,
+        animation: removeAnimationOpt
+      });
+      var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
+      var sourceEdge = sourceSymbolEl.__edge; // 1. when expand the sub tree, delete the children node should delete the edge of
+      // the source at the same time. because the polyline edge shape is only owned by the source.
+      // 2.when the node is the only children of the source, delete the node should delete the edge of
+      // the source at the same time. the same reason as above.
+
+      var edge = symbolEl.__edge || (source.isExpand === false || source.children.length === 1 ? sourceEdge : undefined);
+      var edgeShape = seriesModel.get('edgeShape');
+      var layoutOpt = seriesModel.get('layout');
+      var orient = seriesModel.get('orient');
+      var curvature = seriesModel.get(['lineStyle', 'curveness']);
+
+      if (edge) {
+        if (edgeShape === 'curve') {
+          removeElement(edge, {
+            shape: getEdgeShape(layoutOpt, orient, curvature, sourceLayout, sourceLayout),
+            style: {
+              opacity: 0
+            }
+          }, seriesModel, {
+            cb: function () {
+              group.remove(edge);
+            },
+            removeOpt: removeAnimationOpt
+          });
+        } else if (edgeShape === 'polyline' && seriesModel.get('layout') === 'orthogonal') {
+          removeElement(edge, {
+            shape: {
+              parentPoint: [sourceLayout.x, sourceLayout.y],
+              childPoints: [[sourceLayout.x, sourceLayout.y]]
+            },
+            style: {
+              opacity: 0
+            }
+          }, seriesModel, {
+            cb: function () {
+              group.remove(edge);
+            },
+            removeOpt: removeAnimationOpt
+          });
+        }
+      }
+    }
+
+    function getEdgeShape(layoutOpt, orient, curvature, sourceLayout, targetLayout) {
+      var cpx1;
+      var cpy1;
+      var cpx2;
+      var cpy2;
+      var x1;
+      var x2;
+      var y1;
+      var y2;
+
+      if (layoutOpt === 'radial') {
+        x1 = sourceLayout.rawX;
+        y1 = sourceLayout.rawY;
+        x2 = targetLayout.rawX;
+        y2 = targetLayout.rawY;
+        var radialCoor1 = radialCoordinate(x1, y1);
+        var radialCoor2 = radialCoordinate(x1, y1 + (y2 - y1) * curvature);
+        var radialCoor3 = radialCoordinate(x2, y2 + (y1 - y2) * curvature);
+        var radialCoor4 = radialCoordinate(x2, y2);
+        return {
+          x1: radialCoor1.x || 0,
+          y1: radialCoor1.y || 0,
+          x2: radialCoor4.x || 0,
+          y2: radialCoor4.y || 0,
+          cpx1: radialCoor2.x || 0,
+          cpy1: radialCoor2.y || 0,
+          cpx2: radialCoor3.x || 0,
+          cpy2: radialCoor3.y || 0
+        };
+      } else {
+        x1 = sourceLayout.x;
+        y1 = sourceLayout.y;
+        x2 = targetLayout.x;
+        y2 = targetLayout.y;
+
+        if (orient === 'LR' || orient === 'RL') {
+          cpx1 = x1 + (x2 - x1) * curvature;
+          cpy1 = y1;
+          cpx2 = x2 + (x1 - x2) * curvature;
+          cpy2 = y2;
+        }
+
+        if (orient === 'TB' || orient === 'BT') {
+          cpx1 = x1;
+          cpy1 = y1 + (y2 - y1) * curvature;
+          cpx2 = x2;
+          cpy2 = y2 + (y1 - y2) * curvature;
+        }
+      }
+
+      return {
+        x1: x1,
+        y1: y1,
+        x2: x2,
+        y2: y2,
+        cpx1: cpx1,
+        cpy1: cpy1,
+        cpx2: cpx2,
+        cpy2: cpy2
+      };
+    }
+
+    var inner$8 = makeInner();
+
+    function linkList(opt) {
+      var mainData = opt.mainData;
+      var datas = opt.datas;
+
+      if (!datas) {
+        datas = {
+          main: mainData
+        };
+        opt.datasAttr = {
+          main: 'data'
+        };
+      }
+
+      opt.datas = opt.mainData = null;
+      linkAll(mainData, datas, opt); // Porxy data original methods.
+
+      each(datas, function (data) {
+        each(mainData.TRANSFERABLE_METHODS, function (methodName) {
+          data.wrapMethod(methodName, curry(transferInjection, opt));
+        });
+      }); // Beyond transfer, additional features should be added to `cloneShallow`.
+
+      mainData.wrapMethod('cloneShallow', curry(cloneShallowInjection, opt)); // Only mainData trigger change, because struct.update may trigger
+      // another changable methods, which may bring about dead lock.
+
+      each(mainData.CHANGABLE_METHODS, function (methodName) {
+        mainData.wrapMethod(methodName, curry(changeInjection, opt));
+      }); // Make sure datas contains mainData.
+
+      assert(datas[mainData.dataType] === mainData);
+    }
+
+    function transferInjection(opt, res) {
+      if (isMainData(this)) {
+        // Transfer datas to new main data.
+        var datas = extend({}, inner$8(this).datas);
+        datas[this.dataType] = res;
+        linkAll(res, datas, opt);
+      } else {
+        // Modify the reference in main data to point newData.
+        linkSingle(res, this.dataType, inner$8(this).mainData, opt);
+      }
+
+      return res;
+    }
+
+    function changeInjection(opt, res) {
+      opt.struct && opt.struct.update();
+      return res;
+    }
+
+    function cloneShallowInjection(opt, res) {
+      // cloneShallow, which brings about some fragilities, may be inappropriate
+      // to be exposed as an API. So for implementation simplicity we can make
+      // the restriction that cloneShallow of not-mainData should not be invoked
+      // outside, but only be invoked here.
+      each(inner$8(res).datas, function (data, dataType) {
+        data !== res && linkSingle(data.cloneShallow(), dataType, res, opt);
+      });
+      return res;
+    }
+    /**
+     * Supplement method to List.
+     *
+     * @public
+     * @param [dataType] If not specified, return mainData.
+     */
+
+
+    function getLinkedData(dataType) {
+      var mainData = inner$8(this).mainData;
+      return dataType == null || mainData == null ? mainData : inner$8(mainData).datas[dataType];
+    }
+    /**
+     * Get list of all linked data
+     */
+
+
+    function getLinkedDataAll() {
+      var mainData = inner$8(this).mainData;
+      return mainData == null ? [{
+        data: mainData
+      }] : map(keys(inner$8(mainData).datas), function (type) {
+        return {
+          type: type,
+          data: inner$8(mainData).datas[type]
+        };
+      });
+    }
+
+    function isMainData(data) {
+      return inner$8(data).mainData === data;
+    }
+
+    function linkAll(mainData, datas, opt) {
+      inner$8(mainData).datas = {};
+      each(datas, function (data, dataType) {
+        linkSingle(data, dataType, mainData, opt);
+      });
+    }
+
+    function linkSingle(data, dataType, mainData, opt) {
+      inner$8(mainData).datas[dataType] = data;
+      inner$8(data).mainData = mainData;
+      data.dataType = dataType;
+
+      if (opt.struct) {
+        data[opt.structAttr] = opt.struct;
+        opt.struct[opt.datasAttr[dataType]] = data;
+      } // Supplement method.
+
+
+      data.getLinkedData = getLinkedData;
+      data.getLinkedDataAll = getLinkedDataAll;
+    }
+
+    var TreeNode =
+    /** @class */
+    function () {
+      function TreeNode(name, hostTree) {
+        this.depth = 0;
+        this.height = 0;
+        /**
+         * Reference to list item.
+         * Do not persistent dataIndex outside,
+         * besause it may be changed by list.
+         * If dataIndex -1,
+         * this node is logical deleted (filtered) in list.
+         */
+
+        this.dataIndex = -1;
+        this.children = [];
+        this.viewChildren = [];
+        this.isExpand = false;
+        this.name = name || '';
+        this.hostTree = hostTree;
+      }
+      /**
+       * The node is removed.
+       */
+
+
+      TreeNode.prototype.isRemoved = function () {
+        return this.dataIndex < 0;
+      };
+
+      TreeNode.prototype.eachNode = function (options, cb, context) {
+        if (typeof options === 'function') {
+          context = cb;
+          cb = options;
+          options = null;
+        }
+
+        options = options || {};
+
+        if (isString(options)) {
+          options = {
+            order: options
+          };
+        }
+
+        var order = options.order || 'preorder';
+        var children = this[options.attr || 'children'];
+        var suppressVisitSub;
+        order === 'preorder' && (suppressVisitSub = cb.call(context, this));
+
+        for (var i = 0; !suppressVisitSub && i < children.length; i++) {
+          children[i].eachNode(options, cb, context);
+        }
+
+        order === 'postorder' && cb.call(context, this);
+      };
+      /**
+       * Update depth and height of this subtree.
+       */
+
+
+      TreeNode.prototype.updateDepthAndHeight = function (depth) {
+        var height = 0;
+        this.depth = depth;
+
+        for (var i = 0; i < this.children.length; i++) {
+          var child = this.children[i];
+          child.updateDepthAndHeight(depth + 1);
+
+          if (child.height > height) {
+            height = child.height;
+          }
+        }
+
+        this.height = height + 1;
+      };
+
+      TreeNode.prototype.getNodeById = function (id) {
+        if (this.getId() === id) {
+          return this;
+        }
+
+        for (var i = 0, children = this.children, len = children.length; i < len; i++) {
+          var res = children[i].getNodeById(id);
+
+          if (res) {
+            return res;
+          }
+        }
+      };
+
+      TreeNode.prototype.contains = function (node) {
+        if (node === this) {
+          return true;
+        }
+
+        for (var i = 0, children = this.children, len = children.length; i < len; i++) {
+          var res = children[i].contains(node);
+
+          if (res) {
+            return res;
+          }
+        }
+      };
+      /**
+       * @param includeSelf Default false.
+       * @return order: [root, child, grandchild, ...]
+       */
+
+
+      TreeNode.prototype.getAncestors = function (includeSelf) {
+        var ancestors = [];
+        var node = includeSelf ? this : this.parentNode;
+
+        while (node) {
+          ancestors.push(node);
+          node = node.parentNode;
+        }
+
+        ancestors.reverse();
+        return ancestors;
+      };
+
+      TreeNode.prototype.getAncestorsIndices = function () {
+        var indices = [];
+        var currNode = this;
+
+        while (currNode) {
+          indices.push(currNode.dataIndex);
+          currNode = currNode.parentNode;
+        }
+
+        indices.reverse();
+        return indices;
+      };
+
+      TreeNode.prototype.getDescendantIndices = function () {
+        var indices = [];
+        this.eachNode(function (childNode) {
+          indices.push(childNode.dataIndex);
+        });
+        return indices;
+      };
+
+      TreeNode.prototype.getValue = function (dimension) {
+        var data = this.hostTree.data;
+        return data.get(data.getDimension(dimension || 'value'), this.dataIndex);
+      };
+
+      TreeNode.prototype.setLayout = function (layout, merge) {
+        this.dataIndex >= 0 && this.hostTree.data.setItemLayout(this.dataIndex, layout, merge);
+      };
+      /**
+       * @return {Object} layout
+       */
+
+
+      TreeNode.prototype.getLayout = function () {
+        return this.hostTree.data.getItemLayout(this.dataIndex);
+      }; // @depcrecated
+      // getModel<T = unknown, S extends keyof T = keyof T>(path: S): Model<T[S]>
+
+
+      TreeNode.prototype.getModel = function (path) {
+        if (this.dataIndex < 0) {
+          return;
+        }
+
+        var hostTree = this.hostTree;
+        var itemModel = hostTree.data.getItemModel(this.dataIndex);
+        return itemModel.getModel(path);
+      }; // TODO: TYPE More specific model
+
+
+      TreeNode.prototype.getLevelModel = function () {
+        return (this.hostTree.levelModels || [])[this.depth];
+      };
+
+      TreeNode.prototype.setVisual = function (key, value) {
+        this.dataIndex >= 0 && this.hostTree.data.setItemVisual(this.dataIndex, key, value);
+      };
+      /**
+       * Get item visual
+       */
+
+
+      TreeNode.prototype.getVisual = function (key) {
+        return this.hostTree.data.getItemVisual(this.dataIndex, key);
+      };
+
+      TreeNode.prototype.getRawIndex = function () {
+        return this.hostTree.data.getRawIndex(this.dataIndex);
+      };
+
+      TreeNode.prototype.getId = function () {
+        return this.hostTree.data.getId(this.dataIndex);
+      };
+      /**
+       * if this is an ancestor of another node
+       *
+       * @param node another node
+       * @return if is ancestor
+       */
+
+
+      TreeNode.prototype.isAncestorOf = function (node) {
+        var parent = node.parentNode;
+
+        while (parent) {
+          if (parent === this) {
+            return true;
+          }
+
+          parent = parent.parentNode;
+        }
+
+        return false;
+      };
+      /**
+       * if this is an descendant of another node
+       *
+       * @param node another node
+       * @return if is descendant
+       */
+
+
+      TreeNode.prototype.isDescendantOf = function (node) {
+        return node !== this && node.isAncestorOf(this);
+      };
+
+      return TreeNode;
+    }();
+
+    var Tree =
+    /** @class */
+    function () {
+      function Tree(hostModel) {
+        this.type = 'tree';
+        this._nodes = [];
+        this.hostModel = hostModel;
+      }
+
+      Tree.prototype.eachNode = function (options, cb, context) {
+        this.root.eachNode(options, cb, context);
+      };
+
+      Tree.prototype.getNodeByDataIndex = function (dataIndex) {
+        var rawIndex = this.data.getRawIndex(dataIndex);
+        return this._nodes[rawIndex];
+      };
+
+      Tree.prototype.getNodeById = function (name) {
+        return this.root.getNodeById(name);
+      };
+      /**
+       * Update item available by list,
+       * when list has been performed options like 'filterSelf' or 'map'.
+       */
+
+
+      Tree.prototype.update = function () {
+        var data = this.data;
+        var nodes = this._nodes;
+
+        for (var i = 0, len = nodes.length; i < len; i++) {
+          nodes[i].dataIndex = -1;
+        }
+
+        for (var i = 0, len = data.count(); i < len; i++) {
+          nodes[data.getRawIndex(i)].dataIndex = i;
+        }
+      };
+      /**
+       * Clear all layouts
+       */
+
+
+      Tree.prototype.clearLayouts = function () {
+        this.data.clearItemLayouts();
+      };
+      /**
+       * data node format:
+       * {
+       *     name: ...
+       *     value: ...
+       *     children: [
+       *         {
+       *             name: ...
+       *             value: ...
+       *             children: ...
+       *         },
+       *         ...
+       *     ]
+       * }
+       */
+
+
+      Tree.createTree = function (dataRoot, hostModel, beforeLink) {
+        var tree = new Tree(hostModel);
+        var listData = [];
+        var dimMax = 1;
+        buildHierarchy(dataRoot);
+
+        function buildHierarchy(dataNode, parentNode) {
+          var value = dataNode.value;
+          dimMax = Math.max(dimMax, isArray(value) ? value.length : 1);
+          listData.push(dataNode);
+          var node = new TreeNode(convertOptionIdName(dataNode.name, ''), tree);
+          parentNode ? addChild(node, parentNode) : tree.root = node;
+
+          tree._nodes.push(node);
+
+          var children = dataNode.children;
+
+          if (children) {
+            for (var i = 0; i < children.length; i++) {
+              buildHierarchy(children[i], node);
+            }
+          }
+        }
+
+        tree.root.updateDepthAndHeight(0);
+        var dimensionsInfo = createDimensions(listData, {
+          coordDimensions: ['value'],
+          dimensionsCount: dimMax
+        });
+        var list = new List(dimensionsInfo, hostModel);
+        list.initData(listData);
+        beforeLink && beforeLink(list);
+        linkList({
+          mainData: list,
+          struct: tree,
+          structAttr: 'tree'
+        });
+        tree.update();
+        return tree;
+      };
+
+      return Tree;
+    }();
+    /**
+     * It is needed to consider the mess of 'list', 'hostModel' when creating a TreeNote,
+     * so this function is not ready and not necessary to be public.
+     */
+
+
+    function addChild(child, node) {
+      var children = node.children;
+
+      if (child.parentNode === node) {
+        return;
+      }
+
+      children.push(child);
+      child.parentNode = node;
+    }
+
+    var TreeSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(TreeSeriesModel, _super);
+
+      function TreeSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.hasSymbolVisual = true; // Do it self.
+
+        _this.ignoreStyleOnData = true;
+        return _this;
+      }
+      /**
+       * Init a tree data structure from data in option series
+       * @param  option  the object used to config echarts view
+       * @return storage initial data
+       */
+
+
+      TreeSeriesModel.prototype.getInitialData = function (option) {
+        //create an virtual root
+        var root = {
+          name: option.name,
+          children: option.data
+        };
+        var leaves = option.leaves || {};
+        var leavesModel = new Model(leaves, this, this.ecModel);
+        var tree = Tree.createTree(root, this, beforeLink);
+
+        function beforeLink(nodeData) {
+          nodeData.wrapMethod('getItemModel', function (model, idx) {
+            var node = tree.getNodeByDataIndex(idx);
+
+            if (!node.children.length || !node.isExpand) {
+              model.parentModel = leavesModel;
+            }
+
+            return model;
+          });
+        }
+
+        var treeDepth = 0;
+        tree.eachNode('preorder', function (node) {
+          if (node.depth > treeDepth) {
+            treeDepth = node.depth;
+          }
+        });
+        var expandAndCollapse = option.expandAndCollapse;
+        var expandTreeDepth = expandAndCollapse && option.initialTreeDepth >= 0 ? option.initialTreeDepth : treeDepth;
+        tree.root.eachNode('preorder', function (node) {
+          var item = node.hostTree.data.getRawDataItem(node.dataIndex); // Add item.collapsed != null, because users can collapse node original in the series.data.
+
+          node.isExpand = item && item.collapsed != null ? !item.collapsed : node.depth <= expandTreeDepth;
+        });
+        return tree.data;
+      };
+      /**
+       * Make the configuration 'orient' backward compatibly, with 'horizontal = LR', 'vertical = TB'.
+       * @returns {string} orient
+       */
+
+
+      TreeSeriesModel.prototype.getOrient = function () {
+        var orient = this.get('orient');
+
+        if (orient === 'horizontal') {
+          orient = 'LR';
+        } else if (orient === 'vertical') {
+          orient = 'TB';
+        }
+
+        return orient;
+      };
+
+      TreeSeriesModel.prototype.setZoom = function (zoom) {
+        this.option.zoom = zoom;
+      };
+
+      TreeSeriesModel.prototype.setCenter = function (center) {
+        this.option.center = center;
+      };
+
+      TreeSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var tree = this.getData().tree;
+        var realRoot = tree.root.children[0];
+        var node = tree.getNodeByDataIndex(dataIndex);
+        var value = node.getValue();
+        var name = node.name;
+
+        while (node && node !== realRoot) {
+          name = node.parentNode.name + '.' + name;
+          node = node.parentNode;
+        }
+
+        return createTooltipMarkup('nameValue', {
+          name: name,
+          value: value,
+          noValue: isNaN(value) || value == null
+        });
+      };
+
+      TreeSeriesModel.type = 'series.tree'; // can support the position parameters 'left', 'top','right','bottom', 'width',
+      // 'height' in the setOption() with 'merge' mode normal.
+
+      TreeSeriesModel.layoutMode = 'box';
+      TreeSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'view',
+        // the position of the whole view
+        left: '12%',
+        top: '12%',
+        right: '12%',
+        bottom: '12%',
+        // the layout of the tree, two value can be selected, 'orthogonal' or 'radial'
+        layout: 'orthogonal',
+        // value can be 'polyline'
+        edgeShape: 'curve',
+        edgeForkPosition: '50%',
+        // true | false | 'move' | 'scale', see module:component/helper/RoamController.
+        roam: false,
+        // Symbol size scale ratio in roam
+        nodeScaleRatio: 0.4,
+        // Default on center of graph
+        center: null,
+        zoom: 1,
+        orient: 'LR',
+        symbol: 'emptyCircle',
+        symbolSize: 7,
+        expandAndCollapse: true,
+        initialTreeDepth: 2,
+        lineStyle: {
+          color: '#ccc',
+          width: 1.5,
+          curveness: 0.5
+        },
+        itemStyle: {
+          color: 'lightsteelblue',
+          borderColor: '#c23531',
+          borderWidth: 1.5
+        },
+        label: {
+          show: true
+        },
+        animationEasing: 'linear',
+        animationDuration: 700,
+        animationDurationUpdate: 500
+      };
+      return TreeSeriesModel;
+    }(SeriesModel);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * Traverse the tree from bottom to top and do something
+     */
+    function eachAfter(root, callback, separation) {
+      var nodes = [root];
+      var next = [];
+      var node;
+
+      while (node = nodes.pop()) {
+        // jshint ignore:line
+        next.push(node);
+
+        if (node.isExpand) {
+          var children = node.children;
+
+          if (children.length) {
+            for (var i = 0; i < children.length; i++) {
+              nodes.push(children[i]);
+            }
+          }
+        }
+      }
+
+      while (node = next.pop()) {
+        // jshint ignore:line
+        callback(node, separation);
+      }
+    }
+    /**
+     * Traverse the tree from top to bottom and do something
+     */
+
+
+    function eachBefore(root, callback) {
+      var nodes = [root];
+      var node;
+
+      while (node = nodes.pop()) {
+        // jshint ignore:line
+        callback(node);
+
+        if (node.isExpand) {
+          var children = node.children;
+
+          if (children.length) {
+            for (var i = children.length - 1; i >= 0; i--) {
+              nodes.push(children[i]);
+            }
+          }
+        }
+      }
+    }
+
+    function treeLayout(ecModel, api) {
+      ecModel.eachSeriesByType('tree', function (seriesModel) {
+        commonLayout(seriesModel, api);
+      });
+    }
+
+    function commonLayout(seriesModel, api) {
+      var layoutInfo = getViewRect$1(seriesModel, api);
+      seriesModel.layoutInfo = layoutInfo;
+      var layout = seriesModel.get('layout');
+      var width = 0;
+      var height = 0;
+      var separation$1 = null;
+
+      if (layout === 'radial') {
+        width = 2 * Math.PI;
+        height = Math.min(layoutInfo.height, layoutInfo.width) / 2;
+        separation$1 = separation(function (node1, node2) {
+          return (node1.parentNode === node2.parentNode ? 1 : 2) / node1.depth;
+        });
+      } else {
+        width = layoutInfo.width;
+        height = layoutInfo.height;
+        separation$1 = separation();
+      }
+
+      var virtualRoot = seriesModel.getData().tree.root;
+      var realRoot = virtualRoot.children[0];
+
+      if (realRoot) {
+        init$2(virtualRoot);
+        eachAfter(realRoot, firstWalk, separation$1);
+        virtualRoot.hierNode.modifier = -realRoot.hierNode.prelim;
+        eachBefore(realRoot, secondWalk);
+        var left_1 = realRoot;
+        var right_1 = realRoot;
+        var bottom_1 = realRoot;
+        eachBefore(realRoot, function (node) {
+          var x = node.getLayout().x;
+
+          if (x < left_1.getLayout().x) {
+            left_1 = node;
+          }
+
+          if (x > right_1.getLayout().x) {
+            right_1 = node;
+          }
+
+          if (node.depth > bottom_1.depth) {
+            bottom_1 = node;
+          }
+        });
+        var delta = left_1 === right_1 ? 1 : separation$1(left_1, right_1) / 2;
+        var tx_1 = delta - left_1.getLayout().x;
+        var kx_1 = 0;
+        var ky_1 = 0;
+        var coorX_1 = 0;
+        var coorY_1 = 0;
+
+        if (layout === 'radial') {
+          kx_1 = width / (right_1.getLayout().x + delta + tx_1); // here we use (node.depth - 1), bucause the real root's depth is 1
+
+          ky_1 = height / (bottom_1.depth - 1 || 1);
+          eachBefore(realRoot, function (node) {
+            coorX_1 = (node.getLayout().x + tx_1) * kx_1;
+            coorY_1 = (node.depth - 1) * ky_1;
+            var finalCoor = radialCoordinate(coorX_1, coorY_1);
+            node.setLayout({
+              x: finalCoor.x,
+              y: finalCoor.y,
+              rawX: coorX_1,
+              rawY: coorY_1
+            }, true);
+          });
+        } else {
+          var orient_1 = seriesModel.getOrient();
+
+          if (orient_1 === 'RL' || orient_1 === 'LR') {
+            ky_1 = height / (right_1.getLayout().x + delta + tx_1);
+            kx_1 = width / (bottom_1.depth - 1 || 1);
+            eachBefore(realRoot, function (node) {
+              coorY_1 = (node.getLayout().x + tx_1) * ky_1;
+              coorX_1 = orient_1 === 'LR' ? (node.depth - 1) * kx_1 : width - (node.depth - 1) * kx_1;
+              node.setLayout({
+                x: coorX_1,
+                y: coorY_1
+              }, true);
+            });
+          } else if (orient_1 === 'TB' || orient_1 === 'BT') {
+            kx_1 = width / (right_1.getLayout().x + delta + tx_1);
+            ky_1 = height / (bottom_1.depth - 1 || 1);
+            eachBefore(realRoot, function (node) {
+              coorX_1 = (node.getLayout().x + tx_1) * kx_1;
+              coorY_1 = orient_1 === 'TB' ? (node.depth - 1) * ky_1 : height - (node.depth - 1) * ky_1;
+              node.setLayout({
+                x: coorX_1,
+                y: coorY_1
+              }, true);
+            });
+          }
+        }
+      }
+    }
+
+    function treeVisual(ecModel) {
+      ecModel.eachSeriesByType('tree', function (seriesModel) {
+        var data = seriesModel.getData();
+        var tree = data.tree;
+        tree.eachNode(function (node) {
+          var model = node.getModel(); // TODO Optimize
+
+          var style = model.getModel('itemStyle').getItemStyle();
+          var existsStyle = data.ensureUniqueItemVisual(node.dataIndex, 'style');
+          extend(existsStyle, style);
+        });
+      });
+    }
+
+    function installTreeAction(registers) {
+      registers.registerAction({
+        type: 'treeExpandAndCollapse',
+        event: 'treeExpandAndCollapse',
+        update: 'update'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'tree',
+          query: payload
+        }, function (seriesModel) {
+          var dataIndex = payload.dataIndex;
+          var tree = seriesModel.getData().tree;
+          var node = tree.getNodeByDataIndex(dataIndex);
+          node.isExpand = !node.isExpand;
+        });
+      });
+      registers.registerAction({
+        type: 'treeRoam',
+        event: 'treeRoam',
+        // Here we set 'none' instead of 'update', because roam action
+        // just need to update the transform matrix without having to recalculate
+        // the layout. So don't need to go through the whole update process, such
+        // as 'dataPrcocess', 'coordSystemUpdate', 'layout' and so on.
+        update: 'none'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'tree',
+          query: payload
+        }, function (seriesModel) {
+          var coordSys = seriesModel.coordinateSystem;
+          var res = updateCenterAndZoom(coordSys, payload);
+          seriesModel.setCenter && seriesModel.setCenter(res.center);
+          seriesModel.setZoom && seriesModel.setZoom(res.zoom);
+        });
+      });
+    }
+
+    function install$b(registers) {
+      registers.registerChartView(TreeView);
+      registers.registerSeriesModel(TreeSeriesModel);
+      registers.registerLayout(treeLayout);
+      registers.registerVisual(treeVisual);
+      installTreeAction(registers);
+    }
+
+    function retrieveTargetInfo(payload, validPayloadTypes, seriesModel) {
+      if (payload && indexOf(validPayloadTypes, payload.type) >= 0) {
+        var root = seriesModel.getData().tree.root;
+        var targetNode = payload.targetNode;
+
+        if (typeof targetNode === 'string') {
+          targetNode = root.getNodeById(targetNode);
+        }
+
+        if (targetNode && root.contains(targetNode)) {
+          return {
+            node: targetNode
+          };
+        }
+
+        var targetNodeId = payload.targetNodeId;
+
+        if (targetNodeId != null && (targetNode = root.getNodeById(targetNodeId))) {
+          return {
+            node: targetNode
+          };
+        }
+      }
+    } // Not includes the given node at the last item.
+
+    function getPathToRoot(node) {
+      var path = [];
+
+      while (node) {
+        node = node.parentNode;
+        node && path.push(node);
+      }
+
+      return path.reverse();
+    }
+    function aboveViewRoot(viewRoot, node) {
+      var viewPath = getPathToRoot(viewRoot);
+      return indexOf(viewPath, node) >= 0;
+    } // From root to the input node (the input node will be included).
+
+    function wrapTreePathInfo(node, seriesModel) {
+      var treePathInfo = [];
+
+      while (node) {
+        var nodeDataIndex = node.dataIndex;
+        treePathInfo.push({
+          name: node.name,
+          dataIndex: nodeDataIndex,
+          value: seriesModel.getRawValue(nodeDataIndex)
+        });
+        node = node.parentNode;
+      }
+
+      treePathInfo.reverse();
+      return treePathInfo;
+    }
+
+    var noop$1 = function () {};
+
+    var actionTypes = ['treemapZoomToNode', 'treemapRender', 'treemapMove'];
+    function installTreemapAction(registers) {
+      for (var i = 0; i < actionTypes.length; i++) {
+        registers.registerAction({
+          type: actionTypes[i],
+          update: 'updateView'
+        }, noop$1);
+      }
+
+      registers.registerAction({
+        type: 'treemapRootToNode',
+        update: 'updateView'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'treemap',
+          query: payload
+        }, handleRootToNode);
+
+        function handleRootToNode(model, index) {
+          var types = ['treemapZoomToNode', 'treemapRootToNode'];
+          var targetInfo = retrieveTargetInfo(payload, types, model);
+
+          if (targetInfo) {
+            var originViewRoot = model.getViewRoot();
+
+            if (originViewRoot) {
+              payload.direction = aboveViewRoot(originViewRoot, targetInfo.node) ? 'rollUp' : 'drillDown';
+            }
+
+            model.resetViewRoot(targetInfo.node);
+          }
+        }
+      });
+    }
+
+    function enableAriaDecalForTree(seriesModel) {
+      var data = seriesModel.getData();
+      var tree = data.tree;
+      var decalPaletteScope = {};
+      tree.eachNode(function (node) {
+        // Use decal of level 1 node
+        var current = node;
+
+        while (current && current.depth > 1) {
+          current = current.parentNode;
+        }
+
+        var decal = getDecalFromPalette(seriesModel.ecModel, current.name || current.dataIndex + '', decalPaletteScope);
+        node.setVisual('decal', decal);
+      });
+    }
+
+    var TreemapSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(TreemapSeriesModel, _super);
+
+      function TreemapSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TreemapSeriesModel.type;
+        _this.preventUsingHoverLayer = true;
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      TreemapSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        // Create a virtual root.
+        var root = {
+          name: option.name,
+          children: option.data
+        };
+        completeTreeValue(root);
+        var levels = option.levels || []; // Used in "visual priority" in `treemapVisual.js`.
+        // This way is a little tricky, must satisfy the precondition:
+        //   1. There is no `treeNode.getModel('itemStyle.xxx')` used.
+        //   2. The `Model.prototype.getModel()` will not use any clone-like way.
+
+        var designatedVisualItemStyle = this.designatedVisualItemStyle = {};
+        var designatedVisualModel = new Model({
+          itemStyle: designatedVisualItemStyle
+        }, this, ecModel);
+        levels = option.levels = setDefault(levels, ecModel);
+        var levelModels = map(levels || [], function (levelDefine) {
+          return new Model(levelDefine, designatedVisualModel, ecModel);
+        }, this); // Make sure always a new tree is created when setOption,
+        // in TreemapView, we check whether oldTree === newTree
+        // to choose mappings approach among old shapes and new shapes.
+
+        var tree = Tree.createTree(root, this, beforeLink);
+
+        function beforeLink(nodeData) {
+          nodeData.wrapMethod('getItemModel', function (model, idx) {
+            var node = tree.getNodeByDataIndex(idx);
+            var levelModel = levelModels[node.depth]; // If no levelModel, we also need `designatedVisualModel`.
+
+            model.parentModel = levelModel || designatedVisualModel;
+            return model;
+          });
+        }
+
+        return tree.data;
+      };
+
+      TreemapSeriesModel.prototype.optionUpdated = function () {
+        this.resetViewRoot();
+      };
+      /**
+       * @override
+       * @param {number} dataIndex
+       * @param {boolean} [mutipleSeries=false]
+       */
+
+
+      TreemapSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var data = this.getData();
+        var value = this.getRawValue(dataIndex);
+        var name = data.getName(dataIndex);
+        return createTooltipMarkup('nameValue', {
+          name: name,
+          value: value
+        });
+      };
+      /**
+       * Add tree path to tooltip param
+       *
+       * @override
+       * @param {number} dataIndex
+       * @return {Object}
+       */
+
+
+      TreemapSeriesModel.prototype.getDataParams = function (dataIndex) {
+        var params = _super.prototype.getDataParams.apply(this, arguments);
+
+        var node = this.getData().tree.getNodeByDataIndex(dataIndex);
+        params.treePathInfo = wrapTreePathInfo(node, this);
+        return params;
+      };
+      /**
+       * @public
+       * @param {Object} layoutInfo {
+       *                                x: containerGroup x
+       *                                y: containerGroup y
+       *                                width: containerGroup width
+       *                                height: containerGroup height
+       *                            }
+       */
+
+
+      TreemapSeriesModel.prototype.setLayoutInfo = function (layoutInfo) {
+        /**
+         * @readOnly
+         * @type {Object}
+         */
+        this.layoutInfo = this.layoutInfo || {};
+        extend(this.layoutInfo, layoutInfo);
+      };
+      /**
+       * @param  {string} id
+       * @return {number} index
+       */
+
+
+      TreemapSeriesModel.prototype.mapIdToIndex = function (id) {
+        // A feature is implemented:
+        // index is monotone increasing with the sequence of
+        // input id at the first time.
+        // This feature can make sure that each data item and its
+        // mapped color have the same index between data list and
+        // color list at the beginning, which is useful for user
+        // to adjust data-color mapping.
+
+        /**
+         * @private
+         * @type {Object}
+         */
+        var idIndexMap = this._idIndexMap;
+
+        if (!idIndexMap) {
+          idIndexMap = this._idIndexMap = createHashMap();
+          /**
+           * @private
+           * @type {number}
+           */
+
+          this._idIndexMapCount = 0;
+        }
+
+        var index = idIndexMap.get(id);
+
+        if (index == null) {
+          idIndexMap.set(id, index = this._idIndexMapCount++);
+        }
+
+        return index;
+      };
+
+      TreemapSeriesModel.prototype.getViewRoot = function () {
+        return this._viewRoot;
+      };
+
+      TreemapSeriesModel.prototype.resetViewRoot = function (viewRoot) {
+        viewRoot ? this._viewRoot = viewRoot : viewRoot = this._viewRoot;
+        var root = this.getRawData().tree.root;
+
+        if (!viewRoot || viewRoot !== root && !root.contains(viewRoot)) {
+          this._viewRoot = root;
+        }
+      };
+
+      TreemapSeriesModel.prototype.enableAriaDecal = function () {
+        enableAriaDecalForTree(this);
+      };
+
+      TreemapSeriesModel.type = 'series.treemap';
+      TreemapSeriesModel.layoutMode = 'box';
+      TreemapSeriesModel.defaultOption = {
+        // Disable progressive rendering
+        progressive: 0,
+        // size: ['80%', '80%'],            // deprecated, compatible with ec2.
+        left: 'center',
+        top: 'middle',
+        width: '80%',
+        height: '80%',
+        sort: true,
+        clipWindow: 'origin',
+        squareRatio: 0.5 * (1 + Math.sqrt(5)),
+        leafDepth: null,
+        drillDownIcon: '▶',
+        // to align specialized icon. ▷▶❒❐▼✚
+        zoomToNodeRatio: 0.32 * 0.32,
+        roam: true,
+        nodeClick: 'zoomToNode',
+        animation: true,
+        animationDurationUpdate: 900,
+        animationEasing: 'quinticInOut',
+        breadcrumb: {
+          show: true,
+          height: 22,
+          left: 'center',
+          top: 'bottom',
+          // right
+          // bottom
+          emptyItemWidth: 25,
+          itemStyle: {
+            color: 'rgba(0,0,0,0.7)',
+            textStyle: {
+              color: '#fff'
+            }
+          }
+        },
+        label: {
+          show: true,
+          // Do not use textDistance, for ellipsis rect just the same as treemap node rect.
+          distance: 0,
+          padding: 5,
+          position: 'inside',
+          // formatter: null,
+          color: '#fff',
+          overflow: 'truncate' // align
+          // verticalAlign
+
+        },
+        upperLabel: {
+          show: false,
+          position: [0, '50%'],
+          height: 20,
+          // formatter: null,
+          // color: '#fff',
+          overflow: 'truncate',
+          // align: null,
+          verticalAlign: 'middle'
+        },
+        itemStyle: {
+          color: null,
+          colorAlpha: null,
+          colorSaturation: null,
+          borderWidth: 0,
+          gapWidth: 0,
+          borderColor: '#fff',
+          borderColorSaturation: null // If specified, borderColor will be ineffective, and the
+          // border color is evaluated by color of current node and
+          // borderColorSaturation.
+
+        },
+        emphasis: {
+          upperLabel: {
+            show: true,
+            position: [0, '50%'],
+            ellipsis: true,
+            verticalAlign: 'middle'
+          }
+        },
+        visualDimension: 0,
+        visualMin: null,
+        visualMax: null,
+        color: [],
+        // level[n].color (if necessary).
+        // + Specify color list of each level. level[0].color would be global
+        // color list if not specified. (see method `setDefault`).
+        // + But set as a empty array to forbid fetch color from global palette
+        // when using nodeModel.get('color'), otherwise nodes on deep level
+        // will always has color palette set and are not able to inherit color
+        // from parent node.
+        // + TreemapSeries.color can not be set as 'none', otherwise effect
+        // legend color fetching (see seriesColor.js).
+        colorAlpha: null,
+        colorSaturation: null,
+        colorMappingBy: 'index',
+        visibleMin: 10,
+        // be rendered. Only works when sort is 'asc' or 'desc'.
+        childrenVisibleMin: null,
+        // grandchildren will not show.
+        // Why grandchildren? If not grandchildren but children,
+        // some siblings show children and some not,
+        // the appearance may be mess and not consistent,
+        levels: [] // Each item: {
+        //     visibleMin, itemStyle, visualDimension, label
+        // }
+        // data: {
+        //      value: [],
+        //      children: [],
+        //      link: 'http://xxx.xxx.xxx',
+        //      target: 'blank' or 'self'
+        // }
+
+      };
+      return TreemapSeriesModel;
+    }(SeriesModel);
+    /**
+     * @param {Object} dataNode
+     */
+
+
+    function completeTreeValue(dataNode) {
+      // Postorder travel tree.
+      // If value of none-leaf node is not set,
+      // calculate it by suming up the value of all children.
+      var sum = 0;
+      each(dataNode.children, function (child) {
+        completeTreeValue(child);
+        var childValue = child.value;
+        isArray(childValue) && (childValue = childValue[0]);
+        sum += childValue;
+      });
+      var thisValue = dataNode.value;
+
+      if (isArray(thisValue)) {
+        thisValue = thisValue[0];
+      }
+
+      if (thisValue == null || isNaN(thisValue)) {
+        thisValue = sum;
+      } // Value should not less than 0.
+
+
+      if (thisValue < 0) {
+        thisValue = 0;
+      }
+
+      isArray(dataNode.value) ? dataNode.value[0] = thisValue : dataNode.value = thisValue;
+    }
+    /**
+     * set default to level configuration
+     */
+
+
+    function setDefault(levels, ecModel) {
+      var globalColorList = normalizeToArray(ecModel.get('color'));
+      var globalDecalList = normalizeToArray(ecModel.get(['aria', 'decal', 'decals']));
+
+      if (!globalColorList) {
+        return;
+      }
+
+      levels = levels || [];
+      var hasColorDefine;
+      var hasDecalDefine;
+      each(levels, function (levelDefine) {
+        var model = new Model(levelDefine);
+        var modelColor = model.get('color');
+        var modelDecal = model.get('decal');
+
+        if (model.get(['itemStyle', 'color']) || modelColor && modelColor !== 'none') {
+          hasColorDefine = true;
+        }
+
+        if (model.get(['itemStyle', 'decal']) || modelDecal && modelDecal !== 'none') {
+          hasDecalDefine = true;
+        }
+      });
+      var level0 = levels[0] || (levels[0] = {});
+
+      if (!hasColorDefine) {
+        level0.color = globalColorList.slice();
+      }
+
+      if (!hasDecalDefine && globalDecalList) {
+        level0.decal = globalDecalList.slice();
+      }
+
+      return levels;
+    }
+
+    var TEXT_PADDING = 8;
+    var ITEM_GAP = 8;
+    var ARRAY_LENGTH = 5;
+
+    var Breadcrumb =
+    /** @class */
+    function () {
+      function Breadcrumb(containerGroup) {
+        this.group = new Group();
+        containerGroup.add(this.group);
+      }
+
+      Breadcrumb.prototype.render = function (seriesModel, api, targetNode, onSelect) {
+        var model = seriesModel.getModel('breadcrumb');
+        var thisGroup = this.group;
+        thisGroup.removeAll();
+
+        if (!model.get('show') || !targetNode) {
+          return;
+        }
+
+        var normalStyleModel = model.getModel('itemStyle'); // let emphasisStyleModel = model.getModel('emphasis.itemStyle');
+
+        var textStyleModel = normalStyleModel.getModel('textStyle');
+        var layoutParam = {
+          pos: {
+            left: model.get('left'),
+            right: model.get('right'),
+            top: model.get('top'),
+            bottom: model.get('bottom')
+          },
+          box: {
+            width: api.getWidth(),
+            height: api.getHeight()
+          },
+          emptyItemWidth: model.get('emptyItemWidth'),
+          totalWidth: 0,
+          renderList: []
+        };
+
+        this._prepare(targetNode, layoutParam, textStyleModel);
+
+        this._renderContent(seriesModel, layoutParam, normalStyleModel, textStyleModel, onSelect);
+
+        positionElement(thisGroup, layoutParam.pos, layoutParam.box);
+      };
+      /**
+       * Prepare render list and total width
+       * @private
+       */
+
+
+      Breadcrumb.prototype._prepare = function (targetNode, layoutParam, textStyleModel) {
+        for (var node = targetNode; node; node = node.parentNode) {
+          var text = convertOptionIdName(node.getModel().get('name'), '');
+          var textRect = textStyleModel.getTextRect(text);
+          var itemWidth = Math.max(textRect.width + TEXT_PADDING * 2, layoutParam.emptyItemWidth);
+          layoutParam.totalWidth += itemWidth + ITEM_GAP;
+          layoutParam.renderList.push({
+            node: node,
+            text: text,
+            width: itemWidth
+          });
+        }
+      };
+      /**
+       * @private
+       */
+
+
+      Breadcrumb.prototype._renderContent = function (seriesModel, layoutParam, normalStyleModel, textStyleModel, onSelect) {
+        // Start rendering.
+        var lastX = 0;
+        var emptyItemWidth = layoutParam.emptyItemWidth;
+        var height = seriesModel.get(['breadcrumb', 'height']);
+        var availableSize = getAvailableSize(layoutParam.pos, layoutParam.box);
+        var totalWidth = layoutParam.totalWidth;
+        var renderList = layoutParam.renderList;
+
+        for (var i = renderList.length - 1; i >= 0; i--) {
+          var item = renderList[i];
+          var itemNode = item.node;
+          var itemWidth = item.width;
+          var text = item.text; // Hdie text and shorten width if necessary.
+
+          if (totalWidth > availableSize.width) {
+            totalWidth -= itemWidth - emptyItemWidth;
+            itemWidth = emptyItemWidth;
+            text = null;
+          }
+
+          var el = new Polygon({
+            shape: {
+              points: makeItemPoints(lastX, 0, itemWidth, height, i === renderList.length - 1, i === 0)
+            },
+            style: defaults(normalStyleModel.getItemStyle(), {
+              lineJoin: 'bevel'
+            }),
+            textContent: new ZRText({
+              style: {
+                text: text,
+                fill: textStyleModel.getTextColor(),
+                font: textStyleModel.getFont()
+              }
+            }),
+            textConfig: {
+              position: 'inside'
+            },
+            z: 10,
+            onclick: curry(onSelect, itemNode)
+          });
+          el.disableLabelAnimation = true;
+          this.group.add(el);
+          packEventData(el, seriesModel, itemNode);
+          lastX += itemWidth + ITEM_GAP;
+        }
+      };
+
+      Breadcrumb.prototype.remove = function () {
+        this.group.removeAll();
+      };
+
+      return Breadcrumb;
+    }();
+
+    function makeItemPoints(x, y, itemWidth, itemHeight, head, tail) {
+      var points = [[head ? x : x - ARRAY_LENGTH, y], [x + itemWidth, y], [x + itemWidth, y + itemHeight], [head ? x : x - ARRAY_LENGTH, y + itemHeight]];
+      !tail && points.splice(2, 0, [x + itemWidth + ARRAY_LENGTH, y + itemHeight / 2]);
+      !head && points.push([x, y + itemHeight / 2]);
+      return points;
+    } // Package custom mouse event.
+
+
+    function packEventData(el, seriesModel, itemNode) {
+      getECData(el).eventData = {
+        componentType: 'series',
+        componentSubType: 'treemap',
+        componentIndex: seriesModel.componentIndex,
+        seriesIndex: seriesModel.componentIndex,
+        seriesName: seriesModel.name,
+        seriesType: 'treemap',
+        selfType: 'breadcrumb',
+        nodeData: {
+          dataIndex: itemNode && itemNode.dataIndex,
+          name: itemNode && itemNode.name
+        },
+        treePathInfo: itemNode && wrapTreePathInfo(itemNode, seriesModel)
+      };
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * Animate multiple elements with a single done-callback.
+     *
+     * @example
+     *  animation
+     *      .createWrap()
+     *      .add(el1, {x: 10, y: 10})
+     *      .add(el2, {shape: {width: 500}, style: {fill: 'red'}}, 400)
+     *      .done(function () { // done })
+     *      .start('cubicOut');
+     */
+    var AnimationWrap =
+    /** @class */
+    function () {
+      function AnimationWrap() {
+        this._storage = [];
+        this._elExistsMap = {};
+      }
+      /**
+       * Caution: a el can only be added once, otherwise 'done'
+       * might not be called. This method checks this (by el.id),
+       * suppresses adding and returns false when existing el found.
+       *
+       * @return Whether adding succeeded.
+       */
+
+
+      AnimationWrap.prototype.add = function (el, target, duration, delay, easing) {
+        if (this._elExistsMap[el.id]) {
+          return false;
+        }
+
+        this._elExistsMap[el.id] = true;
+
+        this._storage.push({
+          el: el,
+          target: target,
+          duration: duration,
+          delay: delay,
+          easing: easing
+        });
+
+        return true;
+      };
+      /**
+       * Only execute when animation done/aborted.
+       */
+
+
+      AnimationWrap.prototype.finished = function (callback) {
+        this._finishedCallback = callback;
+        return this;
+      };
+      /**
+       * Will stop exist animation firstly.
+       */
+
+
+      AnimationWrap.prototype.start = function () {
+        var _this = this;
+
+        var count = this._storage.length;
+
+        var checkTerminate = function () {
+          count--;
+
+          if (count <= 0) {
+            // Guard.
+            _this._storage.length = 0;
+            _this._elExistsMap = {};
+            _this._finishedCallback && _this._finishedCallback();
+          }
+        };
+
+        for (var i = 0, len = this._storage.length; i < len; i++) {
+          var item = this._storage[i];
+          item.el.animateTo(item.target, {
+            duration: item.duration,
+            delay: item.delay,
+            easing: item.easing,
+            setToFinal: true,
+            done: checkTerminate,
+            aborted: checkTerminate
+          });
+        }
+
+        return this;
+      };
+
+      return AnimationWrap;
+    }();
+
+    function createWrap() {
+      return new AnimationWrap();
+    }
+
+    var Group$1 = Group;
+    var Rect$1 = Rect;
+    var DRAG_THRESHOLD = 3;
+    var PATH_LABEL_NOAMAL = 'label';
+    var PATH_UPPERLABEL_NORMAL = 'upperLabel';
+    var Z_BASE = 10; // Should bigger than every z.
+
+    var Z_BG = 1;
+    var Z_CONTENT = 2;
+    var getStateItemStyle = makeStyleMapper([['fill', 'color'], // `borderColor` and `borderWidth` has been occupied,
+    // so use `stroke` to indicate the stroke of the rect.
+    ['stroke', 'strokeColor'], ['lineWidth', 'strokeWidth'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+    // So do not transfer decal directly.
+    ]);
+
+    var getItemStyleNormal = function (model) {
+      // Normal style props should include emphasis style props.
+      var itemStyle = getStateItemStyle(model); // Clear styles set by emphasis.
+
+      itemStyle.stroke = itemStyle.fill = itemStyle.lineWidth = null;
+      return itemStyle;
+    };
+
+    var inner$9 = makeInner();
+
+    var TreemapView =
+    /** @class */
+    function (_super) {
+      __extends(TreemapView, _super);
+
+      function TreemapView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TreemapView.type;
+        _this._state = 'ready';
+        _this._storage = createStorage();
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      TreemapView.prototype.render = function (seriesModel, ecModel, api, payload) {
+        var models = ecModel.findComponents({
+          mainType: 'series',
+          subType: 'treemap',
+          query: payload
+        });
+
+        if (indexOf(models, seriesModel) < 0) {
+          return;
+        }
+
+        this.seriesModel = seriesModel;
+        this.api = api;
+        this.ecModel = ecModel;
+        var types = ['treemapZoomToNode', 'treemapRootToNode'];
+        var targetInfo = retrieveTargetInfo(payload, types, seriesModel);
+        var payloadType = payload && payload.type;
+        var layoutInfo = seriesModel.layoutInfo;
+        var isInit = !this._oldTree;
+        var thisStorage = this._storage; // Mark new root when action is treemapRootToNode.
+
+        var reRoot = payloadType === 'treemapRootToNode' && targetInfo && thisStorage ? {
+          rootNodeGroup: thisStorage.nodeGroup[targetInfo.node.getRawIndex()],
+          direction: payload.direction
+        } : null;
+
+        var containerGroup = this._giveContainerGroup(layoutInfo);
+
+        var renderResult = this._doRender(containerGroup, seriesModel, reRoot);
+
+        !isInit && (!payloadType || payloadType === 'treemapZoomToNode' || payloadType === 'treemapRootToNode') ? this._doAnimation(containerGroup, renderResult, seriesModel, reRoot) : renderResult.renderFinally();
+
+        this._resetController(api);
+
+        this._renderBreadcrumb(seriesModel, api, targetInfo);
+      };
+
+      TreemapView.prototype._giveContainerGroup = function (layoutInfo) {
+        var containerGroup = this._containerGroup;
+
+        if (!containerGroup) {
+          // FIXME
+          // 加一层containerGroup是为了clip，但是现在clip功能并没有实现。
+          containerGroup = this._containerGroup = new Group$1();
+
+          this._initEvents(containerGroup);
+
+          this.group.add(containerGroup);
+        }
+
+        containerGroup.x = layoutInfo.x;
+        containerGroup.y = layoutInfo.y;
+        return containerGroup;
+      };
+
+      TreemapView.prototype._doRender = function (containerGroup, seriesModel, reRoot) {
+        var thisTree = seriesModel.getData().tree;
+        var oldTree = this._oldTree; // Clear last shape records.
+
+        var lastsForAnimation = createStorage();
+        var thisStorage = createStorage();
+        var oldStorage = this._storage;
+        var willInvisibleEls = [];
+
+        function doRenderNode(thisNode, oldNode, parentGroup, depth) {
+          return renderNode(seriesModel, thisStorage, oldStorage, reRoot, lastsForAnimation, willInvisibleEls, thisNode, oldNode, parentGroup, depth);
+        } // Notice: when thisTree and oldTree are the same tree (see list.cloneShallow),
+        // the oldTree is actually losted, so we can not find all of the old graphic
+        // elements from tree. So we use this stragegy: make element storage, move
+        // from old storage to new storage, clear old storage.
+
+
+        dualTravel(thisTree.root ? [thisTree.root] : [], oldTree && oldTree.root ? [oldTree.root] : [], containerGroup, thisTree === oldTree || !oldTree, 0); // Process all removing.
+
+        var willDeleteEls = clearStorage(oldStorage);
+        this._oldTree = thisTree;
+        this._storage = thisStorage;
+        return {
+          lastsForAnimation: lastsForAnimation,
+          willDeleteEls: willDeleteEls,
+          renderFinally: renderFinally
+        };
+
+        function dualTravel(thisViewChildren, oldViewChildren, parentGroup, sameTree, depth) {
+          // When 'render' is triggered by action,
+          // 'this' and 'old' may be the same tree,
+          // we use rawIndex in that case.
+          if (sameTree) {
+            oldViewChildren = thisViewChildren;
+            each(thisViewChildren, function (child, index) {
+              !child.isRemoved() && processNode(index, index);
+            });
+          } // Diff hierarchically (diff only in each subtree, but not whole).
+          // because, consistency of view is important.
+          else {
+              new DataDiffer(oldViewChildren, thisViewChildren, getKey, getKey).add(processNode).update(processNode).remove(curry(processNode, null)).execute();
+            }
+
+          function getKey(node) {
+            // Identify by name or raw index.
+            return node.getId();
+          }
+
+          function processNode(newIndex, oldIndex) {
+            var thisNode = newIndex != null ? thisViewChildren[newIndex] : null;
+            var oldNode = oldIndex != null ? oldViewChildren[oldIndex] : null;
+            var group = doRenderNode(thisNode, oldNode, parentGroup, depth);
+            group && dualTravel(thisNode && thisNode.viewChildren || [], oldNode && oldNode.viewChildren || [], group, sameTree, depth + 1);
+          }
+        }
+
+        function clearStorage(storage) {
+          var willDeleteEls = createStorage();
+          storage && each(storage, function (store, storageName) {
+            var delEls = willDeleteEls[storageName];
+            each(store, function (el) {
+              el && (delEls.push(el), inner$9(el).willDelete = true);
+            });
+          });
+          return willDeleteEls;
+        }
+
+        function renderFinally() {
+          each(willDeleteEls, function (els) {
+            each(els, function (el) {
+              el.parent && el.parent.remove(el);
+            });
+          });
+          each(willInvisibleEls, function (el) {
+            el.invisible = true; // Setting invisible is for optimizing, so no need to set dirty,
+            // just mark as invisible.
+
+            el.dirty();
+          });
+        }
+      };
+
+      TreemapView.prototype._doAnimation = function (containerGroup, renderResult, seriesModel, reRoot) {
+        if (!seriesModel.get('animation')) {
+          return;
+        }
+
+        var durationOption = seriesModel.get('animationDurationUpdate');
+        var easingOption = seriesModel.get('animationEasing'); // TODO: do not support function until necessary.
+
+        var duration = (isFunction(durationOption) ? 0 : durationOption) || 0;
+        var easing = (isFunction(easingOption) ? null : easingOption) || 'cubicOut';
+        var animationWrap = createWrap(); // Make delete animations.
+
+        each(renderResult.willDeleteEls, function (store, storageName) {
+          each(store, function (el, rawIndex) {
+            if (el.invisible) {
+              return;
+            }
+
+            var parent = el.parent; // Always has parent, and parent is nodeGroup.
+
+            var target;
+            var innerStore = inner$9(parent);
+
+            if (reRoot && reRoot.direction === 'drillDown') {
+              target = parent === reRoot.rootNodeGroup // This is the content element of view root.
+              // Only `content` will enter this branch, because
+              // `background` and `nodeGroup` will not be deleted.
+              ? {
+                shape: {
+                  x: 0,
+                  y: 0,
+                  width: innerStore.nodeWidth,
+                  height: innerStore.nodeHeight
+                },
+                style: {
+                  opacity: 0
+                }
+              } // Others.
+              : {
+                style: {
+                  opacity: 0
+                }
+              };
+            } else {
+              var targetX = 0;
+              var targetY = 0;
+
+              if (!innerStore.willDelete) {
+                // Let node animate to right-bottom corner, cooperating with fadeout,
+                // which is appropriate for user understanding.
+                // Divided by 2 for reRoot rolling up effect.
+                targetX = innerStore.nodeWidth / 2;
+                targetY = innerStore.nodeHeight / 2;
+              }
+
+              target = storageName === 'nodeGroup' ? {
+                x: targetX,
+                y: targetY,
+                style: {
+                  opacity: 0
+                }
+              } : {
+                shape: {
+                  x: targetX,
+                  y: targetY,
+                  width: 0,
+                  height: 0
+                },
+                style: {
+                  opacity: 0
+                }
+              };
+            } // TODO: do not support delay until necessary.
+
+
+            target && animationWrap.add(el, target, duration, 0, easing);
+          });
+        }); // Make other animations
+
+        each(this._storage, function (store, storageName) {
+          each(store, function (el, rawIndex) {
+            var last = renderResult.lastsForAnimation[storageName][rawIndex];
+            var target = {};
+
+            if (!last) {
+              return;
+            }
+
+            if (el instanceof Group) {
+              if (last.oldX != null) {
+                target.x = el.x;
+                target.y = el.y;
+                el.x = last.oldX;
+                el.y = last.oldY;
+              }
+            } else {
+              if (last.oldShape) {
+                target.shape = extend({}, el.shape);
+                el.setShape(last.oldShape);
+              }
+
+              if (last.fadein) {
+                el.setStyle('opacity', 0);
+                target.style = {
+                  opacity: 1
+                };
+              } // When animation is stopped for succedent animation starting,
+              // el.style.opacity might not be 1
+              else if (el.style.opacity !== 1) {
+                  target.style = {
+                    opacity: 1
+                  };
+                }
+            }
+
+            animationWrap.add(el, target, duration, 0, easing);
+          });
+        }, this);
+        this._state = 'animating';
+        animationWrap.finished(bind(function () {
+          this._state = 'ready';
+          renderResult.renderFinally();
+        }, this)).start();
+      };
+
+      TreemapView.prototype._resetController = function (api) {
+        var controller = this._controller; // Init controller.
+
+        if (!controller) {
+          controller = this._controller = new RoamController(api.getZr());
+          controller.enable(this.seriesModel.get('roam'));
+          controller.on('pan', bind(this._onPan, this));
+          controller.on('zoom', bind(this._onZoom, this));
+        }
+
+        var rect = new BoundingRect(0, 0, api.getWidth(), api.getHeight());
+        controller.setPointerChecker(function (e, x, y) {
+          return rect.contain(x, y);
+        });
+      };
+
+      TreemapView.prototype._clearController = function () {
+        var controller = this._controller;
+
+        if (controller) {
+          controller.dispose();
+          controller = null;
+        }
+      };
+
+      TreemapView.prototype._onPan = function (e) {
+        if (this._state !== 'animating' && (Math.abs(e.dx) > DRAG_THRESHOLD || Math.abs(e.dy) > DRAG_THRESHOLD)) {
+          // These param must not be cached.
+          var root = this.seriesModel.getData().tree.root;
+
+          if (!root) {
+            return;
+          }
+
+          var rootLayout = root.getLayout();
+
+          if (!rootLayout) {
+            return;
+          }
+
+          this.api.dispatchAction({
+            type: 'treemapMove',
+            from: this.uid,
+            seriesId: this.seriesModel.id,
+            rootRect: {
+              x: rootLayout.x + e.dx,
+              y: rootLayout.y + e.dy,
+              width: rootLayout.width,
+              height: rootLayout.height
+            }
+          });
+        }
+      };
+
+      TreemapView.prototype._onZoom = function (e) {
+        var mouseX = e.originX;
+        var mouseY = e.originY;
+
+        if (this._state !== 'animating') {
+          // These param must not be cached.
+          var root = this.seriesModel.getData().tree.root;
+
+          if (!root) {
+            return;
+          }
+
+          var rootLayout = root.getLayout();
+
+          if (!rootLayout) {
+            return;
+          }
+
+          var rect = new BoundingRect(rootLayout.x, rootLayout.y, rootLayout.width, rootLayout.height);
+          var layoutInfo = this.seriesModel.layoutInfo; // Transform mouse coord from global to containerGroup.
+
+          mouseX -= layoutInfo.x;
+          mouseY -= layoutInfo.y; // Scale root bounding rect.
+
+          var m = create$1();
+          translate(m, m, [-mouseX, -mouseY]);
+          scale$1(m, m, [e.scale, e.scale]);
+          translate(m, m, [mouseX, mouseY]);
+          rect.applyTransform(m);
+          this.api.dispatchAction({
+            type: 'treemapRender',
+            from: this.uid,
+            seriesId: this.seriesModel.id,
+            rootRect: {
+              x: rect.x,
+              y: rect.y,
+              width: rect.width,
+              height: rect.height
+            }
+          });
+        }
+      };
+
+      TreemapView.prototype._initEvents = function (containerGroup) {
+        var _this = this;
+
+        containerGroup.on('click', function (e) {
+          if (_this._state !== 'ready') {
+            return;
+          }
+
+          var nodeClick = _this.seriesModel.get('nodeClick', true);
+
+          if (!nodeClick) {
+            return;
+          }
+
+          var targetInfo = _this.findTarget(e.offsetX, e.offsetY);
+
+          if (!targetInfo) {
+            return;
+          }
+
+          var node = targetInfo.node;
+
+          if (node.getLayout().isLeafRoot) {
+            _this._rootToNode(targetInfo);
+          } else {
+            if (nodeClick === 'zoomToNode') {
+              _this._zoomToNode(targetInfo);
+            } else if (nodeClick === 'link') {
+              var itemModel = node.hostTree.data.getItemModel(node.dataIndex);
+              var link = itemModel.get('link', true);
+              var linkTarget = itemModel.get('target', true) || 'blank';
+              link && windowOpen(link, linkTarget);
+            }
+          }
+        }, this);
+      };
+
+      TreemapView.prototype._renderBreadcrumb = function (seriesModel, api, targetInfo) {
+        var _this = this;
+
+        if (!targetInfo) {
+          targetInfo = seriesModel.get('leafDepth', true) != null ? {
+            node: seriesModel.getViewRoot()
+          } // FIXME
+          // better way?
+          // Find breadcrumb tail on center of containerGroup.
+          : this.findTarget(api.getWidth() / 2, api.getHeight() / 2);
+
+          if (!targetInfo) {
+            targetInfo = {
+              node: seriesModel.getData().tree.root
+            };
+          }
+        }
+
+        (this._breadcrumb || (this._breadcrumb = new Breadcrumb(this.group))).render(seriesModel, api, targetInfo.node, function (node) {
+          if (_this._state !== 'animating') {
+            aboveViewRoot(seriesModel.getViewRoot(), node) ? _this._rootToNode({
+              node: node
+            }) : _this._zoomToNode({
+              node: node
+            });
+          }
+        });
+      };
+      /**
+       * @override
+       */
+
+
+      TreemapView.prototype.remove = function () {
+        this._clearController();
+
+        this._containerGroup && this._containerGroup.removeAll();
+        this._storage = createStorage();
+        this._state = 'ready';
+        this._breadcrumb && this._breadcrumb.remove();
+      };
+
+      TreemapView.prototype.dispose = function () {
+        this._clearController();
+      };
+
+      TreemapView.prototype._zoomToNode = function (targetInfo) {
+        this.api.dispatchAction({
+          type: 'treemapZoomToNode',
+          from: this.uid,
+          seriesId: this.seriesModel.id,
+          targetNode: targetInfo.node
+        });
+      };
+
+      TreemapView.prototype._rootToNode = function (targetInfo) {
+        this.api.dispatchAction({
+          type: 'treemapRootToNode',
+          from: this.uid,
+          seriesId: this.seriesModel.id,
+          targetNode: targetInfo.node
+        });
+      };
+      /**
+       * @public
+       * @param {number} x Global coord x.
+       * @param {number} y Global coord y.
+       * @return {Object} info If not found, return undefined;
+       * @return {number} info.node Target node.
+       * @return {number} info.offsetX x refer to target node.
+       * @return {number} info.offsetY y refer to target node.
+       */
+
+
+      TreemapView.prototype.findTarget = function (x, y) {
+        var targetInfo;
+        var viewRoot = this.seriesModel.getViewRoot();
+        viewRoot.eachNode({
+          attr: 'viewChildren',
+          order: 'preorder'
+        }, function (node) {
+          var bgEl = this._storage.background[node.getRawIndex()]; // If invisible, there might be no element.
+
+
+          if (bgEl) {
+            var point = bgEl.transformCoordToLocal(x, y);
+            var shape = bgEl.shape; // For performance consideration, dont use 'getBoundingRect'.
+
+            if (shape.x <= point[0] && point[0] <= shape.x + shape.width && shape.y <= point[1] && point[1] <= shape.y + shape.height) {
+              targetInfo = {
+                node: node,
+                offsetX: point[0],
+                offsetY: point[1]
+              };
+            } else {
+              return false; // Suppress visit subtree.
+            }
+          }
+        }, this);
+        return targetInfo;
+      };
+
+      TreemapView.type = 'treemap';
+      return TreemapView;
+    }(ChartView);
+    /**
+     * @inner
+     */
+
+
+    function createStorage() {
+      return {
+        nodeGroup: [],
+        background: [],
+        content: []
+      };
+    }
+    /**
+     * @inner
+     * @return Return undefined means do not travel further.
+     */
+
+
+    function renderNode(seriesModel, thisStorage, oldStorage, reRoot, lastsForAnimation, willInvisibleEls, thisNode, oldNode, parentGroup, depth) {
+      // Whether under viewRoot.
+      if (!thisNode) {
+        // Deleting nodes will be performed finally. This method just find
+        // element from old storage, or create new element, set them to new
+        // storage, and set styles.
+        return;
+      } // -------------------------------------------------------------------
+      // Start of closure variables available in "Procedures in renderNode".
+
+
+      var thisLayout = thisNode.getLayout();
+      var data = seriesModel.getData();
+      var nodeModel = thisNode.getModel(); // Only for enabling highlight/downplay. Clear firstly.
+      // Because some node will not be rendered.
+
+      data.setItemGraphicEl(thisNode.dataIndex, null);
+
+      if (!thisLayout || !thisLayout.isInView) {
+        return;
+      }
+
+      var thisWidth = thisLayout.width;
+      var thisHeight = thisLayout.height;
+      var borderWidth = thisLayout.borderWidth;
+      var thisInvisible = thisLayout.invisible;
+      var thisRawIndex = thisNode.getRawIndex();
+      var oldRawIndex = oldNode && oldNode.getRawIndex();
+      var thisViewChildren = thisNode.viewChildren;
+      var upperHeight = thisLayout.upperHeight;
+      var isParent = thisViewChildren && thisViewChildren.length;
+      var itemStyleNormalModel = nodeModel.getModel('itemStyle');
+      var itemStyleEmphasisModel = nodeModel.getModel(['emphasis', 'itemStyle']);
+      var itemStyleBlurModel = nodeModel.getModel(['blur', 'itemStyle']);
+      var itemStyleSelectModel = nodeModel.getModel(['select', 'itemStyle']);
+      var borderRadius = itemStyleNormalModel.get('borderRadius') || 0; // End of closure ariables available in "Procedures in renderNode".
+      // -----------------------------------------------------------------
+      // Node group
+
+      var group = giveGraphic('nodeGroup', Group$1);
+
+      if (!group) {
+        return;
+      }
+
+      parentGroup.add(group); // x,y are not set when el is above view root.
+
+      group.x = thisLayout.x || 0;
+      group.y = thisLayout.y || 0;
+      group.markRedraw();
+      inner$9(group).nodeWidth = thisWidth;
+      inner$9(group).nodeHeight = thisHeight;
+
+      if (thisLayout.isAboveViewRoot) {
+        return group;
+      } // Background
+
+
+      var bg = giveGraphic('background', Rect$1, depth, Z_BG);
+      bg && renderBackground(group, bg, isParent && thisLayout.upperLabelHeight);
+      var focus = nodeModel.get(['emphasis', 'focus']);
+      var blurScope = nodeModel.get(['emphasis', 'blurScope']);
+      var focusDataIndices = focus === 'ancestor' ? thisNode.getAncestorsIndices() : focus === 'descendant' ? thisNode.getDescendantIndices() : null; // No children, render content.
+
+      if (isParent) {
+        // Because of the implementation about "traverse" in graphic hover style, we
+        // can not set hover listener on the "group" of non-leaf node. Otherwise the
+        // hover event from the descendents will be listenered.
+        if (isHighDownDispatcher(group)) {
+          setAsHighDownDispatcher(group, false);
+        }
+
+        if (bg) {
+          setAsHighDownDispatcher(bg, true); // Only for enabling highlight/downplay.
+
+          data.setItemGraphicEl(thisNode.dataIndex, bg);
+          enableHoverFocus(bg, focusDataIndices || focus, blurScope);
+        }
+      } else {
+        var content = giveGraphic('content', Rect$1, depth, Z_CONTENT);
+        content && renderContent(group, content);
+
+        if (bg && isHighDownDispatcher(bg)) {
+          setAsHighDownDispatcher(bg, false);
+        }
+
+        setAsHighDownDispatcher(group, true); // Only for enabling highlight/downplay.
+
+        data.setItemGraphicEl(thisNode.dataIndex, group);
+        enableHoverFocus(group, focusDataIndices || focus, blurScope);
+      }
+
+      return group; // ----------------------------
+      // | Procedures in renderNode |
+      // ----------------------------
+
+      function renderBackground(group, bg, useUpperLabel) {
+        var ecData = getECData(bg); // For tooltip.
+
+        ecData.dataIndex = thisNode.dataIndex;
+        ecData.seriesIndex = seriesModel.seriesIndex;
+        bg.setShape({
+          x: 0,
+          y: 0,
+          width: thisWidth,
+          height: thisHeight,
+          r: borderRadius
+        });
+
+        if (thisInvisible) {
+          // If invisible, do not set visual, otherwise the element will
+          // change immediately before animation. We think it is OK to
+          // remain its origin color when moving out of the view window.
+          processInvisible(bg);
+        } else {
+          bg.invisible = false;
+          var style = thisNode.getVisual('style');
+          var visualBorderColor = style.stroke;
+          var normalStyle = getItemStyleNormal(itemStyleNormalModel);
+          normalStyle.fill = visualBorderColor;
+          var emphasisStyle = getStateItemStyle(itemStyleEmphasisModel);
+          emphasisStyle.fill = itemStyleEmphasisModel.get('borderColor');
+          var blurStyle = getStateItemStyle(itemStyleBlurModel);
+          blurStyle.fill = itemStyleBlurModel.get('borderColor');
+          var selectStyle = getStateItemStyle(itemStyleSelectModel);
+          selectStyle.fill = itemStyleSelectModel.get('borderColor');
+
+          if (useUpperLabel) {
+            var upperLabelWidth = thisWidth - 2 * borderWidth;
+            prepareText(bg, visualBorderColor, upperLabelWidth, upperHeight, style.opacity, {
+              x: borderWidth,
+              y: 0,
+              width: upperLabelWidth,
+              height: upperHeight
+            });
+          } // For old bg.
+          else {
+              bg.removeTextContent();
+            }
+
+          bg.setStyle(normalStyle);
+          bg.ensureState('emphasis').style = emphasisStyle;
+          bg.ensureState('blur').style = blurStyle;
+          bg.ensureState('select').style = selectStyle;
+          setDefaultStateProxy(bg);
+        }
+
+        group.add(bg);
+      }
+
+      function renderContent(group, content) {
+        var ecData = getECData(content); // For tooltip.
+
+        ecData.dataIndex = thisNode.dataIndex;
+        ecData.seriesIndex = seriesModel.seriesIndex;
+        var contentWidth = Math.max(thisWidth - 2 * borderWidth, 0);
+        var contentHeight = Math.max(thisHeight - 2 * borderWidth, 0);
+        content.culling = true;
+        content.setShape({
+          x: borderWidth,
+          y: borderWidth,
+          width: contentWidth,
+          height: contentHeight,
+          r: borderRadius
+        });
+
+        if (thisInvisible) {
+          // If invisible, do not set visual, otherwise the element will
+          // change immediately before animation. We think it is OK to
+          // remain its origin color when moving out of the view window.
+          processInvisible(content);
+        } else {
+          content.invisible = false;
+          var nodeStyle = thisNode.getVisual('style');
+          var visualColor = nodeStyle.fill;
+          var normalStyle = getItemStyleNormal(itemStyleNormalModel);
+          normalStyle.fill = visualColor;
+          normalStyle.decal = nodeStyle.decal;
+          var emphasisStyle = getStateItemStyle(itemStyleEmphasisModel);
+          var blurStyle = getStateItemStyle(itemStyleBlurModel);
+          var selectStyle = getStateItemStyle(itemStyleSelectModel);
+          prepareText(content, visualColor, contentWidth, nodeStyle.opacity);
+          content.setStyle(normalStyle);
+          content.ensureState('emphasis').style = emphasisStyle;
+          content.ensureState('blur').style = blurStyle;
+          content.ensureState('select').style = selectStyle;
+          setDefaultStateProxy(content);
+        }
+
+        group.add(content);
+      }
+
+      function processInvisible(element) {
+        // Delay invisible setting utill animation finished,
+        // avoid element vanish suddenly before animation.
+        !element.invisible && willInvisibleEls.push(element);
+      }
+
+      function prepareText(rectEl, visualColor, visualOpacity, width, height, upperLabelRect) {
+        var normalLabelModel = nodeModel.getModel(upperLabelRect ? PATH_UPPERLABEL_NORMAL : PATH_LABEL_NOAMAL);
+        var text = retrieve(seriesModel.getFormattedLabel(thisNode.dataIndex, 'normal', null, null, normalLabelModel.get('formatter')), convertOptionIdName(nodeModel.get('name'), null));
+
+        if (!upperLabelRect && thisLayout.isLeafRoot) {
+          var iconChar = seriesModel.get('drillDownIcon', true);
+          text = iconChar ? iconChar + ' ' + text : text;
+        }
+
+        var isShow = normalLabelModel.getShallow('show');
+        setLabelStyle(rectEl, getLabelStatesModels(nodeModel, upperLabelRect ? PATH_UPPERLABEL_NORMAL : PATH_LABEL_NOAMAL), {
+          defaultText: isShow ? text : null,
+          inheritColor: visualColor,
+          defaultOpacity: visualOpacity,
+          labelFetcher: seriesModel,
+          labelDataIndex: thisNode.dataIndex
+        });
+        var textEl = rectEl.getTextContent();
+        var textStyle = textEl.style;
+        var textPadding = normalizeCssArray(textStyle.padding || 0);
+
+        if (upperLabelRect) {
+          rectEl.setTextConfig({
+            layoutRect: upperLabelRect
+          });
+          textEl.disableLabelLayout = true;
+        }
+
+        textEl.beforeUpdate = function () {
+          var width = Math.max((upperLabelRect ? upperLabelRect.width : rectEl.shape.width) - textPadding[1] - textPadding[3], 0);
+          var height = Math.max((upperLabelRect ? upperLabelRect.height : rectEl.shape.height) - textPadding[0] - textPadding[2], 0);
+
+          if (textStyle.width !== width || textStyle.height !== height) {
+            textEl.setStyle({
+              width: width,
+              height: height
+            });
+          }
+        };
+
+        textStyle.truncateMinChar = 2;
+        textStyle.lineOverflow = 'truncate';
+        addDrillDownIcon(textStyle, upperLabelRect, thisLayout);
+        var textEmphasisState = textEl.getState('emphasis');
+        addDrillDownIcon(textEmphasisState ? textEmphasisState.style : null, upperLabelRect, thisLayout);
+      }
+
+      function addDrillDownIcon(style, upperLabelRect, thisLayout) {
+        var text = style ? style.text : null;
+
+        if (!upperLabelRect && thisLayout.isLeafRoot && text != null) {
+          var iconChar = seriesModel.get('drillDownIcon', true);
+          style.text = iconChar ? iconChar + ' ' + text : text;
+        }
+      }
+
+      function giveGraphic(storageName, Ctor, depth, z) {
+        var element = oldRawIndex != null && oldStorage[storageName][oldRawIndex];
+        var lasts = lastsForAnimation[storageName];
+
+        if (element) {
+          // Remove from oldStorage
+          oldStorage[storageName][oldRawIndex] = null;
+          prepareAnimationWhenHasOld(lasts, element);
+        } // If invisible and no old element, do not create new element (for optimizing).
+        else if (!thisInvisible) {
+            element = new Ctor();
+
+            if (element instanceof Displayable) {
+              element.z = calculateZ(depth, z);
+            }
+
+            prepareAnimationWhenNoOld(lasts, element);
+          } // Set to thisStorage
+
+
+        return thisStorage[storageName][thisRawIndex] = element;
+      }
+
+      function prepareAnimationWhenHasOld(lasts, element) {
+        var lastCfg = lasts[thisRawIndex] = {};
+
+        if (element instanceof Group$1) {
+          lastCfg.oldX = element.x;
+          lastCfg.oldY = element.y;
+        } else {
+          lastCfg.oldShape = extend({}, element.shape);
+        }
+      } // If a element is new, we need to find the animation start point carefully,
+      // otherwise it will looks strange when 'zoomToNode'.
+
+
+      function prepareAnimationWhenNoOld(lasts, element) {
+        var lastCfg = lasts[thisRawIndex] = {};
+        var parentNode = thisNode.parentNode;
+        var isGroup = element instanceof Group;
+
+        if (parentNode && (!reRoot || reRoot.direction === 'drillDown')) {
+          var parentOldX = 0;
+          var parentOldY = 0; // New nodes appear from right-bottom corner in 'zoomToNode' animation.
+          // For convenience, get old bounding rect from background.
+
+          var parentOldBg = lastsForAnimation.background[parentNode.getRawIndex()];
+
+          if (!reRoot && parentOldBg && parentOldBg.oldShape) {
+            parentOldX = parentOldBg.oldShape.width;
+            parentOldY = parentOldBg.oldShape.height;
+          } // When no parent old shape found, its parent is new too,
+          // so we can just use {x:0, y:0}.
+
+
+          if (isGroup) {
+            lastCfg.oldX = 0;
+            lastCfg.oldY = parentOldY;
+          } else {
+            lastCfg.oldShape = {
+              x: parentOldX,
+              y: parentOldY,
+              width: 0,
+              height: 0
+            };
+          }
+        } // Fade in, user can be aware that these nodes are new.
+
+
+        lastCfg.fadein = !isGroup;
+      }
+    } // We can not set all backgroud with the same z, Because the behaviour of
+    // drill down and roll up differ background creation sequence from tree
+    // hierarchy sequence, which cause that lowser background element overlap
+    // upper ones. So we calculate z based on depth.
+    // Moreover, we try to shrink down z interval to [0, 1] to avoid that
+    // treemap with large z overlaps other components.
+
+
+    function calculateZ(depth, zInLevel) {
+      var zb = depth * Z_BASE + zInLevel;
+      return (zb - 1) / zb;
+    }
+
+    var each$4 = each;
+    var isObject$4 = isObject;
+    var CATEGORY_DEFAULT_VISUAL_INDEX = -1;
+
+    var VisualMapping =
+    /** @class */
+    function () {
+      function VisualMapping(option) {
+        var mappingMethod = option.mappingMethod;
+        var visualType = option.type;
+        var thisOption = this.option = clone(option);
+        this.type = visualType;
+        this.mappingMethod = mappingMethod;
+        this._normalizeData = normalizers[mappingMethod];
+        var visualHandler = VisualMapping.visualHandlers[visualType];
+        this.applyVisual = visualHandler.applyVisual;
+        this.getColorMapper = visualHandler.getColorMapper;
+        this._normalizedToVisual = visualHandler._normalizedToVisual[mappingMethod];
+
+        if (mappingMethod === 'piecewise') {
+          normalizeVisualRange(thisOption);
+          preprocessForPiecewise(thisOption);
+        } else if (mappingMethod === 'category') {
+          thisOption.categories ? preprocessForSpecifiedCategory(thisOption) // categories is ordinal when thisOption.categories not specified,
+          // which need no more preprocess except normalize visual.
+          : normalizeVisualRange(thisOption, true);
+        } else {
+          // mappingMethod === 'linear' or 'fixed'
+          assert(mappingMethod !== 'linear' || thisOption.dataExtent);
+          normalizeVisualRange(thisOption);
+        }
+      }
+
+      VisualMapping.prototype.mapValueToVisual = function (value) {
+        var normalized = this._normalizeData(value);
+
+        return this._normalizedToVisual(normalized, value);
+      };
+
+      VisualMapping.prototype.getNormalizer = function () {
+        return bind(this._normalizeData, this);
+      };
+      /**
+       * List available visual types.
+       *
+       * @public
+       * @return {Array.<string>}
+       */
+
+
+      VisualMapping.listVisualTypes = function () {
+        return keys(VisualMapping.visualHandlers);
+      }; // /**
+      //  * @public
+      //  */
+      // static addVisualHandler(name, handler) {
+      //     visualHandlers[name] = handler;
+      // }
+
+      /**
+       * @public
+       */
+
+
+      VisualMapping.isValidType = function (visualType) {
+        return VisualMapping.visualHandlers.hasOwnProperty(visualType);
+      };
+      /**
+       * Convinent method.
+       * Visual can be Object or Array or primary type.
+       */
+
+
+      VisualMapping.eachVisual = function (visual, callback, context) {
+        if (isObject(visual)) {
+          each(visual, callback, context);
+        } else {
+          callback.call(context, visual);
+        }
+      };
+
+      VisualMapping.mapVisual = function (visual, callback, context) {
+        var isPrimary;
+        var newVisual = isArray(visual) ? [] : isObject(visual) ? {} : (isPrimary = true, null);
+        VisualMapping.eachVisual(visual, function (v, key) {
+          var newVal = callback.call(context, v, key);
+          isPrimary ? newVisual = newVal : newVisual[key] = newVal;
+        });
+        return newVisual;
+      };
+      /**
+       * Retrieve visual properties from given object.
+       */
+
+
+      VisualMapping.retrieveVisuals = function (obj) {
+        var ret = {};
+        var hasVisual;
+        obj && each$4(VisualMapping.visualHandlers, function (h, visualType) {
+          if (obj.hasOwnProperty(visualType)) {
+            ret[visualType] = obj[visualType];
+            hasVisual = true;
+          }
+        });
+        return hasVisual ? ret : null;
+      };
+      /**
+       * Give order to visual types, considering colorSaturation, colorAlpha depends on color.
+       *
+       * @public
+       * @param {(Object|Array)} visualTypes If Object, like: {color: ..., colorSaturation: ...}
+       *                                     IF Array, like: ['color', 'symbol', 'colorSaturation']
+       * @return {Array.<string>} Sorted visual types.
+       */
+
+
+      VisualMapping.prepareVisualTypes = function (visualTypes) {
+        if (isArray(visualTypes)) {
+          visualTypes = visualTypes.slice();
+        } else if (isObject$4(visualTypes)) {
+          var types_1 = [];
+          each$4(visualTypes, function (item, type) {
+            types_1.push(type);
+          });
+          visualTypes = types_1;
+        } else {
+          return [];
+        }
+
+        visualTypes.sort(function (type1, type2) {
+          // color should be front of colorSaturation, colorAlpha, ...
+          // symbol and symbolSize do not matter.
+          return type2 === 'color' && type1 !== 'color' && type1.indexOf('color') === 0 ? 1 : -1;
+        });
+        return visualTypes;
+      };
+      /**
+       * 'color', 'colorSaturation', 'colorAlpha', ... are depends on 'color'.
+       * Other visuals are only depends on themself.
+       */
+
+
+      VisualMapping.dependsOn = function (visualType1, visualType2) {
+        return visualType2 === 'color' ? !!(visualType1 && visualType1.indexOf(visualType2) === 0) : visualType1 === visualType2;
+      };
+      /**
+       * @param value
+       * @param pieceList [{value: ..., interval: [min, max]}, ...]
+       *                         Always from small to big.
+       * @param findClosestWhenOutside Default to be false
+       * @return index
+       */
+
+
+      VisualMapping.findPieceIndex = function (value, pieceList, findClosestWhenOutside) {
+        var possibleI;
+        var abs = Infinity; // value has the higher priority.
+
+        for (var i = 0, len = pieceList.length; i < len; i++) {
+          var pieceValue = pieceList[i].value;
+
+          if (pieceValue != null) {
+            if (pieceValue === value // FIXME
+            // It is supposed to compare value according to value type of dimension,
+            // but currently value type can exactly be string or number.
+            // Compromise for numeric-like string (like '12'), especially
+            // in the case that visualMap.categories is ['22', '33'].
+            || typeof pieceValue === 'string' && pieceValue === value + '') {
+              return i;
+            }
+
+            findClosestWhenOutside && updatePossible(pieceValue, i);
+          }
+        }
+
+        for (var i = 0, len = pieceList.length; i < len; i++) {
+          var piece = pieceList[i];
+          var interval = piece.interval;
+          var close_1 = piece.close;
+
+          if (interval) {
+            if (interval[0] === -Infinity) {
+              if (littleThan(close_1[1], value, interval[1])) {
+                return i;
+              }
+            } else if (interval[1] === Infinity) {
+              if (littleThan(close_1[0], interval[0], value)) {
+                return i;
+              }
+            } else if (littleThan(close_1[0], interval[0], value) && littleThan(close_1[1], value, interval[1])) {
+              return i;
+            }
+
+            findClosestWhenOutside && updatePossible(interval[0], i);
+            findClosestWhenOutside && updatePossible(interval[1], i);
+          }
+        }
+
+        if (findClosestWhenOutside) {
+          return value === Infinity ? pieceList.length - 1 : value === -Infinity ? 0 : possibleI;
+        }
+
+        function updatePossible(val, index) {
+          var newAbs = Math.abs(val - value);
+
+          if (newAbs < abs) {
+            abs = newAbs;
+            possibleI = index;
+          }
+        }
+      };
+
+      VisualMapping.visualHandlers = {
+        color: {
+          applyVisual: makeApplyVisual('color'),
+          getColorMapper: function () {
+            var thisOption = this.option;
+            return bind(thisOption.mappingMethod === 'category' ? function (value, isNormalized) {
+              !isNormalized && (value = this._normalizeData(value));
+              return doMapCategory.call(this, value);
+            } : function (value, isNormalized, out) {
+              // If output rgb array
+              // which will be much faster and useful in pixel manipulation
+              var returnRGBArray = !!out;
+              !isNormalized && (value = this._normalizeData(value));
+              out = fastLerp(value, thisOption.parsedVisual, out);
+              return returnRGBArray ? out : stringify(out, 'rgba');
+            }, this);
+          },
+          _normalizedToVisual: {
+            linear: function (normalized) {
+              return stringify(fastLerp(normalized, this.option.parsedVisual), 'rgba');
+            },
+            category: doMapCategory,
+            piecewise: function (normalized, value) {
+              var result = getSpecifiedVisual.call(this, value);
+
+              if (result == null) {
+                result = stringify(fastLerp(normalized, this.option.parsedVisual), 'rgba');
+              }
+
+              return result;
+            },
+            fixed: doMapFixed
+          }
+        },
+        colorHue: makePartialColorVisualHandler(function (color$1, value) {
+          return modifyHSL(color$1, value);
+        }),
+        colorSaturation: makePartialColorVisualHandler(function (color$1, value) {
+          return modifyHSL(color$1, null, value);
+        }),
+        colorLightness: makePartialColorVisualHandler(function (color$1, value) {
+          return modifyHSL(color$1, null, null, value);
+        }),
+        colorAlpha: makePartialColorVisualHandler(function (color$1, value) {
+          return modifyAlpha(color$1, value);
+        }),
+        decal: {
+          applyVisual: makeApplyVisual('decal'),
+          _normalizedToVisual: {
+            linear: null,
+            category: doMapCategory,
+            piecewise: null,
+            fixed: null
+          }
+        },
+        opacity: {
+          applyVisual: makeApplyVisual('opacity'),
+          _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
+        },
+        liftZ: {
+          applyVisual: makeApplyVisual('liftZ'),
+          _normalizedToVisual: {
+            linear: doMapFixed,
+            category: doMapFixed,
+            piecewise: doMapFixed,
+            fixed: doMapFixed
+          }
+        },
+        symbol: {
+          applyVisual: function (value, getter, setter) {
+            var symbolCfg = this.mapValueToVisual(value);
+            setter('symbol', symbolCfg);
+          },
+          _normalizedToVisual: {
+            linear: doMapToArray,
+            category: doMapCategory,
+            piecewise: function (normalized, value) {
+              var result = getSpecifiedVisual.call(this, value);
+
+              if (result == null) {
+                result = doMapToArray.call(this, normalized);
+              }
+
+              return result;
+            },
+            fixed: doMapFixed
+          }
+        },
+        symbolSize: {
+          applyVisual: makeApplyVisual('symbolSize'),
+          _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
+        }
+      };
+      return VisualMapping;
+    }();
+
+    function preprocessForPiecewise(thisOption) {
+      var pieceList = thisOption.pieceList;
+      thisOption.hasSpecialVisual = false;
+      each(pieceList, function (piece, index) {
+        piece.originIndex = index; // piece.visual is "result visual value" but not
+        // a visual range, so it does not need to be normalized.
+
+        if (piece.visual != null) {
+          thisOption.hasSpecialVisual = true;
+        }
+      });
+    }
+
+    function preprocessForSpecifiedCategory(thisOption) {
+      // Hash categories.
+      var categories = thisOption.categories;
+      var categoryMap = thisOption.categoryMap = {};
+      var visual = thisOption.visual;
+      each$4(categories, function (cate, index) {
+        categoryMap[cate] = index;
+      }); // Process visual map input.
+
+      if (!isArray(visual)) {
+        var visualArr_1 = [];
+
+        if (isObject(visual)) {
+          each$4(visual, function (v, cate) {
+            var index = categoryMap[cate];
+            visualArr_1[index != null ? index : CATEGORY_DEFAULT_VISUAL_INDEX] = v;
+          });
+        } else {
+          // Is primary type, represents default visual.
+          visualArr_1[CATEGORY_DEFAULT_VISUAL_INDEX] = visual;
+        }
+
+        visual = setVisualToOption(thisOption, visualArr_1);
+      } // Remove categories that has no visual,
+      // then we can mapping them to CATEGORY_DEFAULT_VISUAL_INDEX.
+
+
+      for (var i = categories.length - 1; i >= 0; i--) {
+        if (visual[i] == null) {
+          delete categoryMap[categories[i]];
+          categories.pop();
+        }
+      }
+    }
+
+    function normalizeVisualRange(thisOption, isCategory) {
+      var visual = thisOption.visual;
+      var visualArr = [];
+
+      if (isObject(visual)) {
+        each$4(visual, function (v) {
+          visualArr.push(v);
+        });
+      } else if (visual != null) {
+        visualArr.push(visual);
+      }
+
+      var doNotNeedPair = {
+        color: 1,
+        symbol: 1
+      };
+
+      if (!isCategory && visualArr.length === 1 && !doNotNeedPair.hasOwnProperty(thisOption.type)) {
+        // Do not care visualArr.length === 0, which is illegal.
+        visualArr[1] = visualArr[0];
+      }
+
+      setVisualToOption(thisOption, visualArr);
+    }
+
+    function makePartialColorVisualHandler(applyValue) {
+      return {
+        applyVisual: function (value, getter, setter) {
+          // Only used in HSL
+          var colorChannel = this.mapValueToVisual(value); // Must not be array value
+
+          setter('color', applyValue(getter('color'), colorChannel));
+        },
+        _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
+      };
+    }
+
+    function doMapToArray(normalized) {
+      var visual = this.option.visual;
+      return visual[Math.round(linearMap(normalized, [0, 1], [0, visual.length - 1], true))] || {}; // TODO {}?
+    }
+
+    function makeApplyVisual(visualType) {
+      return function (value, getter, setter) {
+        setter(visualType, this.mapValueToVisual(value));
+      };
+    }
+
+    function doMapCategory(normalized) {
+      var visual = this.option.visual;
+      return visual[this.option.loop && normalized !== CATEGORY_DEFAULT_VISUAL_INDEX ? normalized % visual.length : normalized];
+    }
+
+    function doMapFixed() {
+      // visual will be convert to array.
+      return this.option.visual[0];
+    }
+    /**
+     * Create mapped to numeric visual
+     */
+
+
+    function createNormalizedToNumericVisual(sourceExtent) {
+      return {
+        linear: function (normalized) {
+          return linearMap(normalized, sourceExtent, this.option.visual, true);
+        },
+        category: doMapCategory,
+        piecewise: function (normalized, value) {
+          var result = getSpecifiedVisual.call(this, value);
+
+          if (result == null) {
+            result = linearMap(normalized, sourceExtent, this.option.visual, true);
+          }
+
+          return result;
+        },
+        fixed: doMapFixed
+      };
+    }
+
+    function getSpecifiedVisual(value) {
+      var thisOption = this.option;
+      var pieceList = thisOption.pieceList;
+
+      if (thisOption.hasSpecialVisual) {
+        var pieceIndex = VisualMapping.findPieceIndex(value, pieceList);
+        var piece = pieceList[pieceIndex];
+
+        if (piece && piece.visual) {
+          return piece.visual[this.type];
+        }
+      }
+    }
+
+    function setVisualToOption(thisOption, visualArr) {
+      thisOption.visual = visualArr;
+
+      if (thisOption.type === 'color') {
+        thisOption.parsedVisual = map(visualArr, function (item) {
+          return parse(item);
+        });
+      }
+
+      return visualArr;
+    }
+    /**
+     * Normalizers by mapping methods.
+     */
+
+
+    var normalizers = {
+      linear: function (value) {
+        return linearMap(value, this.option.dataExtent, [0, 1], true);
+      },
+      piecewise: function (value) {
+        var pieceList = this.option.pieceList;
+        var pieceIndex = VisualMapping.findPieceIndex(value, pieceList, true);
+
+        if (pieceIndex != null) {
+          return linearMap(pieceIndex, [0, pieceList.length - 1], [0, 1], true);
+        }
+      },
+      category: function (value) {
+        var index = this.option.categories ? this.option.categoryMap[value] : value; // ordinal value
+
+        return index == null ? CATEGORY_DEFAULT_VISUAL_INDEX : index;
+      },
+      fixed: noop
+    };
+
+    function littleThan(close, a, b) {
+      return close ? a <= b : a < b;
+    }
+
+    var ITEM_STYLE_NORMAL = 'itemStyle';
+    var inner$a = makeInner();
+    var treemapVisual = {
+      seriesType: 'treemap',
+      reset: function (seriesModel) {
+        var tree = seriesModel.getData().tree;
+        var root = tree.root;
+
+        if (root.isRemoved()) {
+          return;
+        }
+
+        travelTree(root, // Visual should calculate from tree root but not view root.
+        {}, seriesModel.getViewRoot().getAncestors(), seriesModel);
+      }
+    };
+
+    function travelTree(node, designatedVisual, viewRootAncestors, seriesModel) {
+      var nodeModel = node.getModel();
+      var nodeLayout = node.getLayout();
+      var data = node.hostTree.data; // Optimize
+
+      if (!nodeLayout || nodeLayout.invisible || !nodeLayout.isInView) {
+        return;
+      }
+
+      var nodeItemStyleModel = nodeModel.getModel(ITEM_STYLE_NORMAL);
+      var visuals = buildVisuals(nodeItemStyleModel, designatedVisual, seriesModel);
+      var existsStyle = data.ensureUniqueItemVisual(node.dataIndex, 'style'); // calculate border color
+
+      var borderColor = nodeItemStyleModel.get('borderColor');
+      var borderColorSaturation = nodeItemStyleModel.get('borderColorSaturation');
+      var thisNodeColor;
+
+      if (borderColorSaturation != null) {
+        // For performance, do not always execute 'calculateColor'.
+        thisNodeColor = calculateColor(visuals);
+        borderColor = calculateBorderColor(borderColorSaturation, thisNodeColor);
+      }
+
+      existsStyle.stroke = borderColor;
+      var viewChildren = node.viewChildren;
+
+      if (!viewChildren || !viewChildren.length) {
+        thisNodeColor = calculateColor(visuals); // Apply visual to this node.
+
+        existsStyle.fill = thisNodeColor;
+      } else {
+        var mapping_1 = buildVisualMapping(node, nodeModel, nodeLayout, nodeItemStyleModel, visuals, viewChildren); // Designate visual to children.
+
+        each(viewChildren, function (child, index) {
+          // If higher than viewRoot, only ancestors of viewRoot is needed to visit.
+          if (child.depth >= viewRootAncestors.length || child === viewRootAncestors[child.depth]) {
+            var childVisual = mapVisual(nodeModel, visuals, child, index, mapping_1, seriesModel);
+            travelTree(child, childVisual, viewRootAncestors, seriesModel);
+          }
+        });
+      }
+    }
+
+    function buildVisuals(nodeItemStyleModel, designatedVisual, seriesModel) {
+      var visuals = extend({}, designatedVisual);
+      var designatedVisualItemStyle = seriesModel.designatedVisualItemStyle;
+      each(['color', 'colorAlpha', 'colorSaturation'], function (visualName) {
+        // Priority: thisNode > thisLevel > parentNodeDesignated > seriesModel
+        designatedVisualItemStyle[visualName] = designatedVisual[visualName];
+        var val = nodeItemStyleModel.get(visualName);
+        designatedVisualItemStyle[visualName] = null;
+        val != null && (visuals[visualName] = val);
+      });
+      return visuals;
+    }
+
+    function calculateColor(visuals) {
+      var color = getValueVisualDefine(visuals, 'color');
+
+      if (color) {
+        var colorAlpha = getValueVisualDefine(visuals, 'colorAlpha');
+        var colorSaturation = getValueVisualDefine(visuals, 'colorSaturation');
+
+        if (colorSaturation) {
+          color = modifyHSL(color, null, null, colorSaturation);
+        }
+
+        if (colorAlpha) {
+          color = modifyAlpha(color, colorAlpha);
+        }
+
+        return color;
+      }
+    }
+
+    function calculateBorderColor(borderColorSaturation, thisNodeColor) {
+      return thisNodeColor != null // Can only be string
+      ? modifyHSL(thisNodeColor, null, null, borderColorSaturation) : null;
+    }
+
+    function getValueVisualDefine(visuals, name) {
+      var value = visuals[name];
+
+      if (value != null && value !== 'none') {
+        return value;
+      }
+    }
+
+    function buildVisualMapping(node, nodeModel, nodeLayout, nodeItemStyleModel, visuals, viewChildren) {
+      if (!viewChildren || !viewChildren.length) {
+        return;
+      }
+
+      var rangeVisual = getRangeVisual(nodeModel, 'color') || visuals.color != null && visuals.color !== 'none' && (getRangeVisual(nodeModel, 'colorAlpha') || getRangeVisual(nodeModel, 'colorSaturation'));
+
+      if (!rangeVisual) {
+        return;
+      }
+
+      var visualMin = nodeModel.get('visualMin');
+      var visualMax = nodeModel.get('visualMax');
+      var dataExtent = nodeLayout.dataExtent.slice();
+      visualMin != null && visualMin < dataExtent[0] && (dataExtent[0] = visualMin);
+      visualMax != null && visualMax > dataExtent[1] && (dataExtent[1] = visualMax);
+      var colorMappingBy = nodeModel.get('colorMappingBy');
+      var opt = {
+        type: rangeVisual.name,
+        dataExtent: dataExtent,
+        visual: rangeVisual.range
+      };
+
+      if (opt.type === 'color' && (colorMappingBy === 'index' || colorMappingBy === 'id')) {
+        opt.mappingMethod = 'category';
+        opt.loop = true; // categories is ordinal, so do not set opt.categories.
+      } else {
+        opt.mappingMethod = 'linear';
+      }
+
+      var mapping = new VisualMapping(opt);
+      inner$a(mapping).drColorMappingBy = colorMappingBy;
+      return mapping;
+    } // Notice: If we dont have the attribute 'colorRange', but only use
+    // attribute 'color' to represent both concepts of 'colorRange' and 'color',
+    // (It means 'colorRange' when 'color' is Array, means 'color' when not array),
+    // this problem will be encountered:
+    // If a level-1 node dont have children, and its siblings has children,
+    // and colorRange is set on level-1, then the node can not be colored.
+    // So we separate 'colorRange' and 'color' to different attributes.
+
+
+    function getRangeVisual(nodeModel, name) {
+      // 'colorRange', 'colorARange', 'colorSRange'.
+      // If not exsits on this node, fetch from levels and series.
+      var range = nodeModel.get(name);
+      return isArray(range) && range.length ? {
+        name: name,
+        range: range
+      } : null;
+    }
+
+    function mapVisual(nodeModel, visuals, child, index, mapping, seriesModel) {
+      var childVisuals = extend({}, visuals);
+
+      if (mapping) {
+        // Only support color, colorAlpha, colorSaturation.
+        var mappingType = mapping.type;
+        var colorMappingBy = mappingType === 'color' && inner$a(mapping).drColorMappingBy;
+        var value = colorMappingBy === 'index' ? index : colorMappingBy === 'id' ? seriesModel.mapIdToIndex(child.getId()) : child.getValue(nodeModel.get('visualDimension'));
+        childVisuals[mappingType] = mapping.mapValueToVisual(value);
+      }
+
+      return childVisuals;
+    }
+
+    var mathMax$7 = Math.max;
+    var mathMin$7 = Math.min;
+    var retrieveValue = retrieve;
+    var each$5 = each;
+    var PATH_BORDER_WIDTH = ['itemStyle', 'borderWidth'];
+    var PATH_GAP_WIDTH = ['itemStyle', 'gapWidth'];
+    var PATH_UPPER_LABEL_SHOW = ['upperLabel', 'show'];
+    var PATH_UPPER_LABEL_HEIGHT = ['upperLabel', 'height'];
+    /**
+     * @public
+     */
+
+    var treemapLayout = {
+      seriesType: 'treemap',
+      reset: function (seriesModel, ecModel, api, payload) {
+        // Layout result in each node:
+        // {x, y, width, height, area, borderWidth}
+        var ecWidth = api.getWidth();
+        var ecHeight = api.getHeight();
+        var seriesOption = seriesModel.option;
+        var layoutInfo = getLayoutRect(seriesModel.getBoxLayoutParams(), {
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+        var size = seriesOption.size || []; // Compatible with ec2.
+
+        var containerWidth = parsePercent$1(retrieveValue(layoutInfo.width, size[0]), ecWidth);
+        var containerHeight = parsePercent$1(retrieveValue(layoutInfo.height, size[1]), ecHeight); // Fetch payload info.
+
+        var payloadType = payload && payload.type;
+        var types = ['treemapZoomToNode', 'treemapRootToNode'];
+        var targetInfo = retrieveTargetInfo(payload, types, seriesModel);
+        var rootRect = payloadType === 'treemapRender' || payloadType === 'treemapMove' ? payload.rootRect : null;
+        var viewRoot = seriesModel.getViewRoot();
+        var viewAbovePath = getPathToRoot(viewRoot);
+
+        if (payloadType !== 'treemapMove') {
+          var rootSize = payloadType === 'treemapZoomToNode' ? estimateRootSize(seriesModel, targetInfo, viewRoot, containerWidth, containerHeight) : rootRect ? [rootRect.width, rootRect.height] : [containerWidth, containerHeight];
+          var sort_1 = seriesOption.sort;
+
+          if (sort_1 && sort_1 !== 'asc' && sort_1 !== 'desc') {
+            // Default to be desc order.
+            sort_1 = 'desc';
+          }
+
+          var options = {
+            squareRatio: seriesOption.squareRatio,
+            sort: sort_1,
+            leafDepth: seriesOption.leafDepth
+          }; // layout should be cleared because using updateView but not update.
+
+          viewRoot.hostTree.clearLayouts(); // TODO
+          // optimize: if out of view clip, do not layout.
+          // But take care that if do not render node out of view clip,
+          // how to calculate start po
+
+          var viewRootLayout_1 = {
+            x: 0,
+            y: 0,
+            width: rootSize[0],
+            height: rootSize[1],
+            area: rootSize[0] * rootSize[1]
+          };
+          viewRoot.setLayout(viewRootLayout_1);
+          squarify(viewRoot, options, false, 0); // Supplement layout.
+
+          viewRootLayout_1 = viewRoot.getLayout();
+          each$5(viewAbovePath, function (node, index) {
+            var childValue = (viewAbovePath[index + 1] || viewRoot).getValue();
+            node.setLayout(extend({
+              dataExtent: [childValue, childValue],
+              borderWidth: 0,
+              upperHeight: 0
+            }, viewRootLayout_1));
+          });
+        }
+
+        var treeRoot = seriesModel.getData().tree.root;
+        treeRoot.setLayout(calculateRootPosition(layoutInfo, rootRect, targetInfo), true);
+        seriesModel.setLayoutInfo(layoutInfo); // FIXME
+        // 现在没有clip功能，暂时取ec高宽。
+
+        prunning(treeRoot, // Transform to base element coordinate system.
+        new BoundingRect(-layoutInfo.x, -layoutInfo.y, ecWidth, ecHeight), viewAbovePath, viewRoot, 0);
+      }
+    };
+    /**
+     * Layout treemap with squarify algorithm.
+     * The original presentation of this algorithm
+     * was made by Mark Bruls, Kees Huizing, and Jarke J. van Wijk
+     * <https://graphics.ethz.ch/teaching/scivis_common/Literature/squarifiedTreeMaps.pdf>.
+     * The implementation of this algorithm was originally copied from "d3.js"
+     * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/layout/treemap.js>
+     * with some modifications made for this program.
+     * See the license statement at the head of this file.
+     *
+     * @protected
+     * @param {module:echarts/data/Tree~TreeNode} node
+     * @param {Object} options
+     * @param {string} options.sort 'asc' or 'desc'
+     * @param {number} options.squareRatio
+     * @param {boolean} hideChildren
+     * @param {number} depth
+     */
+
+    function squarify(node, options, hideChildren, depth) {
+      var width;
+      var height;
+
+      if (node.isRemoved()) {
+        return;
+      }
+
+      var thisLayout = node.getLayout();
+      width = thisLayout.width;
+      height = thisLayout.height; // Considering border and gap
+
+      var nodeModel = node.getModel();
+      var borderWidth = nodeModel.get(PATH_BORDER_WIDTH);
+      var halfGapWidth = nodeModel.get(PATH_GAP_WIDTH) / 2;
+      var upperLabelHeight = getUpperLabelHeight(nodeModel);
+      var upperHeight = Math.max(borderWidth, upperLabelHeight);
+      var layoutOffset = borderWidth - halfGapWidth;
+      var layoutOffsetUpper = upperHeight - halfGapWidth;
+      node.setLayout({
+        borderWidth: borderWidth,
+        upperHeight: upperHeight,
+        upperLabelHeight: upperLabelHeight
+      }, true);
+      width = mathMax$7(width - 2 * layoutOffset, 0);
+      height = mathMax$7(height - layoutOffset - layoutOffsetUpper, 0);
+      var totalArea = width * height;
+      var viewChildren = initChildren(node, nodeModel, totalArea, options, hideChildren, depth);
+
+      if (!viewChildren.length) {
+        return;
+      }
+
+      var rect = {
+        x: layoutOffset,
+        y: layoutOffsetUpper,
+        width: width,
+        height: height
+      };
+      var rowFixedLength = mathMin$7(width, height);
+      var best = Infinity; // the best row score so far
+
+      var row = [];
+      row.area = 0;
+
+      for (var i = 0, len = viewChildren.length; i < len;) {
+        var child = viewChildren[i];
+        row.push(child);
+        row.area += child.getLayout().area;
+        var score = worst(row, rowFixedLength, options.squareRatio); // continue with this orientation
+
+        if (score <= best) {
+          i++;
+          best = score;
+        } // abort, and try a different orientation
+        else {
+            row.area -= row.pop().getLayout().area;
+            position(row, rowFixedLength, rect, halfGapWidth, false);
+            rowFixedLength = mathMin$7(rect.width, rect.height);
+            row.length = row.area = 0;
+            best = Infinity;
+          }
+      }
+
+      if (row.length) {
+        position(row, rowFixedLength, rect, halfGapWidth, true);
+      }
+
+      if (!hideChildren) {
+        var childrenVisibleMin = nodeModel.get('childrenVisibleMin');
+
+        if (childrenVisibleMin != null && totalArea < childrenVisibleMin) {
+          hideChildren = true;
+        }
+      }
+
+      for (var i = 0, len = viewChildren.length; i < len; i++) {
+        squarify(viewChildren[i], options, hideChildren, depth + 1);
+      }
+    }
+    /**
+     * Set area to each child, and calculate data extent for visual coding.
+     */
+
+
+    function initChildren(node, nodeModel, totalArea, options, hideChildren, depth) {
+      var viewChildren = node.children || [];
+      var orderBy = options.sort;
+      orderBy !== 'asc' && orderBy !== 'desc' && (orderBy = null);
+      var overLeafDepth = options.leafDepth != null && options.leafDepth <= depth; // leafDepth has higher priority.
+
+      if (hideChildren && !overLeafDepth) {
+        return node.viewChildren = [];
+      } // Sort children, order by desc.
+
+
+      viewChildren = filter(viewChildren, function (child) {
+        return !child.isRemoved();
+      });
+      sort$1(viewChildren, orderBy);
+      var info = statistic(nodeModel, viewChildren, orderBy);
+
+      if (info.sum === 0) {
+        return node.viewChildren = [];
+      }
+
+      info.sum = filterByThreshold(nodeModel, totalArea, info.sum, orderBy, viewChildren);
+
+      if (info.sum === 0) {
+        return node.viewChildren = [];
+      } // Set area to each child.
+
+
+      for (var i = 0, len = viewChildren.length; i < len; i++) {
+        var area = viewChildren[i].getValue() / info.sum * totalArea; // Do not use setLayout({...}, true), because it is needed to clear last layout.
+
+        viewChildren[i].setLayout({
+          area: area
+        });
+      }
+
+      if (overLeafDepth) {
+        viewChildren.length && node.setLayout({
+          isLeafRoot: true
+        }, true);
+        viewChildren.length = 0;
+      }
+
+      node.viewChildren = viewChildren;
+      node.setLayout({
+        dataExtent: info.dataExtent
+      }, true);
+      return viewChildren;
+    }
+    /**
+     * Consider 'visibleMin'. Modify viewChildren and get new sum.
+     */
+
+
+    function filterByThreshold(nodeModel, totalArea, sum, orderBy, orderedChildren) {
+      // visibleMin is not supported yet when no option.sort.
+      if (!orderBy) {
+        return sum;
+      }
+
+      var visibleMin = nodeModel.get('visibleMin');
+      var len = orderedChildren.length;
+      var deletePoint = len; // Always travel from little value to big value.
+
+      for (var i = len - 1; i >= 0; i--) {
+        var value = orderedChildren[orderBy === 'asc' ? len - i - 1 : i].getValue();
+
+        if (value / sum * totalArea < visibleMin) {
+          deletePoint = i;
+          sum -= value;
+        }
+      }
+
+      orderBy === 'asc' ? orderedChildren.splice(0, len - deletePoint) : orderedChildren.splice(deletePoint, len - deletePoint);
+      return sum;
+    }
+    /**
+     * Sort
+     */
+
+
+    function sort$1(viewChildren, orderBy) {
+      if (orderBy) {
+        viewChildren.sort(function (a, b) {
+          var diff = orderBy === 'asc' ? a.getValue() - b.getValue() : b.getValue() - a.getValue();
+          return diff === 0 ? orderBy === 'asc' ? a.dataIndex - b.dataIndex : b.dataIndex - a.dataIndex : diff;
+        });
+      }
+
+      return viewChildren;
+    }
+    /**
+     * Statistic
+     */
+
+
+    function statistic(nodeModel, children, orderBy) {
+      // Calculate sum.
+      var sum = 0;
+
+      for (var i = 0, len = children.length; i < len; i++) {
+        sum += children[i].getValue();
+      } // Statistic data extent for latter visual coding.
+      // Notice: data extent should be calculate based on raw children
+      // but not filtered view children, otherwise visual mapping will not
+      // be stable when zoom (where children is filtered by visibleMin).
+
+
+      var dimension = nodeModel.get('visualDimension');
+      var dataExtent; // The same as area dimension.
+
+      if (!children || !children.length) {
+        dataExtent = [NaN, NaN];
+      } else if (dimension === 'value' && orderBy) {
+        dataExtent = [children[children.length - 1].getValue(), children[0].getValue()];
+        orderBy === 'asc' && dataExtent.reverse();
+      } // Other dimension.
+      else {
+          dataExtent = [Infinity, -Infinity];
+          each$5(children, function (child) {
+            var value = child.getValue(dimension);
+            value < dataExtent[0] && (dataExtent[0] = value);
+            value > dataExtent[1] && (dataExtent[1] = value);
+          });
+        }
+
+      return {
+        sum: sum,
+        dataExtent: dataExtent
+      };
+    }
+    /**
+     * Computes the score for the specified row,
+     * as the worst aspect ratio.
+     */
+
+
+    function worst(row, rowFixedLength, ratio) {
+      var areaMax = 0;
+      var areaMin = Infinity;
+
+      for (var i = 0, area = void 0, len = row.length; i < len; i++) {
+        area = row[i].getLayout().area;
+
+        if (area) {
+          area < areaMin && (areaMin = area);
+          area > areaMax && (areaMax = area);
+        }
+      }
+
+      var squareArea = row.area * row.area;
+      var f = rowFixedLength * rowFixedLength * ratio;
+      return squareArea ? mathMax$7(f * areaMax / squareArea, squareArea / (f * areaMin)) : Infinity;
+    }
+    /**
+     * Positions the specified row of nodes. Modifies `rect`.
+     */
+
+
+    function position(row, rowFixedLength, rect, halfGapWidth, flush) {
+      // When rowFixedLength === rect.width,
+      // it is horizontal subdivision,
+      // rowFixedLength is the width of the subdivision,
+      // rowOtherLength is the height of the subdivision,
+      // and nodes will be positioned from left to right.
+      // wh[idx0WhenH] means: when horizontal,
+      //      wh[idx0WhenH] => wh[0] => 'width'.
+      //      xy[idx1WhenH] => xy[1] => 'y'.
+      var idx0WhenH = rowFixedLength === rect.width ? 0 : 1;
+      var idx1WhenH = 1 - idx0WhenH;
+      var xy = ['x', 'y'];
+      var wh = ['width', 'height'];
+      var last = rect[xy[idx0WhenH]];
+      var rowOtherLength = rowFixedLength ? row.area / rowFixedLength : 0;
+
+      if (flush || rowOtherLength > rect[wh[idx1WhenH]]) {
+        rowOtherLength = rect[wh[idx1WhenH]]; // over+underflow
+      }
+
+      for (var i = 0, rowLen = row.length; i < rowLen; i++) {
+        var node = row[i];
+        var nodeLayout = {};
+        var step = rowOtherLength ? node.getLayout().area / rowOtherLength : 0;
+        var wh1 = nodeLayout[wh[idx1WhenH]] = mathMax$7(rowOtherLength - 2 * halfGapWidth, 0); // We use Math.max/min to avoid negative width/height when considering gap width.
+
+        var remain = rect[xy[idx0WhenH]] + rect[wh[idx0WhenH]] - last;
+        var modWH = i === rowLen - 1 || remain < step ? remain : step;
+        var wh0 = nodeLayout[wh[idx0WhenH]] = mathMax$7(modWH - 2 * halfGapWidth, 0);
+        nodeLayout[xy[idx1WhenH]] = rect[xy[idx1WhenH]] + mathMin$7(halfGapWidth, wh1 / 2);
+        nodeLayout[xy[idx0WhenH]] = last + mathMin$7(halfGapWidth, wh0 / 2);
+        last += modWH;
+        node.setLayout(nodeLayout, true);
+      }
+
+      rect[xy[idx1WhenH]] += rowOtherLength;
+      rect[wh[idx1WhenH]] -= rowOtherLength;
+    } // Return [containerWidth, containerHeight] as default.
+
+
+    function estimateRootSize(seriesModel, targetInfo, viewRoot, containerWidth, containerHeight) {
+      // If targetInfo.node exists, we zoom to the node,
+      // so estimate whold width and heigth by target node.
+      var currNode = (targetInfo || {}).node;
+      var defaultSize = [containerWidth, containerHeight];
+
+      if (!currNode || currNode === viewRoot) {
+        return defaultSize;
+      }
+
+      var parent;
+      var viewArea = containerWidth * containerHeight;
+      var area = viewArea * seriesModel.option.zoomToNodeRatio;
+
+      while (parent = currNode.parentNode) {
+        // jshint ignore:line
+        var sum = 0;
+        var siblings = parent.children;
+
+        for (var i = 0, len = siblings.length; i < len; i++) {
+          sum += siblings[i].getValue();
+        }
+
+        var currNodeValue = currNode.getValue();
+
+        if (currNodeValue === 0) {
+          return defaultSize;
+        }
+
+        area *= sum / currNodeValue; // Considering border, suppose aspect ratio is 1.
+
+        var parentModel = parent.getModel();
+        var borderWidth = parentModel.get(PATH_BORDER_WIDTH);
+        var upperHeight = Math.max(borderWidth, getUpperLabelHeight(parentModel));
+        area += 4 * borderWidth * borderWidth + (3 * borderWidth + upperHeight) * Math.pow(area, 0.5);
+        area > MAX_SAFE_INTEGER && (area = MAX_SAFE_INTEGER);
+        currNode = parent;
+      }
+
+      area < viewArea && (area = viewArea);
+      var scale = Math.pow(area / viewArea, 0.5);
+      return [containerWidth * scale, containerHeight * scale];
+    } // Root postion base on coord of containerGroup
+
+
+    function calculateRootPosition(layoutInfo, rootRect, targetInfo) {
+      if (rootRect) {
+        return {
+          x: rootRect.x,
+          y: rootRect.y
+        };
+      }
+
+      var defaultPosition = {
+        x: 0,
+        y: 0
+      };
+
+      if (!targetInfo) {
+        return defaultPosition;
+      } // If targetInfo is fetched by 'retrieveTargetInfo',
+      // old tree and new tree are the same tree,
+      // so the node still exists and we can visit it.
+
+
+      var targetNode = targetInfo.node;
+      var layout = targetNode.getLayout();
+
+      if (!layout) {
+        return defaultPosition;
+      } // Transform coord from local to container.
+
+
+      var targetCenter = [layout.width / 2, layout.height / 2];
+      var node = targetNode;
+
+      while (node) {
+        var nodeLayout = node.getLayout();
+        targetCenter[0] += nodeLayout.x;
+        targetCenter[1] += nodeLayout.y;
+        node = node.parentNode;
+      }
+
+      return {
+        x: layoutInfo.width / 2 - targetCenter[0],
+        y: layoutInfo.height / 2 - targetCenter[1]
+      };
+    } // Mark nodes visible for prunning when visual coding and rendering.
+    // Prunning depends on layout and root position, so we have to do it after layout.
+
+
+    function prunning(node, clipRect, viewAbovePath, viewRoot, depth) {
+      var nodeLayout = node.getLayout();
+      var nodeInViewAbovePath = viewAbovePath[depth];
+      var isAboveViewRoot = nodeInViewAbovePath && nodeInViewAbovePath === node;
+
+      if (nodeInViewAbovePath && !isAboveViewRoot || depth === viewAbovePath.length && node !== viewRoot) {
+        return;
+      }
+
+      node.setLayout({
+        // isInView means: viewRoot sub tree + viewAbovePath
+        isInView: true,
+        // invisible only means: outside view clip so that the node can not
+        // see but still layout for animation preparation but not render.
+        invisible: !isAboveViewRoot && !clipRect.intersect(nodeLayout),
+        isAboveViewRoot: isAboveViewRoot
+      }, true); // Transform to child coordinate.
+
+      var childClipRect = new BoundingRect(clipRect.x - nodeLayout.x, clipRect.y - nodeLayout.y, clipRect.width, clipRect.height);
+      each$5(node.viewChildren || [], function (child) {
+        prunning(child, childClipRect, viewAbovePath, viewRoot, depth + 1);
+      });
+    }
+
+    function getUpperLabelHeight(model) {
+      return model.get(PATH_UPPER_LABEL_SHOW) ? model.get(PATH_UPPER_LABEL_HEIGHT) : 0;
+    }
+
+    function install$c(registers) {
+      registers.registerSeriesModel(TreemapSeriesModel);
+      registers.registerChartView(TreemapView);
+      registers.registerVisual(treemapVisual);
+      registers.registerLayout(treemapLayout);
+      installTreemapAction(registers);
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function categoryFilter(ecModel) {
+      var legendModels = ecModel.findComponents({
+        mainType: 'legend'
+      });
+
+      if (!legendModels || !legendModels.length) {
+        return;
+      }
+
+      ecModel.eachSeriesByType('graph', function (graphSeries) {
+        var categoriesData = graphSeries.getCategoriesData();
+        var graph = graphSeries.getGraph();
+        var data = graph.data;
+        var categoryNames = categoriesData.mapArray(categoriesData.getName);
+        data.filterSelf(function (idx) {
+          var model = data.getItemModel(idx);
+          var category = model.getShallow('category');
+
+          if (category != null) {
+            if (typeof category === 'number') {
+              category = categoryNames[category];
+            } // If in any legend component the status is not selected.
+
+
+            for (var i = 0; i < legendModels.length; i++) {
+              if (!legendModels[i].isSelected(category)) {
+                return false;
+              }
+            }
+          }
+
+          return true;
+        });
+      });
+    }
+
+    function categoryVisual(ecModel) {
+      var paletteScope = {};
+      ecModel.eachSeriesByType('graph', function (seriesModel) {
+        var categoriesData = seriesModel.getCategoriesData();
+        var data = seriesModel.getData();
+        var categoryNameIdxMap = {};
+        categoriesData.each(function (idx) {
+          var name = categoriesData.getName(idx); // Add prefix to avoid conflict with Object.prototype.
+
+          categoryNameIdxMap['ec-' + name] = idx;
+          var itemModel = categoriesData.getItemModel(idx);
+          var style = itemModel.getModel('itemStyle').getItemStyle();
+
+          if (!style.fill) {
+            // Get color from palette.
+            style.fill = seriesModel.getColorFromPalette(name, paletteScope);
+          }
+
+          categoriesData.setItemVisual(idx, 'style', style);
+          var symbolVisualList = ['symbol', 'symbolSize', 'symbolKeepAspect'];
+
+          for (var i = 0; i < symbolVisualList.length; i++) {
+            var symbolVisual = itemModel.getShallow(symbolVisualList[i], true);
+
+            if (symbolVisual != null) {
+              categoriesData.setItemVisual(idx, symbolVisualList[i], symbolVisual);
+            }
+          }
+        }); // Assign category color to visual
+
+        if (categoriesData.count()) {
+          data.each(function (idx) {
+            var model = data.getItemModel(idx);
+            var categoryIdx = model.getShallow('category');
+
+            if (categoryIdx != null) {
+              if (typeof categoryIdx === 'string') {
+                categoryIdx = categoryNameIdxMap['ec-' + categoryIdx];
+              }
+
+              var categoryStyle = categoriesData.getItemVisual(categoryIdx, 'style');
+              var style = data.ensureUniqueItemVisual(idx, 'style');
+              extend(style, categoryStyle);
+              var visualList = ['symbol', 'symbolSize', 'symbolKeepAspect'];
+
+              for (var i = 0; i < visualList.length; i++) {
+                data.setItemVisual(idx, visualList[i], categoriesData.getItemVisual(categoryIdx, visualList[i]));
+              }
+            }
+          });
+        }
+      });
+    }
+
+    function normalize$2(a) {
+      if (!(a instanceof Array)) {
+        a = [a, a];
+      }
+
+      return a;
+    }
+
+    function graphEdgeVisual(ecModel) {
+      ecModel.eachSeriesByType('graph', function (seriesModel) {
+        var graph = seriesModel.getGraph();
+        var edgeData = seriesModel.getEdgeData();
+        var symbolType = normalize$2(seriesModel.get('edgeSymbol'));
+        var symbolSize = normalize$2(seriesModel.get('edgeSymbolSize')); // const colorQuery = ['lineStyle', 'color'] as const;
+        // const opacityQuery = ['lineStyle', 'opacity'] as const;
+
+        edgeData.setVisual('fromSymbol', symbolType && symbolType[0]);
+        edgeData.setVisual('toSymbol', symbolType && symbolType[1]);
+        edgeData.setVisual('fromSymbolSize', symbolSize && symbolSize[0]);
+        edgeData.setVisual('toSymbolSize', symbolSize && symbolSize[1]);
+        edgeData.setVisual('style', seriesModel.getModel('lineStyle').getLineStyle());
+        edgeData.each(function (idx) {
+          var itemModel = edgeData.getItemModel(idx);
+          var edge = graph.getEdgeByIndex(idx);
+          var symbolType = normalize$2(itemModel.getShallow('symbol', true));
+          var symbolSize = normalize$2(itemModel.getShallow('symbolSize', true)); // Edge visual must after node visual
+
+          var style = itemModel.getModel('lineStyle').getLineStyle();
+          var existsStyle = edgeData.ensureUniqueItemVisual(idx, 'style');
+          extend(existsStyle, style);
+
+          switch (existsStyle.stroke) {
+            case 'source':
+              {
+                var nodeStyle = edge.node1.getVisual('style');
+                existsStyle.stroke = nodeStyle && nodeStyle.fill;
+                break;
+              }
+
+            case 'target':
+              {
+                var nodeStyle = edge.node2.getVisual('style');
+                existsStyle.stroke = nodeStyle && nodeStyle.fill;
+                break;
+              }
+          }
+
+          symbolType[0] && edge.setVisual('fromSymbol', symbolType[0]);
+          symbolType[1] && edge.setVisual('toSymbol', symbolType[1]);
+          symbolSize[0] && edge.setVisual('fromSymbolSize', symbolSize[0]);
+          symbolSize[1] && edge.setVisual('toSymbolSize', symbolSize[1]);
+        });
+      });
+    }
+
+    var KEY_DELIMITER = '-->';
+    /**
+     * params handler
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     * @returns {*}
+     */
+
+    var getAutoCurvenessParams = function (seriesModel) {
+      return seriesModel.get('autoCurveness') || null;
+    };
+    /**
+     * Generate a list of edge curvatures, 20 is the default
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     * @param {number} appendLength
+     * @return  20 => [0, -0.2, 0.2, -0.4, 0.4, -0.6, 0.6, -0.8, 0.8, -1, 1, -1.2, 1.2, -1.4, 1.4, -1.6, 1.6, -1.8, 1.8, -2]
+     */
+
+
+    var createCurveness = function (seriesModel, appendLength) {
+      var autoCurvenessParmas = getAutoCurvenessParams(seriesModel);
+      var length = 20;
+      var curvenessList = []; // handler the function set
+
+      if (typeof autoCurvenessParmas === 'number') {
+        length = autoCurvenessParmas;
+      } else if (isArray(autoCurvenessParmas)) {
+        seriesModel.__curvenessList = autoCurvenessParmas;
+        return;
+      } // append length
+
+
+      if (appendLength > length) {
+        length = appendLength;
+      } // make sure the length is even
+
+
+      var len = length % 2 ? length + 2 : length + 3;
+      curvenessList = [];
+
+      for (var i = 0; i < len; i++) {
+        curvenessList.push((i % 2 ? i + 1 : i) / 10 * (i % 2 ? -1 : 1));
+      }
+
+      seriesModel.__curvenessList = curvenessList;
+    };
+    /**
+     * Create different cache key data in the positive and negative directions, in order to set the curvature later
+     * @param {number|string|module:echarts/data/Graph.Node} n1
+     * @param {number|string|module:echarts/data/Graph.Node} n2
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     * @returns {string} key
+     */
+
+
+    var getKeyOfEdges = function (n1, n2, seriesModel) {
+      var source = [n1.id, n1.dataIndex].join('.');
+      var target = [n2.id, n2.dataIndex].join('.');
+      return [seriesModel.uid, source, target].join(KEY_DELIMITER);
+    };
+    /**
+     * get opposite key
+     * @param {string} key
+     * @returns {string}
+     */
+
+
+    var getOppositeKey = function (key) {
+      var keys = key.split(KEY_DELIMITER);
+      return [keys[0], keys[2], keys[1]].join(KEY_DELIMITER);
+    };
+    /**
+     * get edgeMap with key
+     * @param edge
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     */
+
+
+    var getEdgeFromMap = function (edge, seriesModel) {
+      var key = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+      return seriesModel.__edgeMap[key];
+    };
+    /**
+     * calculate all cases total length
+     * @param edge
+     * @param seriesModel
+     * @returns {number}
+     */
+
+
+    var getTotalLengthBetweenNodes = function (edge, seriesModel) {
+      var len = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node1, edge.node2, seriesModel), seriesModel);
+      var lenV = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node2, edge.node1, seriesModel), seriesModel);
+      return len + lenV;
+    };
+    /**
+     *
+     * @param key
+     */
+
+
+    var getEdgeMapLengthWithKey = function (key, seriesModel) {
+      var edgeMap = seriesModel.__edgeMap;
+      return edgeMap[key] ? edgeMap[key].length : 0;
+    };
+    /**
+     * Count the number of edges between the same two points, used to obtain the curvature table and the parity of the edge
+     * @see /graph/GraphSeries.js@getInitialData
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     */
+
+
+    function initCurvenessList(seriesModel) {
+      if (!getAutoCurvenessParams(seriesModel)) {
+        return;
+      }
+
+      seriesModel.__curvenessList = [];
+      seriesModel.__edgeMap = {}; // calc the array of curveness List
+
+      createCurveness(seriesModel);
+    }
+    /**
+     * set edgeMap with key
+     * @param {number|string|module:echarts/data/Graph.Node} n1
+     * @param {number|string|module:echarts/data/Graph.Node} n2
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     * @param {number} index
+     */
+
+    function createEdgeMapForCurveness(n1, n2, seriesModel, index) {
+      if (!getAutoCurvenessParams(seriesModel)) {
+        return;
+      }
+
+      var key = getKeyOfEdges(n1, n2, seriesModel);
+      var edgeMap = seriesModel.__edgeMap;
+      var oppositeEdges = edgeMap[getOppositeKey(key)]; // set direction
+
+      if (edgeMap[key] && !oppositeEdges) {
+        edgeMap[key].isForward = true;
+      } else if (oppositeEdges && edgeMap[key]) {
+        oppositeEdges.isForward = true;
+        edgeMap[key].isForward = false;
+      }
+
+      edgeMap[key] = edgeMap[key] || [];
+      edgeMap[key].push(index);
+    }
+    /**
+     * get curvature for edge
+     * @param edge
+     * @param {module:echarts/model/SeriesModel} seriesModel
+     * @param index
+     */
+
+    function getCurvenessForEdge(edge, seriesModel, index, needReverse) {
+      var autoCurvenessParams = getAutoCurvenessParams(seriesModel);
+      var isArrayParam = isArray(autoCurvenessParams);
+
+      if (!autoCurvenessParams) {
+        return null;
+      }
+
+      var edgeArray = getEdgeFromMap(edge, seriesModel);
+
+      if (!edgeArray) {
+        return null;
+      }
+
+      var edgeIndex = -1;
+
+      for (var i = 0; i < edgeArray.length; i++) {
+        if (edgeArray[i] === index) {
+          edgeIndex = i;
+          break;
+        }
+      } // if totalLen is Longer createCurveness
+
+
+      var totalLen = getTotalLengthBetweenNodes(edge, seriesModel);
+      createCurveness(seriesModel, totalLen);
+      edge.lineStyle = edge.lineStyle || {}; // if is opposite edge, must set curvenss to opposite number
+
+      var curKey = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+      var curvenessList = seriesModel.__curvenessList; // if pass array no need parity
+
+      var parityCorrection = isArrayParam ? 0 : totalLen % 2 ? 0 : 1;
+
+      if (!edgeArray.isForward) {
+        // the opposite edge show outside
+        var oppositeKey = getOppositeKey(curKey);
+        var len = getEdgeMapLengthWithKey(oppositeKey, seriesModel);
+        var resValue = curvenessList[edgeIndex + len + parityCorrection]; // isNeedReverse, simple, force type need reverse the curveness in the junction of the forword and the opposite
+
+        if (needReverse) {
+          // set as array may make the parity handle with the len of opposite
+          if (isArrayParam) {
+            if (autoCurvenessParams && autoCurvenessParams[0] === 0) {
+              return (len + parityCorrection) % 2 ? resValue : -resValue;
+            } else {
+              return ((len % 2 ? 0 : 1) + parityCorrection) % 2 ? resValue : -resValue;
+            }
+          } else {
+            return (len + parityCorrection) % 2 ? resValue : -resValue;
+          }
+        } else {
+          return curvenessList[edgeIndex + len + parityCorrection];
+        }
+      } else {
+        return curvenessList[parityCorrection + edgeIndex];
+      }
+    }
+
+    function simpleLayout(seriesModel) {
+      var coordSys = seriesModel.coordinateSystem;
+
+      if (coordSys && coordSys.type !== 'view') {
+        return;
+      }
+
+      var graph = seriesModel.getGraph();
+      graph.eachNode(function (node) {
+        var model = node.getModel();
+        node.setLayout([+model.get('x'), +model.get('y')]);
+      });
+      simpleLayoutEdge(graph, seriesModel);
+    }
+    function simpleLayoutEdge(graph, seriesModel) {
+      graph.eachEdge(function (edge, index) {
+        var curveness = retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -getCurvenessForEdge(edge, seriesModel, index, true), 0);
+        var p1 = clone$1(edge.node1.getLayout());
+        var p2 = clone$1(edge.node2.getLayout());
+        var points = [p1, p2];
+
+        if (+curveness) {
+          points.push([(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * curveness]);
+        }
+
+        edge.setLayout(points);
+      });
+    }
+
+    function graphSimpleLayout(ecModel, api) {
+      ecModel.eachSeriesByType('graph', function (seriesModel) {
+        var layout = seriesModel.get('layout');
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys && coordSys.type !== 'view') {
+          var data_1 = seriesModel.getData();
+          var dimensions_1 = [];
+          each(coordSys.dimensions, function (coordDim) {
+            dimensions_1 = dimensions_1.concat(data_1.mapDimensionsAll(coordDim));
+          });
+
+          for (var dataIndex = 0; dataIndex < data_1.count(); dataIndex++) {
+            var value = [];
+            var hasValue = false;
+
+            for (var i = 0; i < dimensions_1.length; i++) {
+              var val = data_1.get(dimensions_1[i], dataIndex);
+
+              if (!isNaN(val)) {
+                hasValue = true;
+              }
+
+              value.push(val);
+            }
+
+            if (hasValue) {
+              data_1.setItemLayout(dataIndex, coordSys.dataToPoint(value));
+            } else {
+              // Also {Array.<number>}, not undefined to avoid if...else... statement
+              data_1.setItemLayout(dataIndex, [NaN, NaN]);
+            }
+          }
+
+          simpleLayoutEdge(data_1.graph, seriesModel);
+        } else if (!layout || layout === 'none') {
+          simpleLayout(seriesModel);
+        }
+      });
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function getNodeGlobalScale(seriesModel) {
+      var coordSys = seriesModel.coordinateSystem;
+
+      if (coordSys.type !== 'view') {
+        return 1;
+      }
+
+      var nodeScaleRatio = seriesModel.option.nodeScaleRatio;
+      var groupZoom = coordSys.scaleX; // Scale node when zoom changes
+
+      var roamZoom = coordSys.getZoom();
+      var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+      return nodeScale / groupZoom;
+    }
+    function getSymbolSize(node) {
+      var symbolSize = node.getVisual('symbolSize');
+
+      if (symbolSize instanceof Array) {
+        symbolSize = (symbolSize[0] + symbolSize[1]) / 2;
+      }
+
+      return +symbolSize;
+    }
+
+    var PI$6 = Math.PI;
+    var _symbolRadiansHalf = [];
+    /**
+     * `basedOn` can be:
+     * 'value':
+     *     This layout is not accurate and have same bad case. For example,
+     *     if the min value is very smaller than the max value, the nodes
+     *     with the min value probably overlap even though there is enough
+     *     space to layout them. So we only use this approach in the as the
+     *     init layout of the force layout.
+     *     FIXME
+     *     Probably we do not need this method any more but use
+     *     `basedOn: 'symbolSize'` in force layout if
+     *     delay its init operations to GraphView.
+     * 'symbolSize':
+     *     This approach work only if all of the symbol size calculated.
+     *     That is, the progressive rendering is not applied to graph.
+     *     FIXME
+     *     If progressive rendering is applied to graph some day,
+     *     probably we have to use `basedOn: 'value'`.
+     */
+
+    function circularLayout(seriesModel, basedOn) {
+      var coordSys = seriesModel.coordinateSystem;
+
+      if (coordSys && coordSys.type !== 'view') {
+        return;
+      }
+
+      var rect = coordSys.getBoundingRect();
+      var nodeData = seriesModel.getData();
+      var graph = nodeData.graph;
+      var cx = rect.width / 2 + rect.x;
+      var cy = rect.height / 2 + rect.y;
+      var r = Math.min(rect.width, rect.height) / 2;
+      var count = nodeData.count();
+      nodeData.setLayout({
+        cx: cx,
+        cy: cy
+      });
+
+      if (!count) {
+        return;
+      }
+
+      _layoutNodesBasedOn[basedOn](seriesModel, graph, nodeData, r, cx, cy, count);
+
+      graph.eachEdge(function (edge, index) {
+        var curveness = retrieve3(edge.getModel().get(['lineStyle', 'curveness']), getCurvenessForEdge(edge, seriesModel, index), 0);
+        var p1 = clone$1(edge.node1.getLayout());
+        var p2 = clone$1(edge.node2.getLayout());
+        var cp1;
+        var x12 = (p1[0] + p2[0]) / 2;
+        var y12 = (p1[1] + p2[1]) / 2;
+
+        if (+curveness) {
+          curveness *= 3;
+          cp1 = [cx * curveness + x12 * (1 - curveness), cy * curveness + y12 * (1 - curveness)];
+        }
+
+        edge.setLayout([p1, p2, cp1]);
+      });
+    }
+    var _layoutNodesBasedOn = {
+      value: function (seriesModel, graph, nodeData, r, cx, cy, count) {
+        var angle = 0;
+        var sum = nodeData.getSum('value');
+        var unitAngle = Math.PI * 2 / (sum || count);
+        graph.eachNode(function (node) {
+          var value = node.getValue('value');
+          var radianHalf = unitAngle * (sum ? value : 1) / 2;
+          angle += radianHalf;
+          node.setLayout([r * Math.cos(angle) + cx, r * Math.sin(angle) + cy]);
+          angle += radianHalf;
+        });
+      },
+      symbolSize: function (seriesModel, graph, nodeData, r, cx, cy, count) {
+        var sumRadian = 0;
+        _symbolRadiansHalf.length = count;
+        var nodeScale = getNodeGlobalScale(seriesModel);
+        graph.eachNode(function (node) {
+          var symbolSize = getSymbolSize(node); // Normally this case will not happen, but we still add
+          // some the defensive code (2px is an arbitrary value).
+
+          isNaN(symbolSize) && (symbolSize = 2);
+          symbolSize < 0 && (symbolSize = 0);
+          symbolSize *= nodeScale;
+          var symbolRadianHalf = Math.asin(symbolSize / 2 / r); // when `symbolSize / 2` is bigger than `r`.
+
+          isNaN(symbolRadianHalf) && (symbolRadianHalf = PI$6 / 2);
+          _symbolRadiansHalf[node.dataIndex] = symbolRadianHalf;
+          sumRadian += symbolRadianHalf * 2;
+        });
+        var halfRemainRadian = (2 * PI$6 - sumRadian) / count / 2;
+        var angle = 0;
+        graph.eachNode(function (node) {
+          var radianHalf = halfRemainRadian + _symbolRadiansHalf[node.dataIndex];
+          angle += radianHalf;
+          node.setLayout([r * Math.cos(angle) + cx, r * Math.sin(angle) + cy]);
+          angle += radianHalf;
+        });
+      }
+    };
+
+    function graphCircularLayout(ecModel) {
+      ecModel.eachSeriesByType('graph', function (seriesModel) {
+        if (seriesModel.get('layout') === 'circular') {
+          circularLayout(seriesModel, 'symbolSize');
+        }
+      });
+    }
+
+    var scaleAndAdd$1 = scaleAndAdd; // function adjacentNode(n, e) {
+    //     return e.n1 === n ? e.n2 : e.n1;
+    // }
+
+    function forceLayout(inNodes, inEdges, opts) {
+      var nodes = inNodes;
+      var edges = inEdges;
+      var rect = opts.rect;
+      var width = rect.width;
+      var height = rect.height;
+      var center = [rect.x + width / 2, rect.y + height / 2]; // let scale = opts.scale || 1;
+
+      var gravity = opts.gravity == null ? 0.1 : opts.gravity; // for (let i = 0; i < edges.length; i++) {
+      //     let e = edges[i];
+      //     let n1 = e.n1;
+      //     let n2 = e.n2;
+      //     n1.edges = n1.edges || [];
+      //     n2.edges = n2.edges || [];
+      //     n1.edges.push(e);
+      //     n2.edges.push(e);
+      // }
+      // Init position
+
+      for (var i = 0; i < nodes.length; i++) {
+        var n = nodes[i];
+
+        if (!n.p) {
+          n.p = create(width * (Math.random() - 0.5) + center[0], height * (Math.random() - 0.5) + center[1]);
+        }
+
+        n.pp = clone$1(n.p);
+        n.edges = null;
+      } // Formula in 'Graph Drawing by Force-directed Placement'
+      // let k = scale * Math.sqrt(width * height / nodes.length);
+      // let k2 = k * k;
+
+
+      var initialFriction = opts.friction == null ? 0.6 : opts.friction;
+      var friction = initialFriction;
+      var beforeStepCallback;
+      var afterStepCallback;
+      return {
+        warmUp: function () {
+          friction = initialFriction * 0.8;
+        },
+        setFixed: function (idx) {
+          nodes[idx].fixed = true;
+        },
+        setUnfixed: function (idx) {
+          nodes[idx].fixed = false;
+        },
+
+        /**
+         * Before step hook
+         */
+        beforeStep: function (cb) {
+          beforeStepCallback = cb;
+        },
+
+        /**
+         * After step hook
+         */
+        afterStep: function (cb) {
+          afterStepCallback = cb;
+        },
+
+        /**
+         * Some formulas were originally copied from "d3.js"
+         * https://github.com/d3/d3/blob/b516d77fb8566b576088e73410437494717ada26/src/layout/force.js
+         * with some modifications made for this project.
+         * See the license statement at the head of this file.
+         */
+        step: function (cb) {
+          beforeStepCallback && beforeStepCallback(nodes, edges);
+          var v12 = [];
+          var nLen = nodes.length;
+
+          for (var i = 0; i < edges.length; i++) {
+            var e = edges[i];
+
+            if (e.ignoreForceLayout) {
+              continue;
+            }
+
+            var n1 = e.n1;
+            var n2 = e.n2;
+            sub(v12, n2.p, n1.p);
+            var d = len(v12) - e.d;
+            var w = n2.w / (n1.w + n2.w);
+
+            if (isNaN(w)) {
+              w = 0;
+            }
+
+            normalize(v12, v12);
+            !n1.fixed && scaleAndAdd$1(n1.p, n1.p, v12, w * d * friction);
+            !n2.fixed && scaleAndAdd$1(n2.p, n2.p, v12, -(1 - w) * d * friction);
+          } // Gravity
+
+
+          for (var i = 0; i < nLen; i++) {
+            var n = nodes[i];
+
+            if (!n.fixed) {
+              sub(v12, center, n.p); // let d = vec2.len(v12);
+              // vec2.scale(v12, v12, 1 / d);
+              // let gravityFactor = gravity;
+
+              scaleAndAdd$1(n.p, n.p, v12, gravity * friction);
+            }
+          } // Repulsive
+          // PENDING
+
+
+          for (var i = 0; i < nLen; i++) {
+            var n1 = nodes[i];
+
+            for (var j = i + 1; j < nLen; j++) {
+              var n2 = nodes[j];
+              sub(v12, n2.p, n1.p);
+              var d = len(v12);
+
+              if (d === 0) {
+                // Random repulse
+                set(v12, Math.random() - 0.5, Math.random() - 0.5);
+                d = 1;
+              }
+
+              var repFact = (n1.rep + n2.rep) / d / d;
+              !n1.fixed && scaleAndAdd$1(n1.pp, n1.pp, v12, repFact);
+              !n2.fixed && scaleAndAdd$1(n2.pp, n2.pp, v12, -repFact);
+            }
+          }
+
+          var v = [];
+
+          for (var i = 0; i < nLen; i++) {
+            var n = nodes[i];
+
+            if (!n.fixed) {
+              sub(v, n.p, n.pp);
+              scaleAndAdd$1(n.p, n.p, v, friction);
+              copy(n.pp, n.p);
+            }
+          }
+
+          friction = friction * 0.992;
+          var finished = friction < 0.01;
+          afterStepCallback && afterStepCallback(nodes, edges, finished);
+          cb && cb(finished);
+        }
+      };
+    }
+
+    function graphForceLayout(ecModel) {
+      ecModel.eachSeriesByType('graph', function (graphSeries) {
+        var coordSys = graphSeries.coordinateSystem;
+
+        if (coordSys && coordSys.type !== 'view') {
+          return;
+        }
+
+        if (graphSeries.get('layout') === 'force') {
+          var preservedPoints_1 = graphSeries.preservedPoints || {};
+          var graph_1 = graphSeries.getGraph();
+          var nodeData_1 = graph_1.data;
+          var edgeData = graph_1.edgeData;
+          var forceModel = graphSeries.getModel('force');
+          var initLayout = forceModel.get('initLayout');
+
+          if (graphSeries.preservedPoints) {
+            nodeData_1.each(function (idx) {
+              var id = nodeData_1.getId(idx);
+              nodeData_1.setItemLayout(idx, preservedPoints_1[id] || [NaN, NaN]);
+            });
+          } else if (!initLayout || initLayout === 'none') {
+            simpleLayout(graphSeries);
+          } else if (initLayout === 'circular') {
+            circularLayout(graphSeries, 'value');
+          }
+
+          var nodeDataExtent_1 = nodeData_1.getDataExtent('value');
+          var edgeDataExtent_1 = edgeData.getDataExtent('value'); // let edgeDataExtent = edgeData.getDataExtent('value');
+
+          var repulsion = forceModel.get('repulsion');
+          var edgeLength = forceModel.get('edgeLength');
+          var repulsionArr_1 = isArray(repulsion) ? repulsion : [repulsion, repulsion];
+          var edgeLengthArr_1 = isArray(edgeLength) ? edgeLength : [edgeLength, edgeLength]; // Larger value has smaller length
+
+          edgeLengthArr_1 = [edgeLengthArr_1[1], edgeLengthArr_1[0]];
+          var nodes_1 = nodeData_1.mapArray('value', function (value, idx) {
+            var point = nodeData_1.getItemLayout(idx);
+            var rep = linearMap(value, nodeDataExtent_1, repulsionArr_1);
+
+            if (isNaN(rep)) {
+              rep = (repulsionArr_1[0] + repulsionArr_1[1]) / 2;
+            }
+
+            return {
+              w: rep,
+              rep: rep,
+              fixed: nodeData_1.getItemModel(idx).get('fixed'),
+              p: !point || isNaN(point[0]) || isNaN(point[1]) ? null : point
+            };
+          });
+          var edges = edgeData.mapArray('value', function (value, idx) {
+            var edge = graph_1.getEdgeByIndex(idx);
+            var d = linearMap(value, edgeDataExtent_1, edgeLengthArr_1);
+
+            if (isNaN(d)) {
+              d = (edgeLengthArr_1[0] + edgeLengthArr_1[1]) / 2;
+            }
+
+            var edgeModel = edge.getModel();
+            var curveness = retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -getCurvenessForEdge(edge, graphSeries, idx, true), 0);
+            return {
+              n1: nodes_1[edge.node1.dataIndex],
+              n2: nodes_1[edge.node2.dataIndex],
+              d: d,
+              curveness: curveness,
+              ignoreForceLayout: edgeModel.get('ignoreForceLayout')
+            };
+          }); // let coordSys = graphSeries.coordinateSystem;
+
+          var rect = coordSys.getBoundingRect();
+          var forceInstance = forceLayout(nodes_1, edges, {
+            rect: rect,
+            gravity: forceModel.get('gravity'),
+            friction: forceModel.get('friction')
+          });
+          forceInstance.beforeStep(function (nodes, edges) {
+            for (var i = 0, l = nodes.length; i < l; i++) {
+              if (nodes[i].fixed) {
+                // Write back to layout instance
+                copy(nodes[i].p, graph_1.getNodeByIndex(i).getLayout());
+              }
+            }
+          });
+          forceInstance.afterStep(function (nodes, edges, stopped) {
+            for (var i = 0, l = nodes.length; i < l; i++) {
+              if (!nodes[i].fixed) {
+                graph_1.getNodeByIndex(i).setLayout(nodes[i].p);
+              }
+
+              preservedPoints_1[nodeData_1.getId(i)] = nodes[i].p;
+            }
+
+            for (var i = 0, l = edges.length; i < l; i++) {
+              var e = edges[i];
+              var edge = graph_1.getEdgeByIndex(i);
+              var p1 = e.n1.p;
+              var p2 = e.n2.p;
+              var points = edge.getLayout();
+              points = points ? points.slice() : [];
+              points[0] = points[0] || [];
+              points[1] = points[1] || [];
+              copy(points[0], p1);
+              copy(points[1], p2);
+
+              if (+e.curveness) {
+                points[2] = [(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * e.curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * e.curveness];
+              }
+
+              edge.setLayout(points);
+            }
+          });
+          graphSeries.forceLayout = forceInstance;
+          graphSeries.preservedPoints = preservedPoints_1; // Step to get the layout
+
+          forceInstance.step();
+        } else {
+          // Remove prev injected forceLayout instance
+          graphSeries.forceLayout = null;
+        }
+      });
+    }
+
+    function getViewRect$2(seriesModel, api, aspect) {
+      var option = extend(seriesModel.getBoxLayoutParams(), {
+        aspect: aspect
+      });
+      return getLayoutRect(option, {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+    }
+
+    function createViewCoordSys(ecModel, api) {
+      var viewList = [];
+      ecModel.eachSeriesByType('graph', function (seriesModel) {
+        var coordSysType = seriesModel.get('coordinateSystem');
+
+        if (!coordSysType || coordSysType === 'view') {
+          var data_1 = seriesModel.getData();
+          var positions = data_1.mapArray(function (idx) {
+            var itemModel = data_1.getItemModel(idx);
+            return [+itemModel.get('x'), +itemModel.get('y')];
+          });
+          var min = [];
+          var max = [];
+          fromPoints(positions, min, max); // If width or height is 0
+
+          if (max[0] - min[0] === 0) {
+            max[0] += 1;
+            min[0] -= 1;
+          }
+
+          if (max[1] - min[1] === 0) {
+            max[1] += 1;
+            min[1] -= 1;
+          }
+
+          var aspect = (max[0] - min[0]) / (max[1] - min[1]); // FIXME If get view rect after data processed?
+
+          var viewRect = getViewRect$2(seriesModel, api, aspect); // Position may be NaN, use view rect instead
+
+          if (isNaN(aspect)) {
+            min = [viewRect.x, viewRect.y];
+            max = [viewRect.x + viewRect.width, viewRect.y + viewRect.height];
+          }
+
+          var bbWidth = max[0] - min[0];
+          var bbHeight = max[1] - min[1];
+          var viewWidth = viewRect.width;
+          var viewHeight = viewRect.height;
+          var viewCoordSys = seriesModel.coordinateSystem = new View();
+          viewCoordSys.zoomLimit = seriesModel.get('scaleLimit');
+          viewCoordSys.setBoundingRect(min[0], min[1], bbWidth, bbHeight);
+          viewCoordSys.setViewRect(viewRect.x, viewRect.y, viewWidth, viewHeight); // Update roam info
+
+          viewCoordSys.setCenter(seriesModel.get('center'));
+          viewCoordSys.setZoom(seriesModel.get('zoom'));
+          viewList.push(viewCoordSys);
+        }
+      });
+      return viewList;
+    }
+
+    var straightLineProto = Line.prototype;
+    var bezierCurveProto = BezierCurve.prototype;
+
+    var StraightLineShape =
+    /** @class */
+    function () {
+      function StraightLineShape() {
+        // Start point
+        this.x1 = 0;
+        this.y1 = 0; // End point
+
+        this.x2 = 0;
+        this.y2 = 0;
+        this.percent = 1;
+      }
+
+      return StraightLineShape;
+    }();
+
+    var CurveShape =
+    /** @class */
+    function (_super) {
+      __extends(CurveShape, _super);
+
+      function CurveShape() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      return CurveShape;
+    }(StraightLineShape);
+
+    function isStraightLine(shape) {
+      return isNaN(+shape.cpx1) || isNaN(+shape.cpy1);
+    }
+
+    var ECLinePath =
+    /** @class */
+    function (_super) {
+      __extends(ECLinePath, _super);
+
+      function ECLinePath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'ec-line';
+        return _this;
+      }
+
+      ECLinePath.prototype.getDefaultStyle = function () {
+        return {
+          stroke: '#000',
+          fill: null
+        };
+      };
+
+      ECLinePath.prototype.getDefaultShape = function () {
+        return new StraightLineShape();
+      };
+
+      ECLinePath.prototype.buildPath = function (ctx, shape) {
+        if (isStraightLine(shape)) {
+          straightLineProto.buildPath.call(this, ctx, shape);
+        } else {
+          bezierCurveProto.buildPath.call(this, ctx, shape);
+        }
+      };
+
+      ECLinePath.prototype.pointAt = function (t) {
+        if (isStraightLine(this.shape)) {
+          return straightLineProto.pointAt.call(this, t);
+        } else {
+          return bezierCurveProto.pointAt.call(this, t);
+        }
+      };
+
+      ECLinePath.prototype.tangentAt = function (t) {
+        var shape = this.shape;
+        var p = isStraightLine(shape) ? [shape.x2 - shape.x1, shape.y2 - shape.y1] : bezierCurveProto.tangentAt.call(this, t);
+        return normalize(p, p);
+      };
+
+      return ECLinePath;
+    }(Path);
+
+    var SYMBOL_CATEGORIES = ['fromSymbol', 'toSymbol'];
+
+    function makeSymbolTypeKey(symbolCategory) {
+      return '_' + symbolCategory + 'Type';
+    }
+    /**
+     * @inner
+     */
+
+
+    function createSymbol$1(name, lineData, idx) {
+      var symbolType = lineData.getItemVisual(idx, name);
+
+      if (!symbolType || symbolType === 'none') {
+        return;
+      }
+
+      var symbolSize = lineData.getItemVisual(idx, name + 'Size');
+      var symbolRotate = lineData.getItemVisual(idx, name + 'Rotate');
+      var symbolSizeArr = isArray(symbolSize) ? symbolSize : [symbolSize, symbolSize];
+      var symbolPath = createSymbol(symbolType, -symbolSizeArr[0] / 2, -symbolSizeArr[1] / 2, symbolSizeArr[0], symbolSizeArr[1]);
+      symbolPath.__specifiedRotation = symbolRotate == null || isNaN(symbolRotate) ? void 0 : +symbolRotate * Math.PI / 180 || 0;
+      symbolPath.name = name;
+      return symbolPath;
+    }
+
+    function createLine(points) {
+      var line = new ECLinePath({
+        name: 'line',
+        subPixelOptimize: true
+      });
+      setLinePoints(line.shape, points);
+      return line;
+    }
+
+    function setLinePoints(targetShape, points) {
+      targetShape.x1 = points[0][0];
+      targetShape.y1 = points[0][1];
+      targetShape.x2 = points[1][0];
+      targetShape.y2 = points[1][1];
+      targetShape.percent = 1;
+      var cp1 = points[2];
+
+      if (cp1) {
+        targetShape.cpx1 = cp1[0];
+        targetShape.cpy1 = cp1[1];
+      } else {
+        targetShape.cpx1 = NaN;
+        targetShape.cpy1 = NaN;
+      }
+    }
+
+    var Line$1 =
+    /** @class */
+    function (_super) {
+      __extends(Line, _super);
+
+      function Line(lineData, idx, seriesScope) {
+        var _this = _super.call(this) || this;
+
+        _this._createLine(lineData, idx, seriesScope);
+
+        return _this;
+      }
+
+      Line.prototype._createLine = function (lineData, idx, seriesScope) {
+        var seriesModel = lineData.hostModel;
+        var linePoints = lineData.getItemLayout(idx);
+        var line = createLine(linePoints);
+        line.shape.percent = 0;
+        initProps(line, {
+          shape: {
+            percent: 1
+          }
+        }, seriesModel, idx);
+        this.add(line);
+        each(SYMBOL_CATEGORIES, function (symbolCategory) {
+          var symbol = createSymbol$1(symbolCategory, lineData, idx); // symbols must added after line to make sure
+          // it will be updated after line#update.
+          // Or symbol position and rotation update in line#beforeUpdate will be one frame slow
+
+          this.add(symbol);
+          this[makeSymbolTypeKey(symbolCategory)] = lineData.getItemVisual(idx, symbolCategory);
+        }, this);
+
+        this._updateCommonStl(lineData, idx, seriesScope);
+      }; // TODO More strict on the List type in parameters?
+
+
+      Line.prototype.updateData = function (lineData, idx, seriesScope) {
+        var seriesModel = lineData.hostModel;
+        var line = this.childOfName('line');
+        var linePoints = lineData.getItemLayout(idx);
+        var target = {
+          shape: {}
+        };
+        setLinePoints(target.shape, linePoints);
+        updateProps(line, target, seriesModel, idx);
+        each(SYMBOL_CATEGORIES, function (symbolCategory) {
+          var symbolType = lineData.getItemVisual(idx, symbolCategory);
+          var key = makeSymbolTypeKey(symbolCategory); // Symbol changed
+
+          if (this[key] !== symbolType) {
+            this.remove(this.childOfName(symbolCategory));
+            var symbol = createSymbol$1(symbolCategory, lineData, idx);
+            this.add(symbol);
+          }
+
+          this[key] = symbolType;
+        }, this);
+
+        this._updateCommonStl(lineData, idx, seriesScope);
+      };
+
+      Line.prototype.getLinePath = function () {
+        return this.childAt(0);
+      };
+
+      Line.prototype._updateCommonStl = function (lineData, idx, seriesScope) {
+        var seriesModel = lineData.hostModel;
+        var line = this.childOfName('line');
+        var emphasisLineStyle = seriesScope && seriesScope.emphasisLineStyle;
+        var blurLineStyle = seriesScope && seriesScope.blurLineStyle;
+        var selectLineStyle = seriesScope && seriesScope.selectLineStyle;
+        var labelStatesModels = seriesScope && seriesScope.labelStatesModels; // Optimization for large dataset
+
+        if (!seriesScope || lineData.hasItemOption) {
+          var itemModel = lineData.getItemModel(idx);
+          emphasisLineStyle = itemModel.getModel(['emphasis', 'lineStyle']).getLineStyle();
+          blurLineStyle = itemModel.getModel(['blur', 'lineStyle']).getLineStyle();
+          selectLineStyle = itemModel.getModel(['select', 'lineStyle']).getLineStyle();
+          labelStatesModels = getLabelStatesModels(itemModel);
+        }
+
+        var lineStyle = lineData.getItemVisual(idx, 'style');
+        var visualColor = lineStyle.stroke;
+        line.useStyle(lineStyle);
+        line.style.fill = null;
+        line.style.strokeNoScale = true;
+        line.ensureState('emphasis').style = emphasisLineStyle;
+        line.ensureState('blur').style = blurLineStyle;
+        line.ensureState('select').style = selectLineStyle; // Update symbol
+
+        each(SYMBOL_CATEGORIES, function (symbolCategory) {
+          var symbol = this.childOfName(symbolCategory);
+
+          if (symbol) {
+            // Share opacity and color with line.
+            symbol.setColor(visualColor);
+            symbol.style.opacity = lineStyle.opacity;
+
+            for (var i = 0; i < SPECIAL_STATES.length; i++) {
+              var stateName = SPECIAL_STATES[i];
+              var lineState = line.getState(stateName);
+
+              if (lineState) {
+                var lineStateStyle = lineState.style || {};
+                var state = symbol.ensureState(stateName);
+                var stateStyle = state.style || (state.style = {});
+
+                if (lineStateStyle.stroke != null) {
+                  stateStyle[symbol.__isEmptyBrush ? 'stroke' : 'fill'] = lineStateStyle.stroke;
+                }
+
+                if (lineStateStyle.opacity != null) {
+                  stateStyle.opacity = lineStateStyle.opacity;
+                }
+              }
+            }
+
+            symbol.markRedraw();
+          }
+        }, this);
+        var rawVal = seriesModel.getRawValue(idx);
+        setLabelStyle(this, labelStatesModels, {
+          labelDataIndex: idx,
+          labelFetcher: {
+            getFormattedLabel: function (dataIndex, stateName) {
+              return seriesModel.getFormattedLabel(dataIndex, stateName, lineData.dataType);
+            }
+          },
+          inheritColor: visualColor || '#000',
+          defaultOpacity: lineStyle.opacity,
+          defaultText: (rawVal == null ? lineData.getName(idx) : isFinite(rawVal) ? round(rawVal) : rawVal) + ''
+        });
+        var label = this.getTextContent(); // Always set `textStyle` even if `normalStyle.text` is null, because default
+        // values have to be set on `normalStyle`.
+
+        if (label) {
+          var labelNormalModel = labelStatesModels.normal;
+          label.__align = label.style.align;
+          label.__verticalAlign = label.style.verticalAlign; // 'start', 'middle', 'end'
+
+          label.__position = labelNormalModel.get('position') || 'middle';
+          var distance = labelNormalModel.get('distance');
+
+          if (!isArray(distance)) {
+            distance = [distance, distance];
+          }
+
+          label.__labelDistance = distance;
+        }
+
+        this.setTextConfig({
+          position: null,
+          local: true,
+          inside: false // Can't be inside for stroke element.
+
+        });
+        enableHoverEmphasis(this);
+      };
+
+      Line.prototype.highlight = function () {
+        enterEmphasis(this);
+      };
+
+      Line.prototype.downplay = function () {
+        leaveEmphasis(this);
+      };
+
+      Line.prototype.updateLayout = function (lineData, idx) {
+        this.setLinePoints(lineData.getItemLayout(idx));
+      };
+
+      Line.prototype.setLinePoints = function (points) {
+        var linePath = this.childOfName('line');
+        setLinePoints(linePath.shape, points);
+        linePath.dirty();
+      };
+
+      Line.prototype.beforeUpdate = function () {
+        var lineGroup = this;
+        var symbolFrom = lineGroup.childOfName('fromSymbol');
+        var symbolTo = lineGroup.childOfName('toSymbol');
+        var label = lineGroup.getTextContent(); // Quick reject
+
+        if (!symbolFrom && !symbolTo && (!label || label.ignore)) {
+          return;
+        }
+
+        var invScale = 1;
+        var parentNode = this.parent;
+
+        while (parentNode) {
+          if (parentNode.scaleX) {
+            invScale /= parentNode.scaleX;
+          }
+
+          parentNode = parentNode.parent;
+        }
+
+        var line = lineGroup.childOfName('line'); // If line not changed
+        // FIXME Parent scale changed
+
+        if (!this.__dirty && !line.__dirty) {
+          return;
+        }
+
+        var percent = line.shape.percent;
+        var fromPos = line.pointAt(0);
+        var toPos = line.pointAt(percent);
+        var d = sub([], toPos, fromPos);
+        normalize(d, d);
+
+        function setSymbolRotation(symbol, percent) {
+          // Fix #12388
+          // when symbol is set to be 'arrow' in markLine,
+          // symbolRotate value will be ignored, and compulsively use tangent angle.
+          // rotate by default if symbol rotation is not specified
+          var specifiedRotation = symbol.__specifiedRotation;
+
+          if (specifiedRotation == null) {
+            var tangent = line.tangentAt(percent);
+            symbol.attr('rotation', (percent === 1 ? -1 : 1) * Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+          } else {
+            symbol.attr('rotation', specifiedRotation);
+          }
+        }
+
+        if (symbolFrom) {
+          symbolFrom.setPosition(fromPos);
+          setSymbolRotation(symbolFrom, 0);
+          symbolFrom.scaleX = symbolFrom.scaleY = invScale * percent;
+          symbolFrom.markRedraw();
+        }
+
+        if (symbolTo) {
+          symbolTo.setPosition(toPos);
+          setSymbolRotation(symbolTo, 1);
+          symbolTo.scaleX = symbolTo.scaleY = invScale * percent;
+          symbolTo.markRedraw();
+        }
+
+        if (label && !label.ignore) {
+          label.x = label.y = 0;
+          label.originX = label.originY = 0;
+          var textAlign = void 0;
+          var textVerticalAlign = void 0;
+          var distance = label.__labelDistance;
+          var distanceX = distance[0] * invScale;
+          var distanceY = distance[1] * invScale;
+          var halfPercent = percent / 2;
+          var tangent = line.tangentAt(halfPercent);
+          var n = [tangent[1], -tangent[0]];
+          var cp = line.pointAt(halfPercent);
+
+          if (n[1] > 0) {
+            n[0] = -n[0];
+            n[1] = -n[1];
+          }
+
+          var dir = tangent[0] < 0 ? -1 : 1;
+
+          if (label.__position !== 'start' && label.__position !== 'end') {
+            var rotation = -Math.atan2(tangent[1], tangent[0]);
+
+            if (toPos[0] < fromPos[0]) {
+              rotation = Math.PI + rotation;
+            }
+
+            label.rotation = rotation;
+          }
+
+          var dy = void 0;
+
+          switch (label.__position) {
+            case 'insideStartTop':
+            case 'insideMiddleTop':
+            case 'insideEndTop':
+            case 'middle':
+              dy = -distanceY;
+              textVerticalAlign = 'bottom';
+              break;
+
+            case 'insideStartBottom':
+            case 'insideMiddleBottom':
+            case 'insideEndBottom':
+              dy = distanceY;
+              textVerticalAlign = 'top';
+              break;
+
+            default:
+              dy = 0;
+              textVerticalAlign = 'middle';
+          }
+
+          switch (label.__position) {
+            case 'end':
+              label.x = d[0] * distanceX + toPos[0];
+              label.y = d[1] * distanceY + toPos[1];
+              textAlign = d[0] > 0.8 ? 'left' : d[0] < -0.8 ? 'right' : 'center';
+              textVerticalAlign = d[1] > 0.8 ? 'top' : d[1] < -0.8 ? 'bottom' : 'middle';
+              break;
+
+            case 'start':
+              label.x = -d[0] * distanceX + fromPos[0];
+              label.y = -d[1] * distanceY + fromPos[1];
+              textAlign = d[0] > 0.8 ? 'right' : d[0] < -0.8 ? 'left' : 'center';
+              textVerticalAlign = d[1] > 0.8 ? 'bottom' : d[1] < -0.8 ? 'top' : 'middle';
+              break;
+
+            case 'insideStartTop':
+            case 'insideStart':
+            case 'insideStartBottom':
+              label.x = distanceX * dir + fromPos[0];
+              label.y = fromPos[1] + dy;
+              textAlign = tangent[0] < 0 ? 'right' : 'left';
+              label.originX = -distanceX * dir;
+              label.originY = -dy;
+              break;
+
+            case 'insideMiddleTop':
+            case 'insideMiddle':
+            case 'insideMiddleBottom':
+            case 'middle':
+              label.x = cp[0];
+              label.y = cp[1] + dy;
+              textAlign = 'center';
+              label.originY = -dy;
+              break;
+
+            case 'insideEndTop':
+            case 'insideEnd':
+            case 'insideEndBottom':
+              label.x = -distanceX * dir + toPos[0];
+              label.y = toPos[1] + dy;
+              textAlign = tangent[0] >= 0 ? 'right' : 'left';
+              label.originX = distanceX * dir;
+              label.originY = -dy;
+              break;
+          }
+
+          label.scaleX = label.scaleY = invScale;
+          label.setStyle({
+            // Use the user specified text align and baseline first
+            verticalAlign: label.__verticalAlign || textVerticalAlign,
+            align: label.__align || textAlign
+          });
+        }
+      };
+
+      return Line;
+    }(Group);
+
+    var LineDraw =
+    /** @class */
+    function () {
+      function LineDraw(LineCtor) {
+        this.group = new Group();
+        this._LineCtor = LineCtor || Line$1;
+      }
+
+      LineDraw.prototype.isPersistent = function () {
+        return true;
+      };
+
+      LineDraw.prototype.updateData = function (lineData) {
+        var _this = this;
+
+        var lineDraw = this;
+        var group = lineDraw.group;
+        var oldLineData = lineDraw._lineData;
+        lineDraw._lineData = lineData; // There is no oldLineData only when first rendering or switching from
+        // stream mode to normal mode, where previous elements should be removed.
+
+        if (!oldLineData) {
+          group.removeAll();
+        }
+
+        var seriesScope = makeSeriesScope$1(lineData);
+        lineData.diff(oldLineData).add(function (idx) {
+          _this._doAdd(lineData, idx, seriesScope);
+        }).update(function (newIdx, oldIdx) {
+          _this._doUpdate(oldLineData, lineData, oldIdx, newIdx, seriesScope);
+        }).remove(function (idx) {
+          group.remove(oldLineData.getItemGraphicEl(idx));
+        }).execute();
+      };
+
+      LineDraw.prototype.updateLayout = function () {
+        var lineData = this._lineData; // Do not support update layout in incremental mode.
+
+        if (!lineData) {
+          return;
+        }
+
+        lineData.eachItemGraphicEl(function (el, idx) {
+          el.updateLayout(lineData, idx);
+        }, this);
+      };
+
+      LineDraw.prototype.incrementalPrepareUpdate = function (lineData) {
+        this._seriesScope = makeSeriesScope$1(lineData);
+        this._lineData = null;
+        this.group.removeAll();
+      };
+
+      LineDraw.prototype.incrementalUpdate = function (taskParams, lineData) {
+        function updateIncrementalAndHover(el) {
+          if (!el.isGroup && !isEffectObject(el)) {
+            el.incremental = true;
+            el.ensureState('emphasis').hoverLayer = true;
+          }
+        }
+
+        for (var idx = taskParams.start; idx < taskParams.end; idx++) {
+          var itemLayout = lineData.getItemLayout(idx);
+
+          if (lineNeedsDraw(itemLayout)) {
+            var el = new this._LineCtor(lineData, idx, this._seriesScope);
+            el.traverse(updateIncrementalAndHover);
+            this.group.add(el);
+            lineData.setItemGraphicEl(idx, el);
+          }
+        }
+      };
+
+      LineDraw.prototype.remove = function () {
+        this.group.removeAll();
+      };
+
+      LineDraw.prototype._doAdd = function (lineData, idx, seriesScope) {
+        var itemLayout = lineData.getItemLayout(idx);
+
+        if (!lineNeedsDraw(itemLayout)) {
+          return;
+        }
+
+        var el = new this._LineCtor(lineData, idx, seriesScope);
+        lineData.setItemGraphicEl(idx, el);
+        this.group.add(el);
+      };
+
+      LineDraw.prototype._doUpdate = function (oldLineData, newLineData, oldIdx, newIdx, seriesScope) {
+        var itemEl = oldLineData.getItemGraphicEl(oldIdx);
+
+        if (!lineNeedsDraw(newLineData.getItemLayout(newIdx))) {
+          this.group.remove(itemEl);
+          return;
+        }
+
+        if (!itemEl) {
+          itemEl = new this._LineCtor(newLineData, newIdx, seriesScope);
+        } else {
+          itemEl.updateData(newLineData, newIdx, seriesScope);
+        }
+
+        newLineData.setItemGraphicEl(newIdx, itemEl);
+        this.group.add(itemEl);
+      };
+
+      return LineDraw;
+    }();
+
+    function isEffectObject(el) {
+      return el.animators && el.animators.length > 0;
+    }
+
+    function makeSeriesScope$1(lineData) {
+      var hostModel = lineData.hostModel;
+      return {
+        lineStyle: hostModel.getModel('lineStyle').getLineStyle(),
+        emphasisLineStyle: hostModel.getModel(['emphasis', 'lineStyle']).getLineStyle(),
+        blurLineStyle: hostModel.getModel(['blur', 'lineStyle']).getLineStyle(),
+        selectLineStyle: hostModel.getModel(['select', 'lineStyle']).getLineStyle(),
+        labelStatesModels: getLabelStatesModels(hostModel)
+      };
+    }
+
+    function isPointNaN(pt) {
+      return isNaN(pt[0]) || isNaN(pt[1]);
+    }
+
+    function lineNeedsDraw(pts) {
+      return !isPointNaN(pts[0]) && !isPointNaN(pts[1]);
+    }
+
+    var v1 = [];
+    var v2 = [];
+    var v3 = [];
+    var quadraticAt$1 = quadraticAt;
+    var v2DistSquare = distSquare;
+    var mathAbs$2 = Math.abs;
+
+    function intersectCurveCircle(curvePoints, center, radius) {
+      var p0 = curvePoints[0];
+      var p1 = curvePoints[1];
+      var p2 = curvePoints[2];
+      var d = Infinity;
+      var t;
+      var radiusSquare = radius * radius;
+      var interval = 0.1;
+
+      for (var _t = 0.1; _t <= 0.9; _t += 0.1) {
+        v1[0] = quadraticAt$1(p0[0], p1[0], p2[0], _t);
+        v1[1] = quadraticAt$1(p0[1], p1[1], p2[1], _t);
+        var diff = mathAbs$2(v2DistSquare(v1, center) - radiusSquare);
+
+        if (diff < d) {
+          d = diff;
+          t = _t;
+        }
+      } // Assume the segment is monotone，Find root through Bisection method
+      // At most 32 iteration
+
+
+      for (var i = 0; i < 32; i++) {
+        // let prev = t - interval;
+        var next = t + interval; // v1[0] = quadraticAt(p0[0], p1[0], p2[0], prev);
+        // v1[1] = quadraticAt(p0[1], p1[1], p2[1], prev);
+
+        v2[0] = quadraticAt$1(p0[0], p1[0], p2[0], t);
+        v2[1] = quadraticAt$1(p0[1], p1[1], p2[1], t);
+        v3[0] = quadraticAt$1(p0[0], p1[0], p2[0], next);
+        v3[1] = quadraticAt$1(p0[1], p1[1], p2[1], next);
+        var diff = v2DistSquare(v2, center) - radiusSquare;
+
+        if (mathAbs$2(diff) < 1e-2) {
+          break;
+        } // let prevDiff = v2DistSquare(v1, center) - radiusSquare;
+
+
+        var nextDiff = v2DistSquare(v3, center) - radiusSquare;
+        interval /= 2;
+
+        if (diff < 0) {
+          if (nextDiff >= 0) {
+            t = t + interval;
+          } else {
+            t = t - interval;
+          }
+        } else {
+          if (nextDiff >= 0) {
+            t = t - interval;
+          } else {
+            t = t + interval;
+          }
+        }
+      }
+
+      return t;
+    } // Adjust edge to avoid
+
+
+    function adjustEdge(graph, scale) {
+      var tmp0 = [];
+      var quadraticSubdivide$1 = quadraticSubdivide;
+      var pts = [[], [], []];
+      var pts2 = [[], []];
+      var v = [];
+      scale /= 2;
+      graph.eachEdge(function (edge, idx) {
+        var linePoints = edge.getLayout();
+        var fromSymbol = edge.getVisual('fromSymbol');
+        var toSymbol = edge.getVisual('toSymbol');
+
+        if (!linePoints.__original) {
+          linePoints.__original = [clone$1(linePoints[0]), clone$1(linePoints[1])];
+
+          if (linePoints[2]) {
+            linePoints.__original.push(clone$1(linePoints[2]));
+          }
+        }
+
+        var originalPoints = linePoints.__original; // Quadratic curve
+
+        if (linePoints[2] != null) {
+          copy(pts[0], originalPoints[0]);
+          copy(pts[1], originalPoints[2]);
+          copy(pts[2], originalPoints[1]);
+
+          if (fromSymbol && fromSymbol !== 'none') {
+            var symbolSize = getSymbolSize(edge.node1);
+            var t = intersectCurveCircle(pts, originalPoints[0], symbolSize * scale); // Subdivide and get the second
+
+            quadraticSubdivide$1(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
+            pts[0][0] = tmp0[3];
+            pts[1][0] = tmp0[4];
+            quadraticSubdivide$1(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
+            pts[0][1] = tmp0[3];
+            pts[1][1] = tmp0[4];
+          }
+
+          if (toSymbol && toSymbol !== 'none') {
+            var symbolSize = getSymbolSize(edge.node2);
+            var t = intersectCurveCircle(pts, originalPoints[1], symbolSize * scale); // Subdivide and get the first
+
+            quadraticSubdivide$1(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
+            pts[1][0] = tmp0[1];
+            pts[2][0] = tmp0[2];
+            quadraticSubdivide$1(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
+            pts[1][1] = tmp0[1];
+            pts[2][1] = tmp0[2];
+          } // Copy back to layout
+
+
+          copy(linePoints[0], pts[0]);
+          copy(linePoints[1], pts[2]);
+          copy(linePoints[2], pts[1]);
+        } // Line
+        else {
+            copy(pts2[0], originalPoints[0]);
+            copy(pts2[1], originalPoints[1]);
+            sub(v, pts2[1], pts2[0]);
+            normalize(v, v);
+
+            if (fromSymbol && fromSymbol !== 'none') {
+              var symbolSize = getSymbolSize(edge.node1);
+              scaleAndAdd(pts2[0], pts2[0], v, symbolSize * scale);
+            }
+
+            if (toSymbol && toSymbol !== 'none') {
+              var symbolSize = getSymbolSize(edge.node2);
+              scaleAndAdd(pts2[1], pts2[1], v, -symbolSize * scale);
+            }
+
+            copy(linePoints[0], pts2[0]);
+            copy(linePoints[1], pts2[1]);
+          }
+      });
+    }
+
+    function isViewCoordSys(coordSys) {
+      return coordSys.type === 'view';
+    }
+
+    var GraphView =
+    /** @class */
+    function (_super) {
+      __extends(GraphView, _super);
+
+      function GraphView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GraphView.type;
+        return _this;
+      }
+
+      GraphView.prototype.init = function (ecModel, api) {
+        var symbolDraw = new SymbolDraw();
+        var lineDraw = new LineDraw();
+        var group = this.group;
+        this._controller = new RoamController(api.getZr());
+        this._controllerHost = {
+          target: group
+        };
+        group.add(symbolDraw.group);
+        group.add(lineDraw.group);
+        this._symbolDraw = symbolDraw;
+        this._lineDraw = lineDraw;
+        this._firstRender = true;
+      };
+
+      GraphView.prototype.render = function (seriesModel, ecModel, api) {
+        var _this = this;
+
+        var coordSys = seriesModel.coordinateSystem;
+        this._model = seriesModel;
+        var symbolDraw = this._symbolDraw;
+        var lineDraw = this._lineDraw;
+        var group = this.group;
+
+        if (isViewCoordSys(coordSys)) {
+          var groupNewProp = {
+            x: coordSys.x,
+            y: coordSys.y,
+            scaleX: coordSys.scaleX,
+            scaleY: coordSys.scaleY
+          };
+
+          if (this._firstRender) {
+            group.attr(groupNewProp);
+          } else {
+            updateProps(group, groupNewProp, seriesModel);
+          }
+        } // Fix edge contact point with node
+
+
+        adjustEdge(seriesModel.getGraph(), getNodeGlobalScale(seriesModel));
+        var data = seriesModel.getData();
+        symbolDraw.updateData(data);
+        var edgeData = seriesModel.getEdgeData(); // TODO: TYPE
+
+        lineDraw.updateData(edgeData);
+
+        this._updateNodeAndLinkScale();
+
+        this._updateController(seriesModel, ecModel, api);
+
+        clearTimeout(this._layoutTimeout);
+        var forceLayout = seriesModel.forceLayout;
+        var layoutAnimation = seriesModel.get(['force', 'layoutAnimation']);
+
+        if (forceLayout) {
+          this._startForceLayoutIteration(forceLayout, layoutAnimation);
+        }
+
+        data.graph.eachNode(function (node) {
+          var idx = node.dataIndex;
+          var el = node.getGraphicEl();
+          var itemModel = node.getModel(); // Update draggable
+
+          el.off('drag').off('dragend');
+          var draggable = itemModel.get('draggable');
+
+          if (draggable) {
+            el.on('drag', function () {
+              if (forceLayout) {
+                forceLayout.warmUp();
+                !_this._layouting && _this._startForceLayoutIteration(forceLayout, layoutAnimation);
+                forceLayout.setFixed(idx); // Write position back to layout
+
+                data.setItemLayout(idx, [el.x, el.y]);
+              }
+            }).on('dragend', function () {
+              if (forceLayout) {
+                forceLayout.setUnfixed(idx);
+              }
+            });
+          }
+
+          el.setDraggable(draggable && !!forceLayout);
+          var focus = itemModel.get(['emphasis', 'focus']);
+
+          if (focus === 'adjacency') {
+            getECData(el).focus = node.getAdjacentDataIndices();
+          }
+        });
+        data.graph.eachEdge(function (edge) {
+          var el = edge.getGraphicEl();
+          var focus = edge.getModel().get(['emphasis', 'focus']);
+
+          if (focus === 'adjacency') {
+            getECData(el).focus = {
+              edge: [edge.dataIndex],
+              node: [edge.node1.dataIndex, edge.node2.dataIndex]
+            };
+          }
+        });
+        var circularRotateLabel = seriesModel.get('layout') === 'circular' && seriesModel.get(['circular', 'rotateLabel']);
+        var cx = data.getLayout('cx');
+        var cy = data.getLayout('cy');
+        data.eachItemGraphicEl(function (el, idx) {
+          var itemModel = data.getItemModel(idx);
+          var labelRotate = itemModel.get(['label', 'rotate']) || 0;
+          var symbolPath = el.getSymbolPath();
+
+          if (circularRotateLabel) {
+            var pos = data.getItemLayout(idx);
+            var rad = Math.atan2(pos[1] - cy, pos[0] - cx);
+
+            if (rad < 0) {
+              rad = Math.PI * 2 + rad;
+            }
+
+            var isLeft = pos[0] < cx;
+
+            if (isLeft) {
+              rad = rad - Math.PI;
+            }
+
+            var textPosition = isLeft ? 'left' : 'right';
+            symbolPath.setTextConfig({
+              rotation: -rad,
+              position: textPosition,
+              origin: 'center'
+            });
+            var emphasisState = symbolPath.ensureState('emphasis');
+            extend(emphasisState.textConfig || (emphasisState.textConfig = {}), {
+              position: textPosition
+            });
+          } else {
+            symbolPath.setTextConfig({
+              rotation: labelRotate *= Math.PI / 180
+            });
+          }
+        });
+        this._firstRender = false;
+      };
+
+      GraphView.prototype.dispose = function () {
+        this._controller && this._controller.dispose();
+        this._controllerHost = null;
+      };
+
+      GraphView.prototype._startForceLayoutIteration = function (forceLayout, layoutAnimation) {
+        var self = this;
+
+        (function step() {
+          forceLayout.step(function (stopped) {
+            self.updateLayout(self._model);
+            (self._layouting = !stopped) && (layoutAnimation ? self._layoutTimeout = setTimeout(step, 16) : step());
+          });
+        })();
+      };
+
+      GraphView.prototype._updateController = function (seriesModel, ecModel, api) {
+        var _this = this;
+
+        var controller = this._controller;
+        var controllerHost = this._controllerHost;
+        var group = this.group;
+        controller.setPointerChecker(function (e, x, y) {
+          var rect = group.getBoundingRect();
+          rect.applyTransform(group.transform);
+          return rect.contain(x, y) && !onIrrelevantElement(e, api, seriesModel);
+        });
+
+        if (!isViewCoordSys(seriesModel.coordinateSystem)) {
+          controller.disable();
+          return;
+        }
+
+        controller.enable(seriesModel.get('roam'));
+        controllerHost.zoomLimit = seriesModel.get('scaleLimit');
+        controllerHost.zoom = seriesModel.coordinateSystem.getZoom();
+        controller.off('pan').off('zoom').on('pan', function (e) {
+          updateViewOnPan(controllerHost, e.dx, e.dy);
+          api.dispatchAction({
+            seriesId: seriesModel.id,
+            type: 'graphRoam',
+            dx: e.dx,
+            dy: e.dy
+          });
+        }).on('zoom', function (e) {
+          updateViewOnZoom(controllerHost, e.scale, e.originX, e.originY);
+          api.dispatchAction({
+            seriesId: seriesModel.id,
+            type: 'graphRoam',
+            zoom: e.scale,
+            originX: e.originX,
+            originY: e.originY
+          });
+
+          _this._updateNodeAndLinkScale();
+
+          adjustEdge(seriesModel.getGraph(), getNodeGlobalScale(seriesModel));
+
+          _this._lineDraw.updateLayout(); // Only update label layout on zoom
+
+
+          api.updateLabelLayout();
+        });
+      };
+
+      GraphView.prototype._updateNodeAndLinkScale = function () {
+        var seriesModel = this._model;
+        var data = seriesModel.getData();
+        var nodeScale = getNodeGlobalScale(seriesModel);
+        data.eachItemGraphicEl(function (el, idx) {
+          el.setSymbolScale(nodeScale);
+        });
+      };
+
+      GraphView.prototype.updateLayout = function (seriesModel) {
+        adjustEdge(seriesModel.getGraph(), getNodeGlobalScale(seriesModel));
+
+        this._symbolDraw.updateLayout();
+
+        this._lineDraw.updateLayout();
+      };
+
+      GraphView.prototype.remove = function (ecModel, api) {
+        this._symbolDraw && this._symbolDraw.remove();
+        this._lineDraw && this._lineDraw.remove();
+      };
+
+      GraphView.type = 'graph';
+      return GraphView;
+    }(ChartView);
+
+    function generateNodeKey(id) {
+      return '_EC_' + id;
+    }
+
+    var Graph =
+    /** @class */
+    function () {
+      function Graph(directed) {
+        this.type = 'graph';
+        this.nodes = [];
+        this.edges = [];
+        this._nodesMap = {};
+        /**
+         * @type {Object.<string, module:echarts/data/Graph.Edge>}
+         * @private
+         */
+
+        this._edgesMap = {};
+        this._directed = directed || false;
+      }
+      /**
+       * If is directed graph
+       */
+
+
+      Graph.prototype.isDirected = function () {
+        return this._directed;
+      };
+      /**
+       * Add a new node
+       */
+
+      Graph.prototype.addNode = function (id, dataIndex) {
+        id = id == null ? '' + dataIndex : '' + id;
+        var nodesMap = this._nodesMap;
+
+        if (nodesMap[generateNodeKey(id)]) {
+          if ("development" !== 'production') {
+            console.error('Graph nodes have duplicate name or id');
+          }
+
+          return;
+        }
+
+        var node = new GraphNode(id, dataIndex);
+        node.hostGraph = this;
+        this.nodes.push(node);
+        nodesMap[generateNodeKey(id)] = node;
+        return node;
+      };
+      /**
+       * Get node by data index
+       */
+
+      Graph.prototype.getNodeByIndex = function (dataIndex) {
+        var rawIdx = this.data.getRawIndex(dataIndex);
+        return this.nodes[rawIdx];
+      };
+      /**
+       * Get node by id
+       */
+
+      Graph.prototype.getNodeById = function (id) {
+        return this._nodesMap[generateNodeKey(id)];
+      };
+      /**
+       * Add a new edge
+       */
+
+      Graph.prototype.addEdge = function (n1, n2, dataIndex) {
+        var nodesMap = this._nodesMap;
+        var edgesMap = this._edgesMap; // PNEDING
+
+        if (typeof n1 === 'number') {
+          n1 = this.nodes[n1];
+        }
+
+        if (typeof n2 === 'number') {
+          n2 = this.nodes[n2];
+        }
+
+        if (!(n1 instanceof GraphNode)) {
+          n1 = nodesMap[generateNodeKey(n1)];
+        }
+
+        if (!(n2 instanceof GraphNode)) {
+          n2 = nodesMap[generateNodeKey(n2)];
+        }
+
+        if (!n1 || !n2) {
+          return;
+        }
+
+        var key = n1.id + '-' + n2.id;
+        var edge = new GraphEdge(n1, n2, dataIndex);
+        edge.hostGraph = this;
+
+        if (this._directed) {
+          n1.outEdges.push(edge);
+          n2.inEdges.push(edge);
+        }
+
+        n1.edges.push(edge);
+
+        if (n1 !== n2) {
+          n2.edges.push(edge);
+        }
+
+        this.edges.push(edge);
+        edgesMap[key] = edge;
+        return edge;
+      };
+      /**
+       * Get edge by data index
+       */
+
+      Graph.prototype.getEdgeByIndex = function (dataIndex) {
+        var rawIdx = this.edgeData.getRawIndex(dataIndex);
+        return this.edges[rawIdx];
+      };
+      /**
+       * Get edge by two linked nodes
+       */
+
+      Graph.prototype.getEdge = function (n1, n2) {
+        if (n1 instanceof GraphNode) {
+          n1 = n1.id;
+        }
+
+        if (n2 instanceof GraphNode) {
+          n2 = n2.id;
+        }
+
+        var edgesMap = this._edgesMap;
+
+        if (this._directed) {
+          return edgesMap[n1 + '-' + n2];
+        } else {
+          return edgesMap[n1 + '-' + n2] || edgesMap[n2 + '-' + n1];
+        }
+      };
+      /**
+       * Iterate all nodes
+       */
+
+      Graph.prototype.eachNode = function (cb, context) {
+        var nodes = this.nodes;
+        var len = nodes.length;
+
+        for (var i = 0; i < len; i++) {
+          if (nodes[i].dataIndex >= 0) {
+            cb.call(context, nodes[i], i);
+          }
+        }
+      };
+      /**
+       * Iterate all edges
+       */
+
+      Graph.prototype.eachEdge = function (cb, context) {
+        var edges = this.edges;
+        var len = edges.length;
+
+        for (var i = 0; i < len; i++) {
+          if (edges[i].dataIndex >= 0 && edges[i].node1.dataIndex >= 0 && edges[i].node2.dataIndex >= 0) {
+            cb.call(context, edges[i], i);
+          }
+        }
+      };
+      /**
+       * Breadth first traverse
+       * Return true to stop traversing
+       */
+
+      Graph.prototype.breadthFirstTraverse = function (cb, startNode, direction, context) {
+        if (!(startNode instanceof GraphNode)) {
+          startNode = this._nodesMap[generateNodeKey(startNode)];
+        }
+
+        if (!startNode) {
+          return;
+        }
+
+        var edgeType = direction === 'out' ? 'outEdges' : direction === 'in' ? 'inEdges' : 'edges';
+
+        for (var i = 0; i < this.nodes.length; i++) {
+          this.nodes[i].__visited = false;
+        }
+
+        if (cb.call(context, startNode, null)) {
+          return;
+        }
+
+        var queue = [startNode];
+
+        while (queue.length) {
+          var currentNode = queue.shift();
+          var edges = currentNode[edgeType];
+
+          for (var i = 0; i < edges.length; i++) {
+            var e = edges[i];
+            var otherNode = e.node1 === currentNode ? e.node2 : e.node1;
+
+            if (!otherNode.__visited) {
+              if (cb.call(context, otherNode, currentNode)) {
+                // Stop traversing
+                return;
+              }
+
+              queue.push(otherNode);
+              otherNode.__visited = true;
+            }
+          }
+        }
+      };
+      // depthFirstTraverse(
+      //     cb, startNode, direction, context
+      // ) {
+      // };
+      // Filter update
+
+      Graph.prototype.update = function () {
+        var data = this.data;
+        var edgeData = this.edgeData;
+        var nodes = this.nodes;
+        var edges = this.edges;
+
+        for (var i = 0, len = nodes.length; i < len; i++) {
+          nodes[i].dataIndex = -1;
+        }
+
+        for (var i = 0, len = data.count(); i < len; i++) {
+          nodes[data.getRawIndex(i)].dataIndex = i;
+        }
+
+        edgeData.filterSelf(function (idx) {
+          var edge = edges[edgeData.getRawIndex(idx)];
+          return edge.node1.dataIndex >= 0 && edge.node2.dataIndex >= 0;
+        }); // Update edge
+
+        for (var i = 0, len = edges.length; i < len; i++) {
+          edges[i].dataIndex = -1;
+        }
+
+        for (var i = 0, len = edgeData.count(); i < len; i++) {
+          edges[edgeData.getRawIndex(i)].dataIndex = i;
+        }
+      };
+      /**
+       * @return {module:echarts/data/Graph}
+       */
+
+      Graph.prototype.clone = function () {
+        var graph = new Graph(this._directed);
+        var nodes = this.nodes;
+        var edges = this.edges;
+
+        for (var i = 0; i < nodes.length; i++) {
+          graph.addNode(nodes[i].id, nodes[i].dataIndex);
+        }
+
+        for (var i = 0; i < edges.length; i++) {
+          var e = edges[i];
+          graph.addEdge(e.node1.id, e.node2.id, e.dataIndex);
+        }
+
+        return graph;
+      };
+      return Graph;
+    }();
+
+    var GraphNode =
+    /** @class */
+    function () {
+      function GraphNode(id, dataIndex) {
+        this.inEdges = [];
+        this.outEdges = [];
+        this.edges = [];
+        this.dataIndex = -1;
+        this.id = id == null ? '' : id;
+        this.dataIndex = dataIndex == null ? -1 : dataIndex;
+      }
+      /**
+       * @return {number}
+       */
+
+
+      GraphNode.prototype.degree = function () {
+        return this.edges.length;
+      };
+      /**
+       * @return {number}
+       */
+
+
+      GraphNode.prototype.inDegree = function () {
+        return this.inEdges.length;
+      };
+      /**
+      * @return {number}
+      */
+
+
+      GraphNode.prototype.outDegree = function () {
+        return this.outEdges.length;
+      };
+
+      GraphNode.prototype.getModel = function (path) {
+        if (this.dataIndex < 0) {
+          return;
+        }
+
+        var graph = this.hostGraph;
+        var itemModel = graph.data.getItemModel(this.dataIndex);
+        return itemModel.getModel(path);
+      };
+
+      GraphNode.prototype.getAdjacentDataIndices = function () {
+        var dataIndices = {
+          edge: [],
+          node: []
+        };
+
+        for (var i = 0; i < this.edges.length; i++) {
+          var adjacentEdge = this.edges[i];
+
+          if (adjacentEdge.dataIndex < 0) {
+            continue;
+          }
+
+          dataIndices.edge.push(adjacentEdge.dataIndex);
+          dataIndices.node.push(adjacentEdge.node1.dataIndex, adjacentEdge.node2.dataIndex);
+        }
+
+        return dataIndices;
+      };
+
+      return GraphNode;
+    }();
+
+    var GraphEdge =
+    /** @class */
+    function () {
+      function GraphEdge(n1, n2, dataIndex) {
+        this.dataIndex = -1;
+        this.node1 = n1;
+        this.node2 = n2;
+        this.dataIndex = dataIndex == null ? -1 : dataIndex;
+      }
+
+      GraphEdge.prototype.getModel = function (path) {
+        if (this.dataIndex < 0) {
+          return;
+        }
+
+        var graph = this.hostGraph;
+        var itemModel = graph.edgeData.getItemModel(this.dataIndex);
+        return itemModel.getModel(path);
+      };
+
+      GraphEdge.prototype.getAdjacentDataIndices = function () {
+        return {
+          edge: [this.dataIndex],
+          node: [this.node1.dataIndex, this.node2.dataIndex]
+        };
+      };
+
+      return GraphEdge;
+    }();
+
+    function createGraphDataProxyMixin(hostName, dataName) {
+      return {
+        /**
+         * @param Default 'value'. can be 'a', 'b', 'c', 'd', 'e'.
+         */
+        getValue: function (dimension) {
+          var data = this[hostName][dataName];
+          return data.get(data.getDimension(dimension || 'value'), this.dataIndex);
+        },
+        // TODO: TYPE stricter type.
+        setVisual: function (key, value) {
+          this.dataIndex >= 0 && this[hostName][dataName].setItemVisual(this.dataIndex, key, value);
+        },
+        getVisual: function (key) {
+          return this[hostName][dataName].getItemVisual(this.dataIndex, key);
+        },
+        setLayout: function (layout, merge) {
+          this.dataIndex >= 0 && this[hostName][dataName].setItemLayout(this.dataIndex, layout, merge);
+        },
+        getLayout: function () {
+          return this[hostName][dataName].getItemLayout(this.dataIndex);
+        },
+        getGraphicEl: function () {
+          return this[hostName][dataName].getItemGraphicEl(this.dataIndex);
+        },
+        getRawIndex: function () {
+          return this[hostName][dataName].getRawIndex(this.dataIndex);
+        }
+      };
+    }
+    mixin(GraphNode, createGraphDataProxyMixin('hostGraph', 'data'));
+    mixin(GraphEdge, createGraphDataProxyMixin('hostGraph', 'edgeData'));
+
+    function createGraphFromNodeEdge(nodes, edges, seriesModel, directed, beforeLink) {
+      // ??? TODO
+      // support dataset?
+      var graph = new Graph(directed);
+
+      for (var i = 0; i < nodes.length; i++) {
+        graph.addNode(retrieve( // Id, name, dataIndex
+        nodes[i].id, nodes[i].name, i), i);
+      }
+
+      var linkNameList = [];
+      var validEdges = [];
+      var linkCount = 0;
+
+      for (var i = 0; i < edges.length; i++) {
+        var link = edges[i];
+        var source = link.source;
+        var target = link.target; // addEdge may fail when source or target not exists
+
+        if (graph.addEdge(source, target, linkCount)) {
+          validEdges.push(link);
+          linkNameList.push(retrieve(convertOptionIdName(link.id, null), source + ' > ' + target));
+          linkCount++;
+        }
+      }
+
+      var coordSys = seriesModel.get('coordinateSystem');
+      var nodeData;
+
+      if (coordSys === 'cartesian2d' || coordSys === 'polar') {
+        nodeData = createListFromArray(nodes, seriesModel);
+      } else {
+        var coordSysCtor = CoordinateSystemManager.get(coordSys);
+        var coordDimensions = coordSysCtor ? coordSysCtor.dimensions || [] : []; // FIXME: Some geo do not need `value` dimenson, whereas `calendar` needs
+        // `value` dimension, but graph need `value` dimension. It's better to
+        // uniform this behavior.
+
+        if (indexOf(coordDimensions, 'value') < 0) {
+          coordDimensions.concat(['value']);
+        }
+
+        var dimensionNames = createDimensions(nodes, {
+          coordDimensions: coordDimensions
+        });
+        nodeData = new List(dimensionNames, seriesModel);
+        nodeData.initData(nodes);
+      }
+
+      var edgeData = new List(['value'], seriesModel);
+      edgeData.initData(validEdges, linkNameList);
+      beforeLink && beforeLink(nodeData, edgeData);
+      linkList({
+        mainData: nodeData,
+        struct: graph,
+        structAttr: 'graph',
+        datas: {
+          node: nodeData,
+          edge: edgeData
+        },
+        datasAttr: {
+          node: 'data',
+          edge: 'edgeData'
+        }
+      }); // Update dataIndex of nodes and edges because invalid edge may be removed
+
+      graph.update();
+      return graph;
+    }
+
+    var GraphSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(GraphSeriesModel, _super);
+
+      function GraphSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GraphSeriesModel.type;
+        _this.hasSymbolVisual = true;
+        return _this;
+      }
+
+      GraphSeriesModel.prototype.init = function (option) {
+        _super.prototype.init.apply(this, arguments);
+
+        var self = this;
+
+        function getCategoriesData() {
+          return self._categoriesData;
+        } // Provide data for legend select
+
+
+        this.legendVisualProvider = new LegendVisualProvider(getCategoriesData, getCategoriesData);
+        this.fillDataTextStyle(option.edges || option.links);
+
+        this._updateCategoriesData();
+      };
+
+      GraphSeriesModel.prototype.mergeOption = function (option) {
+        _super.prototype.mergeOption.apply(this, arguments);
+
+        this.fillDataTextStyle(option.edges || option.links);
+
+        this._updateCategoriesData();
+      };
+
+      GraphSeriesModel.prototype.mergeDefaultAndTheme = function (option) {
+        _super.prototype.mergeDefaultAndTheme.apply(this, arguments);
+
+        defaultEmphasis(option, 'edgeLabel', ['show']);
+      };
+
+      GraphSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        var edges = option.edges || option.links || [];
+        var nodes = option.data || option.nodes || [];
+        var self = this;
+
+        if (nodes && edges) {
+          // auto curveness
+          initCurvenessList(this);
+          var graph = createGraphFromNodeEdge(nodes, edges, this, true, beforeLink);
+          each(graph.edges, function (edge) {
+            createEdgeMapForCurveness(edge.node1, edge.node2, this, edge.dataIndex);
+          }, this);
+          return graph.data;
+        }
+
+        function beforeLink(nodeData, edgeData) {
+          // Overwrite nodeData.getItemModel to
+          nodeData.wrapMethod('getItemModel', function (model) {
+            var categoriesModels = self._categoriesModels;
+            var categoryIdx = model.getShallow('category');
+            var categoryModel = categoriesModels[categoryIdx];
+
+            if (categoryModel) {
+              categoryModel.parentModel = model.parentModel;
+              model.parentModel = categoryModel;
+            }
+
+            return model;
+          }); // TODO Inherit resolveParentPath by default in Model#getModel?
+
+          var oldGetModel = Model.prototype.getModel;
+
+          function newGetModel(path, parentModel) {
+            var model = oldGetModel.call(this, path, parentModel);
+            model.resolveParentPath = resolveParentPath;
+            return model;
+          }
+
+          edgeData.wrapMethod('getItemModel', function (model) {
+            model.resolveParentPath = resolveParentPath;
+            model.getModel = newGetModel;
+            return model;
+          });
+
+          function resolveParentPath(pathArr) {
+            if (pathArr && (pathArr[0] === 'label' || pathArr[1] === 'label')) {
+              var newPathArr = pathArr.slice();
+
+              if (pathArr[0] === 'label') {
+                newPathArr[0] = 'edgeLabel';
+              } else if (pathArr[1] === 'label') {
+                newPathArr[1] = 'edgeLabel';
+              }
+
+              return newPathArr;
+            }
+
+            return pathArr;
+          }
+        }
+      };
+
+      GraphSeriesModel.prototype.getGraph = function () {
+        return this.getData().graph;
+      };
+
+      GraphSeriesModel.prototype.getEdgeData = function () {
+        return this.getGraph().edgeData;
+      };
+
+      GraphSeriesModel.prototype.getCategoriesData = function () {
+        return this._categoriesData;
+      };
+
+      GraphSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        if (dataType === 'edge') {
+          var nodeData = this.getData();
+          var params = this.getDataParams(dataIndex, dataType);
+          var edge = nodeData.graph.getEdgeByIndex(dataIndex);
+          var sourceName = nodeData.getName(edge.node1.dataIndex);
+          var targetName = nodeData.getName(edge.node2.dataIndex);
+          var nameArr = [];
+          sourceName != null && nameArr.push(sourceName);
+          targetName != null && nameArr.push(targetName);
+          return createTooltipMarkup('nameValue', {
+            name: nameArr.join(' > '),
+            value: params.value,
+            noValue: params.value == null
+          });
+        } // dataType === 'node' or empty
+
+
+        var nodeMarkup = defaultSeriesFormatTooltip({
+          series: this,
+          dataIndex: dataIndex,
+          multipleSeries: multipleSeries
+        });
+        return nodeMarkup;
+      };
+
+      GraphSeriesModel.prototype._updateCategoriesData = function () {
+        var categories = map(this.option.categories || [], function (category) {
+          // Data must has value
+          return category.value != null ? category : extend({
+            value: 0
+          }, category);
+        });
+        var categoriesData = new List(['value'], this);
+        categoriesData.initData(categories);
+        this._categoriesData = categoriesData;
+        this._categoriesModels = categoriesData.mapArray(function (idx) {
+          return categoriesData.getItemModel(idx);
+        });
+      };
+
+      GraphSeriesModel.prototype.setZoom = function (zoom) {
+        this.option.zoom = zoom;
+      };
+
+      GraphSeriesModel.prototype.setCenter = function (center) {
+        this.option.center = center;
+      };
+
+      GraphSeriesModel.prototype.isAnimationEnabled = function () {
+        return _super.prototype.isAnimationEnabled.call(this) // Not enable animation when do force layout
+        && !(this.get('layout') === 'force' && this.get(['force', 'layoutAnimation']));
+      };
+
+      GraphSeriesModel.type = 'series.graph';
+      GraphSeriesModel.dependencies = ['grid', 'polar', 'geo', 'singleAxis', 'calendar'];
+      GraphSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'view',
+        // Default option for all coordinate systems
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        // polarIndex: 0,
+        // geoIndex: 0,
+        legendHoverLink: true,
+        layout: null,
+        // Configuration of circular layout
+        circular: {
+          rotateLabel: false
+        },
+        // Configuration of force directed layout
+        force: {
+          initLayout: null,
+          // Node repulsion. Can be an array to represent range.
+          repulsion: [0, 50],
+          gravity: 0.1,
+          // Initial friction
+          friction: 0.6,
+          // Edge length. Can be an array to represent range.
+          edgeLength: 30,
+          layoutAnimation: true
+        },
+        left: 'center',
+        top: 'center',
+        // right: null,
+        // bottom: null,
+        // width: '80%',
+        // height: '80%',
+        symbol: 'circle',
+        symbolSize: 10,
+        edgeSymbol: ['none', 'none'],
+        edgeSymbolSize: 10,
+        edgeLabel: {
+          position: 'middle',
+          distance: 5
+        },
+        draggable: false,
+        roam: false,
+        // Default on center of graph
+        center: null,
+        zoom: 1,
+        // Symbol size scale ratio in roam
+        nodeScaleRatio: 0.6,
+        // cursor: null,
+        // categories: [],
+        // data: []
+        // Or
+        // nodes: []
+        //
+        // links: []
+        // Or
+        // edges: []
+        label: {
+          show: false,
+          formatter: '{b}'
+        },
+        itemStyle: {},
+        lineStyle: {
+          color: '#aaa',
+          width: 1,
+          opacity: 0.5
+        },
+        emphasis: {
+          scale: true,
+          label: {
+            show: true
+          }
+        },
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        }
+      };
+      return GraphSeriesModel;
+    }(SeriesModel);
+
+    var actionInfo = {
+      type: 'graphRoam',
+      event: 'graphRoam',
+      update: 'none'
+    };
+    function install$d(registers) {
+      registers.registerChartView(GraphView);
+      registers.registerSeriesModel(GraphSeriesModel);
+      registers.registerProcessor(categoryFilter);
+      registers.registerVisual(categoryVisual);
+      registers.registerVisual(graphEdgeVisual);
+      registers.registerLayout(graphSimpleLayout);
+      registers.registerLayout(registers.PRIORITY.VISUAL.POST_CHART_LAYOUT, graphCircularLayout);
+      registers.registerLayout(graphForceLayout);
+      registers.registerCoordinateSystem('graphView', {
+        dimensions: View.dimensions,
+        create: createViewCoordSys
+      }); // Register legacy focus actions
+
+      registers.registerAction({
+        type: 'focusNodeAdjacency',
+        event: 'focusNodeAdjacency',
+        update: 'series:focusNodeAdjacency'
+      }, function () {});
+      registers.registerAction({
+        type: 'unfocusNodeAdjacency',
+        event: 'unfocusNodeAdjacency',
+        update: 'series:unfocusNodeAdjacency'
+      }, function () {}); // Register roam action.
+
+      registers.registerAction(actionInfo, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          query: payload
+        }, function (seriesModel) {
+          var coordSys = seriesModel.coordinateSystem;
+          var res = updateCenterAndZoom(coordSys, payload);
+          seriesModel.setCenter && seriesModel.setCenter(res.center);
+          seriesModel.setZoom && seriesModel.setZoom(res.zoom);
+        });
+      });
+    }
+
+    var PointerShape =
+    /** @class */
+    function () {
+      function PointerShape() {
+        this.angle = 0;
+        this.width = 10;
+        this.r = 10;
+        this.x = 0;
+        this.y = 0;
+      }
+
+      return PointerShape;
+    }();
+
+    var PointerPath =
+    /** @class */
+    function (_super) {
+      __extends(PointerPath, _super);
+
+      function PointerPath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'pointer';
+        return _this;
+      }
+
+      PointerPath.prototype.getDefaultShape = function () {
+        return new PointerShape();
+      };
+
+      PointerPath.prototype.buildPath = function (ctx, shape) {
+        var mathCos = Math.cos;
+        var mathSin = Math.sin;
+        var r = shape.r;
+        var width = shape.width;
+        var angle = shape.angle;
+        var x = shape.x - mathCos(angle) * width * (width >= r / 3 ? 1 : 2);
+        var y = shape.y - mathSin(angle) * width * (width >= r / 3 ? 1 : 2);
+        angle = shape.angle - Math.PI / 2;
+        ctx.moveTo(x, y);
+        ctx.lineTo(shape.x + mathCos(angle) * width, shape.y + mathSin(angle) * width);
+        ctx.lineTo(shape.x + mathCos(shape.angle) * r, shape.y + mathSin(shape.angle) * r);
+        ctx.lineTo(shape.x - mathCos(angle) * width, shape.y - mathSin(angle) * width);
+        ctx.lineTo(x, y);
+      };
+
+      return PointerPath;
+    }(Path);
+
+    function parsePosition(seriesModel, api) {
+      var center = seriesModel.get('center');
+      var width = api.getWidth();
+      var height = api.getHeight();
+      var size = Math.min(width, height);
+      var cx = parsePercent$1(center[0], api.getWidth());
+      var cy = parsePercent$1(center[1], api.getHeight());
+      var r = parsePercent$1(seriesModel.get('radius'), size / 2);
+      return {
+        cx: cx,
+        cy: cy,
+        r: r
+      };
+    }
+
+    function formatLabel(value, labelFormatter) {
+      var label = value == null ? '' : value + '';
+
+      if (labelFormatter) {
+        if (typeof labelFormatter === 'string') {
+          label = labelFormatter.replace('{value}', label);
+        } else if (typeof labelFormatter === 'function') {
+          label = labelFormatter(value);
+        }
+      }
+
+      return label;
+    }
+
+    var PI2$9 = Math.PI * 2;
+
+    var GaugeView =
+    /** @class */
+    function (_super) {
+      __extends(GaugeView, _super);
+
+      function GaugeView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GaugeView.type;
+        return _this;
+      }
+
+      GaugeView.prototype.render = function (seriesModel, ecModel, api) {
+        this.group.removeAll();
+        var colorList = seriesModel.get(['axisLine', 'lineStyle', 'color']);
+        var posInfo = parsePosition(seriesModel, api);
+
+        this._renderMain(seriesModel, ecModel, api, colorList, posInfo);
+
+        this._data = seriesModel.getData();
+      };
+
+      GaugeView.prototype.dispose = function () {};
+
+      GaugeView.prototype._renderMain = function (seriesModel, ecModel, api, colorList, posInfo) {
+        var group = this.group;
+        var clockwise = seriesModel.get('clockwise');
+        var startAngle = -seriesModel.get('startAngle') / 180 * Math.PI;
+        var endAngle = -seriesModel.get('endAngle') / 180 * Math.PI;
+        var axisLineModel = seriesModel.getModel('axisLine');
+        var roundCap = axisLineModel.get('roundCap');
+        var MainPath = roundCap ? SausagePath : Sector;
+        var showAxis = axisLineModel.get('show');
+        var lineStyleModel = axisLineModel.getModel('lineStyle');
+        var axisLineWidth = lineStyleModel.get('width');
+        var angleRangeSpan = !((endAngle - startAngle) % PI2$9) && endAngle !== startAngle ? PI2$9 : (endAngle - startAngle) % PI2$9;
+        var prevEndAngle = startAngle;
+
+        for (var i = 0; showAxis && i < colorList.length; i++) {
+          // Clamp
+          var percent = Math.min(Math.max(colorList[i][0], 0), 1);
+          endAngle = startAngle + angleRangeSpan * percent;
+          var sector = new MainPath({
+            shape: {
+              startAngle: prevEndAngle,
+              endAngle: endAngle,
+              cx: posInfo.cx,
+              cy: posInfo.cy,
+              clockwise: clockwise,
+              r0: posInfo.r - axisLineWidth,
+              r: posInfo.r
+            },
+            silent: true
+          });
+          sector.setStyle({
+            fill: colorList[i][1]
+          });
+          sector.setStyle(lineStyleModel.getLineStyle( // Because we use sector to simulate arc
+          // so the properties for stroking are useless
+          ['color', 'width']));
+          group.add(sector);
+          prevEndAngle = endAngle;
+        }
+
+        var getColor = function (percent) {
+          // Less than 0
+          if (percent <= 0) {
+            return colorList[0][1];
+          }
+
+          var i;
+
+          for (i = 0; i < colorList.length; i++) {
+            if (colorList[i][0] >= percent && (i === 0 ? 0 : colorList[i - 1][0]) < percent) {
+              return colorList[i][1];
+            }
+          } // More than 1
+
+
+          return colorList[i - 1][1];
+        };
+
+        if (!clockwise) {
+          var tmp = startAngle;
+          startAngle = endAngle;
+          endAngle = tmp;
+        }
+
+        this._renderTicks(seriesModel, ecModel, api, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
+
+        this._renderTitleAndDetail(seriesModel, ecModel, api, getColor, posInfo);
+
+        this._renderAnchor(seriesModel, posInfo);
+
+        this._renderPointer(seriesModel, ecModel, api, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
+      };
+
+      GaugeView.prototype._renderTicks = function (seriesModel, ecModel, api, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
+        var group = this.group;
+        var cx = posInfo.cx;
+        var cy = posInfo.cy;
+        var r = posInfo.r;
+        var minVal = +seriesModel.get('min');
+        var maxVal = +seriesModel.get('max');
+        var splitLineModel = seriesModel.getModel('splitLine');
+        var tickModel = seriesModel.getModel('axisTick');
+        var labelModel = seriesModel.getModel('axisLabel');
+        var splitNumber = seriesModel.get('splitNumber');
+        var subSplitNumber = tickModel.get('splitNumber');
+        var splitLineLen = parsePercent$1(splitLineModel.get('length'), r);
+        var tickLen = parsePercent$1(tickModel.get('length'), r);
+        var angle = startAngle;
+        var step = (endAngle - startAngle) / splitNumber;
+        var subStep = step / subSplitNumber;
+        var splitLineStyle = splitLineModel.getModel('lineStyle').getLineStyle();
+        var tickLineStyle = tickModel.getModel('lineStyle').getLineStyle();
+        var splitLineDistance = splitLineModel.get('distance');
+        var unitX;
+        var unitY;
+
+        for (var i = 0; i <= splitNumber; i++) {
+          unitX = Math.cos(angle);
+          unitY = Math.sin(angle); // Split line
+
+          if (splitLineModel.get('show')) {
+            var distance = splitLineDistance ? splitLineDistance + axisLineWidth : axisLineWidth;
+            var splitLine = new Line({
+              shape: {
+                x1: unitX * (r - distance) + cx,
+                y1: unitY * (r - distance) + cy,
+                x2: unitX * (r - splitLineLen - distance) + cx,
+                y2: unitY * (r - splitLineLen - distance) + cy
+              },
+              style: splitLineStyle,
+              silent: true
+            });
+
+            if (splitLineStyle.stroke === 'auto') {
+              splitLine.setStyle({
+                stroke: getColor(i / splitNumber)
+              });
+            }
+
+            group.add(splitLine);
+          } // Label
+
+
+          if (labelModel.get('show')) {
+            var distance = labelModel.get('distance') + splitLineDistance;
+            var label = formatLabel(round(i / splitNumber * (maxVal - minVal) + minVal), labelModel.get('formatter'));
+            var autoColor = getColor(i / splitNumber);
+            group.add(new ZRText({
+              style: createTextStyle(labelModel, {
+                text: label,
+                x: unitX * (r - splitLineLen - distance) + cx,
+                y: unitY * (r - splitLineLen - distance) + cy,
+                verticalAlign: unitY < -0.8 ? 'top' : unitY > 0.8 ? 'bottom' : 'middle',
+                align: unitX < -0.4 ? 'left' : unitX > 0.4 ? 'right' : 'center'
+              }, {
+                inheritColor: autoColor
+              }),
+              silent: true
+            }));
+          } // Axis tick
+
+
+          if (tickModel.get('show') && i !== splitNumber) {
+            var distance = tickModel.get('distance');
+            distance = distance ? distance + axisLineWidth : axisLineWidth;
+
+            for (var j = 0; j <= subSplitNumber; j++) {
+              unitX = Math.cos(angle);
+              unitY = Math.sin(angle);
+              var tickLine = new Line({
+                shape: {
+                  x1: unitX * (r - distance) + cx,
+                  y1: unitY * (r - distance) + cy,
+                  x2: unitX * (r - tickLen - distance) + cx,
+                  y2: unitY * (r - tickLen - distance) + cy
+                },
+                silent: true,
+                style: tickLineStyle
+              });
+
+              if (tickLineStyle.stroke === 'auto') {
+                tickLine.setStyle({
+                  stroke: getColor((i + j / subSplitNumber) / splitNumber)
+                });
+              }
+
+              group.add(tickLine);
+              angle += subStep;
+            }
+
+            angle -= subStep;
+          } else {
+            angle += step;
+          }
+        }
+      };
+
+      GaugeView.prototype._renderPointer = function (seriesModel, ecModel, api, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
+        var group = this.group;
+        var oldData = this._data;
+        var oldProgressData = this._progressEls;
+        var progressList = [];
+        var showPointer = seriesModel.get(['pointer', 'show']);
+        var progressModel = seriesModel.getModel('progress');
+        var showProgress = progressModel.get('show');
+        var data = seriesModel.getData();
+        var valueDim = data.mapDimension('value');
+        var minVal = +seriesModel.get('min');
+        var maxVal = +seriesModel.get('max');
+        var valueExtent = [minVal, maxVal];
+        var angleExtent = [startAngle, endAngle];
+
+        function createPointer(idx, angle) {
+          var itemModel = data.getItemModel(idx);
+          var pointerModel = itemModel.getModel('pointer');
+          var pointerWidth = parsePercent$1(pointerModel.get('width'), posInfo.r);
+          var pointerLength = parsePercent$1(pointerModel.get('length'), posInfo.r);
+          var pointerStr = seriesModel.get(['pointer', 'icon']);
+          var pointerOffset = pointerModel.get('offsetCenter');
+          var pointerOffsetX = parsePercent$1(pointerOffset[0], posInfo.r);
+          var pointerOffsetY = parsePercent$1(pointerOffset[1], posInfo.r);
+          var pointerKeepAspect = pointerModel.get('keepAspect');
+          var pointer; // not exist icon type will be set 'rect'
+
+          if (pointerStr) {
+            pointer = createSymbol(pointerStr, pointerOffsetX - pointerWidth / 2, pointerOffsetY - pointerLength, pointerWidth, pointerLength, null, pointerKeepAspect);
+          } else {
+            pointer = new PointerPath({
+              shape: {
+                angle: -Math.PI / 2,
+                width: pointerWidth,
+                r: pointerLength,
+                x: pointerOffsetX,
+                y: pointerOffsetY
+              }
+            });
+          }
+
+          pointer.rotation = -(angle + Math.PI / 2);
+          pointer.x = posInfo.cx;
+          pointer.y = posInfo.cy;
+          return pointer;
+        }
+
+        function createProgress(idx, endAngle) {
+          var roundCap = progressModel.get('roundCap');
+          var ProgressPath = roundCap ? SausagePath : Sector;
+          var isOverlap = progressModel.get('overlap');
+          var progressWidth = isOverlap ? progressModel.get('width') : axisLineWidth / data.count();
+          var r0 = isOverlap ? posInfo.r - progressWidth : posInfo.r - (idx + 1) * progressWidth;
+          var r = isOverlap ? posInfo.r : posInfo.r - idx * progressWidth;
+          var progress = new ProgressPath({
+            shape: {
+              startAngle: startAngle,
+              endAngle: endAngle,
+              cx: posInfo.cx,
+              cy: posInfo.cy,
+              clockwise: clockwise,
+              r0: r0,
+              r: r
+            }
+          });
+          isOverlap && (progress.z2 = maxVal - data.get(valueDim, idx) % maxVal);
+          return progress;
+        }
+
+        if (showProgress || showPointer) {
+          data.diff(oldData).add(function (idx) {
+            if (showPointer) {
+              var pointer = createPointer(idx, startAngle);
+              initProps(pointer, {
+                rotation: -(linearMap(data.get(valueDim, idx), valueExtent, angleExtent, true) + Math.PI / 2)
+              }, seriesModel);
+              group.add(pointer);
+              data.setItemGraphicEl(idx, pointer);
+            }
+
+            if (showProgress) {
+              var progress = createProgress(idx, startAngle);
+              var isClip = progressModel.get('clip');
+              initProps(progress, {
+                shape: {
+                  endAngle: linearMap(data.get(valueDim, idx), valueExtent, angleExtent, isClip)
+                }
+              }, seriesModel);
+              group.add(progress);
+              progressList[idx] = progress;
+            }
+          }).update(function (newIdx, oldIdx) {
+            if (showPointer) {
+              var previousPointer = oldData.getItemGraphicEl(oldIdx);
+              var previousRotate = previousPointer ? previousPointer.rotation : startAngle;
+              var pointer = createPointer(newIdx, previousRotate);
+              pointer.rotation = previousRotate;
+              updateProps(pointer, {
+                rotation: -(linearMap(data.get(valueDim, newIdx), valueExtent, angleExtent, true) + Math.PI / 2)
+              }, seriesModel);
+              group.add(pointer);
+              data.setItemGraphicEl(newIdx, pointer);
+            }
+
+            if (showProgress) {
+              var previousProgress = oldProgressData[oldIdx];
+              var previousEndAngle = previousProgress ? previousProgress.shape.endAngle : startAngle;
+              var progress = createProgress(newIdx, previousEndAngle);
+              var isClip = progressModel.get('clip');
+              updateProps(progress, {
+                shape: {
+                  endAngle: linearMap(data.get(valueDim, newIdx), valueExtent, angleExtent, isClip)
+                }
+              }, seriesModel);
+              group.add(progress);
+              progressList[newIdx] = progress;
+            }
+          }).execute();
+          data.each(function (idx) {
+            var itemModel = data.getItemModel(idx);
+            var emphasisModel = itemModel.getModel('emphasis');
+
+            if (showPointer) {
+              var pointer = data.getItemGraphicEl(idx);
+              pointer.useStyle(data.getItemVisual(idx, 'style'));
+              pointer.setStyle(itemModel.getModel(['pointer', 'itemStyle']).getItemStyle());
+
+              if (pointer.style.fill === 'auto') {
+                pointer.setStyle('fill', getColor(linearMap(data.get(valueDim, idx), valueExtent, [0, 1], true)));
+              }
+
+              pointer.z2EmphasisLift = 0;
+              setStatesStylesFromModel(pointer, itemModel);
+              enableHoverEmphasis(pointer, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+            }
+
+            if (showProgress) {
+              var progress = progressList[idx];
+              progress.useStyle(data.getItemVisual(idx, 'style'));
+              progress.setStyle(itemModel.getModel(['progress', 'itemStyle']).getItemStyle());
+              progress.z2EmphasisLift = 0;
+              setStatesStylesFromModel(progress, itemModel);
+              enableHoverEmphasis(progress, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+            }
+          });
+          this._progressEls = progressList;
+        }
+      };
+
+      GaugeView.prototype._renderAnchor = function (seriesModel, posInfo) {
+        var anchorModel = seriesModel.getModel('anchor');
+        var showAnchor = anchorModel.get('show');
+
+        if (showAnchor) {
+          var anchorSize = anchorModel.get('size');
+          var anchorType = anchorModel.get('icon');
+          var offsetCenter = anchorModel.get('offsetCenter');
+          var anchorKeepAspect = anchorModel.get('keepAspect');
+          var anchor = createSymbol(anchorType, posInfo.cx - anchorSize / 2 + parsePercent$1(offsetCenter[0], posInfo.r), posInfo.cy - anchorSize / 2 + parsePercent$1(offsetCenter[1], posInfo.r), anchorSize, anchorSize, null, anchorKeepAspect);
+          anchor.z2 = anchorModel.get('showAbove') ? 1 : 0;
+          anchor.setStyle(anchorModel.getModel('itemStyle').getItemStyle());
+          this.group.add(anchor);
+        }
+      };
+
+      GaugeView.prototype._renderTitleAndDetail = function (seriesModel, ecModel, api, getColor, posInfo) {
+        var _this = this;
+
+        var data = seriesModel.getData();
+        var valueDim = data.mapDimension('value');
+        var minVal = +seriesModel.get('min');
+        var maxVal = +seriesModel.get('max');
+        var contentGroup = new Group();
+        var newTitleEls = [];
+        var newDetailEls = [];
+        var hasAnimation = seriesModel.isAnimationEnabled();
+        data.diff(this._data).add(function (idx) {
+          newTitleEls[idx] = new ZRText({
+            silent: true
+          });
+          newDetailEls[idx] = new ZRText({
+            silent: true
+          });
+        }).update(function (idx, oldIdx) {
+          newTitleEls[idx] = _this._titleEls[oldIdx];
+          newDetailEls[idx] = _this._detailEls[oldIdx];
+        }).execute();
+        data.each(function (idx) {
+          var itemModel = data.getItemModel(idx);
+          var value = data.get(valueDim, idx);
+          var itemGroup = new Group();
+          var autoColor = getColor(linearMap(value, [minVal, maxVal], [0, 1], true));
+          var itemTitleModel = itemModel.getModel('title');
+
+          if (itemTitleModel.get('show')) {
+            var titleOffsetCenter = itemTitleModel.get('offsetCenter');
+            var titleX = posInfo.cx + parsePercent$1(titleOffsetCenter[0], posInfo.r);
+            var titleY = posInfo.cy + parsePercent$1(titleOffsetCenter[1], posInfo.r);
+            var labelEl = newTitleEls[idx];
+            labelEl.attr({
+              style: createTextStyle(itemTitleModel, {
+                x: titleX,
+                y: titleY,
+                text: data.getName(idx),
+                align: 'center',
+                verticalAlign: 'middle'
+              }, {
+                inheritColor: autoColor
+              })
+            });
+            itemGroup.add(labelEl);
+          }
+
+          var itemDetailModel = itemModel.getModel('detail');
+
+          if (itemDetailModel.get('show')) {
+            var detailOffsetCenter = itemDetailModel.get('offsetCenter');
+            var detailX = posInfo.cx + parsePercent$1(detailOffsetCenter[0], posInfo.r);
+            var detailY = posInfo.cy + parsePercent$1(detailOffsetCenter[1], posInfo.r);
+            var width = parsePercent$1(itemDetailModel.get('width'), posInfo.r);
+            var height = parsePercent$1(itemDetailModel.get('height'), posInfo.r);
+            var detailColor = seriesModel.get(['progress', 'show']) ? data.getItemVisual(idx, 'style').fill : autoColor;
+            var labelEl = newDetailEls[idx];
+            var formatter_1 = itemDetailModel.get('formatter');
+            labelEl.attr({
+              style: createTextStyle(itemDetailModel, {
+                x: detailX,
+                y: detailY,
+                text: formatLabel(value, formatter_1),
+                width: isNaN(width) ? null : width,
+                height: isNaN(height) ? null : height,
+                align: 'center',
+                verticalAlign: 'middle'
+              }, {
+                inheritColor: detailColor
+              })
+            });
+            setLabelValueAnimation(labelEl, {
+              normal: itemDetailModel
+            }, value, function (value) {
+              return formatLabel(value, formatter_1);
+            });
+            hasAnimation && animateLabelValue(labelEl, idx, data, seriesModel, {
+              getFormattedLabel: function (labelDataIndex, status, dataType, labelDimIndex, fmt, extendParams) {
+                return formatLabel(extendParams ? extendParams.interpolatedValue : value, formatter_1);
+              }
+            });
+            itemGroup.add(labelEl);
+          }
+
+          contentGroup.add(itemGroup);
+        });
+        this.group.add(contentGroup);
+        this._titleEls = newTitleEls;
+        this._detailEls = newDetailEls;
+      };
+
+      GaugeView.type = 'gauge';
+      return GaugeView;
+    }(ChartView);
+
+    var GaugeSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(GaugeSeriesModel, _super);
+
+      function GaugeSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GaugeSeriesModel.type;
+        _this.visualStyleAccessPath = 'itemStyle';
+        _this.useColorPaletteOnData = true;
+        return _this;
+      }
+
+      GaugeSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListSimply(this, ['value']);
+      };
+
+      GaugeSeriesModel.type = 'series.gauge';
+      GaugeSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        // 默认全局居中
+        center: ['50%', '50%'],
+        legendHoverLink: true,
+        radius: '75%',
+        startAngle: 225,
+        endAngle: -45,
+        clockwise: true,
+        // 最小值
+        min: 0,
+        // 最大值
+        max: 100,
+        // 分割段数，默认为10
+        splitNumber: 10,
+        // 坐标轴线
+        axisLine: {
+          // 默认显示，属性show控制显示与否
+          show: true,
+          roundCap: false,
+          lineStyle: {
+            color: [[1, '#E6EBF8']],
+            width: 10
+          }
+        },
+        // 坐标轴线
+        progress: {
+          // 默认显示，属性show控制显示与否
+          show: false,
+          overlap: true,
+          width: 10,
+          roundCap: false,
+          clip: true
+        },
+        // 分隔线
+        splitLine: {
+          // 默认显示，属性show控制显示与否
+          show: true,
+          // 属性length控制线长
+          length: 10,
+          distance: 10,
+          // 属性lineStyle（详见lineStyle）控制线条样式
+          lineStyle: {
+            color: '#63677A',
+            width: 3,
+            type: 'solid'
+          }
+        },
+        // 坐标轴小标记
+        axisTick: {
+          // 属性show控制显示与否，默认不显示
+          show: true,
+          // 每份split细分多少段
+          splitNumber: 5,
+          // 属性length控制线长
+          length: 6,
+          distance: 10,
+          // 属性lineStyle控制线条样式
+          lineStyle: {
+            color: '#63677A',
+            width: 1,
+            type: 'solid'
+          }
+        },
+        axisLabel: {
+          show: true,
+          distance: 15,
+          // formatter: null,
+          color: '#464646',
+          fontSize: 12
+        },
+        pointer: {
+          icon: null,
+          offsetCenter: [0, 0],
+          show: true,
+          length: '60%',
+          width: 6,
+          keepAspect: false
+        },
+        anchor: {
+          show: false,
+          showAbove: false,
+          size: 6,
+          icon: 'circle',
+          offsetCenter: [0, 0],
+          keepAspect: false,
+          itemStyle: {
+            color: '#fff',
+            borderWidth: 0,
+            borderColor: '#5470c6'
+          }
+        },
+        title: {
+          show: true,
+          // x, y，单位px
+          offsetCenter: [0, '20%'],
+          // 其余属性默认使用全局文本样式，详见TEXTSTYLE
+          color: '#464646',
+          fontSize: 16,
+          valueAnimation: false
+        },
+        detail: {
+          show: true,
+          backgroundColor: 'rgba(0,0,0,0)',
+          borderWidth: 0,
+          borderColor: '#ccc',
+          width: 100,
+          height: null,
+          padding: [5, 10],
+          // x, y，单位px
+          offsetCenter: [0, '40%'],
+          // formatter: null,
+          // 其余属性默认使用全局文本样式，详见TEXTSTYLE
+          color: '#464646',
+          fontSize: 30,
+          fontWeight: 'bold',
+          lineHeight: 30,
+          valueAnimation: false
+        }
+      };
+      return GaugeSeriesModel;
+    }(SeriesModel);
+
+    function install$e(registers) {
+      registers.registerChartView(GaugeView);
+      registers.registerSeriesModel(GaugeSeriesModel);
+    }
+
+    var opacityAccessPath = ['itemStyle', 'opacity'];
+    /**
+     * Piece of pie including Sector, Label, LabelLine
+     */
+
+    var FunnelPiece =
+    /** @class */
+    function (_super) {
+      __extends(FunnelPiece, _super);
+
+      function FunnelPiece(data, idx) {
+        var _this = _super.call(this) || this;
+
+        var polygon = _this;
+        var labelLine = new Polyline();
+        var text = new ZRText();
+        polygon.setTextContent(text);
+
+        _this.setTextGuideLine(labelLine);
+
+        _this.updateData(data, idx, true);
+
+        return _this;
+      }
+
+      FunnelPiece.prototype.updateData = function (data, idx, firstCreate) {
+        var polygon = this;
+        var seriesModel = data.hostModel;
+        var itemModel = data.getItemModel(idx);
+        var layout = data.getItemLayout(idx);
+        var emphasisModel = itemModel.getModel('emphasis');
+        var opacity = itemModel.get(opacityAccessPath);
+        opacity = opacity == null ? 1 : opacity; // Update common style
+
+        polygon.useStyle(data.getItemVisual(idx, 'style'));
+        polygon.style.lineJoin = 'round';
+
+        if (firstCreate) {
+          polygon.setShape({
+            points: layout.points
+          });
+          polygon.style.opacity = 0;
+          initProps(polygon, {
+            style: {
+              opacity: opacity
+            }
+          }, seriesModel, idx);
+        } else {
+          updateProps(polygon, {
+            style: {
+              opacity: opacity
+            },
+            shape: {
+              points: layout.points
+            }
+          }, seriesModel, idx);
+        }
+
+        setStatesStylesFromModel(polygon, itemModel);
+
+        this._updateLabel(data, idx);
+
+        enableHoverEmphasis(this, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+      };
+
+      FunnelPiece.prototype._updateLabel = function (data, idx) {
+        var polygon = this;
+        var labelLine = this.getTextGuideLine();
+        var labelText = polygon.getTextContent();
+        var seriesModel = data.hostModel;
+        var itemModel = data.getItemModel(idx);
+        var layout = data.getItemLayout(idx);
+        var labelLayout = layout.label;
+        var style = data.getItemVisual(idx, 'style');
+        var visualColor = style.fill;
+        setLabelStyle( // position will not be used in setLabelStyle
+        labelText, getLabelStatesModels(itemModel), {
+          labelFetcher: data.hostModel,
+          labelDataIndex: idx,
+          defaultOpacity: style.opacity,
+          defaultText: data.getName(idx)
+        }, {
+          normal: {
+            align: labelLayout.textAlign,
+            verticalAlign: labelLayout.verticalAlign
+          }
+        });
+        polygon.setTextConfig({
+          local: true,
+          inside: !!labelLayout.inside,
+          insideStroke: visualColor,
+          // insideFill: 'auto',
+          outsideFill: visualColor
+        });
+        var linePoints = labelLayout.linePoints;
+        labelLine.setShape({
+          points: linePoints
+        });
+        polygon.textGuideLineConfig = {
+          anchor: linePoints ? new Point(linePoints[0][0], linePoints[0][1]) : null
+        }; // Make sure update style on labelText after setLabelStyle.
+        // Because setLabelStyle will replace a new style on it.
+
+        updateProps(labelText, {
+          style: {
+            x: labelLayout.x,
+            y: labelLayout.y
+          }
+        }, seriesModel, idx);
+        labelText.attr({
+          rotation: labelLayout.rotation,
+          originX: labelLayout.x,
+          originY: labelLayout.y,
+          z2: 10
+        });
+        setLabelLineStyle(polygon, getLabelLineStatesModels(itemModel), {
+          // Default use item visual color
+          stroke: visualColor
+        });
+      };
+
+      return FunnelPiece;
+    }(Polygon);
+
+    var FunnelView =
+    /** @class */
+    function (_super) {
+      __extends(FunnelView, _super);
+
+      function FunnelView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = FunnelView.type;
+        _this.ignoreLabelLineUpdate = true;
+        return _this;
+      }
+
+      FunnelView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var group = this.group;
+        data.diff(oldData).add(function (idx) {
+          var funnelPiece = new FunnelPiece(data, idx);
+          data.setItemGraphicEl(idx, funnelPiece);
+          group.add(funnelPiece);
+        }).update(function (newIdx, oldIdx) {
+          var piece = oldData.getItemGraphicEl(oldIdx);
+          piece.updateData(data, newIdx);
+          group.add(piece);
+          data.setItemGraphicEl(newIdx, piece);
+        }).remove(function (idx) {
+          var piece = oldData.getItemGraphicEl(idx);
+          removeElementWithFadeOut(piece, seriesModel, idx);
+        }).execute();
+        this._data = data;
+      };
+
+      FunnelView.prototype.remove = function () {
+        this.group.removeAll();
+        this._data = null;
+      };
+
+      FunnelView.prototype.dispose = function () {};
+
+      FunnelView.type = 'funnel';
+      return FunnelView;
+    }(ChartView);
+
+    var FunnelSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(FunnelSeriesModel, _super);
+
+      function FunnelSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = FunnelSeriesModel.type;
+        _this.useColorPaletteOnData = true;
+        return _this;
+      }
+
+      FunnelSeriesModel.prototype.init = function (option) {
+        _super.prototype.init.apply(this, arguments); // Enable legend selection for each data item
+        // Use a function instead of direct access because data reference may changed
+
+
+        this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this)); // Extend labelLine emphasis
+
+        this._defaultLabelLine(option);
+      };
+
+      FunnelSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListSimply(this, {
+          coordDimensions: ['value'],
+          encodeDefaulter: curry(makeSeriesEncodeForNameBased, this)
+        });
+      };
+
+      FunnelSeriesModel.prototype._defaultLabelLine = function (option) {
+        // Extend labelLine emphasis
+        defaultEmphasis(option, 'labelLine', ['show']);
+        var labelLineNormalOpt = option.labelLine;
+        var labelLineEmphasisOpt = option.emphasis.labelLine; // Not show label line if `label.normal.show = false`
+
+        labelLineNormalOpt.show = labelLineNormalOpt.show && option.label.show;
+        labelLineEmphasisOpt.show = labelLineEmphasisOpt.show && option.emphasis.label.show;
+      }; // Overwrite
+
+
+      FunnelSeriesModel.prototype.getDataParams = function (dataIndex) {
+        var data = this.getData();
+
+        var params = _super.prototype.getDataParams.call(this, dataIndex);
+
+        var valueDim = data.mapDimension('value');
+        var sum = data.getSum(valueDim); // Percent is 0 if sum is 0
+
+        params.percent = !sum ? 0 : +(data.get(valueDim, dataIndex) / sum * 100).toFixed(2);
+        params.$vars.push('percent');
+        return params;
+      };
+
+      FunnelSeriesModel.type = 'series.funnel';
+      FunnelSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        left: 80,
+        top: 60,
+        right: 80,
+        bottom: 60,
+        // width: {totalWidth} - left - right,
+        // height: {totalHeight} - top - bottom,
+        // 默认取数据最小最大值
+        // min: 0,
+        // max: 100,
+        minSize: '0%',
+        maxSize: '100%',
+        sort: 'descending',
+        orient: 'vertical',
+        gap: 0,
+        funnelAlign: 'center',
+        label: {
+          show: true,
+          position: 'outer' // formatter: 标签文本格式器，同Tooltip.formatter，不支持异步回调
+
+        },
+        labelLine: {
+          show: true,
+          length: 20,
+          lineStyle: {
+            // color: 各异,
+            width: 1
+          }
+        },
+        itemStyle: {
+          // color: 各异,
+          borderColor: '#fff',
+          borderWidth: 1
+        },
+        emphasis: {
+          label: {
+            show: true
+          }
+        },
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        }
+      };
+      return FunnelSeriesModel;
+    }(SeriesModel);
+
+    function getViewRect$3(seriesModel, api) {
+      return getLayoutRect(seriesModel.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+    }
+
+    function getSortedIndices(data, sort) {
+      var valueDim = data.mapDimension('value');
+      var valueArr = data.mapArray(valueDim, function (val) {
+        return val;
+      });
+      var indices = [];
+      var isAscending = sort === 'ascending';
+
+      for (var i = 0, len = data.count(); i < len; i++) {
+        indices[i] = i;
+      } // Add custom sortable function & none sortable opetion by "options.sort"
+
+
+      if (typeof sort === 'function') {
+        indices.sort(sort);
+      } else if (sort !== 'none') {
+        indices.sort(function (a, b) {
+          return isAscending ? valueArr[a] - valueArr[b] : valueArr[b] - valueArr[a];
+        });
+      }
+
+      return indices;
+    }
+
+    function labelLayout(data) {
+      var seriesModel = data.hostModel;
+      var orient = seriesModel.get('orient');
+      data.each(function (idx) {
+        var itemModel = data.getItemModel(idx);
+        var labelModel = itemModel.getModel('label');
+        var labelPosition = labelModel.get('position');
+        var labelLineModel = itemModel.getModel('labelLine');
+        var layout = data.getItemLayout(idx);
+        var points = layout.points;
+        var isLabelInside = labelPosition === 'inner' || labelPosition === 'inside' || labelPosition === 'center' || labelPosition === 'insideLeft' || labelPosition === 'insideRight';
+        var textAlign;
+        var textX;
+        var textY;
+        var linePoints;
+
+        if (isLabelInside) {
+          if (labelPosition === 'insideLeft') {
+            textX = (points[0][0] + points[3][0]) / 2 + 5;
+            textY = (points[0][1] + points[3][1]) / 2;
+            textAlign = 'left';
+          } else if (labelPosition === 'insideRight') {
+            textX = (points[1][0] + points[2][0]) / 2 - 5;
+            textY = (points[1][1] + points[2][1]) / 2;
+            textAlign = 'right';
+          } else {
+            textX = (points[0][0] + points[1][0] + points[2][0] + points[3][0]) / 4;
+            textY = (points[0][1] + points[1][1] + points[2][1] + points[3][1]) / 4;
+            textAlign = 'center';
+          }
+
+          linePoints = [[textX, textY], [textX, textY]];
+        } else {
+          var x1 = void 0;
+          var y1 = void 0;
+          var x2 = void 0;
+          var y2 = void 0;
+          var labelLineLen = labelLineModel.get('length');
+
+          if ("development" !== 'production') {
+            if (orient === 'vertical' && ['top', 'bottom'].indexOf(labelPosition) > -1) {
+              labelPosition = 'left';
+              console.warn('Position error: Funnel chart on vertical orient dose not support top and bottom.');
+            }
+
+            if (orient === 'horizontal' && ['left', 'right'].indexOf(labelPosition) > -1) {
+              labelPosition = 'bottom';
+              console.warn('Position error: Funnel chart on horizontal orient dose not support left and right.');
+            }
+          }
+
+          if (labelPosition === 'left') {
+            // Left side
+            x1 = (points[3][0] + points[0][0]) / 2;
+            y1 = (points[3][1] + points[0][1]) / 2;
+            x2 = x1 - labelLineLen;
+            textX = x2 - 5;
+            textAlign = 'right';
+          } else if (labelPosition === 'right') {
+            // Right side
+            x1 = (points[1][0] + points[2][0]) / 2;
+            y1 = (points[1][1] + points[2][1]) / 2;
+            x2 = x1 + labelLineLen;
+            textX = x2 + 5;
+            textAlign = 'left';
+          } else if (labelPosition === 'top') {
+            // Top side
+            x1 = (points[3][0] + points[0][0]) / 2;
+            y1 = (points[3][1] + points[0][1]) / 2;
+            y2 = y1 - labelLineLen;
+            textY = y2 - 5;
+            textAlign = 'center';
+          } else if (labelPosition === 'bottom') {
+            // Bottom side
+            x1 = (points[1][0] + points[2][0]) / 2;
+            y1 = (points[1][1] + points[2][1]) / 2;
+            y2 = y1 + labelLineLen;
+            textY = y2 + 5;
+            textAlign = 'center';
+          } else if (labelPosition === 'rightTop') {
+            // RightTop side
+            x1 = orient === 'horizontal' ? points[3][0] : points[1][0];
+            y1 = orient === 'horizontal' ? points[3][1] : points[1][1];
+
+            if (orient === 'horizontal') {
+              y2 = y1 - labelLineLen;
+              textY = y2 - 5;
+              textAlign = 'center';
+            } else {
+              x2 = x1 + labelLineLen;
+              textX = x2 + 5;
+              textAlign = 'top';
+            }
+          } else if (labelPosition === 'rightBottom') {
+            // RightBottom side
+            x1 = points[2][0];
+            y1 = points[2][1];
+
+            if (orient === 'horizontal') {
+              y2 = y1 + labelLineLen;
+              textY = y2 + 5;
+              textAlign = 'center';
+            } else {
+              x2 = x1 + labelLineLen;
+              textX = x2 + 5;
+              textAlign = 'bottom';
+            }
+          } else if (labelPosition === 'leftTop') {
+            // LeftTop side
+            x1 = points[0][0];
+            y1 = orient === 'horizontal' ? points[0][1] : points[1][1];
+
+            if (orient === 'horizontal') {
+              y2 = y1 - labelLineLen;
+              textY = y2 - 5;
+              textAlign = 'center';
+            } else {
+              x2 = x1 - labelLineLen;
+              textX = x2 - 5;
+              textAlign = 'right';
+            }
+          } else if (labelPosition === 'leftBottom') {
+            // LeftBottom side
+            x1 = orient === 'horizontal' ? points[1][0] : points[3][0];
+            y1 = orient === 'horizontal' ? points[1][1] : points[2][1];
+
+            if (orient === 'horizontal') {
+              y2 = y1 + labelLineLen;
+              textY = y2 + 5;
+              textAlign = 'center';
+            } else {
+              x2 = x1 - labelLineLen;
+              textX = x2 - 5;
+              textAlign = 'right';
+            }
+          } else {
+            // Right side or Bottom side
+            x1 = (points[1][0] + points[2][0]) / 2;
+            y1 = (points[1][1] + points[2][1]) / 2;
+
+            if (orient === 'horizontal') {
+              y2 = y1 + labelLineLen;
+              textY = y2 + 5;
+              textAlign = 'center';
+            } else {
+              x2 = x1 + labelLineLen;
+              textX = x2 + 5;
+              textAlign = 'left';
+            }
+          }
+
+          if (orient === 'horizontal') {
+            x2 = x1;
+            textX = x2;
+          } else {
+            y2 = y1;
+            textY = y2;
+          }
+
+          linePoints = [[x1, y1], [x2, y2]];
+        }
+
+        layout.label = {
+          linePoints: linePoints,
+          x: textX,
+          y: textY,
+          verticalAlign: 'middle',
+          textAlign: textAlign,
+          inside: isLabelInside
+        };
+      });
+    }
+
+    function funnelLayout(ecModel, api) {
+      ecModel.eachSeriesByType('funnel', function (seriesModel) {
+        var data = seriesModel.getData();
+        var valueDim = data.mapDimension('value');
+        var sort = seriesModel.get('sort');
+        var viewRect = getViewRect$3(seriesModel, api);
+        var orient = seriesModel.get('orient');
+        var viewWidth = viewRect.width;
+        var viewHeight = viewRect.height;
+        var indices = getSortedIndices(data, sort);
+        var x = viewRect.x;
+        var y = viewRect.y;
+        var sizeExtent = orient === 'horizontal' ? [parsePercent$1(seriesModel.get('minSize'), viewHeight), parsePercent$1(seriesModel.get('maxSize'), viewHeight)] : [parsePercent$1(seriesModel.get('minSize'), viewWidth), parsePercent$1(seriesModel.get('maxSize'), viewWidth)];
+        var dataExtent = data.getDataExtent(valueDim);
+        var min = seriesModel.get('min');
+        var max = seriesModel.get('max');
+
+        if (min == null) {
+          min = Math.min(dataExtent[0], 0);
+        }
+
+        if (max == null) {
+          max = dataExtent[1];
+        }
+
+        var funnelAlign = seriesModel.get('funnelAlign');
+        var gap = seriesModel.get('gap');
+        var viewSize = orient === 'horizontal' ? viewWidth : viewHeight;
+        var itemSize = (viewSize - gap * (data.count() - 1)) / data.count();
+
+        var getLinePoints = function (idx, offset) {
+          // End point index is data.count() and we assign it 0
+          if (orient === 'horizontal') {
+            var val_1 = data.get(valueDim, idx) || 0;
+            var itemHeight = linearMap(val_1, [min, max], sizeExtent, true);
+            var y0 = void 0;
+
+            switch (funnelAlign) {
+              case 'top':
+                y0 = y;
+                break;
+
+              case 'center':
+                y0 = y + (viewHeight - itemHeight) / 2;
+                break;
+
+              case 'bottom':
+                y0 = y + (viewHeight - itemHeight);
+                break;
+            }
+
+            return [[offset, y0], [offset, y0 + itemHeight]];
+          }
+
+          var val = data.get(valueDim, idx) || 0;
+          var itemWidth = linearMap(val, [min, max], sizeExtent, true);
+          var x0;
+
+          switch (funnelAlign) {
+            case 'left':
+              x0 = x;
+              break;
+
+            case 'center':
+              x0 = x + (viewWidth - itemWidth) / 2;
+              break;
+
+            case 'right':
+              x0 = x + viewWidth - itemWidth;
+              break;
+          }
+
+          return [[x0, offset], [x0 + itemWidth, offset]];
+        };
+
+        if (sort === 'ascending') {
+          // From bottom to top
+          itemSize = -itemSize;
+          gap = -gap;
+
+          if (orient === 'horizontal') {
+            x += viewWidth;
+          } else {
+            y += viewHeight;
+          }
+
+          indices = indices.reverse();
+        }
+
+        for (var i = 0; i < indices.length; i++) {
+          var idx = indices[i];
+          var nextIdx = indices[i + 1];
+          var itemModel = data.getItemModel(idx);
+
+          if (orient === 'horizontal') {
+            var width = itemModel.get(['itemStyle', 'width']);
+
+            if (width == null) {
+              width = itemSize;
+            } else {
+              width = parsePercent$1(width, viewWidth);
+
+              if (sort === 'ascending') {
+                width = -width;
+              }
+            }
+
+            var start = getLinePoints(idx, x);
+            var end = getLinePoints(nextIdx, x + width);
+            x += width + gap;
+            data.setItemLayout(idx, {
+              points: start.concat(end.slice().reverse())
+            });
+          } else {
+            var height = itemModel.get(['itemStyle', 'height']);
+
+            if (height == null) {
+              height = itemSize;
+            } else {
+              height = parsePercent$1(height, viewHeight);
+
+              if (sort === 'ascending') {
+                height = -height;
+              }
+            }
+
+            var start = getLinePoints(idx, y);
+            var end = getLinePoints(nextIdx, y + height);
+            y += height + gap;
+            data.setItemLayout(idx, {
+              points: start.concat(end.slice().reverse())
+            });
+          }
+        }
+
+        labelLayout(data);
+      });
+    }
+
+    function install$f(registers) {
+      registers.registerChartView(FunnelView);
+      registers.registerSeriesModel(FunnelSeriesModel);
+      registers.registerLayout(funnelLayout);
+      registers.registerProcessor(dataFilter('funnel'));
+    }
+
+    var DEFAULT_SMOOTH = 0.3;
+
+    var ParallelView =
+    /** @class */
+    function (_super) {
+      __extends(ParallelView, _super);
+
+      function ParallelView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelView.type;
+        _this._dataGroup = new Group();
+        _this._initialized = false;
+        return _this;
+      }
+
+      ParallelView.prototype.init = function () {
+        this.group.add(this._dataGroup);
+      };
+      /**
+       * @override
+       */
+
+
+      ParallelView.prototype.render = function (seriesModel, ecModel, api, payload) {
+        var dataGroup = this._dataGroup;
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var coordSys = seriesModel.coordinateSystem;
+        var dimensions = coordSys.dimensions;
+        var seriesScope = makeSeriesScope$2(seriesModel);
+        data.diff(oldData).add(add).update(update).remove(remove).execute();
+
+        function add(newDataIndex) {
+          var line = addEl(data, dataGroup, newDataIndex, dimensions, coordSys);
+          updateElCommon(line, data, newDataIndex, seriesScope);
+        }
+
+        function update(newDataIndex, oldDataIndex) {
+          var line = oldData.getItemGraphicEl(oldDataIndex);
+          var points = createLinePoints(data, newDataIndex, dimensions, coordSys);
+          data.setItemGraphicEl(newDataIndex, line);
+          updateProps(line, {
+            shape: {
+              points: points
+            }
+          }, seriesModel, newDataIndex);
+          updateElCommon(line, data, newDataIndex, seriesScope);
+        }
+
+        function remove(oldDataIndex) {
+          var line = oldData.getItemGraphicEl(oldDataIndex);
+          dataGroup.remove(line);
+        } // First create
+
+
+        if (!this._initialized) {
+          this._initialized = true;
+          var clipPath = createGridClipShape(coordSys, seriesModel, function () {
+            // Callback will be invoked immediately if there is no animation
+            setTimeout(function () {
+              dataGroup.removeClipPath();
+            });
+          });
+          dataGroup.setClipPath(clipPath);
+        }
+
+        this._data = data;
+      };
+
+      ParallelView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+        this._initialized = true;
+        this._data = null;
+
+        this._dataGroup.removeAll();
+      };
+
+      ParallelView.prototype.incrementalRender = function (taskParams, seriesModel, ecModel) {
+        var data = seriesModel.getData();
+        var coordSys = seriesModel.coordinateSystem;
+        var dimensions = coordSys.dimensions;
+        var seriesScope = makeSeriesScope$2(seriesModel);
+
+        for (var dataIndex = taskParams.start; dataIndex < taskParams.end; dataIndex++) {
+          var line = addEl(data, this._dataGroup, dataIndex, dimensions, coordSys);
+          line.incremental = true;
+          updateElCommon(line, data, dataIndex, seriesScope);
+        }
+      };
+
+      ParallelView.prototype.remove = function () {
+        this._dataGroup && this._dataGroup.removeAll();
+        this._data = null;
+      };
+
+      ParallelView.type = 'parallel';
+      return ParallelView;
+    }(ChartView);
+
+    function createGridClipShape(coordSys, seriesModel, cb) {
+      var parallelModel = coordSys.model;
+      var rect = coordSys.getRect();
+      var rectEl = new Rect({
+        shape: {
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        }
+      });
+      var dim = parallelModel.get('layout') === 'horizontal' ? 'width' : 'height';
+      rectEl.setShape(dim, 0);
+      initProps(rectEl, {
+        shape: {
+          width: rect.width,
+          height: rect.height
+        }
+      }, seriesModel, cb);
+      return rectEl;
+    }
+
+    function createLinePoints(data, dataIndex, dimensions, coordSys) {
+      var points = [];
+
+      for (var i = 0; i < dimensions.length; i++) {
+        var dimName = dimensions[i];
+        var value = data.get(data.mapDimension(dimName), dataIndex);
+
+        if (!isEmptyValue(value, coordSys.getAxis(dimName).type)) {
+          points.push(coordSys.dataToPoint(value, dimName));
+        }
+      }
+
+      return points;
+    }
+
+    function addEl(data, dataGroup, dataIndex, dimensions, coordSys) {
+      var points = createLinePoints(data, dataIndex, dimensions, coordSys);
+      var line = new Polyline({
+        shape: {
+          points: points
+        },
+        // silent: true,
+        z2: 10
+      });
+      dataGroup.add(line);
+      data.setItemGraphicEl(dataIndex, line);
+      return line;
+    }
+
+    function makeSeriesScope$2(seriesModel) {
+      var smooth = seriesModel.get('smooth', true);
+      smooth === true && (smooth = DEFAULT_SMOOTH);
+      smooth = numericToNumber(smooth);
+      eqNaN(smooth) && (smooth = 0);
+      return {
+        smooth: smooth
+      };
+    }
+
+    function updateElCommon(el, data, dataIndex, seriesScope) {
+      el.useStyle(data.getItemVisual(dataIndex, 'style'));
+      el.style.fill = null;
+      el.setShape('smooth', seriesScope.smooth);
+      var itemModel = data.getItemModel(dataIndex);
+      var emphasisModel = itemModel.getModel('emphasis');
+      setStatesStylesFromModel(el, itemModel, 'lineStyle');
+      enableHoverEmphasis(el, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+    } // function simpleDiff(oldData, newData, dimensions) {
+    //     let oldLen;
+    //     if (!oldData
+    //         || !oldData.__plProgressive
+    //         || (oldLen = oldData.count()) !== newData.count()
+    //     ) {
+    //         return true;
+    //     }
+    //     let dimLen = dimensions.length;
+    //     for (let i = 0; i < oldLen; i++) {
+    //         for (let j = 0; j < dimLen; j++) {
+    //             if (oldData.get(dimensions[j], i) !== newData.get(dimensions[j], i)) {
+    //                 return true;
+    //             }
+    //         }
+    //     }
+    //     return false;
+    // }
+    // FIXME put in common util?
+
+
+    function isEmptyValue(val, axisType) {
+      return axisType === 'category' ? val == null : val == null || isNaN(val); // axisType === 'value'
+    }
+
+    var ParallelSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(ParallelSeriesModel, _super);
+
+      function ParallelSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelSeriesModel.type;
+        _this.visualStyleAccessPath = 'lineStyle';
+        _this.visualDrawType = 'stroke';
+        return _this;
+      }
+
+      ParallelSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: bind(makeDefaultEncode, null, this)
+        });
+      };
+      /**
+       * User can get data raw indices on 'axisAreaSelected' event received.
+       *
+       * @return Raw indices
+       */
+
+
+      ParallelSeriesModel.prototype.getRawIndicesByActiveState = function (activeState) {
+        var coordSys = this.coordinateSystem;
+        var data = this.getData();
+        var indices = [];
+        coordSys.eachActiveState(data, function (theActiveState, dataIndex) {
+          if (activeState === theActiveState) {
+            indices.push(data.getRawIndex(dataIndex));
+          }
+        });
+        return indices;
+      };
+
+      ParallelSeriesModel.type = 'series.parallel';
+      ParallelSeriesModel.dependencies = ['parallel'];
+      ParallelSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'parallel',
+        parallelIndex: 0,
+        label: {
+          show: false
+        },
+        inactiveOpacity: 0.05,
+        activeOpacity: 1,
+        lineStyle: {
+          width: 1,
+          opacity: 0.45,
+          type: 'solid'
+        },
+        emphasis: {
+          label: {
+            show: false
+          }
+        },
+        progressive: 500,
+        smooth: false,
+        animationEasing: 'linear'
+      };
+      return ParallelSeriesModel;
+    }(SeriesModel);
+
+    function makeDefaultEncode(seriesModel) {
+      // The mapping of parallelAxis dimension to data dimension can
+      // be specified in parallelAxis.option.dim. For example, if
+      // parallelAxis.option.dim is 'dim3', it mapping to the third
+      // dimension of data. But `data.encode` has higher priority.
+      // Moreover, parallelModel.dimension should not be regarded as data
+      // dimensions. Consider dimensions = ['dim4', 'dim2', 'dim6'];
+      var parallelModel = seriesModel.ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));
+
+      if (!parallelModel) {
+        return;
+      }
+
+      var encodeDefine = {};
+      each(parallelModel.dimensions, function (axisDim) {
+        var dataDimIndex = convertDimNameToNumber(axisDim);
+        encodeDefine[axisDim] = dataDimIndex;
+      });
+      return encodeDefine;
+    }
+
+    function convertDimNameToNumber(dimName) {
+      return +dimName.replace('dim', '');
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var opacityAccessPath$1 = ['lineStyle', 'opacity'];
+    var parallelVisual = {
+      seriesType: 'parallel',
+      reset: function (seriesModel, ecModel) {
+        var coordSys = seriesModel.coordinateSystem;
+        var opacityMap = {
+          normal: seriesModel.get(['lineStyle', 'opacity']),
+          active: seriesModel.get('activeOpacity'),
+          inactive: seriesModel.get('inactiveOpacity')
+        };
+        return {
+          progress: function (params, data) {
+            coordSys.eachActiveState(data, function (activeState, dataIndex) {
+              var opacity = opacityMap[activeState];
+
+              if (activeState === 'normal' && data.hasItemOption) {
+                var itemOpacity = data.getItemModel(dataIndex).get(opacityAccessPath$1, true);
+                itemOpacity != null && (opacity = itemOpacity);
+              }
+
+              var existsStyle = data.ensureUniqueItemVisual(dataIndex, 'style');
+              existsStyle.opacity = opacity;
+            }, params.start, params.end);
+          }
+        };
+      }
+    };
+
+    function parallelPreprocessor(option) {
+      createParallelIfNeeded(option);
+      mergeAxisOptionFromParallel(option);
+    }
+    /**
+     * Create a parallel coordinate if not exists.
+     * @inner
+     */
+
+    function createParallelIfNeeded(option) {
+      if (option.parallel) {
+        return;
+      }
+
+      var hasParallelSeries = false;
+      each(option.series, function (seriesOpt) {
+        if (seriesOpt && seriesOpt.type === 'parallel') {
+          hasParallelSeries = true;
+        }
+      });
+
+      if (hasParallelSeries) {
+        option.parallel = [{}];
+      }
+    }
+    /**
+     * Merge aixs definition from parallel option (if exists) to axis option.
+     * @inner
+     */
+
+
+    function mergeAxisOptionFromParallel(option) {
+      var axes = normalizeToArray(option.parallelAxis);
+      each(axes, function (axisOption) {
+        if (!isObject(axisOption)) {
+          return;
+        }
+
+        var parallelIndex = axisOption.parallelIndex || 0;
+        var parallelOption = normalizeToArray(option.parallel)[parallelIndex];
+
+        if (parallelOption && parallelOption.parallelAxisDefault) {
+          merge(axisOption, parallelOption.parallelAxisDefault, false);
+        }
+      });
+    }
+
+    var CLICK_THRESHOLD = 5; // > 4
+
+    var ParallelView$1 =
+    /** @class */
+    function (_super) {
+      __extends(ParallelView, _super);
+
+      function ParallelView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelView.type;
+        return _this;
+      }
+
+      ParallelView.prototype.render = function (parallelModel, ecModel, api) {
+        this._model = parallelModel;
+        this._api = api;
+
+        if (!this._handlers) {
+          this._handlers = {};
+          each(handlers, function (handler, eventName) {
+            api.getZr().on(eventName, this._handlers[eventName] = bind(handler, this));
+          }, this);
+        }
+
+        createOrUpdate(this, '_throttledDispatchExpand', parallelModel.get('axisExpandRate'), 'fixRate');
+      };
+
+      ParallelView.prototype.dispose = function (ecModel, api) {
+        each(this._handlers, function (handler, eventName) {
+          api.getZr().off(eventName, handler);
+        });
+        this._handlers = null;
+      };
+      /**
+       * @internal
+       * @param {Object} [opt] If null, cancle the last action triggering for debounce.
+       */
+
+
+      ParallelView.prototype._throttledDispatchExpand = function (opt) {
+        this._dispatchExpand(opt);
+      };
+      /**
+       * @internal
+       */
+
+
+      ParallelView.prototype._dispatchExpand = function (opt) {
+        opt && this._api.dispatchAction(extend({
+          type: 'parallelAxisExpand'
+        }, opt));
+      };
+
+      ParallelView.type = 'parallel';
+      return ParallelView;
+    }(ComponentView);
+
+    var handlers = {
+      mousedown: function (e) {
+        if (checkTrigger(this, 'click')) {
+          this._mouseDownPoint = [e.offsetX, e.offsetY];
+        }
+      },
+      mouseup: function (e) {
+        var mouseDownPoint = this._mouseDownPoint;
+
+        if (checkTrigger(this, 'click') && mouseDownPoint) {
+          var point = [e.offsetX, e.offsetY];
+          var dist = Math.pow(mouseDownPoint[0] - point[0], 2) + Math.pow(mouseDownPoint[1] - point[1], 2);
+
+          if (dist > CLICK_THRESHOLD) {
+            return;
+          }
+
+          var result = this._model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+
+          result.behavior !== 'none' && this._dispatchExpand({
+            axisExpandWindow: result.axisExpandWindow
+          });
+        }
+
+        this._mouseDownPoint = null;
+      },
+      mousemove: function (e) {
+        // Should do nothing when brushing.
+        if (this._mouseDownPoint || !checkTrigger(this, 'mousemove')) {
+          return;
+        }
+
+        var model = this._model;
+        var result = model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+        var behavior = result.behavior;
+        behavior === 'jump' && this._throttledDispatchExpand.debounceNextCall(model.get('axisExpandDebounce'));
+
+        this._throttledDispatchExpand(behavior === 'none' ? null // Cancle the last trigger, in case that mouse slide out of the area quickly.
+        : {
+          axisExpandWindow: result.axisExpandWindow,
+          // Jumping uses animation, and sliding suppresses animation.
+          animation: behavior === 'jump' ? null : {
+            duration: 0 // Disable animation.
+
+          }
+        });
+      }
+    };
+
+    function checkTrigger(view, triggerOn) {
+      var model = view._model;
+      return model.get('axisExpandable') && model.get('axisExpandTriggerOn') === triggerOn;
+    }
+
+    var ParallelModel =
+    /** @class */
+    function (_super) {
+      __extends(ParallelModel, _super);
+
+      function ParallelModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelModel.type;
+        return _this;
+      }
+
+      ParallelModel.prototype.init = function () {
+        _super.prototype.init.apply(this, arguments);
+
+        this.mergeOption({});
+      };
+
+      ParallelModel.prototype.mergeOption = function (newOption) {
+        var thisOption = this.option;
+        newOption && merge(thisOption, newOption, true);
+
+        this._initDimensions();
+      };
+      /**
+       * Whether series or axis is in this coordinate system.
+       */
+
+
+      ParallelModel.prototype.contains = function (model, ecModel) {
+        var parallelIndex = model.get('parallelIndex');
+        return parallelIndex != null && ecModel.getComponent('parallel', parallelIndex) === this;
+      };
+
+      ParallelModel.prototype.setAxisExpand = function (opt) {
+        each(['axisExpandable', 'axisExpandCenter', 'axisExpandCount', 'axisExpandWidth', 'axisExpandWindow'], function (name) {
+          if (opt.hasOwnProperty(name)) {
+            // @ts-ignore FIXME: why "never" inferred in this.option[name]?
+            this.option[name] = opt[name];
+          }
+        }, this);
+      };
+
+      ParallelModel.prototype._initDimensions = function () {
+        var dimensions = this.dimensions = [];
+        var parallelAxisIndex = this.parallelAxisIndex = [];
+        var axisModels = filter(this.ecModel.queryComponents({
+          mainType: 'parallelAxis'
+        }), function (axisModel) {
+          // Can not use this.contains here, because
+          // initialization has not been completed yet.
+          return (axisModel.get('parallelIndex') || 0) === this.componentIndex;
+        }, this);
+        each(axisModels, function (axisModel) {
+          dimensions.push('dim' + axisModel.get('dim'));
+          parallelAxisIndex.push(axisModel.componentIndex);
+        });
+      };
+
+      ParallelModel.type = 'parallel';
+      ParallelModel.dependencies = ['parallelAxis'];
+      ParallelModel.layoutMode = 'box';
+      ParallelModel.defaultOption = {
+        zlevel: 0,
+        z: 0,
+        left: 80,
+        top: 60,
+        right: 80,
+        bottom: 60,
+        // width: {totalWidth} - left - right,
+        // height: {totalHeight} - top - bottom,
+        layout: 'horizontal',
+        // FIXME
+        // naming?
+        axisExpandable: false,
+        axisExpandCenter: null,
+        axisExpandCount: 0,
+        axisExpandWidth: 50,
+        axisExpandRate: 17,
+        axisExpandDebounce: 50,
+        // [out, in, jumpTarget]. In percentage. If use [null, 0.05], null means full.
+        // Do not doc to user until necessary.
+        axisExpandSlideTriggerArea: [-0.15, 0.05, 0.4],
+        axisExpandTriggerOn: 'click',
+        parallelAxisDefault: null
+      };
+      return ParallelModel;
+    }(ComponentModel);
+
+    var ParallelAxis =
+    /** @class */
+    function (_super) {
+      __extends(ParallelAxis, _super);
+
+      function ParallelAxis(dim, scale, coordExtent, axisType, axisIndex) {
+        var _this = _super.call(this, dim, scale, coordExtent) || this;
+
+        _this.type = axisType || 'value';
+        _this.axisIndex = axisIndex;
+        return _this;
+      }
+
+      ParallelAxis.prototype.isHorizontal = function () {
+        return this.coordinateSystem.getModel().get('layout') !== 'horizontal';
+      };
+
+      return ParallelAxis;
+    }(Axis);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+    /**
+     * Calculate slider move result.
+     * Usage:
+     * (1) If both handle0 and handle1 are needed to be moved, set minSpan the same as
+     * maxSpan and the same as `Math.abs(handleEnd[1] - handleEnds[0])`.
+     * (2) If handle0 is forbidden to cross handle1, set minSpan as `0`.
+     *
+     * @param delta Move length.
+     * @param handleEnds handleEnds[0] can be bigger then handleEnds[1].
+     *              handleEnds will be modified in this method.
+     * @param extent handleEnds is restricted by extent.
+     *              extent[0] should less or equals than extent[1].
+     * @param handleIndex Can be 'all', means that both move the two handleEnds.
+     * @param minSpan The range of dataZoom can not be smaller than that.
+     *              If not set, handle0 and cross handle1. If set as a non-negative
+     *              number (including `0`), handles will push each other when reaching
+     *              the minSpan.
+     * @param maxSpan The range of dataZoom can not be larger than that.
+     * @return The input handleEnds.
+     */
+    function sliderMove(delta, handleEnds, extent, handleIndex, minSpan, maxSpan) {
+      delta = delta || 0;
+      var extentSpan = extent[1] - extent[0]; // Notice maxSpan and minSpan can be null/undefined.
+
+      if (minSpan != null) {
+        minSpan = restrict(minSpan, [0, extentSpan]);
+      }
+
+      if (maxSpan != null) {
+        maxSpan = Math.max(maxSpan, minSpan != null ? minSpan : 0);
+      }
+
+      if (handleIndex === 'all') {
+        var handleSpan = Math.abs(handleEnds[1] - handleEnds[0]);
+        handleSpan = restrict(handleSpan, [0, extentSpan]);
+        minSpan = maxSpan = restrict(handleSpan, [minSpan, maxSpan]);
+        handleIndex = 0;
+      }
+
+      handleEnds[0] = restrict(handleEnds[0], extent);
+      handleEnds[1] = restrict(handleEnds[1], extent);
+      var originalDistSign = getSpanSign(handleEnds, handleIndex);
+      handleEnds[handleIndex] += delta; // Restrict in extent.
+
+      var extentMinSpan = minSpan || 0;
+      var realExtent = extent.slice();
+      originalDistSign.sign < 0 ? realExtent[0] += extentMinSpan : realExtent[1] -= extentMinSpan;
+      handleEnds[handleIndex] = restrict(handleEnds[handleIndex], realExtent); // Expand span.
+
+      var currDistSign;
+      currDistSign = getSpanSign(handleEnds, handleIndex);
+
+      if (minSpan != null && (currDistSign.sign !== originalDistSign.sign || currDistSign.span < minSpan)) {
+        // If minSpan exists, 'cross' is forbidden.
+        handleEnds[1 - handleIndex] = handleEnds[handleIndex] + originalDistSign.sign * minSpan;
+      } // Shrink span.
+
+
+      currDistSign = getSpanSign(handleEnds, handleIndex);
+
+      if (maxSpan != null && currDistSign.span > maxSpan) {
+        handleEnds[1 - handleIndex] = handleEnds[handleIndex] + currDistSign.sign * maxSpan;
+      }
+
+      return handleEnds;
+    }
+
+    function getSpanSign(handleEnds, handleIndex) {
+      var dist = handleEnds[handleIndex] - handleEnds[1 - handleIndex]; // If `handleEnds[0] === handleEnds[1]`, always believe that handleEnd[0]
+      // is at left of handleEnds[1] for non-cross case.
+
+      return {
+        span: Math.abs(dist),
+        sign: dist > 0 ? -1 : dist < 0 ? 1 : handleIndex ? -1 : 1
+      };
+    }
+
+    function restrict(value, extend) {
+      return Math.min(extend[1] != null ? extend[1] : Infinity, Math.max(extend[0] != null ? extend[0] : -Infinity, value));
+    }
+
+    var each$6 = each;
+    var mathMin$8 = Math.min;
+    var mathMax$8 = Math.max;
+    var mathFloor$2 = Math.floor;
+    var mathCeil$1 = Math.ceil;
+    var round$2 = round;
+    var PI$7 = Math.PI;
+
+    var Parallel =
+    /** @class */
+    function () {
+      function Parallel(parallelModel, ecModel, api) {
+        this.type = 'parallel';
+        /**
+         * key: dimension
+         */
+
+        this._axesMap = createHashMap();
+        /**
+         * key: dimension
+         * value: {position: [], rotation, }
+         */
+
+        this._axesLayout = {};
+        this.dimensions = parallelModel.dimensions;
+        this._model = parallelModel;
+
+        this._init(parallelModel, ecModel, api);
+      }
+
+      Parallel.prototype._init = function (parallelModel, ecModel, api) {
+        var dimensions = parallelModel.dimensions;
+        var parallelAxisIndex = parallelModel.parallelAxisIndex;
+        each$6(dimensions, function (dim, idx) {
+          var axisIndex = parallelAxisIndex[idx];
+          var axisModel = ecModel.getComponent('parallelAxis', axisIndex);
+
+          var axis = this._axesMap.set(dim, new ParallelAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisIndex));
+
+          var isCategory = axis.type === 'category';
+          axis.onBand = isCategory && axisModel.get('boundaryGap');
+          axis.inverse = axisModel.get('inverse'); // Injection
+
+          axisModel.axis = axis;
+          axis.model = axisModel;
+          axis.coordinateSystem = axisModel.coordinateSystem = this;
+        }, this);
+      };
+      /**
+       * Update axis scale after data processed
+       */
+
+
+      Parallel.prototype.update = function (ecModel, api) {
+        this._updateAxesFromSeries(this._model, ecModel);
+      };
+
+      Parallel.prototype.containPoint = function (point) {
+        var layoutInfo = this._makeLayoutInfo();
+
+        var axisBase = layoutInfo.axisBase;
+        var layoutBase = layoutInfo.layoutBase;
+        var pixelDimIndex = layoutInfo.pixelDimIndex;
+        var pAxis = point[1 - pixelDimIndex];
+        var pLayout = point[pixelDimIndex];
+        return pAxis >= axisBase && pAxis <= axisBase + layoutInfo.axisLength && pLayout >= layoutBase && pLayout <= layoutBase + layoutInfo.layoutLength;
+      };
+
+      Parallel.prototype.getModel = function () {
+        return this._model;
+      };
+      /**
+       * Update properties from series
+       */
+
+
+      Parallel.prototype._updateAxesFromSeries = function (parallelModel, ecModel) {
+        ecModel.eachSeries(function (seriesModel) {
+          if (!parallelModel.contains(seriesModel, ecModel)) {
+            return;
+          }
+
+          var data = seriesModel.getData();
+          each$6(this.dimensions, function (dim) {
+            var axis = this._axesMap.get(dim);
+
+            axis.scale.unionExtentFromData(data, data.mapDimension(dim));
+            niceScaleExtent(axis.scale, axis.model);
+          }, this);
+        }, this);
+      };
+      /**
+       * Resize the parallel coordinate system.
+       */
+
+
+      Parallel.prototype.resize = function (parallelModel, api) {
+        this._rect = getLayoutRect(parallelModel.getBoxLayoutParams(), {
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+
+        this._layoutAxes();
+      };
+
+      Parallel.prototype.getRect = function () {
+        return this._rect;
+      };
+
+      Parallel.prototype._makeLayoutInfo = function () {
+        var parallelModel = this._model;
+        var rect = this._rect;
+        var xy = ['x', 'y'];
+        var wh = ['width', 'height'];
+        var layout = parallelModel.get('layout');
+        var pixelDimIndex = layout === 'horizontal' ? 0 : 1;
+        var layoutLength = rect[wh[pixelDimIndex]];
+        var layoutExtent = [0, layoutLength];
+        var axisCount = this.dimensions.length;
+        var axisExpandWidth = restrict$1(parallelModel.get('axisExpandWidth'), layoutExtent);
+        var axisExpandCount = restrict$1(parallelModel.get('axisExpandCount') || 0, [0, axisCount]);
+        var axisExpandable = parallelModel.get('axisExpandable') && axisCount > 3 && axisCount > axisExpandCount && axisExpandCount > 1 && axisExpandWidth > 0 && layoutLength > 0; // `axisExpandWindow` is According to the coordinates of [0, axisExpandLength],
+        // for sake of consider the case that axisCollapseWidth is 0 (when screen is narrow),
+        // where collapsed axes should be overlapped.
+
+        var axisExpandWindow = parallelModel.get('axisExpandWindow');
+        var winSize;
+
+        if (!axisExpandWindow) {
+          winSize = restrict$1(axisExpandWidth * (axisExpandCount - 1), layoutExtent);
+          var axisExpandCenter = parallelModel.get('axisExpandCenter') || mathFloor$2(axisCount / 2);
+          axisExpandWindow = [axisExpandWidth * axisExpandCenter - winSize / 2];
+          axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+        } else {
+          winSize = restrict$1(axisExpandWindow[1] - axisExpandWindow[0], layoutExtent);
+          axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+        }
+
+        var axisCollapseWidth = (layoutLength - winSize) / (axisCount - axisExpandCount); // Avoid axisCollapseWidth is too small.
+
+        axisCollapseWidth < 3 && (axisCollapseWidth = 0); // Find the first and last indices > ewin[0] and < ewin[1].
+
+        var winInnerIndices = [mathFloor$2(round$2(axisExpandWindow[0] / axisExpandWidth, 1)) + 1, mathCeil$1(round$2(axisExpandWindow[1] / axisExpandWidth, 1)) - 1]; // Pos in ec coordinates.
+
+        var axisExpandWindow0Pos = axisCollapseWidth / axisExpandWidth * axisExpandWindow[0];
+        return {
+          layout: layout,
+          pixelDimIndex: pixelDimIndex,
+          layoutBase: rect[xy[pixelDimIndex]],
+          layoutLength: layoutLength,
+          axisBase: rect[xy[1 - pixelDimIndex]],
+          axisLength: rect[wh[1 - pixelDimIndex]],
+          axisExpandable: axisExpandable,
+          axisExpandWidth: axisExpandWidth,
+          axisCollapseWidth: axisCollapseWidth,
+          axisExpandWindow: axisExpandWindow,
+          axisCount: axisCount,
+          winInnerIndices: winInnerIndices,
+          axisExpandWindow0Pos: axisExpandWindow0Pos
+        };
+      };
+
+      Parallel.prototype._layoutAxes = function () {
+        var rect = this._rect;
+        var axes = this._axesMap;
+        var dimensions = this.dimensions;
+
+        var layoutInfo = this._makeLayoutInfo();
+
+        var layout = layoutInfo.layout;
+        axes.each(function (axis) {
+          var axisExtent = [0, layoutInfo.axisLength];
+          var idx = axis.inverse ? 1 : 0;
+          axis.setExtent(axisExtent[idx], axisExtent[1 - idx]);
+        });
+        each$6(dimensions, function (dim, idx) {
+          var posInfo = (layoutInfo.axisExpandable ? layoutAxisWithExpand : layoutAxisWithoutExpand)(idx, layoutInfo);
+          var positionTable = {
+            horizontal: {
+              x: posInfo.position,
+              y: layoutInfo.axisLength
+            },
+            vertical: {
+              x: 0,
+              y: posInfo.position
+            }
+          };
+          var rotationTable = {
+            horizontal: PI$7 / 2,
+            vertical: 0
+          };
+          var position = [positionTable[layout].x + rect.x, positionTable[layout].y + rect.y];
+          var rotation = rotationTable[layout];
+          var transform = create$1();
+          rotate(transform, transform, rotation);
+          translate(transform, transform, position); // TODO
+          // tick layout info
+          // TODO
+          // update dimensions info based on axis order.
+
+          this._axesLayout[dim] = {
+            position: position,
+            rotation: rotation,
+            transform: transform,
+            axisNameAvailableWidth: posInfo.axisNameAvailableWidth,
+            axisLabelShow: posInfo.axisLabelShow,
+            nameTruncateMaxWidth: posInfo.nameTruncateMaxWidth,
+            tickDirection: 1,
+            labelDirection: 1
+          };
+        }, this);
+      };
+      /**
+       * Get axis by dim.
+       */
+
+
+      Parallel.prototype.getAxis = function (dim) {
+        return this._axesMap.get(dim);
+      };
+      /**
+       * Convert a dim value of a single item of series data to Point.
+       */
+
+
+      Parallel.prototype.dataToPoint = function (value, dim) {
+        return this.axisCoordToPoint(this._axesMap.get(dim).dataToCoord(value), dim);
+      };
+      /**
+       * Travel data for one time, get activeState of each data item.
+       * @param start the start dataIndex that travel from.
+       * @param end the next dataIndex of the last dataIndex will be travel.
+       */
+
+
+      Parallel.prototype.eachActiveState = function (data, callback, start, end) {
+        start == null && (start = 0);
+        end == null && (end = data.count());
+        var axesMap = this._axesMap;
+        var dimensions = this.dimensions;
+        var dataDimensions = [];
+        var axisModels = [];
+        each(dimensions, function (axisDim) {
+          dataDimensions.push(data.mapDimension(axisDim));
+          axisModels.push(axesMap.get(axisDim).model);
+        });
+        var hasActiveSet = this.hasAxisBrushed();
+
+        for (var dataIndex = start; dataIndex < end; dataIndex++) {
+          var activeState = void 0;
+
+          if (!hasActiveSet) {
+            activeState = 'normal';
+          } else {
+            activeState = 'active';
+            var values = data.getValues(dataDimensions, dataIndex);
+
+            for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+              var state = axisModels[j].getActiveState(values[j]);
+
+              if (state === 'inactive') {
+                activeState = 'inactive';
+                break;
+              }
+            }
+          }
+
+          callback(activeState, dataIndex);
+        }
+      };
+      /**
+       * Whether has any activeSet.
+       */
+
+
+      Parallel.prototype.hasAxisBrushed = function () {
+        var dimensions = this.dimensions;
+        var axesMap = this._axesMap;
+        var hasActiveSet = false;
+
+        for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+          if (axesMap.get(dimensions[j]).model.getActiveState() !== 'normal') {
+            hasActiveSet = true;
+          }
+        }
+
+        return hasActiveSet;
+      };
+      /**
+       * Convert coords of each axis to Point.
+       *  Return point. For example: [10, 20]
+       */
+
+
+      Parallel.prototype.axisCoordToPoint = function (coord, dim) {
+        var axisLayout = this._axesLayout[dim];
+        return applyTransform$1([coord, 0], axisLayout.transform);
+      };
+      /**
+       * Get axis layout.
+       */
+
+
+      Parallel.prototype.getAxisLayout = function (dim) {
+        return clone(this._axesLayout[dim]);
+      };
+      /**
+       * @return {Object} {axisExpandWindow, delta, behavior: 'jump' | 'slide' | 'none'}.
+       */
+
+
+      Parallel.prototype.getSlidedAxisExpandWindow = function (point) {
+        var layoutInfo = this._makeLayoutInfo();
+
+        var pixelDimIndex = layoutInfo.pixelDimIndex;
+        var axisExpandWindow = layoutInfo.axisExpandWindow.slice();
+        var winSize = axisExpandWindow[1] - axisExpandWindow[0];
+        var extent = [0, layoutInfo.axisExpandWidth * (layoutInfo.axisCount - 1)]; // Out of the area of coordinate system.
+
+        if (!this.containPoint(point)) {
+          return {
+            behavior: 'none',
+            axisExpandWindow: axisExpandWindow
+          };
+        } // Conver the point from global to expand coordinates.
+
+
+        var pointCoord = point[pixelDimIndex] - layoutInfo.layoutBase - layoutInfo.axisExpandWindow0Pos; // For dragging operation convenience, the window should not be
+        // slided when mouse is the center area of the window.
+
+        var delta;
+        var behavior = 'slide';
+        var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+
+        var triggerArea = this._model.get('axisExpandSlideTriggerArea'); // But consider touch device, jump is necessary.
+
+
+        var useJump = triggerArea[0] != null;
+
+        if (axisCollapseWidth) {
+          if (useJump && axisCollapseWidth && pointCoord < winSize * triggerArea[0]) {
+            behavior = 'jump';
+            delta = pointCoord - winSize * triggerArea[2];
+          } else if (useJump && axisCollapseWidth && pointCoord > winSize * (1 - triggerArea[0])) {
+            behavior = 'jump';
+            delta = pointCoord - winSize * (1 - triggerArea[2]);
+          } else {
+            (delta = pointCoord - winSize * triggerArea[1]) >= 0 && (delta = pointCoord - winSize * (1 - triggerArea[1])) <= 0 && (delta = 0);
+          }
+
+          delta *= layoutInfo.axisExpandWidth / axisCollapseWidth;
+          delta ? sliderMove(delta, axisExpandWindow, extent, 'all') // Avoid nonsense triger on mousemove.
+          : behavior = 'none';
+        } // When screen is too narrow, make it visible and slidable, although it is hard to interact.
+        else {
+            var winSize2 = axisExpandWindow[1] - axisExpandWindow[0];
+            var pos = extent[1] * pointCoord / winSize2;
+            axisExpandWindow = [mathMax$8(0, pos - winSize2 / 2)];
+            axisExpandWindow[1] = mathMin$8(extent[1], axisExpandWindow[0] + winSize2);
+            axisExpandWindow[0] = axisExpandWindow[1] - winSize2;
+          }
+
+        return {
+          axisExpandWindow: axisExpandWindow,
+          behavior: behavior
+        };
+      };
+
+      return Parallel;
+    }();
+
+    function restrict$1(len, extent) {
+      return mathMin$8(mathMax$8(len, extent[0]), extent[1]);
+    }
+
+    function layoutAxisWithoutExpand(axisIndex, layoutInfo) {
+      var step = layoutInfo.layoutLength / (layoutInfo.axisCount - 1);
+      return {
+        position: step * axisIndex,
+        axisNameAvailableWidth: step,
+        axisLabelShow: true
+      };
+    }
+
+    function layoutAxisWithExpand(axisIndex, layoutInfo) {
+      var layoutLength = layoutInfo.layoutLength;
+      var axisExpandWidth = layoutInfo.axisExpandWidth;
+      var axisCount = layoutInfo.axisCount;
+      var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+      var winInnerIndices = layoutInfo.winInnerIndices;
+      var position;
+      var axisNameAvailableWidth = axisCollapseWidth;
+      var axisLabelShow = false;
+      var nameTruncateMaxWidth;
+
+      if (axisIndex < winInnerIndices[0]) {
+        position = axisIndex * axisCollapseWidth;
+        nameTruncateMaxWidth = axisCollapseWidth;
+      } else if (axisIndex <= winInnerIndices[1]) {
+        position = layoutInfo.axisExpandWindow0Pos + axisIndex * axisExpandWidth - layoutInfo.axisExpandWindow[0];
+        axisNameAvailableWidth = axisExpandWidth;
+        axisLabelShow = true;
+      } else {
+        position = layoutLength - (axisCount - 1 - axisIndex) * axisCollapseWidth;
+        nameTruncateMaxWidth = axisCollapseWidth;
+      }
+
+      return {
+        position: position,
+        axisNameAvailableWidth: axisNameAvailableWidth,
+        axisLabelShow: axisLabelShow,
+        nameTruncateMaxWidth: nameTruncateMaxWidth
+      };
+    }
+
+    function createParallelCoordSys(ecModel, api) {
+      var coordSysList = [];
+      ecModel.eachComponent('parallel', function (parallelModel, idx) {
+        var coordSys = new Parallel(parallelModel, ecModel, api);
+        coordSys.name = 'parallel_' + idx;
+        coordSys.resize(parallelModel, api);
+        parallelModel.coordinateSystem = coordSys;
+        coordSys.model = parallelModel;
+        coordSysList.push(coordSys);
+      }); // Inject the coordinateSystems into seriesModel
+
+      ecModel.eachSeries(function (seriesModel) {
+        if (seriesModel.get('coordinateSystem') === 'parallel') {
+          var parallelModel = seriesModel.getReferringComponents('parallel', SINGLE_REFERRING).models[0];
+          seriesModel.coordinateSystem = parallelModel.coordinateSystem;
+        }
+      });
+      return coordSysList;
+    }
+
+    var parallelCoordSysCreator = {
+      create: createParallelCoordSys
+    };
+
+    var ParallelAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(ParallelAxisModel, _super);
+
+      function ParallelAxisModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelAxisModel.type;
+        /**
+         * @readOnly
+         */
+
+        _this.activeIntervals = [];
+        return _this;
+      }
+
+      ParallelAxisModel.prototype.getAreaSelectStyle = function () {
+        return makeStyleMapper([['fill', 'color'], ['lineWidth', 'borderWidth'], ['stroke', 'borderColor'], ['width', 'width'], ['opacity', 'opacity'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+        // So do not transfer decal directly.
+        ])(this.getModel('areaSelectStyle'));
+      };
+      /**
+       * The code of this feature is put on AxisModel but not ParallelAxis,
+       * because axisModel can be alive after echarts updating but instance of
+       * ParallelAxis having been disposed. this._activeInterval should be kept
+       * when action dispatched (i.e. legend click).
+       *
+       * @param intervals `interval.length === 0` means set all active.
+       */
+
+
+      ParallelAxisModel.prototype.setActiveIntervals = function (intervals) {
+        var activeIntervals = this.activeIntervals = clone(intervals); // Normalize
+
+        if (activeIntervals) {
+          for (var i = activeIntervals.length - 1; i >= 0; i--) {
+            asc(activeIntervals[i]);
+          }
+        }
+      };
+      /**
+       * @param value When only attempting detect whether 'no activeIntervals set',
+       *        `value` is not needed to be input.
+       */
+
+
+      ParallelAxisModel.prototype.getActiveState = function (value) {
+        var activeIntervals = this.activeIntervals;
+
+        if (!activeIntervals.length) {
+          return 'normal';
+        }
+
+        if (value == null || isNaN(+value)) {
+          return 'inactive';
+        } // Simple optimization
+
+
+        if (activeIntervals.length === 1) {
+          var interval = activeIntervals[0];
+
+          if (interval[0] <= value && value <= interval[1]) {
+            return 'active';
+          }
+        } else {
+          for (var i = 0, len = activeIntervals.length; i < len; i++) {
+            if (activeIntervals[i][0] <= value && value <= activeIntervals[i][1]) {
+              return 'active';
+            }
+          }
+        }
+
+        return 'inactive';
+      };
+
+      return ParallelAxisModel;
+    }(ComponentModel);
+
+    mixin(ParallelAxisModel, AxisModelCommonMixin);
+
+    var BRUSH_PANEL_GLOBAL = true;
+    var mathMin$9 = Math.min;
+    var mathMax$9 = Math.max;
+    var mathPow$2 = Math.pow;
+    var COVER_Z = 10000;
+    var UNSELECT_THRESHOLD = 6;
+    var MIN_RESIZE_LINE_WIDTH = 6;
+    var MUTEX_RESOURCE_KEY = 'globalPan';
+    var DIRECTION_MAP = {
+      w: [0, 0],
+      e: [0, 1],
+      n: [1, 0],
+      s: [1, 1]
+    };
+    var CURSOR_MAP = {
+      w: 'ew',
+      e: 'ew',
+      n: 'ns',
+      s: 'ns',
+      ne: 'nesw',
+      sw: 'nesw',
+      nw: 'nwse',
+      se: 'nwse'
+    };
+    var DEFAULT_BRUSH_OPT = {
+      brushStyle: {
+        lineWidth: 2,
+        stroke: 'rgba(210,219,238,0.3)',
+        fill: '#D2DBEE'
+      },
+      transformable: true,
+      brushMode: 'single',
+      removeOnClick: false
+    };
+    var baseUID = 0;
+    /**
+     * params:
+     *     areas: Array.<Array>, coord relates to container group,
+     *                             If no container specified, to global.
+     *     opt {
+     *         isEnd: boolean,
+     *         removeOnClick: boolean
+     *     }
+     */
+
+    var BrushController =
+    /** @class */
+    function (_super) {
+      __extends(BrushController, _super);
+
+      function BrushController(zr) {
+        var _this = _super.call(this) || this;
+        /**
+         * @internal
+         */
+
+
+        _this._track = [];
+        /**
+         * @internal
+         */
+
+        _this._covers = [];
+        _this._handlers = {};
+
+        if ("development" !== 'production') {
+          assert(zr);
+        }
+
+        _this._zr = zr;
+        _this.group = new Group();
+        _this._uid = 'brushController_' + baseUID++;
+        each(pointerHandlers, function (handler, eventName) {
+          this._handlers[eventName] = bind(handler, this);
+        }, _this);
+        return _this;
+      }
+      /**
+       * If set to `false`, select disabled.
+       */
+
+
+      BrushController.prototype.enableBrush = function (brushOption) {
+        if ("development" !== 'production') {
+          assert(this._mounted);
+        }
+
+        this._brushType && this._doDisableBrush();
+        brushOption.brushType && this._doEnableBrush(brushOption);
+        return this;
+      };
+
+      BrushController.prototype._doEnableBrush = function (brushOption) {
+        var zr = this._zr; // Consider roam, which takes globalPan too.
+
+        if (!this._enableGlobalPan) {
+          take(zr, MUTEX_RESOURCE_KEY, this._uid);
+        }
+
+        each(this._handlers, function (handler, eventName) {
+          zr.on(eventName, handler);
+        });
+        this._brushType = brushOption.brushType;
+        this._brushOption = merge(clone(DEFAULT_BRUSH_OPT), brushOption, true);
+      };
+
+      BrushController.prototype._doDisableBrush = function () {
+        var zr = this._zr;
+        release(zr, MUTEX_RESOURCE_KEY, this._uid);
+        each(this._handlers, function (handler, eventName) {
+          zr.off(eventName, handler);
+        });
+        this._brushType = this._brushOption = null;
+      };
+      /**
+       * @param panelOpts If not pass, it is global brush.
+       */
+
+
+      BrushController.prototype.setPanels = function (panelOpts) {
+        if (panelOpts && panelOpts.length) {
+          var panels_1 = this._panels = {};
+          each(panelOpts, function (panelOpts) {
+            panels_1[panelOpts.panelId] = clone(panelOpts);
+          });
+        } else {
+          this._panels = null;
+        }
+
+        return this;
+      };
+
+      BrushController.prototype.mount = function (opt) {
+        opt = opt || {};
+
+        if ("development" !== 'production') {
+          this._mounted = true; // should be at first.
+        }
+
+        this._enableGlobalPan = opt.enableGlobalPan;
+        var thisGroup = this.group;
+
+        this._zr.add(thisGroup);
+
+        thisGroup.attr({
+          x: opt.x || 0,
+          y: opt.y || 0,
+          rotation: opt.rotation || 0,
+          scaleX: opt.scaleX || 1,
+          scaleY: opt.scaleY || 1
+        });
+        this._transform = thisGroup.getLocalTransform();
+        return this;
+      }; // eachCover(cb, context): void {
+      //     each(this._covers, cb, context);
+      // }
+
+      /**
+       * Update covers.
+       * @param coverConfigList
+       *        If coverConfigList is null/undefined, all covers removed.
+       */
+
+
+      BrushController.prototype.updateCovers = function (coverConfigList) {
+        if ("development" !== 'production') {
+          assert(this._mounted);
+        }
+
+        coverConfigList = map(coverConfigList, function (coverConfig) {
+          return merge(clone(DEFAULT_BRUSH_OPT), coverConfig, true);
+        });
+        var tmpIdPrefix = '\0-brush-index-';
+        var oldCovers = this._covers;
+        var newCovers = this._covers = [];
+        var controller = this;
+        var creatingCover = this._creatingCover;
+        new DataDiffer(oldCovers, coverConfigList, oldGetKey, getKey).add(addOrUpdate).update(addOrUpdate).remove(remove).execute();
+        return this;
+
+        function getKey(brushOption, index) {
+          return (brushOption.id != null ? brushOption.id : tmpIdPrefix + index) + '-' + brushOption.brushType;
+        }
+
+        function oldGetKey(cover, index) {
+          return getKey(cover.__brushOption, index);
+        }
+
+        function addOrUpdate(newIndex, oldIndex) {
+          var newBrushInternal = coverConfigList[newIndex]; // Consider setOption in event listener of brushSelect,
+          // where updating cover when creating should be forbiden.
+
+          if (oldIndex != null && oldCovers[oldIndex] === creatingCover) {
+            newCovers[newIndex] = oldCovers[oldIndex];
+          } else {
+            var cover = newCovers[newIndex] = oldIndex != null ? (oldCovers[oldIndex].__brushOption = newBrushInternal, oldCovers[oldIndex]) : endCreating(controller, createCover(controller, newBrushInternal));
+            updateCoverAfterCreation(controller, cover);
+          }
+        }
+
+        function remove(oldIndex) {
+          if (oldCovers[oldIndex] !== creatingCover) {
+            controller.group.remove(oldCovers[oldIndex]);
+          }
+        }
+      };
+
+      BrushController.prototype.unmount = function () {
+        if ("development" !== 'production') {
+          if (!this._mounted) {
+            return;
+          }
+        }
+
+        this.enableBrush(false); // container may 'removeAll' outside.
+
+        clearCovers(this);
+
+        this._zr.remove(this.group);
+
+        if ("development" !== 'production') {
+          this._mounted = false; // should be at last.
+        }
+
+        return this;
+      };
+
+      BrushController.prototype.dispose = function () {
+        this.unmount();
+        this.off();
+      };
+
+      return BrushController;
+    }(Eventful);
+
+    function createCover(controller, brushOption) {
+      var cover = coverRenderers[brushOption.brushType].createCover(controller, brushOption);
+      cover.__brushOption = brushOption;
+      updateZ(cover, brushOption);
+      controller.group.add(cover);
+      return cover;
+    }
+
+    function endCreating(controller, creatingCover) {
+      var coverRenderer = getCoverRenderer(creatingCover);
+
+      if (coverRenderer.endCreating) {
+        coverRenderer.endCreating(controller, creatingCover);
+        updateZ(creatingCover, creatingCover.__brushOption);
+      }
+
+      return creatingCover;
+    }
+
+    function updateCoverShape(controller, cover) {
+      var brushOption = cover.__brushOption;
+      getCoverRenderer(cover).updateCoverShape(controller, cover, brushOption.range, brushOption);
+    }
+
+    function updateZ(cover, brushOption) {
+      var z = brushOption.z;
+      z == null && (z = COVER_Z);
+      cover.traverse(function (el) {
+        el.z = z;
+        el.z2 = z; // Consider in given container.
+      });
+    }
+
+    function updateCoverAfterCreation(controller, cover) {
+      getCoverRenderer(cover).updateCommon(controller, cover);
+      updateCoverShape(controller, cover);
+    }
+
+    function getCoverRenderer(cover) {
+      return coverRenderers[cover.__brushOption.brushType];
+    } // return target panel or `true` (means global panel)
+
+
+    function getPanelByPoint(controller, e, localCursorPoint) {
+      var panels = controller._panels;
+
+      if (!panels) {
+        return BRUSH_PANEL_GLOBAL; // Global panel
+      }
+
+      var panel;
+      var transform = controller._transform;
+      each(panels, function (pn) {
+        pn.isTargetByCursor(e, localCursorPoint, transform) && (panel = pn);
+      });
+      return panel;
+    } // Return a panel or true
+
+
+    function getPanelByCover(controller, cover) {
+      var panels = controller._panels;
+
+      if (!panels) {
+        return BRUSH_PANEL_GLOBAL; // Global panel
+      }
+
+      var panelId = cover.__brushOption.panelId; // User may give cover without coord sys info,
+      // which is then treated as global panel.
+
+      return panelId != null ? panels[panelId] : BRUSH_PANEL_GLOBAL;
+    }
+
+    function clearCovers(controller) {
+      var covers = controller._covers;
+      var originalLength = covers.length;
+      each(covers, function (cover) {
+        controller.group.remove(cover);
+      }, controller);
+      covers.length = 0;
+      return !!originalLength;
+    }
+
+    function trigger$1(controller, opt) {
+      var areas = map(controller._covers, function (cover) {
+        var brushOption = cover.__brushOption;
+        var range = clone(brushOption.range);
+        return {
+          brushType: brushOption.brushType,
+          panelId: brushOption.panelId,
+          range: range
+        };
+      });
+      controller.trigger('brush', {
+        areas: areas,
+        isEnd: !!opt.isEnd,
+        removeOnClick: !!opt.removeOnClick
+      });
+    }
+
+    function shouldShowCover(controller) {
+      var track = controller._track;
+
+      if (!track.length) {
+        return false;
+      }
+
+      var p2 = track[track.length - 1];
+      var p1 = track[0];
+      var dx = p2[0] - p1[0];
+      var dy = p2[1] - p1[1];
+      var dist = mathPow$2(dx * dx + dy * dy, 0.5);
+      return dist > UNSELECT_THRESHOLD;
+    }
+
+    function getTrackEnds(track) {
+      var tail = track.length - 1;
+      tail < 0 && (tail = 0);
+      return [track[0], track[tail]];
+    }
+
+    function createBaseRectCover(rectRangeConverter, controller, brushOption, edgeNameSequences) {
+      var cover = new Group();
+      cover.add(new Rect({
+        name: 'main',
+        style: makeStyle(brushOption),
+        silent: true,
+        draggable: true,
+        cursor: 'move',
+        drift: curry(driftRect, rectRangeConverter, controller, cover, ['n', 's', 'w', 'e']),
+        ondragend: curry(trigger$1, controller, {
+          isEnd: true
+        })
+      }));
+      each(edgeNameSequences, function (nameSequence) {
+        cover.add(new Rect({
+          name: nameSequence.join(''),
+          style: {
+            opacity: 0
+          },
+          draggable: true,
+          silent: true,
+          invisible: true,
+          drift: curry(driftRect, rectRangeConverter, controller, cover, nameSequence),
+          ondragend: curry(trigger$1, controller, {
+            isEnd: true
+          })
+        }));
+      });
+      return cover;
+    }
+
+    function updateBaseRect(controller, cover, localRange, brushOption) {
+      var lineWidth = brushOption.brushStyle.lineWidth || 0;
+      var handleSize = mathMax$9(lineWidth, MIN_RESIZE_LINE_WIDTH);
+      var x = localRange[0][0];
+      var y = localRange[1][0];
+      var xa = x - lineWidth / 2;
+      var ya = y - lineWidth / 2;
+      var x2 = localRange[0][1];
+      var y2 = localRange[1][1];
+      var x2a = x2 - handleSize + lineWidth / 2;
+      var y2a = y2 - handleSize + lineWidth / 2;
+      var width = x2 - x;
+      var height = y2 - y;
+      var widtha = width + lineWidth;
+      var heighta = height + lineWidth;
+      updateRectShape(controller, cover, 'main', x, y, width, height);
+
+      if (brushOption.transformable) {
+        updateRectShape(controller, cover, 'w', xa, ya, handleSize, heighta);
+        updateRectShape(controller, cover, 'e', x2a, ya, handleSize, heighta);
+        updateRectShape(controller, cover, 'n', xa, ya, widtha, handleSize);
+        updateRectShape(controller, cover, 's', xa, y2a, widtha, handleSize);
+        updateRectShape(controller, cover, 'nw', xa, ya, handleSize, handleSize);
+        updateRectShape(controller, cover, 'ne', x2a, ya, handleSize, handleSize);
+        updateRectShape(controller, cover, 'sw', xa, y2a, handleSize, handleSize);
+        updateRectShape(controller, cover, 'se', x2a, y2a, handleSize, handleSize);
+      }
+    }
+
+    function updateCommon(controller, cover) {
+      var brushOption = cover.__brushOption;
+      var transformable = brushOption.transformable;
+      var mainEl = cover.childAt(0);
+      mainEl.useStyle(makeStyle(brushOption));
+      mainEl.attr({
+        silent: !transformable,
+        cursor: transformable ? 'move' : 'default'
+      });
+      each([['w'], ['e'], ['n'], ['s'], ['s', 'e'], ['s', 'w'], ['n', 'e'], ['n', 'w']], function (nameSequence) {
+        var el = cover.childOfName(nameSequence.join(''));
+        var globalDir = nameSequence.length === 1 ? getGlobalDirection1(controller, nameSequence[0]) : getGlobalDirection2(controller, nameSequence);
+        el && el.attr({
+          silent: !transformable,
+          invisible: !transformable,
+          cursor: transformable ? CURSOR_MAP[globalDir] + '-resize' : null
+        });
+      });
+    }
+
+    function updateRectShape(controller, cover, name, x, y, w, h) {
+      var el = cover.childOfName(name);
+      el && el.setShape(pointsToRect(clipByPanel(controller, cover, [[x, y], [x + w, y + h]])));
+    }
+
+    function makeStyle(brushOption) {
+      return defaults({
+        strokeNoScale: true
+      }, brushOption.brushStyle);
+    }
+
+    function formatRectRange(x, y, x2, y2) {
+      var min = [mathMin$9(x, x2), mathMin$9(y, y2)];
+      var max = [mathMax$9(x, x2), mathMax$9(y, y2)];
+      return [[min[0], max[0]], [min[1], max[1]] // y range
+      ];
+    }
+
+    function getTransform$1(controller) {
+      return getTransform(controller.group);
+    }
+
+    function getGlobalDirection1(controller, localDirName) {
+      var map = {
+        w: 'left',
+        e: 'right',
+        n: 'top',
+        s: 'bottom'
+      };
+      var inverseMap = {
+        left: 'w',
+        right: 'e',
+        top: 'n',
+        bottom: 's'
+      };
+      var dir = transformDirection(map[localDirName], getTransform$1(controller));
+      return inverseMap[dir];
+    }
+
+    function getGlobalDirection2(controller, localDirNameSeq) {
+      var globalDir = [getGlobalDirection1(controller, localDirNameSeq[0]), getGlobalDirection1(controller, localDirNameSeq[1])];
+      (globalDir[0] === 'e' || globalDir[0] === 'w') && globalDir.reverse();
+      return globalDir.join('');
+    }
+
+    function driftRect(rectRangeConverter, controller, cover, dirNameSequence, dx, dy) {
+      var brushOption = cover.__brushOption;
+      var rectRange = rectRangeConverter.toRectRange(brushOption.range);
+      var localDelta = toLocalDelta(controller, dx, dy);
+      each(dirNameSequence, function (dirName) {
+        var ind = DIRECTION_MAP[dirName];
+        rectRange[ind[0]][ind[1]] += localDelta[ind[0]];
+      });
+      brushOption.range = rectRangeConverter.fromRectRange(formatRectRange(rectRange[0][0], rectRange[1][0], rectRange[0][1], rectRange[1][1]));
+      updateCoverAfterCreation(controller, cover);
+      trigger$1(controller, {
+        isEnd: false
+      });
+    }
+
+    function driftPolygon(controller, cover, dx, dy) {
+      var range = cover.__brushOption.range;
+      var localDelta = toLocalDelta(controller, dx, dy);
+      each(range, function (point) {
+        point[0] += localDelta[0];
+        point[1] += localDelta[1];
+      });
+      updateCoverAfterCreation(controller, cover);
+      trigger$1(controller, {
+        isEnd: false
+      });
+    }
+
+    function toLocalDelta(controller, dx, dy) {
+      var thisGroup = controller.group;
+      var localD = thisGroup.transformCoordToLocal(dx, dy);
+      var localZero = thisGroup.transformCoordToLocal(0, 0);
+      return [localD[0] - localZero[0], localD[1] - localZero[1]];
+    }
+
+    function clipByPanel(controller, cover, data) {
+      var panel = getPanelByCover(controller, cover);
+      return panel && panel !== BRUSH_PANEL_GLOBAL ? panel.clipPath(data, controller._transform) : clone(data);
+    }
+
+    function pointsToRect(points) {
+      var xmin = mathMin$9(points[0][0], points[1][0]);
+      var ymin = mathMin$9(points[0][1], points[1][1]);
+      var xmax = mathMax$9(points[0][0], points[1][0]);
+      var ymax = mathMax$9(points[0][1], points[1][1]);
+      return {
+        x: xmin,
+        y: ymin,
+        width: xmax - xmin,
+        height: ymax - ymin
+      };
+    }
+
+    function resetCursor(controller, e, localCursorPoint) {
+      if ( // Check active
+      !controller._brushType // resetCursor should be always called when mouse is in zr area,
+      // but not called when mouse is out of zr area to avoid bad influence
+      // if `mousemove`, `mouseup` are triggered from `document` event.
+      || isOutsideZrArea(controller, e.offsetX, e.offsetY)) {
+        return;
+      }
+
+      var zr = controller._zr;
+      var covers = controller._covers;
+      var currPanel = getPanelByPoint(controller, e, localCursorPoint); // Check whether in covers.
+
+      if (!controller._dragging) {
+        for (var i = 0; i < covers.length; i++) {
+          var brushOption = covers[i].__brushOption;
+
+          if (currPanel && (currPanel === BRUSH_PANEL_GLOBAL || brushOption.panelId === currPanel.panelId) && coverRenderers[brushOption.brushType].contain(covers[i], localCursorPoint[0], localCursorPoint[1])) {
+            // Use cursor style set on cover.
+            return;
+          }
+        }
+      }
+
+      currPanel && zr.setCursorStyle('crosshair');
+    }
+
+    function preventDefault(e) {
+      var rawE = e.event;
+      rawE.preventDefault && rawE.preventDefault();
+    }
+
+    function mainShapeContain(cover, x, y) {
+      return cover.childOfName('main').contain(x, y);
+    }
+
+    function updateCoverByMouse(controller, e, localCursorPoint, isEnd) {
+      var creatingCover = controller._creatingCover;
+      var panel = controller._creatingPanel;
+      var thisBrushOption = controller._brushOption;
+      var eventParams;
+
+      controller._track.push(localCursorPoint.slice());
+
+      if (shouldShowCover(controller) || creatingCover) {
+        if (panel && !creatingCover) {
+          thisBrushOption.brushMode === 'single' && clearCovers(controller);
+          var brushOption = clone(thisBrushOption);
+          brushOption.brushType = determineBrushType(brushOption.brushType, panel);
+          brushOption.panelId = panel === BRUSH_PANEL_GLOBAL ? null : panel.panelId;
+          creatingCover = controller._creatingCover = createCover(controller, brushOption);
+
+          controller._covers.push(creatingCover);
+        }
+
+        if (creatingCover) {
+          var coverRenderer = coverRenderers[determineBrushType(controller._brushType, panel)];
+          var coverBrushOption = creatingCover.__brushOption;
+          coverBrushOption.range = coverRenderer.getCreatingRange(clipByPanel(controller, creatingCover, controller._track));
+
+          if (isEnd) {
+            endCreating(controller, creatingCover);
+            coverRenderer.updateCommon(controller, creatingCover);
+          }
+
+          updateCoverShape(controller, creatingCover);
+          eventParams = {
+            isEnd: isEnd
+          };
+        }
+      } else if (isEnd && thisBrushOption.brushMode === 'single' && thisBrushOption.removeOnClick) {
+        // Help user to remove covers easily, only by a tiny drag, in 'single' mode.
+        // But a single click do not clear covers, because user may have casual
+        // clicks (for example, click on other component and do not expect covers
+        // disappear).
+        // Only some cover removed, trigger action, but not every click trigger action.
+        if (getPanelByPoint(controller, e, localCursorPoint) && clearCovers(controller)) {
+          eventParams = {
+            isEnd: isEnd,
+            removeOnClick: true
+          };
+        }
+      }
+
+      return eventParams;
+    }
+
+    function determineBrushType(brushType, panel) {
+      if (brushType === 'auto') {
+        if ("development" !== 'production') {
+          assert(panel && panel.defaultBrushType, 'MUST have defaultBrushType when brushType is "atuo"');
+        }
+
+        return panel.defaultBrushType;
+      }
+
+      return brushType;
+    }
+
+    var pointerHandlers = {
+      mousedown: function (e) {
+        if (this._dragging) {
+          // In case some browser do not support globalOut,
+          // and release mouse out side the browser.
+          handleDragEnd(this, e);
+        } else if (!e.target || !e.target.draggable) {
+          preventDefault(e);
+          var localCursorPoint = this.group.transformCoordToLocal(e.offsetX, e.offsetY);
+          this._creatingCover = null;
+          var panel = this._creatingPanel = getPanelByPoint(this, e, localCursorPoint);
+
+          if (panel) {
+            this._dragging = true;
+            this._track = [localCursorPoint.slice()];
+          }
+        }
+      },
+      mousemove: function (e) {
+        var x = e.offsetX;
+        var y = e.offsetY;
+        var localCursorPoint = this.group.transformCoordToLocal(x, y);
+        resetCursor(this, e, localCursorPoint);
+
+        if (this._dragging) {
+          preventDefault(e);
+          var eventParams = updateCoverByMouse(this, e, localCursorPoint, false);
+          eventParams && trigger$1(this, eventParams);
+        }
+      },
+      mouseup: function (e) {
+        handleDragEnd(this, e);
+      }
+    };
+
+    function handleDragEnd(controller, e) {
+      if (controller._dragging) {
+        preventDefault(e);
+        var x = e.offsetX;
+        var y = e.offsetY;
+        var localCursorPoint = controller.group.transformCoordToLocal(x, y);
+        var eventParams = updateCoverByMouse(controller, e, localCursorPoint, true);
+        controller._dragging = false;
+        controller._track = [];
+        controller._creatingCover = null; // trigger event shoule be at final, after procedure will be nested.
+
+        eventParams && trigger$1(controller, eventParams);
+      }
+    }
+
+    function isOutsideZrArea(controller, x, y) {
+      var zr = controller._zr;
+      return x < 0 || x > zr.getWidth() || y < 0 || y > zr.getHeight();
+    }
+    /**
+     * key: brushType
+     */
+
+
+    var coverRenderers = {
+      lineX: getLineRenderer(0),
+      lineY: getLineRenderer(1),
+      rect: {
+        createCover: function (controller, brushOption) {
+          function returnInput(range) {
+            return range;
+          }
+
+          return createBaseRectCover({
+            toRectRange: returnInput,
+            fromRectRange: returnInput
+          }, controller, brushOption, [['w'], ['e'], ['n'], ['s'], ['s', 'e'], ['s', 'w'], ['n', 'e'], ['n', 'w']]);
+        },
+        getCreatingRange: function (localTrack) {
+          var ends = getTrackEnds(localTrack);
+          return formatRectRange(ends[1][0], ends[1][1], ends[0][0], ends[0][1]);
+        },
+        updateCoverShape: function (controller, cover, localRange, brushOption) {
+          updateBaseRect(controller, cover, localRange, brushOption);
+        },
+        updateCommon: updateCommon,
+        contain: mainShapeContain
+      },
+      polygon: {
+        createCover: function (controller, brushOption) {
+          var cover = new Group(); // Do not use graphic.Polygon because graphic.Polyline do not close the
+          // border of the shape when drawing, which is a better experience for user.
+
+          cover.add(new Polyline({
+            name: 'main',
+            style: makeStyle(brushOption),
+            silent: true
+          }));
+          return cover;
+        },
+        getCreatingRange: function (localTrack) {
+          return localTrack;
+        },
+        endCreating: function (controller, cover) {
+          cover.remove(cover.childAt(0)); // Use graphic.Polygon close the shape.
+
+          cover.add(new Polygon({
+            name: 'main',
+            draggable: true,
+            drift: curry(driftPolygon, controller, cover),
+            ondragend: curry(trigger$1, controller, {
+              isEnd: true
+            })
+          }));
+        },
+        updateCoverShape: function (controller, cover, localRange, brushOption) {
+          cover.childAt(0).setShape({
+            points: clipByPanel(controller, cover, localRange)
+          });
+        },
+        updateCommon: updateCommon,
+        contain: mainShapeContain
+      }
+    };
+
+    function getLineRenderer(xyIndex) {
+      return {
+        createCover: function (controller, brushOption) {
+          return createBaseRectCover({
+            toRectRange: function (range) {
+              var rectRange = [range, [0, 100]];
+              xyIndex && rectRange.reverse();
+              return rectRange;
+            },
+            fromRectRange: function (rectRange) {
+              return rectRange[xyIndex];
+            }
+          }, controller, brushOption, [[['w'], ['e']], [['n'], ['s']]][xyIndex]);
+        },
+        getCreatingRange: function (localTrack) {
+          var ends = getTrackEnds(localTrack);
+          var min = mathMin$9(ends[0][xyIndex], ends[1][xyIndex]);
+          var max = mathMax$9(ends[0][xyIndex], ends[1][xyIndex]);
+          return [min, max];
+        },
+        updateCoverShape: function (controller, cover, localRange, brushOption) {
+          var otherExtent; // If brushWidth not specified, fit the panel.
+
+          var panel = getPanelByCover(controller, cover);
+
+          if (panel !== BRUSH_PANEL_GLOBAL && panel.getLinearBrushOtherExtent) {
+            otherExtent = panel.getLinearBrushOtherExtent(xyIndex);
+          } else {
+            var zr = controller._zr;
+            otherExtent = [0, [zr.getWidth(), zr.getHeight()][1 - xyIndex]];
+          }
+
+          var rectRange = [localRange, otherExtent];
+          xyIndex && rectRange.reverse();
+          updateBaseRect(controller, cover, rectRange, brushOption);
+        },
+        updateCommon: updateCommon,
+        contain: mainShapeContain
+      };
+    }
+
+    function makeRectPanelClipPath(rect) {
+      rect = normalizeRect(rect);
+      return function (localPoints) {
+        return clipPointsByRect(localPoints, rect);
+      };
+    }
+    function makeLinearBrushOtherExtent(rect, specifiedXYIndex) {
+      rect = normalizeRect(rect);
+      return function (xyIndex) {
+        var idx = specifiedXYIndex != null ? specifiedXYIndex : xyIndex;
+        var brushWidth = idx ? rect.width : rect.height;
+        var base = idx ? rect.x : rect.y;
+        return [base, base + (brushWidth || 0)];
+      };
+    }
+    function makeRectIsTargetByCursor(rect, api, targetModel) {
+      var boundingRect = normalizeRect(rect);
+      return function (e, localCursorPoint) {
+        return boundingRect.contain(localCursorPoint[0], localCursorPoint[1]) && !onIrrelevantElement(e, api, targetModel);
+      };
+    } // Consider width/height is negative.
+
+    function normalizeRect(rect) {
+      return BoundingRect.create(rect);
+    }
+
+    var elementList = ['axisLine', 'axisTickLabel', 'axisName'];
+
+    var ParallelAxisView =
+    /** @class */
+    function (_super) {
+      __extends(ParallelAxisView, _super);
+
+      function ParallelAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ParallelAxisView.type;
+        return _this;
+      }
+
+      ParallelAxisView.prototype.init = function (ecModel, api) {
+        _super.prototype.init.apply(this, arguments);
+
+        (this._brushController = new BrushController(api.getZr())).on('brush', bind(this._onBrush, this));
+      };
+
+      ParallelAxisView.prototype.render = function (axisModel, ecModel, api, payload) {
+        if (fromAxisAreaSelect(axisModel, ecModel, payload)) {
+          return;
+        }
+
+        this.axisModel = axisModel;
+        this.api = api;
+        this.group.removeAll();
+        var oldAxisGroup = this._axisGroup;
+        this._axisGroup = new Group();
+        this.group.add(this._axisGroup);
+
+        if (!axisModel.get('show')) {
+          return;
+        }
+
+        var coordSysModel = getCoordSysModel(axisModel, ecModel);
+        var coordSys = coordSysModel.coordinateSystem;
+        var areaSelectStyle = axisModel.getAreaSelectStyle();
+        var areaWidth = areaSelectStyle.width;
+        var dim = axisModel.axis.dim;
+        var axisLayout = coordSys.getAxisLayout(dim);
+        var builderOpt = extend({
+          strokeContainThreshold: areaWidth
+        }, axisLayout);
+        var axisBuilder = new AxisBuilder(axisModel, builderOpt);
+        each(elementList, axisBuilder.add, axisBuilder);
+
+        this._axisGroup.add(axisBuilder.getGroup());
+
+        this._refreshBrushController(builderOpt, areaSelectStyle, axisModel, coordSysModel, areaWidth, api);
+
+        groupTransition(oldAxisGroup, this._axisGroup, axisModel);
+      }; // /**
+      //  * @override
+      //  */
+      // updateVisual(axisModel, ecModel, api, payload) {
+      //     this._brushController && this._brushController
+      //         .updateCovers(getCoverInfoList(axisModel));
+      // }
+
+
+      ParallelAxisView.prototype._refreshBrushController = function (builderOpt, areaSelectStyle, axisModel, coordSysModel, areaWidth, api) {
+        // After filtering, axis may change, select area needs to be update.
+        var extent = axisModel.axis.getExtent();
+        var extentLen = extent[1] - extent[0];
+        var extra = Math.min(30, Math.abs(extentLen) * 0.1); // Arbitrary value.
+        // width/height might be negative, which will be
+        // normalized in BoundingRect.
+
+        var rect = BoundingRect.create({
+          x: extent[0],
+          y: -areaWidth / 2,
+          width: extentLen,
+          height: areaWidth
+        });
+        rect.x -= extra;
+        rect.width += 2 * extra;
+
+        this._brushController.mount({
+          enableGlobalPan: true,
+          rotation: builderOpt.rotation,
+          x: builderOpt.position[0],
+          y: builderOpt.position[1]
+        }).setPanels([{
+          panelId: 'pl',
+          clipPath: makeRectPanelClipPath(rect),
+          isTargetByCursor: makeRectIsTargetByCursor(rect, api, coordSysModel),
+          getLinearBrushOtherExtent: makeLinearBrushOtherExtent(rect, 0)
+        }]).enableBrush({
+          brushType: 'lineX',
+          brushStyle: areaSelectStyle,
+          removeOnClick: true
+        }).updateCovers(getCoverInfoList(axisModel));
+      };
+
+      ParallelAxisView.prototype._onBrush = function (eventParam) {
+        var coverInfoList = eventParam.areas; // Do not cache these object, because the mey be changed.
+
+        var axisModel = this.axisModel;
+        var axis = axisModel.axis;
+        var intervals = map(coverInfoList, function (coverInfo) {
+          return [axis.coordToData(coverInfo.range[0], true), axis.coordToData(coverInfo.range[1], true)];
+        }); // If realtime is true, action is not dispatched on drag end, because
+        // the drag end emits the same params with the last drag move event,
+        // and may have some delay when using touch pad.
+
+        if (!axisModel.option.realtime === eventParam.isEnd || eventParam.removeOnClick) {
+          // jshint ignore:line
+          this.api.dispatchAction({
+            type: 'axisAreaSelect',
+            parallelAxisId: axisModel.id,
+            intervals: intervals
+          });
+        }
+      };
+
+      ParallelAxisView.prototype.dispose = function () {
+        this._brushController.dispose();
+      };
+
+      ParallelAxisView.type = 'parallelAxis';
+      return ParallelAxisView;
+    }(ComponentView);
+
+    function fromAxisAreaSelect(axisModel, ecModel, payload) {
+      return payload && payload.type === 'axisAreaSelect' && ecModel.findComponents({
+        mainType: 'parallelAxis',
+        query: payload
+      })[0] === axisModel;
+    }
+
+    function getCoverInfoList(axisModel) {
+      var axis = axisModel.axis;
+      return map(axisModel.activeIntervals, function (interval) {
+        return {
+          brushType: 'lineX',
+          panelId: 'pl',
+          range: [axis.dataToCoord(interval[0], true), axis.dataToCoord(interval[1], true)]
+        };
+      });
+    }
+
+    function getCoordSysModel(axisModel, ecModel) {
+      return ecModel.getComponent('parallel', axisModel.get('parallelIndex'));
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var actionInfo$1 = {
+      type: 'axisAreaSelect',
+      event: 'axisAreaSelected' // update: 'updateVisual'
+
+    };
+    function installParallelActions(registers) {
+      registers.registerAction(actionInfo$1, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'parallelAxis',
+          query: payload
+        }, function (parallelAxisModel) {
+          parallelAxisModel.axis.model.setActiveIntervals(payload.intervals);
+        });
+      });
+      /**
+       * @payload
+       */
+
+      registers.registerAction('parallelAxisExpand', function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'parallel',
+          query: payload
+        }, function (parallelModel) {
+          parallelModel.setAxisExpand(payload);
+        });
+      });
+    }
+
+    var defaultAxisOption = {
+      type: 'value',
+      areaSelectStyle: {
+        width: 20,
+        borderWidth: 1,
+        borderColor: 'rgba(160,197,232)',
+        color: 'rgba(160,197,232)',
+        opacity: 0.3
+      },
+      realtime: true,
+      z: 10
+    };
+    function install$g(registers) {
+      registers.registerComponentView(ParallelView$1);
+      registers.registerComponentModel(ParallelModel);
+      registers.registerCoordinateSystem('parallel', parallelCoordSysCreator);
+      registers.registerPreprocessor(parallelPreprocessor);
+      registers.registerComponentModel(ParallelAxisModel);
+      registers.registerComponentView(ParallelAxisView);
+      axisModelCreator(registers, 'parallel', ParallelAxisModel, defaultAxisOption);
+      installParallelActions(registers);
+    }
+
+    function install$h(registers) {
+      use(install$g);
+      registers.registerChartView(ParallelView);
+      registers.registerSeriesModel(ParallelSeriesModel);
+      registers.registerVisual(registers.PRIORITY.VISUAL.BRUSH, parallelVisual);
+    }
+
+    var SankeyPathShape =
+    /** @class */
+    function () {
+      function SankeyPathShape() {
+        this.x1 = 0;
+        this.y1 = 0;
+        this.x2 = 0;
+        this.y2 = 0;
+        this.cpx1 = 0;
+        this.cpy1 = 0;
+        this.cpx2 = 0;
+        this.cpy2 = 0;
+        this.extent = 0;
+      }
+
+      return SankeyPathShape;
+    }();
+
+    var SankeyPath =
+    /** @class */
+    function (_super) {
+      __extends(SankeyPath, _super);
+
+      function SankeyPath(opts) {
+        return _super.call(this, opts) || this;
+      }
+
+      SankeyPath.prototype.getDefaultShape = function () {
+        return new SankeyPathShape();
+      };
+
+      SankeyPath.prototype.buildPath = function (ctx, shape) {
+        var extent = shape.extent;
+        ctx.moveTo(shape.x1, shape.y1);
+        ctx.bezierCurveTo(shape.cpx1, shape.cpy1, shape.cpx2, shape.cpy2, shape.x2, shape.y2);
+
+        if (shape.orient === 'vertical') {
+          ctx.lineTo(shape.x2 + extent, shape.y2);
+          ctx.bezierCurveTo(shape.cpx2 + extent, shape.cpy2, shape.cpx1 + extent, shape.cpy1, shape.x1 + extent, shape.y1);
+        } else {
+          ctx.lineTo(shape.x2, shape.y2 + extent);
+          ctx.bezierCurveTo(shape.cpx2, shape.cpy2 + extent, shape.cpx1, shape.cpy1 + extent, shape.x1, shape.y1 + extent);
+        }
+
+        ctx.closePath();
+      };
+
+      SankeyPath.prototype.highlight = function () {
+        enterEmphasis(this);
+      };
+
+      SankeyPath.prototype.downplay = function () {
+        leaveEmphasis(this);
+      };
+
+      return SankeyPath;
+    }(Path);
+
+    var SankeyView =
+    /** @class */
+    function (_super) {
+      __extends(SankeyView, _super);
+
+      function SankeyView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SankeyView.type;
+        _this._focusAdjacencyDisabled = false;
+        return _this;
+      }
+
+      SankeyView.prototype.render = function (seriesModel, ecModel, api) {
+        var sankeyView = this;
+        var graph = seriesModel.getGraph();
+        var group = this.group;
+        var layoutInfo = seriesModel.layoutInfo; // view width
+
+        var width = layoutInfo.width; // view height
+
+        var height = layoutInfo.height;
+        var nodeData = seriesModel.getData();
+        var edgeData = seriesModel.getData('edge');
+        var orient = seriesModel.get('orient');
+        this._model = seriesModel;
+        group.removeAll();
+        group.x = layoutInfo.x;
+        group.y = layoutInfo.y; // generate a bezire Curve for each edge
+
+        graph.eachEdge(function (edge) {
+          var curve = new SankeyPath();
+          var ecData = getECData(curve);
+          ecData.dataIndex = edge.dataIndex;
+          ecData.seriesIndex = seriesModel.seriesIndex;
+          ecData.dataType = 'edge';
+          var edgeModel = edge.getModel();
+          var lineStyleModel = edgeModel.getModel('lineStyle');
+          var curvature = lineStyleModel.get('curveness');
+          var n1Layout = edge.node1.getLayout();
+          var node1Model = edge.node1.getModel();
+          var dragX1 = node1Model.get('localX');
+          var dragY1 = node1Model.get('localY');
+          var n2Layout = edge.node2.getLayout();
+          var node2Model = edge.node2.getModel();
+          var dragX2 = node2Model.get('localX');
+          var dragY2 = node2Model.get('localY');
+          var edgeLayout = edge.getLayout();
+          var x1;
+          var y1;
+          var x2;
+          var y2;
+          var cpx1;
+          var cpy1;
+          var cpx2;
+          var cpy2;
+          curve.shape.extent = Math.max(1, edgeLayout.dy);
+          curve.shape.orient = orient;
+
+          if (orient === 'vertical') {
+            x1 = (dragX1 != null ? dragX1 * width : n1Layout.x) + edgeLayout.sy;
+            y1 = (dragY1 != null ? dragY1 * height : n1Layout.y) + n1Layout.dy;
+            x2 = (dragX2 != null ? dragX2 * width : n2Layout.x) + edgeLayout.ty;
+            y2 = dragY2 != null ? dragY2 * height : n2Layout.y;
+            cpx1 = x1;
+            cpy1 = y1 * (1 - curvature) + y2 * curvature;
+            cpx2 = x2;
+            cpy2 = y1 * curvature + y2 * (1 - curvature);
+          } else {
+            x1 = (dragX1 != null ? dragX1 * width : n1Layout.x) + n1Layout.dx;
+            y1 = (dragY1 != null ? dragY1 * height : n1Layout.y) + edgeLayout.sy;
+            x2 = dragX2 != null ? dragX2 * width : n2Layout.x;
+            y2 = (dragY2 != null ? dragY2 * height : n2Layout.y) + edgeLayout.ty;
+            cpx1 = x1 * (1 - curvature) + x2 * curvature;
+            cpy1 = y1;
+            cpx2 = x1 * curvature + x2 * (1 - curvature);
+            cpy2 = y2;
+          }
+
+          curve.setShape({
+            x1: x1,
+            y1: y1,
+            x2: x2,
+            y2: y2,
+            cpx1: cpx1,
+            cpy1: cpy1,
+            cpx2: cpx2,
+            cpy2: cpy2
+          });
+          curve.useStyle(lineStyleModel.getItemStyle()); // Special color, use source node color or target node color
+
+          switch (curve.style.fill) {
+            case 'source':
+              curve.style.fill = edge.node1.getVisual('color');
+              curve.style.decal = edge.node1.getVisual('style').decal;
+              break;
+
+            case 'target':
+              curve.style.fill = edge.node2.getVisual('color');
+              curve.style.decal = edge.node2.getVisual('style').decal;
+              break;
+
+            case 'gradient':
+              var sourceColor = edge.node1.getVisual('color');
+              var targetColor = edge.node2.getVisual('color');
+
+              if (typeof sourceColor === 'string' && typeof targetColor === 'string') {
+                curve.style.fill = new LinearGradient(0, 0, 1, 0, [{
+                  color: sourceColor,
+                  offset: 0
+                }, {
+                  color: targetColor,
+                  offset: 1
+                }]);
+              }
+
+          }
+
+          var emphasisModel = edgeModel.getModel('emphasis');
+          setStatesStylesFromModel(curve, edgeModel, 'lineStyle', function (model) {
+            return model.getItemStyle();
+          });
+          group.add(curve);
+          edgeData.setItemGraphicEl(edge.dataIndex, curve);
+          var focus = emphasisModel.get('focus');
+          enableHoverEmphasis(curve, focus === 'adjacency' ? edge.getAdjacentDataIndices() : focus, emphasisModel.get('blurScope'));
+          getECData(curve).dataType = 'edge';
+        }); // Generate a rect for each node
+
+        graph.eachNode(function (node) {
+          var layout = node.getLayout();
+          var itemModel = node.getModel();
+          var dragX = itemModel.get('localX');
+          var dragY = itemModel.get('localY');
+          var emphasisModel = itemModel.getModel('emphasis');
+          var rect = new Rect({
+            shape: {
+              x: dragX != null ? dragX * width : layout.x,
+              y: dragY != null ? dragY * height : layout.y,
+              width: layout.dx,
+              height: layout.dy
+            },
+            style: itemModel.getModel('itemStyle').getItemStyle()
+          });
+          setLabelStyle(rect, getLabelStatesModels(itemModel), {
+            labelFetcher: seriesModel,
+            labelDataIndex: node.dataIndex,
+            defaultText: node.id
+          });
+          rect.disableLabelAnimation = true;
+          rect.setStyle('fill', node.getVisual('color'));
+          rect.setStyle('decal', node.getVisual('style').decal);
+          setStatesStylesFromModel(rect, itemModel);
+          group.add(rect);
+          nodeData.setItemGraphicEl(node.dataIndex, rect);
+          getECData(rect).dataType = 'node';
+          var focus = emphasisModel.get('focus');
+          enableHoverEmphasis(rect, focus === 'adjacency' ? node.getAdjacentDataIndices() : focus, emphasisModel.get('blurScope'));
+        });
+        nodeData.eachItemGraphicEl(function (el, dataIndex) {
+          var itemModel = nodeData.getItemModel(dataIndex);
+
+          if (itemModel.get('draggable')) {
+            el.drift = function (dx, dy) {
+              sankeyView._focusAdjacencyDisabled = true;
+              this.shape.x += dx;
+              this.shape.y += dy;
+              this.dirty();
+              api.dispatchAction({
+                type: 'dragNode',
+                seriesId: seriesModel.id,
+                dataIndex: nodeData.getRawIndex(dataIndex),
+                localX: this.shape.x / width,
+                localY: this.shape.y / height
+              });
+            };
+
+            el.ondragend = function () {
+              sankeyView._focusAdjacencyDisabled = false;
+            };
+
+            el.draggable = true;
+            el.cursor = 'move';
+          }
+        });
+
+        if (!this._data && seriesModel.isAnimationEnabled()) {
+          group.setClipPath(createGridClipShape$1(group.getBoundingRect(), seriesModel, function () {
+            group.removeClipPath();
+          }));
+        }
+
+        this._data = seriesModel.getData();
+      };
+
+      SankeyView.prototype.dispose = function () {};
+
+      SankeyView.type = 'sankey';
+      return SankeyView;
+    }(ChartView); // Add animation to the view
+
+
+    function createGridClipShape$1(rect, seriesModel, cb) {
+      var rectEl = new Rect({
+        shape: {
+          x: rect.x - 10,
+          y: rect.y - 10,
+          width: 0,
+          height: rect.height + 20
+        }
+      });
+      initProps(rectEl, {
+        shape: {
+          width: rect.width + 20
+        }
+      }, seriesModel, cb);
+      return rectEl;
+    }
+
+    var SankeySeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(SankeySeriesModel, _super);
+
+      function SankeySeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SankeySeriesModel.type;
+        return _this;
+      }
+      /**
+       * Init a graph data structure from data in option series
+       *
+       * @param  {Object} option  the object used to config echarts view
+       * @return {module:echarts/data/List} storage initial data
+       */
+
+
+      SankeySeriesModel.prototype.getInitialData = function (option, ecModel) {
+        var links = option.edges || option.links;
+        var nodes = option.data || option.nodes;
+        var levels = option.levels;
+        this.levelModels = [];
+        var levelModels = this.levelModels;
+
+        for (var i = 0; i < levels.length; i++) {
+          if (levels[i].depth != null && levels[i].depth >= 0) {
+            levelModels[levels[i].depth] = new Model(levels[i], this, ecModel);
+          } else {
+            if ("development" !== 'production') {
+              throw new Error('levels[i].depth is mandatory and should be natural number');
+            }
+          }
+        }
+
+        if (nodes && links) {
+          var graph = createGraphFromNodeEdge(nodes, links, this, true, beforeLink);
+          return graph.data;
+        }
+
+        function beforeLink(nodeData, edgeData) {
+          nodeData.wrapMethod('getItemModel', function (model, idx) {
+            var seriesModel = model.parentModel;
+            var layout = seriesModel.getData().getItemLayout(idx);
+
+            if (layout) {
+              var nodeDepth = layout.depth;
+              var levelModel = seriesModel.levelModels[nodeDepth];
+
+              if (levelModel) {
+                model.parentModel = levelModel;
+              }
+            }
+
+            return model;
+          });
+          edgeData.wrapMethod('getItemModel', function (model, idx) {
+            var seriesModel = model.parentModel;
+            var edge = seriesModel.getGraph().getEdgeByIndex(idx);
+            var layout = edge.node1.getLayout();
+
+            if (layout) {
+              var depth = layout.depth;
+              var levelModel = seriesModel.levelModels[depth];
+
+              if (levelModel) {
+                model.parentModel = levelModel;
+              }
+            }
+
+            return model;
+          });
+        }
+      };
+
+      SankeySeriesModel.prototype.setNodePosition = function (dataIndex, localPosition) {
+        var dataItem = this.option.data[dataIndex];
+        dataItem.localX = localPosition[0];
+        dataItem.localY = localPosition[1];
+      };
+      /**
+       * Return the graphic data structure
+       *
+       * @return graphic data structure
+       */
+
+
+      SankeySeriesModel.prototype.getGraph = function () {
+        return this.getData().graph;
+      };
+      /**
+       * Get edge data of graphic data structure
+       *
+       * @return data structure of list
+       */
+
+
+      SankeySeriesModel.prototype.getEdgeData = function () {
+        return this.getGraph().edgeData;
+      };
+
+      SankeySeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        function noValue(val) {
+          return isNaN(val) || val == null;
+        } // dataType === 'node' or empty do not show tooltip by default
+
+
+        if (dataType === 'edge') {
+          var params = this.getDataParams(dataIndex, dataType);
+          var rawDataOpt = params.data;
+          var edgeValue = params.value;
+          var edgeName = rawDataOpt.source + ' -- ' + rawDataOpt.target;
+          return createTooltipMarkup('nameValue', {
+            name: edgeName,
+            value: edgeValue,
+            noValue: noValue(edgeValue)
+          });
+        } // dataType === 'node'
+        else {
+            var node = this.getGraph().getNodeByIndex(dataIndex);
+            var value = node.getLayout().value;
+            var name_1 = this.getDataParams(dataIndex, dataType).data.name;
+            return createTooltipMarkup('nameValue', {
+              name: name_1 != null ? name_1 + '' : null,
+              value: value,
+              noValue: noValue(value)
+            });
+          }
+      };
+
+      SankeySeriesModel.prototype.optionUpdated = function () {
+        var option = this.option;
+      }; // Override Series.getDataParams()
+
+
+      SankeySeriesModel.prototype.getDataParams = function (dataIndex, dataType) {
+        var params = _super.prototype.getDataParams.call(this, dataIndex, dataType);
+
+        if (params.value == null && dataType === 'node') {
+          var node = this.getGraph().getNodeByIndex(dataIndex);
+          var nodeValue = node.getLayout().value;
+          params.value = nodeValue;
+        }
+
+        return params;
+      };
+
+      SankeySeriesModel.type = 'series.sankey';
+      SankeySeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'view',
+        left: '5%',
+        top: '5%',
+        right: '20%',
+        bottom: '5%',
+        orient: 'horizontal',
+        nodeWidth: 20,
+        nodeGap: 8,
+        draggable: true,
+        layoutIterations: 32,
+        label: {
+          show: true,
+          position: 'right',
+          fontSize: 12
+        },
+        levels: [],
+        nodeAlign: 'justify',
+        lineStyle: {
+          color: '#314656',
+          opacity: 0.2,
+          curveness: 0.5
+        },
+        emphasis: {
+          label: {
+            show: true
+          },
+          lineStyle: {
+            opacity: 0.5
+          }
+        },
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        },
+        animationEasing: 'linear',
+        animationDuration: 1000
+      };
+      return SankeySeriesModel;
+    }(SeriesModel);
+
+    function sankeyLayout(ecModel, api) {
+      ecModel.eachSeriesByType('sankey', function (seriesModel) {
+        var nodeWidth = seriesModel.get('nodeWidth');
+        var nodeGap = seriesModel.get('nodeGap');
+        var layoutInfo = getViewRect$4(seriesModel, api);
+        seriesModel.layoutInfo = layoutInfo;
+        var width = layoutInfo.width;
+        var height = layoutInfo.height;
+        var graph = seriesModel.getGraph();
+        var nodes = graph.nodes;
+        var edges = graph.edges;
+        computeNodeValues(nodes);
+        var filteredNodes = filter(nodes, function (node) {
+          return node.getLayout().value === 0;
+        });
+        var iterations = filteredNodes.length !== 0 ? 0 : seriesModel.get('layoutIterations');
+        var orient = seriesModel.get('orient');
+        var nodeAlign = seriesModel.get('nodeAlign');
+        layoutSankey(nodes, edges, nodeWidth, nodeGap, width, height, iterations, orient, nodeAlign);
+      });
+    }
+    /**
+     * Get the layout position of the whole view
+     */
+
+    function getViewRect$4(seriesModel, api) {
+      return getLayoutRect(seriesModel.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+    }
+
+    function layoutSankey(nodes, edges, nodeWidth, nodeGap, width, height, iterations, orient, nodeAlign) {
+      computeNodeBreadths(nodes, edges, nodeWidth, width, height, orient, nodeAlign);
+      computeNodeDepths(nodes, edges, height, width, nodeGap, iterations, orient);
+      computeEdgeDepths(nodes, orient);
+    }
+    /**
+     * Compute the value of each node by summing the associated edge's value
+     */
+
+
+    function computeNodeValues(nodes) {
+      each(nodes, function (node) {
+        var value1 = sum(node.outEdges, getEdgeValue);
+        var value2 = sum(node.inEdges, getEdgeValue);
+        var nodeRawValue = node.getValue() || 0;
+        var value = Math.max(value1, value2, nodeRawValue);
+        node.setLayout({
+          value: value
+        }, true);
+      });
+    }
+    /**
+     * Compute the x-position for each node.
+     *
+     * Here we use Kahn algorithm to detect cycle when we traverse
+     * the node to computer the initial x position.
+     */
+
+
+    function computeNodeBreadths(nodes, edges, nodeWidth, width, height, orient, nodeAlign) {
+      // Used to mark whether the edge is deleted. if it is deleted,
+      // the value is 0, otherwise it is 1.
+      var remainEdges = []; // Storage each node's indegree.
+
+      var indegreeArr = []; //Used to storage the node with indegree is equal to 0.
+
+      var zeroIndegrees = [];
+      var nextTargetNode = [];
+      var x = 0; // let kx = 0;
+
+      for (var i = 0; i < edges.length; i++) {
+        remainEdges[i] = 1;
+      }
+
+      for (var i = 0; i < nodes.length; i++) {
+        indegreeArr[i] = nodes[i].inEdges.length;
+
+        if (indegreeArr[i] === 0) {
+          zeroIndegrees.push(nodes[i]);
+        }
+      }
+
+      var maxNodeDepth = -1; // Traversing nodes using topological sorting to calculate the
+      // horizontal(if orient === 'horizontal') or vertical(if orient === 'vertical')
+      // position of the nodes.
+
+      while (zeroIndegrees.length) {
+        for (var idx = 0; idx < zeroIndegrees.length; idx++) {
+          var node = zeroIndegrees[idx];
+          var item = node.hostGraph.data.getRawDataItem(node.dataIndex);
+          var isItemDepth = item.depth != null && item.depth >= 0;
+
+          if (isItemDepth && item.depth > maxNodeDepth) {
+            maxNodeDepth = item.depth;
+          }
+
+          node.setLayout({
+            depth: isItemDepth ? item.depth : x
+          }, true);
+          orient === 'vertical' ? node.setLayout({
+            dy: nodeWidth
+          }, true) : node.setLayout({
+            dx: nodeWidth
+          }, true);
+
+          for (var edgeIdx = 0; edgeIdx < node.outEdges.length; edgeIdx++) {
+            var edge = node.outEdges[edgeIdx];
+            var indexEdge = edges.indexOf(edge);
+            remainEdges[indexEdge] = 0;
+            var targetNode = edge.node2;
+            var nodeIndex = nodes.indexOf(targetNode);
+
+            if (--indegreeArr[nodeIndex] === 0 && nextTargetNode.indexOf(targetNode) < 0) {
+              nextTargetNode.push(targetNode);
+            }
+          }
+        }
+
+        ++x;
+        zeroIndegrees = nextTargetNode;
+        nextTargetNode = [];
+      }
+
+      for (var i = 0; i < remainEdges.length; i++) {
+        if (remainEdges[i] === 1) {
+          throw new Error('Sankey is a DAG, the original data has cycle!');
+        }
+      }
+
+      var maxDepth = maxNodeDepth > x - 1 ? maxNodeDepth : x - 1;
+
+      if (nodeAlign && nodeAlign !== 'left') {
+        adjustNodeWithNodeAlign(nodes, nodeAlign, orient, maxDepth);
+      }
+
+      var kx = orient === 'vertical' ? (height - nodeWidth) / maxDepth : (width - nodeWidth) / maxDepth;
+      scaleNodeBreadths(nodes, kx, orient);
+    }
+
+    function isNodeDepth(node) {
+      var item = node.hostGraph.data.getRawDataItem(node.dataIndex);
+      return item.depth != null && item.depth >= 0;
+    }
+
+    function adjustNodeWithNodeAlign(nodes, nodeAlign, orient, maxDepth) {
+      if (nodeAlign === 'right') {
+        var nextSourceNode = [];
+        var remainNodes = nodes;
+        var nodeHeight = 0;
+
+        while (remainNodes.length) {
+          for (var i = 0; i < remainNodes.length; i++) {
+            var node = remainNodes[i];
+            node.setLayout({
+              skNodeHeight: nodeHeight
+            }, true);
+
+            for (var j = 0; j < node.inEdges.length; j++) {
+              var edge = node.inEdges[j];
+
+              if (nextSourceNode.indexOf(edge.node1) < 0) {
+                nextSourceNode.push(edge.node1);
+              }
+            }
+          }
+
+          remainNodes = nextSourceNode;
+          nextSourceNode = [];
+          ++nodeHeight;
+        }
+
+        each(nodes, function (node) {
+          if (!isNodeDepth(node)) {
+            node.setLayout({
+              depth: Math.max(0, maxDepth - node.getLayout().skNodeHeight)
+            }, true);
+          }
+        });
+      } else if (nodeAlign === 'justify') {
+        moveSinksRight(nodes, maxDepth);
+      }
+    }
+    /**
+     * All the node without outEgdes are assigned maximum x-position and
+     *     be aligned in the last column.
+     *
+     * @param nodes.  node of sankey view.
+     * @param maxDepth.  use to assign to node without outEdges as x-position.
+     */
+
+
+    function moveSinksRight(nodes, maxDepth) {
+      each(nodes, function (node) {
+        if (!isNodeDepth(node) && !node.outEdges.length) {
+          node.setLayout({
+            depth: maxDepth
+          }, true);
+        }
+      });
+    }
+    /**
+     * Scale node x-position to the width
+     *
+     * @param nodes  node of sankey view
+     * @param kx   multiple used to scale nodes
+     */
+
+
+    function scaleNodeBreadths(nodes, kx, orient) {
+      each(nodes, function (node) {
+        var nodeDepth = node.getLayout().depth * kx;
+        orient === 'vertical' ? node.setLayout({
+          y: nodeDepth
+        }, true) : node.setLayout({
+          x: nodeDepth
+        }, true);
+      });
+    }
+    /**
+     * Using Gauss-Seidel iterations method to compute the node depth(y-position)
+     *
+     * @param nodes  node of sankey view
+     * @param edges  edge of sankey view
+     * @param height  the whole height of the area to draw the view
+     * @param nodeGap  the vertical distance between two nodes
+     *     in the same column.
+     * @param iterations  the number of iterations for the algorithm
+     */
+
+
+    function computeNodeDepths(nodes, edges, height, width, nodeGap, iterations, orient) {
+      var nodesByBreadth = prepareNodesByBreadth(nodes, orient);
+      initializeNodeDepth(nodesByBreadth, edges, height, width, nodeGap, orient);
+      resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+
+      for (var alpha = 1; iterations > 0; iterations--) {
+        // 0.99 is a experience parameter, ensure that each iterations of
+        // changes as small as possible.
+        alpha *= 0.99;
+        relaxRightToLeft(nodesByBreadth, alpha, orient);
+        resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+        relaxLeftToRight(nodesByBreadth, alpha, orient);
+        resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+      }
+    }
+
+    function prepareNodesByBreadth(nodes, orient) {
+      var nodesByBreadth = [];
+      var keyAttr = orient === 'vertical' ? 'y' : 'x';
+      var groupResult = groupData(nodes, function (node) {
+        return node.getLayout()[keyAttr];
+      });
+      groupResult.keys.sort(function (a, b) {
+        return a - b;
+      });
+      each(groupResult.keys, function (key) {
+        nodesByBreadth.push(groupResult.buckets.get(key));
+      });
+      return nodesByBreadth;
+    }
+    /**
+     * Compute the original y-position for each node
+     */
+
+
+    function initializeNodeDepth(nodesByBreadth, edges, height, width, nodeGap, orient) {
+      var minKy = Infinity;
+      each(nodesByBreadth, function (nodes) {
+        var n = nodes.length;
+        var sum = 0;
+        each(nodes, function (node) {
+          sum += node.getLayout().value;
+        });
+        var ky = orient === 'vertical' ? (width - (n - 1) * nodeGap) / sum : (height - (n - 1) * nodeGap) / sum;
+
+        if (ky < minKy) {
+          minKy = ky;
+        }
+      });
+      each(nodesByBreadth, function (nodes) {
+        each(nodes, function (node, i) {
+          var nodeDy = node.getLayout().value * minKy;
+
+          if (orient === 'vertical') {
+            node.setLayout({
+              x: i
+            }, true);
+            node.setLayout({
+              dx: nodeDy
+            }, true);
+          } else {
+            node.setLayout({
+              y: i
+            }, true);
+            node.setLayout({
+              dy: nodeDy
+            }, true);
+          }
+        });
+      });
+      each(edges, function (edge) {
+        var edgeDy = +edge.getValue() * minKy;
+        edge.setLayout({
+          dy: edgeDy
+        }, true);
+      });
+    }
+    /**
+     * Resolve the collision of initialized depth (y-position)
+     */
+
+
+    function resolveCollisions(nodesByBreadth, nodeGap, height, width, orient) {
+      var keyAttr = orient === 'vertical' ? 'x' : 'y';
+      each(nodesByBreadth, function (nodes) {
+        nodes.sort(function (a, b) {
+          return a.getLayout()[keyAttr] - b.getLayout()[keyAttr];
+        });
+        var nodeX;
+        var node;
+        var dy;
+        var y0 = 0;
+        var n = nodes.length;
+        var nodeDyAttr = orient === 'vertical' ? 'dx' : 'dy';
+
+        for (var i = 0; i < n; i++) {
+          node = nodes[i];
+          dy = y0 - node.getLayout()[keyAttr];
+
+          if (dy > 0) {
+            nodeX = node.getLayout()[keyAttr] + dy;
+            orient === 'vertical' ? node.setLayout({
+              x: nodeX
+            }, true) : node.setLayout({
+              y: nodeX
+            }, true);
+          }
+
+          y0 = node.getLayout()[keyAttr] + node.getLayout()[nodeDyAttr] + nodeGap;
+        }
+
+        var viewWidth = orient === 'vertical' ? width : height; // If the bottommost node goes outside the bounds, push it back up
+
+        dy = y0 - nodeGap - viewWidth;
+
+        if (dy > 0) {
+          nodeX = node.getLayout()[keyAttr] - dy;
+          orient === 'vertical' ? node.setLayout({
+            x: nodeX
+          }, true) : node.setLayout({
+            y: nodeX
+          }, true);
+          y0 = nodeX;
+
+          for (var i = n - 2; i >= 0; --i) {
+            node = nodes[i];
+            dy = node.getLayout()[keyAttr] + node.getLayout()[nodeDyAttr] + nodeGap - y0;
+
+            if (dy > 0) {
+              nodeX = node.getLayout()[keyAttr] - dy;
+              orient === 'vertical' ? node.setLayout({
+                x: nodeX
+              }, true) : node.setLayout({
+                y: nodeX
+              }, true);
+            }
+
+            y0 = node.getLayout()[keyAttr];
+          }
+        }
+      });
+    }
+    /**
+     * Change the y-position of the nodes, except most the right side nodes
+     * @param nodesByBreadth
+     * @param alpha  parameter used to adjust the nodes y-position
+     */
+
+
+    function relaxRightToLeft(nodesByBreadth, alpha, orient) {
+      each(nodesByBreadth.slice().reverse(), function (nodes) {
+        each(nodes, function (node) {
+          if (node.outEdges.length) {
+            var y = sum(node.outEdges, weightedTarget, orient) / sum(node.outEdges, getEdgeValue);
+
+            if (isNaN(y)) {
+              var len = node.outEdges.length;
+              y = len ? sum(node.outEdges, centerTarget, orient) / len : 0;
+            }
+
+            if (orient === 'vertical') {
+              var nodeX = node.getLayout().x + (y - center$1(node, orient)) * alpha;
+              node.setLayout({
+                x: nodeX
+              }, true);
+            } else {
+              var nodeY = node.getLayout().y + (y - center$1(node, orient)) * alpha;
+              node.setLayout({
+                y: nodeY
+              }, true);
+            }
+          }
+        });
+      });
+    }
+
+    function weightedTarget(edge, orient) {
+      return center$1(edge.node2, orient) * edge.getValue();
+    }
+
+    function centerTarget(edge, orient) {
+      return center$1(edge.node2, orient);
+    }
+
+    function weightedSource(edge, orient) {
+      return center$1(edge.node1, orient) * edge.getValue();
+    }
+
+    function centerSource(edge, orient) {
+      return center$1(edge.node1, orient);
+    }
+
+    function center$1(node, orient) {
+      return orient === 'vertical' ? node.getLayout().x + node.getLayout().dx / 2 : node.getLayout().y + node.getLayout().dy / 2;
+    }
+
+    function getEdgeValue(edge) {
+      return edge.getValue();
+    }
+
+    function sum(array, cb, orient) {
+      var sum = 0;
+      var len = array.length;
+      var i = -1;
+
+      while (++i < len) {
+        var value = +cb(array[i], orient);
+
+        if (!isNaN(value)) {
+          sum += value;
+        }
+      }
+
+      return sum;
+    }
+    /**
+     * Change the y-position of the nodes, except most the left side nodes
+     */
+
+
+    function relaxLeftToRight(nodesByBreadth, alpha, orient) {
+      each(nodesByBreadth, function (nodes) {
+        each(nodes, function (node) {
+          if (node.inEdges.length) {
+            var y = sum(node.inEdges, weightedSource, orient) / sum(node.inEdges, getEdgeValue);
+
+            if (isNaN(y)) {
+              var len = node.inEdges.length;
+              y = len ? sum(node.inEdges, centerSource, orient) / len : 0;
+            }
+
+            if (orient === 'vertical') {
+              var nodeX = node.getLayout().x + (y - center$1(node, orient)) * alpha;
+              node.setLayout({
+                x: nodeX
+              }, true);
+            } else {
+              var nodeY = node.getLayout().y + (y - center$1(node, orient)) * alpha;
+              node.setLayout({
+                y: nodeY
+              }, true);
+            }
+          }
+        });
+      });
+    }
+    /**
+     * Compute the depth(y-position) of each edge
+     */
+
+
+    function computeEdgeDepths(nodes, orient) {
+      var keyAttr = orient === 'vertical' ? 'x' : 'y';
+      each(nodes, function (node) {
+        node.outEdges.sort(function (a, b) {
+          return a.node2.getLayout()[keyAttr] - b.node2.getLayout()[keyAttr];
+        });
+        node.inEdges.sort(function (a, b) {
+          return a.node1.getLayout()[keyAttr] - b.node1.getLayout()[keyAttr];
+        });
+      });
+      each(nodes, function (node) {
+        var sy = 0;
+        var ty = 0;
+        each(node.outEdges, function (edge) {
+          edge.setLayout({
+            sy: sy
+          }, true);
+          sy += edge.getLayout().dy;
+        });
+        each(node.inEdges, function (edge) {
+          edge.setLayout({
+            ty: ty
+          }, true);
+          ty += edge.getLayout().dy;
+        });
+      });
+    }
+
+    function sankeyVisual(ecModel) {
+      ecModel.eachSeriesByType('sankey', function (seriesModel) {
+        var graph = seriesModel.getGraph();
+        var nodes = graph.nodes;
+
+        if (nodes.length) {
+          var minValue_1 = Infinity;
+          var maxValue_1 = -Infinity;
+          each(nodes, function (node) {
+            var nodeValue = node.getLayout().value;
+
+            if (nodeValue < minValue_1) {
+              minValue_1 = nodeValue;
+            }
+
+            if (nodeValue > maxValue_1) {
+              maxValue_1 = nodeValue;
+            }
+          });
+          each(nodes, function (node) {
+            var mapping = new VisualMapping({
+              type: 'color',
+              mappingMethod: 'linear',
+              dataExtent: [minValue_1, maxValue_1],
+              visual: seriesModel.get('color')
+            });
+            var mapValueToColor = mapping.mapValueToVisual(node.getLayout().value);
+            var customColor = node.getModel().get(['itemStyle', 'color']);
+
+            if (customColor != null) {
+              node.setVisual('color', customColor);
+              node.setVisual('style', {
+                fill: customColor
+              });
+            } else {
+              node.setVisual('color', mapValueToColor);
+              node.setVisual('style', {
+                fill: mapValueToColor
+              });
+            }
+          });
+        }
+      });
+    }
+
+    function install$i(registers) {
+      registers.registerChartView(SankeyView);
+      registers.registerSeriesModel(SankeySeriesModel);
+      registers.registerLayout(sankeyLayout);
+      registers.registerVisual(sankeyVisual);
+      registers.registerAction({
+        type: 'dragNode',
+        event: 'dragnode',
+        // here can only use 'update' now, other value is not support in echarts.
+        update: 'update'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'sankey',
+          query: payload
+        }, function (seriesModel) {
+          seriesModel.setNodePosition(payload.dataIndex, [payload.localX, payload.localY]);
+        });
+      });
+    }
+
+    var WhiskerBoxCommonMixin =
+    /** @class */
+    function () {
+      function WhiskerBoxCommonMixin() {}
+      /**
+       * @override
+       */
+
+
+      WhiskerBoxCommonMixin.prototype.getInitialData = function (option, ecModel) {
+        // When both types of xAxis and yAxis are 'value', layout is
+        // needed to be specified by user. Otherwise, layout can be
+        // judged by which axis is category.
+        var ordinalMeta;
+        var xAxisModel = ecModel.getComponent('xAxis', this.get('xAxisIndex'));
+        var yAxisModel = ecModel.getComponent('yAxis', this.get('yAxisIndex'));
+        var xAxisType = xAxisModel.get('type');
+        var yAxisType = yAxisModel.get('type');
+        var addOrdinal; // FIXME
+        // Consider time axis.
+
+        if (xAxisType === 'category') {
+          option.layout = 'horizontal';
+          ordinalMeta = xAxisModel.getOrdinalMeta();
+          addOrdinal = true;
+        } else if (yAxisType === 'category') {
+          option.layout = 'vertical';
+          ordinalMeta = yAxisModel.getOrdinalMeta();
+          addOrdinal = true;
+        } else {
+          option.layout = option.layout || 'horizontal';
+        }
+
+        var coordDims = ['x', 'y'];
+        var baseAxisDimIndex = option.layout === 'horizontal' ? 0 : 1;
+        var baseAxisDim = this._baseAxisDim = coordDims[baseAxisDimIndex];
+        var otherAxisDim = coordDims[1 - baseAxisDimIndex];
+        var axisModels = [xAxisModel, yAxisModel];
+        var baseAxisType = axisModels[baseAxisDimIndex].get('type');
+        var otherAxisType = axisModels[1 - baseAxisDimIndex].get('type');
+        var data = option.data; // ??? FIXME make a stage to perform data transfrom.
+        // MUST create a new data, consider setOption({}) again.
+
+        if (data && addOrdinal) {
+          var newOptionData_1 = [];
+          each(data, function (item, index) {
+            var newItem;
+
+            if (isArray(item)) {
+              newItem = item.slice();
+              item.unshift(index);
+            } else if (isArray(item.value)) {
+              newItem = item.value.slice();
+              item.value.unshift(index);
+            } else {
+              newItem = item;
+            }
+
+            newOptionData_1.push(newItem);
+          });
+          option.data = newOptionData_1;
+        }
+
+        var defaultValueDimensions = this.defaultValueDimensions;
+        var coordDimensions = [{
+          name: baseAxisDim,
+          type: getDimensionTypeByAxis(baseAxisType),
+          ordinalMeta: ordinalMeta,
+          otherDims: {
+            tooltip: false,
+            itemName: 0
+          },
+          dimsDef: ['base']
+        }, {
+          name: otherAxisDim,
+          type: getDimensionTypeByAxis(otherAxisType),
+          dimsDef: defaultValueDimensions.slice()
+        }];
+        return createListSimply(this, {
+          coordDimensions: coordDimensions,
+          dimensionsCount: defaultValueDimensions.length + 1,
+          encodeDefaulter: curry(makeSeriesEncodeForAxisCoordSys, coordDimensions, this)
+        });
+      };
+      /**
+       * If horizontal, base axis is x, otherwise y.
+       * @override
+       */
+
+
+      WhiskerBoxCommonMixin.prototype.getBaseAxis = function () {
+        var dim = this._baseAxisDim;
+        return this.ecModel.getComponent(dim + 'Axis', this.get(dim + 'AxisIndex')).axis;
+      };
+
+      return WhiskerBoxCommonMixin;
+    }();
+
+    var BoxplotSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(BoxplotSeriesModel, _super);
+
+      function BoxplotSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BoxplotSeriesModel.type; // TODO
+        // box width represents group size, so dimension should have 'size'.
+
+        /**
+         * @see <https://en.wikipedia.org/wiki/Box_plot>
+         * The meanings of 'min' and 'max' depend on user,
+         * and echarts do not need to know it.
+         * @readOnly
+         */
+
+        _this.defaultValueDimensions = [{
+          name: 'min',
+          defaultTooltip: true
+        }, {
+          name: 'Q1',
+          defaultTooltip: true
+        }, {
+          name: 'median',
+          defaultTooltip: true
+        }, {
+          name: 'Q3',
+          defaultTooltip: true
+        }, {
+          name: 'max',
+          defaultTooltip: true
+        }];
+        _this.visualDrawType = 'stroke';
+        return _this;
+      }
+
+      BoxplotSeriesModel.type = 'series.boxplot';
+      BoxplotSeriesModel.dependencies = ['xAxis', 'yAxis', 'grid'];
+      BoxplotSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'cartesian2d',
+        legendHoverLink: true,
+        layout: null,
+        boxWidth: [7, 50],
+        itemStyle: {
+          color: '#fff',
+          borderWidth: 1
+        },
+        emphasis: {
+          scale: true,
+          itemStyle: {
+            borderWidth: 2,
+            shadowBlur: 5,
+            shadowOffsetX: 1,
+            shadowOffsetY: 1,
+            shadowColor: 'rgba(0,0,0,0.2)'
+          }
+        },
+        animationDuration: 800
+      };
+      return BoxplotSeriesModel;
+    }(SeriesModel);
+
+    mixin(BoxplotSeriesModel, WhiskerBoxCommonMixin, true);
+
+    var BoxplotView =
+    /** @class */
+    function (_super) {
+      __extends(BoxplotView, _super);
+
+      function BoxplotView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BoxplotView.type;
+        return _this;
+      }
+
+      BoxplotView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var group = this.group;
+        var oldData = this._data; // There is no old data only when first rendering or switching from
+        // stream mode to normal mode, where previous elements should be removed.
+
+        if (!this._data) {
+          group.removeAll();
+        }
+
+        var constDim = seriesModel.get('layout') === 'horizontal' ? 1 : 0;
+        data.diff(oldData).add(function (newIdx) {
+          if (data.hasValue(newIdx)) {
+            var itemLayout = data.getItemLayout(newIdx);
+            var symbolEl = createNormalBox(itemLayout, data, newIdx, constDim, true);
+            data.setItemGraphicEl(newIdx, symbolEl);
+            group.add(symbolEl);
+          }
+        }).update(function (newIdx, oldIdx) {
+          var symbolEl = oldData.getItemGraphicEl(oldIdx); // Empty data
+
+          if (!data.hasValue(newIdx)) {
+            group.remove(symbolEl);
+            return;
+          }
+
+          var itemLayout = data.getItemLayout(newIdx);
+
+          if (!symbolEl) {
+            symbolEl = createNormalBox(itemLayout, data, newIdx, constDim);
+          } else {
+            updateNormalBoxData(itemLayout, symbolEl, data, newIdx);
+          }
+
+          group.add(symbolEl);
+          data.setItemGraphicEl(newIdx, symbolEl);
+        }).remove(function (oldIdx) {
+          var el = oldData.getItemGraphicEl(oldIdx);
+          el && group.remove(el);
+        }).execute();
+        this._data = data;
+      };
+
+      BoxplotView.prototype.remove = function (ecModel) {
+        var group = this.group;
+        var data = this._data;
+        this._data = null;
+        data && data.eachItemGraphicEl(function (el) {
+          el && group.remove(el);
+        });
+      };
+
+      BoxplotView.type = 'boxplot';
+      return BoxplotView;
+    }(ChartView);
+
+    var BoxPathShape =
+    /** @class */
+    function () {
+      function BoxPathShape() {}
+
+      return BoxPathShape;
+    }();
+
+    var BoxPath =
+    /** @class */
+    function (_super) {
+      __extends(BoxPath, _super);
+
+      function BoxPath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'boxplotBoxPath';
+        return _this;
+      }
+
+      BoxPath.prototype.getDefaultShape = function () {
+        return new BoxPathShape();
+      };
+
+      BoxPath.prototype.buildPath = function (ctx, shape) {
+        var ends = shape.points;
+        var i = 0;
+        ctx.moveTo(ends[i][0], ends[i][1]);
+        i++;
+
+        for (; i < 4; i++) {
+          ctx.lineTo(ends[i][0], ends[i][1]);
+        }
+
+        ctx.closePath();
+
+        for (; i < ends.length; i++) {
+          ctx.moveTo(ends[i][0], ends[i][1]);
+          i++;
+          ctx.lineTo(ends[i][0], ends[i][1]);
+        }
+      };
+
+      return BoxPath;
+    }(Path);
+
+    function createNormalBox(itemLayout, data, dataIndex, constDim, isInit) {
+      var ends = itemLayout.ends;
+      var el = new BoxPath({
+        shape: {
+          points: isInit ? transInit(ends, constDim, itemLayout) : ends
+        }
+      });
+      updateNormalBoxData(itemLayout, el, data, dataIndex, isInit);
+      return el;
+    }
+
+    function updateNormalBoxData(itemLayout, el, data, dataIndex, isInit) {
+      var seriesModel = data.hostModel;
+      var updateMethod = graphic[isInit ? 'initProps' : 'updateProps'];
+      updateMethod(el, {
+        shape: {
+          points: itemLayout.ends
+        }
+      }, seriesModel, dataIndex);
+      el.useStyle(data.getItemVisual(dataIndex, 'style'));
+      el.style.strokeNoScale = true;
+      el.z2 = 100;
+      var itemModel = data.getItemModel(dataIndex);
+      setStatesStylesFromModel(el, itemModel);
+      enableHoverEmphasis(el, itemModel.get(['emphasis', 'focus']), itemModel.get(['emphasis', 'blurScope']));
+    }
+
+    function transInit(points, dim, itemLayout) {
+      return map(points, function (point) {
+        point = point.slice();
+        point[dim] = itemLayout.initBaseline;
+        return point;
+      });
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function boxplotVisual(ecModel, api) {
+      ecModel.eachRawSeriesByType('boxplot', function (seriesModel) {
+        seriesModel.getData().setVisual('legendSymbol', 'roundRect');
+      });
+    }
+
+    var each$7 = each;
+    function boxplotLayout(ecModel) {
+      var groupResult = groupSeriesByAxis(ecModel);
+      each$7(groupResult, function (groupItem) {
+        var seriesModels = groupItem.seriesModels;
+
+        if (!seriesModels.length) {
+          return;
+        }
+
+        calculateBase(groupItem);
+        each$7(seriesModels, function (seriesModel, idx) {
+          layoutSingleSeries(seriesModel, groupItem.boxOffsetList[idx], groupItem.boxWidthList[idx]);
+        });
+      });
+    }
+    /**
+     * Group series by axis.
+     */
+
+    function groupSeriesByAxis(ecModel) {
+      var result = [];
+      var axisList = [];
+      ecModel.eachSeriesByType('boxplot', function (seriesModel) {
+        var baseAxis = seriesModel.getBaseAxis();
+        var idx = indexOf(axisList, baseAxis);
+
+        if (idx < 0) {
+          idx = axisList.length;
+          axisList[idx] = baseAxis;
+          result[idx] = {
+            axis: baseAxis,
+            seriesModels: []
+          };
+        }
+
+        result[idx].seriesModels.push(seriesModel);
+      });
+      return result;
+    }
+    /**
+     * Calculate offset and box width for each series.
+     */
+
+
+    function calculateBase(groupItem) {
+      var extent;
+      var baseAxis = groupItem.axis;
+      var seriesModels = groupItem.seriesModels;
+      var seriesCount = seriesModels.length;
+      var boxWidthList = groupItem.boxWidthList = [];
+      var boxOffsetList = groupItem.boxOffsetList = [];
+      var boundList = [];
+      var bandWidth;
+
+      if (baseAxis.type === 'category') {
+        bandWidth = baseAxis.getBandWidth();
+      } else {
+        var maxDataCount_1 = 0;
+        each$7(seriesModels, function (seriesModel) {
+          maxDataCount_1 = Math.max(maxDataCount_1, seriesModel.getData().count());
+        });
+        extent = baseAxis.getExtent(), Math.abs(extent[1] - extent[0]) / maxDataCount_1;
+      }
+
+      each$7(seriesModels, function (seriesModel) {
+        var boxWidthBound = seriesModel.get('boxWidth');
+
+        if (!isArray(boxWidthBound)) {
+          boxWidthBound = [boxWidthBound, boxWidthBound];
+        }
+
+        boundList.push([parsePercent$1(boxWidthBound[0], bandWidth) || 0, parsePercent$1(boxWidthBound[1], bandWidth) || 0]);
+      });
+      var availableWidth = bandWidth * 0.8 - 2;
+      var boxGap = availableWidth / seriesCount * 0.3;
+      var boxWidth = (availableWidth - boxGap * (seriesCount - 1)) / seriesCount;
+      var base = boxWidth / 2 - availableWidth / 2;
+      each$7(seriesModels, function (seriesModel, idx) {
+        boxOffsetList.push(base);
+        base += boxGap + boxWidth;
+        boxWidthList.push(Math.min(Math.max(boxWidth, boundList[idx][0]), boundList[idx][1]));
+      });
+    }
+    /**
+     * Calculate points location for each series.
+     */
+
+
+    function layoutSingleSeries(seriesModel, offset, boxWidth) {
+      var coordSys = seriesModel.coordinateSystem;
+      var data = seriesModel.getData();
+      var halfWidth = boxWidth / 2;
+      var cDimIdx = seriesModel.get('layout') === 'horizontal' ? 0 : 1;
+      var vDimIdx = 1 - cDimIdx;
+      var coordDims = ['x', 'y'];
+      var cDim = data.mapDimension(coordDims[cDimIdx]);
+      var vDims = data.mapDimensionsAll(coordDims[vDimIdx]);
+
+      if (cDim == null || vDims.length < 5) {
+        return;
+      }
+
+      for (var dataIndex = 0; dataIndex < data.count(); dataIndex++) {
+        var axisDimVal = data.get(cDim, dataIndex);
+        var median = getPoint(axisDimVal, vDims[2], dataIndex);
+        var end1 = getPoint(axisDimVal, vDims[0], dataIndex);
+        var end2 = getPoint(axisDimVal, vDims[1], dataIndex);
+        var end4 = getPoint(axisDimVal, vDims[3], dataIndex);
+        var end5 = getPoint(axisDimVal, vDims[4], dataIndex);
+        var ends = [];
+        addBodyEnd(ends, end2, false);
+        addBodyEnd(ends, end4, true);
+        ends.push(end1, end2, end5, end4);
+        layEndLine(ends, end1);
+        layEndLine(ends, end5);
+        layEndLine(ends, median);
+        data.setItemLayout(dataIndex, {
+          initBaseline: median[vDimIdx],
+          ends: ends
+        });
+      }
+
+      function getPoint(axisDimVal, dim, dataIndex) {
+        var val = data.get(dim, dataIndex);
+        var p = [];
+        p[cDimIdx] = axisDimVal;
+        p[vDimIdx] = val;
+        var point;
+
+        if (isNaN(axisDimVal) || isNaN(val)) {
+          point = [NaN, NaN];
+        } else {
+          point = coordSys.dataToPoint(p);
+          point[cDimIdx] += offset;
+        }
+
+        return point;
+      }
+
+      function addBodyEnd(ends, point, start) {
+        var point1 = point.slice();
+        var point2 = point.slice();
+        point1[cDimIdx] += halfWidth;
+        point2[cDimIdx] -= halfWidth;
+        start ? ends.push(point1, point2) : ends.push(point2, point1);
+      }
+
+      function layEndLine(ends, endCenter) {
+        var from = endCenter.slice();
+        var to = endCenter.slice();
+        from[cDimIdx] -= halfWidth;
+        to[cDimIdx] += halfWidth;
+        ends.push(from, to);
+      }
+    }
+
+    /**
+     * See:
+     *  <https://en.wikipedia.org/wiki/Box_plot#cite_note-frigge_hoaglin_iglewicz-2>
+     *  <http://stat.ethz.ch/R-manual/R-devel/library/grDevices/html/boxplot.stats.html>
+     *
+     * Helper method for preparing data.
+     *
+     * @param rawData like
+     *        [
+     *            [12,232,443], (raw data set for the first box)
+     *            [3843,5545,1232], (raw data set for the second box)
+     *            ...
+     *        ]
+     * @param opt.boundIQR=1.5 Data less than min bound is outlier.
+     *      default 1.5, means Q1 - 1.5 * (Q3 - Q1).
+     *      If 'none'/0 passed, min bound will not be used.
+     */
+
+    function prepareBoxplotData(rawData, opt) {
+      opt = opt || {};
+      var boxData = [];
+      var outliers = [];
+      var boundIQR = opt.boundIQR;
+      var useExtreme = boundIQR === 'none' || boundIQR === 0;
+
+      for (var i = 0; i < rawData.length; i++) {
+        var ascList = asc(rawData[i].slice());
+        var Q1 = quantile(ascList, 0.25);
+        var Q2 = quantile(ascList, 0.5);
+        var Q3 = quantile(ascList, 0.75);
+        var min = ascList[0];
+        var max = ascList[ascList.length - 1];
+        var bound = (boundIQR == null ? 1.5 : boundIQR) * (Q3 - Q1);
+        var low = useExtreme ? min : Math.max(min, Q1 - bound);
+        var high = useExtreme ? max : Math.min(max, Q3 + bound);
+        var itemNameFormatter = opt.itemNameFormatter;
+        var itemName = isFunction(itemNameFormatter) ? itemNameFormatter({
+          value: i
+        }) : isString(itemNameFormatter) ? itemNameFormatter.replace('{value}', i + '') : i + '';
+        boxData.push([itemName, low, Q1, Q2, Q3, high]);
+
+        for (var j = 0; j < ascList.length; j++) {
+          var dataItem = ascList[j];
+
+          if (dataItem < low || dataItem > high) {
+            var outlier = [itemName, dataItem];
+            outliers.push(outlier);
+          }
+        }
+      }
+
+      return {
+        boxData: boxData,
+        outliers: outliers
+      };
+    }
+
+    var boxplotTransform = {
+      type: 'echarts:boxplot',
+      transform: function transform(params) {
+        var upstream = params.upstream;
+
+        if (upstream.sourceFormat !== SOURCE_FORMAT_ARRAY_ROWS) {
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            errMsg = makePrintable('source data is not applicable for this boxplot transform. Expect number[][].');
+          }
+
+          throwError(errMsg);
+        }
+
+        var result = prepareBoxplotData(upstream.getRawData(), params.config);
+        return [{
+          dimensions: ['ItemName', 'Low', 'Q1', 'Q2', 'Q3', 'High'],
+          data: result.boxData
+        }, {
+          data: result.outliers
+        }];
+      }
+    };
+
+    function install$j(registers) {
+      registers.registerSeriesModel(BoxplotSeriesModel);
+      registers.registerChartView(BoxplotView);
+      registers.registerVisual(boxplotVisual);
+      registers.registerLayout(boxplotLayout);
+      registers.registerTransform(boxplotTransform);
+    }
+
+    var SKIP_PROPS = ['color', 'borderColor'];
+
+    var CandlestickView =
+    /** @class */
+    function (_super) {
+      __extends(CandlestickView, _super);
+
+      function CandlestickView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CandlestickView.type;
+        return _this;
+      }
+
+      CandlestickView.prototype.render = function (seriesModel, ecModel, api) {
+        // If there is clipPath created in large mode. Remove it.
+        this.group.removeClipPath();
+
+        this._updateDrawMode(seriesModel);
+
+        this._isLargeDraw ? this._renderLarge(seriesModel) : this._renderNormal(seriesModel);
+      };
+
+      CandlestickView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+        this._clear();
+
+        this._updateDrawMode(seriesModel);
+      };
+
+      CandlestickView.prototype.incrementalRender = function (params, seriesModel, ecModel, api) {
+        this._isLargeDraw ? this._incrementalRenderLarge(params, seriesModel) : this._incrementalRenderNormal(params, seriesModel);
+      };
+
+      CandlestickView.prototype._updateDrawMode = function (seriesModel) {
+        var isLargeDraw = seriesModel.pipelineContext.large;
+
+        if (this._isLargeDraw == null || isLargeDraw !== this._isLargeDraw) {
+          this._isLargeDraw = isLargeDraw;
+
+          this._clear();
+        }
+      };
+
+      CandlestickView.prototype._renderNormal = function (seriesModel) {
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var group = this.group;
+        var isSimpleBox = data.getLayout('isSimpleBox');
+        var needsClip = seriesModel.get('clip', true);
+        var coord = seriesModel.coordinateSystem;
+        var clipArea = coord.getArea && coord.getArea(); // There is no old data only when first rendering or switching from
+        // stream mode to normal mode, where previous elements should be removed.
+
+        if (!this._data) {
+          group.removeAll();
+        }
+
+        data.diff(oldData).add(function (newIdx) {
+          if (data.hasValue(newIdx)) {
+            var itemLayout = data.getItemLayout(newIdx);
+
+            if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+              return;
+            }
+
+            var el = createNormalBox$1(itemLayout, newIdx, true);
+            initProps(el, {
+              shape: {
+                points: itemLayout.ends
+              }
+            }, seriesModel, newIdx);
+            setBoxCommon(el, data, newIdx, isSimpleBox);
+            group.add(el);
+            data.setItemGraphicEl(newIdx, el);
+          }
+        }).update(function (newIdx, oldIdx) {
+          var el = oldData.getItemGraphicEl(oldIdx); // Empty data
+
+          if (!data.hasValue(newIdx)) {
+            group.remove(el);
+            return;
+          }
+
+          var itemLayout = data.getItemLayout(newIdx);
+
+          if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+            group.remove(el);
+            return;
+          }
+
+          if (!el) {
+            el = createNormalBox$1(itemLayout);
+          } else {
+            updateProps(el, {
+              shape: {
+                points: itemLayout.ends
+              }
+            }, seriesModel, newIdx);
+          }
+
+          setBoxCommon(el, data, newIdx, isSimpleBox);
+          group.add(el);
+          data.setItemGraphicEl(newIdx, el);
+        }).remove(function (oldIdx) {
+          var el = oldData.getItemGraphicEl(oldIdx);
+          el && group.remove(el);
+        }).execute();
+        this._data = data;
+      };
+
+      CandlestickView.prototype._renderLarge = function (seriesModel) {
+        this._clear();
+
+        createLarge$1(seriesModel, this.group);
+        var clipPath = seriesModel.get('clip', true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+
+        if (clipPath) {
+          this.group.setClipPath(clipPath);
+        } else {
+          this.group.removeClipPath();
+        }
+      };
+
+      CandlestickView.prototype._incrementalRenderNormal = function (params, seriesModel) {
+        var data = seriesModel.getData();
+        var isSimpleBox = data.getLayout('isSimpleBox');
+        var dataIndex;
+
+        while ((dataIndex = params.next()) != null) {
+          var itemLayout = data.getItemLayout(dataIndex);
+          var el = createNormalBox$1(itemLayout);
+          setBoxCommon(el, data, dataIndex, isSimpleBox);
+          el.incremental = true;
+          this.group.add(el);
+        }
+      };
+
+      CandlestickView.prototype._incrementalRenderLarge = function (params, seriesModel) {
+        createLarge$1(seriesModel, this.group, true);
+      };
+
+      CandlestickView.prototype.remove = function (ecModel) {
+        this._clear();
+      };
+
+      CandlestickView.prototype._clear = function () {
+        this.group.removeAll();
+        this._data = null;
+      };
+
+      CandlestickView.type = 'candlestick';
+      return CandlestickView;
+    }(ChartView);
+
+    var NormalBoxPathShape =
+    /** @class */
+    function () {
+      function NormalBoxPathShape() {}
+
+      return NormalBoxPathShape;
+    }();
+
+    var NormalBoxPath =
+    /** @class */
+    function (_super) {
+      __extends(NormalBoxPath, _super);
+
+      function NormalBoxPath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'normalCandlestickBox';
+        return _this;
+      }
+
+      NormalBoxPath.prototype.getDefaultShape = function () {
+        return new NormalBoxPathShape();
+      };
+
+      NormalBoxPath.prototype.buildPath = function (ctx, shape) {
+        var ends = shape.points;
+
+        if (this.__simpleBox) {
+          ctx.moveTo(ends[4][0], ends[4][1]);
+          ctx.lineTo(ends[6][0], ends[6][1]);
+        } else {
+          ctx.moveTo(ends[0][0], ends[0][1]);
+          ctx.lineTo(ends[1][0], ends[1][1]);
+          ctx.lineTo(ends[2][0], ends[2][1]);
+          ctx.lineTo(ends[3][0], ends[3][1]);
+          ctx.closePath();
+          ctx.moveTo(ends[4][0], ends[4][1]);
+          ctx.lineTo(ends[5][0], ends[5][1]);
+          ctx.moveTo(ends[6][0], ends[6][1]);
+          ctx.lineTo(ends[7][0], ends[7][1]);
+        }
+      };
+
+      return NormalBoxPath;
+    }(Path);
+
+    function createNormalBox$1(itemLayout, dataIndex, isInit) {
+      var ends = itemLayout.ends;
+      return new NormalBoxPath({
+        shape: {
+          points: isInit ? transInit$1(ends, itemLayout) : ends
+        },
+        z2: 100
+      });
+    }
+
+    function isNormalBoxClipped(clipArea, itemLayout) {
+      var clipped = true;
+
+      for (var i = 0; i < itemLayout.ends.length; i++) {
+        // If any point are in the region.
+        if (clipArea.contain(itemLayout.ends[i][0], itemLayout.ends[i][1])) {
+          clipped = false;
+          break;
+        }
+      }
+
+      return clipped;
+    }
+
+    function setBoxCommon(el, data, dataIndex, isSimpleBox) {
+      var itemModel = data.getItemModel(dataIndex);
+      el.useStyle(data.getItemVisual(dataIndex, 'style'));
+      el.style.strokeNoScale = true;
+      el.__simpleBox = isSimpleBox;
+      setStatesStylesFromModel(el, itemModel);
+    }
+
+    function transInit$1(points, itemLayout) {
+      return map(points, function (point) {
+        point = point.slice();
+        point[1] = itemLayout.initBaseline;
+        return point;
+      });
+    }
+
+    var LargeBoxPathShape =
+    /** @class */
+    function () {
+      function LargeBoxPathShape() {}
+
+      return LargeBoxPathShape;
+    }();
+
+    var LargeBoxPath =
+    /** @class */
+    function (_super) {
+      __extends(LargeBoxPath, _super);
+
+      function LargeBoxPath(opts) {
+        var _this = _super.call(this, opts) || this;
+
+        _this.type = 'largeCandlestickBox';
+        return _this;
+      }
+
+      LargeBoxPath.prototype.getDefaultShape = function () {
+        return new LargeBoxPathShape();
+      };
+
+      LargeBoxPath.prototype.buildPath = function (ctx, shape) {
+        // Drawing lines is more efficient than drawing
+        // a whole line or drawing rects.
+        var points = shape.points;
+
+        for (var i = 0; i < points.length;) {
+          if (this.__sign === points[i++]) {
+            var x = points[i++];
+            ctx.moveTo(x, points[i++]);
+            ctx.lineTo(x, points[i++]);
+          } else {
+            i += 3;
+          }
+        }
+      };
+
+      return LargeBoxPath;
+    }(Path);
+
+    function createLarge$1(seriesModel, group, incremental) {
+      var data = seriesModel.getData();
+      var largePoints = data.getLayout('largePoints');
+      var elP = new LargeBoxPath({
+        shape: {
+          points: largePoints
+        },
+        __sign: 1
+      });
+      group.add(elP);
+      var elN = new LargeBoxPath({
+        shape: {
+          points: largePoints
+        },
+        __sign: -1
+      });
+      group.add(elN);
+      setLargeStyle$1(1, elP, seriesModel);
+      setLargeStyle$1(-1, elN, seriesModel);
+
+      if (incremental) {
+        elP.incremental = true;
+        elN.incremental = true;
+      }
+    }
+
+    function setLargeStyle$1(sign, el, seriesModel, data) {
+      // TODO put in visual?
+      var borderColor = seriesModel.get(['itemStyle', sign > 0 ? 'borderColor' : 'borderColor0']) || seriesModel.get(['itemStyle', sign > 0 ? 'color' : 'color0']); // Color must be excluded.
+      // Because symbol provide setColor individually to set fill and stroke
+
+      var itemStyle = seriesModel.getModel('itemStyle').getItemStyle(SKIP_PROPS);
+      el.useStyle(itemStyle);
+      el.style.fill = null;
+      el.style.stroke = borderColor;
+    }
+
+    var CandlestickSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(CandlestickSeriesModel, _super);
+
+      function CandlestickSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CandlestickSeriesModel.type;
+        _this.defaultValueDimensions = [{
+          name: 'open',
+          defaultTooltip: true
+        }, {
+          name: 'close',
+          defaultTooltip: true
+        }, {
+          name: 'lowest',
+          defaultTooltip: true
+        }, {
+          name: 'highest',
+          defaultTooltip: true
+        }];
+        return _this;
+      }
+      /**
+       * Get dimension for shadow in dataZoom
+       * @return dimension name
+       */
+
+
+      CandlestickSeriesModel.prototype.getShadowDim = function () {
+        return 'open';
+      };
+
+      CandlestickSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+        var itemLayout = data.getItemLayout(dataIndex);
+        return itemLayout && selectors.rect(itemLayout.brushRect);
+      };
+
+      CandlestickSeriesModel.type = 'series.candlestick';
+      CandlestickSeriesModel.dependencies = ['xAxis', 'yAxis', 'grid'];
+      CandlestickSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'cartesian2d',
+        legendHoverLink: true,
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        layout: null,
+        clip: true,
+        itemStyle: {
+          color: '#eb5454',
+          color0: '#47b262',
+          borderColor: '#eb5454',
+          borderColor0: '#47b262',
+          // borderColor: '#d24040',
+          // borderColor0: '#398f4f',
+          borderWidth: 1
+        },
+        emphasis: {
+          scale: true,
+          itemStyle: {
+            borderWidth: 2
+          }
+        },
+        barMaxWidth: null,
+        barMinWidth: null,
+        barWidth: null,
+        large: true,
+        largeThreshold: 600,
+        progressive: 3e3,
+        progressiveThreshold: 1e4,
+        progressiveChunkMode: 'mod',
+        animationEasing: 'linear',
+        animationDuration: 300
+      };
+      return CandlestickSeriesModel;
+    }(SeriesModel);
+
+    mixin(CandlestickSeriesModel, WhiskerBoxCommonMixin, true);
+
+    function candlestickPreprocessor(option) {
+      if (!option || !isArray(option.series)) {
+        return;
+      } // Translate 'k' to 'candlestick'.
+
+
+      each(option.series, function (seriesItem) {
+        if (isObject(seriesItem) && seriesItem.type === 'k') {
+          seriesItem.type = 'candlestick';
+        }
+      });
+    }
+
+    var positiveBorderColorQuery = ['itemStyle', 'borderColor'];
+    var negativeBorderColorQuery = ['itemStyle', 'borderColor0'];
+    var positiveColorQuery = ['itemStyle', 'color'];
+    var negativeColorQuery = ['itemStyle', 'color0'];
+    var candlestickVisual = {
+      seriesType: 'candlestick',
+      plan: createRenderPlanner(),
+      // For legend.
+      performRawSeries: true,
+      reset: function (seriesModel, ecModel) {
+        function getColor(sign, model) {
+          return model.get(sign > 0 ? positiveColorQuery : negativeColorQuery);
+        }
+
+        function getBorderColor(sign, model) {
+          return model.get(sign > 0 ? positiveBorderColorQuery : negativeBorderColorQuery);
+        }
+
+        var data = seriesModel.getData();
+        data.setVisual('legendSymbol', 'roundRect'); // Only visible series has each data be visual encoded
+
+        if (ecModel.isSeriesFiltered(seriesModel)) {
+          return;
+        }
+
+        var isLargeRender = seriesModel.pipelineContext.large;
+        return !isLargeRender && {
+          progress: function (params, data) {
+            var dataIndex;
+
+            while ((dataIndex = params.next()) != null) {
+              var itemModel = data.getItemModel(dataIndex);
+              var sign = data.getItemLayout(dataIndex).sign;
+              var style = itemModel.getItemStyle();
+              style.fill = getColor(sign, itemModel);
+              style.stroke = getBorderColor(sign, itemModel) || style.fill;
+              var existsStyle = data.ensureUniqueItemVisual(dataIndex, 'style');
+              extend(existsStyle, style);
+            }
+          }
+        };
+      }
+    };
+
+    var LargeArr$1 = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+    var candlestickLayout = {
+      seriesType: 'candlestick',
+      plan: createRenderPlanner(),
+      reset: function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+        var data = seriesModel.getData();
+        var candleWidth = calculateCandleWidth(seriesModel, data);
+        var cDimIdx = 0;
+        var vDimIdx = 1;
+        var coordDims = ['x', 'y'];
+        var cDim = data.mapDimension(coordDims[cDimIdx]);
+        var vDims = data.mapDimensionsAll(coordDims[vDimIdx]);
+        var openDim = vDims[0];
+        var closeDim = vDims[1];
+        var lowestDim = vDims[2];
+        var highestDim = vDims[3];
+        data.setLayout({
+          candleWidth: candleWidth,
+          // The value is experimented visually.
+          isSimpleBox: candleWidth <= 1.3
+        });
+
+        if (cDim == null || vDims.length < 4) {
+          return;
+        }
+
+        return {
+          progress: seriesModel.pipelineContext.large ? largeProgress : normalProgress
+        };
+
+        function normalProgress(params, data) {
+          var dataIndex;
+
+          while ((dataIndex = params.next()) != null) {
+            var axisDimVal = data.get(cDim, dataIndex);
+            var openVal = data.get(openDim, dataIndex);
+            var closeVal = data.get(closeDim, dataIndex);
+            var lowestVal = data.get(lowestDim, dataIndex);
+            var highestVal = data.get(highestDim, dataIndex);
+            var ocLow = Math.min(openVal, closeVal);
+            var ocHigh = Math.max(openVal, closeVal);
+            var ocLowPoint = getPoint(ocLow, axisDimVal);
+            var ocHighPoint = getPoint(ocHigh, axisDimVal);
+            var lowestPoint = getPoint(lowestVal, axisDimVal);
+            var highestPoint = getPoint(highestVal, axisDimVal);
+            var ends = [];
+            addBodyEnd(ends, ocHighPoint, 0);
+            addBodyEnd(ends, ocLowPoint, 1);
+            ends.push(subPixelOptimizePoint(highestPoint), subPixelOptimizePoint(ocHighPoint), subPixelOptimizePoint(lowestPoint), subPixelOptimizePoint(ocLowPoint));
+            data.setItemLayout(dataIndex, {
+              sign: getSign(data, dataIndex, openVal, closeVal, closeDim),
+              initBaseline: openVal > closeVal ? ocHighPoint[vDimIdx] : ocLowPoint[vDimIdx],
+              ends: ends,
+              brushRect: makeBrushRect(lowestVal, highestVal, axisDimVal)
+            });
+          }
+
+          function getPoint(val, axisDimVal) {
+            var p = [];
+            p[cDimIdx] = axisDimVal;
+            p[vDimIdx] = val;
+            return isNaN(axisDimVal) || isNaN(val) ? [NaN, NaN] : coordSys.dataToPoint(p);
+          }
+
+          function addBodyEnd(ends, point, start) {
+            var point1 = point.slice();
+            var point2 = point.slice();
+            point1[cDimIdx] = subPixelOptimize$1(point1[cDimIdx] + candleWidth / 2, 1, false);
+            point2[cDimIdx] = subPixelOptimize$1(point2[cDimIdx] - candleWidth / 2, 1, true);
+            start ? ends.push(point1, point2) : ends.push(point2, point1);
+          }
+
+          function makeBrushRect(lowestVal, highestVal, axisDimVal) {
+            var pmin = getPoint(lowestVal, axisDimVal);
+            var pmax = getPoint(highestVal, axisDimVal);
+            pmin[cDimIdx] -= candleWidth / 2;
+            pmax[cDimIdx] -= candleWidth / 2;
+            return {
+              x: pmin[0],
+              y: pmin[1],
+              width:  candleWidth ,
+              height:  pmax[1] - pmin[1] 
+            };
+          }
+
+          function subPixelOptimizePoint(point) {
+            point[cDimIdx] = subPixelOptimize$1(point[cDimIdx], 1);
+            return point;
+          }
+        }
+
+        function largeProgress(params, data) {
+          // Structure: [sign, x, yhigh, ylow, sign, x, yhigh, ylow, ...]
+          var points = new LargeArr$1(params.count * 4);
+          var offset = 0;
+          var point;
+          var tmpIn = [];
+          var tmpOut = [];
+          var dataIndex;
+
+          while ((dataIndex = params.next()) != null) {
+            var axisDimVal = data.get(cDim, dataIndex);
+            var openVal = data.get(openDim, dataIndex);
+            var closeVal = data.get(closeDim, dataIndex);
+            var lowestVal = data.get(lowestDim, dataIndex);
+            var highestVal = data.get(highestDim, dataIndex);
+
+            if (isNaN(axisDimVal) || isNaN(lowestVal) || isNaN(highestVal)) {
+              points[offset++] = NaN;
+              offset += 3;
+              continue;
+            }
+
+            points[offset++] = getSign(data, dataIndex, openVal, closeVal, closeDim);
+            tmpIn[cDimIdx] = axisDimVal;
+            tmpIn[vDimIdx] = lowestVal;
+            point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+            points[offset++] = point ? point[0] : NaN;
+            points[offset++] = point ? point[1] : NaN;
+            tmpIn[vDimIdx] = highestVal;
+            point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+            points[offset++] = point ? point[1] : NaN;
+          }
+
+          data.setLayout('largePoints', points);
+        }
+      }
+    };
+
+    function getSign(data, dataIndex, openVal, closeVal, closeDim) {
+      var sign;
+
+      if (openVal > closeVal) {
+        sign = -1;
+      } else if (openVal < closeVal) {
+        sign = 1;
+      } else {
+        sign = dataIndex > 0 // If close === open, compare with close of last record
+        ? data.get(closeDim, dataIndex - 1) <= closeVal ? 1 : -1 : // No record of previous, set to be positive
+        1;
+      }
+
+      return sign;
+    }
+
+    function calculateCandleWidth(seriesModel, data) {
+      var baseAxis = seriesModel.getBaseAxis();
+      var extent;
+      var bandWidth = baseAxis.type === 'category' ? baseAxis.getBandWidth() : (extent = baseAxis.getExtent(), Math.abs(extent[1] - extent[0]) / data.count());
+      var barMaxWidth = parsePercent$1(retrieve2(seriesModel.get('barMaxWidth'), bandWidth), bandWidth);
+      var barMinWidth = parsePercent$1(retrieve2(seriesModel.get('barMinWidth'), 1), bandWidth);
+      var barWidth = seriesModel.get('barWidth');
+      return barWidth != null ? parsePercent$1(barWidth, bandWidth) // Put max outer to ensure bar visible in spite of overlap.
+      : Math.max(Math.min(bandWidth / 2, barMaxWidth), barMinWidth);
+    }
+
+    function install$k(registers) {
+      registers.registerChartView(CandlestickView);
+      registers.registerSeriesModel(CandlestickSeriesModel);
+      registers.registerPreprocessor(candlestickPreprocessor);
+      registers.registerVisual(candlestickVisual);
+      registers.registerLayout(candlestickLayout);
+    }
+
+    var EFFECT_RIPPLE_NUMBER = 3;
+
+    function normalizeSymbolSize$1(symbolSize) {
+      if (!isArray(symbolSize)) {
+        symbolSize = [+symbolSize, +symbolSize];
+      }
+
+      return symbolSize;
+    }
+
+    function updateRipplePath(rippleGroup, effectCfg) {
+      var color = effectCfg.rippleEffectColor || effectCfg.color;
+      rippleGroup.eachChild(function (ripplePath) {
+        ripplePath.attr({
+          z: effectCfg.z,
+          zlevel: effectCfg.zlevel,
+          style: {
+            stroke: effectCfg.brushType === 'stroke' ? color : null,
+            fill: effectCfg.brushType === 'fill' ? color : null
+          }
+        });
+      });
+    }
+
+    var EffectSymbol =
+    /** @class */
+    function (_super) {
+      __extends(EffectSymbol, _super);
+
+      function EffectSymbol(data, idx) {
+        var _this = _super.call(this) || this;
+
+        var symbol = new Symbol(data, idx);
+        var rippleGroup = new Group();
+
+        _this.add(symbol);
+
+        _this.add(rippleGroup);
+
+        _this.updateData(data, idx);
+
+        return _this;
+      }
+
+      EffectSymbol.prototype.stopEffectAnimation = function () {
+        this.childAt(1).removeAll();
+      };
+
+      EffectSymbol.prototype.startEffectAnimation = function (effectCfg) {
+        var symbolType = effectCfg.symbolType;
+        var color = effectCfg.color;
+        var rippleGroup = this.childAt(1);
+
+        for (var i = 0; i < EFFECT_RIPPLE_NUMBER; i++) {
+          // If width/height are set too small (e.g., set to 1) on ios10
+          // and macOS Sierra, a circle stroke become a rect, no matter what
+          // the scale is set. So we set width/height as 2. See #4136.
+          var ripplePath = createSymbol(symbolType, -1, -1, 2, 2, color);
+          ripplePath.attr({
+            style: {
+              strokeNoScale: true
+            },
+            z2: 99,
+            silent: true,
+            scaleX: 0.5,
+            scaleY: 0.5
+          });
+          var delay = -i / EFFECT_RIPPLE_NUMBER * effectCfg.period + effectCfg.effectOffset; // TODO Configurable effectCfg.period
+
+          ripplePath.animate('', true).when(effectCfg.period, {
+            scale: [effectCfg.rippleScale / 2, effectCfg.rippleScale / 2]
+          }).delay(delay).start();
+          ripplePath.animateStyle(true).when(effectCfg.period, {
+            opacity: 0
+          }).delay(delay).start();
+          rippleGroup.add(ripplePath);
+        }
+
+        updateRipplePath(rippleGroup, effectCfg);
+      };
+      /**
+       * Update effect symbol
+       */
+
+
+      EffectSymbol.prototype.updateEffectAnimation = function (effectCfg) {
+        var oldEffectCfg = this._effectCfg;
+        var rippleGroup = this.childAt(1); // Must reinitialize effect if following configuration changed
+
+        var DIFFICULT_PROPS = ['symbolType', 'period', 'rippleScale'];
+
+        for (var i = 0; i < DIFFICULT_PROPS.length; i++) {
+          var propName = DIFFICULT_PROPS[i];
+
+          if (oldEffectCfg[propName] !== effectCfg[propName]) {
+            this.stopEffectAnimation();
+            this.startEffectAnimation(effectCfg);
+            return;
+          }
+        }
+
+        updateRipplePath(rippleGroup, effectCfg);
+      };
+      /**
+       * Highlight symbol
+       */
+
+
+      EffectSymbol.prototype.highlight = function () {
+        enterEmphasis(this);
+      };
+      /**
+       * Downplay symbol
+       */
+
+
+      EffectSymbol.prototype.downplay = function () {
+        leaveEmphasis(this);
+      };
+      /**
+       * Update symbol properties
+       */
+
+
+      EffectSymbol.prototype.updateData = function (data, idx) {
+        var _this = this;
+
+        var seriesModel = data.hostModel;
+        this.childAt(0).updateData(data, idx);
+        var rippleGroup = this.childAt(1);
+        var itemModel = data.getItemModel(idx);
+        var symbolType = data.getItemVisual(idx, 'symbol');
+        var symbolSize = normalizeSymbolSize$1(data.getItemVisual(idx, 'symbolSize'));
+        var symbolStyle = data.getItemVisual(idx, 'style');
+        var color = symbolStyle && symbolStyle.fill;
+        rippleGroup.setScale(symbolSize);
+        rippleGroup.traverse(function (ripplePath) {
+          ripplePath.setStyle('fill', color);
+        });
+        var symbolOffset = itemModel.getShallow('symbolOffset');
+
+        if (symbolOffset) {
+          rippleGroup.x = parsePercent$1(symbolOffset[0], symbolSize[0]);
+          rippleGroup.y = parsePercent$1(symbolOffset[1], symbolSize[1]);
+        }
+
+        var symbolRotate = data.getItemVisual(idx, 'symbolRotate');
+        rippleGroup.rotation = (symbolRotate || 0) * Math.PI / 180 || 0;
+        var effectCfg = {};
+        effectCfg.showEffectOn = seriesModel.get('showEffectOn');
+        effectCfg.rippleScale = itemModel.get(['rippleEffect', 'scale']);
+        effectCfg.brushType = itemModel.get(['rippleEffect', 'brushType']);
+        effectCfg.period = itemModel.get(['rippleEffect', 'period']) * 1000;
+        effectCfg.effectOffset = idx / data.count();
+        effectCfg.z = seriesModel.getShallow('z') || 0;
+        effectCfg.zlevel = seriesModel.getShallow('zlevel') || 0;
+        effectCfg.symbolType = symbolType;
+        effectCfg.color = color;
+        effectCfg.rippleEffectColor = itemModel.get(['rippleEffect', 'color']);
+        this.off('mouseover').off('mouseout').off('emphasis').off('normal');
+
+        if (effectCfg.showEffectOn === 'render') {
+          this._effectCfg ? this.updateEffectAnimation(effectCfg) : this.startEffectAnimation(effectCfg);
+          this._effectCfg = effectCfg;
+        } else {
+          // Not keep old effect config
+          this._effectCfg = null;
+          this.stopEffectAnimation();
+
+          this.onHoverStateChange = function (toState) {
+            if (toState === 'emphasis') {
+              if (effectCfg.showEffectOn !== 'render') {
+                _this.startEffectAnimation(effectCfg);
+              }
+            } else if (toState === 'normal') {
+              if (effectCfg.showEffectOn !== 'render') {
+                _this.stopEffectAnimation();
+              }
+            }
+          };
+        }
+
+        this._effectCfg = effectCfg;
+        enableHoverEmphasis(this);
+      };
+
+      EffectSymbol.prototype.fadeOut = function (cb) {
+        this.off('mouseover').off('mouseout');
+        cb && cb();
+      };
+      return EffectSymbol;
+    }(Group);
+
+    inherits(EffectSymbol, Group);
+
+    var EffectScatterView =
+    /** @class */
+    function (_super) {
+      __extends(EffectScatterView, _super);
+
+      function EffectScatterView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = EffectScatterView.type;
+        return _this;
+      }
+
+      EffectScatterView.prototype.init = function () {
+        this._symbolDraw = new SymbolDraw(EffectSymbol);
+      };
+
+      EffectScatterView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var effectSymbolDraw = this._symbolDraw;
+        effectSymbolDraw.updateData(data);
+        this.group.add(effectSymbolDraw.group);
+      };
+
+      EffectScatterView.prototype.updateTransform = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        this.group.dirty();
+        var res = pointsLayout('').reset(seriesModel, ecModel, api);
+
+        if (res.progress) {
+          res.progress({
+            start: 0,
+            end: data.count(),
+            count: data.count()
+          }, data);
+        }
+
+        this._symbolDraw.updateLayout();
+      };
+
+      EffectScatterView.prototype._updateGroupTransform = function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys && coordSys.getRoamTransform) {
+          this.group.transform = clone$2(coordSys.getRoamTransform());
+          this.group.decomposeTransform();
+        }
+      };
+
+      EffectScatterView.prototype.remove = function (ecModel, api) {
+        this._symbolDraw && this._symbolDraw.remove(true);
+      };
+
+      EffectScatterView.type = 'effectScatter';
+      return EffectScatterView;
+    }(ChartView);
+
+    var EffectScatterSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(EffectScatterSeriesModel, _super);
+
+      function EffectScatterSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = EffectScatterSeriesModel.type;
+        _this.hasSymbolVisual = true;
+        return _this;
+      }
+
+      EffectScatterSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this, {
+          useEncodeDefaulter: true
+        });
+      };
+
+      EffectScatterSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+        return selectors.point(data.getItemLayout(dataIndex));
+      };
+
+      EffectScatterSeriesModel.type = 'series.effectScatter';
+      EffectScatterSeriesModel.dependencies = ['grid', 'polar'];
+      EffectScatterSeriesModel.defaultOption = {
+        coordinateSystem: 'cartesian2d',
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        effectType: 'ripple',
+        progressive: 0,
+        // When to show the effect, option: 'render'|'emphasis'
+        showEffectOn: 'render',
+        // Ripple effect config
+        rippleEffect: {
+          period: 4,
+          // Scale of ripple
+          scale: 2.5,
+          // Brush type can be fill or stroke
+          brushType: 'fill'
+        },
+        // Cartesian coordinate system
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        // Polar coordinate system
+        // polarIndex: 0,
+        // Geo coordinate system
+        // geoIndex: 0,
+        // symbol: null,        // 图形类型
+        symbolSize: 10 // 图形大小，半宽（半径）参数，当图形为方向或菱形则总宽度为symbolSize * 2
+        // symbolRotate: null,  // 图形旋转控制
+        // itemStyle: {
+        //     opacity: 1
+        // }
+
+      };
+      return EffectScatterSeriesModel;
+    }(SeriesModel);
+
+    function install$l(registers) {
+      registers.registerChartView(EffectScatterView);
+      registers.registerSeriesModel(EffectScatterSeriesModel);
+      registers.registerLayout(pointsLayout('effectScatter'));
+    }
+
+    var EffectLine =
+    /** @class */
+    function (_super) {
+      __extends(EffectLine, _super);
+
+      function EffectLine(lineData, idx, seriesScope) {
+        var _this = _super.call(this) || this;
+
+        _this.add(_this.createLine(lineData, idx, seriesScope));
+
+        _this._updateEffectSymbol(lineData, idx);
+
+        return _this;
+      }
+
+      EffectLine.prototype.createLine = function (lineData, idx, seriesScope) {
+        return new Line$1(lineData, idx, seriesScope);
+      };
+
+      EffectLine.prototype._updateEffectSymbol = function (lineData, idx) {
+        var itemModel = lineData.getItemModel(idx);
+        var effectModel = itemModel.getModel('effect');
+        var size = effectModel.get('symbolSize');
+        var symbolType = effectModel.get('symbol');
+
+        if (!isArray(size)) {
+          size = [size, size];
+        }
+
+        var lineStyle = lineData.getItemVisual(idx, 'style');
+        var color = effectModel.get('color') || lineStyle && lineStyle.stroke;
+        var symbol = this.childAt(1);
+
+        if (this._symbolType !== symbolType) {
+          // Remove previous
+          this.remove(symbol);
+          symbol = createSymbol(symbolType, -0.5, -0.5, 1, 1, color);
+          symbol.z2 = 100;
+          symbol.culling = true;
+          this.add(symbol);
+        } // Symbol may be removed if loop is false
+
+
+        if (!symbol) {
+          return;
+        } // Shadow color is same with color in default
+
+
+        symbol.setStyle('shadowColor', color);
+        symbol.setStyle(effectModel.getItemStyle(['color']));
+        symbol.scaleX = size[0];
+        symbol.scaleY = size[1];
+        symbol.setColor(color);
+        this._symbolType = symbolType;
+        this._symbolScale = size;
+
+        this._updateEffectAnimation(lineData, effectModel, idx);
+      };
+
+      EffectLine.prototype._updateEffectAnimation = function (lineData, effectModel, idx) {
+        var symbol = this.childAt(1);
+
+        if (!symbol) {
+          return;
+        }
+
+        var self = this;
+        var points = lineData.getItemLayout(idx);
+        var period = effectModel.get('period') * 1000;
+        var loop = effectModel.get('loop');
+        var constantSpeed = effectModel.get('constantSpeed');
+        var delayExpr = retrieve(effectModel.get('delay'), function (idx) {
+          return idx / lineData.count() * period / 3;
+        }); // Ignore when updating
+
+        symbol.ignore = true;
+
+        this._updateAnimationPoints(symbol, points);
+
+        if (constantSpeed > 0) {
+          period = this._getLineLength(symbol) / constantSpeed * 1000;
+        }
+
+        if (period !== this._period || loop !== this._loop) {
+          symbol.stopAnimation();
+
+          if (period > 0) {
+            var delayNum = void 0;
+
+            if (typeof delayExpr === 'function') {
+              delayNum = delayExpr(idx);
+            } else {
+              delayNum = delayExpr;
+            }
+
+            if (symbol.__t > 0) {
+              delayNum = -period * symbol.__t;
+            }
+
+            symbol.__t = 0;
+            var animator = symbol.animate('', loop).when(period, {
+              __t: 1
+            }).delay(delayNum).during(function () {
+              self._updateSymbolPosition(symbol);
+            });
+
+            if (!loop) {
+              animator.done(function () {
+                self.remove(symbol);
+              });
+            }
+
+            animator.start();
+          }
+        }
+
+        this._period = period;
+        this._loop = loop;
+      };
+
+      EffectLine.prototype._getLineLength = function (symbol) {
+        // Not so accurate
+        return dist(symbol.__p1, symbol.__cp1) + dist(symbol.__cp1, symbol.__p2);
+      };
+
+      EffectLine.prototype._updateAnimationPoints = function (symbol, points) {
+        symbol.__p1 = points[0];
+        symbol.__p2 = points[1];
+        symbol.__cp1 = points[2] || [(points[0][0] + points[1][0]) / 2, (points[0][1] + points[1][1]) / 2];
+      };
+
+      EffectLine.prototype.updateData = function (lineData, idx, seriesScope) {
+        this.childAt(0).updateData(lineData, idx, seriesScope);
+
+        this._updateEffectSymbol(lineData, idx);
+      };
+
+      EffectLine.prototype._updateSymbolPosition = function (symbol) {
+        var p1 = symbol.__p1;
+        var p2 = symbol.__p2;
+        var cp1 = symbol.__cp1;
+        var t = symbol.__t;
+        var pos = [symbol.x, symbol.y];
+        var lastPos = pos.slice();
+        var quadraticAt$1 = quadraticAt;
+        var quadraticDerivativeAt$1 = quadraticDerivativeAt;
+        pos[0] = quadraticAt$1(p1[0], cp1[0], p2[0], t);
+        pos[1] = quadraticAt$1(p1[1], cp1[1], p2[1], t); // Tangent
+
+        var tx = quadraticDerivativeAt$1(p1[0], cp1[0], p2[0], t);
+        var ty = quadraticDerivativeAt$1(p1[1], cp1[1], p2[1], t);
+        symbol.rotation = -Math.atan2(ty, tx) - Math.PI / 2; // enable continuity trail for 'line', 'rect', 'roundRect' symbolType
+
+        if (this._symbolType === 'line' || this._symbolType === 'rect' || this._symbolType === 'roundRect') {
+          if (symbol.__lastT !== undefined && symbol.__lastT < symbol.__t) {
+            symbol.scaleY = dist(lastPos, pos) * 1.05; // make sure the last segment render within endPoint
+
+            if (t === 1) {
+              pos[0] = lastPos[0] + (pos[0] - lastPos[0]) / 2;
+              pos[1] = lastPos[1] + (pos[1] - lastPos[1]) / 2;
+            }
+          } else if (symbol.__lastT === 1) {
+            // After first loop, symbol.__t does NOT start with 0, so connect p1 to pos directly.
+            symbol.scaleY = 2 * dist(p1, pos);
+          } else {
+            symbol.scaleY = this._symbolScale[1];
+          }
+        }
+
+        symbol.__lastT = symbol.__t;
+        symbol.ignore = false;
+        symbol.x = pos[0];
+        symbol.y = pos[1];
+      };
+
+      EffectLine.prototype.updateLayout = function (lineData, idx) {
+        this.childAt(0).updateLayout(lineData, idx);
+        var effectModel = lineData.getItemModel(idx).getModel('effect');
+
+        this._updateEffectAnimation(lineData, effectModel, idx);
+      };
+
+      return EffectLine;
+    }(Group);
+
+    var Polyline$1 =
+    /** @class */
+    function (_super) {
+      __extends(Polyline$1, _super);
+
+      function Polyline$1(lineData, idx, seriesScope) {
+        var _this = _super.call(this) || this;
+
+        _this._createPolyline(lineData, idx, seriesScope);
+
+        return _this;
+      }
+
+      Polyline$1.prototype._createPolyline = function (lineData, idx, seriesScope) {
+        // let seriesModel = lineData.hostModel;
+        var points = lineData.getItemLayout(idx);
+        var line = new Polyline({
+          shape: {
+            points: points
+          }
+        });
+        this.add(line);
+
+        this._updateCommonStl(lineData, idx, seriesScope);
+      };
+
+      Polyline$1.prototype.updateData = function (lineData, idx, seriesScope) {
+        var seriesModel = lineData.hostModel;
+        var line = this.childAt(0);
+        var target = {
+          shape: {
+            points: lineData.getItemLayout(idx)
+          }
+        };
+        updateProps(line, target, seriesModel, idx);
+
+        this._updateCommonStl(lineData, idx, seriesScope);
+      };
+
+      Polyline$1.prototype._updateCommonStl = function (lineData, idx, seriesScope) {
+        var line = this.childAt(0);
+        var itemModel = lineData.getItemModel(idx);
+        var hoverLineStyle = seriesScope && seriesScope.emphasisLineStyle;
+
+        if (!seriesScope || lineData.hasItemOption) {
+          hoverLineStyle = itemModel.getModel(['emphasis', 'lineStyle']).getLineStyle();
+        }
+
+        line.useStyle(lineData.getItemVisual(idx, 'style'));
+        line.style.fill = null;
+        line.style.strokeNoScale = true;
+        var lineEmphasisState = line.ensureState('emphasis');
+        lineEmphasisState.style = hoverLineStyle;
+        enableHoverEmphasis(this);
+      };
+
+      Polyline$1.prototype.updateLayout = function (lineData, idx) {
+        var polyline = this.childAt(0);
+        polyline.setShape('points', lineData.getItemLayout(idx));
+      };
+      return Polyline$1;
+    }(Group);
+
+    var EffectPolyline =
+    /** @class */
+    function (_super) {
+      __extends(EffectPolyline, _super);
+
+      function EffectPolyline() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this._lastFrame = 0;
+        _this._lastFramePercent = 0;
+        return _this;
+      } // Override
+
+
+      EffectPolyline.prototype.createLine = function (lineData, idx, seriesScope) {
+        return new Polyline$1(lineData, idx, seriesScope);
+      };
+
+      EffectPolyline.prototype._updateAnimationPoints = function (symbol, points) {
+        this._points = points;
+        var accLenArr = [0];
+        var len = 0;
+
+        for (var i = 1; i < points.length; i++) {
+          var p1 = points[i - 1];
+          var p2 = points[i];
+          len += dist(p1, p2);
+          accLenArr.push(len);
+        }
+
+        if (len === 0) {
+          this._length = 0;
+          return;
+        }
+
+        for (var i = 0; i < accLenArr.length; i++) {
+          accLenArr[i] /= len;
+        }
+
+        this._offsets = accLenArr;
+        this._length = len;
+      };
+
+      EffectPolyline.prototype._getLineLength = function () {
+        return this._length;
+      };
+
+      EffectPolyline.prototype._updateSymbolPosition = function (symbol) {
+        var t = symbol.__t;
+        var points = this._points;
+        var offsets = this._offsets;
+        var len = points.length;
+
+        if (!offsets) {
+          // Has length 0
+          return;
+        }
+
+        var lastFrame = this._lastFrame;
+        var frame;
+
+        if (t < this._lastFramePercent) {
+          // Start from the next frame
+          // PENDING start from lastFrame ?
+          var start = Math.min(lastFrame + 1, len - 1);
+
+          for (frame = start; frame >= 0; frame--) {
+            if (offsets[frame] <= t) {
+              break;
+            }
+          } // PENDING really need to do this ?
+
+
+          frame = Math.min(frame, len - 2);
+        } else {
+          for (frame = lastFrame; frame < len; frame++) {
+            if (offsets[frame] > t) {
+              break;
+            }
+          }
+
+          frame = Math.min(frame - 1, len - 2);
+        }
+
+        var p = (t - offsets[frame]) / (offsets[frame + 1] - offsets[frame]);
+        var p0 = points[frame];
+        var p1 = points[frame + 1];
+        symbol.x = p0[0] * (1 - p) + p * p1[0];
+        symbol.y = p0[1] * (1 - p) + p * p1[1];
+        var tx = p1[0] - p0[0];
+        var ty = p1[1] - p0[1];
+        symbol.rotation = -Math.atan2(ty, tx) - Math.PI / 2;
+        this._lastFrame = frame;
+        this._lastFramePercent = t;
+        symbol.ignore = false;
+      };
+      return EffectPolyline;
+    }(EffectLine);
+
+    var LargeLinesPathShape =
+    /** @class */
+    function () {
+      function LargeLinesPathShape() {
+        this.polyline = false;
+        this.curveness = 0;
+        this.segs = [];
+      }
+
+      return LargeLinesPathShape;
+    }();
+
+    var LargeLinesPath =
+    /** @class */
+    function (_super) {
+      __extends(LargeLinesPath, _super);
+
+      function LargeLinesPath(opts) {
+        return _super.call(this, opts) || this;
+      }
+
+      LargeLinesPath.prototype.getDefaultStyle = function () {
+        return {
+          stroke: '#000',
+          fill: null
+        };
+      };
+
+      LargeLinesPath.prototype.getDefaultShape = function () {
+        return new LargeLinesPathShape();
+      };
+
+      LargeLinesPath.prototype.buildPath = function (ctx, shape) {
+        var segs = shape.segs;
+        var curveness = shape.curveness;
+
+        if (shape.polyline) {
+          for (var i = 0; i < segs.length;) {
+            var count = segs[i++];
+
+            if (count > 0) {
+              ctx.moveTo(segs[i++], segs[i++]);
+
+              for (var k = 1; k < count; k++) {
+                ctx.lineTo(segs[i++], segs[i++]);
+              }
+            }
+          }
+        } else {
+          for (var i = 0; i < segs.length;) {
+            var x0 = segs[i++];
+            var y0 = segs[i++];
+            var x1 = segs[i++];
+            var y1 = segs[i++];
+            ctx.moveTo(x0, y0);
+
+            if (curveness > 0) {
+              var x2 = (x0 + x1) / 2 - (y0 - y1) * curveness;
+              var y2 = (y0 + y1) / 2 - (x1 - x0) * curveness;
+              ctx.quadraticCurveTo(x2, y2, x1, y1);
+            } else {
+              ctx.lineTo(x1, y1);
+            }
+          }
+        }
+      };
+
+      LargeLinesPath.prototype.findDataIndex = function (x, y) {
+        var shape = this.shape;
+        var segs = shape.segs;
+        var curveness = shape.curveness;
+        var lineWidth = this.style.lineWidth;
+
+        if (shape.polyline) {
+          var dataIndex = 0;
+
+          for (var i = 0; i < segs.length;) {
+            var count = segs[i++];
+
+            if (count > 0) {
+              var x0 = segs[i++];
+              var y0 = segs[i++];
+
+              for (var k = 1; k < count; k++) {
+                var x1 = segs[i++];
+                var y1 = segs[i++];
+
+                if (containStroke(x0, y0, x1, y1, lineWidth, x, y)) {
+                  return dataIndex;
+                }
+              }
+            }
+
+            dataIndex++;
+          }
+        } else {
+          var dataIndex = 0;
+
+          for (var i = 0; i < segs.length;) {
+            var x0 = segs[i++];
+            var y0 = segs[i++];
+            var x1 = segs[i++];
+            var y1 = segs[i++];
+
+            if (curveness > 0) {
+              var x2 = (x0 + x1) / 2 - (y0 - y1) * curveness;
+              var y2 = (y0 + y1) / 2 - (x1 - x0) * curveness;
+
+              if (containStroke$2(x0, y0, x2, y2, x1, y1, lineWidth, x, y)) {
+                return dataIndex;
+              }
+            } else {
+              if (containStroke(x0, y0, x1, y1, lineWidth, x, y)) {
+                return dataIndex;
+              }
+            }
+
+            dataIndex++;
+          }
+        }
+
+        return -1;
+      };
+
+      return LargeLinesPath;
+    }(Path);
+
+    var LargeLineDraw =
+    /** @class */
+    function () {
+      function LargeLineDraw() {
+        this.group = new Group();
+      }
+
+      LargeLineDraw.prototype.isPersistent = function () {
+        return !this._incremental;
+      };
+      /**
+       * Update symbols draw by new data
+       */
+
+      LargeLineDraw.prototype.updateData = function (data) {
+        this.group.removeAll();
+        var lineEl = new LargeLinesPath({
+          rectHover: true,
+          cursor: 'default'
+        });
+        lineEl.setShape({
+          segs: data.getLayout('linesPoints')
+        });
+
+        this._setCommon(lineEl, data); // Add back
+
+
+        this.group.add(lineEl);
+        this._incremental = null;
+      };
+      /**
+       * @override
+       */
+
+      LargeLineDraw.prototype.incrementalPrepareUpdate = function (data) {
+        this.group.removeAll();
+
+        this._clearIncremental();
+
+        if (data.count() > 5e5) {
+          if (!this._incremental) {
+            this._incremental = new IncrementalDisplayable({
+              silent: true
+            });
+          }
+
+          this.group.add(this._incremental);
+        } else {
+          this._incremental = null;
+        }
+      };
+      /**
+       * @override
+       */
+
+      LargeLineDraw.prototype.incrementalUpdate = function (taskParams, data) {
+        var lineEl = new LargeLinesPath();
+        lineEl.setShape({
+          segs: data.getLayout('linesPoints')
+        });
+
+        this._setCommon(lineEl, data, !!this._incremental);
+
+        if (!this._incremental) {
+          lineEl.rectHover = true;
+          lineEl.cursor = 'default';
+          lineEl.__startIndex = taskParams.start;
+          this.group.add(lineEl);
+        } else {
+          this._incremental.addDisplayable(lineEl, true);
+        }
+      };
+      /**
+       * @override
+       */
+
+      LargeLineDraw.prototype.remove = function () {
+        this._clearIncremental();
+
+        this._incremental = null;
+        this.group.removeAll();
+      };
+
+      LargeLineDraw.prototype._setCommon = function (lineEl, data, isIncremental) {
+        var hostModel = data.hostModel;
+        lineEl.setShape({
+          polyline: hostModel.get('polyline'),
+          curveness: hostModel.get(['lineStyle', 'curveness'])
+        });
+        lineEl.useStyle(hostModel.getModel('lineStyle').getLineStyle());
+        lineEl.style.strokeNoScale = true;
+        var style = data.getVisual('style');
+
+        if (style && style.stroke) {
+          lineEl.setStyle('stroke', style.stroke);
+        }
+
+        lineEl.setStyle('fill', null);
+
+        if (!isIncremental) {
+          var ecData_1 = getECData(lineEl); // Enable tooltip
+          // PENDING May have performance issue when path is extremely large
+
+          ecData_1.seriesIndex = hostModel.seriesIndex;
+          lineEl.on('mousemove', function (e) {
+            ecData_1.dataIndex = null;
+            var dataIndex = lineEl.findDataIndex(e.offsetX, e.offsetY);
+
+            if (dataIndex > 0) {
+              // Provide dataIndex for tooltip
+              ecData_1.dataIndex = dataIndex + lineEl.__startIndex;
+            }
+          });
+        }
+      };
+
+      LargeLineDraw.prototype._clearIncremental = function () {
+        var incremental = this._incremental;
+
+        if (incremental) {
+          incremental.clearDisplaybles();
+        }
+      };
+      return LargeLineDraw;
+    }();
+
+    var linesLayout = {
+      seriesType: 'lines',
+      plan: createRenderPlanner(),
+      reset: function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+        var isPolyline = seriesModel.get('polyline');
+        var isLarge = seriesModel.pipelineContext.large;
+        return {
+          progress: function (params, lineData) {
+            var lineCoords = [];
+
+            if (isLarge) {
+              var points = void 0;
+              var segCount = params.end - params.start;
+
+              if (isPolyline) {
+                var totalCoordsCount = 0;
+
+                for (var i = params.start; i < params.end; i++) {
+                  totalCoordsCount += seriesModel.getLineCoordsCount(i);
+                }
+
+                points = new Float32Array(segCount + totalCoordsCount * 2);
+              } else {
+                points = new Float32Array(segCount * 4);
+              }
+
+              var offset = 0;
+              var pt = [];
+
+              for (var i = params.start; i < params.end; i++) {
+                var len = seriesModel.getLineCoords(i, lineCoords);
+
+                if (isPolyline) {
+                  points[offset++] = len;
+                }
+
+                for (var k = 0; k < len; k++) {
+                  pt = coordSys.dataToPoint(lineCoords[k], false, pt);
+                  points[offset++] = pt[0];
+                  points[offset++] = pt[1];
+                }
+              }
+
+              lineData.setLayout('linesPoints', points);
+            } else {
+              for (var i = params.start; i < params.end; i++) {
+                var itemModel = lineData.getItemModel(i);
+                var len = seriesModel.getLineCoords(i, lineCoords);
+                var pts = [];
+
+                if (isPolyline) {
+                  for (var j = 0; j < len; j++) {
+                    pts.push(coordSys.dataToPoint(lineCoords[j]));
+                  }
+                } else {
+                  pts[0] = coordSys.dataToPoint(lineCoords[0]);
+                  pts[1] = coordSys.dataToPoint(lineCoords[1]);
+                  var curveness = itemModel.get(['lineStyle', 'curveness']);
+
+                  if (+curveness) {
+                    pts[2] = [(pts[0][0] + pts[1][0]) / 2 - (pts[0][1] - pts[1][1]) * curveness, (pts[0][1] + pts[1][1]) / 2 - (pts[1][0] - pts[0][0]) * curveness];
+                  }
+                }
+
+                lineData.setItemLayout(i, pts);
+              }
+            }
+          }
+        };
+      }
+    };
+
+    var LinesView =
+    /** @class */
+    function (_super) {
+      __extends(LinesView, _super);
+
+      function LinesView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = LinesView.type;
+        return _this;
+      }
+
+      LinesView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+
+        var lineDraw = this._updateLineDraw(data, seriesModel);
+
+        var zlevel = seriesModel.get('zlevel');
+        var trailLength = seriesModel.get(['effect', 'trailLength']);
+        var zr = api.getZr(); // Avoid the drag cause ghost shadow
+        // FIXME Better way ?
+        // SVG doesn't support
+
+        var isSvg = zr.painter.getType() === 'svg';
+
+        if (!isSvg) {
+          zr.painter.getLayer(zlevel).clear(true);
+        } // Config layer with motion blur
+
+
+        if (this._lastZlevel != null && !isSvg) {
+          zr.configLayer(this._lastZlevel, {
+            motionBlur: false
+          });
+        }
+
+        if (this._showEffect(seriesModel) && trailLength) {
+          if ("development" !== 'production') {
+            var notInIndividual_1 = false;
+            ecModel.eachSeries(function (otherSeriesModel) {
+              if (otherSeriesModel !== seriesModel && otherSeriesModel.get('zlevel') === zlevel) {
+                notInIndividual_1 = true;
+              }
+            });
+            notInIndividual_1 && console.warn('Lines with trail effect should have an individual zlevel');
+          }
+
+          if (!isSvg) {
+            zr.configLayer(zlevel, {
+              motionBlur: true,
+              lastFrameAlpha: Math.max(Math.min(trailLength / 10 + 0.9, 1), 0)
+            });
+          }
+        }
+
+        lineDraw.updateData(data);
+        var clipPath = seriesModel.get('clip', true) && createClipPath(seriesModel.coordinateSystem, false, seriesModel);
+
+        if (clipPath) {
+          this.group.setClipPath(clipPath);
+        } else {
+          this.group.removeClipPath();
+        }
+
+        this._lastZlevel = zlevel;
+        this._finished = true;
+      };
+
+      LinesView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+
+        var lineDraw = this._updateLineDraw(data, seriesModel);
+
+        lineDraw.incrementalPrepareUpdate(data);
+
+        this._clearLayer(api);
+
+        this._finished = false;
+      };
+
+      LinesView.prototype.incrementalRender = function (taskParams, seriesModel, ecModel) {
+        this._lineDraw.incrementalUpdate(taskParams, seriesModel.getData());
+
+        this._finished = taskParams.end === seriesModel.getData().count();
+      };
+
+      LinesView.prototype.updateTransform = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var pipelineContext = seriesModel.pipelineContext;
+
+        if (!this._finished || pipelineContext.large || pipelineContext.progressiveRender) {
+          // TODO Don't have to do update in large mode. Only do it when there are millions of data.
+          return {
+            update: true
+          };
+        } else {
+          // TODO Use same logic with ScatterView.
+          // Manually update layout
+          var res = linesLayout.reset(seriesModel, ecModel, api);
+
+          if (res.progress) {
+            res.progress({
+              start: 0,
+              end: data.count(),
+              count: data.count()
+            }, data);
+          } // Not in large mode
+
+
+          this._lineDraw.updateLayout();
+
+          this._clearLayer(api);
+        }
+      };
+
+      LinesView.prototype._updateLineDraw = function (data, seriesModel) {
+        var lineDraw = this._lineDraw;
+
+        var hasEffect = this._showEffect(seriesModel);
+
+        var isPolyline = !!seriesModel.get('polyline');
+        var pipelineContext = seriesModel.pipelineContext;
+        var isLargeDraw = pipelineContext.large;
+
+        if ("development" !== 'production') {
+          if (hasEffect && isLargeDraw) {
+            console.warn('Large lines not support effect');
+          }
+        }
+
+        if (!lineDraw || hasEffect !== this._hasEffet || isPolyline !== this._isPolyline || isLargeDraw !== this._isLargeDraw) {
+          if (lineDraw) {
+            lineDraw.remove();
+          }
+
+          lineDraw = this._lineDraw = isLargeDraw ? new LargeLineDraw() : new LineDraw(isPolyline ? hasEffect ? EffectPolyline : Polyline$1 : hasEffect ? EffectLine : Line$1);
+          this._hasEffet = hasEffect;
+          this._isPolyline = isPolyline;
+          this._isLargeDraw = isLargeDraw;
+          this.group.removeAll();
+        }
+
+        this.group.add(lineDraw.group);
+        return lineDraw;
+      };
+
+      LinesView.prototype._showEffect = function (seriesModel) {
+        return !!seriesModel.get(['effect', 'show']);
+      };
+
+      LinesView.prototype._clearLayer = function (api) {
+        // Not use motion when dragging or zooming
+        var zr = api.getZr();
+        var isSvg = zr.painter.getType() === 'svg';
+
+        if (!isSvg && this._lastZlevel != null) {
+          zr.painter.getLayer(this._lastZlevel).clear(true);
+        }
+      };
+
+      LinesView.prototype.remove = function (ecModel, api) {
+        this._lineDraw && this._lineDraw.remove();
+        this._lineDraw = null; // Clear motion when lineDraw is removed
+
+        this._clearLayer(api);
+      };
+
+      LinesView.type = 'lines';
+      return LinesView;
+    }(ChartView);
+
+    var Uint32Arr = typeof Uint32Array === 'undefined' ? Array : Uint32Array;
+    var Float64Arr = typeof Float64Array === 'undefined' ? Array : Float64Array;
+
+    function compatEc2(seriesOpt) {
+      var data = seriesOpt.data;
+
+      if (data && data[0] && data[0][0] && data[0][0].coord) {
+        if ("development" !== 'production') {
+          console.warn('Lines data configuration has been changed to' + ' { coords:[[1,2],[2,3]] }');
+        }
+
+        seriesOpt.data = map(data, function (itemOpt) {
+          var coords = [itemOpt[0].coord, itemOpt[1].coord];
+          var target = {
+            coords: coords
+          };
+
+          if (itemOpt[0].name) {
+            target.fromName = itemOpt[0].name;
+          }
+
+          if (itemOpt[1].name) {
+            target.toName = itemOpt[1].name;
+          }
+
+          return mergeAll([target, itemOpt[0], itemOpt[1]]);
+        });
+      }
+    }
+
+    var LinesSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(LinesSeriesModel, _super);
+
+      function LinesSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = LinesSeriesModel.type;
+        _this.visualStyleAccessPath = 'lineStyle';
+        _this.visualDrawType = 'stroke';
+        return _this;
+      }
+
+      LinesSeriesModel.prototype.init = function (option) {
+        // The input data may be null/undefined.
+        option.data = option.data || []; // Not using preprocessor because mergeOption may not have series.type
+
+        compatEc2(option);
+
+        var result = this._processFlatCoordsArray(option.data);
+
+        this._flatCoords = result.flatCoords;
+        this._flatCoordsOffset = result.flatCoordsOffset;
+
+        if (result.flatCoords) {
+          option.data = new Float32Array(result.count);
+        }
+
+        _super.prototype.init.apply(this, arguments);
+      };
+
+      LinesSeriesModel.prototype.mergeOption = function (option) {
+        compatEc2(option);
+
+        if (option.data) {
+          // Only update when have option data to merge.
+          var result = this._processFlatCoordsArray(option.data);
+
+          this._flatCoords = result.flatCoords;
+          this._flatCoordsOffset = result.flatCoordsOffset;
+
+          if (result.flatCoords) {
+            option.data = new Float32Array(result.count);
+          }
+        }
+
+        _super.prototype.mergeOption.apply(this, arguments);
+      };
+
+      LinesSeriesModel.prototype.appendData = function (params) {
+        var result = this._processFlatCoordsArray(params.data);
+
+        if (result.flatCoords) {
+          if (!this._flatCoords) {
+            this._flatCoords = result.flatCoords;
+            this._flatCoordsOffset = result.flatCoordsOffset;
+          } else {
+            this._flatCoords = concatArray(this._flatCoords, result.flatCoords);
+            this._flatCoordsOffset = concatArray(this._flatCoordsOffset, result.flatCoordsOffset);
+          }
+
+          params.data = new Float32Array(result.count);
+        }
+
+        this.getRawData().appendData(params.data);
+      };
+
+      LinesSeriesModel.prototype._getCoordsFromItemModel = function (idx) {
+        var itemModel = this.getData().getItemModel(idx);
+        var coords = itemModel.option instanceof Array ? itemModel.option : itemModel.getShallow('coords');
+
+        if ("development" !== 'production') {
+          if (!(coords instanceof Array && coords.length > 0 && coords[0] instanceof Array)) {
+            throw new Error('Invalid coords ' + JSON.stringify(coords) + '. Lines must have 2d coords array in data item.');
+          }
+        }
+
+        return coords;
+      };
+
+      LinesSeriesModel.prototype.getLineCoordsCount = function (idx) {
+        if (this._flatCoordsOffset) {
+          return this._flatCoordsOffset[idx * 2 + 1];
+        } else {
+          return this._getCoordsFromItemModel(idx).length;
+        }
+      };
+
+      LinesSeriesModel.prototype.getLineCoords = function (idx, out) {
+        if (this._flatCoordsOffset) {
+          var offset = this._flatCoordsOffset[idx * 2];
+          var len = this._flatCoordsOffset[idx * 2 + 1];
+
+          for (var i = 0; i < len; i++) {
+            out[i] = out[i] || [];
+            out[i][0] = this._flatCoords[offset + i * 2];
+            out[i][1] = this._flatCoords[offset + i * 2 + 1];
+          }
+
+          return len;
+        } else {
+          var coords = this._getCoordsFromItemModel(idx);
+
+          for (var i = 0; i < coords.length; i++) {
+            out[i] = out[i] || [];
+            out[i][0] = coords[i][0];
+            out[i][1] = coords[i][1];
+          }
+
+          return coords.length;
+        }
+      };
+
+      LinesSeriesModel.prototype._processFlatCoordsArray = function (data) {
+        var startOffset = 0;
+
+        if (this._flatCoords) {
+          startOffset = this._flatCoords.length;
+        } // Stored as a typed array. In format
+        // Points Count(2) | x | y | x | y | Points Count(3) | x |  y | x | y | x | y |
+
+
+        if (typeof data[0] === 'number') {
+          var len = data.length; // Store offset and len of each segment
+
+          var coordsOffsetAndLenStorage = new Uint32Arr(len);
+          var coordsStorage = new Float64Arr(len);
+          var coordsCursor = 0;
+          var offsetCursor = 0;
+          var dataCount = 0;
+
+          for (var i = 0; i < len;) {
+            dataCount++;
+            var count = data[i++]; // Offset
+
+            coordsOffsetAndLenStorage[offsetCursor++] = coordsCursor + startOffset; // Len
+
+            coordsOffsetAndLenStorage[offsetCursor++] = count;
+
+            for (var k = 0; k < count; k++) {
+              var x = data[i++];
+              var y = data[i++];
+              coordsStorage[coordsCursor++] = x;
+              coordsStorage[coordsCursor++] = y;
+
+              if (i > len) {
+                if ("development" !== 'production') {
+                  throw new Error('Invalid data format.');
+                }
+              }
+            }
+          }
+
+          return {
+            flatCoordsOffset: new Uint32Array(coordsOffsetAndLenStorage.buffer, 0, offsetCursor),
+            flatCoords: coordsStorage,
+            count: dataCount
+          };
+        }
+
+        return {
+          flatCoordsOffset: null,
+          flatCoords: null,
+          count: data.length
+        };
+      };
+
+      LinesSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        if ("development" !== 'production') {
+          var CoordSys = CoordinateSystemManager.get(option.coordinateSystem);
+
+          if (!CoordSys) {
+            throw new Error('Unkown coordinate system ' + option.coordinateSystem);
+          }
+        }
+
+        var lineData = new List(['value'], this);
+        lineData.hasItemOption = false;
+        lineData.initData(option.data, [], function (dataItem, dimName, dataIndex, dimIndex) {
+          // dataItem is simply coords
+          if (dataItem instanceof Array) {
+            return NaN;
+          } else {
+            lineData.hasItemOption = true;
+            var value = dataItem.value;
+
+            if (value != null) {
+              return value instanceof Array ? value[dimIndex] : value;
+            }
+          }
+        });
+        return lineData;
+      };
+
+      LinesSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var data = this.getData();
+        var itemModel = data.getItemModel(dataIndex);
+        var name = itemModel.get('name');
+
+        if (name) {
+          return name;
+        }
+
+        var fromName = itemModel.get('fromName');
+        var toName = itemModel.get('toName');
+        var nameArr = [];
+        fromName != null && nameArr.push(fromName);
+        toName != null && nameArr.push(toName);
+        return createTooltipMarkup('nameValue', {
+          name: nameArr.join(' > ')
+        });
+      };
+
+      LinesSeriesModel.prototype.preventIncremental = function () {
+        return !!this.get(['effect', 'show']);
+      };
+
+      LinesSeriesModel.prototype.getProgressive = function () {
+        var progressive = this.option.progressive;
+
+        if (progressive == null) {
+          return this.option.large ? 1e4 : this.get('progressive');
+        }
+
+        return progressive;
+      };
+
+      LinesSeriesModel.prototype.getProgressiveThreshold = function () {
+        var progressiveThreshold = this.option.progressiveThreshold;
+
+        if (progressiveThreshold == null) {
+          return this.option.large ? 2e4 : this.get('progressiveThreshold');
+        }
+
+        return progressiveThreshold;
+      };
+
+      LinesSeriesModel.type = 'series.lines';
+      LinesSeriesModel.dependencies = ['grid', 'polar', 'geo', 'calendar'];
+      LinesSeriesModel.defaultOption = {
+        coordinateSystem: 'geo',
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        // Cartesian coordinate system
+        xAxisIndex: 0,
+        yAxisIndex: 0,
+        symbol: ['none', 'none'],
+        symbolSize: [10, 10],
+        // Geo coordinate system
+        geoIndex: 0,
+        effect: {
+          show: false,
+          period: 4,
+          constantSpeed: 0,
+          symbol: 'circle',
+          symbolSize: 3,
+          loop: true,
+          trailLength: 0.2
+        },
+        large: false,
+        // Available when large is true
+        largeThreshold: 2000,
+        polyline: false,
+        clip: true,
+        label: {
+          show: false,
+          position: 'end' // distance: 5,
+          // formatter: 标签文本格式器，同Tooltip.formatter，不支持异步回调
+
+        },
+        lineStyle: {
+          opacity: 0.5
+        }
+      };
+      return LinesSeriesModel;
+    }(SeriesModel);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function normalize$3(a) {
+      if (!(a instanceof Array)) {
+        a = [a, a];
+      }
+
+      return a;
+    }
+
+    var linesVisual = {
+      seriesType: 'lines',
+      reset: function (seriesModel) {
+        var symbolType = normalize$3(seriesModel.get('symbol'));
+        var symbolSize = normalize$3(seriesModel.get('symbolSize'));
+        var data = seriesModel.getData();
+        data.setVisual('fromSymbol', symbolType && symbolType[0]);
+        data.setVisual('toSymbol', symbolType && symbolType[1]);
+        data.setVisual('fromSymbolSize', symbolSize && symbolSize[0]);
+        data.setVisual('toSymbolSize', symbolSize && symbolSize[1]);
+
+        function dataEach(data, idx) {
+          var itemModel = data.getItemModel(idx);
+          var symbolType = normalize$3(itemModel.getShallow('symbol', true));
+          var symbolSize = normalize$3(itemModel.getShallow('symbolSize', true));
+          symbolType[0] && data.setItemVisual(idx, 'fromSymbol', symbolType[0]);
+          symbolType[1] && data.setItemVisual(idx, 'toSymbol', symbolType[1]);
+          symbolSize[0] && data.setItemVisual(idx, 'fromSymbolSize', symbolSize[0]);
+          symbolSize[1] && data.setItemVisual(idx, 'toSymbolSize', symbolSize[1]);
+        }
+
+        return {
+          dataEach: data.hasItemOption ? dataEach : null
+        };
+      }
+    };
+
+    function install$m(registers) {
+      registers.registerChartView(LinesView);
+      registers.registerSeriesModel(LinesSeriesModel);
+      registers.registerLayout(linesLayout);
+      registers.registerVisual(linesVisual);
+    }
+
+    var GRADIENT_LEVELS = 256;
+
+    var HeatmapLayer =
+    /** @class */
+    function () {
+      function HeatmapLayer() {
+        this.blurSize = 30;
+        this.pointSize = 20;
+        this.maxOpacity = 1;
+        this.minOpacity = 0;
+        this._gradientPixels = {
+          inRange: null,
+          outOfRange: null
+        };
+        var canvas = createCanvas();
+        this.canvas = canvas;
+      }
+      /**
+       * Renders Heatmap and returns the rendered canvas
+       * @param data array of data, each has x, y, value
+       * @param width canvas width
+       * @param height canvas height
+       */
+
+
+      HeatmapLayer.prototype.update = function (data, width, height, normalize, colorFunc, isInRange) {
+        var brush = this._getBrush();
+
+        var gradientInRange = this._getGradient(colorFunc, 'inRange');
+
+        var gradientOutOfRange = this._getGradient(colorFunc, 'outOfRange');
+
+        var r = this.pointSize + this.blurSize;
+        var canvas = this.canvas;
+        var ctx = canvas.getContext('2d');
+        var len = data.length;
+        canvas.width = width;
+        canvas.height = height;
+
+        for (var i = 0; i < len; ++i) {
+          var p = data[i];
+          var x = p[0];
+          var y = p[1];
+          var value = p[2]; // calculate alpha using value
+
+          var alpha = normalize(value); // draw with the circle brush with alpha
+
+          ctx.globalAlpha = alpha;
+          ctx.drawImage(brush, x - r, y - r);
+        }
+
+        if (!canvas.width || !canvas.height) {
+          // Avoid "Uncaught DOMException: Failed to execute 'getImageData' on
+          // 'CanvasRenderingContext2D': The source height is 0."
+          return canvas;
+        } // colorize the canvas using alpha value and set with gradient
+
+
+        var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        var pixels = imageData.data;
+        var offset = 0;
+        var pixelLen = pixels.length;
+        var minOpacity = this.minOpacity;
+        var maxOpacity = this.maxOpacity;
+        var diffOpacity = maxOpacity - minOpacity;
+
+        while (offset < pixelLen) {
+          var alpha = pixels[offset + 3] / 256;
+          var gradientOffset = Math.floor(alpha * (GRADIENT_LEVELS - 1)) * 4; // Simple optimize to ignore the empty data
+
+          if (alpha > 0) {
+            var gradient = isInRange(alpha) ? gradientInRange : gradientOutOfRange; // Any alpha > 0 will be mapped to [minOpacity, maxOpacity]
+
+            alpha > 0 && (alpha = alpha * diffOpacity + minOpacity);
+            pixels[offset++] = gradient[gradientOffset];
+            pixels[offset++] = gradient[gradientOffset + 1];
+            pixels[offset++] = gradient[gradientOffset + 2];
+            pixels[offset++] = gradient[gradientOffset + 3] * alpha * 256;
+          } else {
+            offset += 4;
+          }
+        }
+
+        ctx.putImageData(imageData, 0, 0);
+        return canvas;
+      };
+      /**
+       * get canvas of a black circle brush used for canvas to draw later
+       */
+
+
+      HeatmapLayer.prototype._getBrush = function () {
+        var brushCanvas = this._brushCanvas || (this._brushCanvas = createCanvas()); // set brush size
+
+        var r = this.pointSize + this.blurSize;
+        var d = r * 2;
+        brushCanvas.width = d;
+        brushCanvas.height = d;
+        var ctx = brushCanvas.getContext('2d');
+        ctx.clearRect(0, 0, d, d); // in order to render shadow without the distinct circle,
+        // draw the distinct circle in an invisible place,
+        // and use shadowOffset to draw shadow in the center of the canvas
+
+        ctx.shadowOffsetX = d;
+        ctx.shadowBlur = this.blurSize; // draw the shadow in black, and use alpha and shadow blur to generate
+        // color in color map
+
+        ctx.shadowColor = '#000'; // draw circle in the left to the canvas
+
+        ctx.beginPath();
+        ctx.arc(-r, r, this.pointSize, 0, Math.PI * 2, true);
+        ctx.closePath();
+        ctx.fill();
+        return brushCanvas;
+      };
+      /**
+       * get gradient color map
+       * @private
+       */
+
+
+      HeatmapLayer.prototype._getGradient = function (colorFunc, state) {
+        var gradientPixels = this._gradientPixels;
+        var pixelsSingleState = gradientPixels[state] || (gradientPixels[state] = new Uint8ClampedArray(256 * 4));
+        var color = [0, 0, 0, 0];
+        var off = 0;
+
+        for (var i = 0; i < 256; i++) {
+          colorFunc[state](i / 255, true, color);
+          pixelsSingleState[off++] = color[0];
+          pixelsSingleState[off++] = color[1];
+          pixelsSingleState[off++] = color[2];
+          pixelsSingleState[off++] = color[3];
+        }
+
+        return pixelsSingleState;
+      };
+
+      return HeatmapLayer;
+    }();
+
+    function getIsInPiecewiseRange(dataExtent, pieceList, selected) {
+      var dataSpan = dataExtent[1] - dataExtent[0];
+      pieceList = map(pieceList, function (piece) {
+        return {
+          interval: [(piece.interval[0] - dataExtent[0]) / dataSpan, (piece.interval[1] - dataExtent[0]) / dataSpan]
+        };
+      });
+      var len = pieceList.length;
+      var lastIndex = 0;
+      return function (val) {
+        var i; // Try to find in the location of the last found
+
+        for (i = lastIndex; i < len; i++) {
+          var interval = pieceList[i].interval;
+
+          if (interval[0] <= val && val <= interval[1]) {
+            lastIndex = i;
+            break;
+          }
+        }
+
+        if (i === len) {
+          // Not found, back interation
+          for (i = lastIndex - 1; i >= 0; i--) {
+            var interval = pieceList[i].interval;
+
+            if (interval[0] <= val && val <= interval[1]) {
+              lastIndex = i;
+              break;
+            }
+          }
+        }
+
+        return i >= 0 && i < len && selected[i];
+      };
+    }
+
+    function getIsInContinuousRange(dataExtent, range) {
+      var dataSpan = dataExtent[1] - dataExtent[0];
+      range = [(range[0] - dataExtent[0]) / dataSpan, (range[1] - dataExtent[0]) / dataSpan];
+      return function (val) {
+        return val >= range[0] && val <= range[1];
+      };
+    }
+
+    function isGeoCoordSys(coordSys) {
+      var dimensions = coordSys.dimensions; // Not use coorSys.type === 'geo' because coordSys maybe extended
+
+      return dimensions[0] === 'lng' && dimensions[1] === 'lat';
+    }
+
+    var HeatmapView =
+    /** @class */
+    function (_super) {
+      __extends(HeatmapView, _super);
+
+      function HeatmapView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = HeatmapView.type;
+        return _this;
+      }
+
+      HeatmapView.prototype.render = function (seriesModel, ecModel, api) {
+        var visualMapOfThisSeries;
+        ecModel.eachComponent('visualMap', function (visualMap) {
+          visualMap.eachTargetSeries(function (targetSeries) {
+            if (targetSeries === seriesModel) {
+              visualMapOfThisSeries = visualMap;
+            }
+          });
+        });
+
+        if ("development" !== 'production') {
+          if (!visualMapOfThisSeries) {
+            throw new Error('Heatmap must use with visualMap');
+          }
+        }
+
+        this.group.removeAll();
+        this._incrementalDisplayable = null;
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys.type === 'cartesian2d' || coordSys.type === 'calendar') {
+          this._renderOnCartesianAndCalendar(seriesModel, api, 0, seriesModel.getData().count());
+        } else if (isGeoCoordSys(coordSys)) {
+          this._renderOnGeo(coordSys, seriesModel, visualMapOfThisSeries, api);
+        }
+      };
+
+      HeatmapView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+        this.group.removeAll();
+      };
+
+      HeatmapView.prototype.incrementalRender = function (params, seriesModel, ecModel, api) {
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys) {
+          // geo does not support incremental rendering?
+          if (isGeoCoordSys(coordSys)) {
+            this.render(seriesModel, ecModel, api);
+          } else {
+            this._renderOnCartesianAndCalendar(seriesModel, api, params.start, params.end, true);
+          }
+        }
+      };
+
+      HeatmapView.prototype._renderOnCartesianAndCalendar = function (seriesModel, api, start, end, incremental) {
+        var coordSys = seriesModel.coordinateSystem;
+        var width;
+        var height;
+        var xAxisExtent;
+        var yAxisExtent;
+
+        if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+          var xAxis = coordSys.getAxis('x');
+          var yAxis = coordSys.getAxis('y');
+
+          if ("development" !== 'production') {
+            if (!(xAxis.type === 'category' && yAxis.type === 'category')) {
+              throw new Error('Heatmap on cartesian must have two category axes');
+            }
+
+            if (!(xAxis.onBand && yAxis.onBand)) {
+              throw new Error('Heatmap on cartesian must have two axes with boundaryGap true');
+            }
+          }
+
+          width = xAxis.getBandWidth();
+          height = yAxis.getBandWidth();
+          xAxisExtent = xAxis.scale.getExtent();
+          yAxisExtent = yAxis.scale.getExtent();
+        }
+
+        var group = this.group;
+        var data = seriesModel.getData();
+        var emphasisStyle = seriesModel.getModel(['emphasis', 'itemStyle']).getItemStyle();
+        var blurStyle = seriesModel.getModel(['blur', 'itemStyle']).getItemStyle();
+        var selectStyle = seriesModel.getModel(['select', 'itemStyle']).getItemStyle();
+        var labelStatesModels = getLabelStatesModels(seriesModel);
+        var focus = seriesModel.get(['emphasis', 'focus']);
+        var blurScope = seriesModel.get(['emphasis', 'blurScope']);
+        var dataDims = isCoordinateSystemType(coordSys, 'cartesian2d') ? [data.mapDimension('x'), data.mapDimension('y'), data.mapDimension('value')] : [data.mapDimension('time'), data.mapDimension('value')];
+
+        for (var idx = start; idx < end; idx++) {
+          var rect = void 0;
+          var style = data.getItemVisual(idx, 'style');
+
+          if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+            var dataDimX = data.get(dataDims[0], idx);
+            var dataDimY = data.get(dataDims[1], idx); // Ignore empty data and out of extent data
+
+            if (isNaN(data.get(dataDims[2], idx)) || dataDimX < xAxisExtent[0] || dataDimX > xAxisExtent[1] || dataDimY < yAxisExtent[0] || dataDimY > yAxisExtent[1]) {
+              continue;
+            }
+
+            var point = coordSys.dataToPoint([dataDimX, dataDimY]);
+            rect = new Rect({
+              shape: {
+                x: Math.floor(Math.round(point[0]) - width / 2),
+                y: Math.floor(Math.round(point[1]) - height / 2),
+                width: Math.ceil(width),
+                height: Math.ceil(height)
+              },
+              style: style
+            });
+          } else {
+            // Ignore empty data
+            if (isNaN(data.get(dataDims[1], idx))) {
+              continue;
+            }
+
+            rect = new Rect({
+              z2: 1,
+              shape: coordSys.dataToRect([data.get(dataDims[0], idx)]).contentShape,
+              style: style
+            });
+          }
+
+          var itemModel = data.getItemModel(idx); // Optimization for large datset
+
+          if (data.hasItemOption) {
+            var emphasisModel = itemModel.getModel('emphasis');
+            emphasisStyle = emphasisModel.getModel('itemStyle').getItemStyle();
+            blurStyle = itemModel.getModel(['blur', 'itemStyle']).getItemStyle();
+            selectStyle = itemModel.getModel(['select', 'itemStyle']).getItemStyle();
+            focus = emphasisModel.get('focus');
+            blurScope = emphasisModel.get('blurScope');
+            labelStatesModels = getLabelStatesModels(itemModel);
+          }
+
+          var rawValue = seriesModel.getRawValue(idx);
+          var defaultText = '-';
+
+          if (rawValue && rawValue[2] != null) {
+            defaultText = rawValue[2] + '';
+          }
+
+          setLabelStyle(rect, labelStatesModels, {
+            labelFetcher: seriesModel,
+            labelDataIndex: idx,
+            defaultOpacity: style.opacity,
+            defaultText: defaultText
+          });
+          rect.ensureState('emphasis').style = emphasisStyle;
+          rect.ensureState('blur').style = blurStyle;
+          rect.ensureState('select').style = selectStyle;
+          enableHoverEmphasis(rect, focus, blurScope);
+          rect.incremental = incremental; // PENDING
+
+          if (incremental) {
+            // Rect must use hover layer if it's incremental.
+            rect.states.emphasis.hoverLayer = true;
+          }
+
+          group.add(rect);
+          data.setItemGraphicEl(idx, rect);
+        }
+      };
+
+      HeatmapView.prototype._renderOnGeo = function (geo, seriesModel, visualMapModel, api) {
+        var inRangeVisuals = visualMapModel.targetVisuals.inRange;
+        var outOfRangeVisuals = visualMapModel.targetVisuals.outOfRange; // if (!visualMapping) {
+        //     throw new Error('Data range must have color visuals');
+        // }
+
+        var data = seriesModel.getData();
+        var hmLayer = this._hmLayer || this._hmLayer || new HeatmapLayer();
+        hmLayer.blurSize = seriesModel.get('blurSize');
+        hmLayer.pointSize = seriesModel.get('pointSize');
+        hmLayer.minOpacity = seriesModel.get('minOpacity');
+        hmLayer.maxOpacity = seriesModel.get('maxOpacity');
+        var rect = geo.getViewRect().clone();
+        var roamTransform = geo.getRoamTransform();
+        rect.applyTransform(roamTransform); // Clamp on viewport
+
+        var x = Math.max(rect.x, 0);
+        var y = Math.max(rect.y, 0);
+        var x2 = Math.min(rect.width + rect.x, api.getWidth());
+        var y2 = Math.min(rect.height + rect.y, api.getHeight());
+        var width = x2 - x;
+        var height = y2 - y;
+        var dims = [data.mapDimension('lng'), data.mapDimension('lat'), data.mapDimension('value')];
+        var points = data.mapArray(dims, function (lng, lat, value) {
+          var pt = geo.dataToPoint([lng, lat]);
+          pt[0] -= x;
+          pt[1] -= y;
+          pt.push(value);
+          return pt;
+        });
+        var dataExtent = visualMapModel.getExtent();
+        var isInRange = visualMapModel.type === 'visualMap.continuous' ? getIsInContinuousRange(dataExtent, visualMapModel.option.range) : getIsInPiecewiseRange(dataExtent, visualMapModel.getPieceList(), visualMapModel.option.selected);
+        hmLayer.update(points, width, height, inRangeVisuals.color.getNormalizer(), {
+          inRange: inRangeVisuals.color.getColorMapper(),
+          outOfRange: outOfRangeVisuals.color.getColorMapper()
+        }, isInRange);
+        var img = new ZRImage({
+          style: {
+            width: width,
+            height: height,
+            x: x,
+            y: y,
+            image: hmLayer.canvas
+          },
+          silent: true
+        });
+        this.group.add(img);
+      };
+
+      HeatmapView.type = 'heatmap';
+      return HeatmapView;
+    }(ChartView);
+
+    var HeatmapSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(HeatmapSeriesModel, _super);
+
+      function HeatmapSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = HeatmapSeriesModel.type;
+        return _this;
+      }
+
+      HeatmapSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this, {
+          generateCoord: 'value'
+        });
+      };
+
+      HeatmapSeriesModel.prototype.preventIncremental = function () {
+        var coordSysCreator = CoordinateSystemManager.get(this.get('coordinateSystem'));
+
+        if (coordSysCreator && coordSysCreator.dimensions) {
+          return coordSysCreator.dimensions[0] === 'lng' && coordSysCreator.dimensions[1] === 'lat';
+        }
+      };
+
+      HeatmapSeriesModel.type = 'series.heatmap';
+      HeatmapSeriesModel.dependencies = ['grid', 'geo', 'calendar'];
+      HeatmapSeriesModel.defaultOption = {
+        coordinateSystem: 'cartesian2d',
+        zlevel: 0,
+        z: 2,
+        // Cartesian coordinate system
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        // Geo coordinate system
+        geoIndex: 0,
+        blurSize: 30,
+        pointSize: 20,
+        maxOpacity: 1,
+        minOpacity: 0,
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        }
+      };
+      return HeatmapSeriesModel;
+    }(SeriesModel);
+
+    function install$n(registers) {
+      registers.registerChartView(HeatmapView);
+      registers.registerSeriesModel(HeatmapSeriesModel);
+    }
+
+    var BAR_BORDER_WIDTH_QUERY$1 = ['itemStyle', 'borderWidth']; // index: +isHorizontal
+
+    var LAYOUT_ATTRS = [{
+      xy: 'x',
+      wh: 'width',
+      index: 0,
+      posDesc: ['left', 'right']
+    }, {
+      xy: 'y',
+      wh: 'height',
+      index: 1,
+      posDesc: ['top', 'bottom']
+    }];
+    var pathForLineWidth = new Circle();
+
+    var PictorialBarView =
+    /** @class */
+    function (_super) {
+      __extends(PictorialBarView, _super);
+
+      function PictorialBarView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PictorialBarView.type;
+        return _this;
+      }
+
+      PictorialBarView.prototype.render = function (seriesModel, ecModel, api) {
+        var group = this.group;
+        var data = seriesModel.getData();
+        var oldData = this._data;
+        var cartesian = seriesModel.coordinateSystem;
+        var baseAxis = cartesian.getBaseAxis();
+        var isHorizontal = baseAxis.isHorizontal();
+        var coordSysRect = cartesian.master.getRect();
+        var opt = {
+          ecSize: {
+            width: api.getWidth(),
+            height: api.getHeight()
+          },
+          seriesModel: seriesModel,
+          coordSys: cartesian,
+          coordSysExtent: [[coordSysRect.x, coordSysRect.x + coordSysRect.width], [coordSysRect.y, coordSysRect.y + coordSysRect.height]],
+          isHorizontal: isHorizontal,
+          valueDim: LAYOUT_ATTRS[+isHorizontal],
+          categoryDim: LAYOUT_ATTRS[1 - +isHorizontal]
+        };
+        data.diff(oldData).add(function (dataIndex) {
+          if (!data.hasValue(dataIndex)) {
+            return;
+          }
+
+          var itemModel = getItemModel(data, dataIndex);
+          var symbolMeta = getSymbolMeta(data, dataIndex, itemModel, opt);
+          var bar = createBar(data, opt, symbolMeta);
+          data.setItemGraphicEl(dataIndex, bar);
+          group.add(bar);
+          updateCommon$1(bar, opt, symbolMeta);
+        }).update(function (newIndex, oldIndex) {
+          var bar = oldData.getItemGraphicEl(oldIndex);
+
+          if (!data.hasValue(newIndex)) {
+            group.remove(bar);
+            return;
+          }
+
+          var itemModel = getItemModel(data, newIndex);
+          var symbolMeta = getSymbolMeta(data, newIndex, itemModel, opt);
+          var pictorialShapeStr = getShapeStr(data, symbolMeta);
+
+          if (bar && pictorialShapeStr !== bar.__pictorialShapeStr) {
+            group.remove(bar);
+            data.setItemGraphicEl(newIndex, null);
+            bar = null;
+          }
+
+          if (bar) {
+            updateBar(bar, opt, symbolMeta);
+          } else {
+            bar = createBar(data, opt, symbolMeta, true);
+          }
+
+          data.setItemGraphicEl(newIndex, bar);
+          bar.__pictorialSymbolMeta = symbolMeta; // Add back
+
+          group.add(bar);
+          updateCommon$1(bar, opt, symbolMeta);
+        }).remove(function (dataIndex) {
+          var bar = oldData.getItemGraphicEl(dataIndex);
+          bar && removeBar(oldData, dataIndex, bar.__pictorialSymbolMeta.animationModel, bar);
+        }).execute();
+        this._data = data;
+        return this.group;
+      };
+
+      PictorialBarView.prototype.remove = function (ecModel, api) {
+        var group = this.group;
+        var data = this._data;
+
+        if (ecModel.get('animation')) {
+          if (data) {
+            data.eachItemGraphicEl(function (bar) {
+              removeBar(data, getECData(bar).dataIndex, ecModel, bar);
+            });
+          }
+        } else {
+          group.removeAll();
+        }
+      };
+
+      PictorialBarView.type = 'pictorialBar';
+      return PictorialBarView;
+    }(ChartView); // Set or calculate default value about symbol, and calculate layout info.
+
+
+    function getSymbolMeta(data, dataIndex, itemModel, opt) {
+      var layout = data.getItemLayout(dataIndex);
+      var symbolRepeat = itemModel.get('symbolRepeat');
+      var symbolClip = itemModel.get('symbolClip');
+      var symbolPosition = itemModel.get('symbolPosition') || 'start';
+      var symbolRotate = itemModel.get('symbolRotate');
+      var rotation = (symbolRotate || 0) * Math.PI / 180 || 0;
+      var symbolPatternSize = itemModel.get('symbolPatternSize') || 2;
+      var isAnimationEnabled = itemModel.isAnimationEnabled();
+      var symbolMeta = {
+        dataIndex: dataIndex,
+        layout: layout,
+        itemModel: itemModel,
+        symbolType: data.getItemVisual(dataIndex, 'symbol') || 'circle',
+        style: data.getItemVisual(dataIndex, 'style'),
+        symbolClip: symbolClip,
+        symbolRepeat: symbolRepeat,
+        symbolRepeatDirection: itemModel.get('symbolRepeatDirection'),
+        symbolPatternSize: symbolPatternSize,
+        rotation: rotation,
+        animationModel: isAnimationEnabled ? itemModel : null,
+        hoverScale: isAnimationEnabled && itemModel.get(['emphasis', 'scale']),
+        z2: itemModel.getShallow('z', true) || 0
+      };
+      prepareBarLength(itemModel, symbolRepeat, layout, opt, symbolMeta);
+      prepareSymbolSize(data, dataIndex, layout, symbolRepeat, symbolClip, symbolMeta.boundingLength, symbolMeta.pxSign, symbolPatternSize, opt, symbolMeta);
+      prepareLineWidth(itemModel, symbolMeta.symbolScale, rotation, opt, symbolMeta);
+      var symbolSize = symbolMeta.symbolSize;
+      var symbolOffset = itemModel.get('symbolOffset');
+
+      if (isArray(symbolOffset)) {
+        symbolOffset = [parsePercent$1(symbolOffset[0], symbolSize[0]), parsePercent$1(symbolOffset[1], symbolSize[1])];
+      }
+
+      prepareLayoutInfo(itemModel, symbolSize, layout, symbolRepeat, symbolClip, symbolOffset, symbolPosition, symbolMeta.valueLineWidth, symbolMeta.boundingLength, symbolMeta.repeatCutLength, opt, symbolMeta);
+      return symbolMeta;
+    } // bar length can be negative.
+
+
+    function prepareBarLength(itemModel, symbolRepeat, layout, opt, outputSymbolMeta) {
+      var valueDim = opt.valueDim;
+      var symbolBoundingData = itemModel.get('symbolBoundingData');
+      var valueAxis = opt.coordSys.getOtherAxis(opt.coordSys.getBaseAxis());
+      var zeroPx = valueAxis.toGlobalCoord(valueAxis.dataToCoord(0));
+      var pxSignIdx = 1 - +(layout[valueDim.wh] <= 0);
+      var boundingLength;
+
+      if (isArray(symbolBoundingData)) {
+        var symbolBoundingExtent = [convertToCoordOnAxis(valueAxis, symbolBoundingData[0]) - zeroPx, convertToCoordOnAxis(valueAxis, symbolBoundingData[1]) - zeroPx];
+        symbolBoundingExtent[1] < symbolBoundingExtent[0] && symbolBoundingExtent.reverse();
+        boundingLength = symbolBoundingExtent[pxSignIdx];
+      } else if (symbolBoundingData != null) {
+        boundingLength = convertToCoordOnAxis(valueAxis, symbolBoundingData) - zeroPx;
+      } else if (symbolRepeat) {
+        boundingLength = opt.coordSysExtent[valueDim.index][pxSignIdx] - zeroPx;
+      } else {
+        boundingLength = layout[valueDim.wh];
+      }
+
+      outputSymbolMeta.boundingLength = boundingLength;
+
+      if (symbolRepeat) {
+        outputSymbolMeta.repeatCutLength = layout[valueDim.wh];
+      }
+
+      outputSymbolMeta.pxSign = boundingLength > 0 ? 1 : boundingLength < 0 ? -1 : 0;
+    }
+
+    function convertToCoordOnAxis(axis, value) {
+      return axis.toGlobalCoord(axis.dataToCoord(axis.scale.parse(value)));
+    } // Support ['100%', '100%']
+
+
+    function prepareSymbolSize(data, dataIndex, layout, symbolRepeat, symbolClip, boundingLength, pxSign, symbolPatternSize, opt, outputSymbolMeta) {
+      var valueDim = opt.valueDim;
+      var categoryDim = opt.categoryDim;
+      var categorySize = Math.abs(layout[categoryDim.wh]);
+      var symbolSize = data.getItemVisual(dataIndex, 'symbolSize');
+      var parsedSymbolSize;
+
+      if (isArray(symbolSize)) {
+        parsedSymbolSize = symbolSize.slice();
+      } else {
+        if (symbolSize == null) {
+          // will parse to number below
+          parsedSymbolSize = ['100%', '100%'];
+        } else {
+          parsedSymbolSize = [symbolSize, symbolSize];
+        }
+      } // Note: percentage symbolSize (like '100%') do not consider lineWidth, because it is
+      // to complicated to calculate real percent value if considering scaled lineWidth.
+      // So the actual size will bigger than layout size if lineWidth is bigger than zero,
+      // which can be tolerated in pictorial chart.
+
+
+      parsedSymbolSize[categoryDim.index] = parsePercent$1(parsedSymbolSize[categoryDim.index], categorySize);
+      parsedSymbolSize[valueDim.index] = parsePercent$1(parsedSymbolSize[valueDim.index], symbolRepeat ? categorySize : Math.abs(boundingLength));
+      outputSymbolMeta.symbolSize = parsedSymbolSize; // If x or y is less than zero, show reversed shape.
+
+      var symbolScale = outputSymbolMeta.symbolScale = [parsedSymbolSize[0] / symbolPatternSize, parsedSymbolSize[1] / symbolPatternSize]; // Follow convention, 'right' and 'top' is the normal scale.
+
+      symbolScale[valueDim.index] *= (opt.isHorizontal ? -1 : 1) * pxSign;
+    }
+
+    function prepareLineWidth(itemModel, symbolScale, rotation, opt, outputSymbolMeta) {
+      // In symbols are drawn with scale, so do not need to care about the case that width
+      // or height are too small. But symbol use strokeNoScale, where acture lineWidth should
+      // be calculated.
+      var valueLineWidth = itemModel.get(BAR_BORDER_WIDTH_QUERY$1) || 0;
+
+      if (valueLineWidth) {
+        pathForLineWidth.attr({
+          scaleX: symbolScale[0],
+          scaleY: symbolScale[1],
+          rotation: rotation
+        });
+        pathForLineWidth.updateTransform();
+        valueLineWidth /= pathForLineWidth.getLineScale();
+        valueLineWidth *= symbolScale[opt.valueDim.index];
+      }
+
+      outputSymbolMeta.valueLineWidth = valueLineWidth;
+    }
+
+    function prepareLayoutInfo(itemModel, symbolSize, layout, symbolRepeat, symbolClip, symbolOffset, symbolPosition, valueLineWidth, boundingLength, repeatCutLength, opt, outputSymbolMeta) {
+      var categoryDim = opt.categoryDim;
+      var valueDim = opt.valueDim;
+      var pxSign = outputSymbolMeta.pxSign;
+      var unitLength = Math.max(symbolSize[valueDim.index] + valueLineWidth, 0);
+      var pathLen = unitLength; // Note: rotation will not effect the layout of symbols, because user may
+      // want symbols to rotate on its center, which should not be translated
+      // when rotating.
+
+      if (symbolRepeat) {
+        var absBoundingLength = Math.abs(boundingLength);
+        var symbolMargin = retrieve(itemModel.get('symbolMargin'), '15%') + '';
+        var hasEndGap = false;
+
+        if (symbolMargin.lastIndexOf('!') === symbolMargin.length - 1) {
+          hasEndGap = true;
+          symbolMargin = symbolMargin.slice(0, symbolMargin.length - 1);
+        }
+
+        var symbolMarginNumeric = parsePercent$1(symbolMargin, symbolSize[valueDim.index]);
+        var uLenWithMargin = Math.max(unitLength + symbolMarginNumeric * 2, 0); // When symbol margin is less than 0, margin at both ends will be subtracted
+        // to ensure that all of the symbols will not be overflow the given area.
+
+        var endFix = hasEndGap ? 0 : symbolMarginNumeric * 2; // Both final repeatTimes and final symbolMarginNumeric area calculated based on
+        // boundingLength.
+
+        var repeatSpecified = isNumeric(symbolRepeat);
+        var repeatTimes = repeatSpecified ? symbolRepeat : toIntTimes((absBoundingLength + endFix) / uLenWithMargin); // Adjust calculate margin, to ensure each symbol is displayed
+        // entirely in the given layout area.
+
+        var mDiff = absBoundingLength - repeatTimes * unitLength;
+        symbolMarginNumeric = mDiff / 2 / (hasEndGap ? repeatTimes : repeatTimes - 1);
+        uLenWithMargin = unitLength + symbolMarginNumeric * 2;
+        endFix = hasEndGap ? 0 : symbolMarginNumeric * 2; // Update repeatTimes when not all symbol will be shown.
+
+        if (!repeatSpecified && symbolRepeat !== 'fixed') {
+          repeatTimes = repeatCutLength ? toIntTimes((Math.abs(repeatCutLength) + endFix) / uLenWithMargin) : 0;
+        }
+
+        pathLen = repeatTimes * uLenWithMargin - endFix;
+        outputSymbolMeta.repeatTimes = repeatTimes;
+        outputSymbolMeta.symbolMargin = symbolMarginNumeric;
+      }
+
+      var sizeFix = pxSign * (pathLen / 2);
+      var pathPosition = outputSymbolMeta.pathPosition = [];
+      pathPosition[categoryDim.index] = layout[categoryDim.wh] / 2;
+      pathPosition[valueDim.index] = symbolPosition === 'start' ? sizeFix : symbolPosition === 'end' ? boundingLength - sizeFix : boundingLength / 2; // 'center'
+
+      if (symbolOffset) {
+        pathPosition[0] += symbolOffset[0];
+        pathPosition[1] += symbolOffset[1];
+      }
+
+      var bundlePosition = outputSymbolMeta.bundlePosition = [];
+      bundlePosition[categoryDim.index] = layout[categoryDim.xy];
+      bundlePosition[valueDim.index] = layout[valueDim.xy];
+      var barRectShape = outputSymbolMeta.barRectShape = extend({}, layout);
+      barRectShape[valueDim.wh] = pxSign * Math.max(Math.abs(layout[valueDim.wh]), Math.abs(pathPosition[valueDim.index] + sizeFix));
+      barRectShape[categoryDim.wh] = layout[categoryDim.wh];
+      var clipShape = outputSymbolMeta.clipShape = {}; // Consider that symbol may be overflow layout rect.
+
+      clipShape[categoryDim.xy] = -layout[categoryDim.xy];
+      clipShape[categoryDim.wh] = opt.ecSize[categoryDim.wh];
+      clipShape[valueDim.xy] = 0;
+      clipShape[valueDim.wh] = layout[valueDim.wh];
+    }
+
+    function createPath(symbolMeta) {
+      var symbolPatternSize = symbolMeta.symbolPatternSize;
+      var path = createSymbol( // Consider texture img, make a big size.
+      symbolMeta.symbolType, -symbolPatternSize / 2, -symbolPatternSize / 2, symbolPatternSize, symbolPatternSize);
+      path.attr({
+        culling: true
+      });
+      path.type !== 'image' && path.setStyle({
+        strokeNoScale: true
+      });
+      return path;
+    }
+
+    function createOrUpdateRepeatSymbols(bar, opt, symbolMeta, isUpdate) {
+      var bundle = bar.__pictorialBundle;
+      var symbolSize = symbolMeta.symbolSize;
+      var valueLineWidth = symbolMeta.valueLineWidth;
+      var pathPosition = symbolMeta.pathPosition;
+      var valueDim = opt.valueDim;
+      var repeatTimes = symbolMeta.repeatTimes || 0;
+      var index = 0;
+      var unit = symbolSize[opt.valueDim.index] + valueLineWidth + symbolMeta.symbolMargin * 2;
+      eachPath(bar, function (path) {
+        path.__pictorialAnimationIndex = index;
+        path.__pictorialRepeatTimes = repeatTimes;
+
+        if (index < repeatTimes) {
+          updateAttr(path, null, makeTarget(index), symbolMeta, isUpdate);
+        } else {
+          updateAttr(path, null, {
+            scaleX: 0,
+            scaleY: 0
+          }, symbolMeta, isUpdate, function () {
+            bundle.remove(path);
+          });
+        } // updateHoverAnimation(path, symbolMeta);
+
+
+        index++;
+      });
+
+      for (; index < repeatTimes; index++) {
+        var path = createPath(symbolMeta);
+        path.__pictorialAnimationIndex = index;
+        path.__pictorialRepeatTimes = repeatTimes;
+        bundle.add(path);
+        var target = makeTarget(index);
+        updateAttr(path, {
+          x: target.x,
+          y: target.y,
+          scaleX: 0,
+          scaleY: 0
+        }, {
+          scaleX: target.scaleX,
+          scaleY: target.scaleY,
+          rotation: target.rotation
+        }, symbolMeta, isUpdate);
+      }
+
+      function makeTarget(index) {
+        var position = pathPosition.slice(); // (start && pxSign > 0) || (end && pxSign < 0): i = repeatTimes - index
+        // Otherwise: i = index;
+
+        var pxSign = symbolMeta.pxSign;
+        var i = index;
+
+        if (symbolMeta.symbolRepeatDirection === 'start' ? pxSign > 0 : pxSign < 0) {
+          i = repeatTimes - 1 - index;
+        }
+
+        position[valueDim.index] = unit * (i - repeatTimes / 2 + 0.5) + pathPosition[valueDim.index];
+        return {
+          x: position[0],
+          y: position[1],
+          scaleX: symbolMeta.symbolScale[0],
+          scaleY: symbolMeta.symbolScale[1],
+          rotation: symbolMeta.rotation
+        };
+      }
+    }
+
+    function createOrUpdateSingleSymbol(bar, opt, symbolMeta, isUpdate) {
+      var bundle = bar.__pictorialBundle;
+      var mainPath = bar.__pictorialMainPath;
+
+      if (!mainPath) {
+        mainPath = bar.__pictorialMainPath = createPath(symbolMeta);
+        bundle.add(mainPath);
+        updateAttr(mainPath, {
+          x: symbolMeta.pathPosition[0],
+          y: symbolMeta.pathPosition[1],
+          scaleX: 0,
+          scaleY: 0,
+          rotation: symbolMeta.rotation
+        }, {
+          scaleX: symbolMeta.symbolScale[0],
+          scaleY: symbolMeta.symbolScale[1]
+        }, symbolMeta, isUpdate);
+      } else {
+        updateAttr(mainPath, null, {
+          x: symbolMeta.pathPosition[0],
+          y: symbolMeta.pathPosition[1],
+          scaleX: symbolMeta.symbolScale[0],
+          scaleY: symbolMeta.symbolScale[1],
+          rotation: symbolMeta.rotation
+        }, symbolMeta, isUpdate);
+      }
+    } // bar rect is used for label.
+
+
+    function createOrUpdateBarRect(bar, symbolMeta, isUpdate) {
+      var rectShape = extend({}, symbolMeta.barRectShape);
+      var barRect = bar.__pictorialBarRect;
+
+      if (!barRect) {
+        barRect = bar.__pictorialBarRect = new Rect({
+          z2: 2,
+          shape: rectShape,
+          silent: true,
+          style: {
+            stroke: 'transparent',
+            fill: 'transparent',
+            lineWidth: 0
+          }
+        });
+        bar.add(barRect);
+      } else {
+        updateAttr(barRect, null, {
+          shape: rectShape
+        }, symbolMeta, isUpdate);
+      }
+    }
+
+    function createOrUpdateClip(bar, opt, symbolMeta, isUpdate) {
+      // If not clip, symbol will be remove and rebuilt.
+      if (symbolMeta.symbolClip) {
+        var clipPath = bar.__pictorialClipPath;
+        var clipShape = extend({}, symbolMeta.clipShape);
+        var valueDim = opt.valueDim;
+        var animationModel = symbolMeta.animationModel;
+        var dataIndex = symbolMeta.dataIndex;
+
+        if (clipPath) {
+          updateProps(clipPath, {
+            shape: clipShape
+          }, animationModel, dataIndex);
+        } else {
+          clipShape[valueDim.wh] = 0;
+          clipPath = new Rect({
+            shape: clipShape
+          });
+
+          bar.__pictorialBundle.setClipPath(clipPath);
+
+          bar.__pictorialClipPath = clipPath;
+          var target = {};
+          target[valueDim.wh] = symbolMeta.clipShape[valueDim.wh];
+          graphic[isUpdate ? 'updateProps' : 'initProps'](clipPath, {
+            shape: target
+          }, animationModel, dataIndex);
+        }
+      }
+    }
+
+    function getItemModel(data, dataIndex) {
+      var itemModel = data.getItemModel(dataIndex);
+      itemModel.getAnimationDelayParams = getAnimationDelayParams;
+      itemModel.isAnimationEnabled = isAnimationEnabled;
+      return itemModel;
+    }
+
+    function getAnimationDelayParams(path) {
+      // The order is the same as the z-order, see `symbolRepeatDiretion`.
+      return {
+        index: path.__pictorialAnimationIndex,
+        count: path.__pictorialRepeatTimes
+      };
+    }
+
+    function isAnimationEnabled() {
+      // `animation` prop can be set on itemModel in pictorial bar chart.
+      return this.parentModel.isAnimationEnabled() && !!this.getShallow('animation');
+    }
+
+    function createBar(data, opt, symbolMeta, isUpdate) {
+      // bar is the main element for each data.
+      var bar = new Group(); // bundle is used for location and clip.
+
+      var bundle = new Group();
+      bar.add(bundle);
+      bar.__pictorialBundle = bundle;
+      bundle.x = symbolMeta.bundlePosition[0];
+      bundle.y = symbolMeta.bundlePosition[1];
+
+      if (symbolMeta.symbolRepeat) {
+        createOrUpdateRepeatSymbols(bar, opt, symbolMeta);
+      } else {
+        createOrUpdateSingleSymbol(bar, opt, symbolMeta);
+      }
+
+      createOrUpdateBarRect(bar, symbolMeta, isUpdate);
+      createOrUpdateClip(bar, opt, symbolMeta, isUpdate);
+      bar.__pictorialShapeStr = getShapeStr(data, symbolMeta);
+      bar.__pictorialSymbolMeta = symbolMeta;
+      return bar;
+    }
+
+    function updateBar(bar, opt, symbolMeta) {
+      var animationModel = symbolMeta.animationModel;
+      var dataIndex = symbolMeta.dataIndex;
+      var bundle = bar.__pictorialBundle;
+      updateProps(bundle, {
+        x: symbolMeta.bundlePosition[0],
+        y: symbolMeta.bundlePosition[1]
+      }, animationModel, dataIndex);
+
+      if (symbolMeta.symbolRepeat) {
+        createOrUpdateRepeatSymbols(bar, opt, symbolMeta, true);
+      } else {
+        createOrUpdateSingleSymbol(bar, opt, symbolMeta, true);
+      }
+
+      createOrUpdateBarRect(bar, symbolMeta, true);
+      createOrUpdateClip(bar, opt, symbolMeta, true);
+    }
+
+    function removeBar(data, dataIndex, animationModel, bar) {
+      // Not show text when animating
+      var labelRect = bar.__pictorialBarRect;
+      labelRect && labelRect.removeTextContent();
+      var pathes = [];
+      eachPath(bar, function (path) {
+        pathes.push(path);
+      });
+      bar.__pictorialMainPath && pathes.push(bar.__pictorialMainPath); // I do not find proper remove animation for clip yet.
+
+      bar.__pictorialClipPath && (animationModel = null);
+      each(pathes, function (path) {
+        removeElement(path, {
+          scaleX: 0,
+          scaleY: 0
+        }, animationModel, dataIndex, function () {
+          bar.parent && bar.parent.remove(bar);
+        });
+      });
+      data.setItemGraphicEl(dataIndex, null);
+    }
+
+    function getShapeStr(data, symbolMeta) {
+      return [data.getItemVisual(symbolMeta.dataIndex, 'symbol') || 'none', !!symbolMeta.symbolRepeat, !!symbolMeta.symbolClip].join(':');
+    }
+
+    function eachPath(bar, cb, context) {
+      // Do not use Group#eachChild, because it do not support remove.
+      each(bar.__pictorialBundle.children(), function (el) {
+        el !== bar.__pictorialBarRect && cb.call(context, el);
+      });
+    }
+
+    function updateAttr(el, immediateAttrs, animationAttrs, symbolMeta, isUpdate, cb) {
+      immediateAttrs && el.attr(immediateAttrs); // when symbolCip used, only clip path has init animation, otherwise it would be weird effect.
+
+      if (symbolMeta.symbolClip && !isUpdate) {
+        animationAttrs && el.attr(animationAttrs);
+      } else {
+        animationAttrs && graphic[isUpdate ? 'updateProps' : 'initProps'](el, animationAttrs, symbolMeta.animationModel, symbolMeta.dataIndex, cb);
+      }
+    }
+
+    function updateCommon$1(bar, opt, symbolMeta) {
+      var dataIndex = symbolMeta.dataIndex;
+      var itemModel = symbolMeta.itemModel; // Color must be excluded.
+      // Because symbol provide setColor individually to set fill and stroke
+
+      var emphasisModel = itemModel.getModel('emphasis');
+      var emphasisStyle = emphasisModel.getModel('itemStyle').getItemStyle();
+      var blurStyle = itemModel.getModel(['blur', 'itemStyle']).getItemStyle();
+      var selectStyle = itemModel.getModel(['select', 'itemStyle']).getItemStyle();
+      var cursorStyle = itemModel.getShallow('cursor');
+      var focus = emphasisModel.get('focus');
+      var blurScope = emphasisModel.get('blurScope');
+      var hoverScale = emphasisModel.get('scale');
+      eachPath(bar, function (path) {
+        if (path instanceof ZRImage) {
+          var pathStyle = path.style;
+          path.useStyle(extend({
+            // TODO other properties like dx, dy ?
+            image: pathStyle.image,
+            x: pathStyle.x,
+            y: pathStyle.y,
+            width: pathStyle.width,
+            height: pathStyle.height
+          }, symbolMeta.style));
+        } else {
+          path.useStyle(symbolMeta.style);
+        }
+
+        var emphasisState = path.ensureState('emphasis');
+        emphasisState.style = emphasisStyle;
+
+        if (hoverScale) {
+          // NOTE: Must after scale is set after updateAttr
+          emphasisState.scaleX = path.scaleX * 1.1;
+          emphasisState.scaleY = path.scaleY * 1.1;
+        }
+
+        path.ensureState('blur').style = blurStyle;
+        path.ensureState('select').style = selectStyle;
+        cursorStyle && (path.cursor = cursorStyle);
+        path.z2 = symbolMeta.z2;
+      });
+      var barPositionOutside = opt.valueDim.posDesc[+(symbolMeta.boundingLength > 0)];
+      var barRect = bar.__pictorialBarRect;
+      setLabelStyle(barRect, getLabelStatesModels(itemModel), {
+        labelFetcher: opt.seriesModel,
+        labelDataIndex: dataIndex,
+        defaultText: getDefaultLabel(opt.seriesModel.getData(), dataIndex),
+        inheritColor: symbolMeta.style.fill,
+        defaultOpacity: symbolMeta.style.opacity,
+        defaultOutsidePosition: barPositionOutside
+      });
+      enableHoverEmphasis(bar, focus, blurScope);
+    }
+
+    function toIntTimes(times) {
+      var roundedTimes = Math.round(times); // Escapse accurate error
+
+      return Math.abs(times - roundedTimes) < 1e-4 ? roundedTimes : Math.ceil(times);
+    }
+
+    var PictorialBarSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(PictorialBarSeriesModel, _super);
+
+      function PictorialBarSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PictorialBarSeriesModel.type;
+        _this.hasSymbolVisual = true;
+        _this.defaultSymbol = 'roundRect';
+        return _this;
+      }
+
+      PictorialBarSeriesModel.prototype.getInitialData = function (option) {
+        // Disable stack.
+        option.stack = null;
+        return _super.prototype.getInitialData.apply(this, arguments);
+      };
+
+      PictorialBarSeriesModel.type = 'series.pictorialBar';
+      PictorialBarSeriesModel.dependencies = ['grid'];
+      PictorialBarSeriesModel.defaultOption = inheritDefaultOption(BaseBarSeriesModel.defaultOption, {
+        symbol: 'circle',
+        symbolSize: null,
+        symbolRotate: null,
+        symbolPosition: null,
+        symbolOffset: null,
+        symbolMargin: null,
+        symbolRepeat: false,
+        symbolRepeatDirection: 'end',
+        symbolClip: false,
+        symbolBoundingData: null,
+        symbolPatternSize: 400,
+        barGap: '-100%',
+        // z can be set in data item, which is z2 actually.
+        // Disable progressive
+        progressive: 0,
+        emphasis: {
+          // By default pictorialBar do not hover scale. Hover scale is not suitable
+          // for the case that both has foreground and background.
+          scale: false
+        },
+        select: {
+          itemStyle: {
+            borderColor: '#212121'
+          }
+        }
+      });
+      return PictorialBarSeriesModel;
+    }(BaseBarSeriesModel);
+
+    function install$o(registers) {
+      registers.registerChartView(PictorialBarView);
+      registers.registerSeriesModel(PictorialBarSeriesModel);
+      registers.registerLayout(curry(layout, 'pictorialBar'));
+    }
+
+    var ThemeRiverView =
+    /** @class */
+    function (_super) {
+      __extends(ThemeRiverView, _super);
+
+      function ThemeRiverView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ThemeRiverView.type;
+        _this._layers = [];
+        return _this;
+      }
+
+      ThemeRiverView.prototype.render = function (seriesModel, ecModel, api) {
+        var data = seriesModel.getData();
+        var self = this;
+        var group = this.group;
+        var layersSeries = seriesModel.getLayerSeries();
+        var layoutInfo = data.getLayout('layoutInfo');
+        var rect = layoutInfo.rect;
+        var boundaryGap = layoutInfo.boundaryGap;
+        group.x = 0;
+        group.y = rect.y + boundaryGap[0];
+
+        function keyGetter(item) {
+          return item.name;
+        }
+
+        var dataDiffer = new DataDiffer(this._layersSeries || [], layersSeries, keyGetter, keyGetter);
+        var newLayersGroups = [];
+        dataDiffer.add(bind(process, this, 'add')).update(bind(process, this, 'update')).remove(bind(process, this, 'remove')).execute();
+
+        function process(status, idx, oldIdx) {
+          var oldLayersGroups = self._layers;
+
+          if (status === 'remove') {
+            group.remove(oldLayersGroups[idx]);
+            return;
+          }
+
+          var points0 = [];
+          var points1 = [];
+          var style;
+          var indices = layersSeries[idx].indices;
+          var j = 0;
+
+          for (; j < indices.length; j++) {
+            var layout = data.getItemLayout(indices[j]);
+            var x = layout.x;
+            var y0 = layout.y0;
+            var y = layout.y;
+            points0.push(x, y0);
+            points1.push(x, y0 + y);
+            style = data.getItemVisual(indices[j], 'style');
+          }
+
+          var polygon;
+          var textLayout = data.getItemLayout(indices[0]);
+          var labelModel = seriesModel.getModel('label');
+          var margin = labelModel.get('margin');
+          var emphasisModel = seriesModel.getModel('emphasis');
+
+          if (status === 'add') {
+            var layerGroup = newLayersGroups[idx] = new Group();
+            polygon = new ECPolygon({
+              shape: {
+                points: points0,
+                stackedOnPoints: points1,
+                smooth: 0.4,
+                stackedOnSmooth: 0.4,
+                smoothConstraint: false
+              },
+              z2: 0
+            });
+            layerGroup.add(polygon);
+            group.add(layerGroup);
+
+            if (seriesModel.isAnimationEnabled()) {
+              polygon.setClipPath(createGridClipShape$2(polygon.getBoundingRect(), seriesModel, function () {
+                polygon.removeClipPath();
+              }));
+            }
+          } else {
+            var layerGroup = oldLayersGroups[oldIdx];
+            polygon = layerGroup.childAt(0);
+            group.add(layerGroup);
+            newLayersGroups[idx] = layerGroup;
+            updateProps(polygon, {
+              shape: {
+                points: points0,
+                stackedOnPoints: points1
+              }
+            }, seriesModel);
+          }
+
+          setLabelStyle(polygon, getLabelStatesModels(seriesModel), {
+            labelDataIndex: indices[j - 1],
+            defaultText: data.getName(indices[j - 1]),
+            inheritColor: style.fill
+          }, {
+            normal: {
+              verticalAlign: 'middle' // align: 'right'
+
+            }
+          });
+          polygon.setTextConfig({
+            position: null,
+            local: true
+          });
+          var labelEl = polygon.getTextContent(); // TODO More label position options.
+
+          if (labelEl) {
+            labelEl.x = textLayout.x - margin;
+            labelEl.y = textLayout.y0 + textLayout.y / 2;
+          }
+
+          polygon.useStyle(style);
+          data.setItemGraphicEl(idx, polygon);
+          setStatesStylesFromModel(polygon, seriesModel);
+          enableHoverEmphasis(polygon, emphasisModel.get('focus'), emphasisModel.get('blurScope'));
+        }
+
+        this._layersSeries = layersSeries;
+        this._layers = newLayersGroups;
+      };
+
+      ThemeRiverView.type = 'themeRiver';
+      return ThemeRiverView;
+    }(ChartView);
+
+    function createGridClipShape$2(rect, seriesModel, cb) {
+      var rectEl = new Rect({
+        shape: {
+          x: rect.x - 10,
+          y: rect.y - 10,
+          width: 0,
+          height: rect.height + 20
+        }
+      });
+      initProps(rectEl, {
+        shape: {
+          x: rect.x - 50,
+          width: rect.width + 100,
+          height: rect.height + 20
+        }
+      }, seriesModel, cb);
+      return rectEl;
+    }
+
+    var DATA_NAME_INDEX = 2;
+
+    var ThemeRiverSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(ThemeRiverSeriesModel, _super);
+
+      function ThemeRiverSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ThemeRiverSeriesModel.type;
+        _this.useColorPaletteOnData = true;
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      ThemeRiverSeriesModel.prototype.init = function (option) {
+        // eslint-disable-next-line
+        _super.prototype.init.apply(this, arguments); // Put this function here is for the sake of consistency of code style.
+        // Enable legend selection for each data item
+        // Use a function instead of direct access because data reference may changed
+
+
+        this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this));
+      };
+      /**
+       * If there is no value of a certain point in the time for some event,set it value to 0.
+       *
+       * @param {Array} data  initial data in the option
+       * @return {Array}
+       */
+
+
+      ThemeRiverSeriesModel.prototype.fixData = function (data) {
+        var rawDataLength = data.length;
+        /**
+         * Make sure every layer data get the same keys.
+         * The value index tells which layer has visited.
+         * {
+         *  2014/01/01: -1
+         * }
+         */
+
+        var timeValueKeys = {}; // grouped data by name
+
+        var groupResult = groupData(data, function (item) {
+          if (!timeValueKeys.hasOwnProperty(item[0] + '')) {
+            timeValueKeys[item[0] + ''] = -1;
+          }
+
+          return item[2];
+        });
+        var layerData = [];
+        groupResult.buckets.each(function (items, key) {
+          layerData.push({
+            name: key,
+            dataList: items
+          });
+        });
+        var layerNum = layerData.length;
+
+        for (var k = 0; k < layerNum; ++k) {
+          var name_1 = layerData[k].name;
+
+          for (var j = 0; j < layerData[k].dataList.length; ++j) {
+            var timeValue = layerData[k].dataList[j][0] + '';
+            timeValueKeys[timeValue] = k;
+          }
+
+          for (var timeValue in timeValueKeys) {
+            if (timeValueKeys.hasOwnProperty(timeValue) && timeValueKeys[timeValue] !== k) {
+              timeValueKeys[timeValue] = k;
+              data[rawDataLength] = [timeValue, 0, name_1];
+              rawDataLength++;
+            }
+          }
+        }
+
+        return data;
+      };
+      /**
+       * @override
+       * @param  option  the initial option that user gived
+       * @param  ecModel  the model object for themeRiver option
+       */
+
+
+      ThemeRiverSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        var singleAxisModel = this.getReferringComponents('singleAxis', SINGLE_REFERRING).models[0];
+        var axisType = singleAxisModel.get('type'); // filter the data item with the value of label is undefined
+
+        var filterData = filter(option.data, function (dataItem) {
+          return dataItem[2] !== undefined;
+        }); // ??? TODO design a stage to transfer data for themeRiver and lines?
+
+        var data = this.fixData(filterData || []);
+        var nameList = [];
+        var nameMap = this.nameMap = createHashMap();
+        var count = 0;
+
+        for (var i = 0; i < data.length; ++i) {
+          nameList.push(data[i][DATA_NAME_INDEX]);
+
+          if (!nameMap.get(data[i][DATA_NAME_INDEX])) {
+            nameMap.set(data[i][DATA_NAME_INDEX], count);
+            count++;
+          }
+        }
+
+        var dimensionsInfo = createDimensions(data, {
+          coordDimensions: ['single'],
+          dimensionsDefine: [{
+            name: 'time',
+            type: getDimensionTypeByAxis(axisType)
+          }, {
+            name: 'value',
+            type: 'float'
+          }, {
+            name: 'name',
+            type: 'ordinal'
+          }],
+          encodeDefine: {
+            single: 0,
+            value: 1,
+            itemName: 2
+          }
+        });
+        var list = new List(dimensionsInfo, this);
+        list.initData(data);
+        return list;
+      };
+      /**
+       * The raw data is divided into multiple layers and each layer
+       *     has same name.
+       */
+
+
+      ThemeRiverSeriesModel.prototype.getLayerSeries = function () {
+        var data = this.getData();
+        var lenCount = data.count();
+        var indexArr = [];
+
+        for (var i = 0; i < lenCount; ++i) {
+          indexArr[i] = i;
+        }
+
+        var timeDim = data.mapDimension('single'); // data group by name
+
+        var groupResult = groupData(indexArr, function (index) {
+          return data.get('name', index);
+        });
+        var layerSeries = [];
+        groupResult.buckets.each(function (items, key) {
+          items.sort(function (index1, index2) {
+            return data.get(timeDim, index1) - data.get(timeDim, index2);
+          });
+          layerSeries.push({
+            name: key,
+            indices: items
+          });
+        });
+        return layerSeries;
+      };
+      /**
+       * Get data indices for show tooltip content
+       */
+
+
+      ThemeRiverSeriesModel.prototype.getAxisTooltipData = function (dim, value, baseAxis) {
+        if (!isArray(dim)) {
+          dim = dim ? [dim] : [];
+        }
+
+        var data = this.getData();
+        var layerSeries = this.getLayerSeries();
+        var indices = [];
+        var layerNum = layerSeries.length;
+        var nestestValue;
+
+        for (var i = 0; i < layerNum; ++i) {
+          var minDist = Number.MAX_VALUE;
+          var nearestIdx = -1;
+          var pointNum = layerSeries[i].indices.length;
+
+          for (var j = 0; j < pointNum; ++j) {
+            var theValue = data.get(dim[0], layerSeries[i].indices[j]);
+            var dist = Math.abs(theValue - value);
+
+            if (dist <= minDist) {
+              nestestValue = theValue;
+              minDist = dist;
+              nearestIdx = layerSeries[i].indices[j];
+            }
+          }
+
+          indices.push(nearestIdx);
+        }
+
+        return {
+          dataIndices: indices,
+          nestestValue: nestestValue
+        };
+      };
+
+      ThemeRiverSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var data = this.getData();
+        var name = data.getName(dataIndex);
+        var value = data.get(data.mapDimension('value'), dataIndex);
+        return createTooltipMarkup('nameValue', {
+          name: name,
+          value: value
+        });
+      };
+
+      ThemeRiverSeriesModel.type = 'series.themeRiver';
+      ThemeRiverSeriesModel.dependencies = ['singleAxis'];
+      ThemeRiverSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        coordinateSystem: 'singleAxis',
+        // gap in axis's orthogonal orientation
+        boundaryGap: ['10%', '10%'],
+        // legendHoverLink: true,
+        singleAxisIndex: 0,
+        animationEasing: 'linear',
+        label: {
+          margin: 4,
+          show: true,
+          position: 'left',
+          fontSize: 11
+        },
+        emphasis: {
+          label: {
+            show: true
+          }
+        }
+      };
+      return ThemeRiverSeriesModel;
+    }(SeriesModel);
+
+    function themeRiverLayout(ecModel, api) {
+      ecModel.eachSeriesByType('themeRiver', function (seriesModel) {
+        var data = seriesModel.getData();
+        var single = seriesModel.coordinateSystem;
+        var layoutInfo = {}; // use the axis boundingRect for view
+
+        var rect = single.getRect();
+        layoutInfo.rect = rect;
+        var boundaryGap = seriesModel.get('boundaryGap');
+        var axis = single.getAxis();
+        layoutInfo.boundaryGap = boundaryGap;
+
+        if (axis.orient === 'horizontal') {
+          boundaryGap[0] = parsePercent$1(boundaryGap[0], rect.height);
+          boundaryGap[1] = parsePercent$1(boundaryGap[1], rect.height);
+          var height = rect.height - boundaryGap[0] - boundaryGap[1];
+          doThemeRiverLayout(data, seriesModel, height);
+        } else {
+          boundaryGap[0] = parsePercent$1(boundaryGap[0], rect.width);
+          boundaryGap[1] = parsePercent$1(boundaryGap[1], rect.width);
+          var width = rect.width - boundaryGap[0] - boundaryGap[1];
+          doThemeRiverLayout(data, seriesModel, width);
+        }
+
+        data.setLayout('layoutInfo', layoutInfo);
+      });
+    }
+    /**
+     * The layout information about themeriver
+     *
+     * @param data  data in the series
+     * @param seriesModel  the model object of themeRiver series
+     * @param height  value used to compute every series height
+     */
+
+    function doThemeRiverLayout(data, seriesModel, height) {
+      if (!data.count()) {
+        return;
+      }
+
+      var coordSys = seriesModel.coordinateSystem; // the data in each layer are organized into a series.
+
+      var layerSeries = seriesModel.getLayerSeries(); // the points in each layer.
+
+      var timeDim = data.mapDimension('single');
+      var valueDim = data.mapDimension('value');
+      var layerPoints = map(layerSeries, function (singleLayer) {
+        return map(singleLayer.indices, function (idx) {
+          var pt = coordSys.dataToPoint(data.get(timeDim, idx));
+          pt[1] = data.get(valueDim, idx);
+          return pt;
+        });
+      });
+      var base = computeBaseline(layerPoints);
+      var baseLine = base.y0;
+      var ky = height / base.max; // set layout information for each item.
+
+      var n = layerSeries.length;
+      var m = layerSeries[0].indices.length;
+      var baseY0;
+
+      for (var j = 0; j < m; ++j) {
+        baseY0 = baseLine[j] * ky;
+        data.setItemLayout(layerSeries[0].indices[j], {
+          layerIndex: 0,
+          x: layerPoints[0][j][0],
+          y0: baseY0,
+          y: layerPoints[0][j][1] * ky
+        });
+
+        for (var i = 1; i < n; ++i) {
+          baseY0 += layerPoints[i - 1][j][1] * ky;
+          data.setItemLayout(layerSeries[i].indices[j], {
+            layerIndex: i,
+            x: layerPoints[i][j][0],
+            y0: baseY0,
+            y: layerPoints[i][j][1] * ky
+          });
+        }
+      }
+    }
+    /**
+     * Compute the baseLine of the rawdata
+     * Inspired by Lee Byron's paper Stacked Graphs - Geometry & Aesthetics
+     *
+     * @param  data  the points in each layer
+     */
+
+
+    function computeBaseline(data) {
+      var layerNum = data.length;
+      var pointNum = data[0].length;
+      var sums = [];
+      var y0 = [];
+      var max = 0;
+
+      for (var i = 0; i < pointNum; ++i) {
+        var temp = 0;
+
+        for (var j = 0; j < layerNum; ++j) {
+          temp += data[j][i][1];
+        }
+
+        if (temp > max) {
+          max = temp;
+        }
+
+        sums.push(temp);
+      }
+
+      for (var k = 0; k < pointNum; ++k) {
+        y0[k] = (max - sums[k]) / 2;
+      }
+
+      max = 0;
+
+      for (var l = 0; l < pointNum; ++l) {
+        var sum = sums[l] + y0[l];
+
+        if (sum > max) {
+          max = sum;
+        }
+      }
+
+      return {
+        y0: y0,
+        max: max
+      };
+    }
+
+    function install$p(registers) {
+      registers.registerChartView(ThemeRiverView);
+      registers.registerSeriesModel(ThemeRiverSeriesModel);
+      registers.registerLayout(themeRiverLayout);
+      registers.registerProcessor(dataFilter('themeRiver'));
+    }
+
+    var DEFAULT_SECTOR_Z = 2;
+    var DEFAULT_TEXT_Z = 4;
+    /**
+     * Sunburstce of Sunburst including Sector, Label, LabelLine
+     */
+
+    var SunburstPiece =
+    /** @class */
+    function (_super) {
+      __extends(SunburstPiece, _super);
+
+      function SunburstPiece(node, seriesModel, ecModel, api) {
+        var _this = _super.call(this) || this;
+
+        _this.z2 = DEFAULT_SECTOR_Z;
+        _this.textConfig = {
+          inside: true
+        };
+        getECData(_this).seriesIndex = seriesModel.seriesIndex;
+        var text = new ZRText({
+          z2: DEFAULT_TEXT_Z,
+          silent: node.getModel().get(['label', 'silent'])
+        });
+
+        _this.setTextContent(text);
+
+        _this.updateData(true, node, seriesModel, ecModel, api);
+
+        return _this;
+      }
+
+      SunburstPiece.prototype.updateData = function (firstCreate, node, // state: 'emphasis' | 'normal' | 'highlight' | 'downplay',
+      seriesModel, ecModel, api) {
+        this.node = node;
+        node.piece = this;
+        seriesModel = seriesModel || this._seriesModel;
+        ecModel = ecModel || this._ecModel;
+        var sector = this;
+        getECData(sector).dataIndex = node.dataIndex;
+        var itemModel = node.getModel();
+        var emphasisModel = itemModel.getModel('emphasis');
+        var layout = node.getLayout();
+        var sectorShape = extend({}, layout);
+        sectorShape.label = null;
+        var normalStyle = node.getVisual('style');
+        normalStyle.lineJoin = 'bevel';
+        var decal = node.getVisual('decal');
+
+        if (decal) {
+          normalStyle.decal = createOrUpdatePatternFromDecal(decal, api);
+        }
+
+        var cornerRadius = getSectorCornerRadius(itemModel.getModel('itemStyle'), sectorShape);
+        extend(sectorShape, cornerRadius);
+        each(SPECIAL_STATES, function (stateName) {
+          var state = sector.ensureState(stateName);
+          var itemStyleModel = itemModel.getModel([stateName, 'itemStyle']);
+          state.style = itemStyleModel.getItemStyle(); // border radius
+
+          var cornerRadius = getSectorCornerRadius(itemStyleModel, sectorShape);
+
+          if (cornerRadius) {
+            state.shape = cornerRadius;
+          }
+        });
+
+        if (firstCreate) {
+          sector.setShape(sectorShape);
+          sector.shape.r = layout.r0;
+          updateProps(sector, {
+            shape: {
+              r: layout.r
+            }
+          }, seriesModel, node.dataIndex);
+        } else {
+          // Disable animation for gradient since no interpolation method
+          // is supported for gradient
+          updateProps(sector, {
+            shape: sectorShape
+          }, seriesModel);
+        }
+
+        sector.useStyle(normalStyle);
+
+        this._updateLabel(seriesModel);
+
+        var cursorStyle = itemModel.getShallow('cursor');
+        cursorStyle && sector.attr('cursor', cursorStyle);
+        this._seriesModel = seriesModel || this._seriesModel;
+        this._ecModel = ecModel || this._ecModel;
+        var focus = emphasisModel.get('focus');
+        var focusDataIndices = focus === 'ancestor' ? node.getAncestorsIndices() : focus === 'descendant' ? node.getDescendantIndices() : null;
+        enableHoverEmphasis(this, focusDataIndices || focus, emphasisModel.get('blurScope'));
+      };
+
+      SunburstPiece.prototype._updateLabel = function (seriesModel) {
+        var _this = this;
+
+        var itemModel = this.node.getModel();
+        var normalLabelModel = itemModel.getModel('label');
+        var layout = this.node.getLayout();
+        var angle = layout.endAngle - layout.startAngle;
+        var midAngle = (layout.startAngle + layout.endAngle) / 2;
+        var dx = Math.cos(midAngle);
+        var dy = Math.sin(midAngle);
+        var sector = this;
+        var label = sector.getTextContent();
+        var dataIndex = this.node.dataIndex;
+        var labelMinAngle = normalLabelModel.get('minAngle') / 180 * Math.PI;
+        var isNormalShown = normalLabelModel.get('show') && !(labelMinAngle != null && Math.abs(angle) < labelMinAngle);
+        label.ignore = !isNormalShown; // TODO use setLabelStyle
+
+        each(DISPLAY_STATES, function (stateName) {
+          var labelStateModel = stateName === 'normal' ? itemModel.getModel('label') : itemModel.getModel([stateName, 'label']);
+          var isNormal = stateName === 'normal';
+          var state = isNormal ? label : label.ensureState(stateName);
+          var text = seriesModel.getFormattedLabel(dataIndex, stateName);
+
+          if (isNormal) {
+            text = text || _this.node.name;
+          }
+
+          state.style = createTextStyle(labelStateModel, {}, null, stateName !== 'normal', true);
+
+          if (text) {
+            state.style.text = text;
+          } // Not displaying text when angle is too small
+
+
+          var isShown = labelStateModel.get('show');
+
+          if (isShown != null && !isNormal) {
+            state.ignore = !isShown;
+          }
+
+          var labelPosition = getLabelAttr(labelStateModel, 'position');
+          var sectorState = isNormal ? sector : sector.states[stateName];
+          var labelColor = sectorState.style.fill;
+          sectorState.textConfig = {
+            outsideFill: labelStateModel.get('color') === 'inherit' ? labelColor : null,
+            inside: labelPosition !== 'outside'
+          };
+          var r;
+          var labelPadding = getLabelAttr(labelStateModel, 'distance') || 0;
+          var textAlign = getLabelAttr(labelStateModel, 'align');
+
+          if (labelPosition === 'outside') {
+            r = layout.r + labelPadding;
+            textAlign = midAngle > Math.PI / 2 ? 'right' : 'left';
+          } else {
+            if (!textAlign || textAlign === 'center') {
+              r = (layout.r + layout.r0) / 2;
+              textAlign = 'center';
+            } else if (textAlign === 'left') {
+              r = layout.r0 + labelPadding;
+
+              if (midAngle > Math.PI / 2) {
+                textAlign = 'right';
+              }
+            } else if (textAlign === 'right') {
+              r = layout.r - labelPadding;
+
+              if (midAngle > Math.PI / 2) {
+                textAlign = 'left';
+              }
+            }
+          }
+
+          state.style.align = textAlign;
+          state.style.verticalAlign = getLabelAttr(labelStateModel, 'verticalAlign') || 'middle';
+          state.x = r * dx + layout.cx;
+          state.y = r * dy + layout.cy;
+          var rotateType = getLabelAttr(labelStateModel, 'rotate');
+          var rotate = 0;
+
+          if (rotateType === 'radial') {
+            rotate = -midAngle;
+
+            if (rotate < -Math.PI / 2) {
+              rotate += Math.PI;
+            }
+          } else if (rotateType === 'tangential') {
+            rotate = Math.PI / 2 - midAngle;
+
+            if (rotate > Math.PI / 2) {
+              rotate -= Math.PI;
+            } else if (rotate < -Math.PI / 2) {
+              rotate += Math.PI;
+            }
+          } else if (typeof rotateType === 'number') {
+            rotate = rotateType * Math.PI / 180;
+          }
+
+          state.rotation = rotate;
+        });
+
+        function getLabelAttr(model, name) {
+          var stateAttr = model.get(name);
+
+          if (stateAttr == null) {
+            return normalLabelModel.get(name);
+          }
+
+          return stateAttr;
+        }
+
+        label.dirtyStyle();
+      };
+
+      return SunburstPiece;
+    }(Sector);
+
+    var ROOT_TO_NODE_ACTION = 'sunburstRootToNode';
+    var HIGHLIGHT_ACTION = 'sunburstHighlight';
+    var UNHIGHLIGHT_ACTION = 'sunburstUnhighlight';
+    function installSunburstAction(registers) {
+      registers.registerAction({
+        type: ROOT_TO_NODE_ACTION,
+        update: 'updateView'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'sunburst',
+          query: payload
+        }, handleRootToNode);
+
+        function handleRootToNode(model, index) {
+          var targetInfo = retrieveTargetInfo(payload, [ROOT_TO_NODE_ACTION], model);
+
+          if (targetInfo) {
+            var originViewRoot = model.getViewRoot();
+
+            if (originViewRoot) {
+              payload.direction = aboveViewRoot(originViewRoot, targetInfo.node) ? 'rollUp' : 'drillDown';
+            }
+
+            model.resetViewRoot(targetInfo.node);
+          }
+        }
+      });
+      registers.registerAction({
+        type: HIGHLIGHT_ACTION,
+        update: 'none'
+      }, function (payload, ecModel, api) {
+        // Clone
+        payload = extend({}, payload);
+        ecModel.eachComponent({
+          mainType: 'series',
+          subType: 'sunburst',
+          query: payload
+        }, handleHighlight);
+
+        function handleHighlight(model) {
+          var targetInfo = retrieveTargetInfo(payload, [HIGHLIGHT_ACTION], model);
+
+          if (targetInfo) {
+            payload.dataIndex = targetInfo.node.dataIndex;
+          }
+        }
+
+        if ("development" !== 'production') {
+          deprecateReplaceLog('highlight', 'sunburstHighlight');
+        } // Fast forward action
+
+
+        api.dispatchAction(extend(payload, {
+          type: 'highlight'
+        }));
+      });
+      registers.registerAction({
+        type: UNHIGHLIGHT_ACTION,
+        update: 'updateView'
+      }, function (payload, ecModel, api) {
+        payload = extend({}, payload);
+
+        if ("development" !== 'production') {
+          deprecateReplaceLog('downplay', 'sunburstUnhighlight');
+        }
+
+        api.dispatchAction(extend(payload, {
+          type: 'downplay'
+        }));
+      });
+    }
+
+    var SunburstView =
+    /** @class */
+    function (_super) {
+      __extends(SunburstView, _super);
+
+      function SunburstView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SunburstView.type;
+        return _this;
+      }
+
+      SunburstView.prototype.render = function (seriesModel, ecModel, api, // @ts-ignore
+      payload) {
+        var self = this;
+        this.seriesModel = seriesModel;
+        this.api = api;
+        this.ecModel = ecModel;
+        var data = seriesModel.getData();
+        var virtualRoot = data.tree.root;
+        var newRoot = seriesModel.getViewRoot();
+        var group = this.group;
+        var renderLabelForZeroData = seriesModel.get('renderLabelForZeroData');
+        var newChildren = [];
+        newRoot.eachNode(function (node) {
+          newChildren.push(node);
+        });
+        var oldChildren = this._oldChildren || [];
+        dualTravel(newChildren, oldChildren);
+        renderRollUp(virtualRoot, newRoot);
+
+        this._initEvents();
+
+        this._oldChildren = newChildren;
+
+        function dualTravel(newChildren, oldChildren) {
+          if (newChildren.length === 0 && oldChildren.length === 0) {
+            return;
+          }
+
+          new DataDiffer(oldChildren, newChildren, getKey, getKey).add(processNode).update(processNode).remove(curry(processNode, null)).execute();
+
+          function getKey(node) {
+            return node.getId();
+          }
+
+          function processNode(newIdx, oldIdx) {
+            var newNode = newIdx == null ? null : newChildren[newIdx];
+            var oldNode = oldIdx == null ? null : oldChildren[oldIdx];
+            doRenderNode(newNode, oldNode);
+          }
+        }
+
+        function doRenderNode(newNode, oldNode) {
+          if (!renderLabelForZeroData && newNode && !newNode.getValue()) {
+            // Not render data with value 0
+            newNode = null;
+          }
+
+          if (newNode !== virtualRoot && oldNode !== virtualRoot) {
+            if (oldNode && oldNode.piece) {
+              if (newNode) {
+                // Update
+                oldNode.piece.updateData(false, newNode, seriesModel, ecModel, api); // For tooltip
+
+                data.setItemGraphicEl(newNode.dataIndex, oldNode.piece);
+              } else {
+                // Remove
+                removeNode(oldNode);
+              }
+            } else if (newNode) {
+              // Add
+              var piece = new SunburstPiece(newNode, seriesModel, ecModel, api);
+              group.add(piece); // For tooltip
+
+              data.setItemGraphicEl(newNode.dataIndex, piece);
+            }
+          }
+        }
+
+        function removeNode(node) {
+          if (!node) {
+            return;
+          }
+
+          if (node.piece) {
+            group.remove(node.piece);
+            node.piece = null;
+          }
+        }
+
+        function renderRollUp(virtualRoot, viewRoot) {
+          if (viewRoot.depth > 0) {
+            // Render
+            if (self.virtualPiece) {
+              // Update
+              self.virtualPiece.updateData(false, virtualRoot, seriesModel, ecModel, api);
+            } else {
+              // Add
+              self.virtualPiece = new SunburstPiece(virtualRoot, seriesModel, ecModel, api);
+              group.add(self.virtualPiece);
+            } // TODO event scope
+
+
+            viewRoot.piece.off('click');
+            self.virtualPiece.on('click', function (e) {
+              self._rootToNode(viewRoot.parentNode);
+            });
+          } else if (self.virtualPiece) {
+            // Remove
+            group.remove(self.virtualPiece);
+            self.virtualPiece = null;
+          }
+        }
+      };
+      /**
+       * @private
+       */
+
+
+      SunburstView.prototype._initEvents = function () {
+        var _this = this;
+
+        this.group.off('click');
+        this.group.on('click', function (e) {
+          var targetFound = false;
+
+          var viewRoot = _this.seriesModel.getViewRoot();
+
+          viewRoot.eachNode(function (node) {
+            if (!targetFound && node.piece && node.piece === e.target) {
+              var nodeClick = node.getModel().get('nodeClick');
+
+              if (nodeClick === 'rootToNode') {
+                _this._rootToNode(node);
+              } else if (nodeClick === 'link') {
+                var itemModel = node.getModel();
+                var link = itemModel.get('link');
+
+                if (link) {
+                  var linkTarget = itemModel.get('target', true) || '_blank';
+                  windowOpen(link, linkTarget);
+                }
+              }
+
+              targetFound = true;
+            }
+          });
+        });
+      };
+      /**
+       * @private
+       */
+
+
+      SunburstView.prototype._rootToNode = function (node) {
+        if (node !== this.seriesModel.getViewRoot()) {
+          this.api.dispatchAction({
+            type: ROOT_TO_NODE_ACTION,
+            from: this.uid,
+            seriesId: this.seriesModel.id,
+            targetNode: node
+          });
+        }
+      };
+      /**
+       * @implement
+       */
+
+
+      SunburstView.prototype.containPoint = function (point, seriesModel) {
+        var treeRoot = seriesModel.getData();
+        var itemLayout = treeRoot.getItemLayout(0);
+
+        if (itemLayout) {
+          var dx = point[0] - itemLayout.cx;
+          var dy = point[1] - itemLayout.cy;
+          var radius = Math.sqrt(dx * dx + dy * dy);
+          return radius <= itemLayout.r && radius >= itemLayout.r0;
+        }
+      };
+
+      SunburstView.type = 'sunburst';
+      return SunburstView;
+    }(ChartView);
+
+    var SunburstSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(SunburstSeriesModel, _super);
+
+      function SunburstSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SunburstSeriesModel.type;
+        _this.ignoreStyleOnData = true;
+        return _this;
+      }
+
+      SunburstSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        // Create a virtual root.
+        var root = {
+          name: option.name,
+          children: option.data
+        };
+        completeTreeValue$1(root);
+        var levelModels = map(option.levels || [], function (levelDefine) {
+          return new Model(levelDefine, this, ecModel);
+        }, this); // Make sure always a new tree is created when setOption,
+        // in TreemapView, we check whether oldTree === newTree
+        // to choose mappings approach among old shapes and new shapes.
+
+        var tree = Tree.createTree(root, this, beforeLink);
+
+        function beforeLink(nodeData) {
+          nodeData.wrapMethod('getItemModel', function (model, idx) {
+            var node = tree.getNodeByDataIndex(idx);
+            var levelModel = levelModels[node.depth];
+            levelModel && (model.parentModel = levelModel);
+            return model;
+          });
+        }
+
+        return tree.data;
+      };
+
+      SunburstSeriesModel.prototype.optionUpdated = function () {
+        this.resetViewRoot();
+      };
+      /*
+       * @override
+       */
+
+
+      SunburstSeriesModel.prototype.getDataParams = function (dataIndex) {
+        var params = _super.prototype.getDataParams.apply(this, arguments);
+
+        var node = this.getData().tree.getNodeByDataIndex(dataIndex);
+        params.treePathInfo = wrapTreePathInfo(node, this);
+        return params;
+      };
+
+      SunburstSeriesModel.prototype.getViewRoot = function () {
+        return this._viewRoot;
+      };
+
+      SunburstSeriesModel.prototype.resetViewRoot = function (viewRoot) {
+        viewRoot ? this._viewRoot = viewRoot : viewRoot = this._viewRoot;
+        var root = this.getRawData().tree.root;
+
+        if (!viewRoot || viewRoot !== root && !root.contains(viewRoot)) {
+          this._viewRoot = root;
+        }
+      };
+
+      SunburstSeriesModel.prototype.enableAriaDecal = function () {
+        enableAriaDecalForTree(this);
+      };
+
+      SunburstSeriesModel.type = 'series.sunburst';
+      SunburstSeriesModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        // 默认全局居中
+        center: ['50%', '50%'],
+        radius: [0, '75%'],
+        // 默认顺时针
+        clockwise: true,
+        startAngle: 90,
+        // 最小角度改为0
+        minAngle: 0,
+        // If still show when all data zero.
+        stillShowZeroSum: true,
+        // 'rootToNode', 'link', or false
+        nodeClick: 'rootToNode',
+        renderLabelForZeroData: false,
+        label: {
+          // could be: 'radial', 'tangential', or 'none'
+          rotate: 'radial',
+          show: true,
+          opacity: 1,
+          // 'left' is for inner side of inside, and 'right' is for outter
+          // side for inside
+          align: 'center',
+          position: 'inside',
+          distance: 5,
+          silent: true
+        },
+        itemStyle: {
+          borderWidth: 1,
+          borderColor: 'white',
+          borderType: 'solid',
+          shadowBlur: 0,
+          shadowColor: 'rgba(0, 0, 0, 0.2)',
+          shadowOffsetX: 0,
+          shadowOffsetY: 0,
+          opacity: 1
+        },
+        emphasis: {
+          focus: 'descendant'
+        },
+        blur: {
+          itemStyle: {
+            opacity: 0.2
+          },
+          label: {
+            opacity: 0.1
+          }
+        },
+        // Animation type canbe expansion, scale
+        animationType: 'expansion',
+        animationDuration: 1000,
+        animationDurationUpdate: 500,
+        data: [],
+        levels: [],
+
+        /**
+         * Sort order.
+         *
+         * Valid values: 'desc', 'asc', null, or callback function.
+         * 'desc' and 'asc' for descend and ascendant order;
+         * null for not sorting;
+         * example of callback function:
+         * function(nodeA, nodeB) {
+         *     return nodeA.getValue() - nodeB.getValue();
+         * }
+         */
+        sort: 'desc'
+      };
+      return SunburstSeriesModel;
+    }(SeriesModel);
+
+    function completeTreeValue$1(dataNode) {
+      // Postorder travel tree.
+      // If value of none-leaf node is not set,
+      // calculate it by suming up the value of all children.
+      var sum = 0;
+      each(dataNode.children, function (child) {
+        completeTreeValue$1(child);
+        var childValue = child.value; // TODO First value of array must be a number
+
+        isArray(childValue) && (childValue = childValue[0]);
+        sum += childValue;
+      });
+      var thisValue = dataNode.value;
+
+      if (isArray(thisValue)) {
+        thisValue = thisValue[0];
+      }
+
+      if (thisValue == null || isNaN(thisValue)) {
+        thisValue = sum;
+      } // Value should not less than 0.
+
+
+      if (thisValue < 0) {
+        thisValue = 0;
+      }
+
+      isArray(dataNode.value) ? dataNode.value[0] = thisValue : dataNode.value = thisValue;
+    }
+
+    var RADIAN$2 = Math.PI / 180;
+    function sunburstLayout(seriesType, ecModel, api) {
+      ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+        var center = seriesModel.get('center');
+        var radius = seriesModel.get('radius');
+
+        if (!isArray(radius)) {
+          radius = [0, radius];
+        }
+
+        if (!isArray(center)) {
+          center = [center, center];
+        }
+
+        var width = api.getWidth();
+        var height = api.getHeight();
+        var size = Math.min(width, height);
+        var cx = parsePercent$1(center[0], width);
+        var cy = parsePercent$1(center[1], height);
+        var r0 = parsePercent$1(radius[0], size / 2);
+        var r = parsePercent$1(radius[1], size / 2);
+        var startAngle = -seriesModel.get('startAngle') * RADIAN$2;
+        var minAngle = seriesModel.get('minAngle') * RADIAN$2;
+        var virtualRoot = seriesModel.getData().tree.root;
+        var treeRoot = seriesModel.getViewRoot();
+        var rootDepth = treeRoot.depth;
+        var sort = seriesModel.get('sort');
+
+        if (sort != null) {
+          initChildren$1(treeRoot, sort);
+        }
+
+        var validDataCount = 0;
+        each(treeRoot.children, function (child) {
+          !isNaN(child.getValue()) && validDataCount++;
+        });
+        var sum = treeRoot.getValue(); // Sum may be 0
+
+        var unitRadian = Math.PI / (sum || validDataCount) * 2;
+        var renderRollupNode = treeRoot.depth > 0;
+        var levels = treeRoot.height - (renderRollupNode ? -1 : 1);
+        var rPerLevel = (r - r0) / (levels || 1);
+        var clockwise = seriesModel.get('clockwise');
+        var stillShowZeroSum = seriesModel.get('stillShowZeroSum'); // In the case some sector angle is smaller than minAngle
+        // let restAngle = PI2;
+        // let valueSumLargerThanMinAngle = 0;
+
+        var dir = clockwise ? 1 : -1;
+        /**
+         * Render a tree
+         * @return increased angle
+         */
+
+        var renderNode = function (node, startAngle) {
+          if (!node) {
+            return;
+          }
+
+          var endAngle = startAngle; // Render self
+
+          if (node !== virtualRoot) {
+            // Tree node is virtual, so it doesn't need to be drawn
+            var value = node.getValue();
+            var angle = sum === 0 && stillShowZeroSum ? unitRadian : value * unitRadian;
+
+            if (angle < minAngle) {
+              angle = minAngle; // restAngle -= minAngle;
+            } // else {
+            //     valueSumLargerThanMinAngle += value;
+            // }
+
+
+            endAngle = startAngle + dir * angle;
+            var depth = node.depth - rootDepth - (renderRollupNode ? -1 : 1);
+            var rStart = r0 + rPerLevel * depth;
+            var rEnd = r0 + rPerLevel * (depth + 1);
+            var itemModel = node.getModel(); // @ts-ignore. TODO this is not provided to developer yet. Rename it.
+
+            if (itemModel.get('r0') != null) {
+              // @ts-ignore
+              rStart = parsePercent$1(itemModel.get('r0'), size / 2);
+            } // @ts-ignore
+
+
+            if (itemModel.get('r') != null) {
+              // @ts-ignore
+              rEnd = parsePercent$1(itemModel.get('r'), size / 2);
+            }
+
+            node.setLayout({
+              angle: angle,
+              startAngle: startAngle,
+              endAngle: endAngle,
+              clockwise: clockwise,
+              cx: cx,
+              cy: cy,
+              r0: rStart,
+              r: rEnd
+            });
+          } // Render children
+
+
+          if (node.children && node.children.length) {
+            // currentAngle = startAngle;
+            var siblingAngle_1 = 0;
+            each(node.children, function (node) {
+              siblingAngle_1 += renderNode(node, startAngle + siblingAngle_1);
+            });
+          }
+
+          return endAngle - startAngle;
+        }; // Virtual root node for roll up
+
+
+        if (renderRollupNode) {
+          var rStart = r0;
+          var rEnd = r0 + rPerLevel;
+          var angle = Math.PI * 2;
+          virtualRoot.setLayout({
+            angle: angle,
+            startAngle: startAngle,
+            endAngle: startAngle + angle,
+            clockwise: clockwise,
+            cx: cx,
+            cy: cy,
+            r0: rStart,
+            r: rEnd
+          });
+        }
+
+        renderNode(treeRoot, startAngle);
+      });
+    }
+    /**
+     * Init node children by order and update visual
+     */
+
+    function initChildren$1(node, sortOrder) {
+      var children = node.children || [];
+      node.children = sort$2(children, sortOrder); // Init children recursively
+
+      if (children.length) {
+        each(node.children, function (child) {
+          initChildren$1(child, sortOrder);
+        });
+      }
+    }
+    /**
+     * Sort children nodes
+     *
+     * @param {TreeNode[]}               children children of node to be sorted
+     * @param {string | function | null} sort sort method
+     *                                   See SunburstSeries.js for details.
+     */
+
+
+    function sort$2(children, sortOrder) {
+      if (typeof sortOrder === 'function') {
+        var sortTargets = map(children, function (child, idx) {
+          var value = child.getValue();
+          return {
+            params: {
+              depth: child.depth,
+              height: child.height,
+              dataIndex: child.dataIndex,
+              getValue: function () {
+                return value;
+              }
+            },
+            index: idx
+          };
+        });
+        sortTargets.sort(function (a, b) {
+          return sortOrder(a.params, b.params);
+        });
+        return map(sortTargets, function (target) {
+          return children[target.index];
+        });
+      } else {
+        var isAsc_1 = sortOrder === 'asc';
+        return children.sort(function (a, b) {
+          var diff = (a.getValue() - b.getValue()) * (isAsc_1 ? 1 : -1);
+          return diff === 0 ? (a.dataIndex - b.dataIndex) * (isAsc_1 ? -1 : 1) : diff;
+        });
+      }
+    }
+
+    function sunburstVisual(ecModel) {
+      var paletteScope = {}; // Default color strategy
+
+      function pickColor(node, seriesModel, treeHeight) {
+        // Choose color from palette based on the first level.
+        var current = node;
+
+        while (current && current.depth > 1) {
+          current = current.parentNode;
+        }
+
+        var color = seriesModel.getColorFromPalette(current.name || current.dataIndex + '', paletteScope);
+
+        if (node.depth > 1 && typeof color === 'string') {
+          // Lighter on the deeper level.
+          color = lift(color, (node.depth - 1) / (treeHeight - 1) * 0.5);
+        }
+
+        return color;
+      }
+
+      ecModel.eachSeriesByType('sunburst', function (seriesModel) {
+        var data = seriesModel.getData();
+        var tree = data.tree;
+        tree.eachNode(function (node) {
+          var model = node.getModel();
+          var style = model.getModel('itemStyle').getItemStyle();
+
+          if (!style.fill) {
+            style.fill = pickColor(node, seriesModel, tree.root.height);
+          }
+
+          var existsStyle = data.ensureUniqueItemVisual(node.dataIndex, 'style');
+          extend(existsStyle, style);
+        });
+      });
+    }
+
+    function install$q(registers) {
+      registers.registerChartView(SunburstView);
+      registers.registerSeriesModel(SunburstSeriesModel);
+      registers.registerLayout(curry(sunburstLayout, 'sunburst'));
+      registers.registerProcessor(curry(dataFilter, 'sunburst'));
+      registers.registerVisual(sunburstVisual);
+      installSunburstAction(registers);
+    }
+
+    function dataToCoordSize(dataSize, dataItem) {
+      // dataItem is necessary in log axis.
+      dataItem = dataItem || [0, 0];
+      return map(['x', 'y'], function (dim, dimIdx) {
+        var axis = this.getAxis(dim);
+        var val = dataItem[dimIdx];
+        var halfSize = dataSize[dimIdx] / 2;
+        return axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+      }, this);
+    }
+
+    function cartesianPrepareCustom(coordSys) {
+      var rect = coordSys.master.getRect();
+      return {
+        coordSys: {
+          // The name exposed to user is always 'cartesian2d' but not 'grid'.
+          type: 'cartesian2d',
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        },
+        api: {
+          coord: function (data) {
+            // do not provide "out" param
+            return coordSys.dataToPoint(data);
+          },
+          size: bind(dataToCoordSize, coordSys)
+        }
+      };
+    }
+
+    function dataToCoordSize$1(dataSize, dataItem) {
+      dataItem = dataItem || [0, 0];
+      return map([0, 1], function (dimIdx) {
+        var val = dataItem[dimIdx];
+        var halfSize = dataSize[dimIdx] / 2;
+        var p1 = [];
+        var p2 = [];
+        p1[dimIdx] = val - halfSize;
+        p2[dimIdx] = val + halfSize;
+        p1[1 - dimIdx] = p2[1 - dimIdx] = dataItem[1 - dimIdx];
+        return Math.abs(this.dataToPoint(p1)[dimIdx] - this.dataToPoint(p2)[dimIdx]);
+      }, this);
+    }
+
+    function geoPrepareCustom(coordSys) {
+      var rect = coordSys.getBoundingRect();
+      return {
+        coordSys: {
+          type: 'geo',
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height,
+          zoom: coordSys.getZoom()
+        },
+        api: {
+          coord: function (data) {
+            // do not provide "out" and noRoam param,
+            // Compatible with this usage:
+            // echarts.util.map(item.points, api.coord)
+            return coordSys.dataToPoint(data);
+          },
+          size: bind(dataToCoordSize$1, coordSys)
+        }
+      };
+    }
+
+    function dataToCoordSize$2(dataSize, dataItem) {
+      // dataItem is necessary in log axis.
+      var axis = this.getAxis();
+      var val = dataItem instanceof Array ? dataItem[0] : dataItem;
+      var halfSize = (dataSize instanceof Array ? dataSize[0] : dataSize) / 2;
+      return axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+    }
+
+    function singlePrepareCustom(coordSys) {
+      var rect = coordSys.getRect();
+      return {
+        coordSys: {
+          type: 'singleAxis',
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        },
+        api: {
+          coord: function (val) {
+            // do not provide "out" param
+            return coordSys.dataToPoint(val);
+          },
+          size: bind(dataToCoordSize$2, coordSys)
+        }
+      };
+    }
+
+    function dataToCoordSize$3(dataSize, dataItem) {
+      // dataItem is necessary in log axis.
+      dataItem = dataItem || [0, 0];
+      return map(['Radius', 'Angle'], function (dim, dimIdx) {
+        var getterName = 'get' + dim + 'Axis'; // TODO: TYPE Check Angle Axis
+
+        var axis = this[getterName]();
+        var val = dataItem[dimIdx];
+        var halfSize = dataSize[dimIdx] / 2;
+        var result = axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+
+        if (dim === 'Angle') {
+          result = result * Math.PI / 180;
+        }
+
+        return result;
+      }, this);
+    }
+
+    function polarPrepareCustom(coordSys) {
+      var radiusAxis = coordSys.getRadiusAxis();
+      var angleAxis = coordSys.getAngleAxis();
+      var radius = radiusAxis.getExtent();
+      radius[0] > radius[1] && radius.reverse();
+      return {
+        coordSys: {
+          type: 'polar',
+          cx: coordSys.cx,
+          cy: coordSys.cy,
+          r: radius[1],
+          r0: radius[0]
+        },
+        api: {
+          coord: function (data) {
+            var radius = radiusAxis.dataToRadius(data[0]);
+            var angle = angleAxis.dataToAngle(data[1]);
+            var coord = coordSys.coordToPoint([radius, angle]);
+            coord.push(radius, angle * Math.PI / 180);
+            return coord;
+          },
+          size: bind(dataToCoordSize$3, coordSys)
+        }
+      };
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function calendarPrepareCustom(coordSys) {
+      var rect = coordSys.getRect();
+      var rangeInfo = coordSys.getRangeInfo();
+      return {
+        coordSys: {
+          type: 'calendar',
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height,
+          cellWidth: coordSys.getCellWidth(),
+          cellHeight: coordSys.getCellHeight(),
+          rangeInfo: {
+            start: rangeInfo.start,
+            end: rangeInfo.end,
+            weeks: rangeInfo.weeks,
+            dayCount: rangeInfo.allDay
+          }
+        },
+        api: {
+          coord: function (data, clamp) {
+            return coordSys.dataToPoint(data, clamp);
+          }
+        }
+      };
+    }
+
+    var deprecatedLogs = {};
+    /**
+     * Whether need to call `convertEC4CompatibleStyle`.
+     */
+
+    function isEC4CompatibleStyle(style, elType, hasOwnTextContentOption, hasOwnTextConfig) {
+      // Since echarts5, `RectText` is separated from its host element and style.text
+      // does not exist any more. The compat work brings some extra burden on performance.
+      // So we provide:
+      // `legacy: true` force make compat.
+      // `legacy: false`, force do not compat.
+      // `legacy` not set: auto detect wheter legacy.
+      //     But in this case we do not compat (difficult to detect and rare case):
+      //     Becuse custom series and graphic component support "merge", users may firstly
+      //     only set `textStrokeWidth` style or secondly only set `text`.
+      return style && (style.legacy || style.legacy !== false && !hasOwnTextContentOption && !hasOwnTextConfig && elType !== 'tspan' // Difficult to detect whether legacy for a "text" el.
+      && (elType === 'text' || hasOwn(style, 'text')));
+    }
+    /**
+     * `EC4CompatibleStyle` is style that might be in echarts4 format or echarts5 format.
+     * @param hostStyle The properties might be modified.
+     * @return If be text el, `textContentStyle` and `textConfig` will not be retured.
+     *         Otherwise a `textContentStyle` and `textConfig` will be created, whose props area
+     *         retried from the `hostStyle`.
+     */
+
+    function convertFromEC4CompatibleStyle(hostStyle, elType, isNormal) {
+      var srcStyle = hostStyle;
+      var textConfig;
+      var textContent;
+      var textContentStyle;
+
+      if (elType === 'text') {
+        textContentStyle = srcStyle;
+      } else {
+        textContentStyle = {};
+        hasOwn(srcStyle, 'text') && (textContentStyle.text = srcStyle.text);
+        hasOwn(srcStyle, 'rich') && (textContentStyle.rich = srcStyle.rich);
+        hasOwn(srcStyle, 'textFill') && (textContentStyle.fill = srcStyle.textFill);
+        hasOwn(srcStyle, 'textStroke') && (textContentStyle.stroke = srcStyle.textStroke);
+        textContent = {
+          type: 'text',
+          style: textContentStyle,
+          // ec4 do not support rectText trigger.
+          // And when text postion is different in normal and emphasis
+          // => hover text trigger emphasis;
+          // => text position changed, leave mouse pointer immediately;
+          // That might cause state incorrect.
+          silent: true
+        };
+        textConfig = {};
+        var hasOwnPos = hasOwn(srcStyle, 'textPosition');
+
+        if (isNormal) {
+          textConfig.position = hasOwnPos ? srcStyle.textPosition : 'inside';
+        } else {
+          hasOwnPos && (textConfig.position = srcStyle.textPosition);
+        }
+
+        hasOwn(srcStyle, 'textPosition') && (textConfig.position = srcStyle.textPosition);
+        hasOwn(srcStyle, 'textOffset') && (textConfig.offset = srcStyle.textOffset);
+        hasOwn(srcStyle, 'textRotation') && (textConfig.rotation = srcStyle.textRotation);
+        hasOwn(srcStyle, 'textDistance') && (textConfig.distance = srcStyle.textDistance);
+      }
+
+      convertEC4CompatibleRichItem(textContentStyle, hostStyle);
+      each(textContentStyle.rich, function (richItem) {
+        convertEC4CompatibleRichItem(richItem, richItem);
+      });
+      return {
+        textConfig: textConfig,
+        textContent: textContent
+      };
+    }
+    /**
+     * The result will be set to `out`.
+     */
+
+    function convertEC4CompatibleRichItem(out, richItem) {
+      if (!richItem) {
+        return;
+      } // (1) For simplicity, make textXXX properties (deprecated since ec5) has
+      // higher priority. For example, consider in ec4 `borderColor: 5, textBorderColor: 10`
+      // on a rect means `borderColor: 4` on the rect and `borderColor: 10` on an attached
+      // richText in ec5.
+      // (2) `out === richItem` if and only if `out` is text el or rich item.
+      // So we can overwite existing props in `out` since textXXX has higher priority.
+
+
+      richItem.font = richItem.textFont || richItem.font;
+      hasOwn(richItem, 'textStrokeWidth') && (out.lineWidth = richItem.textStrokeWidth);
+      hasOwn(richItem, 'textAlign') && (out.align = richItem.textAlign);
+      hasOwn(richItem, 'textVerticalAlign') && (out.verticalAlign = richItem.textVerticalAlign);
+      hasOwn(richItem, 'textLineHeight') && (out.lineHeight = richItem.textLineHeight);
+      hasOwn(richItem, 'textWidth') && (out.width = richItem.textWidth);
+      hasOwn(richItem, 'textHeight') && (out.height = richItem.textHeight);
+      hasOwn(richItem, 'textBackgroundColor') && (out.backgroundColor = richItem.textBackgroundColor);
+      hasOwn(richItem, 'textPadding') && (out.padding = richItem.textPadding);
+      hasOwn(richItem, 'textBorderColor') && (out.borderColor = richItem.textBorderColor);
+      hasOwn(richItem, 'textBorderWidth') && (out.borderWidth = richItem.textBorderWidth);
+      hasOwn(richItem, 'textBorderRadius') && (out.borderRadius = richItem.textBorderRadius);
+      hasOwn(richItem, 'textBoxShadowColor') && (out.shadowColor = richItem.textBoxShadowColor);
+      hasOwn(richItem, 'textBoxShadowBlur') && (out.shadowBlur = richItem.textBoxShadowBlur);
+      hasOwn(richItem, 'textBoxShadowOffsetX') && (out.shadowOffsetX = richItem.textBoxShadowOffsetX);
+      hasOwn(richItem, 'textBoxShadowOffsetY') && (out.shadowOffsetY = richItem.textBoxShadowOffsetY);
+    }
+    /**
+     * Convert to pure echarts4 format style.
+     * `itemStyle` will be modified, added with ec4 style properties from
+     * `textStyle` and `textConfig`.
+     *
+     * [Caveat]: For simplicity, `insideRollback` in ec4 does not compat, where
+     * `styleEmphasis: {textFill: 'red'}` will remove the normal auto added stroke.
+     */
+
+
+    function convertToEC4StyleForCustomSerise(itemStl, txStl, txCfg) {
+      var out = itemStl; // See `custom.ts`, a trick to set extra `textPosition` firstly.
+
+      out.textPosition = out.textPosition || txCfg.position || 'inside';
+      txCfg.offset != null && (out.textOffset = txCfg.offset);
+      txCfg.rotation != null && (out.textRotation = txCfg.rotation);
+      txCfg.distance != null && (out.textDistance = txCfg.distance);
+      var isInside = out.textPosition.indexOf('inside') >= 0;
+      var hostFill = itemStl.fill || '#000';
+      convertToEC4RichItem(out, txStl);
+      var textFillNotSet = out.textFill == null;
+
+      if (isInside) {
+        if (textFillNotSet) {
+          out.textFill = txCfg.insideFill || '#fff';
+          !out.textStroke && txCfg.insideStroke && (out.textStroke = txCfg.insideStroke);
+          !out.textStroke && (out.textStroke = hostFill);
+          out.textStrokeWidth == null && (out.textStrokeWidth = 2);
+        }
+      } else {
+        if (textFillNotSet) {
+          out.textFill = txCfg.outsideFill || hostFill;
+        }
+
+        !out.textStroke && txCfg.outsideStroke && (out.textStroke = txCfg.outsideStroke);
+      }
+
+      out.text = txStl.text;
+      out.rich = txStl.rich;
+      each(txStl.rich, function (richItem) {
+        convertToEC4RichItem(richItem, richItem);
+      });
+      return out;
+    }
+
+    function convertToEC4RichItem(out, richItem) {
+      if (!richItem) {
+        return;
+      }
+
+      hasOwn(richItem, 'fill') && (out.textFill = richItem.fill);
+      hasOwn(richItem, 'stroke') && (out.textStroke = richItem.fill);
+      hasOwn(richItem, 'lineWidth') && (out.textStrokeWidth = richItem.lineWidth);
+      hasOwn(richItem, 'font') && (out.font = richItem.font);
+      hasOwn(richItem, 'fontStyle') && (out.fontStyle = richItem.fontStyle);
+      hasOwn(richItem, 'fontWeight') && (out.fontWeight = richItem.fontWeight);
+      hasOwn(richItem, 'fontSize') && (out.fontSize = richItem.fontSize);
+      hasOwn(richItem, 'fontFamily') && (out.fontFamily = richItem.fontFamily);
+      hasOwn(richItem, 'align') && (out.textAlign = richItem.align);
+      hasOwn(richItem, 'verticalAlign') && (out.textVerticalAlign = richItem.verticalAlign);
+      hasOwn(richItem, 'lineHeight') && (out.textLineHeight = richItem.lineHeight);
+      hasOwn(richItem, 'width') && (out.textWidth = richItem.width);
+      hasOwn(richItem, 'height') && (out.textHeight = richItem.height);
+      hasOwn(richItem, 'backgroundColor') && (out.textBackgroundColor = richItem.backgroundColor);
+      hasOwn(richItem, 'padding') && (out.textPadding = richItem.padding);
+      hasOwn(richItem, 'borderColor') && (out.textBorderColor = richItem.borderColor);
+      hasOwn(richItem, 'borderWidth') && (out.textBorderWidth = richItem.borderWidth);
+      hasOwn(richItem, 'borderRadius') && (out.textBorderRadius = richItem.borderRadius);
+      hasOwn(richItem, 'shadowColor') && (out.textBoxShadowColor = richItem.shadowColor);
+      hasOwn(richItem, 'shadowBlur') && (out.textBoxShadowBlur = richItem.shadowBlur);
+      hasOwn(richItem, 'shadowOffsetX') && (out.textBoxShadowOffsetX = richItem.shadowOffsetX);
+      hasOwn(richItem, 'shadowOffsetY') && (out.textBoxShadowOffsetY = richItem.shadowOffsetY);
+      hasOwn(richItem, 'textShadowColor') && (out.textShadowColor = richItem.textShadowColor);
+      hasOwn(richItem, 'textShadowBlur') && (out.textShadowBlur = richItem.textShadowBlur);
+      hasOwn(richItem, 'textShadowOffsetX') && (out.textShadowOffsetX = richItem.textShadowOffsetX);
+      hasOwn(richItem, 'textShadowOffsetY') && (out.textShadowOffsetY = richItem.textShadowOffsetY);
+    }
+
+    function warnDeprecated(deprecated, insteadApproach) {
+      if ("development" !== 'production') {
+        var key = deprecated + '^_^' + insteadApproach;
+
+        if (!deprecatedLogs[key]) {
+          console.warn("[ECharts] DEPRECATED: \"" + deprecated + "\" has been deprecated. " + insteadApproach);
+          deprecatedLogs[key] = true;
+        }
+      }
+    }
+
+    var CMD$4 = PathProxy.CMD;
+    var PI2$a = Math.PI * 2;
+    var PROP_XY = ['x', 'y'];
+    var PROP_WH = ['width', 'height'];
+    var tmpArr$1 = [];
+    function aroundEqual(a, b) {
+        return Math.abs(a - b) < 1e-5;
+    }
+    function pathToBezierCurves(path) {
+        var data = path.data;
+        var len = path.len();
+        var bezierArray = [];
+        var currentSubpath;
+        var xi = 0;
+        var yi = 0;
+        var x0 = 0;
+        var y0 = 0;
+        function createNewSubpath(x, y) {
+            if (currentSubpath && currentSubpath.length > 2) {
+                bezierArray.push(currentSubpath);
+            }
+            currentSubpath = [x, y];
+        }
+        function addLine(x0, y0, x1, y1) {
+            if (!(aroundEqual(x0, x1) && aroundEqual(y0, y1))) {
+                currentSubpath.push(x0, y0, x1, y1, x1, y1);
+            }
+        }
+        function addArc(startAngle, endAngle, cx, cy, rx, ry) {
+            var delta = Math.abs(endAngle - startAngle);
+            var len = Math.tan(delta / 4) * 4 / 3;
+            var dir = endAngle < startAngle ? -1 : 1;
+            var c1 = Math.cos(startAngle);
+            var s1 = Math.sin(startAngle);
+            var c2 = Math.cos(endAngle);
+            var s2 = Math.sin(endAngle);
+            var x1 = c1 * rx + cx;
+            var y1 = s1 * ry + cy;
+            var x4 = c2 * rx + cx;
+            var y4 = s2 * ry + cy;
+            var hx = rx * len * dir;
+            var hy = ry * len * dir;
+            currentSubpath.push(x1 - hx * s1, y1 + hy * c1, x4 + hx * s2, y4 - hy * c2, x4, y4);
+        }
+        var x1;
+        var y1;
+        var x2;
+        var y2;
+        for (var i = 0; i < len;) {
+            var cmd = data[i++];
+            var isFirst = i === 1;
+            if (isFirst) {
+                xi = data[i];
+                yi = data[i + 1];
+                x0 = xi;
+                y0 = yi;
+                if (cmd === CMD$4.L || cmd === CMD$4.C || cmd === CMD$4.Q) {
+                    currentSubpath = [x0, y0];
+                }
+            }
+            switch (cmd) {
+                case CMD$4.M:
+                    xi = x0 = data[i++];
+                    yi = y0 = data[i++];
+                    createNewSubpath(x0, y0);
+                    break;
+                case CMD$4.L:
+                    x1 = data[i++];
+                    y1 = data[i++];
+                    addLine(xi, yi, x1, y1);
+                    xi = x1;
+                    yi = y1;
+                    break;
+                case CMD$4.C:
+                    currentSubpath.push(data[i++], data[i++], data[i++], data[i++], xi = data[i++], yi = data[i++]);
+                    break;
+                case CMD$4.Q:
+                    x1 = data[i++];
+                    y1 = data[i++];
+                    x2 = data[i++];
+                    y2 = data[i++];
+                    currentSubpath.push(xi + 2 / 3 * (x1 - xi), yi + 2 / 3 * (y1 - yi), x2 + 2 / 3 * (x1 - x2), y2 + 2 / 3 * (y1 - y2), x2, y2);
+                    xi = x2;
+                    yi = y2;
+                    break;
+                case CMD$4.A:
+                    var cx = data[i++];
+                    var cy = data[i++];
+                    var rx = data[i++];
+                    var ry = data[i++];
+                    var startAngle = data[i++];
+                    var endAngle = data[i++] + startAngle;
+                    i += 1;
+                    var anticlockwise = !data[i++];
+                    x1 = Math.cos(startAngle) * rx + cx;
+                    y1 = Math.sin(startAngle) * ry + cy;
+                    if (isFirst) {
+                        x0 = x1;
+                        y0 = y1;
+                        createNewSubpath(x0, y0);
+                    }
+                    else {
+                        addLine(xi, yi, x1, y1);
+                    }
+                    xi = Math.cos(endAngle) * rx + cx;
+                    yi = Math.sin(endAngle) * ry + cy;
+                    var step = (anticlockwise ? -1 : 1) * Math.PI / 2;
+                    for (var angle = startAngle; anticlockwise ? angle > endAngle : angle < endAngle; angle += step) {
+                        var nextAngle = anticlockwise ? Math.max(angle + step, endAngle)
+                            : Math.min(angle + step, endAngle);
+                        addArc(angle, nextAngle, cx, cy, rx, ry);
+                    }
+                    break;
+                case CMD$4.R:
+                    x0 = xi = data[i++];
+                    y0 = yi = data[i++];
+                    x1 = x0 + data[i++];
+                    y1 = y0 + data[i++];
+                    createNewSubpath(x1, y0);
+                    addLine(x1, y0, x1, y1);
+                    addLine(x1, y1, x0, y1);
+                    addLine(x0, y1, x0, y0);
+                    addLine(x0, y0, x1, y0);
+                    break;
+                case CMD$4.Z:
+                    currentSubpath && addLine(xi, yi, x0, y0);
+                    xi = x0;
+                    yi = y0;
+                    break;
+            }
+        }
+        if (currentSubpath && currentSubpath.length > 2) {
+            bezierArray.push(currentSubpath);
+        }
+        return bezierArray;
+    }
+    function alignSubpath(subpath1, subpath2) {
+        var len1 = subpath1.length;
+        var len2 = subpath2.length;
+        if (len1 === len2) {
+            return [subpath1, subpath2];
+        }
+        var shorterPath = len1 < len2 ? subpath1 : subpath2;
+        var shorterLen = Math.min(len1, len2);
+        var diff = Math.abs(len2 - len1) / 6;
+        var shorterBezierCount = (shorterLen - 2) / 6;
+        var eachCurveSubDivCount = Math.ceil(diff / shorterBezierCount) + 1;
+        var newSubpath = [shorterPath[0], shorterPath[1]];
+        var remained = diff;
+        var tmpSegX = [];
+        var tmpSegY = [];
+        for (var i = 2; i < shorterLen;) {
+            var x0 = shorterPath[i - 2];
+            var y0 = shorterPath[i - 1];
+            var x1 = shorterPath[i++];
+            var y1 = shorterPath[i++];
+            var x2 = shorterPath[i++];
+            var y2 = shorterPath[i++];
+            var x3 = shorterPath[i++];
+            var y3 = shorterPath[i++];
+            if (remained <= 0) {
+                newSubpath.push(x1, y1, x2, y2, x3, y3);
+                continue;
+            }
+            var actualSubDivCount = Math.min(remained, eachCurveSubDivCount - 1) + 1;
+            for (var k = 1; k <= actualSubDivCount; k++) {
+                var p = k / actualSubDivCount;
+                cubicSubdivide(x0, x1, x2, x3, p, tmpSegX);
+                cubicSubdivide(y0, y1, y2, y3, p, tmpSegY);
+                x0 = tmpSegX[3];
+                y0 = tmpSegY[3];
+                newSubpath.push(tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], x0, y0);
+                x1 = tmpSegX[5];
+                y1 = tmpSegY[5];
+                x2 = tmpSegX[6];
+                y2 = tmpSegY[6];
+            }
+            remained -= actualSubDivCount - 1;
+        }
+        return shorterPath === subpath1 ? [newSubpath, subpath2] : [subpath1, newSubpath];
+    }
+    function createSubpath(lastSubpathSubpath, otherSubpath) {
+        var len = lastSubpathSubpath.length;
+        var lastX = lastSubpathSubpath[len - 2];
+        var lastY = lastSubpathSubpath[len - 1];
+        var newSubpath = [];
+        for (var i = 0; i < otherSubpath.length;) {
+            newSubpath[i++] = lastX;
+            newSubpath[i++] = lastY;
+        }
+        return newSubpath;
+    }
+    function alignBezierCurves(array1, array2) {
+        var _a;
+        var lastSubpath1;
+        var lastSubpath2;
+        var newArray1 = [];
+        var newArray2 = [];
+        for (var i = 0; i < Math.max(array1.length, array2.length); i++) {
+            var subpath1 = array1[i];
+            var subpath2 = array2[i];
+            var newSubpath1 = void 0;
+            var newSubpath2 = void 0;
+            if (!subpath1) {
+                newSubpath1 = createSubpath(lastSubpath1 || subpath2, subpath2);
+                newSubpath2 = subpath2;
+            }
+            else if (!subpath2) {
+                newSubpath2 = createSubpath(lastSubpath2 || subpath1, subpath1);
+                newSubpath1 = subpath1;
+            }
+            else {
+                _a = alignSubpath(subpath1, subpath2), newSubpath1 = _a[0], newSubpath2 = _a[1];
+                lastSubpath1 = newSubpath1;
+                lastSubpath2 = newSubpath2;
+            }
+            newArray1.push(newSubpath1);
+            newArray2.push(newSubpath2);
+        }
+        return [newArray1, newArray2];
+    }
+    function centroid(array) {
+        var signedArea = 0;
+        var cx = 0;
+        var cy = 0;
+        var len = array.length;
+        for (var i = 0, j = len - 2; i < len; j = i, i += 2) {
+            var x0 = array[j];
+            var y0 = array[j + 1];
+            var x1 = array[i];
+            var y1 = array[i + 1];
+            var a = x0 * y1 - x1 * y0;
+            signedArea += a;
+            cx += (x0 + x1) * a;
+            cy += (y0 + y1) * a;
+        }
+        if (signedArea === 0) {
+            return [array[0] || 0, array[1] || 0];
+        }
+        return [cx / signedArea / 3, cy / signedArea / 3, signedArea];
+    }
+    function findBestRingOffset(fromSubBeziers, toSubBeziers, fromCp, toCp) {
+        var bezierCount = (fromSubBeziers.length - 2) / 6;
+        var bestScore = Infinity;
+        var bestOffset = 0;
+        var len = fromSubBeziers.length;
+        var len2 = len - 2;
+        for (var offset = 0; offset < bezierCount; offset++) {
+            var cursorOffset = offset * 6;
+            var score = 0;
+            for (var k = 0; k < len; k += 2) {
+                var idx = k === 0 ? cursorOffset : ((cursorOffset + k - 2) % len2 + 2);
+                var x0 = fromSubBeziers[idx] - fromCp[0];
+                var y0 = fromSubBeziers[idx + 1] - fromCp[1];
+                var x1 = toSubBeziers[k] - toCp[0];
+                var y1 = toSubBeziers[k + 1] - toCp[1];
+                var dx = x1 - x0;
+                var dy = y1 - y0;
+                score += dx * dx + dy * dy;
+            }
+            if (score < bestScore) {
+                bestScore = score;
+                bestOffset = offset;
+            }
+        }
+        return bestOffset;
+    }
+    function reverse(array) {
+        var newArr = [];
+        var len = array.length;
+        for (var i = 0; i < len; i += 2) {
+            newArr[i] = array[len - i - 2];
+            newArr[i + 1] = array[len - i - 1];
+        }
+        return newArr;
+    }
+    function findBestMorphingRotation(fromArr, toArr, searchAngleIteration, searchAngleRange) {
+        var result = [];
+        var fromNeedsReverse;
+        for (var i = 0; i < fromArr.length; i++) {
+            var fromSubpathBezier = fromArr[i];
+            var toSubpathBezier = toArr[i];
+            var fromCp = centroid(fromSubpathBezier);
+            var toCp = centroid(toSubpathBezier);
+            if (fromNeedsReverse == null) {
+                fromNeedsReverse = fromCp[2] < 0 !== toCp[2] < 0;
+            }
+            var newFromSubpathBezier = [];
+            var newToSubpathBezier = [];
+            var bestAngle = 0;
+            var bestScore = Infinity;
+            var tmpArr_1 = [];
+            var len = fromSubpathBezier.length;
+            if (fromNeedsReverse) {
+                fromSubpathBezier = reverse(fromSubpathBezier);
+            }
+            var offset = findBestRingOffset(fromSubpathBezier, toSubpathBezier, fromCp, toCp) * 6;
+            var len2 = len - 2;
+            for (var k = 0; k < len2; k += 2) {
+                var idx = (offset + k) % len2 + 2;
+                newFromSubpathBezier[k + 2] = fromSubpathBezier[idx] - fromCp[0];
+                newFromSubpathBezier[k + 3] = fromSubpathBezier[idx + 1] - fromCp[1];
+            }
+            newFromSubpathBezier[0] = fromSubpathBezier[offset] - fromCp[0];
+            newFromSubpathBezier[1] = fromSubpathBezier[offset + 1] - fromCp[1];
+            if (searchAngleIteration > 0) {
+                var step = searchAngleRange / searchAngleIteration;
+                for (var angle = -searchAngleRange / 2; angle <= searchAngleRange / 2; angle += step) {
+                    var sa = Math.sin(angle);
+                    var ca = Math.cos(angle);
+                    var score = 0;
+                    for (var k = 0; k < fromSubpathBezier.length; k += 2) {
+                        var x0 = newFromSubpathBezier[k];
+                        var y0 = newFromSubpathBezier[k + 1];
+                        var x1 = toSubpathBezier[k] - toCp[0];
+                        var y1 = toSubpathBezier[k + 1] - toCp[1];
+                        var newX1 = x1 * ca - y1 * sa;
+                        var newY1 = x1 * sa + y1 * ca;
+                        tmpArr_1[k] = newX1;
+                        tmpArr_1[k + 1] = newY1;
+                        var dx = newX1 - x0;
+                        var dy = newY1 - y0;
+                        score += dx * dx + dy * dy;
+                    }
+                    if (score < bestScore) {
+                        bestScore = score;
+                        bestAngle = angle;
+                        for (var m = 0; m < tmpArr_1.length; m++) {
+                            newToSubpathBezier[m] = tmpArr_1[m];
+                        }
+                    }
+                }
+            }
+            else {
+                for (var i_1 = 0; i_1 < len; i_1 += 2) {
+                    newToSubpathBezier[i_1] = toSubpathBezier[i_1] - toCp[0];
+                    newToSubpathBezier[i_1 + 1] = toSubpathBezier[i_1 + 1] - toCp[1];
+                }
+            }
+            result.push({
+                from: newFromSubpathBezier,
+                to: newToSubpathBezier,
+                fromCp: fromCp,
+                toCp: toCp,
+                rotation: -bestAngle
+            });
+        }
+        return result;
+    }
+    function morphPath(fromPath, toPath, animationOpts) {
+        var fromPathProxy;
+        var toPathProxy;
+        if (!fromPath || !toPath) {
+            return toPath;
+        }
+        !fromPath.path && fromPath.createPathProxy();
+        fromPathProxy = fromPath.path;
+        fromPathProxy.beginPath();
+        fromPath.buildPath(fromPathProxy, fromPath.shape);
+        !toPath.path && toPath.createPathProxy();
+        toPathProxy = toPath.path;
+        toPathProxy === fromPathProxy && (toPathProxy = new PathProxy(false));
+        toPathProxy.beginPath();
+        if (isIndividualMorphingPath(toPath)) {
+            toPath.__oldBuildPath(toPathProxy, toPath.shape);
+        }
+        else {
+            toPath.buildPath(toPathProxy, toPath.shape);
+        }
+        var _a = alignBezierCurves(pathToBezierCurves(fromPathProxy), pathToBezierCurves(toPathProxy)), fromBezierCurves = _a[0], toBezierCurves = _a[1];
+        var morphingData = findBestMorphingRotation(fromBezierCurves, toBezierCurves, 10, Math.PI);
+        becomeIndividualMorphingPath(toPath, morphingData, 0);
+        var oldDone = animationOpts && animationOpts.done;
+        var oldAborted = animationOpts && animationOpts.aborted;
+        var oldDuring = animationOpts && animationOpts.during;
+        toPath.animateTo({
+            __morphT: 1
+        }, defaults({
+            during: function (p) {
+                toPath.dirtyShape();
+                oldDuring && oldDuring(p);
+            },
+            done: function () {
+                restoreIndividualMorphingPath(toPath);
+                toPath.createPathProxy();
+                toPath.dirtyShape();
+                oldDone && oldDone();
+            },
+            aborted: function () {
+                oldAborted && oldAborted();
+            }
+        }, animationOpts));
+        return toPath;
+    }
+    function morphingPathBuildPath(path) {
+        var morphingData = this.__morphingData;
+        var t = this.__morphT;
+        var onet = 1 - t;
+        var newCp = [];
+        for (var i = 0; i < morphingData.length; i++) {
+            var item = morphingData[i];
+            var from = item.from;
+            var to = item.to;
+            var angle = item.rotation * t;
+            var fromCp = item.fromCp;
+            var toCp = item.toCp;
+            var sa = Math.sin(angle);
+            var ca = Math.cos(angle);
+            lerp(newCp, fromCp, toCp, t);
+            for (var m = 0; m < from.length; m += 2) {
+                var x0 = from[m];
+                var y0 = from[m + 1];
+                var x1 = to[m];
+                var y1 = to[m + 1];
+                var x = x0 * onet + x1 * t;
+                var y = y0 * onet + y1 * t;
+                tmpArr$1[m] = (x * ca - y * sa) + newCp[0];
+                tmpArr$1[m + 1] = (x * sa + y * ca) + newCp[1];
+            }
+            for (var m = 0; m < from.length;) {
+                if (m === 0) {
+                    path.moveTo(tmpArr$1[m++], tmpArr$1[m++]);
+                }
+                path.bezierCurveTo(tmpArr$1[m++], tmpArr$1[m++], tmpArr$1[m++], tmpArr$1[m++], tmpArr$1[m++], tmpArr$1[m++]);
+            }
+        }
+    }
+    function becomeIndividualMorphingPath(path, morphingData, morphT) {
+        if (isIndividualMorphingPath(path)) {
+            updateIndividualMorphingPath(path, morphingData, morphT);
+            return;
+        }
+        var morphingPath = path;
+        morphingPath.__oldBuildPath = morphingPath.buildPath;
+        morphingPath.buildPath = morphingPathBuildPath;
+        updateIndividualMorphingPath(morphingPath, morphingData, morphT);
+    }
+    function updateIndividualMorphingPath(morphingPath, morphingData, morphT) {
+        morphingPath.__morphingData = morphingData;
+        morphingPath.__morphT = morphT;
+    }
+    function restoreIndividualMorphingPath(path) {
+        if (isIndividualMorphingPath(path)) {
+            path.buildPath = path.__oldBuildPath;
+            path.__oldBuildPath = path.__morphingData = null;
+        }
+    }
+    function isIndividualMorphingPath(path) {
+        return path.__oldBuildPath != null;
+    }
+    function isCombiningPath(path) {
+        return !!path.__combiningSubList;
+    }
+    function isInAnyMorphing(path) {
+        return isIndividualMorphingPath(path) || isCombiningPath(path);
+    }
+    function combine(fromPathList, toPath, animationOpts, copyPropsIfDivided) {
+        var fromIndividuals = [];
+        var separateCount = 0;
+        for (var i = 0; i < fromPathList.length; i++) {
+            var fromPath = fromPathList[i];
+            if (isCombiningPath(fromPath)) {
+                var fromCombiningSubList = fromPath.__combiningSubList;
+                for (var j = 0; j < fromCombiningSubList.length; j++) {
+                    fromIndividuals.push(fromCombiningSubList[j]);
+                }
+                separateCount += fromCombiningSubList.length;
+            }
+            else {
+                fromIndividuals.push(fromPath);
+                separateCount++;
+            }
+        }
+        if (!separateCount) {
+            return;
+        }
+        var dividingMethod = animationOpts ? animationOpts.dividingMethod : null;
+        var toPathSplittedList = divideShape(toPath, separateCount, dividingMethod);
+        assert(toPathSplittedList.length === separateCount);
+        var oldDone = animationOpts && animationOpts.done;
+        var oldAborted = animationOpts && animationOpts.aborted;
+        var oldDuring = animationOpts && animationOpts.during;
+        var doneCount = 0;
+        var abortedCalled = false;
+        var morphAnimationOpts = defaults({
+            during: function (p) {
+                oldDuring && oldDuring(p);
+            },
+            done: function () {
+                doneCount++;
+                if (doneCount === toPathSplittedList.length) {
+                    restoreCombiningPath(toPath);
+                    oldDone && oldDone();
+                }
+            },
+            aborted: function () {
+                if (!abortedCalled) {
+                    abortedCalled = true;
+                    oldAborted && oldAborted();
+                }
+            }
+        }, animationOpts);
+        for (var i = 0; i < separateCount; i++) {
+            var from = fromIndividuals[i];
+            var to = toPathSplittedList[i];
+            copyPropsIfDivided && copyPropsIfDivided(toPath, to, true);
+            morphPath(from, to, morphAnimationOpts);
+        }
+        becomeCombiningPath(toPath, toPathSplittedList);
+        return {
+            fromIndividuals: fromIndividuals,
+            toIndividuals: toPathSplittedList,
+            count: separateCount
+        };
+    }
+    function becomeCombiningPath(path, combiningSubList) {
+        if (isCombiningPath(path)) {
+            updateCombiningPathSubList(path, combiningSubList);
+            return;
+        }
+        var combiningPath = path;
+        updateCombiningPathSubList(combiningPath, combiningSubList);
+        combiningPath.__oldAddSelfToZr = path.addSelfToZr;
+        combiningPath.__oldRemoveSelfFromZr = path.removeSelfFromZr;
+        combiningPath.addSelfToZr = combiningAddSelfToZr;
+        combiningPath.removeSelfFromZr = combiningRemoveSelfFromZr;
+        combiningPath.__oldBuildPath = combiningPath.buildPath;
+        combiningPath.buildPath = noop;
+        combiningPath.childrenRef = combiningChildrenRef;
+    }
+    function restoreCombiningPath(path) {
+        if (!isCombiningPath(path)) {
+            return;
+        }
+        var combiningPath = path;
+        updateCombiningPathSubList(combiningPath, null);
+        combiningPath.addSelfToZr = combiningPath.__oldAddSelfToZr;
+        combiningPath.removeSelfFromZr = combiningPath.__oldRemoveSelfFromZr;
+        combiningPath.buildPath = combiningPath.__oldBuildPath;
+        combiningPath.childrenRef =
+            combiningPath.__combiningSubList =
+                combiningPath.__oldAddSelfToZr =
+                    combiningPath.__oldRemoveSelfFromZr =
+                        combiningPath.__oldBuildPath = null;
+    }
+    function updateCombiningPathSubList(combiningPath, combiningSubList) {
+        if (combiningPath.__combiningSubList !== combiningSubList) {
+            combiningPathSubListAddRemoveWithZr(combiningPath, 'removeSelfFromZr');
+            combiningPath.__combiningSubList = combiningSubList;
+            if (combiningSubList) {
+                for (var i = 0; i < combiningSubList.length; i++) {
+                    combiningSubList[i].parent = combiningPath;
+                }
+            }
+            combiningPathSubListAddRemoveWithZr(combiningPath, 'addSelfToZr');
+        }
+    }
+    function combiningAddSelfToZr(zr) {
+        this.__oldAddSelfToZr(zr);
+        combiningPathSubListAddRemoveWithZr(this, 'addSelfToZr');
+    }
+    function combiningPathSubListAddRemoveWithZr(path, method) {
+        var combiningSubList = path.__combiningSubList;
+        var zr = path.__zr;
+        if (combiningSubList && zr) {
+            for (var i = 0; i < combiningSubList.length; i++) {
+                var child = combiningSubList[i];
+                child[method](zr);
+            }
+        }
+    }
+    function combiningRemoveSelfFromZr(zr) {
+        this.__oldRemoveSelfFromZr(zr);
+        var combiningSubList = this.__combiningSubList;
+        for (var i = 0; i < combiningSubList.length; i++) {
+            var child = combiningSubList[i];
+            child.removeSelfFromZr(zr);
+        }
+    }
+    function combiningChildrenRef() {
+        return this.__combiningSubList;
+    }
+    function separate(fromPath, toPathList, animationOpts, copyPropsIfDivided) {
+        var toPathListLen = toPathList.length;
+        var fromPathList;
+        var dividingMethod = animationOpts ? animationOpts.dividingMethod : null;
+        var copyProps = false;
+        if (isCombiningPath(fromPath)) {
+            var fromCombiningSubList = fromPath.__combiningSubList;
+            if (fromCombiningSubList.length === toPathListLen) {
+                fromPathList = fromCombiningSubList;
+            }
+            else {
+                fromPathList = divideShape(fromPath, toPathListLen, dividingMethod);
+                copyProps = true;
+            }
+        }
+        else {
+            fromPathList = divideShape(fromPath, toPathListLen, dividingMethod);
+            copyProps = true;
+        }
+        assert(fromPathList.length === toPathListLen);
+        for (var i = 0; i < toPathListLen; i++) {
+            if (copyProps && copyPropsIfDivided) {
+                copyPropsIfDivided(fromPath, fromPathList[i], false);
+            }
+            morphPath(fromPathList[i], toPathList[i], animationOpts);
+        }
+        return {
+            fromIndividuals: fromPathList,
+            toIndividuals: toPathList,
+            count: toPathListLen
+        };
+    }
+    function divideShape(path, separateCount, dividingMethod) {
+        return dividingMethod === 'duplicate'
+            ? duplicateShape(path, separateCount)
+            : splitShape(path, separateCount);
+    }
+    function splitShape(path, separateCount) {
+        var resultPaths = [];
+        if (separateCount <= 0) {
+            return resultPaths;
+        }
+        if (separateCount === 1) {
+            return duplicateShape(path, separateCount);
+        }
+        if (path instanceof Rect) {
+            var toPathShape = path.shape;
+            var splitPropIdx = toPathShape.height > toPathShape.width ? 1 : 0;
+            var propWH = PROP_WH[splitPropIdx];
+            var propXY = PROP_XY[splitPropIdx];
+            var subWH = toPathShape[propWH] / separateCount;
+            var xyCurr = toPathShape[propXY];
+            for (var i = 0; i < separateCount; i++, xyCurr += subWH) {
+                var subShape = {
+                    x: toPathShape.x,
+                    y: toPathShape.y,
+                    width: toPathShape.width,
+                    height: toPathShape.height
+                };
+                subShape[propXY] = xyCurr;
+                subShape[propWH] = i < separateCount - 1
+                    ? subWH
+                    : toPathShape[propXY] + toPathShape[propWH] - xyCurr;
+                var splitted = new Rect({ shape: subShape });
+                resultPaths.push(splitted);
+            }
+        }
+        else if (path instanceof Sector) {
+            var toPathShape = path.shape;
+            var clockwise = toPathShape.clockwise;
+            var startAngle = toPathShape.startAngle;
+            var endAngle = toPathShape.endAngle;
+            var endAngleNormalized = normalizeRadian$1(startAngle, toPathShape.endAngle, clockwise);
+            var step = (endAngleNormalized - startAngle) / separateCount;
+            var angleCurr = startAngle;
+            for (var i = 0; i < separateCount; i++, angleCurr += step) {
+                var splitted = new Sector({
+                    shape: {
+                        cx: toPathShape.cx,
+                        cy: toPathShape.cy,
+                        r: toPathShape.r,
+                        r0: toPathShape.r0,
+                        clockwise: clockwise,
+                        startAngle: angleCurr,
+                        endAngle: i === separateCount - 1 ? endAngle : angleCurr + step
+                    }
+                });
+                resultPaths.push(splitted);
+            }
+        }
+        else {
+            return duplicateShape(path, separateCount);
+        }
+        return resultPaths;
+    }
+    function duplicateShape(path, separateCount) {
+        var resultPaths = [];
+        if (separateCount <= 0) {
+            return resultPaths;
+        }
+        var ctor = path.constructor;
+        for (var i = 0; i < separateCount; i++) {
+            var sub = new ctor({
+                shape: clone(path.shape)
+            });
+            resultPaths.push(sub);
+        }
+        return resultPaths;
+    }
+    function normalizeRadian$1(start, end, clockwise) {
+        return end + PI2$a * (Math[clockwise ? 'ceil' : 'floor']((start - end) / PI2$a));
+    }
+
+    var inner$b = makeInner();
+    var TRANSFORM_PROPS = {
+      x: 1,
+      y: 1,
+      scaleX: 1,
+      scaleY: 1,
+      originX: 1,
+      originY: 1,
+      rotation: 1
+    };
+    var transformPropNamesStr = keys(TRANSFORM_PROPS).join(', ');
+    // `visual('color') visual('borderColor')` is supported.
+
+    var STYLE_VISUAL_TYPE = {
+      color: 'fill',
+      borderColor: 'stroke'
+    };
+    var NON_STYLE_VISUAL_PROPS = {
+      symbol: 1,
+      symbolSize: 1,
+      symbolKeepAspect: 1,
+      legendSymbol: 1,
+      visualMeta: 1,
+      liftZ: 1,
+      decal: 1
+    };
+    var EMPHASIS = 'emphasis';
+    var NORMAL = 'normal';
+    var BLUR = 'blur';
+    var SELECT = 'select';
+    var STATES = [NORMAL, EMPHASIS, BLUR, SELECT];
+    var PATH_ITEM_STYLE = {
+      normal: ['itemStyle'],
+      emphasis: [EMPHASIS, 'itemStyle'],
+      blur: [BLUR, 'itemStyle'],
+      select: [SELECT, 'itemStyle']
+    };
+    var PATH_LABEL = {
+      normal: ['label'],
+      emphasis: [EMPHASIS, 'label'],
+      blur: [BLUR, 'label'],
+      select: [SELECT, 'label']
+    }; // Use prefix to avoid index to be the same as el.name,
+    // which will cause weird update animation.
+
+    var GROUP_DIFF_PREFIX = 'e\0\0';
+    var attachedTxInfoTmp = {
+      normal: {},
+      emphasis: {},
+      blur: {},
+      select: {}
+    };
+    var LEGACY_TRANSFORM_PROPS = {
+      position: ['x', 'y'],
+      scale: ['scaleX', 'scaleY'],
+      origin: ['originX', 'originY']
+    };
+    var tmpTransformable = new Transformable();
+    /**
+     * To reduce total package size of each coordinate systems, the modules `prepareCustom`
+     * of each coordinate systems are not required by each coordinate systems directly, but
+     * required by the module `custom`.
+     *
+     * prepareInfoForCustomSeries {Function}: optional
+     *     @return {Object} {coordSys: {...}, api: {
+     *         coord: function (data, clamp) {}, // return point in global.
+     *         size: function (dataSize, dataItem) {} // return size of each axis in coordSys.
+     *     }}
+     */
+
+    var prepareCustoms = {
+      cartesian2d: cartesianPrepareCustom,
+      geo: geoPrepareCustom,
+      singleAxis: singlePrepareCustom,
+      polar: polarPrepareCustom,
+      calendar: calendarPrepareCustom
+    };
+
+    var CustomSeriesModel =
+    /** @class */
+    function (_super) {
+      __extends(CustomSeriesModel, _super);
+
+      function CustomSeriesModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CustomSeriesModel.type;
+        return _this;
+      }
+
+      CustomSeriesModel.prototype.optionUpdated = function () {
+        this.currentZLevel = this.get('zlevel', true);
+        this.currentZ = this.get('z', true);
+      };
+
+      CustomSeriesModel.prototype.getInitialData = function (option, ecModel) {
+        return createListFromArray(this.getSource(), this);
+      };
+
+      CustomSeriesModel.prototype.getDataParams = function (dataIndex, dataType, el) {
+        var params = _super.prototype.getDataParams.call(this, dataIndex, dataType);
+
+        el && (params.info = inner$b(el).info);
+        return params;
+      };
+
+      CustomSeriesModel.type = 'series.custom';
+      CustomSeriesModel.dependencies = ['grid', 'polar', 'geo', 'singleAxis', 'calendar'];
+      CustomSeriesModel.defaultOption = {
+        coordinateSystem: 'cartesian2d',
+        zlevel: 0,
+        z: 2,
+        legendHoverLink: true,
+        // Custom series will not clip by default.
+        // Some case will use custom series to draw label
+        // For example https://echarts.apache.org/examples/en/editor.html?c=custom-gantt-flight
+        clip: false // Cartesian coordinate system
+        // xAxisIndex: 0,
+        // yAxisIndex: 0,
+        // Polar coordinate system
+        // polarIndex: 0,
+        // Geo coordinate system
+        // geoIndex: 0,
+
+      };
+      return CustomSeriesModel;
+    }(SeriesModel);
+
+    var CustomSeriesView =
+    /** @class */
+    function (_super) {
+      __extends(CustomSeriesView, _super);
+
+      function CustomSeriesView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CustomSeriesView.type;
+        return _this;
+      }
+
+      CustomSeriesView.prototype.render = function (customSeries, ecModel, api, payload) {
+        var oldData = this._data;
+        var data = customSeries.getData();
+        var group = this.group;
+        var renderItem = makeRenderItem(customSeries, data, ecModel, api); // By default, merge mode is applied. In most cases, custom series is
+        // used in the scenario that data amount is not large but graphic elements
+        // is complicated, where merge mode is probably necessary for optimization.
+        // For example, reuse graphic elements and only update the transform when
+        // roam or data zoom according to `actionType`.
+
+        var transOpt = customSeries.__transientTransitionOpt; // Enable user to disable transition animation by both set
+        // `from` and `to` dimension as `null`/`undefined`.
+
+        if (transOpt && (transOpt.from == null || transOpt.to == null)) {
+          oldData && oldData.each(function (oldIdx) {
+            doRemoveEl(oldData.getItemGraphicEl(oldIdx), customSeries, group);
+          });
+          data.each(function (newIdx) {
+            createOrUpdateItem(api, null, newIdx, renderItem(newIdx, payload), customSeries, group, data, null);
+          });
+        } else {
+          var morphPreparation_1 = new MorphPreparation(customSeries, transOpt);
+          var diffMode = transOpt ? 'multiple' : 'oneToOne';
+          new DataDiffer(oldData ? oldData.getIndices() : [], data.getIndices(), createGetKey(oldData, diffMode, transOpt && transOpt.from), createGetKey(data, diffMode, transOpt && transOpt.to), null, diffMode).add(function (newIdx) {
+            createOrUpdateItem(api, null, newIdx, renderItem(newIdx, payload), customSeries, group, data, null);
+          }).remove(function (oldIdx) {
+            doRemoveEl(oldData.getItemGraphicEl(oldIdx), customSeries, group);
+          }).update(function (newIdx, oldIdx) {
+            morphPreparation_1.reset('oneToOne');
+            var oldEl = oldData.getItemGraphicEl(oldIdx);
+            morphPreparation_1.findAndAddFrom(oldEl); // PENDING:
+            // if may morph, currently we alway recreate the whole el.
+            // because if reuse some of the el in the group tree, the old el has to
+            // be removed from the group, and consequently we can not calculate
+            // the "global transition" of the old element.
+            // But is there performance issue?
+
+            if (morphPreparation_1.hasFrom()) {
+              removeElementDirectly(oldEl, group);
+              oldEl = null;
+            }
+
+            createOrUpdateItem(api, oldEl, newIdx, renderItem(newIdx, payload), customSeries, group, data, morphPreparation_1);
+            morphPreparation_1.applyMorphing();
+          }).updateManyToOne(function (newIdx, oldIndices) {
+            morphPreparation_1.reset('manyToOne');
+
+            for (var i = 0; i < oldIndices.length; i++) {
+              var oldEl = oldData.getItemGraphicEl(oldIndices[i]);
+              morphPreparation_1.findAndAddFrom(oldEl);
+              removeElementDirectly(oldEl, group);
+            }
+
+            createOrUpdateItem(api, null, newIdx, renderItem(newIdx, payload), customSeries, group, data, morphPreparation_1);
+            morphPreparation_1.applyMorphing();
+          }).updateOneToMany(function (newIndices, oldIdx) {
+            morphPreparation_1.reset('oneToMany');
+            var newLen = newIndices.length;
+            var oldEl = oldData.getItemGraphicEl(oldIdx);
+            morphPreparation_1.findAndAddFrom(oldEl);
+            removeElementDirectly(oldEl, group);
+
+            for (var i = 0; i < newLen; i++) {
+              createOrUpdateItem(api, null, newIndices[i], renderItem(newIndices[i], payload), customSeries, group, data, morphPreparation_1);
+            }
+
+            morphPreparation_1.applyMorphing();
+          }).execute();
+        } // Do clipping
+
+
+        var clipPath = customSeries.get('clip', true) ? createClipPath(customSeries.coordinateSystem, false, customSeries) : null;
+
+        if (clipPath) {
+          group.setClipPath(clipPath);
+        } else {
+          group.removeClipPath();
+        }
+
+        this._data = data;
+      };
+
+      CustomSeriesView.prototype.incrementalPrepareRender = function (customSeries, ecModel, api) {
+        this.group.removeAll();
+        this._data = null;
+      };
+
+      CustomSeriesView.prototype.incrementalRender = function (params, customSeries, ecModel, api, payload) {
+        var data = customSeries.getData();
+        var renderItem = makeRenderItem(customSeries, data, ecModel, api);
+
+        function setIncrementalAndHoverLayer(el) {
+          if (!el.isGroup) {
+            el.incremental = true;
+            el.ensureState('emphasis').hoverLayer = true;
+          }
+        }
+
+        for (var idx = params.start; idx < params.end; idx++) {
+          var el = createOrUpdateItem(null, null, idx, renderItem(idx, payload), customSeries, this.group, data, null);
+          el.traverse(setIncrementalAndHoverLayer);
+        }
+      };
+
+      CustomSeriesView.prototype.filterForExposedEvent = function (eventType, query, targetEl, packedEvent) {
+        var elementName = query.element;
+
+        if (elementName == null || targetEl.name === elementName) {
+          return true;
+        } // Enable to give a name on a group made by `renderItem`, and listen
+        // events that triggerd by its descendents.
+
+
+        while ((targetEl = targetEl.__hostTarget || targetEl.parent) && targetEl !== this.group) {
+          if (targetEl.name === elementName) {
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      CustomSeriesView.type = 'custom';
+      return CustomSeriesView;
+    }(ChartView);
+
+    function createGetKey(data, diffMode, dimension) {
+      if (!data) {
+        return;
+      }
+
+      if (diffMode === 'oneToOne') {
+        return function (rawIdx, dataIndex) {
+          return data.getId(dataIndex);
+        };
+      }
+
+      var diffByDimName = data.getDimension(dimension);
+      var dimInfo = data.getDimensionInfo(diffByDimName);
+
+      if (!dimInfo) {
+        var errMsg = '';
+
+        if ("development" !== 'production') {
+          errMsg = dimension + " is not a valid dimension.";
+        }
+
+        throwError(errMsg);
+      }
+
+      var ordinalMeta = dimInfo.ordinalMeta;
+      return function (rawIdx, dataIndex) {
+        var key = data.get(diffByDimName, dataIndex);
+
+        if (ordinalMeta) {
+          key = ordinalMeta.categories[key];
+        }
+
+        return key == null || eqNaN(key) ? rawIdx + '' : '_ec_' + key;
+      };
+    }
+
+    function createEl(elOption) {
+      var graphicType = elOption.type;
+      var el; // Those graphic elements are not shapes. They should not be
+      // overwritten by users, so do them first.
+
+      if (graphicType === 'path') {
+        var shape = elOption.shape; // Using pathRect brings convenience to users sacle svg path.
+
+        var pathRect = shape.width != null && shape.height != null ? {
+          x: shape.x || 0,
+          y: shape.y || 0,
+          width: shape.width,
+          height: shape.height
+        } : null;
+        var pathData = getPathData(shape); // Path is also used for icon, so layout 'center' by default.
+
+        el = makePath(pathData, null, pathRect, shape.layout || 'center');
+        inner$b(el).customPathData = pathData;
+      } else if (graphicType === 'image') {
+        el = new ZRImage({});
+        inner$b(el).customImagePath = elOption.style.image;
+      } else if (graphicType === 'text') {
+        el = new ZRText({}); // inner(el).customText = (elOption.style as TextStyleProps).text;
+      } else if (graphicType === 'group') {
+        el = new Group();
+      } else if (graphicType === 'compoundPath') {
+        throw new Error('"compoundPath" is not supported yet.');
+      } else {
+        var Clz = getShapeClass(graphicType);
+
+        if (!Clz) {
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            errMsg = 'graphic type "' + graphicType + '" can not be found.';
+          }
+
+          throwError(errMsg);
+        }
+
+        el = new Clz();
+      }
+
+      inner$b(el).customGraphicType = graphicType;
+      el.name = elOption.name; // Compat ec4: the default z2 lift is 1. If changing the number,
+      // some cases probably be broken: hierarchy layout along z, like circle packing,
+      // where emphasis only intending to modify color/border rather than lift z2.
+
+      el.z2EmphasisLift = 1;
+      el.z2SelectLift = 1;
+      return el;
+    }
+    /**
+     * ----------------------------------------------------------
+     * [STRATEGY_MERGE] Merge properties or erase all properties:
+     *
+     * Based on the fact that the existing zr element probably be reused, we now consider whether
+     * merge or erase all properties to the exsiting elements.
+     * That is, if a certain props is not specified in the lastest return of `renderItem`:
+     * + "Merge" means that do not modify the value on the existing element.
+     * + "Erase all" means that use a default value to the existing element.
+     *
+     * "Merge" might bring some unexpected state retaining for users and "erase all" seams to be
+     * more safe. "erase all" force users to specify all of the props each time, which is recommanded
+     * in most cases.
+     * But "erase all" theoretically disables the chance of performance optimization (e.g., just
+     * generete shape and style at the first time rather than always do that).
+     * So we still use "merge" rather than "erase all". If users need "erase all", they can
+     * simple always set all of the props each time.
+     * Some "object-like" config like `textConfig`, `textContent`, `style` which are not needed for
+     * every elment, so we replace them only when user specify them. And the that is a total replace.
+     *
+     * TODO: there is no hint of 'isFirst' to users. So the performance enhancement can not be
+     * performed yet. Consider the case:
+     * (1) setOption to "mergeChildren" with a smaller children count
+     * (2) Use dataZoom to make an item disappear.
+     * (3) User dataZoom to make the item display again. At that time, renderItem need to return the
+     * full option rather than partial option to recreate the element.
+     *
+     * ----------------------------------------------
+     * [STRATEGY_NULL] `hasOwnProperty` or `== null`:
+     *
+     * Ditinguishing "own property" probably bring little trouble to user when make el options.
+     * So we  trade a {xx: null} or {xx: undefined} as "not specified" if possible rather than
+     * "set them to null/undefined". In most cases, props can not be cleared. Some typicall
+     * clearable props like `style`/`textConfig`/`textContent` we enable `false` to means
+     * "clear". In some othere special cases that the prop is able to set as null/undefined,
+     * but not suitable to use `false`, `hasOwnProperty` is checked.
+     *
+     * ---------------------------------------------
+     * [STRATEGY_TRANSITION] The rule of transition:
+     * + For props on the root level of a element:
+     *      If there is no `transition` specified, tansform props will be transitioned by default,
+     *      which is the same as the previous setting in echarts4 and suitable for the scenario
+     *      of dataZoom change.
+     *      If `transition` specified, only the specified props will be transitioned.
+     * + For props in `shape` and `style`:
+     *      Only props specified in `transition` will be transitioned.
+     * + Break:
+     *      Since ec5, do not make transition to shape by default, because it might result in
+     *      performance issue (especially `points` of polygon) and do not necessary in most cases.
+     *
+     * @return if `isMorphTo`, return `allPropsFinal`.
+     */
+
+
+    function updateElNormal( // Can be null/undefined
+    api, el, // Whether be a morph target.
+    isMorphTo, dataIndex, elOption, styleOpt, attachedTxInfo, seriesModel, isInit, isTextContent) {
+      var transFromProps = {};
+      var allPropsFinal = {};
+      var elDisplayable = el.isGroup ? null : el; // If be "morph to", delay the `updateElNormal` when all of the els in
+      // this data item processed. Because at that time we can get all of the
+      // "morph from" and make correct separate/combine.
+
+      !isMorphTo && prepareShapeOrExtraTransitionFrom('shape', el, null, elOption, transFromProps, isInit);
+      prepareShapeOrExtraAllPropsFinal('shape', elOption, allPropsFinal);
+      !isMorphTo && prepareShapeOrExtraTransitionFrom('extra', el, null, elOption, transFromProps, isInit);
+      prepareShapeOrExtraAllPropsFinal('extra', elOption, allPropsFinal);
+      !isMorphTo && prepareTransformTransitionFrom(el, null, elOption, transFromProps, isInit);
+      prepareTransformAllPropsFinal(elOption, allPropsFinal);
+      var txCfgOpt = attachedTxInfo && attachedTxInfo.normal.cfg;
+
+      if (txCfgOpt) {
+        // PENDING: whether use user object directly rather than clone?
+        // TODO:5.0 textConfig transition animation?
+        el.setTextConfig(txCfgOpt);
+      }
+
+      if (el.type === 'text' && styleOpt) {
+        var textOptionStyle = styleOpt; // Compatible with ec4: if `textFill` or `textStroke` exists use them.
+
+        hasOwn(textOptionStyle, 'textFill') && (textOptionStyle.fill = textOptionStyle.textFill);
+        hasOwn(textOptionStyle, 'textStroke') && (textOptionStyle.stroke = textOptionStyle.textStroke);
+      }
+
+      if (styleOpt) {
+        var decalPattern = void 0;
+        var decalObj = isPath$1(el) ? styleOpt.decal : null;
+
+        if (api && decalObj) {
+          decalObj.dirty = true;
+          decalPattern = createOrUpdatePatternFromDecal(decalObj, api);
+        } // Always overwrite in case user specify this prop.
+
+
+        styleOpt.__decalPattern = decalPattern;
+      }
+
+      !isMorphTo && prepareStyleTransitionFrom(el, null, elOption, styleOpt, transFromProps, isInit);
+
+      if (elDisplayable) {
+        hasOwn(elOption, 'invisible') && (elDisplayable.invisible = elOption.invisible);
+      } // If `isMorphTo`, we should not update these props to el directly, otherwise,
+      // when applying morph finally, the original prop are missing for making "animation from".
+
+
+      if (!isMorphTo) {
+        applyPropsFinal(el, allPropsFinal, styleOpt);
+        applyTransitionFrom(el, dataIndex, elOption, seriesModel, transFromProps, isInit);
+      } // Merge by default.
+
+
+      hasOwn(elOption, 'silent') && (el.silent = elOption.silent);
+      hasOwn(elOption, 'ignore') && (el.ignore = elOption.ignore);
+
+      if (!isTextContent) {
+        // `elOption.info` enables user to mount some info on
+        // elements and use them in event handlers.
+        // Update them only when user specified, otherwise, remain.
+        hasOwn(elOption, 'info') && (inner$b(el).info = elOption.info);
+      }
+
+      styleOpt ? el.dirty() : el.markRedraw();
+      return isMorphTo ? allPropsFinal : null;
+    }
+
+    function applyPropsFinal(el, // Can be null/undefined
+    allPropsFinal, styleOpt) {
+      var elDisplayable = el.isGroup ? null : el;
+
+      if (elDisplayable && styleOpt) {
+        var decalPattern = styleOpt.__decalPattern;
+        var originalDecalObj = void 0;
+
+        if (decalPattern) {
+          originalDecalObj = styleOpt.decal;
+          styleOpt.decal = decalPattern;
+        } // PENDING: here the input style object is used directly.
+        // Good for performance but bad for compatibility control.
+
+
+        elDisplayable.useStyle(styleOpt);
+
+        if (decalPattern) {
+          styleOpt.decal = originalDecalObj;
+        } // When style object changed, how to trade the existing animation?
+        // It is probably conplicated and not needed to cover all the cases.
+        // But still need consider the case:
+        // (1) When using init animation on `style.opacity`, and before the animation
+        //     ended users triggers an update by mousewhell. At that time the init
+        //     animation should better be continued rather than terminated.
+        //     So after `useStyle` called, we should change the animation target manually
+        //     to continue the effect of the init animation.
+        // (2) PENDING: If the previous animation targeted at a `val1`, and currently we need
+        //     to update the value to `val2` and no animation declared, should be terminate
+        //     the previous animation or just modify the target of the animation?
+        //     Therotically That will happen not only on `style` but also on `shape` and
+        //     `transfrom` props. But we haven't handle this case at present yet.
+        // (3) PENDING: Is it proper to visit `animators` and `targetName`?
+
+
+        var animators = elDisplayable.animators;
+
+        for (var i = 0; i < animators.length; i++) {
+          var animator = animators[i]; // targetName is the "topKey".
+
+          if (animator.targetName === 'style') {
+            animator.changeTarget(elDisplayable.style);
+          }
+        }
+      } // Set el to the final state firstly.
+
+
+      allPropsFinal && el.attr(allPropsFinal);
+    }
+
+    function applyTransitionFrom(el, dataIndex, elOption, seriesModel, // Can be null/undefined
+    transFromProps, isInit) {
+      if (transFromProps) {
+        // Do not use `el.updateDuringAnimation` here becuase `el.updateDuringAnimation` will
+        // be called mutiple time in each animation frame. For example, if both "transform" props
+        // and shape props and style props changed, it will generate three animator and called
+        // one-by-one in each animation frame.
+        // We use the during in `animateTo/From` params.
+        var userDuring = elOption.during; // For simplicity, if during not specified, the previous during will not work any more.
+
+        inner$b(el).userDuring = userDuring;
+        var cfgDuringCall = userDuring ? bind(duringCall, {
+          el: el,
+          userDuring: userDuring
+        }) : null;
+        var cfg = {
+          dataIndex: dataIndex,
+          isFrom: true,
+          during: cfgDuringCall
+        };
+        isInit ? initProps(el, transFromProps, seriesModel, cfg) : updateProps(el, transFromProps, seriesModel, cfg);
+      }
+    } // See [STRATEGY_TRANSITION]
+
+
+    function prepareShapeOrExtraTransitionFrom(mainAttr, el, morphFromEl, elOption, transFromProps, isInit) {
+      var attrOpt = elOption[mainAttr];
+
+      if (!attrOpt) {
+        return;
+      }
+
+      var elPropsInAttr = el[mainAttr];
+      var transFromPropsInAttr;
+      var enterFrom = attrOpt.enterFrom;
+
+      if (isInit && enterFrom) {
+        !transFromPropsInAttr && (transFromPropsInAttr = transFromProps[mainAttr] = {});
+        var enterFromKeys = keys(enterFrom);
+
+        for (var i = 0; i < enterFromKeys.length; i++) {
+          // `enterFrom` props are not necessarily also declared in `shape`/`style`/...,
+          // for example, `opacity` can only declared in `enterFrom` but not in `style`.
+          var key = enterFromKeys[i]; // Do not clone, animator will perform that clone.
+
+          transFromPropsInAttr[key] = enterFrom[key];
+        }
+      }
+
+      if (!isInit && elPropsInAttr // Just ignore shape animation in morphing.
+      && !(morphFromEl != null && mainAttr === 'shape')) {
+        if (attrOpt.transition) {
+          !transFromPropsInAttr && (transFromPropsInAttr = transFromProps[mainAttr] = {});
+          var transitionKeys = normalizeToArray(attrOpt.transition);
+
+          for (var i = 0; i < transitionKeys.length; i++) {
+            var key = transitionKeys[i];
+            var elVal = elPropsInAttr[key];
+
+            if ("development" !== 'production') {
+              checkNonStyleTansitionRefer(key, attrOpt[key], elVal);
+            } // Do not clone, see `checkNonStyleTansitionRefer`.
+
+
+            transFromPropsInAttr[key] = elVal;
+          }
+        } else if (indexOf(elOption.transition, mainAttr) >= 0) {
+          !transFromPropsInAttr && (transFromPropsInAttr = transFromProps[mainAttr] = {});
+          var elPropsInAttrKeys = keys(elPropsInAttr);
+
+          for (var i = 0; i < elPropsInAttrKeys.length; i++) {
+            var key = elPropsInAttrKeys[i];
+            var elVal = elPropsInAttr[key];
+
+            if (isNonStyleTransitionEnabled(attrOpt[key], elVal)) {
+              transFromPropsInAttr[key] = elVal;
+            }
+          }
+        }
+      }
+
+      var leaveTo = attrOpt.leaveTo;
+
+      if (leaveTo) {
+        var leaveToProps = getOrCreateLeaveToPropsFromEl(el);
+        var leaveToPropsInAttr = leaveToProps[mainAttr] || (leaveToProps[mainAttr] = {});
+        var leaveToKeys = keys(leaveTo);
+
+        for (var i = 0; i < leaveToKeys.length; i++) {
+          var key = leaveToKeys[i];
+          leaveToPropsInAttr[key] = leaveTo[key];
+        }
+      }
+    }
+
+    function prepareShapeOrExtraAllPropsFinal(mainAttr, elOption, allProps) {
+      var attrOpt = elOption[mainAttr];
+
+      if (!attrOpt) {
+        return;
+      }
+
+      var allPropsInAttr = allProps[mainAttr] = {};
+      var keysInAttr = keys(attrOpt);
+
+      for (var i = 0; i < keysInAttr.length; i++) {
+        var key = keysInAttr[i]; // To avoid share one object with different element, and
+        // to avoid user modify the object inexpectedly, have to clone.
+
+        allPropsInAttr[key] = cloneValue(attrOpt[key]);
+      }
+    } // See [STRATEGY_TRANSITION].
+
+
+    function prepareTransformTransitionFrom(el, morphFromEl, elOption, transFromProps, isInit) {
+      var enterFrom = elOption.enterFrom;
+
+      if (isInit && enterFrom) {
+        var enterFromKeys = keys(enterFrom);
+
+        for (var i = 0; i < enterFromKeys.length; i++) {
+          var key = enterFromKeys[i];
+
+          if ("development" !== 'production') {
+            checkTransformPropRefer(key, 'el.enterFrom');
+          } // Do not clone, animator will perform that clone.
+
+
+          transFromProps[key] = enterFrom[key];
+        }
+      }
+
+      if (!isInit) {
+        // If morphing, force transition all transform props.
+        // otherwise might have incorrect morphing animation.
+        if (morphFromEl) {
+          var fromTransformable = calcOldElLocalTransformBasedOnNewElParent(morphFromEl, el);
+          setTransformPropToTransitionFrom(transFromProps, 'x', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'y', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'scaleX', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'scaleY', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'originX', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'originY', fromTransformable);
+          setTransformPropToTransitionFrom(transFromProps, 'rotation', fromTransformable);
+        } else if (elOption.transition) {
+          var transitionKeys = normalizeToArray(elOption.transition);
+
+          for (var i = 0; i < transitionKeys.length; i++) {
+            var key = transitionKeys[i];
+
+            if (key === 'style' || key === 'shape' || key === 'extra') {
+              continue;
+            }
+
+            var elVal = el[key];
+
+            if ("development" !== 'production') {
+              checkTransformPropRefer(key, 'el.transition');
+              checkNonStyleTansitionRefer(key, elOption[key], elVal);
+            } // Do not clone, see `checkNonStyleTansitionRefer`.
+
+
+            transFromProps[key] = elVal;
+          }
+        } // This default transition see [STRATEGY_TRANSITION]
+        else {
+            setTransformPropToTransitionFrom(transFromProps, 'x', el);
+            setTransformPropToTransitionFrom(transFromProps, 'y', el);
+          }
+      }
+
+      var leaveTo = elOption.leaveTo;
+
+      if (leaveTo) {
+        var leaveToProps = getOrCreateLeaveToPropsFromEl(el);
+        var leaveToKeys = keys(leaveTo);
+
+        for (var i = 0; i < leaveToKeys.length; i++) {
+          var key = leaveToKeys[i];
+
+          if ("development" !== 'production') {
+            checkTransformPropRefer(key, 'el.leaveTo');
+          }
+
+          leaveToProps[key] = leaveTo[key];
+        }
+      }
+    }
+
+    function prepareTransformAllPropsFinal(elOption, allProps) {
+      setLagecyTransformProp(elOption, allProps, 'position');
+      setLagecyTransformProp(elOption, allProps, 'scale');
+      setLagecyTransformProp(elOption, allProps, 'origin');
+      setTransformProp(elOption, allProps, 'x');
+      setTransformProp(elOption, allProps, 'y');
+      setTransformProp(elOption, allProps, 'scaleX');
+      setTransformProp(elOption, allProps, 'scaleY');
+      setTransformProp(elOption, allProps, 'originX');
+      setTransformProp(elOption, allProps, 'originY');
+      setTransformProp(elOption, allProps, 'rotation');
+    } // See [STRATEGY_TRANSITION].
+
+
+    function prepareStyleTransitionFrom(el, morphFromEl, elOption, styleOpt, transFromProps, isInit) {
+      if (!styleOpt) {
+        return;
+      } // At present in "many-to-one"/"one-to-many" case, to not support "many" have
+      // different styles and make style transitions. That might be a rare case.
+
+
+      var fromEl = morphFromEl || el;
+      var fromElStyle = fromEl.style;
+      var transFromStyleProps;
+      var enterFrom = styleOpt.enterFrom;
+
+      if (isInit && enterFrom) {
+        var enterFromKeys = keys(enterFrom);
+        !transFromStyleProps && (transFromStyleProps = transFromProps.style = {});
+
+        for (var i = 0; i < enterFromKeys.length; i++) {
+          var key = enterFromKeys[i]; // Do not clone, animator will perform that clone.
+
+          transFromStyleProps[key] = enterFrom[key];
+        }
+      }
+
+      if (!isInit && fromElStyle) {
+        if (styleOpt.transition) {
+          var transitionKeys = normalizeToArray(styleOpt.transition);
+          !transFromStyleProps && (transFromStyleProps = transFromProps.style = {});
+
+          for (var i = 0; i < transitionKeys.length; i++) {
+            var key = transitionKeys[i];
+            var elVal = fromElStyle[key]; // Do not clone, see `checkNonStyleTansitionRefer`.
+
+            transFromStyleProps[key] = elVal;
+          }
+        } else if (el.getAnimationStyleProps && indexOf(elOption.transition, 'style') >= 0) {
+          var animationProps = el.getAnimationStyleProps();
+          var animationStyleProps = animationProps ? animationProps.style : null;
+
+          if (animationStyleProps) {
+            !transFromStyleProps && (transFromStyleProps = transFromProps.style = {});
+            var styleKeys = keys(styleOpt);
+
+            for (var i = 0; i < styleKeys.length; i++) {
+              var key = styleKeys[i];
+
+              if (animationStyleProps[key]) {
+                var elVal = fromElStyle[key];
+                transFromStyleProps[key] = elVal;
+              }
+            }
+          }
+        }
+      }
+
+      var leaveTo = styleOpt.leaveTo;
+
+      if (leaveTo) {
+        var leaveToKeys = keys(leaveTo);
+        var leaveToProps = getOrCreateLeaveToPropsFromEl(el);
+        var leaveToStyleProps = leaveToProps.style || (leaveToProps.style = {});
+
+        for (var i = 0; i < leaveToKeys.length; i++) {
+          var key = leaveToKeys[i];
+          leaveToStyleProps[key] = leaveTo[key];
+        }
+      }
+    }
+    /**
+     * If make "transform"(x/y/scaleX/scaleY/orient/originX/originY) transition between
+     * two path elements that have different hierarchy, before we retrieve the "from" props,
+     * we have to calculate the local transition of the "oldPath" based on the parent of
+     * the "newPath".
+     * At present, the case only happend in "morphing". Without morphing, the transform
+     * transition are all between elements in the same hierarchy, where this kind of process
+     * is not needed.
+     *
+     * [CAVEAT]:
+     * This method makes sense only if: (very tricky)
+     * (1) "newEl" has been added to its final parent.
+     * (2) Local transform props of "newPath.parent" are not at their final value but already
+     * have been at the "from value".
+     *     This is currently ensured by:
+     *     (2.1) "graphicUtil.animationFrom", which will set the element to the "from value"
+     *     immediately.
+     *     (2.2) "morph" option is not allowed to be set on Group, so all of the groups have
+     *     been finished their "updateElNormal" when calling this method in morphing process.
+     */
+
+
+    function calcOldElLocalTransformBasedOnNewElParent(oldEl, newEl) {
+      if (!oldEl || oldEl === newEl || oldEl.parent === newEl.parent) {
+        return oldEl;
+      } // Not sure oldEl is rendered (may have "lazyUpdate"),
+      // so always call `getComputedTransform`.
+
+
+      var tmpM = tmpTransformable.transform || (tmpTransformable.transform = identity([]));
+      var oldGlobalTransform = oldEl.getComputedTransform();
+      oldGlobalTransform ? copy$1(tmpM, oldGlobalTransform) : identity(tmpM);
+      var newParent = newEl.parent;
+
+      if (newParent) {
+        newParent.getComputedTransform();
+      }
+
+      tmpTransformable.originX = oldEl.originX;
+      tmpTransformable.originY = oldEl.originY;
+      tmpTransformable.parent = newParent;
+      tmpTransformable.decomposeTransform();
+      return tmpTransformable;
+    }
+
+    var checkNonStyleTansitionRefer;
+
+    if ("development" !== 'production') {
+      checkNonStyleTansitionRefer = function (propName, optVal, elVal) {
+        if (!isArrayLike(optVal)) {
+          assert(optVal != null && isFinite(optVal), 'Prop `' + propName + '` must refer to a finite number or ArrayLike for transition.');
+        } else {
+          // Try not to copy array for performance, but if user use the same object in different
+          // call of `renderItem`, it will casue animation transition fail.
+          assert(optVal !== elVal, 'Prop `' + propName + '` must use different Array object each time for transition.');
+        }
+      };
+    }
+
+    function isNonStyleTransitionEnabled(optVal, elVal) {
+      // The same as `checkNonStyleTansitionRefer`.
+      return !isArrayLike(optVal) ? optVal != null && isFinite(optVal) : optVal !== elVal;
+    }
+
+    var checkTransformPropRefer;
+
+    if ("development" !== 'production') {
+      checkTransformPropRefer = function (key, usedIn) {
+        assert(hasOwn(TRANSFORM_PROPS, key), 'Prop `' + key + '` is not a permitted in `' + usedIn + '`. ' + 'Only `' + keys(TRANSFORM_PROPS).join('`, `') + '` are permitted.');
+      };
+    }
+
+    function getOrCreateLeaveToPropsFromEl(el) {
+      var innerEl = inner$b(el);
+      return innerEl.leaveToProps || (innerEl.leaveToProps = {});
+    } // Use it to avoid it be exposed to user.
+
+
+    var tmpDuringScope = {};
+    var customDuringAPI = {
+      // Usually other props do not need to be changed in animation during.
+      setTransform: function (key, val) {
+        if ("development" !== 'production') {
+          assert(hasOwn(TRANSFORM_PROPS, key), 'Only ' + transformPropNamesStr + ' available in `setTransform`.');
+        }
+
+        tmpDuringScope.el[key] = val;
+        return this;
+      },
+      getTransform: function (key) {
+        if ("development" !== 'production') {
+          assert(hasOwn(TRANSFORM_PROPS, key), 'Only ' + transformPropNamesStr + ' available in `getTransform`.');
+        }
+
+        return tmpDuringScope.el[key];
+      },
+      setShape: function (key, val) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var shape = tmpDuringScope.el.shape || (tmpDuringScope.el.shape = {});
+        shape[key] = val;
+        tmpDuringScope.isShapeDirty = true;
+        return this;
+      },
+      getShape: function (key) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var shape = tmpDuringScope.el.shape;
+
+        if (shape) {
+          return shape[key];
+        }
+      },
+      setStyle: function (key, val) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var style = tmpDuringScope.el.style;
+
+        if (style) {
+          if ("development" !== 'production') {
+            if (eqNaN(val)) {
+              warn('style.' + key + ' must not be assigned with NaN.');
+            }
+          }
+
+          style[key] = val;
+          tmpDuringScope.isStyleDirty = true;
+        }
+
+        return this;
+      },
+      getStyle: function (key) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var style = tmpDuringScope.el.style;
+
+        if (style) {
+          return style[key];
+        }
+      },
+      setExtra: function (key, val) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var extra = tmpDuringScope.el.extra || (tmpDuringScope.el.extra = {});
+        extra[key] = val;
+        return this;
+      },
+      getExtra: function (key) {
+        if ("development" !== 'production') {
+          assertNotReserved(key);
+        }
+
+        var extra = tmpDuringScope.el.extra;
+
+        if (extra) {
+          return extra[key];
+        }
+      }
+    };
+
+    function assertNotReserved(key) {
+      if ("development" !== 'production') {
+        if (key === 'transition' || key === 'enterFrom' || key === 'leaveTo') {
+          throw new Error('key must not be "' + key + '"');
+        }
+      }
+    }
+
+    function duringCall() {
+      // Do not provide "percent" until some requirements come.
+      // Because consider thies case:
+      // enterFrom: {x: 100, y: 30}, transition: 'x'.
+      // And enter duration is different from update duration.
+      // Thus it might be confused about the meaning of "percent" in during callback.
+      var scope = this;
+      var el = scope.el;
+
+      if (!el) {
+        return;
+      } // If el is remove from zr by reason like legend, during still need to called,
+      // becuase el will be added back to zr and the prop value should not be incorrect.
+
+
+      var newstUserDuring = inner$b(el).userDuring;
+      var scopeUserDuring = scope.userDuring; // Ensured a during is only called once in each animation frame.
+      // If a during is called multiple times in one frame, maybe some users' calulation logic
+      // might be wrong (not sure whether this usage exists).
+      // The case of a during might be called twice can be: by default there is a animator for
+      // 'x', 'y' when init. Before the init animation finished, call `setOption` to start
+      // another animators for 'style'/'shape'/'extra'.
+
+      if (newstUserDuring !== scopeUserDuring) {
+        // release
+        scope.el = scope.userDuring = null;
+        return;
+      }
+
+      tmpDuringScope.el = el;
+      tmpDuringScope.isShapeDirty = false;
+      tmpDuringScope.isStyleDirty = false; // Give no `this` to user in "during" calling.
+
+      scopeUserDuring(customDuringAPI);
+
+      if (tmpDuringScope.isShapeDirty && el.dirtyShape) {
+        el.dirtyShape();
+      }
+
+      if (tmpDuringScope.isStyleDirty && el.dirtyStyle) {
+        el.dirtyStyle();
+      } // markRedraw() will be called by default in during.
+      // FIXME `this.markRedraw();` directly ?
+      // FIXME: if in future meet the case that some prop will be both modified in `during` and `state`,
+      // consider the issue that the prop might be incorrect when return to "normal" state.
+
+    }
+
+    function updateElOnState(state, el, elStateOpt, styleOpt, attachedTxInfo, isRoot, isTextContent) {
+      var elDisplayable = el.isGroup ? null : el;
+      var txCfgOpt = attachedTxInfo && attachedTxInfo[state].cfg; // PENDING:5.0 support customize scale change and transition animation?
+
+      if (elDisplayable) {
+        // By default support auto lift color when hover whether `emphasis` specified.
+        var stateObj = elDisplayable.ensureState(state);
+
+        if (styleOpt === false) {
+          var existingEmphasisState = elDisplayable.getState(state);
+
+          if (existingEmphasisState) {
+            existingEmphasisState.style = null;
+          }
+        } else {
+          // style is needed to enable defaut emphasis.
+          stateObj.style = styleOpt || null;
+        } // If `elOption.styleEmphasis` or `elOption.emphasis.style` is `false`,
+        // remove hover style.
+        // If `elOption.textConfig` or `elOption.emphasis.textConfig` is null/undefined, it does not
+        // make sense. So for simplicity, we do not ditinguish `hasOwnProperty` and null/undefined.
+
+
+        if (txCfgOpt) {
+          stateObj.textConfig = txCfgOpt;
+        }
+
+        setDefaultStateProxy(elDisplayable);
+      }
+    }
+
+    function updateZ$1(el, elOption, seriesModel, attachedTxInfo) {
+      // Group not support textContent and not support z yet.
+      if (el.isGroup) {
+        return;
+      }
+
+      var elDisplayable = el;
+      var currentZ = seriesModel.currentZ;
+      var currentZLevel = seriesModel.currentZLevel; // Always erase.
+
+      elDisplayable.z = currentZ;
+      elDisplayable.zlevel = currentZLevel; // z2 must not be null/undefined, otherwise sort error may occur.
+
+      var optZ2 = elOption.z2;
+      optZ2 != null && (elDisplayable.z2 = optZ2 || 0);
+
+      for (var i = 0; i < STATES.length; i++) {
+        updateZForEachState(elDisplayable, elOption, STATES[i]);
+      }
+    }
+
+    function updateZForEachState(elDisplayable, elOption, state) {
+      var isNormal = state === NORMAL;
+      var elStateOpt = isNormal ? elOption : retrieveStateOption(elOption, state);
+      var optZ2 = elStateOpt ? elStateOpt.z2 : null;
+      var stateObj;
+
+      if (optZ2 != null) {
+        // Do not `ensureState` until required.
+        stateObj = isNormal ? elDisplayable : elDisplayable.ensureState(state);
+        stateObj.z2 = optZ2 || 0;
+      }
+    }
+
+    function setLagecyTransformProp(elOption, targetProps, legacyName, fromTransformable // If provided, retrieve from the element.
+    ) {
+      var legacyArr = elOption[legacyName];
+      var xyName = LEGACY_TRANSFORM_PROPS[legacyName];
+
+      if (legacyArr) {
+        if (fromTransformable) {
+          targetProps[xyName[0]] = fromTransformable[xyName[0]];
+          targetProps[xyName[1]] = fromTransformable[xyName[1]];
+        } else {
+          targetProps[xyName[0]] = legacyArr[0];
+          targetProps[xyName[1]] = legacyArr[1];
+        }
+      }
+    }
+
+    function setTransformProp(elOption, allProps, name, fromTransformable // If provided, retrieve from the element.
+    ) {
+      if (elOption[name] != null) {
+        allProps[name] = fromTransformable ? fromTransformable[name] : elOption[name];
+      }
+    }
+
+    function setTransformPropToTransitionFrom(transitionFrom, name, fromTransformable // If provided, retrieve from the element.
+    ) {
+      if (fromTransformable) {
+        transitionFrom[name] = fromTransformable[name];
+      }
+    }
+
+    function makeRenderItem(customSeries, data, ecModel, api) {
+      var renderItem = customSeries.get('renderItem');
+      var coordSys = customSeries.coordinateSystem;
+      var prepareResult = {};
+
+      if (coordSys) {
+        if ("development" !== 'production') {
+          assert(renderItem, 'series.render is required.');
+          assert(coordSys.prepareCustoms || prepareCustoms[coordSys.type], 'This coordSys does not support custom series.');
+        } // `coordSys.prepareCustoms` is used for external coord sys like bmap.
+
+
+        prepareResult = coordSys.prepareCustoms ? coordSys.prepareCustoms(coordSys) : prepareCustoms[coordSys.type](coordSys);
+      }
+
+      var userAPI = defaults({
+        getWidth: api.getWidth,
+        getHeight: api.getHeight,
+        getZr: api.getZr,
+        getDevicePixelRatio: api.getDevicePixelRatio,
+        value: value,
+        style: style,
+        ordinalRawValue: ordinalRawValue,
+        styleEmphasis: styleEmphasis,
+        visual: visual,
+        barLayout: barLayout,
+        currentSeriesIndices: currentSeriesIndices,
+        font: font
+      }, prepareResult.api || {});
+      var userParams = {
+        // The life cycle of context: current round of rendering.
+        // The global life cycle is probably not necessary, because
+        // user can store global status by themselves.
+        context: {},
+        seriesId: customSeries.id,
+        seriesName: customSeries.name,
+        seriesIndex: customSeries.seriesIndex,
+        coordSys: prepareResult.coordSys,
+        dataInsideLength: data.count(),
+        encode: wrapEncodeDef(customSeries.getData())
+      }; // If someday intending to refactor them to a class, should consider do not
+      // break change: currently these attribute member are encapsulated in a closure
+      // so that do not need to force user to call these method with a scope.
+      // Do not support call `api` asynchronously without dataIndexInside input.
+
+      var currDataIndexInside;
+      var currItemModel;
+      var currItemStyleModels = {};
+      var currLabelModels = {};
+      var seriesItemStyleModels = {};
+      var seriesLabelModels = {};
+
+      for (var i = 0; i < STATES.length; i++) {
+        var stateName = STATES[i];
+        seriesItemStyleModels[stateName] = customSeries.getModel(PATH_ITEM_STYLE[stateName]);
+        seriesLabelModels[stateName] = customSeries.getModel(PATH_LABEL[stateName]);
+      }
+
+      function getItemModel(dataIndexInside) {
+        return dataIndexInside === currDataIndexInside ? currItemModel || (currItemModel = data.getItemModel(dataIndexInside)) : data.getItemModel(dataIndexInside);
+      }
+
+      function getItemStyleModel(dataIndexInside, state) {
+        return !data.hasItemOption ? seriesItemStyleModels[state] : dataIndexInside === currDataIndexInside ? currItemStyleModels[state] || (currItemStyleModels[state] = getItemModel(dataIndexInside).getModel(PATH_ITEM_STYLE[state])) : getItemModel(dataIndexInside).getModel(PATH_ITEM_STYLE[state]);
+      }
+
+      function getLabelModel(dataIndexInside, state) {
+        return !data.hasItemOption ? seriesLabelModels[state] : dataIndexInside === currDataIndexInside ? currLabelModels[state] || (currLabelModels[state] = getItemModel(dataIndexInside).getModel(PATH_LABEL[state])) : getItemModel(dataIndexInside).getModel(PATH_LABEL[state]);
+      }
+
+      return function (dataIndexInside, payload) {
+        currDataIndexInside = dataIndexInside;
+        currItemModel = null;
+        currItemStyleModels = {};
+        currLabelModels = {};
+        return renderItem && renderItem(defaults({
+          dataIndexInside: dataIndexInside,
+          dataIndex: data.getRawIndex(dataIndexInside),
+          // Can be used for optimization when zoom or roam.
+          actionType: payload ? payload.type : null
+        }, userParams), userAPI);
+      };
+      /**
+       * @public
+       * @param dim by default 0.
+       * @param dataIndexInside by default `currDataIndexInside`.
+       */
+
+      function value(dim, dataIndexInside) {
+        dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+        return data.get(data.getDimension(dim || 0), dataIndexInside);
+      }
+      /**
+       * @public
+       * @param dim by default 0.
+       * @param dataIndexInside by default `currDataIndexInside`.
+       */
+
+
+      function ordinalRawValue(dim, dataIndexInside) {
+        dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+        var dimInfo = data.getDimensionInfo(dim || 0);
+
+        if (!dimInfo) {
+          return;
+        }
+
+        var val = data.get(dimInfo.name, dataIndexInside);
+        var ordinalMeta = dimInfo && dimInfo.ordinalMeta;
+        return ordinalMeta ? ordinalMeta.categories[val] : val;
+      }
+      /**
+       * @deprecated The orgininal intention of `api.style` is enable to set itemStyle
+       * like other series. But it not necessary and not easy to give a strict definition
+       * of what it return. And since echarts5 it needs to be make compat work. So
+       * deprecates it since echarts5.
+       *
+       * By default, `visual` is applied to style (to support visualMap).
+       * `visual.color` is applied at `fill`. If user want apply visual.color on `stroke`,
+       * it can be implemented as:
+       * `api.style({stroke: api.visual('color'), fill: null})`;
+       *
+       * [Compat]: since ec5, RectText has been separated from its hosts el.
+       * so `api.style()` will only return the style from `itemStyle` but not handle `label`
+       * any more. But `series.label` config is never published in doc.
+       * We still compat it in `api.style()`. But not encourage to use it and will still not
+       * to pulish it to doc.
+       * @public
+       * @param dataIndexInside by default `currDataIndexInside`.
+       */
+
+
+      function style(userProps, dataIndexInside) {
+        if ("development" !== 'production') {
+          warnDeprecated('api.style', 'Please write literal style directly instead.');
+        }
+
+        dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+        var style = data.getItemVisual(dataIndexInside, 'style');
+        var visualColor = style && style.fill;
+        var opacity = style && style.opacity;
+        var itemStyle = getItemStyleModel(dataIndexInside, NORMAL).getItemStyle();
+        visualColor != null && (itemStyle.fill = visualColor);
+        opacity != null && (itemStyle.opacity = opacity);
+        var opt = {
+          inheritColor: isString(visualColor) ? visualColor : '#000'
+        };
+        var labelModel = getLabelModel(dataIndexInside, NORMAL); // Now that the feture of "auto adjust text fill/stroke" has been migrated to zrender
+        // since ec5, we should set `isAttached` as `false` here and make compat in
+        // `convertToEC4StyleForCustomSerise`.
+
+        var textStyle = createTextStyle(labelModel, null, opt, false, true);
+        textStyle.text = labelModel.getShallow('show') ? retrieve2(customSeries.getFormattedLabel(dataIndexInside, NORMAL), getDefaultLabel(data, dataIndexInside)) : null;
+        var textConfig = createTextConfig(labelModel, opt, false);
+        preFetchFromExtra(userProps, itemStyle);
+        itemStyle = convertToEC4StyleForCustomSerise(itemStyle, textStyle, textConfig);
+        userProps && applyUserPropsAfter(itemStyle, userProps);
+        itemStyle.legacy = true;
+        return itemStyle;
+      }
+      /**
+       * @deprecated The reason see `api.style()`
+       * @public
+       * @param dataIndexInside by default `currDataIndexInside`.
+       */
+
+
+      function styleEmphasis(userProps, dataIndexInside) {
+        if ("development" !== 'production') {
+          warnDeprecated('api.styleEmphasis', 'Please write literal style directly instead.');
+        }
+
+        dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+        var itemStyle = getItemStyleModel(dataIndexInside, EMPHASIS).getItemStyle();
+        var labelModel = getLabelModel(dataIndexInside, EMPHASIS);
+        var textStyle = createTextStyle(labelModel, null, null, true, true);
+        textStyle.text = labelModel.getShallow('show') ? retrieve3(customSeries.getFormattedLabel(dataIndexInside, EMPHASIS), customSeries.getFormattedLabel(dataIndexInside, NORMAL), getDefaultLabel(data, dataIndexInside)) : null;
+        var textConfig = createTextConfig(labelModel, null, true);
+        preFetchFromExtra(userProps, itemStyle);
+        itemStyle = convertToEC4StyleForCustomSerise(itemStyle, textStyle, textConfig);
+        userProps && applyUserPropsAfter(itemStyle, userProps);
+        itemStyle.legacy = true;
+        return itemStyle;
+      }
+
+      function applyUserPropsAfter(itemStyle, extra) {
+        for (var key in extra) {
+          if (hasOwn(extra, key)) {
+            itemStyle[key] = extra[key];
+          }
+        }
+      }
+
+      function preFetchFromExtra(extra, itemStyle) {
+        // A trick to retrieve those props firstly, which are used to
+        // apply auto inside fill/stroke in `convertToEC4StyleForCustomSerise`.
+        // (It's not reasonable but only for a degree of compat)
+        if (extra) {
+          extra.textFill && (itemStyle.textFill = extra.textFill);
+          extra.textPosition && (itemStyle.textPosition = extra.textPosition);
+        }
+      }
+      /**
+       * @public
+       * @param dataIndexInside by default `currDataIndexInside`.
+       */
+
+
+      function visual(visualType, dataIndexInside) {
+        dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+
+        if (hasOwn(STYLE_VISUAL_TYPE, visualType)) {
+          var style_1 = data.getItemVisual(dataIndexInside, 'style');
+          return style_1 ? style_1[STYLE_VISUAL_TYPE[visualType]] : null;
+        } // Only support these visuals. Other visual might be inner tricky
+        // for performance (like `style`), do not expose to users.
+
+
+        if (hasOwn(NON_STYLE_VISUAL_PROPS, visualType)) {
+          return data.getItemVisual(dataIndexInside, visualType);
+        }
+      }
+      /**
+       * @public
+       * @return If not support, return undefined.
+       */
+
+
+      function barLayout(opt) {
+        if (coordSys.type === 'cartesian2d') {
+          var baseAxis = coordSys.getBaseAxis();
+          return getLayoutOnAxis(defaults({
+            axis: baseAxis
+          }, opt));
+        }
+      }
+      /**
+       * @public
+       */
+
+
+      function currentSeriesIndices() {
+        return ecModel.getCurrentSeriesIndices();
+      }
+      /**
+       * @public
+       * @return font string
+       */
+
+
+      function font(opt) {
+        return getFont(opt, ecModel);
+      }
+    }
+
+    function wrapEncodeDef(data) {
+      var encodeDef = {};
+      each(data.dimensions, function (dimName, dataDimIndex) {
+        var dimInfo = data.getDimensionInfo(dimName);
+
+        if (!dimInfo.isExtraCoord) {
+          var coordDim = dimInfo.coordDim;
+          var dataDims = encodeDef[coordDim] = encodeDef[coordDim] || [];
+          dataDims[dimInfo.coordDimIndex] = dataDimIndex;
+        }
+      });
+      return encodeDef;
+    }
+
+    function createOrUpdateItem(api, el, dataIndex, elOption, seriesModel, group, data, morphPreparation) {
+      // [Rule]
+      // If `renderItem` returns `null`/`undefined`/`false`, remove the previous el if existing.
+      //     (It seems that violate the "merge" principle, but most of users probably intuitively
+      //     regard "return;" as "show nothing element whatever", so make a exception to meet the
+      //     most cases.)
+      // The rule or "merge" see [STRATEGY_MERGE].
+      // If `elOption` is `null`/`undefined`/`false` (when `renderItem` returns nothing).
+      if (!elOption) {
+        removeElementDirectly(el, group);
+        return;
+      }
+
+      el = doCreateOrUpdateEl(api, el, dataIndex, elOption, seriesModel, group, true, morphPreparation);
+      el && data.setItemGraphicEl(dataIndex, el);
+      enableHoverEmphasis(el, elOption.focus, elOption.blurScope);
+      return el;
+    }
+
+    function doCreateOrUpdateEl(api, el, dataIndex, elOption, seriesModel, group, isRoot, morphPreparation) {
+      if ("development" !== 'production') {
+        assert(elOption, 'should not have an null/undefined element setting');
+      }
+
+      var toBeReplacedIdx = -1;
+
+      if (el && doesElNeedRecreate(el, elOption) // || (
+      //     // PENDING: even in one-to-one mapping case, if el is marked as morph,
+      //     // do not sure whether the el will be mapped to another el with different
+      //     // hierarchy in Group tree. So always recreate el rather than reuse the el.
+      //     morphPreparation && morphPreparation.isOneToOneFrom(el)
+      // )
+      ) {
+        // Should keep at the original index, otherwise "merge by index" will be incorrect.
+        toBeReplacedIdx = group.childrenRef().indexOf(el);
+        el = null;
+      }
+
+      var elIsNewCreated = !el;
+
+      if (!el) {
+        el = createEl(elOption);
+      } else {
+        // FIMXE:NEXT unified clearState?
+        // If in some case the performance issue arised, consider
+        // do not clearState but update cached normal state directly.
+        el.clearStates();
+      }
+
+      var canMorph = inner$b(el).canMorph = elOption.morph && isPath$1(el);
+      var thisElIsMorphTo = canMorph && morphPreparation && morphPreparation.hasFrom(); // Use update animation when morph is enabled.
+
+      var isInit = elIsNewCreated && !thisElIsMorphTo;
+      attachedTxInfoTmp.normal.cfg = attachedTxInfoTmp.normal.conOpt = attachedTxInfoTmp.emphasis.cfg = attachedTxInfoTmp.emphasis.conOpt = attachedTxInfoTmp.blur.cfg = attachedTxInfoTmp.blur.conOpt = attachedTxInfoTmp.select.cfg = attachedTxInfoTmp.select.conOpt = null;
+      attachedTxInfoTmp.isLegacy = false;
+      doCreateOrUpdateAttachedTx(el, dataIndex, elOption, seriesModel, isInit, attachedTxInfoTmp);
+      doCreateOrUpdateClipPath(el, dataIndex, elOption, seriesModel, isInit);
+      var pendingAllPropsFinal = updateElNormal(api, el, thisElIsMorphTo, dataIndex, elOption, elOption.style, attachedTxInfoTmp, seriesModel, isInit, false);
+
+      if (thisElIsMorphTo) {
+        morphPreparation.addTo(el, elOption, dataIndex, pendingAllPropsFinal);
+      }
+
+      for (var i = 0; i < STATES.length; i++) {
+        var stateName = STATES[i];
+
+        if (stateName !== NORMAL) {
+          var otherStateOpt = retrieveStateOption(elOption, stateName);
+          var otherStyleOpt = retrieveStyleOptionOnState(elOption, otherStateOpt, stateName);
+          updateElOnState(stateName, el, otherStateOpt, otherStyleOpt, attachedTxInfoTmp);
+        }
+      }
+
+      updateZ$1(el, elOption, seriesModel);
+
+      if (elOption.type === 'group') {
+        mergeChildren(api, el, dataIndex, elOption, seriesModel, morphPreparation);
+      }
+
+      if (toBeReplacedIdx >= 0) {
+        group.replaceAt(el, toBeReplacedIdx);
+      } else {
+        group.add(el);
+      }
+
+      return el;
+    } // `el` must not be null/undefined.
+
+
+    function doesElNeedRecreate(el, elOption) {
+      var elInner = inner$b(el);
+      var elOptionType = elOption.type;
+      var elOptionShape = elOption.shape;
+      var elOptionStyle = elOption.style;
+      return (// If `elOptionType` is `null`, follow the merge principle.
+        elOptionType != null && elOptionType !== elInner.customGraphicType || elOptionType === 'path' && hasOwnPathData(elOptionShape) && getPathData(elOptionShape) !== elInner.customPathData || elOptionType === 'image' && hasOwn(elOptionStyle, 'image') && elOptionStyle.image !== elInner.customImagePath // // FIXME test and remove this restriction?
+        // || (elOptionType === 'text'
+        //     && hasOwn(elOptionStyle, 'text')
+        //     && (elOptionStyle as TextStyleProps).text !== elInner.customText
+        // )
+
+      );
+    }
+
+    function doCreateOrUpdateClipPath(el, dataIndex, elOption, seriesModel, isInit) {
+      // Based on the "merge" principle, if no clipPath provided,
+      // do nothing. The exists clip will be totally removed only if
+      // `el.clipPath` is `false`. Otherwise it will be merged/replaced.
+      var clipPathOpt = elOption.clipPath;
+
+      if (clipPathOpt === false) {
+        if (el && el.getClipPath()) {
+          el.removeClipPath();
+        }
+      } else if (clipPathOpt) {
+        var clipPath = el.getClipPath();
+
+        if (clipPath && doesElNeedRecreate(clipPath, clipPathOpt)) {
+          clipPath = null;
+        }
+
+        if (!clipPath) {
+          clipPath = createEl(clipPathOpt);
+
+          if ("development" !== 'production') {
+            assert(clipPath instanceof Path, 'Only any type of `path` can be used in `clipPath`, rather than ' + clipPath.type + '.');
+          }
+
+          el.setClipPath(clipPath);
+        }
+
+        updateElNormal(null, clipPath, null, dataIndex, clipPathOpt, null, null, seriesModel, isInit, false);
+      } // If not define `clipPath` in option, do nothing unnecessary.
+
+    }
+
+    function doCreateOrUpdateAttachedTx(el, dataIndex, elOption, seriesModel, isInit, attachedTxInfo) {
+      // group do not support textContent temporarily untill necessary.
+      if (el.isGroup) {
+        return;
+      } // Normal must be called before emphasis, for `isLegacy` detection.
+
+
+      processTxInfo(elOption, null, attachedTxInfo);
+      processTxInfo(elOption, EMPHASIS, attachedTxInfo); // If `elOption.textConfig` or `elOption.textContent` is null/undefined, it does not make sence.
+      // So for simplicity, if "elOption hasOwnProperty of them but be null/undefined", we do not
+      // trade them as set to null to el.
+      // Especially:
+      // `elOption.textContent: false` means remove textContent.
+      // `elOption.textContent.emphasis.style: false` means remove the style from emphasis state.
+
+      var txConOptNormal = attachedTxInfo.normal.conOpt;
+      var txConOptEmphasis = attachedTxInfo.emphasis.conOpt;
+      var txConOptBlur = attachedTxInfo.blur.conOpt;
+      var txConOptSelect = attachedTxInfo.select.conOpt;
+
+      if (txConOptNormal != null || txConOptEmphasis != null || txConOptSelect != null || txConOptBlur != null) {
+        var textContent = el.getTextContent();
+
+        if (txConOptNormal === false) {
+          textContent && el.removeTextContent();
+        } else {
+          txConOptNormal = attachedTxInfo.normal.conOpt = txConOptNormal || {
+            type: 'text'
+          };
+
+          if (!textContent) {
+            textContent = createEl(txConOptNormal);
+            el.setTextContent(textContent);
+          } else {
+            // If in some case the performance issue arised, consider
+            // do not clearState but update cached normal state directly.
+            textContent.clearStates();
+          }
+
+          var txConStlOptNormal = txConOptNormal && txConOptNormal.style;
+          updateElNormal(null, textContent, null, dataIndex, txConOptNormal, txConStlOptNormal, null, seriesModel, isInit, true);
+
+          for (var i = 0; i < STATES.length; i++) {
+            var stateName = STATES[i];
+
+            if (stateName !== NORMAL) {
+              var txConOptOtherState = attachedTxInfo[stateName].conOpt;
+              updateElOnState(stateName, textContent, txConOptOtherState, retrieveStyleOptionOnState(txConOptNormal, txConOptOtherState, stateName), null);
+            }
+          }
+
+          txConStlOptNormal ? textContent.dirty() : textContent.markRedraw();
+        }
+      }
+    }
+
+    function processTxInfo(elOption, state, attachedTxInfo) {
+      var stateOpt = !state ? elOption : retrieveStateOption(elOption, state);
+      var styleOpt = !state ? elOption.style : retrieveStyleOptionOnState(elOption, stateOpt, EMPHASIS);
+      var elType = elOption.type;
+      var txCfg = stateOpt ? stateOpt.textConfig : null;
+      var txConOptNormal = elOption.textContent;
+      var txConOpt = !txConOptNormal ? null : !state ? txConOptNormal : retrieveStateOption(txConOptNormal, state);
+
+      if (styleOpt && ( // Because emphasis style has little info to detect legacy,
+      // if normal is legacy, emphasis is trade as legacy.
+      attachedTxInfo.isLegacy || isEC4CompatibleStyle(styleOpt, elType, !!txCfg, !!txConOpt))) {
+        attachedTxInfo.isLegacy = true;
+        var convertResult = convertFromEC4CompatibleStyle(styleOpt, elType, !state); // Explicitly specified `textConfig` and `textContent` has higher priority than
+        // the ones generated by legacy style. Otherwise if users use them and `api.style`
+        // at the same time, they not both work and hardly to known why.
+
+        if (!txCfg && convertResult.textConfig) {
+          txCfg = convertResult.textConfig;
+        }
+
+        if (!txConOpt && convertResult.textContent) {
+          txConOpt = convertResult.textContent;
+        }
+      }
+
+      if (!state && txConOpt) {
+        var txConOptNormal_1 = txConOpt; // `textContent: {type: 'text'}`, the "type" is easy to be missing. So we tolerate it.
+
+        !txConOptNormal_1.type && (txConOptNormal_1.type = 'text');
+
+        if ("development" !== 'production') {
+          // Do not tolerate incorret type for forward compat.
+          txConOptNormal_1.type !== 'text' && assert(txConOptNormal_1.type === 'text', 'textContent.type must be "text"');
+        }
+      }
+
+      var info = !state ? attachedTxInfo.normal : attachedTxInfo[state];
+      info.cfg = txCfg;
+      info.conOpt = txConOpt;
+    }
+
+    function retrieveStateOption(elOption, state) {
+      return !state ? elOption : elOption ? elOption[state] : null;
+    }
+
+    function retrieveStyleOptionOnState(stateOptionNormal, stateOption, state) {
+      var style = stateOption && stateOption.style;
+
+      if (style == null && state === EMPHASIS && stateOptionNormal) {
+        style = stateOptionNormal.styleEmphasis;
+      }
+
+      return style;
+    } // Usage:
+    // (1) By default, `elOption.$mergeChildren` is `'byIndex'`, which indicates that
+    //     the existing children will not be removed, and enables the feature that
+    //     update some of the props of some of the children simply by construct
+    //     the returned children of `renderItem` like:
+    //     `var children = group.children = []; children[3] = {opacity: 0.5};`
+    // (2) If `elOption.$mergeChildren` is `'byName'`, add/update/remove children
+    //     by child.name. But that might be lower performance.
+    // (3) If `elOption.$mergeChildren` is `false`, the existing children will be
+    //     replaced totally.
+    // (4) If `!elOption.children`, following the "merge" principle, nothing will happen.
+    //
+    // For implementation simpleness, do not provide a direct way to remove sinlge
+    // child (otherwise the total indicies of the children array have to be modified).
+    // User can remove a single child by set its `ignore` as `true`.
+
+
+    function mergeChildren(api, el, dataIndex, elOption, seriesModel, morphPreparation) {
+      var newChildren = elOption.children;
+      var newLen = newChildren ? newChildren.length : 0;
+      var mergeChildren = elOption.$mergeChildren; // `diffChildrenByName` has been deprecated.
+
+      var byName = mergeChildren === 'byName' || elOption.diffChildrenByName;
+      var notMerge = mergeChildren === false; // For better performance on roam update, only enter if necessary.
+
+      if (!newLen && !byName && !notMerge) {
+        return;
+      }
+
+      if (byName) {
+        diffGroupChildren({
+          api: api,
+          oldChildren: el.children() || [],
+          newChildren: newChildren || [],
+          dataIndex: dataIndex,
+          seriesModel: seriesModel,
+          group: el,
+          morphPreparation: morphPreparation
+        });
+        return;
+      }
+
+      notMerge && el.removeAll(); // Mapping children of a group simply by index, which
+      // might be better performance.
+
+      var index = 0;
+
+      for (; index < newLen; index++) {
+        newChildren[index] && doCreateOrUpdateEl(api, el.childAt(index), dataIndex, newChildren[index], seriesModel, el, false, morphPreparation);
+      }
+
+      for (var i = el.childCount() - 1; i >= index; i--) {
+        // Do not supprot leave elements that are not mentioned in the latest
+        // `renderItem` return. Otherwise users may not have a clear and simple
+        // concept that how to contorl all of the elements.
+        doRemoveEl(el.childAt(i), seriesModel, el);
+      }
+    }
+
+    function diffGroupChildren(context) {
+      new DataDiffer(context.oldChildren, context.newChildren, getKey, getKey, context).add(processAddUpdate).update(processAddUpdate).remove(processRemove).execute();
+    }
+
+    function getKey(item, idx) {
+      var name = item && item.name;
+      return name != null ? name : GROUP_DIFF_PREFIX + idx;
+    }
+
+    function processAddUpdate(newIndex, oldIndex) {
+      var context = this.context;
+      var childOption = newIndex != null ? context.newChildren[newIndex] : null;
+      var child = oldIndex != null ? context.oldChildren[oldIndex] : null;
+      doCreateOrUpdateEl(context.api, child, context.dataIndex, childOption, context.seriesModel, context.group, false, context.morphPreparation);
+    }
+
+    function processRemove(oldIndex) {
+      var context = this.context;
+      var child = context.oldChildren[oldIndex];
+      doRemoveEl(child, context.seriesModel, context.group);
+    }
+
+    function doRemoveEl(el, seriesModel, group) {
+      if (el) {
+        var leaveToProps = inner$b(el).leaveToProps;
+        leaveToProps ? updateProps(el, leaveToProps, seriesModel, {
+          cb: function () {
+            group.remove(el);
+          }
+        }) : group.remove(el);
+      }
+    }
+    /**
+     * @return SVG Path data.
+     */
+
+
+    function getPathData(shape) {
+      // "d" follows the SVG convention.
+      return shape && (shape.pathData || shape.d);
+    }
+
+    function hasOwnPathData(shape) {
+      return shape && (hasOwn(shape, 'pathData') || hasOwn(shape, 'd'));
+    }
+
+    function isPath$1(el) {
+      return el && el instanceof Path;
+    }
+
+    function removeElementDirectly(el, group) {
+      el && group.remove(el);
+    }
+    /**
+     * Any morph-potential el should added by `morphPreparation.addTo(el)`.
+     * And they may apply morph or not when `morphPreparation.applyMorphing()`.
+     * But at least, all of the "to" elements will apply all of the updates
+     * as `doCreateOrUpdateItem` did.
+     */
+
+
+    var MorphPreparation =
+    /** @class */
+    function () {
+      function MorphPreparation(seriesModel, transOpt) {
+        this._fromList = [];
+        this._toList = [];
+        this._toElOptionList = [];
+        this._allPropsFinalList = [];
+        this._toDataIndices = []; // Key: `toDataIndex`, not `toIdx`
+
+        this._morphConfigList = [];
+        this._seriesModel = seriesModel;
+        this._transOpt = transOpt;
+      }
+
+      MorphPreparation.prototype.hasFrom = function () {
+        return !!this._fromList.length;
+      }; // isOneToOneFrom(el: Element): boolean {
+      //     if (el && inner(el).canMorph) {
+      //         const fromList = this._fromList;
+      //         for (let i = 0; i < fromList.length; i++) {
+      //             if (fromList[i] === el) {
+      //                 return true;
+      //             }
+      //         }
+      //     }
+      // }
+
+
+      MorphPreparation.prototype.findAndAddFrom = function (el) {
+        if (!el) {
+          return;
+        }
+
+        if (inner$b(el).canMorph) {
+          this._fromList.push(el);
+        }
+
+        if (el.isGroup) {
+          var children = el.childrenRef();
+
+          for (var i = 0; i < children.length; i++) {
+            this.findAndAddFrom(children[i]);
+          }
+        }
+      };
+
+      MorphPreparation.prototype.addTo = function (path, elOption, dataIndex, allPropsFinal) {
+        if (path) {
+          this._toList.push(path);
+
+          this._toElOptionList.push(elOption);
+
+          this._toDataIndices.push(dataIndex);
+
+          this._allPropsFinalList.push(allPropsFinal);
+        }
+      };
+
+      MorphPreparation.prototype.applyMorphing = function () {
+        // [MORPHING_LOGIC_HINT]
+        // Pay attention to the order:
+        // (A) Apply `allPropsFinal` and `styleOption` to "to".
+        //     (Then "to" becomes to the final state.)
+        // (B) Apply `morphPath`/`combine`/`separate`.
+        //     (Based on the current state of "from" and the final state of "to".)
+        //     (Then we may get "from.subList" or "to.subList".)
+        // (C) Copy the related props from "from" to "from.subList", from "to" to "to.subList".
+        // (D) Collect `transitionFromProps` for "to" and "to.subList"
+        //     (Based on "from" or "from.subList".)
+        // (E) Apply `transitionFromProps` to "to" and "to.subList"
+        //     (It might change the prop values to the first frame value.)
+        // Case_I:
+        //     If (D) should be after (C), we use sequence: A - B - C - D - E
+        // Case_II:
+        //     If (A) should be after (D), we use sequence: D - A - B - C - E
+        // [MORPHING_LOGIC_HINT]
+        // zrender `morphPath`/`combine`/`separate` only manages the shape animation.
+        // Other props (like transfrom, style transition) will handled in echarts).
+        // [MORPHING_LOGIC_HINT]
+        // Make sure `applyPropsFinal` always be called for "to".
+        var type = this._type;
+        var fromList = this._fromList;
+        var toList = this._toList;
+        var toListLen = toList.length;
+        var fromListLen = fromList.length;
+
+        if (!fromListLen || !toListLen) {
+          return;
+        }
+
+        if (type === 'oneToOne') {
+          // In one-to-one case, we by default apply a simple rule:
+          // map "from" and "to" one by one.
+          // For this case: old_data_item_el and new_data_item_el
+          // has the same hierarchy of group tree but only some path type changed.
+          for (var toIdx = 0; toIdx < toListLen; toIdx++) {
+            this._oneToOneForSingleTo(toIdx, toIdx);
+          }
+        } else if (type === 'manyToOne') {
+          // A rough strategy: if there are more than one "to", we simply divide "fromList" equally.
+          var fromSingleSegLen = Math.max(1, Math.floor(fromListLen / toListLen));
+
+          for (var toIdx = 0, fromIdxStart = 0; toIdx < toListLen; toIdx++, fromIdxStart += fromSingleSegLen) {
+            var fromCount = toIdx + 1 >= toListLen ? fromListLen - fromIdxStart : fromSingleSegLen;
+
+            this._manyToOneForSingleTo(toIdx, fromIdxStart >= fromListLen ? null : fromIdxStart, fromCount);
+          }
+        } else if (type === 'oneToMany') {
+          // A rough strategy: if there are more than one "from", we simply divide "toList" equally.
+          var toSingleSegLen = Math.max(1, Math.floor(toListLen / fromListLen));
+
+          for (var toIdxStart = 0, fromIdx = 0; toIdxStart < toListLen; toIdxStart += toSingleSegLen, fromIdx++) {
+            var toCount = toIdxStart + toSingleSegLen >= toListLen ? toListLen - toIdxStart : toSingleSegLen;
+
+            this._oneToManyForSingleFrom(toIdxStart, toCount, fromIdx >= fromListLen ? null : fromIdx);
+          }
+        }
+      };
+
+      MorphPreparation.prototype._oneToOneForSingleTo = function ( // "to" must NOT be null/undefined.
+      toIdx, // May `fromIdx >= this._fromList.length`
+      fromIdx) {
+        var to = this._toList[toIdx];
+        var toElOption = this._toElOptionList[toIdx];
+        var toDataIndex = this._toDataIndices[toIdx];
+        var allPropsFinal = this._allPropsFinalList[toIdx];
+        var from = this._fromList[fromIdx];
+
+        var elAnimationConfig = this._getOrCreateMorphConfig(toDataIndex);
+
+        var morphDuration = elAnimationConfig.duration;
+
+        if (from && isCombiningPath(from)) {
+          applyPropsFinal(to, allPropsFinal, toElOption.style);
+
+          if (morphDuration) {
+            var combineResult = combine([from], to, elAnimationConfig, copyPropsWhenDivided);
+
+            this._processResultIndividuals(combineResult, toIdx, null);
+          } // The target el will not be displayed and transition from multiple path.
+          // transition on the target el does not make sense.
+
+        } else {
+          var morphFrom = morphDuration // from === to usually happen in scenarios where internal update like
+          // "dataZoom", "legendToggle" happen. If from is not in any morphing,
+          // we do not need to call `morphPath`.
+          && from && (from !== to || isInAnyMorphing(from)) ? from : null; // See [Case_II] above.
+          // In this case, there is probably `from === to`. And the `transitionFromProps` collecting
+          // does not depends on morphing. So we collect `transitionFromProps` first.
+
+          var transFromProps = {};
+          prepareShapeOrExtraTransitionFrom('shape', to, morphFrom, toElOption, transFromProps, false);
+          prepareShapeOrExtraTransitionFrom('extra', to, morphFrom, toElOption, transFromProps, false);
+          prepareTransformTransitionFrom(to, morphFrom, toElOption, transFromProps, false);
+          prepareStyleTransitionFrom(to, morphFrom, toElOption, toElOption.style, transFromProps, false);
+          applyPropsFinal(to, allPropsFinal, toElOption.style);
+
+          if (morphFrom) {
+            morphPath(morphFrom, to, elAnimationConfig);
+          }
+
+          applyTransitionFrom(to, toDataIndex, toElOption, this._seriesModel, transFromProps, false);
+        }
+      };
+
+      MorphPreparation.prototype._manyToOneForSingleTo = function ( // "to" must NOT be null/undefined.
+      toIdx, // May be null.
+      fromIdxStart, fromCount) {
+        var to = this._toList[toIdx];
+        var toElOption = this._toElOptionList[toIdx];
+        var allPropsFinal = this._allPropsFinalList[toIdx];
+        applyPropsFinal(to, allPropsFinal, toElOption.style);
+
+        var elAnimationConfig = this._getOrCreateMorphConfig(this._toDataIndices[toIdx]);
+
+        if (elAnimationConfig.duration && fromIdxStart != null) {
+          var combineFromList = [];
+
+          for (var fromIdx = fromIdxStart; fromIdx < fromCount; fromIdx++) {
+            combineFromList.push(this._fromList[fromIdx]);
+          }
+
+          var combineResult = combine(combineFromList, to, elAnimationConfig, copyPropsWhenDivided);
+
+          this._processResultIndividuals(combineResult, toIdx, null);
+        }
+      };
+
+      MorphPreparation.prototype._oneToManyForSingleFrom = function ( // "to" must NOT be null/undefined.
+      toIdxStart, toCount, // May be null
+      fromIdx) {
+        var from = fromIdx == null ? null : this._fromList[fromIdx];
+        var toList = this._toList;
+        var separateToList = [];
+
+        for (var toIdx = toIdxStart; toIdx < toCount; toIdx++) {
+          var to = toList[toIdx];
+          applyPropsFinal(to, this._allPropsFinalList[toIdx], this._toElOptionList[toIdx].style);
+          separateToList.push(to);
+        }
+
+        var elAnimationConfig = this._getOrCreateMorphConfig(this._toDataIndices[toIdxStart]);
+
+        if (elAnimationConfig.duration && from) {
+          var separateResult = separate(from, separateToList, elAnimationConfig, copyPropsWhenDivided);
+
+          this._processResultIndividuals(separateResult, toIdxStart, toCount);
+        }
+      };
+
+      MorphPreparation.prototype._processResultIndividuals = function (combineSeparateResult, toIdxStart, toCount) {
+        var isSeparate = toCount != null;
+
+        for (var i = 0; i < combineSeparateResult.count; i++) {
+          var fromIndividual = combineSeparateResult.fromIndividuals[i];
+          var toIndividual = combineSeparateResult.toIndividuals[i]; // Here it's a trick:
+          // For "combine" case, all of the `toIndividuals` map to the same `toIdx`.
+          // For "separate" case, the `toIndividuals` map to some certain segment of `_toList` accurately.
+
+          var toIdx = toIdxStart + (isSeparate ? i : 0);
+          var toElOption = this._toElOptionList[toIdx];
+          var dataIndex = this._toDataIndices[toIdx];
+          var transFromProps = {};
+          prepareTransformTransitionFrom(toIndividual, fromIndividual, toElOption, transFromProps, false);
+          prepareStyleTransitionFrom(toIndividual, fromIndividual, toElOption, toElOption.style, transFromProps, false);
+          applyTransitionFrom(toIndividual, dataIndex, toElOption, this._seriesModel, transFromProps, false);
+        }
+      };
+
+      MorphPreparation.prototype._getOrCreateMorphConfig = function (dataIndex) {
+        var morphConfigList = this._morphConfigList;
+        var config = morphConfigList[dataIndex];
+
+        if (config) {
+          return config;
+        }
+
+        var duration;
+        var easing;
+        var delay;
+        var seriesModel = this._seriesModel;
+        var transOpt = this._transOpt;
+
+        if (seriesModel.isAnimationEnabled()) {
+          // PENDING: refactor? this is the same logic as `src/util/graphic.ts#animateOrSetProps`.
+          var animationPayload = void 0;
+
+          if (seriesModel && seriesModel.ecModel) {
+            var updatePayload = seriesModel.ecModel.getUpdatePayload();
+            animationPayload = updatePayload && updatePayload.animation;
+          }
+
+          if (animationPayload) {
+            duration = animationPayload.duration || 0;
+            easing = animationPayload.easing || 'cubicOut';
+            delay = animationPayload.delay || 0;
+          } else {
+            easing = seriesModel.get('animationEasingUpdate');
+            var delayOption = seriesModel.get('animationDelayUpdate');
+            delay = isFunction(delayOption) ? delayOption(dataIndex) : delayOption;
+            var durationOption = seriesModel.get('animationDurationUpdate');
+            duration = isFunction(durationOption) ? durationOption(dataIndex) : durationOption;
+          }
+        }
+
+        config = {
+          duration: duration || 0,
+          delay: delay,
+          easing: easing,
+          dividingMethod: transOpt ? transOpt.dividingMethod : null
+        };
+        morphConfigList[dataIndex] = config;
+        return config;
+      };
+
+      MorphPreparation.prototype.reset = function (type) {
+        // `this._morphConfigList` can be kept. It only related to `dataIndex`.
+        this._type = type;
+        this._fromList.length = this._toList.length = this._toElOptionList.length = this._allPropsFinalList.length = this._toDataIndices.length = 0;
+      };
+
+      return MorphPreparation;
+    }();
+
+    function copyPropsWhenDivided(srcPath, tarPath, willClone) {
+      // Do not copy transform props.
+      // Sub paths are transfrom based on their host path.
+      // tarPath.x = srcPath.x;
+      // tarPath.y = srcPath.y;
+      // tarPath.scaleX = srcPath.scaleX;
+      // tarPath.scaleY = srcPath.scaleY;
+      // tarPath.originX = srcPath.originX;
+      // tarPath.originY = srcPath.originY;
+      // If just carry the style, will not be modifed, so do not copy.
+      tarPath.style = willClone ? clone(srcPath.style) : srcPath.style;
+      tarPath.zlevel = srcPath.zlevel;
+      tarPath.z = srcPath.z;
+      tarPath.z2 = srcPath.z2;
+    }
+
+    function install$r(registers) {
+      registers.registerChartView(CustomSeriesView);
+      registers.registerSeriesModel(CustomSeriesModel);
+    }
+
+    var inner$c = makeInner();
+    var clone$3 = clone;
+    var bind$1 = bind;
+    /**
+     * Base axis pointer class in 2D.
+     */
+
+    var BaseAxisPointer =
+    /** @class */
+    function () {
+      function BaseAxisPointer() {
+        this._dragging = false;
+        /**
+         * In px, arbitrary value. Do not set too small,
+         * no animation is ok for most cases.
+         */
+
+        this.animationThreshold = 15;
+      }
+      /**
+       * @implement
+       */
+
+
+      BaseAxisPointer.prototype.render = function (axisModel, axisPointerModel, api, forceRender) {
+        var value = axisPointerModel.get('value');
+        var status = axisPointerModel.get('status'); // Bind them to `this`, not in closure, otherwise they will not
+        // be replaced when user calling setOption in not merge mode.
+
+        this._axisModel = axisModel;
+        this._axisPointerModel = axisPointerModel;
+        this._api = api; // Optimize: `render` will be called repeatly during mouse move.
+        // So it is power consuming if performing `render` each time,
+        // especially on mobile device.
+
+        if (!forceRender && this._lastValue === value && this._lastStatus === status) {
+          return;
+        }
+
+        this._lastValue = value;
+        this._lastStatus = status;
+        var group = this._group;
+        var handle = this._handle;
+
+        if (!status || status === 'hide') {
+          // Do not clear here, for animation better.
+          group && group.hide();
+          handle && handle.hide();
+          return;
+        }
+
+        group && group.show();
+        handle && handle.show(); // Otherwise status is 'show'
+
+        var elOption = {};
+        this.makeElOption(elOption, value, axisModel, axisPointerModel, api); // Enable change axis pointer type.
+
+        var graphicKey = elOption.graphicKey;
+
+        if (graphicKey !== this._lastGraphicKey) {
+          this.clear(api);
+        }
+
+        this._lastGraphicKey = graphicKey;
+        var moveAnimation = this._moveAnimation = this.determineAnimation(axisModel, axisPointerModel);
+
+        if (!group) {
+          group = this._group = new Group();
+          this.createPointerEl(group, elOption, axisModel, axisPointerModel);
+          this.createLabelEl(group, elOption, axisModel, axisPointerModel);
+          api.getZr().add(group);
+        } else {
+          var doUpdateProps = curry(updateProps$1, axisPointerModel, moveAnimation);
+          this.updatePointerEl(group, elOption, doUpdateProps);
+          this.updateLabelEl(group, elOption, doUpdateProps, axisPointerModel);
+        }
+
+        updateMandatoryProps(group, axisPointerModel, true);
+
+        this._renderHandle(value);
+      };
+      /**
+       * @implement
+       */
+
+
+      BaseAxisPointer.prototype.remove = function (api) {
+        this.clear(api);
+      };
+      /**
+       * @implement
+       */
+
+
+      BaseAxisPointer.prototype.dispose = function (api) {
+        this.clear(api);
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.determineAnimation = function (axisModel, axisPointerModel) {
+        var animation = axisPointerModel.get('animation');
+        var axis = axisModel.axis;
+        var isCategoryAxis = axis.type === 'category';
+        var useSnap = axisPointerModel.get('snap'); // Value axis without snap always do not snap.
+
+        if (!useSnap && !isCategoryAxis) {
+          return false;
+        }
+
+        if (animation === 'auto' || animation == null) {
+          var animationThreshold = this.animationThreshold;
+
+          if (isCategoryAxis && axis.getBandWidth() > animationThreshold) {
+            return true;
+          } // It is important to auto animation when snap used. Consider if there is
+          // a dataZoom, animation will be disabled when too many points exist, while
+          // it will be enabled for better visual effect when little points exist.
+
+
+          if (useSnap) {
+            var seriesDataCount = getAxisInfo(axisModel).seriesDataCount;
+            var axisExtent = axis.getExtent(); // Approximate band width
+
+            return Math.abs(axisExtent[0] - axisExtent[1]) / seriesDataCount > animationThreshold;
+          }
+
+          return false;
+        }
+
+        return animation === true;
+      };
+      /**
+       * add {pointer, label, graphicKey} to elOption
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {// Shoule be implemenented by sub-class.
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.createPointerEl = function (group, elOption, axisModel, axisPointerModel) {
+        var pointerOption = elOption.pointer;
+
+        if (pointerOption) {
+          var pointerEl = inner$c(group).pointerEl = new graphic[pointerOption.type](clone$3(elOption.pointer));
+          group.add(pointerEl);
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.createLabelEl = function (group, elOption, axisModel, axisPointerModel) {
+        if (elOption.label) {
+          var labelEl = inner$c(group).labelEl = new ZRText(clone$3(elOption.label));
+          group.add(labelEl);
+          updateLabelShowHide(labelEl, axisPointerModel);
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.updatePointerEl = function (group, elOption, updateProps) {
+        var pointerEl = inner$c(group).pointerEl;
+
+        if (pointerEl && elOption.pointer) {
+          pointerEl.setStyle(elOption.pointer.style);
+          updateProps(pointerEl, {
+            shape: elOption.pointer.shape
+          });
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.updateLabelEl = function (group, elOption, updateProps, axisPointerModel) {
+        var labelEl = inner$c(group).labelEl;
+
+        if (labelEl) {
+          labelEl.setStyle(elOption.label.style);
+          updateProps(labelEl, {
+            // Consider text length change in vertical axis, animation should
+            // be used on shape, otherwise the effect will be weird.
+            // TODOTODO
+            // shape: elOption.label.shape,
+            x: elOption.label.x,
+            y: elOption.label.y
+          });
+          updateLabelShowHide(labelEl, axisPointerModel);
+        }
+      };
+      /**
+       * @private
+       */
+
+
+      BaseAxisPointer.prototype._renderHandle = function (value) {
+        if (this._dragging || !this.updateHandleTransform) {
+          return;
+        }
+
+        var axisPointerModel = this._axisPointerModel;
+
+        var zr = this._api.getZr();
+
+        var handle = this._handle;
+        var handleModel = axisPointerModel.getModel('handle');
+        var status = axisPointerModel.get('status');
+
+        if (!handleModel.get('show') || !status || status === 'hide') {
+          handle && zr.remove(handle);
+          this._handle = null;
+          return;
+        }
+
+        var isInit;
+
+        if (!this._handle) {
+          isInit = true;
+          handle = this._handle = createIcon(handleModel.get('icon'), {
+            cursor: 'move',
+            draggable: true,
+            onmousemove: function (e) {
+              // Fot mobile devicem, prevent screen slider on the button.
+              stop(e.event);
+            },
+            onmousedown: bind$1(this._onHandleDragMove, this, 0, 0),
+            drift: bind$1(this._onHandleDragMove, this),
+            ondragend: bind$1(this._onHandleDragEnd, this)
+          });
+          zr.add(handle);
+        }
+
+        updateMandatoryProps(handle, axisPointerModel, false); // update style
+
+        handle.setStyle(handleModel.getItemStyle(null, ['color', 'borderColor', 'borderWidth', 'opacity', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY'])); // update position
+
+        var handleSize = handleModel.get('size');
+
+        if (!isArray(handleSize)) {
+          handleSize = [handleSize, handleSize];
+        }
+
+        handle.scaleX = handleSize[0] / 2;
+        handle.scaleY = handleSize[1] / 2;
+        createOrUpdate(this, '_doDispatchAxisPointer', handleModel.get('throttle') || 0, 'fixRate');
+
+        this._moveHandleToValue(value, isInit);
+      };
+
+      BaseAxisPointer.prototype._moveHandleToValue = function (value, isInit) {
+        updateProps$1(this._axisPointerModel, !isInit && this._moveAnimation, this._handle, getHandleTransProps(this.getHandleTransform(value, this._axisModel, this._axisPointerModel)));
+      };
+
+      BaseAxisPointer.prototype._onHandleDragMove = function (dx, dy) {
+        var handle = this._handle;
+
+        if (!handle) {
+          return;
+        }
+
+        this._dragging = true; // Persistent for throttle.
+
+        var trans = this.updateHandleTransform(getHandleTransProps(handle), [dx, dy], this._axisModel, this._axisPointerModel);
+        this._payloadInfo = trans;
+        handle.stopAnimation();
+        handle.attr(getHandleTransProps(trans));
+        inner$c(handle).lastProp = null;
+
+        this._doDispatchAxisPointer();
+      };
+      /**
+       * Throttled method.
+       */
+
+
+      BaseAxisPointer.prototype._doDispatchAxisPointer = function () {
+        var handle = this._handle;
+
+        if (!handle) {
+          return;
+        }
+
+        var payloadInfo = this._payloadInfo;
+        var axisModel = this._axisModel;
+
+        this._api.dispatchAction({
+          type: 'updateAxisPointer',
+          x: payloadInfo.cursorPoint[0],
+          y: payloadInfo.cursorPoint[1],
+          tooltipOption: payloadInfo.tooltipOption,
+          axesInfo: [{
+            axisDim: axisModel.axis.dim,
+            axisIndex: axisModel.componentIndex
+          }]
+        });
+      };
+
+      BaseAxisPointer.prototype._onHandleDragEnd = function () {
+        this._dragging = false;
+        var handle = this._handle;
+
+        if (!handle) {
+          return;
+        }
+
+        var value = this._axisPointerModel.get('value'); // Consider snap or categroy axis, handle may be not consistent with
+        // axisPointer. So move handle to align the exact value position when
+        // drag ended.
+
+
+        this._moveHandleToValue(value); // For the effect: tooltip will be shown when finger holding on handle
+        // button, and will be hidden after finger left handle button.
+
+
+        this._api.dispatchAction({
+          type: 'hideTip'
+        });
+      };
+      /**
+       * @private
+       */
+
+
+      BaseAxisPointer.prototype.clear = function (api) {
+        this._lastValue = null;
+        this._lastStatus = null;
+        var zr = api.getZr();
+        var group = this._group;
+        var handle = this._handle;
+
+        if (zr && group) {
+          this._lastGraphicKey = null;
+          group && zr.remove(group);
+          handle && zr.remove(handle);
+          this._group = null;
+          this._handle = null;
+          this._payloadInfo = null;
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      BaseAxisPointer.prototype.doClear = function () {// Implemented by sub-class if necessary.
+      };
+
+      BaseAxisPointer.prototype.buildLabel = function (xy, wh, xDimIndex) {
+        xDimIndex = xDimIndex || 0;
+        return {
+          x: xy[xDimIndex],
+          y: xy[1 - xDimIndex],
+          width: wh[xDimIndex],
+          height: wh[1 - xDimIndex]
+        };
+      };
+
+      return BaseAxisPointer;
+    }();
+
+    function updateProps$1(animationModel, moveAnimation, el, props) {
+      // Animation optimize.
+      if (!propsEqual(inner$c(el).lastProp, props)) {
+        inner$c(el).lastProp = props;
+        moveAnimation ? updateProps(el, props, animationModel) : (el.stopAnimation(), el.attr(props));
+      }
+    }
+
+    function propsEqual(lastProps, newProps) {
+      if (isObject(lastProps) && isObject(newProps)) {
+        var equals_1 = true;
+        each(newProps, function (item, key) {
+          equals_1 = equals_1 && propsEqual(lastProps[key], item);
+        });
+        return !!equals_1;
+      } else {
+        return lastProps === newProps;
+      }
+    }
+
+    function updateLabelShowHide(labelEl, axisPointerModel) {
+      labelEl[axisPointerModel.get(['label', 'show']) ? 'show' : 'hide']();
+    }
+
+    function getHandleTransProps(trans) {
+      return {
+        x: trans.x || 0,
+        y: trans.y || 0,
+        rotation: trans.rotation || 0
+      };
+    }
+
+    function updateMandatoryProps(group, axisPointerModel, silent) {
+      var z = axisPointerModel.get('z');
+      var zlevel = axisPointerModel.get('zlevel');
+      group && group.traverse(function (el) {
+        if (el.type !== 'group') {
+          z != null && (el.z = z);
+          zlevel != null && (el.zlevel = zlevel);
+          el.silent = silent;
+        }
+      });
+    }
+
+    function buildElStyle(axisPointerModel) {
+      var axisPointerType = axisPointerModel.get('type');
+      var styleModel = axisPointerModel.getModel(axisPointerType + 'Style');
+      var style;
+
+      if (axisPointerType === 'line') {
+        style = styleModel.getLineStyle();
+        style.fill = null;
+      } else if (axisPointerType === 'shadow') {
+        style = styleModel.getAreaStyle();
+        style.stroke = null;
+      }
+
+      return style;
+    }
+    /**
+     * @param {Function} labelPos {align, verticalAlign, position}
+     */
+
+    function buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos) {
+      var value = axisPointerModel.get('value');
+      var text = getValueLabel(value, axisModel.axis, axisModel.ecModel, axisPointerModel.get('seriesDataIndices'), {
+        precision: axisPointerModel.get(['label', 'precision']),
+        formatter: axisPointerModel.get(['label', 'formatter'])
+      });
+      var labelModel = axisPointerModel.getModel('label');
+      var paddings = normalizeCssArray$1(labelModel.get('padding') || 0);
+      var font = labelModel.getFont();
+      var textRect = getBoundingRect(text, font);
+      var position = labelPos.position;
+      var width = textRect.width + paddings[1] + paddings[3];
+      var height = textRect.height + paddings[0] + paddings[2]; // Adjust by align.
+
+      var align = labelPos.align;
+      align === 'right' && (position[0] -= width);
+      align === 'center' && (position[0] -= width / 2);
+      var verticalAlign = labelPos.verticalAlign;
+      verticalAlign === 'bottom' && (position[1] -= height);
+      verticalAlign === 'middle' && (position[1] -= height / 2); // Not overflow ec container
+
+      confineInContainer(position, width, height, api);
+      var bgColor = labelModel.get('backgroundColor');
+
+      if (!bgColor || bgColor === 'auto') {
+        bgColor = axisModel.get(['axisLine', 'lineStyle', 'color']);
+      }
+
+      elOption.label = {
+        // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')},
+        x: position[0],
+        y: position[1],
+        style: createTextStyle(labelModel, {
+          text: text,
+          font: font,
+          fill: labelModel.getTextColor(),
+          padding: paddings,
+          backgroundColor: bgColor
+        }),
+        // Lable should be over axisPointer.
+        z2: 10
+      };
+    } // Do not overflow ec container
+
+    function confineInContainer(position, width, height, api) {
+      var viewWidth = api.getWidth();
+      var viewHeight = api.getHeight();
+      position[0] = Math.min(position[0] + width, viewWidth) - width;
+      position[1] = Math.min(position[1] + height, viewHeight) - height;
+      position[0] = Math.max(position[0], 0);
+      position[1] = Math.max(position[1], 0);
+    }
+
+    function getValueLabel(value, axis, ecModel, seriesDataIndices, opt) {
+      value = axis.scale.parse(value);
+      var text = axis.scale.getLabel({
+        value: value
+      }, {
+        // If `precision` is set, width can be fixed (like '12.00500'), which
+        // helps to debounce when when moving label.
+        precision: opt.precision
+      });
+      var formatter = opt.formatter;
+
+      if (formatter) {
+        var params_1 = {
+          value: getAxisRawValue(axis, {
+            value: value
+          }),
+          axisDimension: axis.dim,
+          axisIndex: axis.index,
+          seriesData: []
+        };
+        each(seriesDataIndices, function (idxItem) {
+          var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+          var dataIndex = idxItem.dataIndexInside;
+          var dataParams = series && series.getDataParams(dataIndex);
+          dataParams && params_1.seriesData.push(dataParams);
+        });
+
+        if (isString(formatter)) {
+          text = formatter.replace('{value}', text);
+        } else if (isFunction(formatter)) {
+          text = formatter(params_1);
+        }
+      }
+
+      return text;
+    }
+    function getTransformedPosition(axis, value, layoutInfo) {
+      var transform = create$1();
+      rotate(transform, transform, layoutInfo.rotation);
+      translate(transform, transform, layoutInfo.position);
+      return applyTransform$1([axis.dataToCoord(value), (layoutInfo.labelOffset || 0) + (layoutInfo.labelDirection || 1) * (layoutInfo.labelMargin || 0)], transform);
+    }
+    function buildCartesianSingleLabelElOption(value, elOption, layoutInfo, axisModel, axisPointerModel, api) {
+      // @ts-ignore
+      var textLayout = AxisBuilder.innerTextLayout(layoutInfo.rotation, 0, layoutInfo.labelDirection);
+      layoutInfo.labelMargin = axisPointerModel.get(['label', 'margin']);
+      buildLabelElOption(elOption, axisModel, axisPointerModel, api, {
+        position: getTransformedPosition(axisModel.axis, value, layoutInfo),
+        align: textLayout.textAlign,
+        verticalAlign: textLayout.textVerticalAlign
+      });
+    }
+    function makeLineShape(p1, p2, xDimIndex) {
+      xDimIndex = xDimIndex || 0;
+      return {
+        x1: p1[xDimIndex],
+        y1: p1[1 - xDimIndex],
+        x2: p2[xDimIndex],
+        y2: p2[1 - xDimIndex]
+      };
+    }
+    function makeRectShape(xy, wh, xDimIndex) {
+      xDimIndex = xDimIndex || 0;
+      return {
+        x: xy[xDimIndex],
+        y: xy[1 - xDimIndex],
+        width: wh[xDimIndex],
+        height: wh[1 - xDimIndex]
+      };
+    }
+    function makeSectorShape(cx, cy, r0, r, startAngle, endAngle) {
+      return {
+        cx: cx,
+        cy: cy,
+        r0: r0,
+        r: r,
+        startAngle: startAngle,
+        endAngle: endAngle,
+        clockwise: true
+      };
+    }
+
+    var CartesianAxisPointer =
+    /** @class */
+    function (_super) {
+      __extends(CartesianAxisPointer, _super);
+
+      function CartesianAxisPointer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      /**
+       * @override
+       */
+
+
+      CartesianAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+        var axis = axisModel.axis;
+        var grid = axis.grid;
+        var axisPointerType = axisPointerModel.get('type');
+        var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+        var pixelValue = axis.toGlobalCoord(axis.dataToCoord(value, true));
+
+        if (axisPointerType && axisPointerType !== 'none') {
+          var elStyle = buildElStyle(axisPointerModel);
+          var pointerOption = pointerShapeBuilder[axisPointerType](axis, pixelValue, otherExtent);
+          pointerOption.style = elStyle;
+          elOption.graphicKey = pointerOption.type;
+          elOption.pointer = pointerOption;
+        }
+
+        var layoutInfo = layout$1(grid.model, axisModel);
+        buildCartesianSingleLabelElOption( // @ts-ignore
+        value, elOption, layoutInfo, axisModel, axisPointerModel, api);
+      };
+      /**
+       * @override
+       */
+
+
+      CartesianAxisPointer.prototype.getHandleTransform = function (value, axisModel, axisPointerModel) {
+        var layoutInfo = layout$1(axisModel.axis.grid.model, axisModel, {
+          labelInside: false
+        }); // @ts-ignore
+
+        layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']);
+        var pos = getTransformedPosition(axisModel.axis, value, layoutInfo);
+        return {
+          x: pos[0],
+          y: pos[1],
+          rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
+        };
+      };
+      /**
+       * @override
+       */
+
+
+      CartesianAxisPointer.prototype.updateHandleTransform = function (transform, delta, axisModel, axisPointerModel) {
+        var axis = axisModel.axis;
+        var grid = axis.grid;
+        var axisExtent = axis.getGlobalExtent(true);
+        var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+        var dimIndex = axis.dim === 'x' ? 0 : 1;
+        var currPosition = [transform.x, transform.y];
+        currPosition[dimIndex] += delta[dimIndex];
+        currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]);
+        currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]);
+        var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
+        var cursorPoint = [cursorOtherValue, cursorOtherValue];
+        cursorPoint[dimIndex] = currPosition[dimIndex]; // Make tooltip do not overlap axisPointer and in the middle of the grid.
+
+        var tooltipOptions = [{
+          verticalAlign: 'middle'
+        }, {
+          align: 'center'
+        }];
+        return {
+          x: currPosition[0],
+          y: currPosition[1],
+          rotation: transform.rotation,
+          cursorPoint: cursorPoint,
+          tooltipOption: tooltipOptions[dimIndex]
+        };
+      };
+
+      return CartesianAxisPointer;
+    }(BaseAxisPointer);
+
+    function getCartesian(grid, axis) {
+      var opt = {};
+      opt[axis.dim + 'AxisIndex'] = axis.index;
+      return grid.getCartesian(opt);
+    }
+
+    var pointerShapeBuilder = {
+      line: function (axis, pixelValue, otherExtent) {
+        var targetShape = makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getAxisDimIndex(axis));
+        return {
+          type: 'Line',
+          subPixelOptimize: true,
+          shape: targetShape
+        };
+      },
+      shadow: function (axis, pixelValue, otherExtent) {
+        var bandWidth = Math.max(1, axis.getBandWidth());
+        var span = otherExtent[1] - otherExtent[0];
+        return {
+          type: 'Rect',
+          shape: makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getAxisDimIndex(axis))
+        };
+      }
+    };
+
+    function getAxisDimIndex(axis) {
+      return axis.dim === 'x' ? 0 : 1;
+    }
+
+    var AxisPointerModel =
+    /** @class */
+    function (_super) {
+      __extends(AxisPointerModel, _super);
+
+      function AxisPointerModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = AxisPointerModel.type;
+        return _this;
+      }
+
+      AxisPointerModel.type = 'axisPointer';
+      AxisPointerModel.defaultOption = {
+        // 'auto' means that show when triggered by tooltip or handle.
+        show: 'auto',
+        zlevel: 0,
+        z: 50,
+        type: 'line',
+        // axispointer triggered by tootip determine snap automatically,
+        // see `modelHelper`.
+        snap: false,
+        triggerTooltip: true,
+        value: null,
+        status: null,
+        link: [],
+        // Do not set 'auto' here, otherwise global animation: false
+        // will not effect at this axispointer.
+        animation: null,
+        animationDurationUpdate: 200,
+        lineStyle: {
+          color: '#B9BEC9',
+          width: 1,
+          type: 'dashed'
+        },
+        shadowStyle: {
+          color: 'rgba(210,219,238,0.2)'
+        },
+        label: {
+          show: true,
+          formatter: null,
+          precision: 'auto',
+          margin: 3,
+          color: '#fff',
+          padding: [5, 7, 5, 7],
+          backgroundColor: 'auto',
+          borderColor: null,
+          borderWidth: 0,
+          borderRadius: 3
+        },
+        handle: {
+          show: false,
+          // eslint-disable-next-line
+          icon: 'M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z',
+          size: 45,
+          // handle margin is from symbol center to axis, which is stable when circular move.
+          margin: 50,
+          // color: '#1b8bbd'
+          // color: '#2f4554'
+          color: '#333',
+          shadowBlur: 3,
+          shadowColor: '#aaa',
+          shadowOffsetX: 0,
+          shadowOffsetY: 2,
+          // For mobile performance
+          throttle: 40
+        }
+      };
+      return AxisPointerModel;
+    }(ComponentModel);
+
+    var inner$d = makeInner();
+    var each$8 = each;
+    /**
+     * @param {string} key
+     * @param {module:echarts/ExtensionAPI} api
+     * @param {Function} handler
+     *      param: {string} currTrigger
+     *      param: {Array.<number>} point
+     */
+
+    function register(key, api, handler) {
+      if (env.node) {
+        return;
+      }
+
+      var zr = api.getZr();
+      inner$d(zr).records || (inner$d(zr).records = {});
+      initGlobalListeners(zr, api);
+      var record = inner$d(zr).records[key] || (inner$d(zr).records[key] = {});
+      record.handler = handler;
+    }
+
+    function initGlobalListeners(zr, api) {
+      if (inner$d(zr).initialized) {
+        return;
+      }
+
+      inner$d(zr).initialized = true;
+      useHandler('click', curry(doEnter, 'click'));
+      useHandler('mousemove', curry(doEnter, 'mousemove')); // useHandler('mouseout', onLeave);
+
+      useHandler('globalout', onLeave);
+
+      function useHandler(eventType, cb) {
+        zr.on(eventType, function (e) {
+          var dis = makeDispatchAction(api);
+          each$8(inner$d(zr).records, function (record) {
+            record && cb(record, e, dis.dispatchAction);
+          });
+          dispatchTooltipFinally(dis.pendings, api);
+        });
+      }
+    }
+
+    function dispatchTooltipFinally(pendings, api) {
+      var showLen = pendings.showTip.length;
+      var hideLen = pendings.hideTip.length;
+      var actuallyPayload;
+
+      if (showLen) {
+        actuallyPayload = pendings.showTip[showLen - 1];
+      } else if (hideLen) {
+        actuallyPayload = pendings.hideTip[hideLen - 1];
+      }
+
+      if (actuallyPayload) {
+        actuallyPayload.dispatchAction = null;
+        api.dispatchAction(actuallyPayload);
+      }
+    }
+
+    function onLeave(record, e, dispatchAction) {
+      record.handler('leave', null, dispatchAction);
+    }
+
+    function doEnter(currTrigger, record, e, dispatchAction) {
+      record.handler(currTrigger, e, dispatchAction);
+    }
+
+    function makeDispatchAction(api) {
+      var pendings = {
+        showTip: [],
+        hideTip: []
+      }; // FIXME
+      // better approach?
+      // 'showTip' and 'hideTip' can be triggered by axisPointer and tooltip,
+      // which may be conflict, (axisPointer call showTip but tooltip call hideTip);
+      // So we have to add "final stage" to merge those dispatched actions.
+
+      var dispatchAction = function (payload) {
+        var pendingList = pendings[payload.type];
+
+        if (pendingList) {
+          pendingList.push(payload);
+        } else {
+          payload.dispatchAction = dispatchAction;
+          api.dispatchAction(payload);
+        }
+      };
+
+      return {
+        dispatchAction: dispatchAction,
+        pendings: pendings
+      };
+    }
+
+    function unregister(key, api) {
+      if (env.node) {
+        return;
+      }
+
+      var zr = api.getZr();
+      var record = (inner$d(zr).records || {})[key];
+
+      if (record) {
+        inner$d(zr).records[key] = null;
+      }
+    }
+
+    var AxisPointerView =
+    /** @class */
+    function (_super) {
+      __extends(AxisPointerView, _super);
+
+      function AxisPointerView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = AxisPointerView.type;
+        return _this;
+      }
+
+      AxisPointerView.prototype.render = function (globalAxisPointerModel, ecModel, api) {
+        var globalTooltipModel = ecModel.getComponent('tooltip');
+        var triggerOn = globalAxisPointerModel.get('triggerOn') || globalTooltipModel && globalTooltipModel.get('triggerOn') || 'mousemove|click'; // Register global listener in AxisPointerView to enable
+        // AxisPointerView to be independent to Tooltip.
+
+        register('axisPointer', api, function (currTrigger, e, dispatchAction) {
+          // If 'none', it is not controlled by mouse totally.
+          if (triggerOn !== 'none' && (currTrigger === 'leave' || triggerOn.indexOf(currTrigger) >= 0)) {
+            dispatchAction({
+              type: 'updateAxisPointer',
+              currTrigger: currTrigger,
+              x: e && e.offsetX,
+              y: e && e.offsetY
+            });
+          }
+        });
+      };
+
+      AxisPointerView.prototype.remove = function (ecModel, api) {
+        unregister('axisPointer', api);
+      };
+
+      AxisPointerView.prototype.dispose = function (ecModel, api) {
+        unregister('axisPointer', api);
+      };
+
+      AxisPointerView.type = 'axisPointer';
+      return AxisPointerView;
+    }(ComponentView);
+
+    /**
+     * @param finder contains {seriesIndex, dataIndex, dataIndexInside}
+     * @param ecModel
+     * @return  {point: [x, y], el: ...} point Will not be null.
+     */
+
+    function findPointFromSeries(finder, ecModel) {
+      var point = [];
+      var seriesIndex = finder.seriesIndex;
+      var seriesModel;
+
+      if (seriesIndex == null || !(seriesModel = ecModel.getSeriesByIndex(seriesIndex))) {
+        return {
+          point: []
+        };
+      }
+
+      var data = seriesModel.getData();
+      var dataIndex = queryDataIndex(data, finder);
+
+      if (dataIndex == null || dataIndex < 0 || isArray(dataIndex)) {
+        return {
+          point: []
+        };
+      }
+
+      var el = data.getItemGraphicEl(dataIndex);
+      var coordSys = seriesModel.coordinateSystem;
+
+      if (seriesModel.getTooltipPosition) {
+        point = seriesModel.getTooltipPosition(dataIndex) || [];
+      } else if (coordSys && coordSys.dataToPoint) {
+        if (finder.isStacked) {
+          var baseAxis = coordSys.getBaseAxis();
+          var valueAxis = coordSys.getOtherAxis(baseAxis);
+          var valueAxisDim = valueAxis.dim;
+          var baseAxisDim = baseAxis.dim;
+          var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0;
+          var baseDim = data.mapDimension(baseAxisDim);
+          var stackedData = [];
+          stackedData[baseDataOffset] = data.get(baseDim, dataIndex);
+          stackedData[1 - baseDataOffset] = data.get(data.getCalculationInfo('stackResultDimension'), dataIndex);
+          point = coordSys.dataToPoint(stackedData) || [];
+        } else {
+          point = coordSys.dataToPoint(data.getValues(map(coordSys.dimensions, function (dim) {
+            return data.mapDimension(dim);
+          }), dataIndex)) || [];
+        }
+      } else if (el) {
+        // Use graphic bounding rect
+        var rect = el.getBoundingRect().clone();
+        rect.applyTransform(el.transform);
+        point = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+      }
+
+      return {
+        point: point,
+        el: el
+      };
+    }
+
+    var inner$e = makeInner();
+    /**
+     * Basic logic: check all axis, if they do not demand show/highlight,
+     * then hide/downplay them.
+     *
+     * @return content of event obj for echarts.connect.
+     */
+
+    function axisTrigger(payload, ecModel, api) {
+      var currTrigger = payload.currTrigger;
+      var point = [payload.x, payload.y];
+      var finder = payload;
+      var dispatchAction = payload.dispatchAction || bind(api.dispatchAction, api);
+      var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo; // Pending
+      // See #6121. But we are not able to reproduce it yet.
+
+      if (!coordSysAxesInfo) {
+        return;
+      }
+
+      if (illegalPoint(point)) {
+        // Used in the default behavior of `connection`: use the sample seriesIndex
+        // and dataIndex. And also used in the tooltipView trigger.
+        point = findPointFromSeries({
+          seriesIndex: finder.seriesIndex,
+          // Do not use dataIndexInside from other ec instance.
+          // FIXME: auto detect it?
+          dataIndex: finder.dataIndex
+        }, ecModel).point;
+      }
+
+      var isIllegalPoint = illegalPoint(point); // Axis and value can be specified when calling dispatchAction({type: 'updateAxisPointer'}).
+      // Notice: In this case, it is difficult to get the `point` (which is necessary to show
+      // tooltip, so if point is not given, we just use the point found by sample seriesIndex
+      // and dataIndex.
+
+      var inputAxesInfo = finder.axesInfo;
+      var axesInfo = coordSysAxesInfo.axesInfo;
+      var shouldHide = currTrigger === 'leave' || illegalPoint(point);
+      var outputPayload = {};
+      var showValueMap = {};
+      var dataByCoordSys = {
+        list: [],
+        map: {}
+      };
+      var updaters = {
+        showPointer: curry(showPointer, showValueMap),
+        showTooltip: curry(showTooltip, dataByCoordSys)
+      }; // Process for triggered axes.
+
+      each(coordSysAxesInfo.coordSysMap, function (coordSys, coordSysKey) {
+        // If a point given, it must be contained by the coordinate system.
+        var coordSysContainsPoint = isIllegalPoint || coordSys.containPoint(point);
+        each(coordSysAxesInfo.coordSysAxesInfo[coordSysKey], function (axisInfo, key) {
+          var axis = axisInfo.axis;
+          var inputAxisInfo = findInputAxisInfo(inputAxesInfo, axisInfo); // If no inputAxesInfo, no axis is restricted.
+
+          if (!shouldHide && coordSysContainsPoint && (!inputAxesInfo || inputAxisInfo)) {
+            var val = inputAxisInfo && inputAxisInfo.value;
+
+            if (val == null && !isIllegalPoint) {
+              val = axis.pointToData(point);
+            }
+
+            val != null && processOnAxis(axisInfo, val, updaters, false, outputPayload);
+          }
+        });
+      }); // Process for linked axes.
+
+      var linkTriggers = {};
+      each(axesInfo, function (tarAxisInfo, tarKey) {
+        var linkGroup = tarAxisInfo.linkGroup; // If axis has been triggered in the previous stage, it should not be triggered by link.
+
+        if (linkGroup && !showValueMap[tarKey]) {
+          each(linkGroup.axesInfo, function (srcAxisInfo, srcKey) {
+            var srcValItem = showValueMap[srcKey]; // If srcValItem exist, source axis is triggered, so link to target axis.
+
+            if (srcAxisInfo !== tarAxisInfo && srcValItem) {
+              var val = srcValItem.value;
+              linkGroup.mapper && (val = tarAxisInfo.axis.scale.parse(linkGroup.mapper(val, makeMapperParam(srcAxisInfo), makeMapperParam(tarAxisInfo))));
+              linkTriggers[tarAxisInfo.key] = val;
+            }
+          });
+        }
+      });
+      each(linkTriggers, function (val, tarKey) {
+        processOnAxis(axesInfo[tarKey], val, updaters, true, outputPayload);
+      });
+      updateModelActually(showValueMap, axesInfo, outputPayload);
+      dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction);
+      dispatchHighDownActually(axesInfo, dispatchAction, api);
+      return outputPayload;
+    }
+
+    function processOnAxis(axisInfo, newValue, updaters, noSnap, outputFinder) {
+      var axis = axisInfo.axis;
+
+      if (axis.scale.isBlank() || !axis.containData(newValue)) {
+        return;
+      }
+
+      if (!axisInfo.involveSeries) {
+        updaters.showPointer(axisInfo, newValue);
+        return;
+      } // Heavy calculation. So put it after axis.containData checking.
+
+
+      var payloadInfo = buildPayloadsBySeries(newValue, axisInfo);
+      var payloadBatch = payloadInfo.payloadBatch;
+      var snapToValue = payloadInfo.snapToValue; // Fill content of event obj for echarts.connect.
+      // By default use the first involved series data as a sample to connect.
+
+      if (payloadBatch[0] && outputFinder.seriesIndex == null) {
+        extend(outputFinder, payloadBatch[0]);
+      } // If no linkSource input, this process is for collecting link
+      // target, where snap should not be accepted.
+
+
+      if (!noSnap && axisInfo.snap) {
+        if (axis.containData(snapToValue) && snapToValue != null) {
+          newValue = snapToValue;
+        }
+      }
+
+      updaters.showPointer(axisInfo, newValue, payloadBatch); // Tooltip should always be snapToValue, otherwise there will be
+      // incorrect "axis value ~ series value" mapping displayed in tooltip.
+
+      updaters.showTooltip(axisInfo, payloadInfo, snapToValue);
+    }
+
+    function buildPayloadsBySeries(value, axisInfo) {
+      var axis = axisInfo.axis;
+      var dim = axis.dim;
+      var snapToValue = value;
+      var payloadBatch = [];
+      var minDist = Number.MAX_VALUE;
+      var minDiff = -1;
+      each(axisInfo.seriesModels, function (series, idx) {
+        var dataDim = series.getData().mapDimensionsAll(dim);
+        var seriesNestestValue;
+        var dataIndices;
+
+        if (series.getAxisTooltipData) {
+          var result = series.getAxisTooltipData(dataDim, value, axis);
+          dataIndices = result.dataIndices;
+          seriesNestestValue = result.nestestValue;
+        } else {
+          dataIndices = series.getData().indicesOfNearest(dataDim[0], value, // Add a threshold to avoid find the wrong dataIndex
+          // when data length is not same.
+          // false,
+          axis.type === 'category' ? 0.5 : null);
+
+          if (!dataIndices.length) {
+            return;
+          }
+
+          seriesNestestValue = series.getData().get(dataDim[0], dataIndices[0]);
+        }
+
+        if (seriesNestestValue == null || !isFinite(seriesNestestValue)) {
+          return;
+        }
+
+        var diff = value - seriesNestestValue;
+        var dist = Math.abs(diff); // Consider category case
+
+        if (dist <= minDist) {
+          if (dist < minDist || diff >= 0 && minDiff < 0) {
+            minDist = dist;
+            minDiff = diff;
+            snapToValue = seriesNestestValue;
+            payloadBatch.length = 0;
+          }
+
+          each(dataIndices, function (dataIndex) {
+            payloadBatch.push({
+              seriesIndex: series.seriesIndex,
+              dataIndexInside: dataIndex,
+              dataIndex: series.getData().getRawIndex(dataIndex)
+            });
+          });
+        }
+      });
+      return {
+        payloadBatch: payloadBatch,
+        snapToValue: snapToValue
+      };
+    }
+
+    function showPointer(showValueMap, axisInfo, value, payloadBatch) {
+      showValueMap[axisInfo.key] = {
+        value: value,
+        payloadBatch: payloadBatch
+      };
+    }
+
+    function showTooltip(dataByCoordSys, axisInfo, payloadInfo, value) {
+      var payloadBatch = payloadInfo.payloadBatch;
+      var axis = axisInfo.axis;
+      var axisModel = axis.model;
+      var axisPointerModel = axisInfo.axisPointerModel; // If no data, do not create anything in dataByCoordSys,
+      // whose length will be used to judge whether dispatch action.
+
+      if (!axisInfo.triggerTooltip || !payloadBatch.length) {
+        return;
+      }
+
+      var coordSysModel = axisInfo.coordSys.model;
+      var coordSysKey = makeKey(coordSysModel);
+      var coordSysItem = dataByCoordSys.map[coordSysKey];
+
+      if (!coordSysItem) {
+        coordSysItem = dataByCoordSys.map[coordSysKey] = {
+          coordSysId: coordSysModel.id,
+          coordSysIndex: coordSysModel.componentIndex,
+          coordSysType: coordSysModel.type,
+          coordSysMainType: coordSysModel.mainType,
+          dataByAxis: []
+        };
+        dataByCoordSys.list.push(coordSysItem);
+      }
+
+      coordSysItem.dataByAxis.push({
+        axisDim: axis.dim,
+        axisIndex: axisModel.componentIndex,
+        axisType: axisModel.type,
+        axisId: axisModel.id,
+        value: value,
+        // Caustion: viewHelper.getValueLabel is actually on "view stage", which
+        // depends that all models have been updated. So it should not be performed
+        // here. Considering axisPointerModel used here is volatile, which is hard
+        // to be retrieve in TooltipView, we prepare parameters here.
+        valueLabelOpt: {
+          precision: axisPointerModel.get(['label', 'precision']),
+          formatter: axisPointerModel.get(['label', 'formatter'])
+        },
+        seriesDataIndices: payloadBatch.slice()
+      });
+    }
+
+    function updateModelActually(showValueMap, axesInfo, outputPayload) {
+      var outputAxesInfo = outputPayload.axesInfo = []; // Basic logic: If no 'show' required, 'hide' this axisPointer.
+
+      each(axesInfo, function (axisInfo, key) {
+        var option = axisInfo.axisPointerModel.option;
+        var valItem = showValueMap[key];
+
+        if (valItem) {
+          !axisInfo.useHandle && (option.status = 'show');
+          option.value = valItem.value; // For label formatter param and highlight.
+
+          option.seriesDataIndices = (valItem.payloadBatch || []).slice();
+        } // When always show (e.g., handle used), remain
+        // original value and status.
+        else {
+            // If hide, value still need to be set, consider
+            // click legend to toggle axis blank.
+            !axisInfo.useHandle && (option.status = 'hide');
+          } // If status is 'hide', should be no info in payload.
+
+
+        option.status === 'show' && outputAxesInfo.push({
+          axisDim: axisInfo.axis.dim,
+          axisIndex: axisInfo.axis.model.componentIndex,
+          value: option.value
+        });
+      });
+    }
+
+    function dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction) {
+      // Basic logic: If no showTip required, hideTip will be dispatched.
+      if (illegalPoint(point) || !dataByCoordSys.list.length) {
+        dispatchAction({
+          type: 'hideTip'
+        });
+        return;
+      } // In most case only one axis (or event one series is used). It is
+      // convinient to fetch payload.seriesIndex and payload.dataIndex
+      // dirtectly. So put the first seriesIndex and dataIndex of the first
+      // axis on the payload.
+
+
+      var sampleItem = ((dataByCoordSys.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
+      dispatchAction({
+        type: 'showTip',
+        escapeConnect: true,
+        x: point[0],
+        y: point[1],
+        tooltipOption: payload.tooltipOption,
+        position: payload.position,
+        dataIndexInside: sampleItem.dataIndexInside,
+        dataIndex: sampleItem.dataIndex,
+        seriesIndex: sampleItem.seriesIndex,
+        dataByCoordSys: dataByCoordSys.list
+      });
+    }
+
+    function dispatchHighDownActually(axesInfo, dispatchAction, api) {
+      // FIXME
+      // highlight status modification shoule be a stage of main process?
+      // (Consider confilct (e.g., legend and axisPointer) and setOption)
+      var zr = api.getZr();
+      var highDownKey = 'axisPointerLastHighlights';
+      var lastHighlights = inner$e(zr)[highDownKey] || {};
+      var newHighlights = inner$e(zr)[highDownKey] = {}; // Update highlight/downplay status according to axisPointer model.
+      // Build hash map and remove duplicate incidentally.
+
+      each(axesInfo, function (axisInfo, key) {
+        var option = axisInfo.axisPointerModel.option;
+        option.status === 'show' && each(option.seriesDataIndices, function (batchItem) {
+          var key = batchItem.seriesIndex + ' | ' + batchItem.dataIndex;
+          newHighlights[key] = batchItem;
+        });
+      }); // Diff.
+
+      var toHighlight = [];
+      var toDownplay = [];
+      each(lastHighlights, function (batchItem, key) {
+        !newHighlights[key] && toDownplay.push(batchItem);
+      });
+      each(newHighlights, function (batchItem, key) {
+        !lastHighlights[key] && toHighlight.push(batchItem);
+      });
+      toDownplay.length && api.dispatchAction({
+        type: 'downplay',
+        escapeConnect: true,
+        // Not blur others when highlight in axisPointer.
+        notBlur: true,
+        batch: toDownplay
+      });
+      toHighlight.length && api.dispatchAction({
+        type: 'highlight',
+        escapeConnect: true,
+        // Not blur others when highlight in axisPointer.
+        notBlur: true,
+        batch: toHighlight
+      });
+    }
+
+    function findInputAxisInfo(inputAxesInfo, axisInfo) {
+      for (var i = 0; i < (inputAxesInfo || []).length; i++) {
+        var inputAxisInfo = inputAxesInfo[i];
+
+        if (axisInfo.axis.dim === inputAxisInfo.axisDim && axisInfo.axis.model.componentIndex === inputAxisInfo.axisIndex) {
+          return inputAxisInfo;
+        }
+      }
+    }
+
+    function makeMapperParam(axisInfo) {
+      var axisModel = axisInfo.axis.model;
+      var item = {};
+      var dim = item.axisDim = axisInfo.axis.dim;
+      item.axisIndex = item[dim + 'AxisIndex'] = axisModel.componentIndex;
+      item.axisName = item[dim + 'AxisName'] = axisModel.name;
+      item.axisId = item[dim + 'AxisId'] = axisModel.id;
+      return item;
+    }
+
+    function illegalPoint(point) {
+      return !point || point[0] == null || isNaN(point[0]) || point[1] == null || isNaN(point[1]);
+    }
+
+    function install$s(registers) {
+      // CartesianAxisPointer is not supposed to be required here. But consider
+      // echarts.simple.js and online build tooltip, which only require gridSimple,
+      // CartesianAxisPointer should be able to required somewhere.
+      AxisView.registerAxisPointerClass('CartesianAxisPointer', CartesianAxisPointer);
+      registers.registerComponentModel(AxisPointerModel);
+      registers.registerComponentView(AxisPointerView);
+      registers.registerPreprocessor(function (option) {
+        // Always has a global axisPointerModel for default setting.
+        if (option) {
+          (!option.axisPointer || option.axisPointer.length === 0) && (option.axisPointer = {});
+          var link = option.axisPointer.link; // Normalize to array to avoid object mergin. But if link
+          // is not set, remain null/undefined, otherwise it will
+          // override existent link setting.
+
+          if (link && !isArray(link)) {
+            option.axisPointer.link = [link];
+          }
+        }
+      }); // This process should proformed after coordinate systems created
+      // and series data processed. So put it on statistic processing stage.
+
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, function (ecModel, api) {
+        // Build axisPointerModel, mergin tooltip.axisPointer model for each axis.
+        // allAxesInfo should be updated when setOption performed.
+        ecModel.getComponent('axisPointer').coordSysAxesInfo = collect(ecModel, api);
+      }); // Broadcast to all views.
+
+      registers.registerAction({
+        type: 'updateAxisPointer',
+        event: 'updateAxisPointer',
+        update: ':updateAxisPointer'
+      }, axisTrigger);
+    }
+
+    function install$t(registers) {
+      use(install$5);
+      use(install$s);
+    }
+
+    var PolarAxisPointer =
+    /** @class */
+    function (_super) {
+      __extends(PolarAxisPointer, _super);
+
+      function PolarAxisPointer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      /**
+       * @override
+       */
+
+
+      PolarAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+        var axis = axisModel.axis;
+
+        if (axis.dim === 'angle') {
+          this.animationThreshold = Math.PI / 18;
+        }
+
+        var polar = axis.polar;
+        var otherAxis = polar.getOtherAxis(axis);
+        var otherExtent = otherAxis.getExtent();
+        var coordValue = axis.dataToCoord(value);
+        var axisPointerType = axisPointerModel.get('type');
+
+        if (axisPointerType && axisPointerType !== 'none') {
+          var elStyle = buildElStyle(axisPointerModel);
+          var pointerOption = pointerShapeBuilder$1[axisPointerType](axis, polar, coordValue, otherExtent);
+          pointerOption.style = elStyle;
+          elOption.graphicKey = pointerOption.type;
+          elOption.pointer = pointerOption;
+        }
+
+        var labelMargin = axisPointerModel.get(['label', 'margin']);
+        var labelPos = getLabelPosition(value, axisModel, axisPointerModel, polar, labelMargin);
+        buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos);
+      };
+
+      return PolarAxisPointer;
+    }(BaseAxisPointer);
+
+    function getLabelPosition(value, axisModel, axisPointerModel, polar, labelMargin) {
+      var axis = axisModel.axis;
+      var coord = axis.dataToCoord(value);
+      var axisAngle = polar.getAngleAxis().getExtent()[0];
+      axisAngle = axisAngle / 180 * Math.PI;
+      var radiusExtent = polar.getRadiusAxis().getExtent();
+      var position;
+      var align;
+      var verticalAlign;
+
+      if (axis.dim === 'radius') {
+        var transform = create$1();
+        rotate(transform, transform, axisAngle);
+        translate(transform, transform, [polar.cx, polar.cy]);
+        position = applyTransform$1([coord, -labelMargin], transform);
+        var labelRotation = axisModel.getModel('axisLabel').get('rotate') || 0; // @ts-ignore
+
+        var labelLayout = AxisBuilder.innerTextLayout(axisAngle, labelRotation * Math.PI / 180, -1);
+        align = labelLayout.textAlign;
+        verticalAlign = labelLayout.textVerticalAlign;
+      } else {
+        // angle axis
+        var r = radiusExtent[1];
+        position = polar.coordToPoint([r + labelMargin, coord]);
+        var cx = polar.cx;
+        var cy = polar.cy;
+        align = Math.abs(position[0] - cx) / r < 0.3 ? 'center' : position[0] > cx ? 'left' : 'right';
+        verticalAlign = Math.abs(position[1] - cy) / r < 0.3 ? 'middle' : position[1] > cy ? 'top' : 'bottom';
+      }
+
+      return {
+        position: position,
+        align: align,
+        verticalAlign: verticalAlign
+      };
+    }
+
+    var pointerShapeBuilder$1 = {
+      line: function (axis, polar, coordValue, otherExtent) {
+        return axis.dim === 'angle' ? {
+          type: 'Line',
+          shape: makeLineShape(polar.coordToPoint([otherExtent[0], coordValue]), polar.coordToPoint([otherExtent[1], coordValue]))
+        } : {
+          type: 'Circle',
+          shape: {
+            cx: polar.cx,
+            cy: polar.cy,
+            r: coordValue
+          }
+        };
+      },
+      shadow: function (axis, polar, coordValue, otherExtent) {
+        var bandWidth = Math.max(1, axis.getBandWidth());
+        var radian = Math.PI / 180;
+        return axis.dim === 'angle' ? {
+          type: 'Sector',
+          shape: makeSectorShape(polar.cx, polar.cy, otherExtent[0], otherExtent[1], // In ECharts y is negative if angle is positive
+          (-coordValue - bandWidth / 2) * radian, (-coordValue + bandWidth / 2) * radian)
+        } : {
+          type: 'Sector',
+          shape: makeSectorShape(polar.cx, polar.cy, coordValue - bandWidth / 2, coordValue + bandWidth / 2, 0, Math.PI * 2)
+        };
+      }
+    };
+
+    var PolarModel =
+    /** @class */
+    function (_super) {
+      __extends(PolarModel, _super);
+
+      function PolarModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PolarModel.type;
+        return _this;
+      }
+
+      PolarModel.prototype.findAxisModel = function (axisType) {
+        var foundAxisModel;
+        var ecModel = this.ecModel;
+        ecModel.eachComponent(axisType, function (axisModel) {
+          if (axisModel.getCoordSysModel() === this) {
+            foundAxisModel = axisModel;
+          }
+        }, this);
+        return foundAxisModel;
+      };
+
+      PolarModel.type = 'polar';
+      PolarModel.dependencies = ['radiusAxis', 'angleAxis'];
+      PolarModel.defaultOption = {
+        zlevel: 0,
+        z: 0,
+        center: ['50%', '50%'],
+        radius: '80%'
+      };
+      return PolarModel;
+    }(ComponentModel);
+
+    var PolarAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(PolarAxisModel, _super);
+
+      function PolarAxisModel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      PolarAxisModel.prototype.getCoordSysModel = function () {
+        return this.getReferringComponents('polar', SINGLE_REFERRING).models[0];
+      };
+
+      PolarAxisModel.type = 'polarAxis';
+      return PolarAxisModel;
+    }(ComponentModel);
+
+    mixin(PolarAxisModel, AxisModelCommonMixin);
+
+    var AngleAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(AngleAxisModel, _super);
+
+      function AngleAxisModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = AngleAxisModel.type;
+        return _this;
+      }
+
+      AngleAxisModel.type = 'angleAxis';
+      return AngleAxisModel;
+    }(PolarAxisModel);
+
+    var RadiusAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(RadiusAxisModel, _super);
+
+      function RadiusAxisModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadiusAxisModel.type;
+        return _this;
+      }
+
+      RadiusAxisModel.type = 'radiusAxis';
+      return RadiusAxisModel;
+    }(PolarAxisModel);
+
+    var RadiusAxis =
+    /** @class */
+    function (_super) {
+      __extends(RadiusAxis, _super);
+
+      function RadiusAxis(scale, radiusExtent) {
+        return _super.call(this, 'radius', scale, radiusExtent) || this;
+      }
+
+      RadiusAxis.prototype.pointToData = function (point, clamp) {
+        return this.polar.pointToData(point, clamp)[this.dim === 'radius' ? 0 : 1];
+      };
+
+      return RadiusAxis;
+    }(Axis);
+
+    RadiusAxis.prototype.dataToRadius = Axis.prototype.dataToCoord;
+    RadiusAxis.prototype.radiusToData = Axis.prototype.coordToData;
+
+    var inner$f = makeInner();
+
+    var AngleAxis =
+    /** @class */
+    function (_super) {
+      __extends(AngleAxis, _super);
+
+      function AngleAxis(scale, angleExtent) {
+        return _super.call(this, 'angle', scale, angleExtent || [0, 360]) || this;
+      }
+
+      AngleAxis.prototype.pointToData = function (point, clamp) {
+        return this.polar.pointToData(point, clamp)[this.dim === 'radius' ? 0 : 1];
+      };
+      /**
+       * Only be called in category axis.
+       * Angle axis uses text height to decide interval
+       *
+       * @override
+       * @return {number} Auto interval for cateogry axis tick and label
+       */
+
+
+      AngleAxis.prototype.calculateCategoryInterval = function () {
+        var axis = this;
+        var labelModel = axis.getLabelModel();
+        var ordinalScale = axis.scale;
+        var ordinalExtent = ordinalScale.getExtent(); // Providing this method is for optimization:
+        // avoid generating a long array by `getTicks`
+        // in large category data case.
+
+        var tickCount = ordinalScale.count();
+
+        if (ordinalExtent[1] - ordinalExtent[0] < 1) {
+          return 0;
+        }
+
+        var tickValue = ordinalExtent[0];
+        var unitSpan = axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue);
+        var unitH = Math.abs(unitSpan); // Not precise, just use height as text width
+        // and each distance from axis line yet.
+
+        var rect = getBoundingRect(tickValue == null ? '' : tickValue + '', labelModel.getFont(), 'center', 'top');
+        var maxH = Math.max(rect.height, 7);
+        var dh = maxH / unitH; // 0/0 is NaN, 1/0 is Infinity.
+
+        isNaN(dh) && (dh = Infinity);
+        var interval = Math.max(0, Math.floor(dh));
+        var cache = inner$f(axis.model);
+        var lastAutoInterval = cache.lastAutoInterval;
+        var lastTickCount = cache.lastTickCount; // Use cache to keep interval stable while moving zoom window,
+        // otherwise the calculated interval might jitter when the zoom
+        // window size is close to the interval-changing size.
+
+        if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 // Always choose the bigger one, otherwise the critical
+        // point is not the same when zooming in or zooming out.
+        && lastAutoInterval > interval) {
+          interval = lastAutoInterval;
+        } // Only update cache if cache not used, otherwise the
+        // changing of interval is too insensitive.
+        else {
+            cache.lastTickCount = tickCount;
+            cache.lastAutoInterval = interval;
+          }
+
+        return interval;
+      };
+
+      return AngleAxis;
+    }(Axis);
+
+    AngleAxis.prototype.dataToAngle = Axis.prototype.dataToCoord;
+    AngleAxis.prototype.angleToData = Axis.prototype.coordToData;
+
+    var Polar =
+    /** @class */
+    function () {
+      function Polar(name) {
+        this.dimensions = ['radius', 'angle'];
+        this.type = 'polar';
+        /**
+         * x of polar center
+         */
+
+        this.cx = 0;
+        /**
+         * y of polar center
+         */
+
+        this.cy = 0;
+        this._radiusAxis = new RadiusAxis();
+        this._angleAxis = new AngleAxis();
+        this.axisPointerEnabled = true;
+        this.name = name || '';
+        this._radiusAxis.polar = this._angleAxis.polar = this;
+      }
+      /**
+       * If contain coord
+       */
+
+
+      Polar.prototype.containPoint = function (point) {
+        var coord = this.pointToCoord(point);
+        return this._radiusAxis.contain(coord[0]) && this._angleAxis.contain(coord[1]);
+      };
+      /**
+       * If contain data
+       */
+
+
+      Polar.prototype.containData = function (data) {
+        return this._radiusAxis.containData(data[0]) && this._angleAxis.containData(data[1]);
+      };
+
+      Polar.prototype.getAxis = function (dim) {
+        var key = '_' + dim + 'Axis';
+        return this[key];
+      };
+
+      Polar.prototype.getAxes = function () {
+        return [this._radiusAxis, this._angleAxis];
+      };
+      /**
+       * Get axes by type of scale
+       */
+
+
+      Polar.prototype.getAxesByScale = function (scaleType) {
+        var axes = [];
+        var angleAxis = this._angleAxis;
+        var radiusAxis = this._radiusAxis;
+        angleAxis.scale.type === scaleType && axes.push(angleAxis);
+        radiusAxis.scale.type === scaleType && axes.push(radiusAxis);
+        return axes;
+      };
+
+      Polar.prototype.getAngleAxis = function () {
+        return this._angleAxis;
+      };
+
+      Polar.prototype.getRadiusAxis = function () {
+        return this._radiusAxis;
+      };
+
+      Polar.prototype.getOtherAxis = function (axis) {
+        var angleAxis = this._angleAxis;
+        return axis === angleAxis ? this._radiusAxis : angleAxis;
+      };
+      /**
+       * Base axis will be used on stacking.
+       *
+       */
+
+
+      Polar.prototype.getBaseAxis = function () {
+        return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAngleAxis();
+      };
+
+      Polar.prototype.getTooltipAxes = function (dim) {
+        var baseAxis = dim != null && dim !== 'auto' ? this.getAxis(dim) : this.getBaseAxis();
+        return {
+          baseAxes: [baseAxis],
+          otherAxes: [this.getOtherAxis(baseAxis)]
+        };
+      };
+      /**
+       * Convert a single data item to (x, y) point.
+       * Parameter data is an array which the first element is radius and the second is angle
+       */
+
+
+      Polar.prototype.dataToPoint = function (data, clamp) {
+        return this.coordToPoint([this._radiusAxis.dataToRadius(data[0], clamp), this._angleAxis.dataToAngle(data[1], clamp)]);
+      };
+      /**
+       * Convert a (x, y) point to data
+       */
+
+
+      Polar.prototype.pointToData = function (point, clamp) {
+        var coord = this.pointToCoord(point);
+        return [this._radiusAxis.radiusToData(coord[0], clamp), this._angleAxis.angleToData(coord[1], clamp)];
+      };
+      /**
+       * Convert a (x, y) point to (radius, angle) coord
+       */
+
+
+      Polar.prototype.pointToCoord = function (point) {
+        var dx = point[0] - this.cx;
+        var dy = point[1] - this.cy;
+        var angleAxis = this.getAngleAxis();
+        var extent = angleAxis.getExtent();
+        var minAngle = Math.min(extent[0], extent[1]);
+        var maxAngle = Math.max(extent[0], extent[1]); // Fix fixed extent in polarCreator
+        // FIXME
+
+        angleAxis.inverse ? minAngle = maxAngle - 360 : maxAngle = minAngle + 360;
+        var radius = Math.sqrt(dx * dx + dy * dy);
+        dx /= radius;
+        dy /= radius;
+        var radian = Math.atan2(-dy, dx) / Math.PI * 180; // move to angleExtent
+
+        var dir = radian < minAngle ? 1 : -1;
+
+        while (radian < minAngle || radian > maxAngle) {
+          radian += dir * 360;
+        }
+
+        return [radius, radian];
+      };
+      /**
+       * Convert a (radius, angle) coord to (x, y) point
+       */
+
+
+      Polar.prototype.coordToPoint = function (coord) {
+        var radius = coord[0];
+        var radian = coord[1] / 180 * Math.PI;
+        var x = Math.cos(radian) * radius + this.cx; // Inverse the y
+
+        var y = -Math.sin(radian) * radius + this.cy;
+        return [x, y];
+      };
+      /**
+       * Get ring area of cartesian.
+       * Area will have a contain function to determine if a point is in the coordinate system.
+       */
+
+
+      Polar.prototype.getArea = function () {
+        var angleAxis = this.getAngleAxis();
+        var radiusAxis = this.getRadiusAxis();
+        var radiusExtent = radiusAxis.getExtent().slice();
+        radiusExtent[0] > radiusExtent[1] && radiusExtent.reverse();
+        var angleExtent = angleAxis.getExtent();
+        var RADIAN = Math.PI / 180;
+        return {
+          cx: this.cx,
+          cy: this.cy,
+          r0: radiusExtent[0],
+          r: radiusExtent[1],
+          startAngle: -angleExtent[0] * RADIAN,
+          endAngle: -angleExtent[1] * RADIAN,
+          clockwise: angleAxis.inverse,
+          contain: function (x, y) {
+            // It's a ring shape.
+            // Start angle and end angle don't matter
+            var dx = x - this.cx;
+            var dy = y - this.cy;
+            var d2 = dx * dx + dy * dy;
+            var r = this.r;
+            var r0 = this.r0;
+            return d2 <= r * r && d2 >= r0 * r0;
+          }
+        };
+      };
+
+      Polar.prototype.convertToPixel = function (ecModel, finder, value) {
+        var coordSys = getCoordSys$2(finder);
+        return coordSys === this ? this.dataToPoint(value) : null;
+      };
+
+      Polar.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        var coordSys = getCoordSys$2(finder);
+        return coordSys === this ? this.pointToData(pixel) : null;
+      };
+
+      return Polar;
+    }();
+
+    function getCoordSys$2(finder) {
+      var seriesModel = finder.seriesModel;
+      var polarModel = finder.polarModel;
+      return polarModel && polarModel.coordinateSystem || seriesModel && seriesModel.coordinateSystem;
+    }
+
+    /**
+     * Resize method bound to the polar
+     */
+
+    function resizePolar(polar, polarModel, api) {
+      var center = polarModel.get('center');
+      var width = api.getWidth();
+      var height = api.getHeight();
+      polar.cx = parsePercent$1(center[0], width);
+      polar.cy = parsePercent$1(center[1], height);
+      var radiusAxis = polar.getRadiusAxis();
+      var size = Math.min(width, height) / 2;
+      var radius = polarModel.get('radius');
+
+      if (radius == null) {
+        radius = [0, '100%'];
+      } else if (!isArray(radius)) {
+        // r0 = 0
+        radius = [0, radius];
+      }
+
+      var parsedRadius = [parsePercent$1(radius[0], size), parsePercent$1(radius[1], size)];
+      radiusAxis.inverse ? radiusAxis.setExtent(parsedRadius[1], parsedRadius[0]) : radiusAxis.setExtent(parsedRadius[0], parsedRadius[1]);
+    }
+    /**
+     * Update polar
+     */
+
+
+    function updatePolarScale(ecModel, api) {
+      var polar = this;
+      var angleAxis = polar.getAngleAxis();
+      var radiusAxis = polar.getRadiusAxis(); // Reset scale
+
+      angleAxis.scale.setExtent(Infinity, -Infinity);
+      radiusAxis.scale.setExtent(Infinity, -Infinity);
+      ecModel.eachSeries(function (seriesModel) {
+        if (seriesModel.coordinateSystem === polar) {
+          var data_1 = seriesModel.getData();
+          each(getDataDimensionsOnAxis(data_1, 'radius'), function (dim) {
+            radiusAxis.scale.unionExtentFromData(data_1, dim);
+          });
+          each(getDataDimensionsOnAxis(data_1, 'angle'), function (dim) {
+            angleAxis.scale.unionExtentFromData(data_1, dim);
+          });
+        }
+      });
+      niceScaleExtent(angleAxis.scale, angleAxis.model);
+      niceScaleExtent(radiusAxis.scale, radiusAxis.model); // Fix extent of category angle axis
+
+      if (angleAxis.type === 'category' && !angleAxis.onBand) {
+        var extent = angleAxis.getExtent();
+        var diff = 360 / angleAxis.scale.count();
+        angleAxis.inverse ? extent[1] += diff : extent[1] -= diff;
+        angleAxis.setExtent(extent[0], extent[1]);
+      }
+    }
+
+    function isAngleAxisModel(axisModel) {
+      return axisModel.mainType === 'angleAxis';
+    }
+    /**
+     * Set common axis properties
+     */
+
+
+    function setAxis(axis, axisModel) {
+      axis.type = axisModel.get('type');
+      axis.scale = createScaleByModel(axisModel);
+      axis.onBand = axisModel.get('boundaryGap') && axis.type === 'category';
+      axis.inverse = axisModel.get('inverse');
+
+      if (isAngleAxisModel(axisModel)) {
+        axis.inverse = axis.inverse !== axisModel.get('clockwise');
+        var startAngle = axisModel.get('startAngle');
+        axis.setExtent(startAngle, startAngle + (axis.inverse ? -360 : 360));
+      } // Inject axis instance
+
+
+      axisModel.axis = axis;
+      axis.model = axisModel;
+    }
+
+    var polarCreator = {
+      dimensions: Polar.prototype.dimensions,
+      create: function (ecModel, api) {
+        var polarList = [];
+        ecModel.eachComponent('polar', function (polarModel, idx) {
+          var polar = new Polar(idx + ''); // Inject resize and update method
+
+          polar.update = updatePolarScale;
+          var radiusAxis = polar.getRadiusAxis();
+          var angleAxis = polar.getAngleAxis();
+          var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+          var angleAxisModel = polarModel.findAxisModel('angleAxis');
+          setAxis(radiusAxis, radiusAxisModel);
+          setAxis(angleAxis, angleAxisModel);
+          resizePolar(polar, polarModel, api);
+          polarList.push(polar);
+          polarModel.coordinateSystem = polar;
+          polar.model = polarModel;
+        }); // Inject coordinateSystem to series
+
+        ecModel.eachSeries(function (seriesModel) {
+          if (seriesModel.get('coordinateSystem') === 'polar') {
+            var polarModel = seriesModel.getReferringComponents('polar', SINGLE_REFERRING).models[0];
+
+            if ("development" !== 'production') {
+              if (!polarModel) {
+                throw new Error('Polar "' + retrieve(seriesModel.get('polarIndex'), seriesModel.get('polarId'), 0) + '" not found');
+              }
+            }
+
+            seriesModel.coordinateSystem = polarModel.coordinateSystem;
+          }
+        });
+        return polarList;
+      }
+    };
+
+    var elementList$1 = ['axisLine', 'axisLabel', 'axisTick', 'minorTick', 'splitLine', 'minorSplitLine', 'splitArea'];
+
+    function getAxisLineShape(polar, rExtent, angle) {
+      rExtent[1] > rExtent[0] && (rExtent = rExtent.slice().reverse());
+      var start = polar.coordToPoint([rExtent[0], angle]);
+      var end = polar.coordToPoint([rExtent[1], angle]);
+      return {
+        x1: start[0],
+        y1: start[1],
+        x2: end[0],
+        y2: end[1]
+      };
+    }
+
+    function getRadiusIdx(polar) {
+      var radiusAxis = polar.getRadiusAxis();
+      return radiusAxis.inverse ? 0 : 1;
+    } // Remove the last tick which will overlap the first tick
+
+
+    function fixAngleOverlap(list) {
+      var firstItem = list[0];
+      var lastItem = list[list.length - 1];
+
+      if (firstItem && lastItem && Math.abs(Math.abs(firstItem.coord - lastItem.coord) - 360) < 1e-4) {
+        list.pop();
+      }
+    }
+
+    var AngleAxisView =
+    /** @class */
+    function (_super) {
+      __extends(AngleAxisView, _super);
+
+      function AngleAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = AngleAxisView.type;
+        _this.axisPointerClass = 'PolarAxisPointer';
+        return _this;
+      }
+
+      AngleAxisView.prototype.render = function (angleAxisModel, ecModel) {
+        this.group.removeAll();
+
+        if (!angleAxisModel.get('show')) {
+          return;
+        }
+
+        var angleAxis = angleAxisModel.axis;
+        var polar = angleAxis.polar;
+        var radiusExtent = polar.getRadiusAxis().getExtent();
+        var ticksAngles = angleAxis.getTicksCoords();
+        var minorTickAngles = angleAxis.getMinorTicksCoords();
+        var labels = map(angleAxis.getViewLabels(), function (labelItem) {
+          labelItem = clone(labelItem);
+          var scale = angleAxis.scale;
+          var tickValue = scale.type === 'ordinal' ? scale.getRawOrdinalNumber(labelItem.tickValue) : labelItem.tickValue;
+          labelItem.coord = angleAxis.dataToCoord(tickValue);
+          return labelItem;
+        });
+        fixAngleOverlap(labels);
+        fixAngleOverlap(ticksAngles);
+        each(elementList$1, function (name) {
+          if (angleAxisModel.get([name, 'show']) && (!angleAxis.scale.isBlank() || name === 'axisLine')) {
+            angelAxisElementsBuilders[name](this.group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent, labels);
+          }
+        }, this);
+      };
+
+      AngleAxisView.type = 'angleAxis';
+      return AngleAxisView;
+    }(AxisView);
+
+    var angelAxisElementsBuilders = {
+      axisLine: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent) {
+        var lineStyleModel = angleAxisModel.getModel(['axisLine', 'lineStyle']); // extent id of the axis radius (r0 and r)
+
+        var rId = getRadiusIdx(polar);
+        var r0Id = rId ? 0 : 1;
+        var shape;
+
+        if (radiusExtent[r0Id] === 0) {
+          shape = new Circle({
+            shape: {
+              cx: polar.cx,
+              cy: polar.cy,
+              r: radiusExtent[rId]
+            },
+            style: lineStyleModel.getLineStyle(),
+            z2: 1,
+            silent: true
+          });
+        } else {
+          shape = new Ring({
+            shape: {
+              cx: polar.cx,
+              cy: polar.cy,
+              r: radiusExtent[rId],
+              r0: radiusExtent[r0Id]
+            },
+            style: lineStyleModel.getLineStyle(),
+            z2: 1,
+            silent: true
+          });
+        }
+
+        shape.style.fill = null;
+        group.add(shape);
+      },
+      axisTick: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent) {
+        var tickModel = angleAxisModel.getModel('axisTick');
+        var tickLen = (tickModel.get('inside') ? -1 : 1) * tickModel.get('length');
+        var radius = radiusExtent[getRadiusIdx(polar)];
+        var lines = map(ticksAngles, function (tickAngleItem) {
+          return new Line({
+            shape: getAxisLineShape(polar, [radius, radius + tickLen], tickAngleItem.coord)
+          });
+        });
+        group.add(mergePath$1(lines, {
+          style: defaults(tickModel.getModel('lineStyle').getLineStyle(), {
+            stroke: angleAxisModel.get(['axisLine', 'lineStyle', 'color'])
+          })
+        }));
+      },
+      minorTick: function (group, angleAxisModel, polar, tickAngles, minorTickAngles, radiusExtent) {
+        if (!minorTickAngles.length) {
+          return;
+        }
+
+        var tickModel = angleAxisModel.getModel('axisTick');
+        var minorTickModel = angleAxisModel.getModel('minorTick');
+        var tickLen = (tickModel.get('inside') ? -1 : 1) * minorTickModel.get('length');
+        var radius = radiusExtent[getRadiusIdx(polar)];
+        var lines = [];
+
+        for (var i = 0; i < minorTickAngles.length; i++) {
+          for (var k = 0; k < minorTickAngles[i].length; k++) {
+            lines.push(new Line({
+              shape: getAxisLineShape(polar, [radius, radius + tickLen], minorTickAngles[i][k].coord)
+            }));
+          }
+        }
+
+        group.add(mergePath$1(lines, {
+          style: defaults(minorTickModel.getModel('lineStyle').getLineStyle(), defaults(tickModel.getLineStyle(), {
+            stroke: angleAxisModel.get(['axisLine', 'lineStyle', 'color'])
+          }))
+        }));
+      },
+      axisLabel: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent, labels) {
+        var rawCategoryData = angleAxisModel.getCategories(true);
+        var commonLabelModel = angleAxisModel.getModel('axisLabel');
+        var labelMargin = commonLabelModel.get('margin');
+        var triggerEvent = angleAxisModel.get('triggerEvent'); // Use length of ticksAngles because it may remove the last tick to avoid overlapping
+
+        each(labels, function (labelItem, idx) {
+          var labelModel = commonLabelModel;
+          var tickValue = labelItem.tickValue;
+          var r = radiusExtent[getRadiusIdx(polar)];
+          var p = polar.coordToPoint([r + labelMargin, labelItem.coord]);
+          var cx = polar.cx;
+          var cy = polar.cy;
+          var labelTextAlign = Math.abs(p[0] - cx) / r < 0.3 ? 'center' : p[0] > cx ? 'left' : 'right';
+          var labelTextVerticalAlign = Math.abs(p[1] - cy) / r < 0.3 ? 'middle' : p[1] > cy ? 'top' : 'bottom';
+
+          if (rawCategoryData && rawCategoryData[tickValue]) {
+            var rawCategoryItem = rawCategoryData[tickValue];
+
+            if (isObject(rawCategoryItem) && rawCategoryItem.textStyle) {
+              labelModel = new Model(rawCategoryItem.textStyle, commonLabelModel, commonLabelModel.ecModel);
+            }
+          }
+
+          var textEl = new ZRText({
+            silent: AxisBuilder.isLabelSilent(angleAxisModel),
+            style: createTextStyle(labelModel, {
+              x: p[0],
+              y: p[1],
+              fill: labelModel.getTextColor() || angleAxisModel.get(['axisLine', 'lineStyle', 'color']),
+              text: labelItem.formattedLabel,
+              align: labelTextAlign,
+              verticalAlign: labelTextVerticalAlign
+            })
+          });
+          group.add(textEl); // Pack data for mouse event
+
+          if (triggerEvent) {
+            var eventData = AxisBuilder.makeAxisEventDataBase(angleAxisModel);
+            eventData.targetType = 'axisLabel';
+            eventData.value = labelItem.rawLabel;
+            getECData(textEl).eventData = eventData;
+          }
+        }, this);
+      },
+      splitLine: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent) {
+        var splitLineModel = angleAxisModel.getModel('splitLine');
+        var lineStyleModel = splitLineModel.getModel('lineStyle');
+        var lineColors = lineStyleModel.get('color');
+        var lineCount = 0;
+        lineColors = lineColors instanceof Array ? lineColors : [lineColors];
+        var splitLines = [];
+
+        for (var i = 0; i < ticksAngles.length; i++) {
+          var colorIndex = lineCount++ % lineColors.length;
+          splitLines[colorIndex] = splitLines[colorIndex] || [];
+          splitLines[colorIndex].push(new Line({
+            shape: getAxisLineShape(polar, radiusExtent, ticksAngles[i].coord)
+          }));
+        } // Simple optimization
+        // Batching the lines if color are the same
+
+
+        for (var i = 0; i < splitLines.length; i++) {
+          group.add(mergePath$1(splitLines[i], {
+            style: defaults({
+              stroke: lineColors[i % lineColors.length]
+            }, lineStyleModel.getLineStyle()),
+            silent: true,
+            z: angleAxisModel.get('z')
+          }));
+        }
+      },
+      minorSplitLine: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent) {
+        if (!minorTickAngles.length) {
+          return;
+        }
+
+        var minorSplitLineModel = angleAxisModel.getModel('minorSplitLine');
+        var lineStyleModel = minorSplitLineModel.getModel('lineStyle');
+        var lines = [];
+
+        for (var i = 0; i < minorTickAngles.length; i++) {
+          for (var k = 0; k < minorTickAngles[i].length; k++) {
+            lines.push(new Line({
+              shape: getAxisLineShape(polar, radiusExtent, minorTickAngles[i][k].coord)
+            }));
+          }
+        }
+
+        group.add(mergePath$1(lines, {
+          style: lineStyleModel.getLineStyle(),
+          silent: true,
+          z: angleAxisModel.get('z')
+        }));
+      },
+      splitArea: function (group, angleAxisModel, polar, ticksAngles, minorTickAngles, radiusExtent) {
+        if (!ticksAngles.length) {
+          return;
+        }
+
+        var splitAreaModel = angleAxisModel.getModel('splitArea');
+        var areaStyleModel = splitAreaModel.getModel('areaStyle');
+        var areaColors = areaStyleModel.get('color');
+        var lineCount = 0;
+        areaColors = areaColors instanceof Array ? areaColors : [areaColors];
+        var splitAreas = [];
+        var RADIAN = Math.PI / 180;
+        var prevAngle = -ticksAngles[0].coord * RADIAN;
+        var r0 = Math.min(radiusExtent[0], radiusExtent[1]);
+        var r1 = Math.max(radiusExtent[0], radiusExtent[1]);
+        var clockwise = angleAxisModel.get('clockwise');
+
+        for (var i = 1, len = ticksAngles.length; i <= len; i++) {
+          var coord = i === len ? ticksAngles[0].coord : ticksAngles[i].coord;
+          var colorIndex = lineCount++ % areaColors.length;
+          splitAreas[colorIndex] = splitAreas[colorIndex] || [];
+          splitAreas[colorIndex].push(new Sector({
+            shape: {
+              cx: polar.cx,
+              cy: polar.cy,
+              r0: r0,
+              r: r1,
+              startAngle: prevAngle,
+              endAngle: -coord * RADIAN,
+              clockwise: clockwise
+            },
+            silent: true
+          }));
+          prevAngle = -coord * RADIAN;
+        } // Simple optimization
+        // Batching the lines if color are the same
+
+
+        for (var i = 0; i < splitAreas.length; i++) {
+          group.add(mergePath$1(splitAreas[i], {
+            style: defaults({
+              fill: areaColors[i % areaColors.length]
+            }, areaStyleModel.getAreaStyle()),
+            silent: true
+          }));
+        }
+      }
+    };
+
+    var axisBuilderAttrs$2 = ['axisLine', 'axisTickLabel', 'axisName'];
+    var selfBuilderAttrs$1 = ['splitLine', 'splitArea', 'minorSplitLine'];
+
+    var RadiusAxisView =
+    /** @class */
+    function (_super) {
+      __extends(RadiusAxisView, _super);
+
+      function RadiusAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = RadiusAxisView.type;
+        _this.axisPointerClass = 'PolarAxisPointer';
+        return _this;
+      }
+
+      RadiusAxisView.prototype.render = function (radiusAxisModel, ecModel) {
+        this.group.removeAll();
+
+        if (!radiusAxisModel.get('show')) {
+          return;
+        }
+
+        var oldAxisGroup = this._axisGroup;
+        var newAxisGroup = this._axisGroup = new Group();
+        this.group.add(newAxisGroup);
+        var radiusAxis = radiusAxisModel.axis;
+        var polar = radiusAxis.polar;
+        var angleAxis = polar.getAngleAxis();
+        var ticksCoords = radiusAxis.getTicksCoords();
+        var minorTicksCoords = radiusAxis.getMinorTicksCoords();
+        var axisAngle = angleAxis.getExtent()[0];
+        var radiusExtent = radiusAxis.getExtent();
+        var layout = layoutAxis(polar, radiusAxisModel, axisAngle);
+        var axisBuilder = new AxisBuilder(radiusAxisModel, layout);
+        each(axisBuilderAttrs$2, axisBuilder.add, axisBuilder);
+        newAxisGroup.add(axisBuilder.getGroup());
+        groupTransition(oldAxisGroup, newAxisGroup, radiusAxisModel);
+        each(selfBuilderAttrs$1, function (name) {
+          if (radiusAxisModel.get([name, 'show']) && !radiusAxis.scale.isBlank()) {
+            axisElementBuilders$1[name](this.group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords, minorTicksCoords);
+          }
+        }, this);
+      };
+
+      RadiusAxisView.type = 'radiusAxis';
+      return RadiusAxisView;
+    }(AxisView);
+
+    var axisElementBuilders$1 = {
+      splitLine: function (group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords) {
+        var splitLineModel = radiusAxisModel.getModel('splitLine');
+        var lineStyleModel = splitLineModel.getModel('lineStyle');
+        var lineColors = lineStyleModel.get('color');
+        var lineCount = 0;
+        lineColors = lineColors instanceof Array ? lineColors : [lineColors];
+        var splitLines = [];
+
+        for (var i = 0; i < ticksCoords.length; i++) {
+          var colorIndex = lineCount++ % lineColors.length;
+          splitLines[colorIndex] = splitLines[colorIndex] || [];
+          splitLines[colorIndex].push(new Circle({
+            shape: {
+              cx: polar.cx,
+              cy: polar.cy,
+              r: ticksCoords[i].coord
+            }
+          }));
+        } // Simple optimization
+        // Batching the lines if color are the same
+
+
+        for (var i = 0; i < splitLines.length; i++) {
+          group.add(mergePath$1(splitLines[i], {
+            style: defaults({
+              stroke: lineColors[i % lineColors.length],
+              fill: null
+            }, lineStyleModel.getLineStyle()),
+            silent: true
+          }));
+        }
+      },
+      minorSplitLine: function (group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords, minorTicksCoords) {
+        if (!minorTicksCoords.length) {
+          return;
+        }
+
+        var minorSplitLineModel = radiusAxisModel.getModel('minorSplitLine');
+        var lineStyleModel = minorSplitLineModel.getModel('lineStyle');
+        var lines = [];
+
+        for (var i = 0; i < minorTicksCoords.length; i++) {
+          for (var k = 0; k < minorTicksCoords[i].length; k++) {
+            lines.push(new Circle({
+              shape: {
+                cx: polar.cx,
+                cy: polar.cy,
+                r: minorTicksCoords[i][k].coord
+              }
+            }));
+          }
+        }
+
+        group.add(mergePath$1(lines, {
+          style: defaults({
+            fill: null
+          }, lineStyleModel.getLineStyle()),
+          silent: true
+        }));
+      },
+      splitArea: function (group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords) {
+        if (!ticksCoords.length) {
+          return;
+        }
+
+        var splitAreaModel = radiusAxisModel.getModel('splitArea');
+        var areaStyleModel = splitAreaModel.getModel('areaStyle');
+        var areaColors = areaStyleModel.get('color');
+        var lineCount = 0;
+        areaColors = areaColors instanceof Array ? areaColors : [areaColors];
+        var splitAreas = [];
+        var prevRadius = ticksCoords[0].coord;
+
+        for (var i = 1; i < ticksCoords.length; i++) {
+          var colorIndex = lineCount++ % areaColors.length;
+          splitAreas[colorIndex] = splitAreas[colorIndex] || [];
+          splitAreas[colorIndex].push(new Sector({
+            shape: {
+              cx: polar.cx,
+              cy: polar.cy,
+              r0: prevRadius,
+              r: ticksCoords[i].coord,
+              startAngle: 0,
+              endAngle: Math.PI * 2
+            },
+            silent: true
+          }));
+          prevRadius = ticksCoords[i].coord;
+        } // Simple optimization
+        // Batching the lines if color are the same
+
+
+        for (var i = 0; i < splitAreas.length; i++) {
+          group.add(mergePath$1(splitAreas[i], {
+            style: defaults({
+              fill: areaColors[i % areaColors.length]
+            }, areaStyleModel.getAreaStyle()),
+            silent: true
+          }));
+        }
+      }
+    };
+    /**
+     * @inner
+     */
+
+    function layoutAxis(polar, radiusAxisModel, axisAngle) {
+      return {
+        position: [polar.cx, polar.cy],
+        rotation: axisAngle / 180 * Math.PI,
+        labelDirection: -1,
+        tickDirection: -1,
+        nameDirection: 1,
+        labelRotate: radiusAxisModel.getModel('axisLabel').get('rotate'),
+        // Over splitLine and splitArea
+        z2: 1
+      };
+    }
+
+    function getSeriesStackId$1(seriesModel) {
+      return seriesModel.get('stack') || '__ec_stack_' + seriesModel.seriesIndex;
+    }
+
+    function getAxisKey$1(polar, axis) {
+      return axis.dim + polar.model.componentIndex;
+    }
+
+    function barLayoutPolar(seriesType, ecModel, api) {
+      var lastStackCoords = {};
+      var barWidthAndOffset = calRadialBar(filter(ecModel.getSeriesByType(seriesType), function (seriesModel) {
+        return !ecModel.isSeriesFiltered(seriesModel) && seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'polar';
+      }));
+      ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+        // Check series coordinate, do layout for polar only
+        if (seriesModel.coordinateSystem.type !== 'polar') {
+          return;
+        }
+
+        var data = seriesModel.getData();
+        var polar = seriesModel.coordinateSystem;
+        var baseAxis = polar.getBaseAxis();
+        var axisKey = getAxisKey$1(polar, baseAxis);
+        var stackId = getSeriesStackId$1(seriesModel);
+        var columnLayoutInfo = barWidthAndOffset[axisKey][stackId];
+        var columnOffset = columnLayoutInfo.offset;
+        var columnWidth = columnLayoutInfo.width;
+        var valueAxis = polar.getOtherAxis(baseAxis);
+        var cx = seriesModel.coordinateSystem.cx;
+        var cy = seriesModel.coordinateSystem.cy;
+        var barMinHeight = seriesModel.get('barMinHeight') || 0;
+        var barMinAngle = seriesModel.get('barMinAngle') || 0;
+        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim
+        /*, baseDim*/
+        );
+        var clampLayout = baseAxis.dim !== 'radius' || !seriesModel.get('roundCap', true);
+        var valueAxisStart = valueAxis.dataToCoord(0);
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+          var value = data.get(valueDim, idx);
+          var baseValue = data.get(baseDim, idx);
+          var sign = value >= 0 ? 'p' : 'n';
+          var baseCoord = valueAxisStart; // Because of the barMinHeight, we can not use the value in
+          // stackResultDimension directly.
+          // Only ordinal axis can be stacked.
+
+          if (stacked) {
+            if (!lastStackCoords[stackId][baseValue]) {
+              lastStackCoords[stackId][baseValue] = {
+                p: valueAxisStart,
+                n: valueAxisStart // Negative stack
+
+              };
+            } // Should also consider #4243
+
+
+            baseCoord = lastStackCoords[stackId][baseValue][sign];
+          }
+
+          var r0 = void 0;
+          var r = void 0;
+          var startAngle = void 0;
+          var endAngle = void 0; // radial sector
+
+          if (valueAxis.dim === 'radius') {
+            var radiusSpan = valueAxis.dataToCoord(value) - valueAxisStart;
+            var angle = baseAxis.dataToCoord(baseValue);
+
+            if (Math.abs(radiusSpan) < barMinHeight) {
+              radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
+            }
+
+            r0 = baseCoord;
+            r = baseCoord + radiusSpan;
+            startAngle = angle - columnOffset;
+            endAngle = startAngle - columnWidth;
+            stacked && (lastStackCoords[stackId][baseValue][sign] = r);
+          } // tangential sector
+          else {
+              var angleSpan = valueAxis.dataToCoord(value, clampLayout) - valueAxisStart;
+              var radius = baseAxis.dataToCoord(baseValue);
+
+              if (Math.abs(angleSpan) < barMinAngle) {
+                angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
+              }
+
+              r0 = radius + columnOffset;
+              r = r0 + columnWidth;
+              startAngle = baseCoord;
+              endAngle = baseCoord + angleSpan; // if the previous stack is at the end of the ring,
+              // add a round to differentiate it from origin
+              // let extent = angleAxis.getExtent();
+              // let stackCoord = angle;
+              // if (stackCoord === extent[0] && value > 0) {
+              //     stackCoord = extent[1];
+              // }
+              // else if (stackCoord === extent[1] && value < 0) {
+              //     stackCoord = extent[0];
+              // }
+
+              stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
+            }
+
+          data.setItemLayout(idx, {
+            cx: cx,
+            cy: cy,
+            r0: r0,
+            r: r,
+            // Consider that positive angle is anti-clockwise,
+            // while positive radian of sector is clockwise
+            startAngle: -startAngle * Math.PI / 180,
+            endAngle: -endAngle * Math.PI / 180
+          });
+        }
+      });
+    }
+    /**
+     * Calculate bar width and offset for radial bar charts
+     */
+
+
+    function calRadialBar(barSeries) {
+      // Columns info on each category axis. Key is polar name
+      var columnsMap = {};
+      each(barSeries, function (seriesModel, idx) {
+        var data = seriesModel.getData();
+        var polar = seriesModel.coordinateSystem;
+        var baseAxis = polar.getBaseAxis();
+        var axisKey = getAxisKey$1(polar, baseAxis);
+        var axisExtent = baseAxis.getExtent();
+        var bandWidth = baseAxis.type === 'category' ? baseAxis.getBandWidth() : Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
+        var columnsOnAxis = columnsMap[axisKey] || {
+          bandWidth: bandWidth,
+          remainedWidth: bandWidth,
+          autoWidthCount: 0,
+          categoryGap: '20%',
+          gap: '30%',
+          stacks: {}
+        };
+        var stacks = columnsOnAxis.stacks;
+        columnsMap[axisKey] = columnsOnAxis;
+        var stackId = getSeriesStackId$1(seriesModel);
+
+        if (!stacks[stackId]) {
+          columnsOnAxis.autoWidthCount++;
+        }
+
+        stacks[stackId] = stacks[stackId] || {
+          width: 0,
+          maxWidth: 0
+        };
+        var barWidth = parsePercent$1(seriesModel.get('barWidth'), bandWidth);
+        var barMaxWidth = parsePercent$1(seriesModel.get('barMaxWidth'), bandWidth);
+        var barGap = seriesModel.get('barGap');
+        var barCategoryGap = seriesModel.get('barCategoryGap');
+
+        if (barWidth && !stacks[stackId].width) {
+          barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+          stacks[stackId].width = barWidth;
+          columnsOnAxis.remainedWidth -= barWidth;
+        }
+
+        barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+        barGap != null && (columnsOnAxis.gap = barGap);
+        barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+      });
+      var result = {};
+      each(columnsMap, function (columnsOnAxis, coordSysName) {
+        result[coordSysName] = {};
+        var stacks = columnsOnAxis.stacks;
+        var bandWidth = columnsOnAxis.bandWidth;
+        var categoryGap = parsePercent$1(columnsOnAxis.categoryGap, bandWidth);
+        var barGapPercent = parsePercent$1(columnsOnAxis.gap, 1);
+        var remainedWidth = columnsOnAxis.remainedWidth;
+        var autoWidthCount = columnsOnAxis.autoWidthCount;
+        var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+        autoWidth = Math.max(autoWidth, 0); // Find if any auto calculated bar exceeded maxBarWidth
+
+        each(stacks, function (column, stack) {
+          var maxWidth = column.maxWidth;
+
+          if (maxWidth && maxWidth < autoWidth) {
+            maxWidth = Math.min(maxWidth, remainedWidth);
+
+            if (column.width) {
+              maxWidth = Math.min(maxWidth, column.width);
+            }
+
+            remainedWidth -= maxWidth;
+            column.width = maxWidth;
+            autoWidthCount--;
+          }
+        }); // Recalculate width again
+
+        autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+        autoWidth = Math.max(autoWidth, 0);
+        var widthSum = 0;
+        var lastColumn;
+        each(stacks, function (column, idx) {
+          if (!column.width) {
+            column.width = autoWidth;
+          }
+
+          lastColumn = column;
+          widthSum += column.width * (1 + barGapPercent);
+        });
+
+        if (lastColumn) {
+          widthSum -= lastColumn.width * barGapPercent;
+        }
+
+        var offset = -widthSum / 2;
+        each(stacks, function (column, stackId) {
+          result[coordSysName][stackId] = result[coordSysName][stackId] || {
+            offset: offset,
+            width: column.width
+          };
+          offset += column.width * (1 + barGapPercent);
+        });
+      });
+      return result;
+    }
+
+    var angleAxisExtraOption = {
+      startAngle: 90,
+      clockwise: true,
+      splitNumber: 12,
+      axisLabel: {
+        rotate: 0
+      }
+    };
+    var radiusAxisExtraOption = {
+      splitNumber: 5
+    };
+
+    var PolarView =
+    /** @class */
+    function (_super) {
+      __extends(PolarView, _super);
+
+      function PolarView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PolarView.type;
+        return _this;
+      }
+
+      PolarView.type = 'polar';
+      return PolarView;
+    }(ComponentView);
+
+    function install$u(registers) {
+      use(install$s);
+      AxisView.registerAxisPointerClass('PolarAxisPointer', PolarAxisPointer);
+      registers.registerCoordinateSystem('polar', polarCreator);
+      registers.registerComponentModel(PolarModel);
+      registers.registerComponentView(PolarView); // Model and view for angleAxis and radiusAxis
+
+      axisModelCreator(registers, 'angle', AngleAxisModel, angleAxisExtraOption);
+      axisModelCreator(registers, 'radius', RadiusAxisModel, radiusAxisExtraOption);
+      registers.registerComponentView(AngleAxisView);
+      registers.registerComponentView(RadiusAxisView);
+      registers.registerLayout(curry(barLayoutPolar, 'bar'));
+    }
+
+    function layout$2(axisModel, opt) {
+      opt = opt || {};
+      var single = axisModel.coordinateSystem;
+      var axis = axisModel.axis;
+      var layout = {};
+      var axisPosition = axis.position;
+      var orient = axis.orient;
+      var rect = single.getRect();
+      var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+      var positionMap = {
+        horizontal: {
+          top: rectBound[2],
+          bottom: rectBound[3]
+        },
+        vertical: {
+          left: rectBound[0],
+          right: rectBound[1]
+        }
+      };
+      layout.position = [orient === 'vertical' ? positionMap.vertical[axisPosition] : rectBound[0], orient === 'horizontal' ? positionMap.horizontal[axisPosition] : rectBound[3]];
+      var r = {
+        horizontal: 0,
+        vertical: 1
+      };
+      layout.rotation = Math.PI / 2 * r[orient];
+      var directionMap = {
+        top: -1,
+        bottom: 1,
+        right: 1,
+        left: -1
+      };
+      layout.labelDirection = layout.tickDirection = layout.nameDirection = directionMap[axisPosition];
+
+      if (axisModel.get(['axisTick', 'inside'])) {
+        layout.tickDirection = -layout.tickDirection;
+      }
+
+      if (retrieve(opt.labelInside, axisModel.get(['axisLabel', 'inside']))) {
+        layout.labelDirection = -layout.labelDirection;
+      }
+
+      var labelRotation = opt.rotate;
+      labelRotation == null && (labelRotation = axisModel.get(['axisLabel', 'rotate']));
+      layout.labelRotation = axisPosition === 'top' ? -labelRotation : labelRotation;
+      layout.z2 = 1;
+      return layout;
+    }
+
+    var axisBuilderAttrs$3 = ['axisLine', 'axisTickLabel', 'axisName'];
+    var selfBuilderAttrs$2 = ['splitArea', 'splitLine'];
+
+    var SingleAxisView =
+    /** @class */
+    function (_super) {
+      __extends(SingleAxisView, _super);
+
+      function SingleAxisView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SingleAxisView.type;
+        _this.axisPointerClass = 'SingleAxisPointer';
+        return _this;
+      }
+
+      SingleAxisView.prototype.render = function (axisModel, ecModel, api, payload) {
+        var group = this.group;
+        group.removeAll();
+        var oldAxisGroup = this._axisGroup;
+        this._axisGroup = new Group();
+        var layout = layout$2(axisModel);
+        var axisBuilder = new AxisBuilder(axisModel, layout);
+        each(axisBuilderAttrs$3, axisBuilder.add, axisBuilder);
+        group.add(this._axisGroup);
+        group.add(axisBuilder.getGroup());
+        each(selfBuilderAttrs$2, function (name) {
+          if (axisModel.get([name, 'show'])) {
+            axisElementBuilders$2[name](this, this.group, this._axisGroup, axisModel);
+          }
+        }, this);
+        groupTransition(oldAxisGroup, this._axisGroup, axisModel);
+
+        _super.prototype.render.call(this, axisModel, ecModel, api, payload);
+      };
+
+      SingleAxisView.prototype.remove = function () {
+        rectCoordAxisHandleRemove(this);
+      };
+
+      SingleAxisView.type = 'singleAxis';
+      return SingleAxisView;
+    }(AxisView);
+
+    var axisElementBuilders$2 = {
+      splitLine: function (axisView, group, axisGroup, axisModel) {
+        var axis = axisModel.axis;
+
+        if (axis.scale.isBlank()) {
+          return;
+        }
+
+        var splitLineModel = axisModel.getModel('splitLine');
+        var lineStyleModel = splitLineModel.getModel('lineStyle');
+        var lineColors = lineStyleModel.get('color');
+        lineColors = lineColors instanceof Array ? lineColors : [lineColors];
+        var gridRect = axisModel.coordinateSystem.getRect();
+        var isHorizontal = axis.isHorizontal();
+        var splitLines = [];
+        var lineCount = 0;
+        var ticksCoords = axis.getTicksCoords({
+          tickModel: splitLineModel
+        });
+        var p1 = [];
+        var p2 = [];
+
+        for (var i = 0; i < ticksCoords.length; ++i) {
+          var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
+
+          if (isHorizontal) {
+            p1[0] = tickCoord;
+            p1[1] = gridRect.y;
+            p2[0] = tickCoord;
+            p2[1] = gridRect.y + gridRect.height;
+          } else {
+            p1[0] = gridRect.x;
+            p1[1] = tickCoord;
+            p2[0] = gridRect.x + gridRect.width;
+            p2[1] = tickCoord;
+          }
+
+          var colorIndex = lineCount++ % lineColors.length;
+          splitLines[colorIndex] = splitLines[colorIndex] || [];
+          splitLines[colorIndex].push(new Line({
+            subPixelOptimize: true,
+            shape: {
+              x1: p1[0],
+              y1: p1[1],
+              x2: p2[0],
+              y2: p2[1]
+            },
+            silent: true
+          }));
+        }
+
+        var lineStyle = lineStyleModel.getLineStyle(['color']);
+
+        for (var i = 0; i < splitLines.length; ++i) {
+          group.add(mergePath$1(splitLines[i], {
+            style: defaults({
+              stroke: lineColors[i % lineColors.length]
+            }, lineStyle),
+            silent: true
+          }));
+        }
+      },
+      splitArea: function (axisView, group, axisGroup, axisModel) {
+        rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, axisModel);
+      }
+    };
+
+    var SingleAxisModel =
+    /** @class */
+    function (_super) {
+      __extends(SingleAxisModel, _super);
+
+      function SingleAxisModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SingleAxisModel.type;
+        return _this;
+      }
+
+      SingleAxisModel.prototype.getCoordSysModel = function () {
+        return this;
+      };
+
+      SingleAxisModel.type = 'singleAxis';
+      SingleAxisModel.layoutMode = 'box';
+      SingleAxisModel.defaultOption = {
+        left: '5%',
+        top: '5%',
+        right: '5%',
+        bottom: '5%',
+        type: 'value',
+        position: 'bottom',
+        orient: 'horizontal',
+        axisLine: {
+          show: true,
+          lineStyle: {
+            width: 1,
+            type: 'solid'
+          }
+        },
+        // Single coordinate system and single axis is the,
+        // which is used as the parent tooltip model.
+        // same model, so we set default tooltip show as true.
+        tooltip: {
+          show: true
+        },
+        axisTick: {
+          show: true,
+          length: 6,
+          lineStyle: {
+            width: 1
+          }
+        },
+        axisLabel: {
+          show: true,
+          interval: 'auto'
+        },
+        splitLine: {
+          show: true,
+          lineStyle: {
+            type: 'dashed',
+            opacity: 0.2
+          }
+        }
+      };
+      return SingleAxisModel;
+    }(ComponentModel);
+
+    mixin(SingleAxisModel, AxisModelCommonMixin.prototype);
+
+    var SingleAxis =
+    /** @class */
+    function (_super) {
+      __extends(SingleAxis, _super);
+
+      function SingleAxis(dim, scale, coordExtent, axisType, position) {
+        var _this = _super.call(this, dim, scale, coordExtent) || this;
+
+        _this.type = axisType || 'value';
+        _this.position = position || 'bottom';
+        return _this;
+      }
+      /**
+       * Judge the orient of the axis.
+       */
+
+
+      SingleAxis.prototype.isHorizontal = function () {
+        var position = this.position;
+        return position === 'top' || position === 'bottom';
+      };
+
+      SingleAxis.prototype.pointToData = function (point, clamp) {
+        return this.coordinateSystem.pointToData(point)[0];
+      };
+
+      return SingleAxis;
+    }(Axis);
+
+    /**
+     * Create a single coordinates system.
+     */
+
+    var Single =
+    /** @class */
+    function () {
+      function Single(axisModel, ecModel, api) {
+        this.type = 'single';
+        this.dimension = 'single';
+        /**
+         * Add it just for draw tooltip.
+         */
+
+        this.dimensions = ['single'];
+        this.axisPointerEnabled = true;
+        this.model = axisModel;
+
+        this._init(axisModel, ecModel, api);
+      }
+      /**
+       * Initialize single coordinate system.
+       */
+
+
+      Single.prototype._init = function (axisModel, ecModel, api) {
+        var dim = this.dimension;
+        var axis = new SingleAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisModel.get('position'));
+        var isCategory = axis.type === 'category';
+        axis.onBand = isCategory && axisModel.get('boundaryGap');
+        axis.inverse = axisModel.get('inverse');
+        axis.orient = axisModel.get('orient');
+        axisModel.axis = axis;
+        axis.model = axisModel;
+        axis.coordinateSystem = this;
+        this._axis = axis;
+      };
+      /**
+       * Update axis scale after data processed
+       */
+
+
+      Single.prototype.update = function (ecModel, api) {
+        ecModel.eachSeries(function (seriesModel) {
+          if (seriesModel.coordinateSystem === this) {
+            var data_1 = seriesModel.getData();
+            each(data_1.mapDimensionsAll(this.dimension), function (dim) {
+              this._axis.scale.unionExtentFromData(data_1, dim);
+            }, this);
+            niceScaleExtent(this._axis.scale, this._axis.model);
+          }
+        }, this);
+      };
+      /**
+       * Resize the single coordinate system.
+       */
+
+
+      Single.prototype.resize = function (axisModel, api) {
+        this._rect = getLayoutRect({
+          left: axisModel.get('left'),
+          top: axisModel.get('top'),
+          right: axisModel.get('right'),
+          bottom: axisModel.get('bottom'),
+          width: axisModel.get('width'),
+          height: axisModel.get('height')
+        }, {
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+
+        this._adjustAxis();
+      };
+
+      Single.prototype.getRect = function () {
+        return this._rect;
+      };
+
+      Single.prototype._adjustAxis = function () {
+        var rect = this._rect;
+        var axis = this._axis;
+        var isHorizontal = axis.isHorizontal();
+        var extent = isHorizontal ? [0, rect.width] : [0, rect.height];
+        var idx = axis.reverse ? 1 : 0;
+        axis.setExtent(extent[idx], extent[1 - idx]);
+
+        this._updateAxisTransform(axis, isHorizontal ? rect.x : rect.y);
+      };
+
+      Single.prototype._updateAxisTransform = function (axis, coordBase) {
+        var axisExtent = axis.getExtent();
+        var extentSum = axisExtent[0] + axisExtent[1];
+        var isHorizontal = axis.isHorizontal();
+        axis.toGlobalCoord = isHorizontal ? function (coord) {
+          return coord + coordBase;
+        } : function (coord) {
+          return extentSum - coord + coordBase;
+        };
+        axis.toLocalCoord = isHorizontal ? function (coord) {
+          return coord - coordBase;
+        } : function (coord) {
+          return extentSum - coord + coordBase;
+        };
+      };
+      /**
+       * Get axis.
+       */
+
+
+      Single.prototype.getAxis = function () {
+        return this._axis;
+      };
+      /**
+       * Get axis, add it just for draw tooltip.
+       */
+
+
+      Single.prototype.getBaseAxis = function () {
+        return this._axis;
+      };
+
+      Single.prototype.getAxes = function () {
+        return [this._axis];
+      };
+
+      Single.prototype.getTooltipAxes = function () {
+        return {
+          baseAxes: [this.getAxis()],
+          // Empty otherAxes
+          otherAxes: []
+        };
+      };
+      /**
+       * If contain point.
+       */
+
+
+      Single.prototype.containPoint = function (point) {
+        var rect = this.getRect();
+        var axis = this.getAxis();
+        var orient = axis.orient;
+
+        if (orient === 'horizontal') {
+          return axis.contain(axis.toLocalCoord(point[0])) && point[1] >= rect.y && point[1] <= rect.y + rect.height;
+        } else {
+          return axis.contain(axis.toLocalCoord(point[1])) && point[0] >= rect.y && point[0] <= rect.y + rect.height;
+        }
+      };
+
+      Single.prototype.pointToData = function (point) {
+        var axis = this.getAxis();
+        return [axis.coordToData(axis.toLocalCoord(point[axis.orient === 'horizontal' ? 0 : 1]))];
+      };
+      /**
+       * Convert the series data to concrete point.
+       * Can be [val] | val
+       */
+
+
+      Single.prototype.dataToPoint = function (val) {
+        var axis = this.getAxis();
+        var rect = this.getRect();
+        var pt = [];
+        var idx = axis.orient === 'horizontal' ? 0 : 1;
+
+        if (val instanceof Array) {
+          val = val[0];
+        }
+
+        pt[idx] = axis.toGlobalCoord(axis.dataToCoord(+val));
+        pt[1 - idx] = idx === 0 ? rect.y + rect.height / 2 : rect.x + rect.width / 2;
+        return pt;
+      };
+
+      Single.prototype.convertToPixel = function (ecModel, finder, value) {
+        var coordSys = getCoordSys$3(finder);
+        return coordSys === this ? this.dataToPoint(value) : null;
+      };
+
+      Single.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        var coordSys = getCoordSys$3(finder);
+        return coordSys === this ? this.pointToData(pixel) : null;
+      };
+
+      return Single;
+    }();
+
+    function getCoordSys$3(finder) {
+      var seriesModel = finder.seriesModel;
+      var singleModel = finder.singleAxisModel;
+      return singleModel && singleModel.coordinateSystem || seriesModel && seriesModel.coordinateSystem;
+    }
+
+    /**
+     * Create single coordinate system and inject it into seriesModel.
+     */
+
+    function create$2(ecModel, api) {
+      var singles = [];
+      ecModel.eachComponent('singleAxis', function (axisModel, idx) {
+        var single = new Single(axisModel, ecModel, api);
+        single.name = 'single_' + idx;
+        single.resize(axisModel, api);
+        axisModel.coordinateSystem = single;
+        singles.push(single);
+      });
+      ecModel.eachSeries(function (seriesModel) {
+        if (seriesModel.get('coordinateSystem') === 'singleAxis') {
+          var singleAxisModel = seriesModel.getReferringComponents('singleAxis', SINGLE_REFERRING).models[0];
+          seriesModel.coordinateSystem = singleAxisModel && singleAxisModel.coordinateSystem;
+        }
+      });
+      return singles;
+    }
+
+    var singleCreator = {
+      create: create$2,
+      dimensions: Single.prototype.dimensions
+    };
+
+    var XY = ['x', 'y'];
+    var WH = ['width', 'height'];
+
+    var SingleAxisPointer =
+    /** @class */
+    function (_super) {
+      __extends(SingleAxisPointer, _super);
+
+      function SingleAxisPointer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      /**
+       * @override
+       */
+
+
+      SingleAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+        var axis = axisModel.axis;
+        var coordSys = axis.coordinateSystem;
+        var otherExtent = getGlobalExtent(coordSys, 1 - getPointDimIndex(axis));
+        var pixelValue = coordSys.dataToPoint(value)[0];
+        var axisPointerType = axisPointerModel.get('type');
+
+        if (axisPointerType && axisPointerType !== 'none') {
+          var elStyle = buildElStyle(axisPointerModel);
+          var pointerOption = pointerShapeBuilder$2[axisPointerType](axis, pixelValue, otherExtent);
+          pointerOption.style = elStyle;
+          elOption.graphicKey = pointerOption.type;
+          elOption.pointer = pointerOption;
+        }
+
+        var layoutInfo = layout$2(axisModel);
+        buildCartesianSingleLabelElOption( // @ts-ignore
+        value, elOption, layoutInfo, axisModel, axisPointerModel, api);
+      };
+      /**
+       * @override
+       */
+
+
+      SingleAxisPointer.prototype.getHandleTransform = function (value, axisModel, axisPointerModel) {
+        var layoutInfo = layout$2(axisModel, {
+          labelInside: false
+        }); // @ts-ignore
+
+        layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']);
+        var position = getTransformedPosition(axisModel.axis, value, layoutInfo);
+        return {
+          x: position[0],
+          y: position[1],
+          rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
+        };
+      };
+      /**
+       * @override
+       */
+
+
+      SingleAxisPointer.prototype.updateHandleTransform = function (transform, delta, axisModel, axisPointerModel) {
+        var axis = axisModel.axis;
+        var coordSys = axis.coordinateSystem;
+        var dimIndex = getPointDimIndex(axis);
+        var axisExtent = getGlobalExtent(coordSys, dimIndex);
+        var currPosition = [transform.x, transform.y];
+        currPosition[dimIndex] += delta[dimIndex];
+        currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]);
+        currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]);
+        var otherExtent = getGlobalExtent(coordSys, 1 - dimIndex);
+        var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
+        var cursorPoint = [cursorOtherValue, cursorOtherValue];
+        cursorPoint[dimIndex] = currPosition[dimIndex];
+        return {
+          x: currPosition[0],
+          y: currPosition[1],
+          rotation: transform.rotation,
+          cursorPoint: cursorPoint,
+          tooltipOption: {
+            verticalAlign: 'middle'
+          }
+        };
+      };
+
+      return SingleAxisPointer;
+    }(BaseAxisPointer);
+
+    var pointerShapeBuilder$2 = {
+      line: function (axis, pixelValue, otherExtent) {
+        var targetShape = makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getPointDimIndex(axis));
+        return {
+          type: 'Line',
+          subPixelOptimize: true,
+          shape: targetShape
+        };
+      },
+      shadow: function (axis, pixelValue, otherExtent) {
+        var bandWidth = axis.getBandWidth();
+        var span = otherExtent[1] - otherExtent[0];
+        return {
+          type: 'Rect',
+          shape: makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getPointDimIndex(axis))
+        };
+      }
+    };
+
+    function getPointDimIndex(axis) {
+      return axis.isHorizontal() ? 0 : 1;
+    }
+
+    function getGlobalExtent(coordSys, dimIndex) {
+      var rect = coordSys.getRect();
+      return [rect[XY[dimIndex]], rect[XY[dimIndex]] + rect[WH[dimIndex]]];
+    }
+
+    var SingleView =
+    /** @class */
+    function (_super) {
+      __extends(SingleView, _super);
+
+      function SingleView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SingleView.type;
+        return _this;
+      }
+
+      SingleView.type = 'single';
+      return SingleView;
+    }(ComponentView);
+
+    function install$v(registers) {
+      use(install$s);
+      AxisView.registerAxisPointerClass('SingleAxisPointer', SingleAxisPointer);
+      registers.registerComponentView(SingleView); // Axis
+
+      registers.registerComponentView(SingleAxisView);
+      registers.registerComponentModel(SingleAxisModel);
+      axisModelCreator(registers, 'single', SingleAxisModel, SingleAxisModel.defaultOption);
+      registers.registerCoordinateSystem('single', singleCreator);
+    }
+
+    var CalendarModel =
+    /** @class */
+    function (_super) {
+      __extends(CalendarModel, _super);
+
+      function CalendarModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CalendarModel.type;
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      CalendarModel.prototype.init = function (option, parentModel, ecModel) {
+        var inputPositionParams = getLayoutParams(option);
+
+        _super.prototype.init.apply(this, arguments);
+
+        mergeAndNormalizeLayoutParams(option, inputPositionParams);
+      };
+      /**
+       * @override
+       */
+
+
+      CalendarModel.prototype.mergeOption = function (option) {
+        _super.prototype.mergeOption.apply(this, arguments);
+
+        mergeAndNormalizeLayoutParams(this.option, option);
+      };
+
+      CalendarModel.prototype.getCellSize = function () {
+        // Has been normalized
+        return this.option.cellSize;
+      };
+
+      CalendarModel.type = 'calendar';
+      CalendarModel.defaultOption = {
+        zlevel: 0,
+        z: 2,
+        left: 80,
+        top: 60,
+        cellSize: 20,
+        // horizontal vertical
+        orient: 'horizontal',
+        // month separate line style
+        splitLine: {
+          show: true,
+          lineStyle: {
+            color: '#000',
+            width: 1,
+            type: 'solid'
+          }
+        },
+        // rect style  temporarily unused emphasis
+        itemStyle: {
+          color: '#fff',
+          borderWidth: 1,
+          borderColor: '#ccc'
+        },
+        // week text style
+        dayLabel: {
+          show: true,
+          firstDay: 0,
+          // start end
+          position: 'start',
+          margin: '50%',
+          nameMap: 'en',
+          color: '#000'
+        },
+        // month text style
+        monthLabel: {
+          show: true,
+          // start end
+          position: 'start',
+          margin: 5,
+          // center or left
+          align: 'center',
+          // cn en []
+          nameMap: 'en',
+          formatter: null,
+          color: '#000'
+        },
+        // year text style
+        yearLabel: {
+          show: true,
+          // top bottom left right
+          position: null,
+          margin: 30,
+          formatter: null,
+          color: '#ccc',
+          fontFamily: 'sans-serif',
+          fontWeight: 'bolder',
+          fontSize: 20
+        }
+      };
+      return CalendarModel;
+    }(ComponentModel);
+
+    function mergeAndNormalizeLayoutParams(target, raw) {
+      // Normalize cellSize
+      var cellSize = target.cellSize;
+      var cellSizeArr;
+
+      if (!isArray(cellSize)) {
+        cellSizeArr = target.cellSize = [cellSize, cellSize];
+      } else {
+        cellSizeArr = cellSize;
+      }
+
+      if (cellSizeArr.length === 1) {
+        cellSizeArr[1] = cellSizeArr[0];
+      }
+
+      var ignoreSize = map([0, 1], function (hvIdx) {
+        // If user have set `width` or both `left` and `right`, cellSizeArr
+        // will be automatically set to 'auto', otherwise the default
+        // setting of cellSizeArr will make `width` setting not work.
+        if (sizeCalculable(raw, hvIdx)) {
+          cellSizeArr[hvIdx] = 'auto';
+        }
+
+        return cellSizeArr[hvIdx] != null && cellSizeArr[hvIdx] !== 'auto';
+      });
+      mergeLayoutParam(target, raw, {
+        type: 'box',
+        ignoreSize: ignoreSize
+      });
+    }
+
+    var MONTH_TEXT = {
+      EN: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+      CN: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']
+    };
+    var WEEK_TEXT = {
+      EN: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
+      CN: ['日', '一', '二', '三', '四', '五', '六']
+    };
+
+    var CalendarView =
+    /** @class */
+    function (_super) {
+      __extends(CalendarView, _super);
+
+      function CalendarView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = CalendarView.type;
+        return _this;
+      }
+
+      CalendarView.prototype.render = function (calendarModel, ecModel, api) {
+        var group = this.group;
+        group.removeAll();
+        var coordSys = calendarModel.coordinateSystem; // range info
+
+        var rangeData = coordSys.getRangeInfo();
+        var orient = coordSys.getOrient();
+
+        this._renderDayRect(calendarModel, rangeData, group); // _renderLines must be called prior to following function
+
+
+        this._renderLines(calendarModel, rangeData, orient, group);
+
+        this._renderYearText(calendarModel, rangeData, orient, group);
+
+        this._renderMonthText(calendarModel, orient, group);
+
+        this._renderWeekText(calendarModel, rangeData, orient, group);
+      }; // render day rect
+
+
+      CalendarView.prototype._renderDayRect = function (calendarModel, rangeData, group) {
+        var coordSys = calendarModel.coordinateSystem;
+        var itemRectStyleModel = calendarModel.getModel('itemStyle').getItemStyle();
+        var sw = coordSys.getCellWidth();
+        var sh = coordSys.getCellHeight();
+
+        for (var i = rangeData.start.time; i <= rangeData.end.time; i = coordSys.getNextNDay(i, 1).time) {
+          var point = coordSys.dataToRect([i], false).tl; // every rect
+
+          var rect = new Rect({
+            shape: {
+              x: point[0],
+              y: point[1],
+              width: sw,
+              height: sh
+            },
+            cursor: 'default',
+            style: itemRectStyleModel
+          });
+          group.add(rect);
+        }
+      }; // render separate line
+
+
+      CalendarView.prototype._renderLines = function (calendarModel, rangeData, orient, group) {
+        var self = this;
+        var coordSys = calendarModel.coordinateSystem;
+        var lineStyleModel = calendarModel.getModel(['splitLine', 'lineStyle']).getLineStyle();
+        var show = calendarModel.get(['splitLine', 'show']);
+        var lineWidth = lineStyleModel.lineWidth;
+        this._tlpoints = [];
+        this._blpoints = [];
+        this._firstDayOfMonth = [];
+        this._firstDayPoints = [];
+        var firstDay = rangeData.start;
+
+        for (var i = 0; firstDay.time <= rangeData.end.time; i++) {
+          addPoints(firstDay.formatedDate);
+
+          if (i === 0) {
+            firstDay = coordSys.getDateInfo(rangeData.start.y + '-' + rangeData.start.m);
+          }
+
+          var date = firstDay.date;
+          date.setMonth(date.getMonth() + 1);
+          firstDay = coordSys.getDateInfo(date);
+        }
+
+        addPoints(coordSys.getNextNDay(rangeData.end.time, 1).formatedDate);
+
+        function addPoints(date) {
+          self._firstDayOfMonth.push(coordSys.getDateInfo(date));
+
+          self._firstDayPoints.push(coordSys.dataToRect([date], false).tl);
+
+          var points = self._getLinePointsOfOneWeek(calendarModel, date, orient);
+
+          self._tlpoints.push(points[0]);
+
+          self._blpoints.push(points[points.length - 1]);
+
+          show && self._drawSplitline(points, lineStyleModel, group);
+        } // render top/left line
+
+
+        show && this._drawSplitline(self._getEdgesPoints(self._tlpoints, lineWidth, orient), lineStyleModel, group); // render bottom/right line
+
+        show && this._drawSplitline(self._getEdgesPoints(self._blpoints, lineWidth, orient), lineStyleModel, group);
+      }; // get points at both ends
+
+
+      CalendarView.prototype._getEdgesPoints = function (points, lineWidth, orient) {
+        var rs = [points[0].slice(), points[points.length - 1].slice()];
+        var idx = orient === 'horizontal' ? 0 : 1; // both ends of the line are extend half lineWidth
+
+        rs[0][idx] = rs[0][idx] - lineWidth / 2;
+        rs[1][idx] = rs[1][idx] + lineWidth / 2;
+        return rs;
+      }; // render split line
+
+
+      CalendarView.prototype._drawSplitline = function (points, lineStyle, group) {
+        var poyline = new Polyline({
+          z2: 20,
+          shape: {
+            points: points
+          },
+          style: lineStyle
+        });
+        group.add(poyline);
+      }; // render month line of one week points
+
+
+      CalendarView.prototype._getLinePointsOfOneWeek = function (calendarModel, date, orient) {
+        var coordSys = calendarModel.coordinateSystem;
+        var parsedDate = coordSys.getDateInfo(date);
+        var points = [];
+
+        for (var i = 0; i < 7; i++) {
+          var tmpD = coordSys.getNextNDay(parsedDate.time, i);
+          var point = coordSys.dataToRect([tmpD.time], false);
+          points[2 * tmpD.day] = point.tl;
+          points[2 * tmpD.day + 1] = point[orient === 'horizontal' ? 'bl' : 'tr'];
+        }
+
+        return points;
+      };
+
+      CalendarView.prototype._formatterLabel = function (formatter, params) {
+        if (typeof formatter === 'string' && formatter) {
+          return formatTplSimple(formatter, params);
+        }
+
+        if (typeof formatter === 'function') {
+          return formatter(params);
+        }
+
+        return params.nameMap;
+      };
+
+      CalendarView.prototype._yearTextPositionControl = function (textEl, point, orient, position, margin) {
+        var x = point[0];
+        var y = point[1];
+        var aligns = ['center', 'bottom'];
+
+        if (position === 'bottom') {
+          y += margin;
+          aligns = ['center', 'top'];
+        } else if (position === 'left') {
+          x -= margin;
+        } else if (position === 'right') {
+          x += margin;
+          aligns = ['center', 'top'];
+        } else {
+          // top
+          y -= margin;
+        }
+
+        var rotate = 0;
+
+        if (position === 'left' || position === 'right') {
+          rotate = Math.PI / 2;
+        }
+
+        return {
+          rotation: rotate,
+          x: x,
+          y: y,
+          style: {
+            align: aligns[0],
+            verticalAlign: aligns[1]
+          }
+        };
+      }; // render year
+
+
+      CalendarView.prototype._renderYearText = function (calendarModel, rangeData, orient, group) {
+        var yearLabel = calendarModel.getModel('yearLabel');
+
+        if (!yearLabel.get('show')) {
+          return;
+        }
+
+        var margin = yearLabel.get('margin');
+        var pos = yearLabel.get('position');
+
+        if (!pos) {
+          pos = orient !== 'horizontal' ? 'top' : 'left';
+        }
+
+        var points = [this._tlpoints[this._tlpoints.length - 1], this._blpoints[0]];
+        var xc = (points[0][0] + points[1][0]) / 2;
+        var yc = (points[0][1] + points[1][1]) / 2;
+        var idx = orient === 'horizontal' ? 0 : 1;
+        var posPoints = {
+          top: [xc, points[idx][1]],
+          bottom: [xc, points[1 - idx][1]],
+          left: [points[1 - idx][0], yc],
+          right: [points[idx][0], yc]
+        };
+        var name = rangeData.start.y;
+
+        if (+rangeData.end.y > +rangeData.start.y) {
+          name = name + '-' + rangeData.end.y;
+        }
+
+        var formatter = yearLabel.get('formatter');
+        var params = {
+          start: rangeData.start.y,
+          end: rangeData.end.y,
+          nameMap: name
+        };
+
+        var content = this._formatterLabel(formatter, params);
+
+        var yearText = new ZRText({
+          z2: 30,
+          style: createTextStyle(yearLabel, {
+            text: content
+          })
+        });
+        yearText.attr(this._yearTextPositionControl(yearText, posPoints[pos], orient, pos, margin));
+        group.add(yearText);
+      };
+
+      CalendarView.prototype._monthTextPositionControl = function (point, isCenter, orient, position, margin) {
+        var align = 'left';
+        var vAlign = 'top';
+        var x = point[0];
+        var y = point[1];
+
+        if (orient === 'horizontal') {
+          y = y + margin;
+
+          if (isCenter) {
+            align = 'center';
+          }
+
+          if (position === 'start') {
+            vAlign = 'bottom';
+          }
+        } else {
+          x = x + margin;
+
+          if (isCenter) {
+            vAlign = 'middle';
+          }
+
+          if (position === 'start') {
+            align = 'right';
+          }
+        }
+
+        return {
+          x: x,
+          y: y,
+          align: align,
+          verticalAlign: vAlign
+        };
+      }; // render month and year text
+
+
+      CalendarView.prototype._renderMonthText = function (calendarModel, orient, group) {
+        var monthLabel = calendarModel.getModel('monthLabel');
+
+        if (!monthLabel.get('show')) {
+          return;
+        }
+
+        var nameMap = monthLabel.get('nameMap');
+        var margin = monthLabel.get('margin');
+        var pos = monthLabel.get('position');
+        var align = monthLabel.get('align');
+        var termPoints = [this._tlpoints, this._blpoints];
+
+        if (isString(nameMap)) {
+          nameMap = MONTH_TEXT[nameMap.toUpperCase()] || [];
+        }
+
+        var idx = pos === 'start' ? 0 : 1;
+        var axis = orient === 'horizontal' ? 0 : 1;
+        margin = pos === 'start' ? -margin : margin;
+        var isCenter = align === 'center';
+
+        for (var i = 0; i < termPoints[idx].length - 1; i++) {
+          var tmp = termPoints[idx][i].slice();
+          var firstDay = this._firstDayOfMonth[i];
+
+          if (isCenter) {
+            var firstDayPoints = this._firstDayPoints[i];
+            tmp[axis] = (firstDayPoints[axis] + termPoints[0][i + 1][axis]) / 2;
+          }
+
+          var formatter = monthLabel.get('formatter');
+          var name_1 = nameMap[+firstDay.m - 1];
+          var params = {
+            yyyy: firstDay.y,
+            yy: (firstDay.y + '').slice(2),
+            MM: firstDay.m,
+            M: +firstDay.m,
+            nameMap: name_1
+          };
+
+          var content = this._formatterLabel(formatter, params);
+
+          var monthText = new ZRText({
+            z2: 30,
+            style: extend(createTextStyle(monthLabel, {
+              text: content
+            }), this._monthTextPositionControl(tmp, isCenter, orient, pos, margin))
+          });
+          group.add(monthText);
+        }
+      };
+
+      CalendarView.prototype._weekTextPositionControl = function (point, orient, position, margin, cellSize) {
+        var align = 'center';
+        var vAlign = 'middle';
+        var x = point[0];
+        var y = point[1];
+        var isStart = position === 'start';
+
+        if (orient === 'horizontal') {
+          x = x + margin + (isStart ? 1 : -1) * cellSize[0] / 2;
+          align = isStart ? 'right' : 'left';
+        } else {
+          y = y + margin + (isStart ? 1 : -1) * cellSize[1] / 2;
+          vAlign = isStart ? 'bottom' : 'top';
+        }
+
+        return {
+          x: x,
+          y: y,
+          align: align,
+          verticalAlign: vAlign
+        };
+      }; // render weeks
+
+
+      CalendarView.prototype._renderWeekText = function (calendarModel, rangeData, orient, group) {
+        var dayLabel = calendarModel.getModel('dayLabel');
+
+        if (!dayLabel.get('show')) {
+          return;
+        }
+
+        var coordSys = calendarModel.coordinateSystem;
+        var pos = dayLabel.get('position');
+        var nameMap = dayLabel.get('nameMap');
+        var margin = dayLabel.get('margin');
+        var firstDayOfWeek = coordSys.getFirstDayOfWeek();
+
+        if (isString(nameMap)) {
+          nameMap = WEEK_TEXT[nameMap.toUpperCase()] || [];
+        }
+
+        var start = coordSys.getNextNDay(rangeData.end.time, 7 - rangeData.lweek).time;
+        var cellSize = [coordSys.getCellWidth(), coordSys.getCellHeight()];
+        margin = parsePercent$1(margin, cellSize[orient === 'horizontal' ? 0 : 1]);
+
+        if (pos === 'start') {
+          start = coordSys.getNextNDay(rangeData.start.time, -(7 + rangeData.fweek)).time;
+          margin = -margin;
+        }
+
+        for (var i = 0; i < 7; i++) {
+          var tmpD = coordSys.getNextNDay(start, i);
+          var point = coordSys.dataToRect([tmpD.time], false).center;
+          var day = i;
+          day = Math.abs((i + firstDayOfWeek) % 7);
+          var weekText = new ZRText({
+            z2: 30,
+            style: extend(createTextStyle(dayLabel, {
+              text: nameMap[day]
+            }), this._weekTextPositionControl(point, orient, pos, margin, cellSize))
+          });
+          group.add(weekText);
+        }
+      };
+
+      CalendarView.type = 'calendar';
+      return CalendarView;
+    }(ComponentView);
+
+    var PROXIMATE_ONE_DAY = 86400000;
+
+    var Calendar =
+    /** @class */
+    function () {
+      function Calendar(calendarModel, ecModel, api) {
+        this.type = 'calendar';
+        this.dimensions = Calendar.dimensions; // Required in createListFromData
+
+        this.getDimensionsInfo = Calendar.getDimensionsInfo;
+        this._model = calendarModel;
+      }
+
+      Calendar.getDimensionsInfo = function () {
+        return [{
+          name: 'time',
+          type: 'time'
+        }, 'value'];
+      };
+
+      Calendar.prototype.getRangeInfo = function () {
+        return this._rangeInfo;
+      };
+
+      Calendar.prototype.getModel = function () {
+        return this._model;
+      };
+
+      Calendar.prototype.getRect = function () {
+        return this._rect;
+      };
+
+      Calendar.prototype.getCellWidth = function () {
+        return this._sw;
+      };
+
+      Calendar.prototype.getCellHeight = function () {
+        return this._sh;
+      };
+
+      Calendar.prototype.getOrient = function () {
+        return this._orient;
+      };
+      /**
+       * getFirstDayOfWeek
+       *
+       * @example
+       *     0 : start at Sunday
+       *     1 : start at Monday
+       *
+       * @return {number}
+       */
+
+
+      Calendar.prototype.getFirstDayOfWeek = function () {
+        return this._firstDayOfWeek;
+      };
+      /**
+       * get date info
+       * }
+       */
+
+
+      Calendar.prototype.getDateInfo = function (date) {
+        date = parseDate(date);
+        var y = date.getFullYear();
+        var m = date.getMonth() + 1;
+        var mStr = m < 10 ? '0' + m : '' + m;
+        var d = date.getDate();
+        var dStr = d < 10 ? '0' + d : '' + d;
+        var day = date.getDay();
+        day = Math.abs((day + 7 - this.getFirstDayOfWeek()) % 7);
+        return {
+          y: y + '',
+          m: mStr,
+          d: dStr,
+          day: day,
+          time: date.getTime(),
+          formatedDate: y + '-' + mStr + '-' + dStr,
+          date: date
+        };
+      };
+
+      Calendar.prototype.getNextNDay = function (date, n) {
+        n = n || 0;
+
+        if (n === 0) {
+          return this.getDateInfo(date);
+        }
+
+        date = new Date(this.getDateInfo(date).time);
+        date.setDate(date.getDate() + n);
+        return this.getDateInfo(date);
+      };
+
+      Calendar.prototype.update = function (ecModel, api) {
+        this._firstDayOfWeek = +this._model.getModel('dayLabel').get('firstDay');
+        this._orient = this._model.get('orient');
+        this._lineWidth = this._model.getModel('itemStyle').getItemStyle().lineWidth || 0;
+        this._rangeInfo = this._getRangeInfo(this._initRangeOption());
+        var weeks = this._rangeInfo.weeks || 1;
+        var whNames = ['width', 'height'];
+
+        var cellSize = this._model.getCellSize().slice();
+
+        var layoutParams = this._model.getBoxLayoutParams();
+
+        var cellNumbers = this._orient === 'horizontal' ? [weeks, 7] : [7, weeks];
+        each([0, 1], function (idx) {
+          if (cellSizeSpecified(cellSize, idx)) {
+            layoutParams[whNames[idx]] = cellSize[idx] * cellNumbers[idx];
+          }
+        });
+        var whGlobal = {
+          width: api.getWidth(),
+          height: api.getHeight()
+        };
+        var calendarRect = this._rect = getLayoutRect(layoutParams, whGlobal);
+        each([0, 1], function (idx) {
+          if (!cellSizeSpecified(cellSize, idx)) {
+            cellSize[idx] = calendarRect[whNames[idx]] / cellNumbers[idx];
+          }
+        });
+
+        function cellSizeSpecified(cellSize, idx) {
+          return cellSize[idx] != null && cellSize[idx] !== 'auto';
+        } // Has been calculated out number.
+
+
+        this._sw = cellSize[0];
+        this._sh = cellSize[1];
+      };
+      /**
+       * Convert a time data(time, value) item to (x, y) point.
+       */
+      // TODO Clamp of calendar is not same with cartesian coordinate systems.
+      // It will return NaN if data exceeds.
+
+
+      Calendar.prototype.dataToPoint = function (data, clamp) {
+        isArray(data) && (data = data[0]);
+        clamp == null && (clamp = true);
+        var dayInfo = this.getDateInfo(data);
+        var range = this._rangeInfo;
+        var date = dayInfo.formatedDate; // if not in range return [NaN, NaN]
+
+        if (clamp && !(dayInfo.time >= range.start.time && dayInfo.time < range.end.time + PROXIMATE_ONE_DAY)) {
+          return [NaN, NaN];
+        }
+
+        var week = dayInfo.day;
+
+        var nthWeek = this._getRangeInfo([range.start.time, date]).nthWeek;
+
+        if (this._orient === 'vertical') {
+          return [this._rect.x + week * this._sw + this._sw / 2, this._rect.y + nthWeek * this._sh + this._sh / 2];
+        }
+
+        return [this._rect.x + nthWeek * this._sw + this._sw / 2, this._rect.y + week * this._sh + this._sh / 2];
+      };
+      /**
+       * Convert a (x, y) point to time data
+       */
+
+
+      Calendar.prototype.pointToData = function (point) {
+        var date = this.pointToDate(point);
+        return date && date.time;
+      };
+      /**
+       * Convert a time date item to (x, y) four point.
+       */
+
+
+      Calendar.prototype.dataToRect = function (data, clamp) {
+        var point = this.dataToPoint(data, clamp);
+        return {
+          contentShape: {
+            x: point[0] - (this._sw - this._lineWidth) / 2,
+            y: point[1] - (this._sh - this._lineWidth) / 2,
+            width: this._sw - this._lineWidth,
+            height: this._sh - this._lineWidth
+          },
+          center: point,
+          tl: [point[0] - this._sw / 2, point[1] - this._sh / 2],
+          tr: [point[0] + this._sw / 2, point[1] - this._sh / 2],
+          br: [point[0] + this._sw / 2, point[1] + this._sh / 2],
+          bl: [point[0] - this._sw / 2, point[1] + this._sh / 2]
+        };
+      };
+      /**
+       * Convert a (x, y) point to time date
+       *
+       * @param  {Array} point point
+       * @return {Object}       date
+       */
+
+
+      Calendar.prototype.pointToDate = function (point) {
+        var nthX = Math.floor((point[0] - this._rect.x) / this._sw) + 1;
+        var nthY = Math.floor((point[1] - this._rect.y) / this._sh) + 1;
+        var range = this._rangeInfo.range;
+
+        if (this._orient === 'vertical') {
+          return this._getDateByWeeksAndDay(nthY, nthX - 1, range);
+        }
+
+        return this._getDateByWeeksAndDay(nthX, nthY - 1, range);
+      };
+
+      Calendar.prototype.convertToPixel = function (ecModel, finder, value) {
+        var coordSys = getCoordSys$4(finder);
+        return coordSys === this ? coordSys.dataToPoint(value) : null;
+      };
+
+      Calendar.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+        var coordSys = getCoordSys$4(finder);
+        return coordSys === this ? coordSys.pointToData(pixel) : null;
+      };
+
+      Calendar.prototype.containPoint = function (point) {
+        console.warn('Not implemented.');
+        return false;
+      };
+      /**
+       * initRange
+       * Normalize to an [start, end] array
+       */
+
+
+      Calendar.prototype._initRangeOption = function () {
+        var range = this._model.get('range');
+
+        var normalizedRange; // Convert [1990] to 1990
+
+        if (isArray(range) && range.length === 1) {
+          range = range[0];
+        }
+
+        if (!isArray(range)) {
+          var rangeStr = range.toString(); // One year.
+
+          if (/^\d{4}$/.test(rangeStr)) {
+            normalizedRange = [rangeStr + '-01-01', rangeStr + '-12-31'];
+          } // One month
+
+
+          if (/^\d{4}[\/|-]\d{1,2}$/.test(rangeStr)) {
+            var start = this.getDateInfo(rangeStr);
+            var firstDay = start.date;
+            firstDay.setMonth(firstDay.getMonth() + 1);
+            var end = this.getNextNDay(firstDay, -1);
+            normalizedRange = [start.formatedDate, end.formatedDate];
+          } // One day
+
+
+          if (/^\d{4}[\/|-]\d{1,2}[\/|-]\d{1,2}$/.test(rangeStr)) {
+            normalizedRange = [rangeStr, rangeStr];
+          }
+        } else {
+          normalizedRange = range;
+        }
+
+        if (!normalizedRange) {
+          if ("development" !== 'production') {
+            logError('Invalid date range.');
+          } // Not handling it.
+
+
+          return range;
+        }
+
+        var tmp = this._getRangeInfo(normalizedRange);
+
+        if (tmp.start.time > tmp.end.time) {
+          normalizedRange.reverse();
+        }
+
+        return normalizedRange;
+      };
+      /**
+       * range info
+       *
+       * @private
+       * @param  {Array} range range ['2017-01-01', '2017-07-08']
+       *  If range[0] > range[1], they will not be reversed.
+       * @return {Object}       obj
+       */
+
+
+      Calendar.prototype._getRangeInfo = function (range) {
+        var parsedRange = [this.getDateInfo(range[0]), this.getDateInfo(range[1])];
+        var reversed;
+
+        if (parsedRange[0].time > parsedRange[1].time) {
+          reversed = true;
+          parsedRange.reverse();
+        }
+
+        var allDay = Math.floor(parsedRange[1].time / PROXIMATE_ONE_DAY) - Math.floor(parsedRange[0].time / PROXIMATE_ONE_DAY) + 1; // Consider case1 (#11677 #10430):
+        // Set the system timezone as "UK", set the range to `['2016-07-01', '2016-12-31']`
+        // Consider case2:
+        // Firstly set system timezone as "Time Zone: America/Toronto",
+        // ```
+        // let first = new Date(1478412000000 - 3600 * 1000 * 2.5);
+        // let second = new Date(1478412000000);
+        // let allDays = Math.floor(second / ONE_DAY) - Math.floor(first / ONE_DAY) + 1;
+        // ```
+        // will get wrong result because of DST. So we should fix it.
+
+        var date = new Date(parsedRange[0].time);
+        var startDateNum = date.getDate();
+        var endDateNum = parsedRange[1].date.getDate();
+        date.setDate(startDateNum + allDay - 1); // The bias can not over a month, so just compare date.
+
+        var dateNum = date.getDate();
+
+        if (dateNum !== endDateNum) {
+          var sign = date.getTime() - parsedRange[1].time > 0 ? 1 : -1;
+
+          while ((dateNum = date.getDate()) !== endDateNum && (date.getTime() - parsedRange[1].time) * sign > 0) {
+            allDay -= sign;
+            date.setDate(dateNum - sign);
+          }
+        }
+
+        var weeks = Math.floor((allDay + parsedRange[0].day + 6) / 7);
+        var nthWeek = reversed ? -weeks + 1 : weeks - 1;
+        reversed && parsedRange.reverse();
+        return {
+          range: [parsedRange[0].formatedDate, parsedRange[1].formatedDate],
+          start: parsedRange[0],
+          end: parsedRange[1],
+          allDay: allDay,
+          weeks: weeks,
+          // From 0.
+          nthWeek: nthWeek,
+          fweek: parsedRange[0].day,
+          lweek: parsedRange[1].day
+        };
+      };
+      /**
+       * get date by nthWeeks and week day in range
+       *
+       * @private
+       * @param  {number} nthWeek the week
+       * @param  {number} day   the week day
+       * @param  {Array} range [d1, d2]
+       * @return {Object}
+       */
+
+
+      Calendar.prototype._getDateByWeeksAndDay = function (nthWeek, day, range) {
+        var rangeInfo = this._getRangeInfo(range);
+
+        if (nthWeek > rangeInfo.weeks || nthWeek === 0 && day < rangeInfo.fweek || nthWeek === rangeInfo.weeks && day > rangeInfo.lweek) {
+          return null;
+        }
+
+        var nthDay = (nthWeek - 1) * 7 - rangeInfo.fweek + day;
+        var date = new Date(rangeInfo.start.time);
+        date.setDate(+rangeInfo.start.d + nthDay);
+        return this.getDateInfo(date);
+      };
+
+      Calendar.create = function (ecModel, api) {
+        var calendarList = [];
+        ecModel.eachComponent('calendar', function (calendarModel) {
+          var calendar = new Calendar(calendarModel, ecModel, api);
+          calendarList.push(calendar);
+          calendarModel.coordinateSystem = calendar;
+        });
+        ecModel.eachSeries(function (calendarSeries) {
+          if (calendarSeries.get('coordinateSystem') === 'calendar') {
+            // Inject coordinate system
+            calendarSeries.coordinateSystem = calendarList[calendarSeries.get('calendarIndex') || 0];
+          }
+        });
+        return calendarList;
+      };
+
+      Calendar.dimensions = ['time', 'value'];
+      return Calendar;
+    }();
+
+    function getCoordSys$4(finder) {
+      var calendarModel = finder.calendarModel;
+      var seriesModel = finder.seriesModel;
+      var coordSys = calendarModel ? calendarModel.coordinateSystem : seriesModel ? seriesModel.coordinateSystem : null;
+      return coordSys;
+    }
+
+    function install$w(registers) {
+      registers.registerComponentModel(CalendarModel);
+      registers.registerComponentView(CalendarView);
+      registers.registerCoordinateSystem('calendar', Calendar);
+    }
+
+    var inner$g = makeInner();
+    var _nonShapeGraphicElements = {
+      // Reserved but not supported in graphic component.
+      path: null,
+      compoundPath: null,
+      // Supported in graphic component.
+      group: Group,
+      image: ZRImage,
+      text: ZRText
+    }; // ------------------------
+    // Preprocessor
+    // ------------------------
+
+    var preprocessor = function (option) {
+      var graphicOption = option.graphic; // Convert
+      // {graphic: [{left: 10, type: 'circle'}, ...]}
+      // or
+      // {graphic: {left: 10, type: 'circle'}}
+      // to
+      // {graphic: [{elements: [{left: 10, type: 'circle'}, ...]}]}
+
+      if (isArray(graphicOption)) {
+        if (!graphicOption[0] || !graphicOption[0].elements) {
+          option.graphic = [{
+            elements: graphicOption
+          }];
+        } else {
+          // Only one graphic instance can be instantiated. (We dont
+          // want that too many views are created in echarts._viewMap)
+          option.graphic = [option.graphic[0]];
+        }
+      } else if (graphicOption && !graphicOption.elements) {
+        option.graphic = [{
+          elements: [graphicOption]
+        }];
+      }
+    };
+
+    var GraphicComponentModel =
+    /** @class */
+    function (_super) {
+      __extends(GraphicComponentModel, _super);
+
+      function GraphicComponentModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GraphicComponentModel.type;
+        return _this;
+      }
+
+      GraphicComponentModel.prototype.mergeOption = function (option, ecModel) {
+        // Prevent default merge to elements
+        var elements = this.option.elements;
+        this.option.elements = null;
+
+        _super.prototype.mergeOption.call(this, option, ecModel);
+
+        this.option.elements = elements;
+      };
+
+      GraphicComponentModel.prototype.optionUpdated = function (newOption, isInit) {
+        var thisOption = this.option;
+        var newList = (isInit ? thisOption : newOption).elements;
+        var existList = thisOption.elements = isInit ? [] : thisOption.elements;
+        var flattenedList = [];
+
+        this._flatten(newList, flattenedList, null);
+
+        var mappingResult = mappingToExists(existList, flattenedList, 'normalMerge'); // Clear elOptionsToUpdate
+
+        var elOptionsToUpdate = this._elOptionsToUpdate = [];
+        each(mappingResult, function (resultItem, index) {
+          var newElOption = resultItem.newOption;
+
+          if ("development" !== 'production') {
+            assert(isObject(newElOption) || resultItem.existing, 'Empty graphic option definition');
+          }
+
+          if (!newElOption) {
+            return;
+          }
+
+          elOptionsToUpdate.push(newElOption);
+          setKeyInfoToNewElOption(resultItem, newElOption);
+          mergeNewElOptionToExist(existList, index, newElOption);
+          setLayoutInfoToExist(existList[index], newElOption);
+        }, this); // Clean
+
+        for (var i = existList.length - 1; i >= 0; i--) {
+          if (existList[i] == null) {
+            existList.splice(i, 1);
+          } else {
+            // $action should be volatile, otherwise option gotten from
+            // `getOption` will contain unexpected $action.
+            delete existList[i].$action;
+          }
+        }
+      };
+      /**
+       * Convert
+       * [{
+       *  type: 'group',
+       *  id: 'xx',
+       *  children: [{type: 'circle'}, {type: 'polygon'}]
+       * }]
+       * to
+       * [
+       *  {type: 'group', id: 'xx'},
+       *  {type: 'circle', parentId: 'xx'},
+       *  {type: 'polygon', parentId: 'xx'}
+       * ]
+       */
+
+
+      GraphicComponentModel.prototype._flatten = function (optionList, result, parentOption) {
+        each(optionList, function (option) {
+          if (!option) {
+            return;
+          }
+
+          if (parentOption) {
+            option.parentOption = parentOption;
+          }
+
+          result.push(option);
+          var children = option.children;
+
+          if (option.type === 'group' && children) {
+            this._flatten(children, result, option);
+          } // Deleting for JSON output, and for not affecting group creation.
+
+
+          delete option.children;
+        }, this);
+      }; // FIXME
+      // Pass to view using payload? setOption has a payload?
+
+
+      GraphicComponentModel.prototype.useElOptionsToUpdate = function () {
+        var els = this._elOptionsToUpdate; // Clear to avoid render duplicately when zooming.
+
+        this._elOptionsToUpdate = null;
+        return els;
+      };
+
+      GraphicComponentModel.type = 'graphic';
+      GraphicComponentModel.defaultOption = {
+        elements: [] // parentId: null
+
+      };
+      return GraphicComponentModel;
+    }(ComponentModel); // ------------------------
+    // View
+    // ------------------------
+
+
+    var GraphicComponentView =
+    /** @class */
+    function (_super) {
+      __extends(GraphicComponentView, _super);
+
+      function GraphicComponentView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = GraphicComponentView.type;
+        return _this;
+      }
+
+      GraphicComponentView.prototype.init = function () {
+        this._elMap = createHashMap();
+      };
+
+      GraphicComponentView.prototype.render = function (graphicModel, ecModel, api) {
+        // Having leveraged between use cases and algorithm complexity, a very
+        // simple layout mechanism is used:
+        // The size(width/height) can be determined by itself or its parent (not
+        // implemented yet), but can not by its children. (Top-down travel)
+        // The location(x/y) can be determined by the bounding rect of itself
+        // (can including its descendants or not) and the size of its parent.
+        // (Bottom-up travel)
+        // When `chart.clear()` or `chart.setOption({...}, true)` with the same id,
+        // view will be reused.
+        if (graphicModel !== this._lastGraphicModel) {
+          this._clear();
+        }
+
+        this._lastGraphicModel = graphicModel;
+
+        this._updateElements(graphicModel);
+
+        this._relocate(graphicModel, api);
+      };
+      /**
+       * Update graphic elements.
+       */
+
+
+      GraphicComponentView.prototype._updateElements = function (graphicModel) {
+        var elOptionsToUpdate = graphicModel.useElOptionsToUpdate();
+
+        if (!elOptionsToUpdate) {
+          return;
+        }
+
+        var elMap = this._elMap;
+        var rootGroup = this.group; // Top-down tranverse to assign graphic settings to each elements.
+
+        each(elOptionsToUpdate, function (elOption) {
+          var id = convertOptionIdName(elOption.id, null);
+          var elExisting = id != null ? elMap.get(id) : null;
+          var parentId = convertOptionIdName(elOption.parentId, null);
+          var targetElParent = parentId != null ? elMap.get(parentId) : rootGroup;
+          var elType = elOption.type;
+          var elOptionStyle = elOption.style;
+
+          if (elType === 'text' && elOptionStyle) {
+            // In top/bottom mode, textVerticalAlign should not be used, which cause
+            // inaccurately locating.
+            if (elOption.hv && elOption.hv[1]) {
+              elOptionStyle.textVerticalAlign = elOptionStyle.textBaseline = elOptionStyle.verticalAlign = elOptionStyle.align = null;
+            }
+          }
+
+          var textContentOption = elOption.textContent;
+          var textConfig = elOption.textConfig;
+
+          if (elOptionStyle && isEC4CompatibleStyle(elOptionStyle, elType, !!textConfig, !!textContentOption)) {
+            var convertResult = convertFromEC4CompatibleStyle(elOptionStyle, elType, true);
+
+            if (!textConfig && convertResult.textConfig) {
+              textConfig = elOption.textConfig = convertResult.textConfig;
+            }
+
+            if (!textContentOption && convertResult.textContent) {
+              textContentOption = convertResult.textContent;
+            }
+          } // Remove unnecessary props to avoid potential problems.
+
+
+          var elOptionCleaned = getCleanedElOption(elOption); // For simple, do not support parent change, otherwise reorder is needed.
+
+          if ("development" !== 'production') {
+            elExisting && assert(targetElParent === elExisting.parent, 'Changing parent is not supported.');
+          }
+
+          var $action = elOption.$action || 'merge';
+
+          if ($action === 'merge') {
+            elExisting ? elExisting.attr(elOptionCleaned) : createEl$1(id, targetElParent, elOptionCleaned, elMap);
+          } else if ($action === 'replace') {
+            removeEl(elExisting, elMap);
+            createEl$1(id, targetElParent, elOptionCleaned, elMap);
+          } else if ($action === 'remove') {
+            removeEl(elExisting, elMap);
+          }
+
+          var el = elMap.get(id);
+
+          if (el && textContentOption) {
+            if ($action === 'merge') {
+              var textContentExisting = el.getTextContent();
+              textContentExisting ? textContentExisting.attr(textContentOption) : el.setTextContent(new ZRText(textContentOption));
+            } else if ($action === 'replace') {
+              el.setTextContent(new ZRText(textContentOption));
+            }
+          }
+
+          if (el) {
+            var elInner = inner$g(el);
+            elInner.__ecGraphicWidthOption = elOption.width;
+            elInner.__ecGraphicHeightOption = elOption.height;
+            setEventData(el, graphicModel, elOption);
+          }
+        });
+      };
+      /**
+       * Locate graphic elements.
+       */
+
+
+      GraphicComponentView.prototype._relocate = function (graphicModel, api) {
+        var elOptions = graphicModel.option.elements;
+        var rootGroup = this.group;
+        var elMap = this._elMap;
+        var apiWidth = api.getWidth();
+        var apiHeight = api.getHeight(); // Top-down to calculate percentage width/height of group
+
+        for (var i = 0; i < elOptions.length; i++) {
+          var elOption = elOptions[i];
+          var id = convertOptionIdName(elOption.id, null);
+          var el = id != null ? elMap.get(id) : null;
+
+          if (!el || !el.isGroup) {
+            continue;
+          }
+
+          var parentEl = el.parent;
+          var isParentRoot = parentEl === rootGroup; // Like 'position:absolut' in css, default 0.
+
+          var elInner = inner$g(el);
+          var parentElInner = inner$g(parentEl);
+          elInner.__ecGraphicWidth = parsePercent$1(elInner.__ecGraphicWidthOption, isParentRoot ? apiWidth : parentElInner.__ecGraphicWidth) || 0;
+          elInner.__ecGraphicHeight = parsePercent$1(elInner.__ecGraphicHeightOption, isParentRoot ? apiHeight : parentElInner.__ecGraphicHeight) || 0;
+        } // Bottom-up tranvese all elements (consider ec resize) to locate elements.
+
+
+        for (var i = elOptions.length - 1; i >= 0; i--) {
+          var elOption = elOptions[i];
+          var id = convertOptionIdName(elOption.id, null);
+          var el = id != null ? elMap.get(id) : null;
+
+          if (!el) {
+            continue;
+          }
+
+          var parentEl = el.parent;
+          var parentElInner = inner$g(parentEl);
+          var containerInfo = parentEl === rootGroup ? {
+            width: apiWidth,
+            height: apiHeight
+          } : {
+            width: parentElInner.__ecGraphicWidth,
+            height: parentElInner.__ecGraphicHeight
+          }; // PENDING
+          // Currently, when `bounding: 'all'`, the union bounding rect of the group
+          // does not include the rect of [0, 0, group.width, group.height], which
+          // is probably weird for users. Should we make a break change for it?
+
+          positionElement(el, elOption, containerInfo, null, {
+            hv: elOption.hv,
+            boundingMode: elOption.bounding
+          });
+        }
+      };
+      /**
+       * Clear all elements.
+       */
+
+
+      GraphicComponentView.prototype._clear = function () {
+        var elMap = this._elMap;
+        elMap.each(function (el) {
+          removeEl(el, elMap);
+        });
+        this._elMap = createHashMap();
+      };
+
+      GraphicComponentView.prototype.dispose = function () {
+        this._clear();
+      };
+
+      GraphicComponentView.type = 'graphic';
+      return GraphicComponentView;
+    }(ComponentView);
+
+    function createEl$1(id, targetElParent, elOption, elMap) {
+      var graphicType = elOption.type;
+
+      if ("development" !== 'production') {
+        assert(graphicType, 'graphic type MUST be set');
+      }
+
+      var Clz = hasOwn(_nonShapeGraphicElements, graphicType) // Those graphic elements are not shapes. They should not be
+      // overwritten by users, so do them first.
+      ? _nonShapeGraphicElements[graphicType] : getShapeClass(graphicType);
+
+      if ("development" !== 'production') {
+        assert(Clz, 'graphic type can not be found');
+      }
+
+      var el = new Clz(elOption);
+      targetElParent.add(el);
+      elMap.set(id, el);
+      inner$g(el).__ecGraphicId = id;
+    }
+
+    function removeEl(elExisting, elMap) {
+      var existElParent = elExisting && elExisting.parent;
+
+      if (existElParent) {
+        elExisting.type === 'group' && elExisting.traverse(function (el) {
+          removeEl(el, elMap);
+        });
+        elMap.removeKey(inner$g(elExisting).__ecGraphicId);
+        existElParent.remove(elExisting);
+      }
+    } // Remove unnecessary props to avoid potential problems.
+
+
+    function getCleanedElOption(elOption) {
+      elOption = extend({}, elOption);
+      each(['id', 'parentId', '$action', 'hv', 'bounding', 'textContent'].concat(LOCATION_PARAMS), function (name) {
+        delete elOption[name];
+      });
+      return elOption;
+    }
+
+    function isSetLoc(obj, props) {
+      var isSet;
+      each(props, function (prop) {
+        obj[prop] != null && obj[prop] !== 'auto' && (isSet = true);
+      });
+      return isSet;
+    }
+
+    function setKeyInfoToNewElOption(resultItem, newElOption) {
+      var existElOption = resultItem.existing; // Set id and type after id assigned.
+
+      newElOption.id = resultItem.keyInfo.id;
+      !newElOption.type && existElOption && (newElOption.type = existElOption.type); // Set parent id if not specified
+
+      if (newElOption.parentId == null) {
+        var newElParentOption = newElOption.parentOption;
+
+        if (newElParentOption) {
+          newElOption.parentId = newElParentOption.id;
+        } else if (existElOption) {
+          newElOption.parentId = existElOption.parentId;
+        }
+      } // Clear
+
+
+      newElOption.parentOption = null;
+    }
+
+    function mergeNewElOptionToExist(existList, index, newElOption) {
+      // Update existing options, for `getOption` feature.
+      var newElOptCopy = extend({}, newElOption);
+      var existElOption = existList[index];
+      var $action = newElOption.$action || 'merge';
+
+      if ($action === 'merge') {
+        if (existElOption) {
+          if ("development" !== 'production') {
+            var newType = newElOption.type;
+            assert(!newType || existElOption.type === newType, 'Please set $action: "replace" to change `type`');
+          } // We can ensure that newElOptCopy and existElOption are not
+          // the same object, so `merge` will not change newElOptCopy.
+
+
+          merge(existElOption, newElOptCopy, true); // Rigid body, use ignoreSize.
+
+          mergeLayoutParam(existElOption, newElOptCopy, {
+            ignoreSize: true
+          }); // Will be used in render.
+
+          copyLayoutParams(newElOption, existElOption);
+        } else {
+          existList[index] = newElOptCopy;
+        }
+      } else if ($action === 'replace') {
+        existList[index] = newElOptCopy;
+      } else if ($action === 'remove') {
+        // null will be cleaned later.
+        existElOption && (existList[index] = null);
+      }
+    }
+
+    function setLayoutInfoToExist(existItem, newElOption) {
+      if (!existItem) {
+        return;
+      }
+
+      existItem.hv = newElOption.hv = [// Rigid body, dont care `width`.
+      isSetLoc(newElOption, ['left', 'right']), // Rigid body, dont care `height`.
+      isSetLoc(newElOption, ['top', 'bottom'])]; // Give default group size. Otherwise layout error may occur.
+
+      if (existItem.type === 'group') {
+        var existingGroupOpt = existItem;
+        var newGroupOpt = newElOption;
+        existingGroupOpt.width == null && (existingGroupOpt.width = newGroupOpt.width = 0);
+        existingGroupOpt.height == null && (existingGroupOpt.height = newGroupOpt.height = 0);
+      }
+    }
+
+    function setEventData(el, graphicModel, elOption) {
+      var eventData = getECData(el).eventData; // Simple optimize for large amount of elements that no need event.
+
+      if (!el.silent && !el.ignore && !eventData) {
+        eventData = getECData(el).eventData = {
+          componentType: 'graphic',
+          componentIndex: graphicModel.componentIndex,
+          name: el.name
+        };
+      } // `elOption.info` enables user to mount some info on
+      // elements and use them in event handlers.
+
+
+      if (eventData) {
+        eventData.info = elOption.info;
+      }
+    }
+
+    function install$x(registers) {
+      registers.registerComponentModel(GraphicComponentModel);
+      registers.registerComponentView(GraphicComponentView);
+      registers.registerPreprocessor(preprocessor);
+    }
+
+    var DATA_ZOOM_AXIS_DIMENSIONS = ['x', 'y', 'radius', 'angle', 'single']; // Supported coords.
+    // FIXME: polar has been broken (but rarely used).
+
+    var SERIES_COORDS = ['cartesian2d', 'polar', 'singleAxis'];
+    function isCoordSupported(seriesModel) {
+      var coordType = seriesModel.get('coordinateSystem');
+      return indexOf(SERIES_COORDS, coordType) >= 0;
+    }
+    function getAxisMainType(axisDim) {
+      if ("development" !== 'production') {
+        assert(axisDim);
+      }
+
+      return axisDim + 'Axis';
+    }
+    /**
+     * If two dataZoomModels has the same axis controlled, we say that they are 'linked'.
+     * This function finds all linked dataZoomModels start from the given payload.
+     */
+
+    function findEffectedDataZooms(ecModel, payload) {
+      // Key: `DataZoomAxisDimension`
+      var axisRecords = createHashMap();
+      var effectedModels = []; // Key: uid of dataZoomModel
+
+      var effectedModelMap = createHashMap(); // Find the dataZooms specified by payload.
+
+      ecModel.eachComponent({
+        mainType: 'dataZoom',
+        query: payload
+      }, function (dataZoomModel) {
+        if (!effectedModelMap.get(dataZoomModel.uid)) {
+          addToEffected(dataZoomModel);
+        }
+      }); // Start from the given dataZoomModels, travel the graph to find
+      // all of the linked dataZoom models.
+
+      var foundNewLink;
+
+      do {
+        foundNewLink = false;
+        ecModel.eachComponent('dataZoom', processSingle);
+      } while (foundNewLink);
+
+      function processSingle(dataZoomModel) {
+        if (!effectedModelMap.get(dataZoomModel.uid) && isLinked(dataZoomModel)) {
+          addToEffected(dataZoomModel);
+          foundNewLink = true;
+        }
+      }
+
+      function addToEffected(dataZoom) {
+        effectedModelMap.set(dataZoom.uid, true);
+        effectedModels.push(dataZoom);
+        markAxisControlled(dataZoom);
+      }
+
+      function isLinked(dataZoomModel) {
+        var isLink = false;
+        dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+          var axisIdxArr = axisRecords.get(axisDim);
+
+          if (axisIdxArr && axisIdxArr[axisIndex]) {
+            isLink = true;
+          }
+        });
+        return isLink;
+      }
+
+      function markAxisControlled(dataZoomModel) {
+        dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+          (axisRecords.get(axisDim) || axisRecords.set(axisDim, []))[axisIndex] = true;
+        });
+      }
+
+      return effectedModels;
+    }
+    /**
+     * Find the first target coordinate system.
+     * Available after model built.
+     *
+     * @return Like {
+     *                  grid: [
+     *                      {model: coord0, axisModels: [axis1, axis3], coordIndex: 1},
+     *                      {model: coord1, axisModels: [axis0, axis2], coordIndex: 0},
+     *                      ...
+     *                  ],  // cartesians must not be null/undefined.
+     *                  polar: [
+     *                      {model: coord0, axisModels: [axis4], coordIndex: 0},
+     *                      ...
+     *                  ],  // polars must not be null/undefined.
+     *                  singleAxis: [
+     *                      {model: coord0, axisModels: [], coordIndex: 0}
+     *                  ]
+     *              }
+     */
+
+    function collectReferCoordSysModelInfo(dataZoomModel) {
+      var ecModel = dataZoomModel.ecModel;
+      var coordSysInfoWrap = {
+        infoList: [],
+        infoMap: createHashMap()
+      };
+      dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+        var axisModel = ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+
+        if (!axisModel) {
+          return;
+        }
+
+        var coordSysModel = axisModel.getCoordSysModel();
+
+        if (!coordSysModel) {
+          return;
+        }
+
+        var coordSysUid = coordSysModel.uid;
+        var coordSysInfo = coordSysInfoWrap.infoMap.get(coordSysUid);
+
+        if (!coordSysInfo) {
+          coordSysInfo = {
+            model: coordSysModel,
+            axisModels: []
+          };
+          coordSysInfoWrap.infoList.push(coordSysInfo);
+          coordSysInfoWrap.infoMap.set(coordSysUid, coordSysInfo);
+        }
+
+        coordSysInfo.axisModels.push(axisModel);
+      });
+      return coordSysInfoWrap;
+    }
+
+    var DataZoomAxisInfo =
+    /** @class */
+    function () {
+      function DataZoomAxisInfo() {
+        this.indexList = [];
+        this.indexMap = [];
+      }
+
+      DataZoomAxisInfo.prototype.add = function (axisCmptIdx) {
+        // Remove duplication.
+        if (!this.indexMap[axisCmptIdx]) {
+          this.indexList.push(axisCmptIdx);
+          this.indexMap[axisCmptIdx] = true;
+        }
+      };
+
+      return DataZoomAxisInfo;
+    }();
+
+    var DataZoomModel =
+    /** @class */
+    function (_super) {
+      __extends(DataZoomModel, _super);
+
+      function DataZoomModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = DataZoomModel.type;
+        _this._autoThrottle = true;
+        _this._noTarget = true;
+        /**
+         * It is `[rangeModeForMin, rangeModeForMax]`.
+         * The optional values for `rangeMode`:
+         * + `'value'` mode: the axis extent will always be determined by
+         *     `dataZoom.startValue` and `dataZoom.endValue`, despite
+         *     how data like and how `axis.min` and `axis.max` are.
+         * + `'percent'` mode: `100` represents 100% of the `[dMin, dMax]`,
+         *     where `dMin` is `axis.min` if `axis.min` specified, otherwise `data.extent[0]`,
+         *     and `dMax` is `axis.max` if `axis.max` specified, otherwise `data.extent[1]`.
+         *     Axis extent will be determined by the result of the percent of `[dMin, dMax]`.
+         *
+         * For example, when users are using dynamic data (update data periodically via `setOption`),
+         * if in `'value`' mode, the window will be kept in a fixed value range despite how
+         * data are appended, while if in `'percent'` mode, whe window range will be changed alone with
+         * the appended data (suppose `axis.min` and `axis.max` are not specified).
+         */
+
+        _this._rangePropMode = ['percent', 'percent'];
+        return _this;
+      }
+
+      DataZoomModel.prototype.init = function (option, parentModel, ecModel) {
+        var inputRawOption = retrieveRawOption(option);
+        /**
+         * Suppose a "main process" start at the point that model prepared (that is,
+         * model initialized or merged or method called in `action`).
+         * We should keep the `main process` idempotent, that is, given a set of values
+         * on `option`, we get the same result.
+         *
+         * But sometimes, values on `option` will be updated for providing users
+         * a "final calculated value" (`dataZoomProcessor` will do that). Those value
+         * should not be the base/input of the `main process`.
+         *
+         * So in that case we should save and keep the input of the `main process`
+         * separately, called `settledOption`.
+         *
+         * For example, consider the case:
+         * (Step_1) brush zoom the grid by `toolbox.dataZoom`,
+         *     where the original input `option.startValue`, `option.endValue` are earsed by
+         *     calculated value.
+         * (Step)2) click the legend to hide and show a series,
+         *     where the new range is calculated by the earsed `startValue` and `endValue`,
+         *     which brings incorrect result.
+         */
+
+        this.settledOption = inputRawOption;
+        this.mergeDefaultAndTheme(option, ecModel);
+
+        this._doInit(inputRawOption);
+      };
+
+      DataZoomModel.prototype.mergeOption = function (newOption) {
+        var inputRawOption = retrieveRawOption(newOption); //FIX #2591
+
+        merge(this.option, newOption, true);
+        merge(this.settledOption, inputRawOption, true);
+
+        this._doInit(inputRawOption);
+      };
+
+      DataZoomModel.prototype._doInit = function (inputRawOption) {
+        var thisOption = this.option; // if (!env.canvasSupported) {
+        //     thisOption.realtime = false;
+        // }
+
+        this._setDefaultThrottle(inputRawOption);
+
+        this._updateRangeUse(inputRawOption);
+
+        var settledOption = this.settledOption;
+        each([['start', 'startValue'], ['end', 'endValue']], function (names, index) {
+          // start/end has higher priority over startValue/endValue if they
+          // both set, but we should make chart.setOption({endValue: 1000})
+          // effective, rather than chart.setOption({endValue: 1000, end: null}).
+          if (this._rangePropMode[index] === 'value') {
+            thisOption[names[0]] = settledOption[names[0]] = null;
+          } // Otherwise do nothing and use the merge result.
+
+        }, this);
+
+        this._resetTarget();
+      };
+
+      DataZoomModel.prototype._resetTarget = function () {
+        var optionOrient = this.get('orient', true);
+        var targetAxisIndexMap = this._targetAxisInfoMap = createHashMap();
+
+        var hasAxisSpecified = this._fillSpecifiedTargetAxis(targetAxisIndexMap);
+
+        if (hasAxisSpecified) {
+          this._orient = optionOrient || this._makeAutoOrientByTargetAxis();
+        } else {
+          this._orient = optionOrient || 'horizontal';
+
+          this._fillAutoTargetAxisByOrient(targetAxisIndexMap, this._orient);
+        }
+
+        this._noTarget = true;
+        targetAxisIndexMap.each(function (axisInfo) {
+          if (axisInfo.indexList.length) {
+            this._noTarget = false;
+          }
+        }, this);
+      };
+
+      DataZoomModel.prototype._fillSpecifiedTargetAxis = function (targetAxisIndexMap) {
+        var hasAxisSpecified = false;
+        each(DATA_ZOOM_AXIS_DIMENSIONS, function (axisDim) {
+          var refering = this.getReferringComponents(getAxisMainType(axisDim), MULTIPLE_REFERRING); // When user set axisIndex as a empty array, we think that user specify axisIndex
+          // but do not want use auto mode. Because empty array may be encountered when
+          // some error occured.
+
+          if (!refering.specified) {
+            return;
+          }
+
+          hasAxisSpecified = true;
+          var axisInfo = new DataZoomAxisInfo();
+          each(refering.models, function (axisModel) {
+            axisInfo.add(axisModel.componentIndex);
+          });
+          targetAxisIndexMap.set(axisDim, axisInfo);
+        }, this);
+        return hasAxisSpecified;
+      };
+
+      DataZoomModel.prototype._fillAutoTargetAxisByOrient = function (targetAxisIndexMap, orient) {
+        var ecModel = this.ecModel;
+        var needAuto = true; // Find axis that parallel to dataZoom as default.
+
+        if (needAuto) {
+          var axisDim = orient === 'vertical' ? 'y' : 'x';
+          var axisModels = ecModel.findComponents({
+            mainType: axisDim + 'Axis'
+          });
+          setParallelAxis(axisModels, axisDim);
+        } // Find axis that parallel to dataZoom as default.
+
+
+        if (needAuto) {
+          var axisModels = ecModel.findComponents({
+            mainType: 'singleAxis',
+            filter: function (axisModel) {
+              return axisModel.get('orient', true) === orient;
+            }
+          });
+          setParallelAxis(axisModels, 'single');
+        }
+
+        function setParallelAxis(axisModels, axisDim) {
+          // At least use the first parallel axis as the target axis.
+          var axisModel = axisModels[0];
+
+          if (!axisModel) {
+            return;
+          }
+
+          var axisInfo = new DataZoomAxisInfo();
+          axisInfo.add(axisModel.componentIndex);
+          targetAxisIndexMap.set(axisDim, axisInfo);
+          needAuto = false; // Find parallel axes in the same grid.
+
+          if (axisDim === 'x' || axisDim === 'y') {
+            var gridModel_1 = axisModel.getReferringComponents('grid', SINGLE_REFERRING).models[0];
+            gridModel_1 && each(axisModels, function (axModel) {
+              if (axisModel.componentIndex !== axModel.componentIndex && gridModel_1 === axModel.getReferringComponents('grid', SINGLE_REFERRING).models[0]) {
+                axisInfo.add(axModel.componentIndex);
+              }
+            });
+          }
+        }
+
+        if (needAuto) {
+          // If no parallel axis, find the first category axis as default. (Also consider polar).
+          each(DATA_ZOOM_AXIS_DIMENSIONS, function (axisDim) {
+            if (!needAuto) {
+              return;
+            }
+
+            var axisModels = ecModel.findComponents({
+              mainType: getAxisMainType(axisDim),
+              filter: function (axisModel) {
+                return axisModel.get('type', true) === 'category';
+              }
+            });
+
+            if (axisModels[0]) {
+              var axisInfo = new DataZoomAxisInfo();
+              axisInfo.add(axisModels[0].componentIndex);
+              targetAxisIndexMap.set(axisDim, axisInfo);
+              needAuto = false;
+            }
+          }, this);
+        }
+      };
+
+      DataZoomModel.prototype._makeAutoOrientByTargetAxis = function () {
+        var dim; // Find the first axis
+
+        this.eachTargetAxis(function (axisDim) {
+          !dim && (dim = axisDim);
+        }, this);
+        return dim === 'y' ? 'vertical' : 'horizontal';
+      };
+
+      DataZoomModel.prototype._setDefaultThrottle = function (inputRawOption) {
+        // When first time user set throttle, auto throttle ends.
+        if (inputRawOption.hasOwnProperty('throttle')) {
+          this._autoThrottle = false;
+        }
+
+        if (this._autoThrottle) {
+          var globalOption = this.ecModel.option;
+          this.option.throttle = globalOption.animation && globalOption.animationDurationUpdate > 0 ? 100 : 20;
+        }
+      };
+
+      DataZoomModel.prototype._updateRangeUse = function (inputRawOption) {
+        var rangePropMode = this._rangePropMode;
+        var rangeModeInOption = this.get('rangeMode');
+        each([['start', 'startValue'], ['end', 'endValue']], function (names, index) {
+          var percentSpecified = inputRawOption[names[0]] != null;
+          var valueSpecified = inputRawOption[names[1]] != null;
+
+          if (percentSpecified && !valueSpecified) {
+            rangePropMode[index] = 'percent';
+          } else if (!percentSpecified && valueSpecified) {
+            rangePropMode[index] = 'value';
+          } else if (rangeModeInOption) {
+            rangePropMode[index] = rangeModeInOption[index];
+          } else if (percentSpecified) {
+            // percentSpecified && valueSpecified
+            rangePropMode[index] = 'percent';
+          } // else remain its original setting.
+
+        });
+      };
+
+      DataZoomModel.prototype.noTarget = function () {
+        return this._noTarget;
+      };
+
+      DataZoomModel.prototype.getFirstTargetAxisModel = function () {
+        var firstAxisModel;
+        this.eachTargetAxis(function (axisDim, axisIndex) {
+          if (firstAxisModel == null) {
+            firstAxisModel = this.ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+          }
+        }, this);
+        return firstAxisModel;
+      };
+      /**
+       * @param {Function} callback param: axisModel, dimNames, axisIndex, dataZoomModel, ecModel
+       */
+
+
+      DataZoomModel.prototype.eachTargetAxis = function (callback, context) {
+        this._targetAxisInfoMap.each(function (axisInfo, axisDim) {
+          each(axisInfo.indexList, function (axisIndex) {
+            callback.call(context, axisDim, axisIndex);
+          });
+        });
+      };
+      /**
+       * @return If not found, return null/undefined.
+       */
+
+
+      DataZoomModel.prototype.getAxisProxy = function (axisDim, axisIndex) {
+        var axisModel = this.getAxisModel(axisDim, axisIndex);
+
+        if (axisModel) {
+          return axisModel.__dzAxisProxy;
+        }
+      };
+      /**
+       * @return If not found, return null/undefined.
+       */
+
+
+      DataZoomModel.prototype.getAxisModel = function (axisDim, axisIndex) {
+        if ("development" !== 'production') {
+          assert(axisDim && axisIndex != null);
+        }
+
+        var axisInfo = this._targetAxisInfoMap.get(axisDim);
+
+        if (axisInfo && axisInfo.indexMap[axisIndex]) {
+          return this.ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+        }
+      };
+      /**
+       * If not specified, set to undefined.
+       */
+
+
+      DataZoomModel.prototype.setRawRange = function (opt) {
+        var thisOption = this.option;
+        var settledOption = this.settledOption;
+        each([['start', 'startValue'], ['end', 'endValue']], function (names) {
+          // Consider the pair <start, startValue>:
+          // If one has value and the other one is `null/undefined`, we both set them
+          // to `settledOption`. This strategy enables the feature to clear the original
+          // value in `settledOption` to `null/undefined`.
+          // But if both of them are `null/undefined`, we do not set them to `settledOption`
+          // and keep `settledOption` with the original value. This strategy enables users to
+          // only set <end or endValue> but not set <start or startValue> when calling
+          // `dispatchAction`.
+          // The pair <end, endValue> is treated in the same way.
+          if (opt[names[0]] != null || opt[names[1]] != null) {
+            thisOption[names[0]] = settledOption[names[0]] = opt[names[0]];
+            thisOption[names[1]] = settledOption[names[1]] = opt[names[1]];
+          }
+        }, this);
+
+        this._updateRangeUse(opt);
+      };
+
+      DataZoomModel.prototype.setCalculatedRange = function (opt) {
+        var option = this.option;
+        each(['start', 'startValue', 'end', 'endValue'], function (name) {
+          option[name] = opt[name];
+        });
+      };
+
+      DataZoomModel.prototype.getPercentRange = function () {
+        var axisProxy = this.findRepresentativeAxisProxy();
+
+        if (axisProxy) {
+          return axisProxy.getDataPercentWindow();
+        }
+      };
+      /**
+       * For example, chart.getModel().getComponent('dataZoom').getValueRange('y', 0);
+       *
+       * @return [startValue, endValue] value can only be '-' or finite number.
+       */
+
+
+      DataZoomModel.prototype.getValueRange = function (axisDim, axisIndex) {
+        if (axisDim == null && axisIndex == null) {
+          var axisProxy = this.findRepresentativeAxisProxy();
+
+          if (axisProxy) {
+            return axisProxy.getDataValueWindow();
+          }
+        } else {
+          return this.getAxisProxy(axisDim, axisIndex).getDataValueWindow();
+        }
+      };
+      /**
+       * @param axisModel If axisModel given, find axisProxy
+       *      corresponding to the axisModel
+       */
+
+
+      DataZoomModel.prototype.findRepresentativeAxisProxy = function (axisModel) {
+        if (axisModel) {
+          return axisModel.__dzAxisProxy;
+        } // Find the first hosted axisProxy
+
+
+        var firstProxy;
+
+        var axisDimList = this._targetAxisInfoMap.keys();
+
+        for (var i = 0; i < axisDimList.length; i++) {
+          var axisDim = axisDimList[i];
+
+          var axisInfo = this._targetAxisInfoMap.get(axisDim);
+
+          for (var j = 0; j < axisInfo.indexList.length; j++) {
+            var proxy = this.getAxisProxy(axisDim, axisInfo.indexList[j]);
+
+            if (proxy.hostedBy(this)) {
+              return proxy;
+            }
+
+            if (!firstProxy) {
+              firstProxy = proxy;
+            }
+          }
+        } // If no hosted proxy found, still need to return a proxy.
+        // This case always happens in toolbox dataZoom, where axes are all hosted by
+        // other dataZooms.
+
+
+        return firstProxy;
+      };
+
+      DataZoomModel.prototype.getRangePropMode = function () {
+        return this._rangePropMode.slice();
+      };
+
+      DataZoomModel.prototype.getOrient = function () {
+        if ("development" !== 'production') {
+          // Should not be called before initialized.
+          assert(this._orient);
+        }
+
+        return this._orient;
+      };
+
+      DataZoomModel.type = 'dataZoom';
+      DataZoomModel.dependencies = ['xAxis', 'yAxis', 'radiusAxis', 'angleAxis', 'singleAxis', 'series', 'toolbox'];
+      DataZoomModel.defaultOption = {
+        zlevel: 0,
+        z: 4,
+        filterMode: 'filter',
+        start: 0,
+        end: 100
+      };
+      return DataZoomModel;
+    }(ComponentModel);
+    /**
+     * Retrieve the those raw params from option, which will be cached separately.
+     * becasue they will be overwritten by normalized/calculated values in the main
+     * process.
+     */
+
+
+    function retrieveRawOption(option) {
+      var ret = {};
+      each(['start', 'end', 'startValue', 'endValue', 'throttle'], function (name) {
+        option.hasOwnProperty(name) && (ret[name] = option[name]);
+      });
+      return ret;
+    }
+
+    var SelectDataZoomModel =
+    /** @class */
+    function (_super) {
+      __extends(SelectDataZoomModel, _super);
+
+      function SelectDataZoomModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SelectDataZoomModel.type;
+        return _this;
+      }
+
+      SelectDataZoomModel.type = 'dataZoom.select';
+      return SelectDataZoomModel;
+    }(DataZoomModel);
+
+    var DataZoomView =
+    /** @class */
+    function (_super) {
+      __extends(DataZoomView, _super);
+
+      function DataZoomView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = DataZoomView.type;
+        return _this;
+      }
+
+      DataZoomView.prototype.render = function (dataZoomModel, ecModel, api, payload) {
+        this.dataZoomModel = dataZoomModel;
+        this.ecModel = ecModel;
+        this.api = api;
+      };
+
+      DataZoomView.type = 'dataZoom';
+      return DataZoomView;
+    }(ComponentView);
+
+    var SelectDataZoomView =
+    /** @class */
+    function (_super) {
+      __extends(SelectDataZoomView, _super);
+
+      function SelectDataZoomView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SelectDataZoomView.type;
+        return _this;
+      }
+
+      SelectDataZoomView.type = 'dataZoom.select';
+      return SelectDataZoomView;
+    }(DataZoomView);
+
+    var each$9 = each;
+    var asc$1 = asc;
+    /**
+     * Operate single axis.
+     * One axis can only operated by one axis operator.
+     * Different dataZoomModels may be defined to operate the same axis.
+     * (i.e. 'inside' data zoom and 'slider' data zoom components)
+     * So dataZoomModels share one axisProxy in that case.
+     */
+
+    var AxisProxy =
+    /** @class */
+    function () {
+      function AxisProxy(dimName, axisIndex, dataZoomModel, ecModel) {
+        this._dimName = dimName;
+        this._axisIndex = axisIndex;
+        this.ecModel = ecModel;
+        this._dataZoomModel = dataZoomModel; // /**
+        //  * @readOnly
+        //  * @private
+        //  */
+        // this.hasSeriesStacked;
+      }
+      /**
+       * Whether the axisProxy is hosted by dataZoomModel.
+       */
+
+
+      AxisProxy.prototype.hostedBy = function (dataZoomModel) {
+        return this._dataZoomModel === dataZoomModel;
+      };
+      /**
+       * @return Value can only be NaN or finite value.
+       */
+
+
+      AxisProxy.prototype.getDataValueWindow = function () {
+        return this._valueWindow.slice();
+      };
+      /**
+       * @return {Array.<number>}
+       */
+
+
+      AxisProxy.prototype.getDataPercentWindow = function () {
+        return this._percentWindow.slice();
+      };
+
+      AxisProxy.prototype.getTargetSeriesModels = function () {
+        var seriesModels = [];
+        this.ecModel.eachSeries(function (seriesModel) {
+          if (isCoordSupported(seriesModel)) {
+            var axisMainType = getAxisMainType(this._dimName);
+            var axisModel = seriesModel.getReferringComponents(axisMainType, SINGLE_REFERRING).models[0];
+
+            if (axisModel && this._axisIndex === axisModel.componentIndex) {
+              seriesModels.push(seriesModel);
+            }
+          }
+        }, this);
+        return seriesModels;
+      };
+
+      AxisProxy.prototype.getAxisModel = function () {
+        return this.ecModel.getComponent(this._dimName + 'Axis', this._axisIndex);
+      };
+
+      AxisProxy.prototype.getMinMaxSpan = function () {
+        return clone(this._minMaxSpan);
+      };
+      /**
+       * Only calculate by given range and this._dataExtent, do not change anything.
+       */
+
+
+      AxisProxy.prototype.calculateDataWindow = function (opt) {
+        var dataExtent = this._dataExtent;
+        var axisModel = this.getAxisModel();
+        var scale = axisModel.axis.scale;
+
+        var rangePropMode = this._dataZoomModel.getRangePropMode();
+
+        var percentExtent = [0, 100];
+        var percentWindow = [];
+        var valueWindow = [];
+        var hasPropModeValue;
+        each$9(['start', 'end'], function (prop, idx) {
+          var boundPercent = opt[prop];
+          var boundValue = opt[prop + 'Value']; // Notice: dataZoom is based either on `percentProp` ('start', 'end') or
+          // on `valueProp` ('startValue', 'endValue'). (They are based on the data extent
+          // but not min/max of axis, which will be calculated by data window then).
+          // The former one is suitable for cases that a dataZoom component controls multiple
+          // axes with different unit or extent, and the latter one is suitable for accurate
+          // zoom by pixel (e.g., in dataZoomSelect).
+          // we use `getRangePropMode()` to mark which prop is used. `rangePropMode` is updated
+          // only when setOption or dispatchAction, otherwise it remains its original value.
+          // (Why not only record `percentProp` and always map to `valueProp`? Because
+          // the map `valueProp` -> `percentProp` -> `valueProp` probably not the original
+          // `valueProp`. consider two axes constrolled by one dataZoom. They have different
+          // data extent. All of values that are overflow the `dataExtent` will be calculated
+          // to percent '100%').
+
+          if (rangePropMode[idx] === 'percent') {
+            boundPercent == null && (boundPercent = percentExtent[idx]); // Use scale.parse to math round for category or time axis.
+
+            boundValue = scale.parse(linearMap(boundPercent, percentExtent, dataExtent));
+          } else {
+            hasPropModeValue = true;
+            boundValue = boundValue == null ? dataExtent[idx] : scale.parse(boundValue); // Calculating `percent` from `value` may be not accurate, because
+            // This calculation can not be inversed, because all of values that
+            // are overflow the `dataExtent` will be calculated to percent '100%'
+
+            boundPercent = linearMap(boundValue, dataExtent, percentExtent);
+          } // valueWindow[idx] = round(boundValue);
+          // percentWindow[idx] = round(boundPercent);
+
+
+          valueWindow[idx] = boundValue;
+          percentWindow[idx] = boundPercent;
+        });
+        asc$1(valueWindow);
+        asc$1(percentWindow); // The windows from user calling of `dispatchAction` might be out of the extent,
+        // or do not obey the `min/maxSpan`, `min/maxValueSpan`. But we dont restrict window
+        // by `zoomLock` here, because we see `zoomLock` just as a interaction constraint,
+        // where API is able to initialize/modify the window size even though `zoomLock`
+        // specified.
+
+        var spans = this._minMaxSpan;
+        hasPropModeValue ? restrictSet(valueWindow, percentWindow, dataExtent, percentExtent, false) : restrictSet(percentWindow, valueWindow, percentExtent, dataExtent, true);
+
+        function restrictSet(fromWindow, toWindow, fromExtent, toExtent, toValue) {
+          var suffix = toValue ? 'Span' : 'ValueSpan';
+          sliderMove(0, fromWindow, fromExtent, 'all', spans['min' + suffix], spans['max' + suffix]);
+
+          for (var i = 0; i < 2; i++) {
+            toWindow[i] = linearMap(fromWindow[i], fromExtent, toExtent, true);
+            toValue && (toWindow[i] = scale.parse(toWindow[i]));
+          }
+        }
+
+        return {
+          valueWindow: valueWindow,
+          percentWindow: percentWindow
+        };
+      };
+      /**
+       * Notice: reset should not be called before series.restoreData() called,
+       * so it is recommanded to be called in "process stage" but not "model init
+       * stage".
+       */
+
+
+      AxisProxy.prototype.reset = function (dataZoomModel) {
+        if (dataZoomModel !== this._dataZoomModel) {
+          return;
+        }
+
+        var targetSeries = this.getTargetSeriesModels(); // Culculate data window and data extent, and record them.
+
+        this._dataExtent = calculateDataExtent(this, this._dimName, targetSeries); // this.hasSeriesStacked = false;
+        // each(targetSeries, function (series) {
+        // let data = series.getData();
+        // let dataDim = data.mapDimension(this._dimName);
+        // let stackedDimension = data.getCalculationInfo('stackedDimension');
+        // if (stackedDimension && stackedDimension === dataDim) {
+        // this.hasSeriesStacked = true;
+        // }
+        // }, this);
+        // `calculateDataWindow` uses min/maxSpan.
+
+        this._updateMinMaxSpan();
+
+        var dataWindow = this.calculateDataWindow(dataZoomModel.settledOption);
+        this._valueWindow = dataWindow.valueWindow;
+        this._percentWindow = dataWindow.percentWindow; // Update axis setting then.
+
+        this._setAxisModel();
+      };
+
+      AxisProxy.prototype.filterData = function (dataZoomModel, api) {
+        if (dataZoomModel !== this._dataZoomModel) {
+          return;
+        }
+
+        var axisDim = this._dimName;
+        var seriesModels = this.getTargetSeriesModels();
+        var filterMode = dataZoomModel.get('filterMode');
+        var valueWindow = this._valueWindow;
+
+        if (filterMode === 'none') {
+          return;
+        } // FIXME
+        // Toolbox may has dataZoom injected. And if there are stacked bar chart
+        // with NaN data, NaN will be filtered and stack will be wrong.
+        // So we need to force the mode to be set empty.
+        // In fect, it is not a big deal that do not support filterMode-'filter'
+        // when using toolbox#dataZoom, utill tooltip#dataZoom support "single axis
+        // selection" some day, which might need "adapt to data extent on the
+        // otherAxis", which is disabled by filterMode-'empty'.
+        // But currently, stack has been fixed to based on value but not index,
+        // so this is not an issue any more.
+        // let otherAxisModel = this.getOtherAxisModel();
+        // if (dataZoomModel.get('$fromToolbox')
+        //     && otherAxisModel
+        //     && otherAxisModel.hasSeriesStacked
+        // ) {
+        //     filterMode = 'empty';
+        // }
+        // TODO
+        // filterMode 'weakFilter' and 'empty' is not optimized for huge data yet.
+
+
+        each$9(seriesModels, function (seriesModel) {
+          var seriesData = seriesModel.getData();
+          var dataDims = seriesData.mapDimensionsAll(axisDim);
+
+          if (!dataDims.length) {
+            return;
+          }
+
+          if (filterMode === 'weakFilter') {
+            seriesData.filterSelf(function (dataIndex) {
+              var leftOut;
+              var rightOut;
+              var hasValue;
+
+              for (var i = 0; i < dataDims.length; i++) {
+                var value = seriesData.get(dataDims[i], dataIndex);
+                var thisHasValue = !isNaN(value);
+                var thisLeftOut = value < valueWindow[0];
+                var thisRightOut = value > valueWindow[1];
+
+                if (thisHasValue && !thisLeftOut && !thisRightOut) {
+                  return true;
+                }
+
+                thisHasValue && (hasValue = true);
+                thisLeftOut && (leftOut = true);
+                thisRightOut && (rightOut = true);
+              } // If both left out and right out, do not filter.
+
+
+              return hasValue && leftOut && rightOut;
+            });
+          } else {
+            each$9(dataDims, function (dim) {
+              if (filterMode === 'empty') {
+                seriesModel.setData(seriesData = seriesData.map(dim, function (value) {
+                  return !isInWindow(value) ? NaN : value;
+                }));
+              } else {
+                var range = {};
+                range[dim] = valueWindow; // console.time('select');
+
+                seriesData.selectRange(range); // console.timeEnd('select');
+              }
+            });
+          }
+
+          each$9(dataDims, function (dim) {
+            seriesData.setApproximateExtent(valueWindow, dim);
+          });
+        });
+
+        function isInWindow(value) {
+          return value >= valueWindow[0] && value <= valueWindow[1];
+        }
+      };
+
+      AxisProxy.prototype._updateMinMaxSpan = function () {
+        var minMaxSpan = this._minMaxSpan = {};
+        var dataZoomModel = this._dataZoomModel;
+        var dataExtent = this._dataExtent;
+        each$9(['min', 'max'], function (minMax) {
+          var percentSpan = dataZoomModel.get(minMax + 'Span');
+          var valueSpan = dataZoomModel.get(minMax + 'ValueSpan');
+          valueSpan != null && (valueSpan = this.getAxisModel().axis.scale.parse(valueSpan)); // minValueSpan and maxValueSpan has higher priority than minSpan and maxSpan
+
+          if (valueSpan != null) {
+            percentSpan = linearMap(dataExtent[0] + valueSpan, dataExtent, [0, 100], true);
+          } else if (percentSpan != null) {
+            valueSpan = linearMap(percentSpan, [0, 100], dataExtent, true) - dataExtent[0];
+          }
+
+          minMaxSpan[minMax + 'Span'] = percentSpan;
+          minMaxSpan[minMax + 'ValueSpan'] = valueSpan;
+        }, this);
+      };
+
+      AxisProxy.prototype._setAxisModel = function () {
+        var axisModel = this.getAxisModel();
+        var percentWindow = this._percentWindow;
+        var valueWindow = this._valueWindow;
+
+        if (!percentWindow) {
+          return;
+        } // [0, 500]: arbitrary value, guess axis extent.
+
+
+        var precision = getPixelPrecision(valueWindow, [0, 500]);
+        precision = Math.min(precision, 20); // For value axis, if min/max/scale are not set, we just use the extent obtained
+        // by series data, which may be a little different from the extent calculated by
+        // `axisHelper.getScaleExtent`. But the different just affects the experience a
+        // little when zooming. So it will not be fixed until some users require it strongly.
+
+        var rawExtentInfo = axisModel.axis.scale.rawExtentInfo;
+
+        if (percentWindow[0] !== 0) {
+          rawExtentInfo.setDeterminedMinMax('min', +valueWindow[0].toFixed(precision));
+        }
+
+        if (percentWindow[1] !== 100) {
+          rawExtentInfo.setDeterminedMinMax('max', +valueWindow[1].toFixed(precision));
+        }
+
+        rawExtentInfo.freeze();
+      };
+
+      return AxisProxy;
+    }();
+
+    function calculateDataExtent(axisProxy, axisDim, seriesModels) {
+      var dataExtent = [Infinity, -Infinity];
+      each$9(seriesModels, function (seriesModel) {
+        unionAxisExtentFromData(dataExtent, seriesModel.getData(), axisDim);
+      }); // It is important to get "consistent" extent when more then one axes is
+      // controlled by a `dataZoom`, otherwise those axes will not be synchronized
+      // when zooming. But it is difficult to know what is "consistent", considering
+      // axes have different type or even different meanings (For example, two
+      // time axes are used to compare data of the same date in different years).
+      // So basically dataZoom just obtains extent by series.data (in category axis
+      // extent can be obtained from axis.data).
+      // Nevertheless, user can set min/max/scale on axes to make extent of axes
+      // consistent.
+
+      var axisModel = axisProxy.getAxisModel();
+      var rawExtentResult = ensureScaleRawExtentInfo(axisModel.axis.scale, axisModel, dataExtent).calculate();
+      return [rawExtentResult.min, rawExtentResult.max];
+    }
+
+    var dataZoomProcessor = {
+      // `dataZoomProcessor` will only be performed in needed series. Consider if
+      // there is a line series and a pie series, it is better not to update the
+      // line series if only pie series is needed to be updated.
+      getTargetSeries: function (ecModel) {
+        function eachAxisModel(cb) {
+          ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+            dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+              var axisModel = ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+              cb(axisDim, axisIndex, axisModel, dataZoomModel);
+            });
+          });
+        } // FIXME: it brings side-effect to `getTargetSeries`.
+        // Prepare axis proxies.
+
+
+        eachAxisModel(function (axisDim, axisIndex, axisModel, dataZoomModel) {
+          // dispose all last axis proxy, in case that some axis are deleted.
+          axisModel.__dzAxisProxy = null;
+        });
+        var proxyList = [];
+        eachAxisModel(function (axisDim, axisIndex, axisModel, dataZoomModel) {
+          // Different dataZooms may constrol the same axis. In that case,
+          // an axisProxy serves both of them.
+          if (!axisModel.__dzAxisProxy) {
+            // Use the first dataZoomModel as the main model of axisProxy.
+            axisModel.__dzAxisProxy = new AxisProxy(axisDim, axisIndex, dataZoomModel, ecModel);
+            proxyList.push(axisModel.__dzAxisProxy);
+          }
+        });
+        var seriesModelMap = createHashMap();
+        each(proxyList, function (axisProxy) {
+          each(axisProxy.getTargetSeriesModels(), function (seriesModel) {
+            seriesModelMap.set(seriesModel.uid, seriesModel);
+          });
+        });
+        return seriesModelMap;
+      },
+      // Consider appendData, where filter should be performed. Because data process is
+      // in block mode currently, it is not need to worry about that the overallProgress
+      // execute every frame.
+      overallReset: function (ecModel, api) {
+        ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+          // We calculate window and reset axis here but not in model
+          // init stage and not after action dispatch handler, because
+          // reset should be called after seriesData.restoreData.
+          dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+            dataZoomModel.getAxisProxy(axisDim, axisIndex).reset(dataZoomModel);
+          }); // Caution: data zoom filtering is order sensitive when using
+          // percent range and no min/max/scale set on axis.
+          // For example, we have dataZoom definition:
+          // [
+          //      {xAxisIndex: 0, start: 30, end: 70},
+          //      {yAxisIndex: 0, start: 20, end: 80}
+          // ]
+          // In this case, [20, 80] of y-dataZoom should be based on data
+          // that have filtered by x-dataZoom using range of [30, 70],
+          // but should not be based on full raw data. Thus sliding
+          // x-dataZoom will change both ranges of xAxis and yAxis,
+          // while sliding y-dataZoom will only change the range of yAxis.
+          // So we should filter x-axis after reset x-axis immediately,
+          // and then reset y-axis and filter y-axis.
+
+          dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+            dataZoomModel.getAxisProxy(axisDim, axisIndex).filterData(dataZoomModel, api);
+          });
+        });
+        ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+          // Fullfill all of the range props so that user
+          // is able to get them from chart.getOption().
+          var axisProxy = dataZoomModel.findRepresentativeAxisProxy();
+
+          if (axisProxy) {
+            var percentRange = axisProxy.getDataPercentWindow();
+            var valueRange = axisProxy.getDataValueWindow();
+            dataZoomModel.setCalculatedRange({
+              start: percentRange[0],
+              end: percentRange[1],
+              startValue: valueRange[0],
+              endValue: valueRange[1]
+            });
+          }
+        });
+      }
+    };
+
+    function installDataZoomAction(registers) {
+      registers.registerAction('dataZoom', function (payload, ecModel) {
+        var effectedModels = findEffectedDataZooms(ecModel, payload);
+        each(effectedModels, function (dataZoomModel) {
+          dataZoomModel.setRawRange({
+            start: payload.start,
+            end: payload.end,
+            startValue: payload.startValue,
+            endValue: payload.endValue
+          });
+        });
+      });
+    }
+
+    var installed = false;
+    function installCommon(registers) {
+      if (installed) {
+        return;
+      }
+
+      installed = true;
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, dataZoomProcessor);
+      installDataZoomAction(registers);
+      registers.registerSubTypeDefaulter('dataZoom', function () {
+        // Default 'slider' when no type specified.
+        return 'slider';
+      });
+    }
+
+    function install$y(registers) {
+      registers.registerComponentModel(SelectDataZoomModel);
+      registers.registerComponentView(SelectDataZoomView);
+      installCommon(registers);
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    var ToolboxFeature =
+    /** @class */
+    function () {
+      function ToolboxFeature() {}
+
+      return ToolboxFeature;
+    }();
+    var features = {};
+    function registerFeature(name, ctor) {
+      features[name] = ctor;
+    }
+    function getFeature(name) {
+      return features[name];
+    }
+
+    var ToolboxModel =
+    /** @class */
+    function (_super) {
+      __extends(ToolboxModel, _super);
+
+      function ToolboxModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ToolboxModel.type;
+        return _this;
+      }
+
+      ToolboxModel.prototype.optionUpdated = function () {
+        _super.prototype.optionUpdated.apply(this, arguments);
+
+        var ecModel = this.ecModel;
+        each(this.option.feature, function (featureOpt, featureName) {
+          var Feature = getFeature(featureName);
+
+          if (Feature) {
+            if (Feature.getDefaultOption) {
+              Feature.defaultOption = Feature.getDefaultOption(ecModel);
+            }
+
+            merge(featureOpt, Feature.defaultOption);
+          }
+        });
+      };
+
+      ToolboxModel.type = 'toolbox';
+      ToolboxModel.layoutMode = {
+        type: 'box',
+        ignoreSize: true
+      };
+      ToolboxModel.defaultOption = {
+        show: true,
+        z: 6,
+        zlevel: 0,
+        orient: 'horizontal',
+        left: 'right',
+        top: 'top',
+        // right
+        // bottom
+        backgroundColor: 'transparent',
+        borderColor: '#ccc',
+        borderRadius: 0,
+        borderWidth: 0,
+        padding: 5,
+        itemSize: 15,
+        itemGap: 8,
+        showTitle: true,
+        iconStyle: {
+          borderColor: '#666',
+          color: 'none'
+        },
+        emphasis: {
+          iconStyle: {
+            borderColor: '#3E98C5'
+          }
+        },
+        // textStyle: {},
+        // feature
+        tooltip: {
+          show: false
+        }
+      };
+      return ToolboxModel;
+    }(ComponentModel);
+
+    /**
+     * Layout list like component.
+     * It will box layout each items in group of component and then position the whole group in the viewport
+     * @param {module:zrender/group/Group} group
+     * @param {module:echarts/model/Component} componentModel
+     * @param {module:echarts/ExtensionAPI}
+     */
+
+    function layout$3(group, componentModel, api) {
+      var boxLayoutParams = componentModel.getBoxLayoutParams();
+      var padding = componentModel.get('padding');
+      var viewportSize = {
+        width: api.getWidth(),
+        height: api.getHeight()
+      };
+      var rect = getLayoutRect(boxLayoutParams, viewportSize, padding);
+      box(componentModel.get('orient'), group, componentModel.get('itemGap'), rect.width, rect.height);
+      positionElement(group, boxLayoutParams, viewportSize, padding);
+    }
+    function makeBackground(rect, componentModel) {
+      var padding = normalizeCssArray$1(componentModel.get('padding'));
+      var style = componentModel.getItemStyle(['color', 'opacity']);
+      style.fill = componentModel.get('backgroundColor');
+      rect = new Rect({
+        shape: {
+          x: rect.x - padding[3],
+          y: rect.y - padding[0],
+          width: rect.width + padding[1] + padding[3],
+          height: rect.height + padding[0] + padding[2],
+          r: componentModel.get('borderRadius')
+        },
+        style: style,
+        silent: true,
+        z2: -1
+      }); // FIXME
+      // `subPixelOptimizeRect` may bring some gap between edge of viewpart
+      // and background rect when setting like `left: 0`, `top: 0`.
+      // graphic.subPixelOptimizeRect(rect);
+
+      return rect;
+    }
+
+    var ToolboxView =
+    /** @class */
+    function (_super) {
+      __extends(ToolboxView, _super);
+
+      function ToolboxView() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      ToolboxView.prototype.render = function (toolboxModel, ecModel, api, payload) {
+        var group = this.group;
+        group.removeAll();
+
+        if (!toolboxModel.get('show')) {
+          return;
+        }
+
+        var itemSize = +toolboxModel.get('itemSize');
+        var featureOpts = toolboxModel.get('feature') || {};
+        var features = this._features || (this._features = {});
+        var featureNames = [];
+        each(featureOpts, function (opt, name) {
+          featureNames.push(name);
+        });
+        new DataDiffer(this._featureNames || [], featureNames).add(processFeature).update(processFeature).remove(curry(processFeature, null)).execute(); // Keep for diff.
+
+        this._featureNames = featureNames;
+
+        function processFeature(newIndex, oldIndex) {
+          var featureName = featureNames[newIndex];
+          var oldName = featureNames[oldIndex];
+          var featureOpt = featureOpts[featureName];
+          var featureModel = new Model(featureOpt, toolboxModel, toolboxModel.ecModel);
+          var feature; // FIX#11236, merge feature title from MagicType newOption. TODO: consider seriesIndex ?
+
+          if (payload && payload.newTitle != null && payload.featureName === featureName) {
+            featureOpt.title = payload.newTitle;
+          }
+
+          if (featureName && !oldName) {
+            // Create
+            if (isUserFeatureName(featureName)) {
+              feature = {
+                onclick: featureModel.option.onclick,
+                featureName: featureName
+              };
+            } else {
+              var Feature = getFeature(featureName);
+
+              if (!Feature) {
+                return;
+              }
+
+              feature = new Feature();
+            }
+
+            features[featureName] = feature;
+          } else {
+            feature = features[oldName]; // If feature does not exsit.
+
+            if (!feature) {
+              return;
+            }
+          }
+
+          feature.uid = getUID('toolbox-feature');
+          feature.model = featureModel;
+          feature.ecModel = ecModel;
+          feature.api = api;
+
+          if (feature instanceof ToolboxFeature) {
+            if (!featureName && oldName) {
+              feature.dispose && feature.dispose(ecModel, api);
+              return;
+            }
+
+            if (!featureModel.get('show') || feature.unusable) {
+              feature.remove && feature.remove(ecModel, api);
+              return;
+            }
+          }
+
+          createIconPaths(featureModel, feature, featureName);
+
+          featureModel.setIconStatus = function (iconName, status) {
+            var option = this.option;
+            var iconPaths = this.iconPaths;
+            option.iconStatus = option.iconStatus || {};
+            option.iconStatus[iconName] = status;
+
+            if (iconPaths[iconName]) {
+              (status === 'emphasis' ? enterEmphasis : leaveEmphasis)(iconPaths[iconName]);
+            }
+          };
+
+          if (feature instanceof ToolboxFeature) {
+            if (feature.render) {
+              feature.render(featureModel, ecModel, api, payload);
+            }
+          }
+        }
+
+        function createIconPaths(featureModel, feature, featureName) {
+          var iconStyleModel = featureModel.getModel('iconStyle');
+          var iconStyleEmphasisModel = featureModel.getModel(['emphasis', 'iconStyle']); // If one feature has mutiple icon. they are orginaized as
+          // {
+          //     icon: {
+          //         foo: '',
+          //         bar: ''
+          //     },
+          //     title: {
+          //         foo: '',
+          //         bar: ''
+          //     }
+          // }
+
+          var icons = feature instanceof ToolboxFeature && feature.getIcons ? feature.getIcons() : featureModel.get('icon');
+          var titles = featureModel.get('title') || {};
+          var iconsMap;
+          var titlesMap;
+
+          if (typeof icons === 'string') {
+            iconsMap = {};
+            iconsMap[featureName] = icons;
+          } else {
+            iconsMap = icons;
+          }
+
+          if (typeof titles === 'string') {
+            titlesMap = {};
+            titlesMap[featureName] = titles;
+          } else {
+            titlesMap = titles;
+          }
+
+          var iconPaths = featureModel.iconPaths = {};
+          each(iconsMap, function (iconStr, iconName) {
+            var path = createIcon(iconStr, {}, {
+              x: -itemSize / 2,
+              y: -itemSize / 2,
+              width: itemSize,
+              height: itemSize
+            }); // TODO handling image
+
+            path.setStyle(iconStyleModel.getItemStyle());
+            var pathEmphasisState = path.ensureState('emphasis');
+            pathEmphasisState.style = iconStyleEmphasisModel.getItemStyle(); // Text position calculation
+
+            var textContent = new ZRText({
+              style: {
+                text: titlesMap[iconName],
+                align: iconStyleEmphasisModel.get('textAlign'),
+                borderRadius: iconStyleEmphasisModel.get('textBorderRadius'),
+                padding: iconStyleEmphasisModel.get('textPadding'),
+                fill: null
+              },
+              ignore: true
+            });
+            path.setTextContent(textContent);
+            var tooltipModel = toolboxModel.getModel('tooltip');
+
+            if (tooltipModel && tooltipModel.get('show')) {
+              path.tooltip = extend({
+                content: titlesMap[iconName],
+                formatter: tooltipModel.get('formatter', true) || function () {
+                  return titlesMap[iconName];
+                },
+                formatterParams: {
+                  componentType: 'toolbox',
+                  name: iconName,
+                  title: titlesMap[iconName],
+                  $vars: ['name', 'title']
+                },
+                position: tooltipModel.get('position', true) || 'bottom'
+              }, tooltipModel.option);
+            } // graphic.enableHoverEmphasis(path);
+
+
+            path.__title = titlesMap[iconName];
+            path.on('mouseover', function () {
+              // Should not reuse above hoverStyle, which might be modified.
+              var hoverStyle = iconStyleEmphasisModel.getItemStyle();
+              var defaultTextPosition = toolboxModel.get('orient') === 'vertical' ? toolboxModel.get('right') == null ? 'right' : 'left' : toolboxModel.get('bottom') == null ? 'bottom' : 'top';
+              textContent.setStyle({
+                fill: iconStyleEmphasisModel.get('textFill') || hoverStyle.fill || hoverStyle.stroke || '#000',
+                backgroundColor: iconStyleEmphasisModel.get('textBackgroundColor')
+              });
+              path.setTextConfig({
+                position: iconStyleEmphasisModel.get('textPosition') || defaultTextPosition
+              });
+              textContent.ignore = !toolboxModel.get('showTitle'); // Use enterEmphasis and leaveEmphasis provide by ec.
+              // There are flags managed by the echarts.
+
+              enterEmphasis(this);
+            }).on('mouseout', function () {
+              if (featureModel.get(['iconStatus', iconName]) !== 'emphasis') {
+                leaveEmphasis(this);
+              }
+
+              textContent.hide();
+            });
+            (featureModel.get(['iconStatus', iconName]) === 'emphasis' ? enterEmphasis : leaveEmphasis)(path);
+            group.add(path);
+            path.on('click', bind(feature.onclick, feature, ecModel, api, iconName));
+            iconPaths[iconName] = path;
+          });
+        }
+
+        layout$3(group, toolboxModel, api); // Render background after group is layout
+        // FIXME
+
+        group.add(makeBackground(group.getBoundingRect(), toolboxModel)); // Adjust icon title positions to avoid them out of screen
+
+        group.eachChild(function (icon) {
+          var titleText = icon.__title; // const hoverStyle = icon.hoverStyle;
+          // TODO simplify code?
+
+          var emphasisState = icon.ensureState('emphasis');
+          var emphasisTextConfig = emphasisState.textConfig || (emphasisState.textConfig = {});
+          var textContent = icon.getTextContent();
+          var emphasisTextState = textContent && textContent.states.emphasis; // May be background element
+
+          if (emphasisTextState && !isFunction(emphasisTextState) && titleText) {
+            var emphasisTextStyle = emphasisTextState.style || (emphasisTextState.style = {});
+            var rect = getBoundingRect(titleText, ZRText.makeFont(emphasisTextStyle));
+            var offsetX = icon.x + group.x;
+            var offsetY = icon.y + group.y + itemSize;
+            var needPutOnTop = false;
+
+            if (offsetY + rect.height > api.getHeight()) {
+              emphasisTextConfig.position = 'top';
+              needPutOnTop = true;
+            }
+
+            var topOffset = needPutOnTop ? -5 - rect.height : itemSize + 8;
+
+            if (offsetX + rect.width / 2 > api.getWidth()) {
+              emphasisTextConfig.position = ['100%', topOffset];
+              emphasisTextStyle.align = 'right';
+            } else if (offsetX - rect.width / 2 < 0) {
+              emphasisTextConfig.position = [0, topOffset];
+              emphasisTextStyle.align = 'left';
+            }
+          }
+        });
+      };
+
+      ToolboxView.prototype.updateView = function (toolboxModel, ecModel, api, payload) {
+        each(this._features, function (feature) {
+          feature instanceof ToolboxFeature && feature.updateView && feature.updateView(feature.model, ecModel, api, payload);
+        });
+      }; // updateLayout(toolboxModel, ecModel, api, payload) {
+      //     zrUtil.each(this._features, function (feature) {
+      //         feature.updateLayout && feature.updateLayout(feature.model, ecModel, api, payload);
+      //     });
+      // },
+
+
+      ToolboxView.prototype.remove = function (ecModel, api) {
+        each(this._features, function (feature) {
+          feature instanceof ToolboxFeature && feature.remove && feature.remove(ecModel, api);
+        });
+        this.group.removeAll();
+      };
+
+      ToolboxView.prototype.dispose = function (ecModel, api) {
+        each(this._features, function (feature) {
+          feature instanceof ToolboxFeature && feature.dispose && feature.dispose(ecModel, api);
+        });
+      };
+
+      ToolboxView.type = 'toolbox';
+      return ToolboxView;
+    }(ComponentView);
+
+    function isUserFeatureName(featureName) {
+      return featureName.indexOf('my') === 0;
+    }
+
+    var SaveAsImage =
+    /** @class */
+    function (_super) {
+      __extends(SaveAsImage, _super);
+
+      function SaveAsImage() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      SaveAsImage.prototype.onclick = function (ecModel, api) {
+        var model = this.model;
+        var title = model.get('name') || ecModel.get('title.0.text') || 'echarts';
+        var isSvg = api.getZr().painter.getType() === 'svg';
+        var type = isSvg ? 'svg' : model.get('type', true) || 'png';
+        var url = api.getConnectedDataURL({
+          type: type,
+          backgroundColor: model.get('backgroundColor', true) || ecModel.get('backgroundColor') || '#fff',
+          connectedBackgroundColor: model.get('connectedBackgroundColor'),
+          excludeComponents: model.get('excludeComponents'),
+          pixelRatio: model.get('pixelRatio')
+        }); // Chrome, Firefox, New Edge
+
+        if (typeof MouseEvent === 'function' && (env.browser.newEdge || !env.browser.ie && !env.browser.edge)) {
+          var $a = document.createElement('a');
+          $a.download = title + '.' + type;
+          $a.target = '_blank';
+          $a.href = url;
+          var evt = new MouseEvent('click', {
+            // some micro front-end framework， window maybe is a Proxy
+            view: document.defaultView,
+            bubbles: true,
+            cancelable: false
+          });
+          $a.dispatchEvent(evt);
+        } // IE or old Edge
+        else {
+            if (window.navigator.msSaveOrOpenBlob || isSvg) {
+              var parts = url.split(','); // data:[<mime type>][;charset=<charset>][;base64],<encoded data>
+
+              var base64Encoded = parts[0].indexOf('base64') > -1;
+              var bstr = isSvg // should decode the svg data uri first
+              ? decodeURIComponent(parts[1]) : parts[1]; // only `atob` when the data uri is encoded with base64
+              // otherwise, like `svg` data uri exported by zrender,
+              // there will be an error, for it's not encoded with base64.
+              // (just a url-encoded string through `encodeURIComponent`)
+
+              base64Encoded && (bstr = atob(bstr));
+              var filename = title + '.' + type;
+
+              if (window.navigator.msSaveOrOpenBlob) {
+                var n = bstr.length;
+                var u8arr = new Uint8Array(n);
+
+                while (n--) {
+                  u8arr[n] = bstr.charCodeAt(n);
+                }
+
+                var blob = new Blob([u8arr]);
+                window.navigator.msSaveOrOpenBlob(blob, filename);
+              } else {
+                var frame = document.createElement('iframe');
+                document.body.appendChild(frame);
+                var cw = frame.contentWindow;
+                var doc = cw.document;
+                doc.open('image/svg+xml', 'replace');
+                doc.write(bstr);
+                doc.close();
+                cw.focus();
+                doc.execCommand('SaveAs', true, filename);
+                document.body.removeChild(frame);
+              }
+            } else {
+              var lang = model.get('lang');
+              var html = '' + '<body style="margin:0;">' + '<img src="' + url + '" style="max-width:100%;" title="' + (lang && lang[0] || '') + '" />' + '</body>';
+              var tab = window.open();
+              tab.document.write(html);
+              tab.document.title = title;
+            }
+          }
+      };
+
+      SaveAsImage.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          icon: 'M4.7,22.9L29.3,45.5L54.7,23.4M4.6,43.6L4.6,58L53.8,58L53.8,43.6M29.2,45.1L29.2,0',
+          title: ecModel.getLocale(['toolbox', 'saveAsImage', 'title']),
+          type: 'png',
+          // Default use option.backgroundColor
+          // backgroundColor: '#fff',
+          connectedBackgroundColor: '#fff',
+          name: '',
+          excludeComponents: ['toolbox'],
+          // use current pixel ratio of device by default
+          // pixelRatio: 1,
+          lang: ecModel.getLocale(['toolbox', 'saveAsImage', 'lang'])
+        };
+        return defaultOption;
+      };
+
+      return SaveAsImage;
+    }(ToolboxFeature);
+
+    SaveAsImage.prototype.unusable = !env.canvasSupported;
+
+    var INNER_STACK_KEYWORD = '__ec_magicType_stack__';
+    var radioTypes = [['line', 'bar'], ['stack']];
+
+    var MagicType =
+    /** @class */
+    function (_super) {
+      __extends(MagicType, _super);
+
+      function MagicType() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      MagicType.prototype.getIcons = function () {
+        var model = this.model;
+        var availableIcons = model.get('icon');
+        var icons = {};
+        each(model.get('type'), function (type) {
+          if (availableIcons[type]) {
+            icons[type] = availableIcons[type];
+          }
+        });
+        return icons;
+      };
+
+      MagicType.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          type: [],
+          // Icon group
+          icon: {
+            line: 'M4.1,28.9h7.1l9.3-22l7.4,38l9.7-19.7l3,12.8h14.9M4.1,58h51.4',
+            bar: 'M6.7,22.9h10V48h-10V22.9zM24.9,13h10v35h-10V13zM43.2,2h10v46h-10V2zM3.1,58h53.7',
+            // eslint-disable-next-line
+            stack: 'M8.2,38.4l-8.4,4.1l30.6,15.3L60,42.5l-8.1-4.1l-21.5,11L8.2,38.4z M51.9,30l-8.1,4.2l-13.4,6.9l-13.9-6.9L8.2,30l-8.4,4.2l8.4,4.2l22.2,11l21.5-11l8.1-4.2L51.9,30z M51.9,21.7l-8.1,4.2L35.7,30l-5.3,2.8L24.9,30l-8.4-4.1l-8.3-4.2l-8.4,4.2L8.2,30l8.3,4.2l13.9,6.9l13.4-6.9l8.1-4.2l8.1-4.1L51.9,21.7zM30.4,2.2L-0.2,17.5l8.4,4.1l8.3,4.2l8.4,4.2l5.5,2.7l5.3-2.7l8.1-4.2l8.1-4.2l8.1-4.1L30.4,2.2z' // jshint ignore:line
+
+          },
+          // `line`, `bar`, `stack`, `tiled`
+          title: ecModel.getLocale(['toolbox', 'magicType', 'title']),
+          option: {},
+          seriesIndex: {}
+        };
+        return defaultOption;
+      };
+
+      MagicType.prototype.onclick = function (ecModel, api, type) {
+        var model = this.model;
+        var seriesIndex = model.get(['seriesIndex', type]); // Not supported magicType
+
+        if (!seriesOptGenreator[type]) {
+          return;
+        }
+
+        var newOption = {
+          series: []
+        };
+
+        var generateNewSeriesTypes = function (seriesModel) {
+          var seriesType = seriesModel.subType;
+          var seriesId = seriesModel.id;
+          var newSeriesOpt = seriesOptGenreator[type](seriesType, seriesId, seriesModel, model);
+
+          if (newSeriesOpt) {
+            // PENDING If merge original option?
+            defaults(newSeriesOpt, seriesModel.option);
+            newOption.series.push(newSeriesOpt);
+          } // Modify boundaryGap
+
+
+          var coordSys = seriesModel.coordinateSystem;
+
+          if (coordSys && coordSys.type === 'cartesian2d' && (type === 'line' || type === 'bar')) {
+            var categoryAxis = coordSys.getAxesByScale('ordinal')[0];
+
+            if (categoryAxis) {
+              var axisDim = categoryAxis.dim;
+              var axisType = axisDim + 'Axis';
+              var axisModel = seriesModel.getReferringComponents(axisType, SINGLE_REFERRING).models[0];
+              var axisIndex = axisModel.componentIndex;
+              newOption[axisType] = newOption[axisType] || [];
+
+              for (var i = 0; i <= axisIndex; i++) {
+                newOption[axisType][axisIndex] = newOption[axisType][axisIndex] || {};
+              }
+
+              newOption[axisType][axisIndex].boundaryGap = type === 'bar';
+            }
+          }
+        };
+
+        each(radioTypes, function (radio) {
+          if (indexOf(radio, type) >= 0) {
+            each(radio, function (item) {
+              model.setIconStatus(item, 'normal');
+            });
+          }
+        });
+        model.setIconStatus(type, 'emphasis');
+        ecModel.eachComponent({
+          mainType: 'series',
+          query: seriesIndex == null ? null : {
+            seriesIndex: seriesIndex
+          }
+        }, generateNewSeriesTypes);
+        var newTitle; // Change title of stack
+
+        if (type === 'stack') {
+          // use titles in model instead of ecModel
+          // as stack and tiled appears in pair, just flip them
+          // no need of checking stack state
+          newTitle = merge({
+            stack: model.option.title.tiled,
+            tiled: model.option.title.stack
+          }, model.option.title);
+        }
+
+        api.dispatchAction({
+          type: 'changeMagicType',
+          currentType: type,
+          newOption: newOption,
+          newTitle: newTitle,
+          featureName: 'magicType'
+        });
+      };
+
+      return MagicType;
+    }(ToolboxFeature);
+
+    var seriesOptGenreator = {
+      'line': function (seriesType, seriesId, seriesModel, model) {
+        if (seriesType === 'bar') {
+          return merge({
+            id: seriesId,
+            type: 'line',
+            // Preserve data related option
+            data: seriesModel.get('data'),
+            stack: seriesModel.get('stack'),
+            markPoint: seriesModel.get('markPoint'),
+            markLine: seriesModel.get('markLine')
+          }, model.get(['option', 'line']) || {}, true);
+        }
+      },
+      'bar': function (seriesType, seriesId, seriesModel, model) {
+        if (seriesType === 'line') {
+          return merge({
+            id: seriesId,
+            type: 'bar',
+            // Preserve data related option
+            data: seriesModel.get('data'),
+            stack: seriesModel.get('stack'),
+            markPoint: seriesModel.get('markPoint'),
+            markLine: seriesModel.get('markLine')
+          }, model.get(['option', 'bar']) || {}, true);
+        }
+      },
+      'stack': function (seriesType, seriesId, seriesModel, model) {
+        var isStack = seriesModel.get('stack') === INNER_STACK_KEYWORD;
+
+        if (seriesType === 'line' || seriesType === 'bar') {
+          model.setIconStatus('stack', isStack ? 'normal' : 'emphasis');
+          return merge({
+            id: seriesId,
+            stack: isStack ? '' : INNER_STACK_KEYWORD
+          }, model.get(['option', 'stack']) || {}, true);
+        }
+      }
+    }; // TODO: SELF REGISTERED.
+
+    registerAction({
+      type: 'changeMagicType',
+      event: 'magicTypeChanged',
+      update: 'prepareAndUpdate'
+    }, function (payload, ecModel) {
+      ecModel.mergeOption(payload.newOption);
+    });
+
+    var BLOCK_SPLITER = new Array(60).join('-');
+    var ITEM_SPLITER = '\t';
+    /**
+     * Group series into two types
+     *  1. on category axis, like line, bar
+     *  2. others, like scatter, pie
+     */
+
+    function groupSeries(ecModel) {
+      var seriesGroupByCategoryAxis = {};
+      var otherSeries = [];
+      var meta = [];
+      ecModel.eachRawSeries(function (seriesModel) {
+        var coordSys = seriesModel.coordinateSystem;
+
+        if (coordSys && (coordSys.type === 'cartesian2d' || coordSys.type === 'polar')) {
+          // TODO: TYPE Consider polar? Include polar may increase unecessary bundle size.
+          var baseAxis = coordSys.getBaseAxis();
+
+          if (baseAxis.type === 'category') {
+            var key = baseAxis.dim + '_' + baseAxis.index;
+
+            if (!seriesGroupByCategoryAxis[key]) {
+              seriesGroupByCategoryAxis[key] = {
+                categoryAxis: baseAxis,
+                valueAxis: coordSys.getOtherAxis(baseAxis),
+                series: []
+              };
+              meta.push({
+                axisDim: baseAxis.dim,
+                axisIndex: baseAxis.index
+              });
+            }
+
+            seriesGroupByCategoryAxis[key].series.push(seriesModel);
+          } else {
+            otherSeries.push(seriesModel);
+          }
+        } else {
+          otherSeries.push(seriesModel);
+        }
+      });
+      return {
+        seriesGroupByCategoryAxis: seriesGroupByCategoryAxis,
+        other: otherSeries,
+        meta: meta
+      };
+    }
+    /**
+     * Assemble content of series on cateogory axis
+     * @inner
+     */
+
+
+    function assembleSeriesWithCategoryAxis(groups) {
+      var tables = [];
+      each(groups, function (group, key) {
+        var categoryAxis = group.categoryAxis;
+        var valueAxis = group.valueAxis;
+        var valueAxisDim = valueAxis.dim;
+        var headers = [' '].concat(map(group.series, function (series) {
+          return series.name;
+        })); // @ts-ignore TODO Polar
+
+        var columns = [categoryAxis.model.getCategories()];
+        each(group.series, function (series) {
+          var rawData = series.getRawData();
+          columns.push(series.getRawData().mapArray(rawData.mapDimension(valueAxisDim), function (val) {
+            return val;
+          }));
+        }); // Assemble table content
+
+        var lines = [headers.join(ITEM_SPLITER)];
+
+        for (var i = 0; i < columns[0].length; i++) {
+          var items = [];
+
+          for (var j = 0; j < columns.length; j++) {
+            items.push(columns[j][i]);
+          }
+
+          lines.push(items.join(ITEM_SPLITER));
+        }
+
+        tables.push(lines.join('\n'));
+      });
+      return tables.join('\n\n' + BLOCK_SPLITER + '\n\n');
+    }
+    /**
+     * Assemble content of other series
+     */
+
+
+    function assembleOtherSeries(series) {
+      return map(series, function (series) {
+        var data = series.getRawData();
+        var lines = [series.name];
+        var vals = [];
+        data.each(data.dimensions, function () {
+          var argLen = arguments.length;
+          var dataIndex = arguments[argLen - 1];
+          var name = data.getName(dataIndex);
+
+          for (var i = 0; i < argLen - 1; i++) {
+            vals[i] = arguments[i];
+          }
+
+          lines.push((name ? name + ITEM_SPLITER : '') + vals.join(ITEM_SPLITER));
+        });
+        return lines.join('\n');
+      }).join('\n\n' + BLOCK_SPLITER + '\n\n');
+    }
+
+    function getContentFromModel(ecModel) {
+      var result = groupSeries(ecModel);
+      return {
+        value: filter([assembleSeriesWithCategoryAxis(result.seriesGroupByCategoryAxis), assembleOtherSeries(result.other)], function (str) {
+          return !!str.replace(/[\n\t\s]/g, '');
+        }).join('\n\n' + BLOCK_SPLITER + '\n\n'),
+        meta: result.meta
+      };
+    }
+
+    function trim$1(str) {
+      return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+    }
+    /**
+     * If a block is tsv format
+     */
+
+
+    function isTSVFormat(block) {
+      // Simple method to find out if a block is tsv format
+      var firstLine = block.slice(0, block.indexOf('\n'));
+
+      if (firstLine.indexOf(ITEM_SPLITER) >= 0) {
+        return true;
+      }
+    }
+
+    var itemSplitRegex = new RegExp('[' + ITEM_SPLITER + ']+', 'g');
+    /**
+     * @param {string} tsv
+     * @return {Object}
+     */
+
+    function parseTSVContents(tsv) {
+      var tsvLines = tsv.split(/\n+/g);
+      var headers = trim$1(tsvLines.shift()).split(itemSplitRegex);
+      var categories = [];
+      var series = map(headers, function (header) {
+        return {
+          name: header,
+          data: []
+        };
+      });
+
+      for (var i = 0; i < tsvLines.length; i++) {
+        var items = trim$1(tsvLines[i]).split(itemSplitRegex);
+        categories.push(items.shift());
+
+        for (var j = 0; j < items.length; j++) {
+          series[j] && (series[j].data[i] = items[j]);
+        }
+      }
+
+      return {
+        series: series,
+        categories: categories
+      };
+    }
+
+    function parseListContents(str) {
+      var lines = str.split(/\n+/g);
+      var seriesName = trim$1(lines.shift());
+      var data = [];
+
+      for (var i = 0; i < lines.length; i++) {
+        // if line is empty, ignore it.
+        // there is a case that a user forgot to delete `\n`.
+        var line = trim$1(lines[i]);
+
+        if (!line) {
+          continue;
+        }
+
+        var items = line.split(itemSplitRegex);
+        var name_1 = '';
+        var value = void 0;
+        var hasName = false;
+
+        if (isNaN(items[0])) {
+          // First item is name
+          hasName = true;
+          name_1 = items[0];
+          items = items.slice(1);
+          data[i] = {
+            name: name_1,
+            value: []
+          };
+          value = data[i].value;
+        } else {
+          value = data[i] = [];
+        }
+
+        for (var j = 0; j < items.length; j++) {
+          value.push(+items[j]);
+        }
+
+        if (value.length === 1) {
+          hasName ? data[i].value = value[0] : data[i] = value[0];
+        }
+      }
+
+      return {
+        name: seriesName,
+        data: data
+      };
+    }
+
+    function parseContents(str, blockMetaList) {
+      var blocks = str.split(new RegExp('\n*' + BLOCK_SPLITER + '\n*', 'g'));
+      var newOption = {
+        series: []
+      };
+      each(blocks, function (block, idx) {
+        if (isTSVFormat(block)) {
+          var result = parseTSVContents(block);
+          var blockMeta = blockMetaList[idx];
+          var axisKey = blockMeta.axisDim + 'Axis';
+
+          if (blockMeta) {
+            newOption[axisKey] = newOption[axisKey] || [];
+            newOption[axisKey][blockMeta.axisIndex] = {
+              data: result.categories
+            };
+            newOption.series = newOption.series.concat(result.series);
+          }
+        } else {
+          var result = parseListContents(block);
+          newOption.series.push(result);
+        }
+      });
+      return newOption;
+    }
+
+    var DataView =
+    /** @class */
+    function (_super) {
+      __extends(DataView, _super);
+
+      function DataView() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      DataView.prototype.onclick = function (ecModel, api) {
+        var container = api.getDom();
+        var model = this.model;
+
+        if (this._dom) {
+          container.removeChild(this._dom);
+        }
+
+        var root = document.createElement('div');
+        root.style.cssText = 'position:absolute;left:5px;top:5px;bottom:5px;right:5px;';
+        root.style.backgroundColor = model.get('backgroundColor') || '#fff'; // Create elements
+
+        var header = document.createElement('h4');
+        var lang = model.get('lang') || [];
+        header.innerHTML = lang[0] || model.get('title');
+        header.style.cssText = 'margin: 10px 20px;';
+        header.style.color = model.get('textColor');
+        var viewMain = document.createElement('div');
+        var textarea = document.createElement('textarea');
+        viewMain.style.cssText = 'display:block;width:100%;overflow:auto;';
+        var optionToContent = model.get('optionToContent');
+        var contentToOption = model.get('contentToOption');
+        var result = getContentFromModel(ecModel);
+
+        if (typeof optionToContent === 'function') {
+          var htmlOrDom = optionToContent(api.getOption());
+
+          if (typeof htmlOrDom === 'string') {
+            viewMain.innerHTML = htmlOrDom;
+          } else if (isDom(htmlOrDom)) {
+            viewMain.appendChild(htmlOrDom);
+          }
+        } else {
+          // Use default textarea
+          viewMain.appendChild(textarea);
+          textarea.readOnly = model.get('readOnly');
+          textarea.style.cssText = 'width:100%;height:100%;font-family:monospace;font-size:14px;line-height:1.6rem;';
+          textarea.style.color = model.get('textColor');
+          textarea.style.borderColor = model.get('textareaBorderColor');
+          textarea.style.backgroundColor = model.get('textareaColor');
+          textarea.value = result.value;
+        }
+
+        var blockMetaList = result.meta;
+        var buttonContainer = document.createElement('div');
+        buttonContainer.style.cssText = 'position:absolute;bottom:0;left:0;right:0;';
+        var buttonStyle = 'float:right;margin-right:20px;border:none;' + 'cursor:pointer;padding:2px 5px;font-size:12px;border-radius:3px';
+        var closeButton = document.createElement('div');
+        var refreshButton = document.createElement('div');
+        buttonStyle += ';background-color:' + model.get('buttonColor');
+        buttonStyle += ';color:' + model.get('buttonTextColor');
+        var self = this;
+
+        function close() {
+          container.removeChild(root);
+          self._dom = null;
+        }
+
+        addEventListener(closeButton, 'click', close);
+        addEventListener(refreshButton, 'click', function () {
+          if (contentToOption == null && optionToContent != null || contentToOption != null && optionToContent == null) {
+            if ("development" !== 'production') {
+              // eslint-disable-next-line
+              console.warn('It seems you have just provided one of `contentToOption` and `optionToContent` functions but missed the other one. Data change is ignored.');
+            }
+
+            close();
+            return;
+          }
+
+          var newOption;
+
+          try {
+            if (typeof contentToOption === 'function') {
+              newOption = contentToOption(viewMain, api.getOption());
+            } else {
+              newOption = parseContents(textarea.value, blockMetaList);
+            }
+          } catch (e) {
+            close();
+            throw new Error('Data view format error ' + e);
+          }
+
+          if (newOption) {
+            api.dispatchAction({
+              type: 'changeDataView',
+              newOption: newOption
+            });
+          }
+
+          close();
+        });
+        closeButton.innerHTML = lang[1];
+        refreshButton.innerHTML = lang[2];
+        refreshButton.style.cssText = buttonStyle;
+        closeButton.style.cssText = buttonStyle;
+        !model.get('readOnly') && buttonContainer.appendChild(refreshButton);
+        buttonContainer.appendChild(closeButton);
+        root.appendChild(header);
+        root.appendChild(viewMain);
+        root.appendChild(buttonContainer);
+        viewMain.style.height = container.clientHeight - 80 + 'px';
+        container.appendChild(root);
+        this._dom = root;
+      };
+
+      DataView.prototype.remove = function (ecModel, api) {
+        this._dom && api.getDom().removeChild(this._dom);
+      };
+
+      DataView.prototype.dispose = function (ecModel, api) {
+        this.remove(ecModel, api);
+      };
+
+      DataView.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          readOnly: false,
+          optionToContent: null,
+          contentToOption: null,
+          // eslint-disable-next-line
+          icon: 'M17.5,17.3H33 M17.5,17.3H33 M45.4,29.5h-28 M11.5,2v56H51V14.8L38.4,2H11.5z M38.4,2.2v12.7H51 M45.4,41.7h-28',
+          title: ecModel.getLocale(['toolbox', 'dataView', 'title']),
+          lang: ecModel.getLocale(['toolbox', 'dataView', 'lang']),
+          backgroundColor: '#fff',
+          textColor: '#000',
+          textareaColor: '#fff',
+          textareaBorderColor: '#333',
+          buttonColor: '#c23531',
+          buttonTextColor: '#fff'
+        };
+        return defaultOption;
+      };
+
+      return DataView;
+    }(ToolboxFeature);
+    /**
+     * @inner
+     */
+
+
+    function tryMergeDataOption(newData, originalData) {
+      return map(newData, function (newVal, idx) {
+        var original = originalData && originalData[idx];
+
+        if (isObject(original) && !isArray(original)) {
+          var newValIsObject = isObject(newVal) && !isArray(newVal);
+
+          if (!newValIsObject) {
+            newVal = {
+              value: newVal
+            };
+          } // original data has name but new data has no name
+
+
+          var shouldDeleteName = original.name != null && newVal.name == null; // Original data has option
+
+          newVal = defaults(newVal, original);
+          shouldDeleteName && delete newVal.name;
+          return newVal;
+        } else {
+          return newVal;
+        }
+      });
+    } // TODO: SELF REGISTERED.
+
+
+    registerAction({
+      type: 'changeDataView',
+      event: 'dataViewChanged',
+      update: 'prepareAndUpdate'
+    }, function (payload, ecModel) {
+      var newSeriesOptList = [];
+      each(payload.newOption.series, function (seriesOpt) {
+        var seriesModel = ecModel.getSeriesByName(seriesOpt.name)[0];
+
+        if (!seriesModel) {
+          // New created series
+          // Geuss the series type
+          newSeriesOptList.push(extend({
+            // Default is scatter
+            type: 'scatter'
+          }, seriesOpt));
+        } else {
+          var originalData = seriesModel.get('data');
+          newSeriesOptList.push({
+            name: seriesOpt.name,
+            data: tryMergeDataOption(seriesOpt.data, originalData)
+          });
+        }
+      });
+      ecModel.mergeOption(defaults({
+        series: newSeriesOptList
+      }, payload.newOption));
+    });
+
+    var each$a = each;
+    var inner$h = makeInner();
+    /**
+     * @param ecModel
+     * @param newSnapshot key is dataZoomId
+     */
+
+    function push(ecModel, newSnapshot) {
+      var storedSnapshots = getStoreSnapshots(ecModel); // If previous dataZoom can not be found,
+      // complete an range with current range.
+
+      each$a(newSnapshot, function (batchItem, dataZoomId) {
+        var i = storedSnapshots.length - 1;
+
+        for (; i >= 0; i--) {
+          var snapshot = storedSnapshots[i];
+
+          if (snapshot[dataZoomId]) {
+            break;
+          }
+        }
+
+        if (i < 0) {
+          // No origin range set, create one by current range.
+          var dataZoomModel = ecModel.queryComponents({
+            mainType: 'dataZoom',
+            subType: 'select',
+            id: dataZoomId
+          })[0];
+
+          if (dataZoomModel) {
+            var percentRange = dataZoomModel.getPercentRange();
+            storedSnapshots[0][dataZoomId] = {
+              dataZoomId: dataZoomId,
+              start: percentRange[0],
+              end: percentRange[1]
+            };
+          }
+        }
+      });
+      storedSnapshots.push(newSnapshot);
+    }
+    function pop(ecModel) {
+      var storedSnapshots = getStoreSnapshots(ecModel);
+      var head = storedSnapshots[storedSnapshots.length - 1];
+      storedSnapshots.length > 1 && storedSnapshots.pop(); // Find top for all dataZoom.
+
+      var snapshot = {};
+      each$a(head, function (batchItem, dataZoomId) {
+        for (var i = storedSnapshots.length - 1; i >= 0; i--) {
+          batchItem = storedSnapshots[i][dataZoomId];
+
+          if (batchItem) {
+            snapshot[dataZoomId] = batchItem;
+            break;
+          }
+        }
+      });
+      return snapshot;
+    }
+    function clear$1(ecModel) {
+      inner$h(ecModel).snapshots = null;
+    }
+    function count(ecModel) {
+      return getStoreSnapshots(ecModel).length;
+    }
+    /**
+     * History length of each dataZoom may be different.
+     * this._history[0] is used to store origin range.
+     */
+
+    function getStoreSnapshots(ecModel) {
+      var store = inner$h(ecModel);
+
+      if (!store.snapshots) {
+        store.snapshots = [{}];
+      }
+
+      return store.snapshots;
+    }
+
+    var RestoreOption =
+    /** @class */
+    function (_super) {
+      __extends(RestoreOption, _super);
+
+      function RestoreOption() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      RestoreOption.prototype.onclick = function (ecModel, api) {
+        clear$1(ecModel);
+        api.dispatchAction({
+          type: 'restore',
+          from: this.uid
+        });
+      };
+
+      RestoreOption.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          // eslint-disable-next-line
+          icon: 'M3.8,33.4 M47,18.9h9.8V8.7 M56.3,20.1 C52.1,9,40.5,0.6,26.8,2.1C12.6,3.7,1.6,16.2,2.1,30.6 M13,41.1H3.1v10.2 M3.7,39.9c4.2,11.1,15.8,19.5,29.5,18 c14.2-1.6,25.2-14.1,24.7-28.5',
+          title: ecModel.getLocale(['toolbox', 'restore', 'title'])
+        };
+        return defaultOption;
+      };
+
+      return RestoreOption;
+    }(ToolboxFeature); // TODO: SELF REGISTERED.
+
+
+    registerAction({
+      type: 'restore',
+      event: 'restore',
+      update: 'prepareAndUpdate'
+    }, function (payload, ecModel) {
+      ecModel.resetOption('recreate');
+    });
+
+    var COORD_CONVERTS = ['dataToPoint', 'pointToData']; // FIXME
+    // how to genarialize to more coordinate systems.
+
+    var INCLUDE_FINDER_MAIN_TYPES = ['grid', 'xAxis', 'yAxis', 'geo', 'graph', 'polar', 'radiusAxis', 'angleAxis', 'bmap'];
+
+    var BrushTargetManager =
+    /** @class */
+    function () {
+      /**
+       * @param finder contains Index/Id/Name of xAxis/yAxis/geo/grid
+       *        Each can be {number|Array.<number>}. like: {xAxisIndex: [3, 4]}
+       * @param opt.include include coordinate system types.
+       */
+      function BrushTargetManager(finder, ecModel, opt) {
+        var _this = this;
+
+        this._targetInfoList = [];
+        var foundCpts = parseFinder$1(ecModel, finder);
+        each(targetInfoBuilders, function (builder, type) {
+          if (!opt || !opt.include || indexOf(opt.include, type) >= 0) {
+            builder(foundCpts, _this._targetInfoList);
+          }
+        });
+      }
+
+      BrushTargetManager.prototype.setOutputRanges = function (areas, ecModel) {
+        this.matchOutputRanges(areas, ecModel, function (area, coordRange, coordSys) {
+          (area.coordRanges || (area.coordRanges = [])).push(coordRange); // area.coordRange is the first of area.coordRanges
+
+          if (!area.coordRange) {
+            area.coordRange = coordRange; // In 'category' axis, coord to pixel is not reversible, so we can not
+            // rebuild range by coordRange accrately, which may bring trouble when
+            // brushing only one item. So we use __rangeOffset to rebuilding range
+            // by coordRange. And this it only used in brush component so it is no
+            // need to be adapted to coordRanges.
+
+            var result = coordConvert[area.brushType](0, coordSys, coordRange);
+            area.__rangeOffset = {
+              offset: diffProcessor[area.brushType](result.values, area.range, [1, 1]),
+              xyMinMax: result.xyMinMax
+            };
+          }
+        });
+        return areas;
+      };
+
+      BrushTargetManager.prototype.matchOutputRanges = function (areas, ecModel, cb) {
+        each(areas, function (area) {
+          var targetInfo = this.findTargetInfo(area, ecModel);
+
+          if (targetInfo && targetInfo !== true) {
+            each(targetInfo.coordSyses, function (coordSys) {
+              var result = coordConvert[area.brushType](1, coordSys, area.range);
+              cb(area, result.values, coordSys, ecModel);
+            });
+          }
+        }, this);
+      };
+      /**
+       * the `areas` is `BrushModel.areas`.
+       * Called in layout stage.
+       * convert `area.coordRange` to global range and set panelId to `area.range`.
+       */
+
+
+      BrushTargetManager.prototype.setInputRanges = function (areas, ecModel) {
+        each(areas, function (area) {
+          var targetInfo = this.findTargetInfo(area, ecModel);
+
+          if ("development" !== 'production') {
+            assert(!targetInfo || targetInfo === true || area.coordRange, 'coordRange must be specified when coord index specified.');
+            assert(!targetInfo || targetInfo !== true || area.range, 'range must be specified in global brush.');
+          }
+
+          area.range = area.range || []; // convert coordRange to global range and set panelId.
+
+          if (targetInfo && targetInfo !== true) {
+            area.panelId = targetInfo.panelId; // (1) area.range shoule always be calculate from coordRange but does
+            // not keep its original value, for the sake of the dataZoom scenario,
+            // where area.coordRange remains unchanged but area.range may be changed.
+            // (2) Only support converting one coordRange to pixel range in brush
+            // component. So do not consider `coordRanges`.
+            // (3) About __rangeOffset, see comment above.
+
+            var result = coordConvert[area.brushType](0, targetInfo.coordSys, area.coordRange);
+            var rangeOffset = area.__rangeOffset;
+            area.range = rangeOffset ? diffProcessor[area.brushType](result.values, rangeOffset.offset, getScales(result.xyMinMax, rangeOffset.xyMinMax)) : result.values;
+          }
+        }, this);
+      };
+
+      BrushTargetManager.prototype.makePanelOpts = function (api, getDefaultBrushType) {
+        return map(this._targetInfoList, function (targetInfo) {
+          var rect = targetInfo.getPanelRect();
+          return {
+            panelId: targetInfo.panelId,
+            defaultBrushType: getDefaultBrushType ? getDefaultBrushType(targetInfo) : null,
+            clipPath: makeRectPanelClipPath(rect),
+            isTargetByCursor: makeRectIsTargetByCursor(rect, api, targetInfo.coordSysModel),
+            getLinearBrushOtherExtent: makeLinearBrushOtherExtent(rect)
+          };
+        });
+      };
+
+      BrushTargetManager.prototype.controlSeries = function (area, seriesModel, ecModel) {
+        // Check whether area is bound in coord, and series do not belong to that coord.
+        // If do not do this check, some brush (like lineX) will controll all axes.
+        var targetInfo = this.findTargetInfo(area, ecModel);
+        return targetInfo === true || targetInfo && indexOf(targetInfo.coordSyses, seriesModel.coordinateSystem) >= 0;
+      };
+      /**
+       * If return Object, a coord found.
+       * If reutrn true, global found.
+       * Otherwise nothing found.
+       */
+
+
+      BrushTargetManager.prototype.findTargetInfo = function (area, ecModel) {
+        var targetInfoList = this._targetInfoList;
+        var foundCpts = parseFinder$1(ecModel, area);
+
+        for (var i = 0; i < targetInfoList.length; i++) {
+          var targetInfo = targetInfoList[i];
+          var areaPanelId = area.panelId;
+
+          if (areaPanelId) {
+            if (targetInfo.panelId === areaPanelId) {
+              return targetInfo;
+            }
+          } else {
+            for (var j = 0; j < targetInfoMatchers.length; j++) {
+              if (targetInfoMatchers[j](foundCpts, targetInfo)) {
+                return targetInfo;
+              }
+            }
+          }
+        }
+
+        return true;
+      };
+
+      return BrushTargetManager;
+    }();
+
+    function formatMinMax(minMax) {
+      minMax[0] > minMax[1] && minMax.reverse();
+      return minMax;
+    }
+
+    function parseFinder$1(ecModel, finder) {
+      return parseFinder(ecModel, finder, {
+        includeMainTypes: INCLUDE_FINDER_MAIN_TYPES
+      });
+    }
+
+    var targetInfoBuilders = {
+      grid: function (foundCpts, targetInfoList) {
+        var xAxisModels = foundCpts.xAxisModels;
+        var yAxisModels = foundCpts.yAxisModels;
+        var gridModels = foundCpts.gridModels; // Remove duplicated.
+
+        var gridModelMap = createHashMap();
+        var xAxesHas = {};
+        var yAxesHas = {};
+
+        if (!xAxisModels && !yAxisModels && !gridModels) {
+          return;
+        }
+
+        each(xAxisModels, function (axisModel) {
+          var gridModel = axisModel.axis.grid.model;
+          gridModelMap.set(gridModel.id, gridModel);
+          xAxesHas[gridModel.id] = true;
+        });
+        each(yAxisModels, function (axisModel) {
+          var gridModel = axisModel.axis.grid.model;
+          gridModelMap.set(gridModel.id, gridModel);
+          yAxesHas[gridModel.id] = true;
+        });
+        each(gridModels, function (gridModel) {
+          gridModelMap.set(gridModel.id, gridModel);
+          xAxesHas[gridModel.id] = true;
+          yAxesHas[gridModel.id] = true;
+        });
+        gridModelMap.each(function (gridModel) {
+          var grid = gridModel.coordinateSystem;
+          var cartesians = [];
+          each(grid.getCartesians(), function (cartesian, index) {
+            if (indexOf(xAxisModels, cartesian.getAxis('x').model) >= 0 || indexOf(yAxisModels, cartesian.getAxis('y').model) >= 0) {
+              cartesians.push(cartesian);
+            }
+          });
+          targetInfoList.push({
+            panelId: 'grid--' + gridModel.id,
+            gridModel: gridModel,
+            coordSysModel: gridModel,
+            // Use the first one as the representitive coordSys.
+            coordSys: cartesians[0],
+            coordSyses: cartesians,
+            getPanelRect: panelRectBuilders.grid,
+            xAxisDeclared: xAxesHas[gridModel.id],
+            yAxisDeclared: yAxesHas[gridModel.id]
+          });
+        });
+      },
+      geo: function (foundCpts, targetInfoList) {
+        each(foundCpts.geoModels, function (geoModel) {
+          var coordSys = geoModel.coordinateSystem;
+          targetInfoList.push({
+            panelId: 'geo--' + geoModel.id,
+            geoModel: geoModel,
+            coordSysModel: geoModel,
+            coordSys: coordSys,
+            coordSyses: [coordSys],
+            getPanelRect: panelRectBuilders.geo
+          });
+        });
+      }
+    };
+    var targetInfoMatchers = [// grid
+    function (foundCpts, targetInfo) {
+      var xAxisModel = foundCpts.xAxisModel;
+      var yAxisModel = foundCpts.yAxisModel;
+      var gridModel = foundCpts.gridModel;
+      !gridModel && xAxisModel && (gridModel = xAxisModel.axis.grid.model);
+      !gridModel && yAxisModel && (gridModel = yAxisModel.axis.grid.model);
+      return gridModel && gridModel === targetInfo.gridModel;
+    }, // geo
+    function (foundCpts, targetInfo) {
+      var geoModel = foundCpts.geoModel;
+      return geoModel && geoModel === targetInfo.geoModel;
+    }];
+    var panelRectBuilders = {
+      grid: function () {
+        // grid is not Transformable.
+        return this.coordSys.master.getRect().clone();
+      },
+      geo: function () {
+        var coordSys = this.coordSys;
+        var rect = coordSys.getBoundingRect().clone(); // geo roam and zoom transform
+
+        rect.applyTransform(getTransform(coordSys));
+        return rect;
+      }
+    };
+    var coordConvert = {
+      lineX: curry(axisConvert, 0),
+      lineY: curry(axisConvert, 1),
+      rect: function (to, coordSys, rangeOrCoordRange) {
+        var xminymin = coordSys[COORD_CONVERTS[to]]([rangeOrCoordRange[0][0], rangeOrCoordRange[1][0]]);
+        var xmaxymax = coordSys[COORD_CONVERTS[to]]([rangeOrCoordRange[0][1], rangeOrCoordRange[1][1]]);
+        var values = [formatMinMax([xminymin[0], xmaxymax[0]]), formatMinMax([xminymin[1], xmaxymax[1]])];
+        return {
+          values: values,
+          xyMinMax: values
+        };
+      },
+      polygon: function (to, coordSys, rangeOrCoordRange) {
+        var xyMinMax = [[Infinity, -Infinity], [Infinity, -Infinity]];
+        var values = map(rangeOrCoordRange, function (item) {
+          var p = coordSys[COORD_CONVERTS[to]](item);
+          xyMinMax[0][0] = Math.min(xyMinMax[0][0], p[0]);
+          xyMinMax[1][0] = Math.min(xyMinMax[1][0], p[1]);
+          xyMinMax[0][1] = Math.max(xyMinMax[0][1], p[0]);
+          xyMinMax[1][1] = Math.max(xyMinMax[1][1], p[1]);
+          return p;
+        });
+        return {
+          values: values,
+          xyMinMax: xyMinMax
+        };
+      }
+    };
+
+    function axisConvert(axisNameIndex, to, coordSys, rangeOrCoordRange) {
+      if ("development" !== 'production') {
+        assert(coordSys.type === 'cartesian2d', 'lineX/lineY brush is available only in cartesian2d.');
+      }
+
+      var axis = coordSys.getAxis(['x', 'y'][axisNameIndex]);
+      var values = formatMinMax(map([0, 1], function (i) {
+        return to ? axis.coordToData(axis.toLocalCoord(rangeOrCoordRange[i])) : axis.toGlobalCoord(axis.dataToCoord(rangeOrCoordRange[i]));
+      }));
+      var xyMinMax = [];
+      xyMinMax[axisNameIndex] = values;
+      xyMinMax[1 - axisNameIndex] = [NaN, NaN];
+      return {
+        values: values,
+        xyMinMax: xyMinMax
+      };
+    }
+
+    var diffProcessor = {
+      lineX: curry(axisDiffProcessor, 0),
+      lineY: curry(axisDiffProcessor, 1),
+      rect: function (values, refer, scales) {
+        return [[values[0][0] - scales[0] * refer[0][0], values[0][1] - scales[0] * refer[0][1]], [values[1][0] - scales[1] * refer[1][0], values[1][1] - scales[1] * refer[1][1]]];
+      },
+      polygon: function (values, refer, scales) {
+        return map(values, function (item, idx) {
+          return [item[0] - scales[0] * refer[idx][0], item[1] - scales[1] * refer[idx][1]];
+        });
+      }
+    };
+
+    function axisDiffProcessor(axisNameIndex, values, refer, scales) {
+      return [values[0] - scales[axisNameIndex] * refer[0], values[1] - scales[axisNameIndex] * refer[1]];
+    } // We have to process scale caused by dataZoom manually,
+    // although it might be not accurate.
+    // Return [0~1, 0~1]
+
+
+    function getScales(xyMinMaxCurr, xyMinMaxOrigin) {
+      var sizeCurr = getSize(xyMinMaxCurr);
+      var sizeOrigin = getSize(xyMinMaxOrigin);
+      var scales = [sizeCurr[0] / sizeOrigin[0], sizeCurr[1] / sizeOrigin[1]];
+      isNaN(scales[0]) && (scales[0] = 1);
+      isNaN(scales[1]) && (scales[1] = 1);
+      return scales;
+    }
+
+    function getSize(xyMinMax) {
+      return xyMinMax ? [xyMinMax[0][1] - xyMinMax[0][0], xyMinMax[1][1] - xyMinMax[1][0]] : [NaN, NaN];
+    }
+
+    var each$b = each;
+    var DATA_ZOOM_ID_BASE = makeInternalComponentId('toolbox-dataZoom_');
+
+    var DataZoomFeature =
+    /** @class */
+    function (_super) {
+      __extends(DataZoomFeature, _super);
+
+      function DataZoomFeature() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      DataZoomFeature.prototype.render = function (featureModel, ecModel, api, payload) {
+        if (!this._brushController) {
+          this._brushController = new BrushController(api.getZr());
+
+          this._brushController.on('brush', bind(this._onBrush, this)).mount();
+        }
+
+        updateZoomBtnStatus(featureModel, ecModel, this, payload, api);
+        updateBackBtnStatus(featureModel, ecModel);
+      };
+
+      DataZoomFeature.prototype.onclick = function (ecModel, api, type) {
+        handlers$1[type].call(this);
+      };
+
+      DataZoomFeature.prototype.remove = function (ecModel, api) {
+        this._brushController && this._brushController.unmount();
+      };
+
+      DataZoomFeature.prototype.dispose = function (ecModel, api) {
+        this._brushController && this._brushController.dispose();
+      };
+
+      DataZoomFeature.prototype._onBrush = function (eventParam) {
+        var areas = eventParam.areas;
+
+        if (!eventParam.isEnd || !areas.length) {
+          return;
+        }
+
+        var snapshot = {};
+        var ecModel = this.ecModel;
+
+        this._brushController.updateCovers([]); // remove cover
+
+
+        var brushTargetManager = new BrushTargetManager(makeAxisFinder(this.model), ecModel, {
+          include: ['grid']
+        });
+        brushTargetManager.matchOutputRanges(areas, ecModel, function (area, coordRange, coordSys) {
+          if (coordSys.type !== 'cartesian2d') {
+            return;
+          }
+
+          var brushType = area.brushType;
+
+          if (brushType === 'rect') {
+            setBatch('x', coordSys, coordRange[0]);
+            setBatch('y', coordSys, coordRange[1]);
+          } else {
+            setBatch({
+              lineX: 'x',
+              lineY: 'y'
+            }[brushType], coordSys, coordRange);
+          }
+        });
+        push(ecModel, snapshot);
+
+        this._dispatchZoomAction(snapshot);
+
+        function setBatch(dimName, coordSys, minMax) {
+          var axis = coordSys.getAxis(dimName);
+          var axisModel = axis.model;
+          var dataZoomModel = findDataZoom(dimName, axisModel, ecModel); // Restrict range.
+
+          var minMaxSpan = dataZoomModel.findRepresentativeAxisProxy(axisModel).getMinMaxSpan();
+
+          if (minMaxSpan.minValueSpan != null || minMaxSpan.maxValueSpan != null) {
+            minMax = sliderMove(0, minMax.slice(), axis.scale.getExtent(), 0, minMaxSpan.minValueSpan, minMaxSpan.maxValueSpan);
+          }
+
+          dataZoomModel && (snapshot[dataZoomModel.id] = {
+            dataZoomId: dataZoomModel.id,
+            startValue: minMax[0],
+            endValue: minMax[1]
+          });
+        }
+
+        function findDataZoom(dimName, axisModel, ecModel) {
+          var found;
+          ecModel.eachComponent({
+            mainType: 'dataZoom',
+            subType: 'select'
+          }, function (dzModel) {
+            var has = dzModel.getAxisModel(dimName, axisModel.componentIndex);
+            has && (found = dzModel);
+          });
+          return found;
+        }
+      };
+
+      DataZoomFeature.prototype._dispatchZoomAction = function (snapshot) {
+        var batch = []; // Convert from hash map to array.
+
+        each$b(snapshot, function (batchItem, dataZoomId) {
+          batch.push(clone(batchItem));
+        });
+        batch.length && this.api.dispatchAction({
+          type: 'dataZoom',
+          from: this.uid,
+          batch: batch
+        });
+      };
+
+      DataZoomFeature.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          filterMode: 'filter',
+          // Icon group
+          icon: {
+            zoom: 'M0,13.5h26.9 M13.5,26.9V0 M32.1,13.5H58V58H13.5 V32.1',
+            back: 'M22,1.4L9.9,13.5l12.3,12.3 M10.3,13.5H54.9v44.6 H10.3v-26'
+          },
+          // `zoom`, `back`
+          title: ecModel.getLocale(['toolbox', 'dataZoom', 'title']),
+          brushStyle: {
+            borderWidth: 0,
+            color: 'rgba(210,219,238,0.2)'
+          }
+        };
+        return defaultOption;
+      };
+
+      return DataZoomFeature;
+    }(ToolboxFeature);
+
+    var handlers$1 = {
+      zoom: function () {
+        var nextActive = !this._isZoomActive;
+        this.api.dispatchAction({
+          type: 'takeGlobalCursor',
+          key: 'dataZoomSelect',
+          dataZoomSelectActive: nextActive
+        });
+      },
+      back: function () {
+        this._dispatchZoomAction(pop(this.ecModel));
+      }
+    };
+
+    function makeAxisFinder(dzFeatureModel) {
+      var setting = {
+        xAxisIndex: dzFeatureModel.get('xAxisIndex', true),
+        yAxisIndex: dzFeatureModel.get('yAxisIndex', true),
+        xAxisId: dzFeatureModel.get('xAxisId', true),
+        yAxisId: dzFeatureModel.get('yAxisId', true)
+      }; // If both `xAxisIndex` `xAxisId` not set, it means 'all'.
+      // If both `yAxisIndex` `yAxisId` not set, it means 'all'.
+      // Some old cases set like this below to close yAxis control but leave xAxis control:
+      // `{ feature: { dataZoom: { yAxisIndex: false } }`.
+
+      if (setting.xAxisIndex == null && setting.xAxisId == null) {
+        setting.xAxisIndex = 'all';
+      }
+
+      if (setting.yAxisIndex == null && setting.yAxisId == null) {
+        setting.yAxisIndex = 'all';
+      }
+
+      return setting;
+    }
+
+    function updateBackBtnStatus(featureModel, ecModel) {
+      featureModel.setIconStatus('back', count(ecModel) > 1 ? 'emphasis' : 'normal');
+    }
+
+    function updateZoomBtnStatus(featureModel, ecModel, view, payload, api) {
+      var zoomActive = view._isZoomActive;
+
+      if (payload && payload.type === 'takeGlobalCursor') {
+        zoomActive = payload.key === 'dataZoomSelect' ? payload.dataZoomSelectActive : false;
+      }
+
+      view._isZoomActive = zoomActive;
+      featureModel.setIconStatus('zoom', zoomActive ? 'emphasis' : 'normal');
+      var brushTargetManager = new BrushTargetManager(makeAxisFinder(featureModel), ecModel, {
+        include: ['grid']
+      });
+      var panels = brushTargetManager.makePanelOpts(api, function (targetInfo) {
+        return targetInfo.xAxisDeclared && !targetInfo.yAxisDeclared ? 'lineX' : !targetInfo.xAxisDeclared && targetInfo.yAxisDeclared ? 'lineY' : 'rect';
+      });
+
+      view._brushController.setPanels(panels).enableBrush(zoomActive && panels.length ? {
+        brushType: 'auto',
+        brushStyle: featureModel.getModel('brushStyle').getItemStyle()
+      } : false);
+    }
+
+    registerInternalOptionCreator('dataZoom', function (ecModel) {
+      var toolboxModel = ecModel.getComponent('toolbox', 0);
+
+      if (!toolboxModel) {
+        return;
+      }
+
+      var dzFeatureModel = toolboxModel.getModel(['feature', 'dataZoom']);
+      var dzOptions = [];
+      var finder = makeAxisFinder(dzFeatureModel);
+      var finderResult = parseFinder(ecModel, finder);
+      each$b(finderResult.xAxisModels, function (axisModel) {
+        return buildInternalOptions(axisModel, 'xAxis', 'xAxisIndex');
+      });
+      each$b(finderResult.yAxisModels, function (axisModel) {
+        return buildInternalOptions(axisModel, 'yAxis', 'yAxisIndex');
+      });
+
+      function buildInternalOptions(axisModel, axisMainType, axisIndexPropName) {
+        var axisIndex = axisModel.componentIndex;
+        var newOpt = {
+          type: 'select',
+          $fromToolbox: true,
+          // Default to be filter
+          filterMode: dzFeatureModel.get('filterMode', true) || 'filter',
+          // Id for merge mapping.
+          id: DATA_ZOOM_ID_BASE + axisMainType + axisIndex
+        };
+        newOpt[axisIndexPropName] = axisIndex;
+        dzOptions.push(newOpt);
+      }
+
+      return dzOptions;
+    });
+
+    function install$z(registers) {
+      registers.registerComponentModel(ToolboxModel);
+      registers.registerComponentView(ToolboxView);
+      registerFeature('saveAsImage', SaveAsImage);
+      registerFeature('magicType', MagicType);
+      registerFeature('dataView', DataView);
+      registerFeature('dataZoom', DataZoomFeature);
+      registerFeature('restore', RestoreOption);
+      use(install$y);
+    }
+
+    var TooltipModel =
+    /** @class */
+    function (_super) {
+      __extends(TooltipModel, _super);
+
+      function TooltipModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TooltipModel.type;
+        return _this;
+      }
+
+      TooltipModel.type = 'tooltip';
+      TooltipModel.dependencies = ['axisPointer'];
+      TooltipModel.defaultOption = {
+        zlevel: 0,
+        z: 60,
+        show: true,
+        // tooltip main content
+        showContent: true,
+        // 'trigger' only works on coordinate system.
+        // 'item' | 'axis' | 'none'
+        trigger: 'item',
+        // 'click' | 'mousemove' | 'none'
+        triggerOn: 'mousemove|click',
+        alwaysShowContent: false,
+        displayMode: 'single',
+        renderMode: 'auto',
+        // whether restraint content inside viewRect.
+        // If renderMode: 'richText', default true.
+        // If renderMode: 'html', defaut false (for backward compat).
+        confine: null,
+        showDelay: 0,
+        hideDelay: 100,
+        // Animation transition time, unit is second
+        transitionDuration: 0.4,
+        enterable: false,
+        backgroundColor: '#fff',
+        // box shadow
+        shadowBlur: 10,
+        shadowColor: 'rgba(0, 0, 0, .2)',
+        shadowOffsetX: 1,
+        shadowOffsetY: 2,
+        // tooltip border radius, unit is px, default is 4
+        borderRadius: 4,
+        // tooltip border width, unit is px, default is 0 (no border)
+        borderWidth: 1,
+        // Tooltip inside padding, default is 5 for all direction
+        // Array is allowed to set up, right, bottom, left, same with css
+        // The default value: See `tooltip/tooltipMarkup.ts#getPaddingFromTooltipModel`.
+        padding: null,
+        // Extra css text
+        extraCssText: '',
+        // axis indicator, trigger by axis
+        axisPointer: {
+          // default is line
+          // legal values: 'line' | 'shadow' | 'cross'
+          type: 'line',
+          // Valid when type is line, appoint tooltip line locate on which line. Optional
+          // legal values: 'x' | 'y' | 'angle' | 'radius' | 'auto'
+          // default is 'auto', chose the axis which type is category.
+          // for multiply y axis, cartesian coord chose x axis, polar chose angle axis
+          axis: 'auto',
+          animation: 'auto',
+          animationDurationUpdate: 200,
+          animationEasingUpdate: 'exponentialOut',
+          crossStyle: {
+            color: '#999',
+            width: 1,
+            type: 'dashed',
+            // TODO formatter
+            textStyle: {}
+          } // lineStyle and shadowStyle should not be specified here,
+          // otherwise it will always override those styles on option.axisPointer.
+
+        },
+        textStyle: {
+          color: '#666',
+          fontSize: 14
+        }
+      };
+      return TooltipModel;
+    }(ComponentModel);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function shouldTooltipConfine(tooltipModel) {
+      var confineOption = tooltipModel.get('confine');
+      return confineOption != null ? !!confineOption // In richText mode, the outside part can not be visible.
+      : tooltipModel.get('renderMode') === 'richText';
+    }
+
+    var vendors = ['-ms-', '-moz-', '-o-', '-webkit-', ''];
+    var gCssText = 'position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;';
+
+    function mirrorPos(pos) {
+      pos = pos === 'left' ? 'right' : pos === 'right' ? 'left' : pos === 'top' ? 'bottom' : 'top';
+      return pos;
+    }
+
+    function assembleArrow(backgroundColor, borderColor, arrowPosition) {
+      if (!isString(arrowPosition) || arrowPosition === 'inside') {
+        return '';
+      }
+
+      borderColor = convertToColorString(borderColor);
+      var arrowPos = mirrorPos(arrowPosition);
+      var positionStyle = '';
+      var transformStyle = '';
+
+      if (indexOf(['left', 'right'], arrowPos) > -1) {
+        positionStyle = arrowPos + ":-6px;top:50%;";
+        transformStyle = "translateY(-50%) rotate(" + (arrowPos === 'left' ? -225 : -45) + "deg)";
+      } else {
+        positionStyle = arrowPos + ":-6px;left:50%;";
+        transformStyle = "translateX(-50%) rotate(" + (arrowPos === 'top' ? 225 : 45) + "deg)";
+      }
+
+      transformStyle = map(vendors, function (vendorPrefix) {
+        return vendorPrefix + 'transform:' + transformStyle;
+      }).join(';');
+      var styleCss = ['position:absolute;width:10px;height:10px;', "" + positionStyle + transformStyle + ";", "border-bottom: " + borderColor + " solid 1px;", "border-right: " + borderColor + " solid 1px;", "background-color: " + backgroundColor + ";", 'box-shadow: 8px 8px 16px -3px #000;'];
+      return "<div style=\"" + styleCss.join('') + "\"></div>";
+    }
+
+    function assembleTransition(duration, onlyFade) {
+      var transitionCurve = 'cubic-bezier(0.23, 1, 0.32, 1)';
+      var transitionText = 'opacity ' + duration / 2 + 's ' + transitionCurve + ',' + 'visibility ' + duration / 2 + 's ' + transitionCurve;
+
+      if (!onlyFade) {
+        transitionText += ',left ' + duration + 's ' + transitionCurve + ',top ' + duration + 's ' + transitionCurve;
+      }
+
+      return map(vendors, function (vendorPrefix) {
+        return vendorPrefix + 'transition:' + transitionText;
+      }).join(';');
+    }
+    /**
+     * @param {Object} textStyle
+     * @return {string}
+     * @inner
+     */
+
+
+    function assembleFont(textStyleModel) {
+      var cssText = [];
+      var fontSize = textStyleModel.get('fontSize');
+      var color = textStyleModel.getTextColor();
+      color && cssText.push('color:' + color);
+      cssText.push('font:' + textStyleModel.getFont());
+      fontSize // @ts-ignore, leave it to the tooltip refactor.
+      && cssText.push('line-height:' + Math.round(fontSize * 3 / 2) + 'px');
+      var shadowColor = textStyleModel.get('textShadowColor');
+      var shadowBlur = textStyleModel.get('textShadowBlur') || 0;
+      var shadowOffsetX = textStyleModel.get('textShadowOffsetX') || 0;
+      var shadowOffsetY = textStyleModel.get('textShadowOffsetY') || 0;
+      shadowColor && shadowBlur && cssText.push('text-shadow:' + shadowOffsetX + 'px ' + shadowOffsetY + 'px ' + shadowBlur + 'px ' + shadowColor);
+      each(['decoration', 'align'], function (name) {
+        var val = textStyleModel.get(name);
+        val && cssText.push('text-' + name + ':' + val);
+      });
+      return cssText.join(';');
+    }
+
+    function assembleCssText(tooltipModel, enableTransition, onlyFade) {
+      var cssText = [];
+      var transitionDuration = tooltipModel.get('transitionDuration');
+      var backgroundColor = tooltipModel.get('backgroundColor');
+      var shadowBlur = tooltipModel.get('shadowBlur');
+      var shadowColor = tooltipModel.get('shadowColor');
+      var shadowOffsetX = tooltipModel.get('shadowOffsetX');
+      var shadowOffsetY = tooltipModel.get('shadowOffsetY');
+      var textStyleModel = tooltipModel.getModel('textStyle');
+      var padding = getPaddingFromTooltipModel(tooltipModel, 'html');
+      var boxShadow = shadowOffsetX + "px " + shadowOffsetY + "px " + shadowBlur + "px " + shadowColor;
+      cssText.push('box-shadow:' + boxShadow); // Animation transition. Do not animate when transitionDuration is 0.
+
+      enableTransition && transitionDuration && cssText.push(assembleTransition(transitionDuration, onlyFade));
+
+      if (backgroundColor) {
+        if (env.canvasSupported) {
+          cssText.push('background-Color:' + backgroundColor);
+        } else {
+          // for ie
+          cssText.push('background-Color:#' + toHex(backgroundColor));
+          cssText.push('filter:alpha(opacity=70)');
+        }
+      } // Border style
+
+
+      each(['width', 'color', 'radius'], function (name) {
+        var borderName = 'border-' + name;
+        var camelCase = toCamelCase(borderName);
+        var val = tooltipModel.get(camelCase);
+        val != null && cssText.push(borderName + ':' + val + (name === 'color' ? '' : 'px'));
+      }); // Text style
+
+      cssText.push(assembleFont(textStyleModel)); // Padding
+
+      if (padding != null) {
+        cssText.push('padding:' + normalizeCssArray$1(padding).join('px ') + 'px');
+      }
+
+      return cssText.join(';') + ';';
+    } // If not able to make, do not modify the input `out`.
+
+
+    function makeStyleCoord(out, zr, appendToBody, zrX, zrY) {
+      var zrPainter = zr && zr.painter;
+
+      if (appendToBody) {
+        var zrViewportRoot = zrPainter && zrPainter.getViewportRoot();
+
+        if (zrViewportRoot) {
+          // Some APPs might use scale on body, so we support CSS transform here.
+          transformLocalCoord(out, zrViewportRoot, document.body, zrX, zrY);
+        }
+      } else {
+        out[0] = zrX;
+        out[1] = zrY; // xy should be based on canvas root. But tooltipContent is
+        // the sibling of canvas root. So padding of ec container
+        // should be considered here.
+
+        var viewportRootOffset = zrPainter && zrPainter.getViewportRootOffset();
+
+        if (viewportRootOffset) {
+          out[0] += viewportRootOffset.offsetLeft;
+          out[1] += viewportRootOffset.offsetTop;
+        }
+      }
+
+      out[2] = out[0] / zr.getWidth();
+      out[3] = out[1] / zr.getHeight();
+    }
+
+    var TooltipHTMLContent =
+    /** @class */
+    function () {
+      function TooltipHTMLContent(container, api, opt) {
+        this._show = false;
+        this._styleCoord = [0, 0, 0, 0];
+        this._enterable = true;
+        this._firstShow = true;
+        this._longHide = true;
+
+        if (env.wxa) {
+          return null;
+        }
+
+        var el = document.createElement('div'); // TODO: TYPE
+
+        el.domBelongToZr = true;
+        this.el = el;
+        var zr = this._zr = api.getZr();
+        var appendToBody = this._appendToBody = opt && opt.appendToBody;
+        makeStyleCoord(this._styleCoord, zr, appendToBody, api.getWidth() / 2, api.getHeight() / 2);
+
+        if (appendToBody) {
+          document.body.appendChild(el);
+        } else {
+          container.appendChild(el);
+        }
+
+        this._container = container; // FIXME
+        // Is it needed to trigger zr event manually if
+        // the browser do not support `pointer-events: none`.
+
+        var self = this;
+
+        el.onmouseenter = function () {
+          // clear the timeout in hideLater and keep showing tooltip
+          if (self._enterable) {
+            clearTimeout(self._hideTimeout);
+            self._show = true;
+          }
+
+          self._inContent = true;
+        };
+
+        el.onmousemove = function (e) {
+          e = e || window.event;
+
+          if (!self._enterable) {
+            // `pointer-events: none` is set to tooltip content div
+            // if `enterable` is set as `false`, and `el.onmousemove`
+            // can not be triggered. But in browser that do not
+            // support `pointer-events`, we need to do this:
+            // Try trigger zrender event to avoid mouse
+            // in and out shape too frequently
+            var handler = zr.handler;
+            var zrViewportRoot = zr.painter.getViewportRoot();
+            normalizeEvent(zrViewportRoot, e, true);
+            handler.dispatch('mousemove', e);
+          }
+        };
+
+        el.onmouseleave = function () {
+          // set `_inContent` to `false` before `hideLater`
+          self._inContent = false;
+
+          if (self._enterable) {
+            if (self._show) {
+              self.hideLater(self._hideDelay);
+            }
+          }
+        };
+      }
+      /**
+       * Update when tooltip is rendered
+       */
+
+
+      TooltipHTMLContent.prototype.update = function (tooltipModel) {
+        // FIXME
+        // Move this logic to ec main?
+        var container = this._container;
+        var stl = container.currentStyle || document.defaultView.getComputedStyle(container);
+        var domStyle = container.style;
+
+        if (domStyle.position !== 'absolute' && stl.position !== 'absolute') {
+          domStyle.position = 'relative';
+        } // move tooltip if chart resized
+
+
+        var alwaysShowContent = tooltipModel.get('alwaysShowContent');
+        alwaysShowContent && this._moveIfResized(); // update className
+
+        this.el.className = tooltipModel.get('className') || ''; // Hide the tooltip
+        // PENDING
+        // this.hide();
+      };
+
+      TooltipHTMLContent.prototype.show = function (tooltipModel, nearPointColor) {
+        clearTimeout(this._hideTimeout);
+        clearTimeout(this._longHideTimeout);
+        var el = this.el;
+        var styleCoord = this._styleCoord;
+        var offset = el.offsetHeight / 2;
+        nearPointColor = convertToColorString(nearPointColor);
+        el.style.cssText = gCssText + assembleCssText(tooltipModel, !this._firstShow, this._longHide) // Because of the reason described in:
+        // http://stackoverflow.com/questions/21125587/css3-transition-not-working-in-chrome-anymore
+        // we should set initial value to `left` and `top`.
+        + ';left:' + styleCoord[0] + 'px;top:' + (styleCoord[1] - offset) + 'px;' + ("border-color: " + nearPointColor + ";") + (tooltipModel.get('extraCssText') || '');
+        el.style.display = el.innerHTML ? 'block' : 'none'; // If mouse occasionally move over the tooltip, a mouseout event will be
+        // triggered by canvas, and cause some unexpectable result like dragging
+        // stop, "unfocusAdjacency". Here `pointer-events: none` is used to solve
+        // it. Although it is not supported by IE8~IE10, fortunately it is a rare
+        // scenario.
+
+        el.style.pointerEvents = this._enterable ? 'auto' : 'none';
+        this._show = true;
+        this._firstShow = false;
+        this._longHide = false;
+      };
+
+      TooltipHTMLContent.prototype.setContent = function (content, markers, tooltipModel, borderColor, arrowPosition) {
+        if (content == null) {
+          return;
+        }
+
+        var el = this.el;
+
+        if (isString(arrowPosition) && tooltipModel.get('trigger') === 'item' && !shouldTooltipConfine(tooltipModel)) {
+          content += assembleArrow(tooltipModel.get('backgroundColor'), borderColor, arrowPosition);
+        }
+
+        if (isString(content)) {
+          el.innerHTML = content;
+        } else if (content) {
+          // Clear previous
+          el.innerHTML = '';
+
+          if (!isArray(content)) {
+            content = [content];
+          }
+
+          for (var i = 0; i < content.length; i++) {
+            if (isDom(content[i]) && content[i].parentNode !== el) {
+              el.appendChild(content[i]);
+            }
+          }
+        }
+      };
+
+      TooltipHTMLContent.prototype.setEnterable = function (enterable) {
+        this._enterable = enterable;
+      };
+
+      TooltipHTMLContent.prototype.getSize = function () {
+        var el = this.el;
+        return [el.clientWidth, el.clientHeight];
+      };
+
+      TooltipHTMLContent.prototype.moveTo = function (zrX, zrY) {
+        var styleCoord = this._styleCoord;
+        makeStyleCoord(styleCoord, this._zr, this._appendToBody, zrX, zrY);
+
+        if (styleCoord[0] != null && styleCoord[1] != null) {
+          var style = this.el.style; // If using float on style, the final width of the dom might
+          // keep changing slightly while mouse move. So `toFixed(0)` them.
+
+          style.left = styleCoord[0].toFixed(0) + 'px';
+          style.top = styleCoord[1].toFixed(0) + 'px';
+        }
+      };
+      /**
+       * when `alwaysShowContent` is true,
+       * move the tooltip after chart resized
+       */
+
+
+      TooltipHTMLContent.prototype._moveIfResized = function () {
+        // The ratio of left to width
+        var ratioX = this._styleCoord[2]; // The ratio of top to height
+
+        var ratioY = this._styleCoord[3];
+        this.moveTo(ratioX * this._zr.getWidth(), ratioY * this._zr.getHeight());
+      };
+
+      TooltipHTMLContent.prototype.hide = function () {
+        var _this = this;
+
+        this.el.style.visibility = 'hidden';
+        this.el.style.opacity = '0';
+        this._show = false;
+        this._longHideTimeout = setTimeout(function () {
+          return _this._longHide = true;
+        }, 500);
+      };
+
+      TooltipHTMLContent.prototype.hideLater = function (time) {
+        if (this._show && !(this._inContent && this._enterable)) {
+          if (time) {
+            this._hideDelay = time; // Set show false to avoid invoke hideLater multiple times
+
+            this._show = false;
+            this._hideTimeout = setTimeout(bind(this.hide, this), time);
+          } else {
+            this.hide();
+          }
+        }
+      };
+
+      TooltipHTMLContent.prototype.isShow = function () {
+        return this._show;
+      };
+
+      TooltipHTMLContent.prototype.dispose = function () {
+        this.el.parentNode.removeChild(this.el);
+      };
+
+      TooltipHTMLContent.prototype.getOuterSize = function () {
+        var width = this.el.clientWidth;
+        var height = this.el.clientHeight; // Consider browser compatibility.
+        // IE8 does not support getComputedStyle.
+
+        if (document.defaultView && document.defaultView.getComputedStyle) {
+          var stl = document.defaultView.getComputedStyle(this.el);
+
+          if (stl) {
+            width += parseInt(stl.borderLeftWidth, 10) + parseInt(stl.borderRightWidth, 10);
+            height += parseInt(stl.borderTopWidth, 10) + parseInt(stl.borderBottomWidth, 10);
+          }
+        }
+
+        return {
+          width: width,
+          height: height
+        };
+      };
+
+      return TooltipHTMLContent;
+    }();
+
+    var TooltipRichContent =
+    /** @class */
+    function () {
+      function TooltipRichContent(api) {
+        this._show = false;
+        this._styleCoord = [0, 0, 0, 0];
+        this._enterable = true;
+        this._zr = api.getZr();
+        makeStyleCoord$1(this._styleCoord, this._zr, api.getWidth() / 2, api.getHeight() / 2);
+      }
+      /**
+       * Update when tooltip is rendered
+       */
+
+
+      TooltipRichContent.prototype.update = function (tooltipModel) {
+        var alwaysShowContent = tooltipModel.get('alwaysShowContent');
+        alwaysShowContent && this._moveIfResized();
+      };
+
+      TooltipRichContent.prototype.show = function () {
+        if (this._hideTimeout) {
+          clearTimeout(this._hideTimeout);
+        }
+
+        this.el.show();
+        this._show = true;
+      };
+      /**
+       * Set tooltip content
+       */
+
+
+      TooltipRichContent.prototype.setContent = function (content, markupStyleCreator, tooltipModel, borderColor, arrowPosition) {
+        if (isObject(content)) {
+          throwError("development" !== 'production' ? 'Passing DOM nodes as content is not supported in richText tooltip!' : '');
+        }
+
+        if (this.el) {
+          this._zr.remove(this.el);
+        }
+
+        var textStyleModel = tooltipModel.getModel('textStyle');
+        this.el = new ZRText({
+          style: {
+            rich: markupStyleCreator.richTextStyles,
+            text: content,
+            lineHeight: 22,
+            backgroundColor: tooltipModel.get('backgroundColor'),
+            borderRadius: tooltipModel.get('borderRadius'),
+            borderWidth: 1,
+            borderColor: borderColor,
+            shadowColor: tooltipModel.get('shadowColor'),
+            shadowBlur: tooltipModel.get('shadowBlur'),
+            shadowOffsetX: tooltipModel.get('shadowOffsetX'),
+            shadowOffsetY: tooltipModel.get('shadowOffsetY'),
+            textShadowColor: textStyleModel.get('textShadowColor'),
+            textShadowBlur: textStyleModel.get('textShadowBlur') || 0,
+            textShadowOffsetX: textStyleModel.get('textShadowOffsetX') || 0,
+            textShadowOffsetY: textStyleModel.get('textShadowOffsetY') || 0,
+            fill: tooltipModel.get(['textStyle', 'color']),
+            padding: getPaddingFromTooltipModel(tooltipModel, 'richText'),
+            verticalAlign: 'top',
+            align: 'left'
+          },
+          z: tooltipModel.get('z')
+        });
+
+        this._zr.add(this.el);
+
+        var self = this;
+        this.el.on('mouseover', function () {
+          // clear the timeout in hideLater and keep showing tooltip
+          if (self._enterable) {
+            clearTimeout(self._hideTimeout);
+            self._show = true;
+          }
+
+          self._inContent = true;
+        });
+        this.el.on('mouseout', function () {
+          if (self._enterable) {
+            if (self._show) {
+              self.hideLater(self._hideDelay);
+            }
+          }
+
+          self._inContent = false;
+        });
+      };
+
+      TooltipRichContent.prototype.setEnterable = function (enterable) {
+        this._enterable = enterable;
+      };
+
+      TooltipRichContent.prototype.getSize = function () {
+        var el = this.el;
+        var bounding = this.el.getBoundingRect(); // bounding rect does not include shadow. For renderMode richText,
+        // if overflow, it will be cut. So calculate them accurately.
+
+        var shadowOuterSize = calcShadowOuterSize(el.style);
+        return [bounding.width + shadowOuterSize.left + shadowOuterSize.right, bounding.height + shadowOuterSize.top + shadowOuterSize.bottom];
+      };
+
+      TooltipRichContent.prototype.moveTo = function (x, y) {
+        var el = this.el;
+
+        if (el) {
+          var styleCoord = this._styleCoord;
+          makeStyleCoord$1(styleCoord, this._zr, x, y);
+          x = styleCoord[0];
+          y = styleCoord[1];
+          var style = el.style;
+          var borderWidth = mathMaxWith0(style.borderWidth || 0);
+          var shadowOuterSize = calcShadowOuterSize(style); // rich text x, y do not include border.
+
+          el.x = x + borderWidth + shadowOuterSize.left;
+          el.y = y + borderWidth + shadowOuterSize.top;
+          el.markRedraw();
+        }
+      };
+      /**
+       * when `alwaysShowContent` is true,
+       * move the tooltip after chart resized
+       */
+
+
+      TooltipRichContent.prototype._moveIfResized = function () {
+        // The ratio of left to width
+        var ratioX = this._styleCoord[2]; // The ratio of top to height
+
+        var ratioY = this._styleCoord[3];
+        this.moveTo(ratioX * this._zr.getWidth(), ratioY * this._zr.getHeight());
+      };
+
+      TooltipRichContent.prototype.hide = function () {
+        if (this.el) {
+          this.el.hide();
+        }
+
+        this._show = false;
+      };
+
+      TooltipRichContent.prototype.hideLater = function (time) {
+        if (this._show && !(this._inContent && this._enterable)) {
+          if (time) {
+            this._hideDelay = time; // Set show false to avoid invoke hideLater multiple times
+
+            this._show = false;
+            this._hideTimeout = setTimeout(bind(this.hide, this), time);
+          } else {
+            this.hide();
+          }
+        }
+      };
+
+      TooltipRichContent.prototype.isShow = function () {
+        return this._show;
+      };
+
+      TooltipRichContent.prototype.getOuterSize = function () {
+        var size = this.getSize();
+        return {
+          width: size[0],
+          height: size[1]
+        };
+      };
+
+      TooltipRichContent.prototype.dispose = function () {
+        this._zr.remove(this.el);
+      };
+
+      return TooltipRichContent;
+    }();
+
+    function mathMaxWith0(val) {
+      return Math.max(0, val);
+    }
+
+    function calcShadowOuterSize(style) {
+      var shadowBlur = mathMaxWith0(style.shadowBlur || 0);
+      var shadowOffsetX = mathMaxWith0(style.shadowOffsetX || 0);
+      var shadowOffsetY = mathMaxWith0(style.shadowOffsetY || 0);
+      return {
+        left: mathMaxWith0(shadowBlur - shadowOffsetX),
+        right: mathMaxWith0(shadowBlur + shadowOffsetX),
+        top: mathMaxWith0(shadowBlur - shadowOffsetY),
+        bottom: mathMaxWith0(shadowBlur + shadowOffsetY)
+      };
+    }
+
+    function makeStyleCoord$1(out, zr, zrX, zrY) {
+      out[0] = zrX;
+      out[1] = zrY;
+      out[2] = out[0] / zr.getWidth();
+      out[3] = out[1] / zr.getHeight();
+    }
+
+    var bind$2 = bind;
+    var each$c = each;
+    var parsePercent$3 = parsePercent$1;
+    var proxyRect = new Rect({
+      shape: {
+        x: -1,
+        y: -1,
+        width: 2,
+        height: 2
+      }
+    });
+
+    var TooltipView =
+    /** @class */
+    function (_super) {
+      __extends(TooltipView, _super);
+
+      function TooltipView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TooltipView.type;
+        return _this;
+      }
+
+      TooltipView.prototype.init = function (ecModel, api) {
+        if (env.node) {
+          return;
+        }
+
+        var tooltipModel = ecModel.getComponent('tooltip');
+        var renderMode = tooltipModel.get('renderMode');
+        this._renderMode = getTooltipRenderMode(renderMode);
+        this._tooltipContent = this._renderMode === 'richText' ? new TooltipRichContent(api) : new TooltipHTMLContent(api.getDom(), api, {
+          appendToBody: tooltipModel.get('appendToBody', true)
+        });
+      };
+
+      TooltipView.prototype.render = function (tooltipModel, ecModel, api) {
+        if (env.node) {
+          return;
+        } // Reset
+
+
+        this.group.removeAll();
+        this._tooltipModel = tooltipModel;
+        this._ecModel = ecModel;
+        this._api = api;
+        /**
+         * @private
+         * @type {boolean}
+         */
+
+        this._alwaysShowContent = tooltipModel.get('alwaysShowContent');
+        var tooltipContent = this._tooltipContent;
+        tooltipContent.update(tooltipModel);
+        tooltipContent.setEnterable(tooltipModel.get('enterable'));
+
+        this._initGlobalListener();
+
+        this._keepShow();
+      };
+
+      TooltipView.prototype._initGlobalListener = function () {
+        var tooltipModel = this._tooltipModel;
+        var triggerOn = tooltipModel.get('triggerOn');
+        register('itemTooltip', this._api, bind$2(function (currTrigger, e, dispatchAction) {
+          // If 'none', it is not controlled by mouse totally.
+          if (triggerOn !== 'none') {
+            if (triggerOn.indexOf(currTrigger) >= 0) {
+              this._tryShow(e, dispatchAction);
+            } else if (currTrigger === 'leave') {
+              this._hide(dispatchAction);
+            }
+          }
+        }, this));
+      };
+
+      TooltipView.prototype._keepShow = function () {
+        var tooltipModel = this._tooltipModel;
+        var ecModel = this._ecModel;
+        var api = this._api; // Try to keep the tooltip show when refreshing
+
+        if (this._lastX != null && this._lastY != null // When user is willing to control tooltip totally using API,
+        // self.manuallyShowTip({x, y}) might cause tooltip hide,
+        // which is not expected.
+        && tooltipModel.get('triggerOn') !== 'none') {
+          var self_1 = this;
+          clearTimeout(this._refreshUpdateTimeout);
+          this._refreshUpdateTimeout = setTimeout(function () {
+            // Show tip next tick after other charts are rendered
+            // In case highlight action has wrong result
+            // FIXME
+            !api.isDisposed() && self_1.manuallyShowTip(tooltipModel, ecModel, api, {
+              x: self_1._lastX,
+              y: self_1._lastY,
+              dataByCoordSys: self_1._lastDataByCoordSys
+            });
+          });
+        }
+      };
+      /**
+       * Show tip manually by
+       * dispatchAction({
+       *     type: 'showTip',
+       *     x: 10,
+       *     y: 10
+       * });
+       * Or
+       * dispatchAction({
+       *      type: 'showTip',
+       *      seriesIndex: 0,
+       *      dataIndex or dataIndexInside or name
+       * });
+       *
+       *  TODO Batch
+       */
+
+
+      TooltipView.prototype.manuallyShowTip = function (tooltipModel, ecModel, api, payload) {
+        if (payload.from === this.uid || env.node) {
+          return;
+        }
+
+        var dispatchAction = makeDispatchAction$1(payload, api); // Reset ticket
+
+        this._ticket = ''; // When triggered from axisPointer.
+
+        var dataByCoordSys = payload.dataByCoordSys;
+
+        if (payload.tooltip && payload.x != null && payload.y != null) {
+          var el = proxyRect;
+          el.x = payload.x;
+          el.y = payload.y;
+          el.update();
+          el.tooltip = payload.tooltip; // Manually show tooltip while view is not using zrender elements.
+
+          this._tryShow({
+            offsetX: payload.x,
+            offsetY: payload.y,
+            target: el
+          }, dispatchAction);
+        } else if (dataByCoordSys) {
+          this._tryShow({
+            offsetX: payload.x,
+            offsetY: payload.y,
+            position: payload.position,
+            dataByCoordSys: dataByCoordSys,
+            tooltipOption: payload.tooltipOption
+          }, dispatchAction);
+        } else if (payload.seriesIndex != null) {
+          if (this._manuallyAxisShowTip(tooltipModel, ecModel, api, payload)) {
+            return;
+          }
+
+          var pointInfo = findPointFromSeries(payload, ecModel);
+          var cx = pointInfo.point[0];
+          var cy = pointInfo.point[1];
+
+          if (cx != null && cy != null) {
+            this._tryShow({
+              offsetX: cx,
+              offsetY: cy,
+              position: payload.position,
+              target: pointInfo.el
+            }, dispatchAction);
+          }
+        } else if (payload.x != null && payload.y != null) {
+          // FIXME
+          // should wrap dispatchAction like `axisPointer/globalListener` ?
+          api.dispatchAction({
+            type: 'updateAxisPointer',
+            x: payload.x,
+            y: payload.y
+          });
+
+          this._tryShow({
+            offsetX: payload.x,
+            offsetY: payload.y,
+            position: payload.position,
+            target: api.getZr().findHover(payload.x, payload.y).target
+          }, dispatchAction);
+        }
+      };
+
+      TooltipView.prototype.manuallyHideTip = function (tooltipModel, ecModel, api, payload) {
+        var tooltipContent = this._tooltipContent;
+
+        if (!this._alwaysShowContent && this._tooltipModel) {
+          tooltipContent.hideLater(this._tooltipModel.get('hideDelay'));
+        }
+
+        this._lastX = this._lastY = this._lastDataByCoordSys = null;
+
+        if (payload.from !== this.uid) {
+          this._hide(makeDispatchAction$1(payload, api));
+        }
+      }; // Be compatible with previous design, that is, when tooltip.type is 'axis' and
+      // dispatchAction 'showTip' with seriesIndex and dataIndex will trigger axis pointer
+      // and tooltip.
+
+
+      TooltipView.prototype._manuallyAxisShowTip = function (tooltipModel, ecModel, api, payload) {
+        var seriesIndex = payload.seriesIndex;
+        var dataIndex = payload.dataIndex; // @ts-ignore
+
+        var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo;
+
+        if (seriesIndex == null || dataIndex == null || coordSysAxesInfo == null) {
+          return;
+        }
+
+        var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
+
+        if (!seriesModel) {
+          return;
+        }
+
+        var data = seriesModel.getData();
+        var tooltipCascadedModel = buildTooltipModel([data.getItemModel(dataIndex), seriesModel, (seriesModel.coordinateSystem || {}).model, tooltipModel]);
+
+        if (tooltipCascadedModel.get('trigger') !== 'axis') {
+          return;
+        }
+
+        api.dispatchAction({
+          type: 'updateAxisPointer',
+          seriesIndex: seriesIndex,
+          dataIndex: dataIndex,
+          position: payload.position
+        });
+        return true;
+      };
+
+      TooltipView.prototype._tryShow = function (e, dispatchAction) {
+        var el = e.target;
+        var tooltipModel = this._tooltipModel;
+
+        if (!tooltipModel) {
+          return;
+        } // Save mouse x, mouse y. So we can try to keep showing the tip if chart is refreshed
+
+
+        this._lastX = e.offsetX;
+        this._lastY = e.offsetY;
+        var dataByCoordSys = e.dataByCoordSys;
+
+        if (dataByCoordSys && dataByCoordSys.length) {
+          this._showAxisTooltip(dataByCoordSys, e);
+        } // Always show item tooltip if mouse is on the element with dataIndex
+        else if (el && findEventDispatcher(el, function (target) {
+            return getECData(target).dataIndex != null;
+          }, true)) {
+            this._lastDataByCoordSys = null;
+
+            this._showSeriesItemTooltip(e, el, dispatchAction);
+          } // Tooltip provided directly. Like legend.
+          else if (el && el.tooltip) {
+              this._lastDataByCoordSys = null;
+
+              this._showComponentItemTooltip(e, el, dispatchAction);
+            } else {
+              this._lastDataByCoordSys = null;
+
+              this._hide(dispatchAction);
+            }
+      };
+
+      TooltipView.prototype._showOrMove = function (tooltipModel, cb) {
+        // showDelay is used in this case: tooltip.enterable is set
+        // as true. User intent to move mouse into tooltip and click
+        // something. `showDelay` makes it easier to enter the content
+        // but tooltip do not move immediately.
+        var delay = tooltipModel.get('showDelay');
+        cb = bind(cb, this);
+        clearTimeout(this._showTimout);
+        delay > 0 ? this._showTimout = setTimeout(cb, delay) : cb();
+      };
+
+      TooltipView.prototype._showAxisTooltip = function (dataByCoordSys, e) {
+        var ecModel = this._ecModel;
+        var globalTooltipModel = this._tooltipModel;
+        var point = [e.offsetX, e.offsetY];
+        var singleTooltipModel = buildTooltipModel([e.tooltipOption, globalTooltipModel]);
+        var renderMode = this._renderMode;
+        var cbParamsList = [];
+        var articleMarkup = createTooltipMarkup('section', {
+          blocks: [],
+          noHeader: true
+        }); // Only for legacy: `Serise['formatTooltip']` returns a string.
+
+        var markupTextArrLegacy = [];
+        var markupStyleCreator = new TooltipMarkupStyleCreator();
+        each$c(dataByCoordSys, function (itemCoordSys) {
+          each$c(itemCoordSys.dataByAxis, function (axisItem) {
+            var axisModel = ecModel.getComponent(axisItem.axisDim + 'Axis', axisItem.axisIndex);
+            var axisValue = axisItem.value;
+
+            if (!axisModel || axisValue == null) {
+              return;
+            }
+
+            var axisValueLabel = getValueLabel(axisValue, axisModel.axis, ecModel, axisItem.seriesDataIndices, axisItem.valueLabelOpt);
+            var axisSectionMarkup = createTooltipMarkup('section', {
+              header: axisValueLabel,
+              noHeader: !trim(axisValueLabel),
+              sortBlocks: true,
+              blocks: []
+            });
+            articleMarkup.blocks.push(axisSectionMarkup);
+            each(axisItem.seriesDataIndices, function (idxItem) {
+              var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+              var dataIndex = idxItem.dataIndexInside;
+              var cbParams = series.getDataParams(dataIndex);
+              cbParams.axisDim = axisItem.axisDim;
+              cbParams.axisIndex = axisItem.axisIndex;
+              cbParams.axisType = axisItem.axisType;
+              cbParams.axisId = axisItem.axisId;
+              cbParams.axisValue = getAxisRawValue(axisModel.axis, {
+                value: axisValue
+              });
+              cbParams.axisValueLabel = axisValueLabel; // Pre-create marker style for makers. Users can assemble richText
+              // text in `formatter` callback and use those markers style.
+
+              cbParams.marker = markupStyleCreator.makeTooltipMarker('item', convertToColorString(cbParams.color), renderMode);
+              var seriesTooltipResult = normalizeTooltipFormatResult(series.formatTooltip(dataIndex, true, null));
+
+              if (seriesTooltipResult.markupFragment) {
+                axisSectionMarkup.blocks.push(seriesTooltipResult.markupFragment);
+              }
+
+              if (seriesTooltipResult.markupText) {
+                markupTextArrLegacy.push(seriesTooltipResult.markupText);
+              }
+
+              cbParamsList.push(cbParams);
+            });
+          });
+        }); // In most cases, the second axis is displays upper on the first one.
+        // So we reverse it to look better.
+
+        articleMarkup.blocks.reverse();
+        markupTextArrLegacy.reverse();
+        var positionExpr = e.position;
+        var orderMode = singleTooltipModel.get('order');
+        var builtMarkupText = buildTooltipMarkup(articleMarkup, markupStyleCreator, renderMode, orderMode, ecModel.get('useUTC'), singleTooltipModel.get('textStyle'));
+        builtMarkupText && markupTextArrLegacy.unshift(builtMarkupText);
+        var blockBreak = renderMode === 'richText' ? '\n\n' : '<br/>';
+        var allMarkupText = markupTextArrLegacy.join(blockBreak);
+
+        this._showOrMove(singleTooltipModel, function () {
+          if (this._updateContentNotChangedOnAxis(dataByCoordSys)) {
+            this._updatePosition(singleTooltipModel, positionExpr, point[0], point[1], this._tooltipContent, cbParamsList);
+          } else {
+            this._showTooltipContent(singleTooltipModel, allMarkupText, cbParamsList, Math.random() + '', point[0], point[1], positionExpr, null, markupStyleCreator);
+          }
+        }); // Do not trigger events here, because this branch only be entered
+        // from dispatchAction.
+
+      };
+
+      TooltipView.prototype._showSeriesItemTooltip = function (e, el, dispatchAction) {
+        var dispatcher = findEventDispatcher(el, function (target) {
+          return getECData(target).dataIndex != null;
+        }, true);
+        var ecModel = this._ecModel;
+        var ecData = getECData(dispatcher); // Use dataModel in element if possible
+        // Used when mouseover on a element like markPoint or edge
+        // In which case, the data is not main data in series.
+
+        var seriesIndex = ecData.seriesIndex;
+        var seriesModel = ecModel.getSeriesByIndex(seriesIndex); // For example, graph link.
+
+        var dataModel = ecData.dataModel || seriesModel;
+        var dataIndex = ecData.dataIndex;
+        var dataType = ecData.dataType;
+        var data = dataModel.getData(dataType);
+        var renderMode = this._renderMode;
+        var tooltipModel = buildTooltipModel([data.getItemModel(dataIndex), dataModel, seriesModel && (seriesModel.coordinateSystem || {}).model, this._tooltipModel]);
+        var tooltipTrigger = tooltipModel.get('trigger');
+
+        if (tooltipTrigger != null && tooltipTrigger !== 'item') {
+          return;
+        }
+
+        var params = dataModel.getDataParams(dataIndex, dataType);
+        var markupStyleCreator = new TooltipMarkupStyleCreator(); // Pre-create marker style for makers. Users can assemble richText
+        // text in `formatter` callback and use those markers style.
+
+        params.marker = markupStyleCreator.makeTooltipMarker('item', convertToColorString(params.color), renderMode);
+        var seriesTooltipResult = normalizeTooltipFormatResult(dataModel.formatTooltip(dataIndex, false, dataType));
+        var orderMode = tooltipModel.get('order');
+        var markupText = seriesTooltipResult.markupFragment ? buildTooltipMarkup(seriesTooltipResult.markupFragment, markupStyleCreator, renderMode, orderMode, ecModel.get('useUTC'), tooltipModel.get('textStyle')) : seriesTooltipResult.markupText;
+        var asyncTicket = 'item_' + dataModel.name + '_' + dataIndex;
+
+        this._showOrMove(tooltipModel, function () {
+          this._showTooltipContent(tooltipModel, markupText, params, asyncTicket, e.offsetX, e.offsetY, e.position, e.target, markupStyleCreator);
+        }); // FIXME
+        // duplicated showtip if manuallyShowTip is called from dispatchAction.
+
+
+        dispatchAction({
+          type: 'showTip',
+          dataIndexInside: dataIndex,
+          dataIndex: data.getRawIndex(dataIndex),
+          seriesIndex: seriesIndex,
+          from: this.uid
+        });
+      };
+
+      TooltipView.prototype._showComponentItemTooltip = function (e, el, dispatchAction) {
+        var tooltipOpt = el.tooltip;
+
+        if (isString(tooltipOpt)) {
+          var content = tooltipOpt;
+          tooltipOpt = {
+            content: content,
+            // Fixed formatter
+            formatter: content
+          };
+        }
+
+        var subTooltipModel = new Model(tooltipOpt, this._tooltipModel, this._ecModel);
+        var defaultHtml = subTooltipModel.get('content');
+        var asyncTicket = Math.random() + ''; // PENDING: this case do not support richText style yet.
+
+        var markupStyleCreator = new TooltipMarkupStyleCreator(); // Do not check whether `trigger` is 'none' here, because `trigger`
+        // only works on coordinate system. In fact, we have not found case
+        // that requires setting `trigger` nothing on component yet.
+
+        this._showOrMove(subTooltipModel, function () {
+          this._showTooltipContent( // Use formatterParams from element defined in component
+          subTooltipModel, defaultHtml, subTooltipModel.get('formatterParams') || {}, asyncTicket, e.offsetX, e.offsetY, e.position, el, markupStyleCreator);
+        }); // If not dispatch showTip, tip may be hide triggered by axis.
+
+
+        dispatchAction({
+          type: 'showTip',
+          from: this.uid
+        });
+      };
+
+      TooltipView.prototype._showTooltipContent = function ( // Use Model<TooltipOption> insteadof TooltipModel because this model may be from series or other options.
+      // Instead of top level tooltip.
+      tooltipModel, defaultHtml, params, asyncTicket, x, y, positionExpr, el, markupStyleCreator) {
+        // Reset ticket
+        this._ticket = '';
+
+        if (!tooltipModel.get('showContent') || !tooltipModel.get('show')) {
+          return;
+        }
+
+        var tooltipContent = this._tooltipContent;
+        var formatter = tooltipModel.get('formatter');
+        positionExpr = positionExpr || tooltipModel.get('position');
+        var html = defaultHtml;
+
+        var nearPoint = this._getNearestPoint([x, y], params, tooltipModel.get('trigger'), tooltipModel.get('borderColor'));
+
+        if (formatter && isString(formatter)) {
+          var useUTC = tooltipModel.ecModel.get('useUTC');
+          var params0 = isArray(params) ? params[0] : params;
+          var isTimeAxis = params0 && params0.axisType && params0.axisType.indexOf('time') >= 0;
+          html = formatter;
+
+          if (isTimeAxis) {
+            html = format(params0.axisValue, html, useUTC);
+          }
+
+          html = formatTpl(html, params, true);
+        } else if (isFunction(formatter)) {
+          var callback = bind$2(function (cbTicket, html) {
+            if (cbTicket === this._ticket) {
+              tooltipContent.setContent(html, markupStyleCreator, tooltipModel, nearPoint.color, positionExpr);
+
+              this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el);
+            }
+          }, this);
+          this._ticket = asyncTicket;
+          html = formatter(params, asyncTicket, callback);
+        }
+
+        tooltipContent.setContent(html, markupStyleCreator, tooltipModel, nearPoint.color, positionExpr);
+        tooltipContent.show(tooltipModel, nearPoint.color);
+
+        this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el);
+      };
+
+      TooltipView.prototype._getNearestPoint = function (point, tooltipDataParams, trigger, borderColor) {
+        if (trigger === 'axis' || isArray(tooltipDataParams)) {
+          return {
+            color: borderColor || (this._renderMode === 'html' ? '#fff' : 'none')
+          };
+        }
+
+        if (!isArray(tooltipDataParams)) {
+          return {
+            color: borderColor || tooltipDataParams.color || tooltipDataParams.borderColor
+          };
+        }
+      };
+
+      TooltipView.prototype._updatePosition = function (tooltipModel, positionExpr, x, // Mouse x
+      y, // Mouse y
+      content, params, el) {
+        var viewWidth = this._api.getWidth();
+
+        var viewHeight = this._api.getHeight();
+
+        positionExpr = positionExpr || tooltipModel.get('position');
+        var contentSize = content.getSize();
+        var align = tooltipModel.get('align');
+        var vAlign = tooltipModel.get('verticalAlign');
+        var rect = el && el.getBoundingRect().clone();
+        el && rect.applyTransform(el.transform);
+
+        if (isFunction(positionExpr)) {
+          // Callback of position can be an array or a string specify the position
+          positionExpr = positionExpr([x, y], params, content.el, rect, {
+            viewSize: [viewWidth, viewHeight],
+            contentSize: contentSize.slice()
+          });
+        }
+
+        if (isArray(positionExpr)) {
+          x = parsePercent$3(positionExpr[0], viewWidth);
+          y = parsePercent$3(positionExpr[1], viewHeight);
+        } else if (isObject(positionExpr)) {
+          var boxLayoutPosition = positionExpr;
+          boxLayoutPosition.width = contentSize[0];
+          boxLayoutPosition.height = contentSize[1];
+          var layoutRect = getLayoutRect(boxLayoutPosition, {
+            width: viewWidth,
+            height: viewHeight
+          });
+          x = layoutRect.x;
+          y = layoutRect.y;
+          align = null; // When positionExpr is left/top/right/bottom,
+          // align and verticalAlign will not work.
+
+          vAlign = null;
+        } // Specify tooltip position by string 'top' 'bottom' 'left' 'right' around graphic element
+        else if (isString(positionExpr) && el) {
+            var pos = calcTooltipPosition(positionExpr, rect, contentSize);
+            x = pos[0];
+            y = pos[1];
+          } else {
+            var pos = refixTooltipPosition(x, y, content, viewWidth, viewHeight, align ? null : 20, vAlign ? null : 20);
+            x = pos[0];
+            y = pos[1];
+          }
+
+        align && (x -= isCenterAlign(align) ? contentSize[0] / 2 : align === 'right' ? contentSize[0] : 0);
+        vAlign && (y -= isCenterAlign(vAlign) ? contentSize[1] / 2 : vAlign === 'bottom' ? contentSize[1] : 0);
+
+        if (shouldTooltipConfine(tooltipModel)) {
+          var pos = confineTooltipPosition(x, y, content, viewWidth, viewHeight);
+          x = pos[0];
+          y = pos[1];
+        }
+
+        content.moveTo(x, y);
+      }; // FIXME
+      // Should we remove this but leave this to user?
+
+
+      TooltipView.prototype._updateContentNotChangedOnAxis = function (dataByCoordSys) {
+        var lastCoordSys = this._lastDataByCoordSys;
+        var contentNotChanged = !!lastCoordSys && lastCoordSys.length === dataByCoordSys.length;
+        contentNotChanged && each$c(lastCoordSys, function (lastItemCoordSys, indexCoordSys) {
+          var lastDataByAxis = lastItemCoordSys.dataByAxis || [];
+          var thisItemCoordSys = dataByCoordSys[indexCoordSys] || {};
+          var thisDataByAxis = thisItemCoordSys.dataByAxis || [];
+          contentNotChanged = contentNotChanged && lastDataByAxis.length === thisDataByAxis.length;
+          contentNotChanged && each$c(lastDataByAxis, function (lastItem, indexAxis) {
+            var thisItem = thisDataByAxis[indexAxis] || {};
+            var lastIndices = lastItem.seriesDataIndices || [];
+            var newIndices = thisItem.seriesDataIndices || [];
+            contentNotChanged = contentNotChanged && lastItem.value === thisItem.value && lastItem.axisType === thisItem.axisType && lastItem.axisId === thisItem.axisId && lastIndices.length === newIndices.length;
+            contentNotChanged && each$c(lastIndices, function (lastIdxItem, j) {
+              var newIdxItem = newIndices[j];
+              contentNotChanged = contentNotChanged && lastIdxItem.seriesIndex === newIdxItem.seriesIndex && lastIdxItem.dataIndex === newIdxItem.dataIndex;
+            });
+          });
+        });
+        this._lastDataByCoordSys = dataByCoordSys;
+        return !!contentNotChanged;
+      };
+
+      TooltipView.prototype._hide = function (dispatchAction) {
+        // Do not directly hideLater here, because this behavior may be prevented
+        // in dispatchAction when showTip is dispatched.
+        // FIXME
+        // duplicated hideTip if manuallyHideTip is called from dispatchAction.
+        this._lastDataByCoordSys = null;
+        dispatchAction({
+          type: 'hideTip',
+          from: this.uid
+        });
+      };
+
+      TooltipView.prototype.dispose = function (ecModel, api) {
+        if (env.node) {
+          return;
+        }
+
+        this._tooltipContent.dispose();
+
+        unregister('itemTooltip', api);
+      };
+
+      TooltipView.type = 'tooltip';
+      return TooltipView;
+    }(ComponentView);
+    /**
+     * From top to bottom. (the last one should be globalTooltipModel);
+     */
+
+
+    function buildTooltipModel(modelCascade) {
+      // Last is always tooltip model.
+      var resultModel = modelCascade.pop();
+
+      while (modelCascade.length) {
+        var tooltipOpt = modelCascade.pop();
+
+        if (tooltipOpt) {
+          if (tooltipOpt instanceof Model) {
+            tooltipOpt = tooltipOpt.get('tooltip', true);
+          } // In each data item tooltip can be simply write:
+          // {
+          //  value: 10,
+          //  tooltip: 'Something you need to know'
+          // }
+
+
+          if (isString(tooltipOpt)) {
+            tooltipOpt = {
+              formatter: tooltipOpt
+            };
+          }
+
+          resultModel = new Model(tooltipOpt, resultModel, resultModel.ecModel);
+        }
+      }
+
+      return resultModel;
+    }
+
+    function makeDispatchAction$1(payload, api) {
+      return payload.dispatchAction || bind(api.dispatchAction, api);
+    }
+
+    function refixTooltipPosition(x, y, content, viewWidth, viewHeight, gapH, gapV) {
+      var size = content.getOuterSize();
+      var width = size.width;
+      var height = size.height;
+
+      if (gapH != null) {
+        // Add extra 2 pixels for this case:
+        // At present the "values" in defaut tooltip are using CSS `float: right`.
+        // When the right edge of the tooltip box is on the right side of the
+        // viewport, the `float` layout might push the "values" to the second line.
+        if (x + width + gapH + 2 > viewWidth) {
+          x -= width + gapH;
+        } else {
+          x += gapH;
+        }
+      }
+
+      if (gapV != null) {
+        if (y + height + gapV > viewHeight) {
+          y -= height + gapV;
+        } else {
+          y += gapV;
+        }
+      }
+
+      return [x, y];
+    }
+
+    function confineTooltipPosition(x, y, content, viewWidth, viewHeight) {
+      var size = content.getOuterSize();
+      var width = size.width;
+      var height = size.height;
+      x = Math.min(x + width, viewWidth) - width;
+      y = Math.min(y + height, viewHeight) - height;
+      x = Math.max(x, 0);
+      y = Math.max(y, 0);
+      return [x, y];
+    }
+
+    function calcTooltipPosition(position, rect, contentSize) {
+      var domWidth = contentSize[0];
+      var domHeight = contentSize[1];
+      var gap = 10;
+      var offset = 5;
+      var x = 0;
+      var y = 0;
+      var rectWidth = rect.width;
+      var rectHeight = rect.height;
+
+      switch (position) {
+        case 'inside':
+          x = rect.x + rectWidth / 2 - domWidth / 2;
+          y = rect.y + rectHeight / 2 - domHeight / 2;
+          break;
+
+        case 'top':
+          x = rect.x + rectWidth / 2 - domWidth / 2;
+          y = rect.y - domHeight - gap;
+          break;
+
+        case 'bottom':
+          x = rect.x + rectWidth / 2 - domWidth / 2;
+          y = rect.y + rectHeight + gap;
+          break;
+
+        case 'left':
+          x = rect.x - domWidth - gap - offset;
+          y = rect.y + rectHeight / 2 - domHeight / 2;
+          break;
+
+        case 'right':
+          x = rect.x + rectWidth + gap + offset;
+          y = rect.y + rectHeight / 2 - domHeight / 2;
+      }
+
+      return [x, y];
+    }
+
+    function isCenterAlign(align) {
+      return align === 'center' || align === 'middle';
+    }
+
+    function install$A(registers) {
+      use(install$s);
+      registers.registerComponentModel(TooltipModel);
+      registers.registerComponentView(TooltipView);
+      /**
+       * @action
+       * @property {string} type
+       * @property {number} seriesIndex
+       * @property {number} dataIndex
+       * @property {number} [x]
+       * @property {number} [y]
+       */
+
+      registers.registerAction({
+        type: 'showTip',
+        event: 'showTip',
+        update: 'tooltip:manuallyShowTip'
+      }, // noop
+      function () {});
+      registers.registerAction({
+        type: 'hideTip',
+        event: 'hideTip',
+        update: 'tooltip:manuallyHideTip'
+      }, // noop
+      function () {});
+    }
+
+    var DEFAULT_TOOLBOX_BTNS = ['rect', 'polygon', 'keep', 'clear'];
+    function brushPreprocessor(option, isNew) {
+      var brushComponents = normalizeToArray(option ? option.brush : []);
+
+      if (!brushComponents.length) {
+        return;
+      }
+
+      var brushComponentSpecifiedBtns = [];
+      each(brushComponents, function (brushOpt) {
+        var tbs = brushOpt.hasOwnProperty('toolbox') ? brushOpt.toolbox : [];
+
+        if (tbs instanceof Array) {
+          brushComponentSpecifiedBtns = brushComponentSpecifiedBtns.concat(tbs);
+        }
+      });
+      var toolbox = option && option.toolbox;
+
+      if (isArray(toolbox)) {
+        toolbox = toolbox[0];
+      }
+
+      if (!toolbox) {
+        toolbox = {
+          feature: {}
+        };
+        option.toolbox = [toolbox];
+      }
+
+      var toolboxFeature = toolbox.feature || (toolbox.feature = {});
+      var toolboxBrush = toolboxFeature.brush || (toolboxFeature.brush = {});
+      var brushTypes = toolboxBrush.type || (toolboxBrush.type = []);
+      brushTypes.push.apply(brushTypes, brushComponentSpecifiedBtns);
+      removeDuplicate(brushTypes);
+
+      if (isNew && !brushTypes.length) {
+        brushTypes.push.apply(brushTypes, DEFAULT_TOOLBOX_BTNS);
+      }
+    }
+
+    function removeDuplicate(arr) {
+      var map = {};
+      each(arr, function (val) {
+        map[val] = 1;
+      });
+      arr.length = 0;
+      each(map, function (flag, val) {
+        arr.push(val);
+      });
+    }
+
+    var each$d = each;
+
+    function hasKeys(obj) {
+      if (obj) {
+        for (var name_1 in obj) {
+          if (obj.hasOwnProperty(name_1)) {
+            return true;
+          }
+        }
+      }
+    }
+
+    function createVisualMappings(option, stateList, supplementVisualOption) {
+      var visualMappings = {};
+      each$d(stateList, function (state) {
+        var mappings = visualMappings[state] = createMappings();
+        each$d(option[state], function (visualData, visualType) {
+          if (!VisualMapping.isValidType(visualType)) {
+            return;
+          }
+
+          var mappingOption = {
+            type: visualType,
+            visual: visualData
+          };
+          supplementVisualOption && supplementVisualOption(mappingOption, state);
+          mappings[visualType] = new VisualMapping(mappingOption); // Prepare a alpha for opacity, for some case that opacity
+          // is not supported, such as rendering using gradient color.
+
+          if (visualType === 'opacity') {
+            mappingOption = clone(mappingOption);
+            mappingOption.type = 'colorAlpha';
+            mappings.__hidden.__alphaForOpacity = new VisualMapping(mappingOption);
+          }
+        });
+      });
+      return visualMappings;
+
+      function createMappings() {
+        var Creater = function () {}; // Make sure hidden fields will not be visited by
+        // object iteration (with hasOwnProperty checking).
+
+
+        Creater.prototype.__hidden = Creater.prototype;
+        var obj = new Creater();
+        return obj;
+      }
+    }
+    function replaceVisualOption(thisOption, newOption, keys) {
+      // Visual attributes merge is not supported, otherwise it
+      // brings overcomplicated merge logic. See #2853. So if
+      // newOption has anyone of these keys, all of these keys
+      // will be reset. Otherwise, all keys remain.
+      var has;
+      each(keys, function (key) {
+        if (newOption.hasOwnProperty(key) && hasKeys(newOption[key])) {
+          has = true;
+        }
+      });
+      has && each(keys, function (key) {
+        if (newOption.hasOwnProperty(key) && hasKeys(newOption[key])) {
+          thisOption[key] = clone(newOption[key]);
+        } else {
+          delete thisOption[key];
+        }
+      });
+    }
+    /**
+     * @param stateList
+     * @param visualMappings
+     * @param list
+     * @param getValueState param: valueOrIndex, return: state.
+     * @param scope Scope for getValueState
+     * @param dimension Concrete dimension, if used.
+     */
+    // ???! handle brush?
+
+    function applyVisual(stateList, visualMappings, data, getValueState, scope, dimension) {
+      var visualTypesMap = {};
+      each(stateList, function (state) {
+        var visualTypes = VisualMapping.prepareVisualTypes(visualMappings[state]);
+        visualTypesMap[state] = visualTypes;
+      });
+      var dataIndex;
+
+      function getVisual(key) {
+        return getItemVisualFromData(data, dataIndex, key);
+      }
+
+      function setVisual(key, value) {
+        setItemVisualFromData(data, dataIndex, key, value);
+      }
+
+      if (dimension == null) {
+        data.each(eachItem);
+      } else {
+        data.each([dimension], eachItem);
+      }
+
+      function eachItem(valueOrIndex, index) {
+        dataIndex = dimension == null ? valueOrIndex // First argument is index
+        : index;
+        var rawDataItem = data.getRawDataItem(dataIndex); // Consider performance
+        // @ts-ignore
+
+        if (rawDataItem && rawDataItem.visualMap === false) {
+          return;
+        }
+
+        var valueState = getValueState.call(scope, valueOrIndex);
+        var mappings = visualMappings[valueState];
+        var visualTypes = visualTypesMap[valueState];
+
+        for (var i = 0, len = visualTypes.length; i < len; i++) {
+          var type = visualTypes[i];
+          mappings[type] && mappings[type].applyVisual(valueOrIndex, getVisual, setVisual);
+        }
+      }
+    }
+    /**
+     * @param data
+     * @param stateList
+     * @param visualMappings <state, Object.<visualType, module:echarts/visual/VisualMapping>>
+     * @param getValueState param: valueOrIndex, return: state.
+     * @param dim dimension or dimension index.
+     */
+
+    function incrementalApplyVisual(stateList, visualMappings, getValueState, dim) {
+      var visualTypesMap = {};
+      each(stateList, function (state) {
+        var visualTypes = VisualMapping.prepareVisualTypes(visualMappings[state]);
+        visualTypesMap[state] = visualTypes;
+      });
+      return {
+        progress: function progress(params, data) {
+          var dimName;
+
+          if (dim != null) {
+            dimName = data.getDimension(dim);
+          }
+
+          function getVisual(key) {
+            return getItemVisualFromData(data, dataIndex, key);
+          }
+
+          function setVisual(key, value) {
+            setItemVisualFromData(data, dataIndex, key, value);
+          }
+
+          var dataIndex;
+
+          while ((dataIndex = params.next()) != null) {
+            var rawDataItem = data.getRawDataItem(dataIndex); // Consider performance
+            // @ts-ignore
+
+            if (rawDataItem && rawDataItem.visualMap === false) {
+              continue;
+            }
+
+            var value = dim != null ? data.get(dimName, dataIndex) : dataIndex;
+            var valueState = getValueState(value);
+            var mappings = visualMappings[valueState];
+            var visualTypes = visualTypesMap[valueState];
+
+            for (var i = 0, len = visualTypes.length; i < len; i++) {
+              var type = visualTypes[i];
+              mappings[type] && mappings[type].applyVisual(value, getVisual, setVisual);
+            }
+          }
+        }
+      };
+    }
+
+    function makeBrushCommonSelectorForSeries(area) {
+      var brushType = area.brushType; // Do not use function binding or curry for performance.
+
+      var selectors = {
+        point: function (itemLayout) {
+          return selector[brushType].point(itemLayout, selectors, area);
+        },
+        rect: function (itemLayout) {
+          return selector[brushType].rect(itemLayout, selectors, area);
+        }
+      };
+      return selectors;
+    }
+    var selector = {
+      lineX: getLineSelectors(0),
+      lineY: getLineSelectors(1),
+      rect: {
+        point: function (itemLayout, selectors, area) {
+          return itemLayout && area.boundingRect.contain(itemLayout[0], itemLayout[1]);
+        },
+        rect: function (itemLayout, selectors, area) {
+          return itemLayout && area.boundingRect.intersect(itemLayout);
+        }
+      },
+      polygon: {
+        point: function (itemLayout, selectors, area) {
+          return itemLayout && area.boundingRect.contain(itemLayout[0], itemLayout[1]) && contain$2(area.range, itemLayout[0], itemLayout[1]);
+        },
+        rect: function (itemLayout, selectors, area) {
+          var points = area.range;
+
+          if (!itemLayout || points.length <= 1) {
+            return false;
+          }
+
+          var x = itemLayout.x;
+          var y = itemLayout.y;
+          var width = itemLayout.width;
+          var height = itemLayout.height;
+          var p = points[0];
+
+          if (contain$2(points, x, y) || contain$2(points, x + width, y) || contain$2(points, x, y + height) || contain$2(points, x + width, y + height) || BoundingRect.create(itemLayout).contain(p[0], p[1]) || linePolygonIntersect(x, y, x + width, y, points) || linePolygonIntersect(x, y, x, y + height, points) || linePolygonIntersect(x + width, y, x + width, y + height, points) || linePolygonIntersect(x, y + height, x + width, y + height, points)) {
+            return true;
+          }
+        }
+      }
+    };
+
+    function getLineSelectors(xyIndex) {
+      var xy = ['x', 'y'];
+      var wh = ['width', 'height'];
+      return {
+        point: function (itemLayout, selectors, area) {
+          if (itemLayout) {
+            var range = area.range;
+            var p = itemLayout[xyIndex];
+            return inLineRange(p, range);
+          }
+        },
+        rect: function (itemLayout, selectors, area) {
+          if (itemLayout) {
+            var range = area.range;
+            var layoutRange = [itemLayout[xy[xyIndex]], itemLayout[xy[xyIndex]] + itemLayout[wh[xyIndex]]];
+            layoutRange[1] < layoutRange[0] && layoutRange.reverse();
+            return inLineRange(layoutRange[0], range) || inLineRange(layoutRange[1], range) || inLineRange(range[0], layoutRange) || inLineRange(range[1], layoutRange);
+          }
+        }
+      };
+    }
+
+    function inLineRange(p, range) {
+      return range[0] <= p && p <= range[1];
+    }
+
+    var STATE_LIST = ['inBrush', 'outOfBrush'];
+    var DISPATCH_METHOD = '__ecBrushSelect';
+    var DISPATCH_FLAG = '__ecInBrushSelectEvent';
+    function layoutCovers(ecModel) {
+      ecModel.eachComponent({
+        mainType: 'brush'
+      }, function (brushModel) {
+        var brushTargetManager = brushModel.brushTargetManager = new BrushTargetManager(brushModel.option, ecModel);
+        brushTargetManager.setInputRanges(brushModel.areas, ecModel);
+      });
+    }
+    /**
+     * Register the visual encoding if this modules required.
+     */
+
+    function brushVisual(ecModel, api, payload) {
+      var brushSelected = [];
+      var throttleType;
+      var throttleDelay;
+      ecModel.eachComponent({
+        mainType: 'brush'
+      }, function (brushModel) {
+        payload && payload.type === 'takeGlobalCursor' && brushModel.setBrushOption(payload.key === 'brush' ? payload.brushOption : {
+          brushType: false
+        });
+      });
+      layoutCovers(ecModel);
+      ecModel.eachComponent({
+        mainType: 'brush'
+      }, function (brushModel, brushIndex) {
+        var thisBrushSelected = {
+          brushId: brushModel.id,
+          brushIndex: brushIndex,
+          brushName: brushModel.name,
+          areas: clone(brushModel.areas),
+          selected: []
+        }; // Every brush component exists in event params, convenient
+        // for user to find by index.
+
+        brushSelected.push(thisBrushSelected);
+        var brushOption = brushModel.option;
+        var brushLink = brushOption.brushLink;
+        var linkedSeriesMap = [];
+        var selectedDataIndexForLink = [];
+        var rangeInfoBySeries = [];
+        var hasBrushExists = false;
+
+        if (!brushIndex) {
+          // Only the first throttle setting works.
+          throttleType = brushOption.throttleType;
+          throttleDelay = brushOption.throttleDelay;
+        } // Add boundingRect and selectors to range.
+
+
+        var areas = map(brushModel.areas, function (area) {
+          var builder = boundingRectBuilders[area.brushType];
+          var selectableArea = defaults({
+            boundingRect: builder ? builder(area) : void 0
+          }, area);
+          selectableArea.selectors = makeBrushCommonSelectorForSeries(selectableArea);
+          return selectableArea;
+        });
+        var visualMappings = createVisualMappings(brushModel.option, STATE_LIST, function (mappingOption) {
+          mappingOption.mappingMethod = 'fixed';
+        });
+        isArray(brushLink) && each(brushLink, function (seriesIndex) {
+          linkedSeriesMap[seriesIndex] = 1;
+        });
+
+        function linkOthers(seriesIndex) {
+          return brushLink === 'all' || !!linkedSeriesMap[seriesIndex];
+        } // If no supported brush or no brush on the series,
+        // all visuals should be in original state.
+
+
+        function brushed(rangeInfoList) {
+          return !!rangeInfoList.length;
+        }
+        /**
+         * Logic for each series: (If the logic has to be modified one day, do it carefully!)
+         *
+         * ( brushed ┬ && ┬hasBrushExist ┬ && linkOthers  ) => StepA: ┬record, ┬ StepB: ┬visualByRecord.
+         *   !brushed┘    ├hasBrushExist ┤                            └nothing,┘        ├visualByRecord.
+         *                └!hasBrushExist┘                                              └nothing.
+         * ( !brushed  && ┬hasBrushExist ┬ && linkOthers  ) => StepA:  nothing,  StepB: ┬visualByRecord.
+         *                └!hasBrushExist┘                                              └nothing.
+         * ( brushed ┬ &&                     !linkOthers ) => StepA:  nothing,  StepB: ┬visualByCheck.
+         *   !brushed┘                                                                  └nothing.
+         * ( !brushed  &&                     !linkOthers ) => StepA:  nothing,  StepB:  nothing.
+         */
+        // Step A
+
+
+        ecModel.eachSeries(function (seriesModel, seriesIndex) {
+          var rangeInfoList = rangeInfoBySeries[seriesIndex] = [];
+          seriesModel.subType === 'parallel' ? stepAParallel(seriesModel, seriesIndex) : stepAOthers(seriesModel, seriesIndex, rangeInfoList);
+        });
+
+        function stepAParallel(seriesModel, seriesIndex) {
+          var coordSys = seriesModel.coordinateSystem;
+          hasBrushExists = hasBrushExists || coordSys.hasAxisBrushed();
+          linkOthers(seriesIndex) && coordSys.eachActiveState(seriesModel.getData(), function (activeState, dataIndex) {
+            activeState === 'active' && (selectedDataIndexForLink[dataIndex] = 1);
+          });
+        }
+
+        function stepAOthers(seriesModel, seriesIndex, rangeInfoList) {
+          if (!seriesModel.brushSelector || brushModelNotControll(brushModel, seriesIndex)) {
+            return;
+          }
+
+          each(areas, function (area) {
+            if (brushModel.brushTargetManager.controlSeries(area, seriesModel, ecModel)) {
+              rangeInfoList.push(area);
+            }
+
+            hasBrushExists = hasBrushExists || brushed(rangeInfoList);
+          });
+
+          if (linkOthers(seriesIndex) && brushed(rangeInfoList)) {
+            var data_1 = seriesModel.getData();
+            data_1.each(function (dataIndex) {
+              if (checkInRange(seriesModel, rangeInfoList, data_1, dataIndex)) {
+                selectedDataIndexForLink[dataIndex] = 1;
+              }
+            });
+          }
+        } // Step B
+
+
+        ecModel.eachSeries(function (seriesModel, seriesIndex) {
+          var seriesBrushSelected = {
+            seriesId: seriesModel.id,
+            seriesIndex: seriesIndex,
+            seriesName: seriesModel.name,
+            dataIndex: []
+          }; // Every series exists in event params, convenient
+          // for user to find series by seriesIndex.
+
+          thisBrushSelected.selected.push(seriesBrushSelected);
+          var rangeInfoList = rangeInfoBySeries[seriesIndex];
+          var data = seriesModel.getData();
+          var getValueState = linkOthers(seriesIndex) ? function (dataIndex) {
+            return selectedDataIndexForLink[dataIndex] ? (seriesBrushSelected.dataIndex.push(data.getRawIndex(dataIndex)), 'inBrush') : 'outOfBrush';
+          } : function (dataIndex) {
+            return checkInRange(seriesModel, rangeInfoList, data, dataIndex) ? (seriesBrushSelected.dataIndex.push(data.getRawIndex(dataIndex)), 'inBrush') : 'outOfBrush';
+          }; // If no supported brush or no brush, all visuals are in original state.
+
+          (linkOthers(seriesIndex) ? hasBrushExists : brushed(rangeInfoList)) && applyVisual(STATE_LIST, visualMappings, data, getValueState);
+        });
+      });
+      dispatchAction(api, throttleType, throttleDelay, brushSelected, payload);
+    }
+
+    function dispatchAction(api, throttleType, throttleDelay, brushSelected, payload) {
+      // This event will not be triggered when `setOpion`, otherwise dead lock may
+      // triggered when do `setOption` in event listener, which we do not find
+      // satisfactory way to solve yet. Some considered resolutions:
+      // (a) Diff with prevoius selected data ant only trigger event when changed.
+      // But store previous data and diff precisely (i.e., not only by dataIndex, but
+      // also detect value changes in selected data) might bring complexity or fragility.
+      // (b) Use spectial param like `silent` to suppress event triggering.
+      // But such kind of volatile param may be weird in `setOption`.
+      if (!payload) {
+        return;
+      }
+
+      var zr = api.getZr();
+
+      if (zr[DISPATCH_FLAG]) {
+        return;
+      }
+
+      if (!zr[DISPATCH_METHOD]) {
+        zr[DISPATCH_METHOD] = doDispatch;
+      }
+
+      var fn = createOrUpdate(zr, DISPATCH_METHOD, throttleDelay, throttleType);
+      fn(api, brushSelected);
+    }
+
+    function doDispatch(api, brushSelected) {
+      if (!api.isDisposed()) {
+        var zr = api.getZr();
+        zr[DISPATCH_FLAG] = true;
+        api.dispatchAction({
+          type: 'brushSelect',
+          batch: brushSelected
+        });
+        zr[DISPATCH_FLAG] = false;
+      }
+    }
+
+    function checkInRange(seriesModel, rangeInfoList, data, dataIndex) {
+      for (var i = 0, len = rangeInfoList.length; i < len; i++) {
+        var area = rangeInfoList[i];
+
+        if (seriesModel.brushSelector(dataIndex, data, area.selectors, area)) {
+          return true;
+        }
+      }
+    }
+
+    function brushModelNotControll(brushModel, seriesIndex) {
+      var seriesIndices = brushModel.option.seriesIndex;
+      return seriesIndices != null && seriesIndices !== 'all' && (isArray(seriesIndices) ? indexOf(seriesIndices, seriesIndex) < 0 : seriesIndex !== seriesIndices);
+    }
+
+    var boundingRectBuilders = {
+      rect: function (area) {
+        return getBoundingRectFromMinMax(area.range);
+      },
+      polygon: function (area) {
+        var minMax;
+        var range = area.range;
+
+        for (var i = 0, len = range.length; i < len; i++) {
+          minMax = minMax || [[Infinity, -Infinity], [Infinity, -Infinity]];
+          var rg = range[i];
+          rg[0] < minMax[0][0] && (minMax[0][0] = rg[0]);
+          rg[0] > minMax[0][1] && (minMax[0][1] = rg[0]);
+          rg[1] < minMax[1][0] && (minMax[1][0] = rg[1]);
+          rg[1] > minMax[1][1] && (minMax[1][1] = rg[1]);
+        }
+
+        return minMax && getBoundingRectFromMinMax(minMax);
+      }
+    };
+
+    function getBoundingRectFromMinMax(minMax) {
+      return new BoundingRect(minMax[0][0], minMax[1][0], minMax[0][1] - minMax[0][0], minMax[1][1] - minMax[1][0]);
+    }
+
+    var BrushView =
+    /** @class */
+    function (_super) {
+      __extends(BrushView, _super);
+
+      function BrushView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BrushView.type;
+        return _this;
+      }
+
+      BrushView.prototype.init = function (ecModel, api) {
+        this.ecModel = ecModel;
+        this.api = api;
+        this.model;
+        (this._brushController = new BrushController(api.getZr())).on('brush', bind(this._onBrush, this)).mount();
+      };
+
+      BrushView.prototype.render = function (brushModel, ecModel, api, payload) {
+        this.model = brushModel;
+
+        this._updateController(brushModel, ecModel, api, payload);
+      };
+
+      BrushView.prototype.updateTransform = function (brushModel, ecModel, api, payload) {
+        // PENDING: `updateTransform` is a little tricky, whose layout need
+        // to be calculate mandatorily and other stages will not be performed.
+        // Take care the correctness of the logic. See #11754 .
+        layoutCovers(ecModel);
+
+        this._updateController(brushModel, ecModel, api, payload);
+      };
+
+      BrushView.prototype.updateVisual = function (brushModel, ecModel, api, payload) {
+        this.updateTransform(brushModel, ecModel, api, payload);
+      };
+
+      BrushView.prototype.updateView = function (brushModel, ecModel, api, payload) {
+        this._updateController(brushModel, ecModel, api, payload);
+      };
+
+      BrushView.prototype._updateController = function (brushModel, ecModel, api, payload) {
+        // Do not update controller when drawing.
+        (!payload || payload.$from !== brushModel.id) && this._brushController.setPanels(brushModel.brushTargetManager.makePanelOpts(api)).enableBrush(brushModel.brushOption).updateCovers(brushModel.areas.slice());
+      }; // updateLayout: updateController,
+      // updateVisual: updateController,
+
+
+      BrushView.prototype.dispose = function () {
+        this._brushController.dispose();
+      };
+
+      BrushView.prototype._onBrush = function (eventParam) {
+        var modelId = this.model.id;
+        var areas = this.model.brushTargetManager.setOutputRanges(eventParam.areas, this.ecModel); // Action is not dispatched on drag end, because the drag end
+        // emits the same params with the last drag move event, and
+        // may have some delay when using touch pad, which makes
+        // animation not smooth (when using debounce).
+
+        (!eventParam.isEnd || eventParam.removeOnClick) && this.api.dispatchAction({
+          type: 'brush',
+          brushId: modelId,
+          areas: clone(areas),
+          $from: modelId
+        });
+        eventParam.isEnd && this.api.dispatchAction({
+          type: 'brushEnd',
+          brushId: modelId,
+          areas: clone(areas),
+          $from: modelId
+        });
+      };
+
+      BrushView.type = 'brush';
+      return BrushView;
+    }(ComponentView);
+
+    var DEFAULT_OUT_OF_BRUSH_COLOR = '#ddd';
+
+    var BrushModel =
+    /** @class */
+    function (_super) {
+      __extends(BrushModel, _super);
+
+      function BrushModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = BrushModel.type;
+        /**
+         * @readOnly
+         */
+
+        _this.areas = [];
+        /**
+         * Current brush painting area settings.
+         * @readOnly
+         */
+
+        _this.brushOption = {};
+        return _this;
+      }
+
+      BrushModel.prototype.optionUpdated = function (newOption, isInit) {
+        var thisOption = this.option;
+        !isInit && replaceVisualOption(thisOption, newOption, ['inBrush', 'outOfBrush']);
+        var inBrush = thisOption.inBrush = thisOption.inBrush || {}; // Always give default visual, consider setOption at the second time.
+
+        thisOption.outOfBrush = thisOption.outOfBrush || {
+          color: DEFAULT_OUT_OF_BRUSH_COLOR
+        };
+
+        if (!inBrush.hasOwnProperty('liftZ')) {
+          // Bigger than the highlight z lift, otherwise it will
+          // be effected by the highlight z when brush.
+          inBrush.liftZ = 5;
+        }
+      };
+      /**
+       * If `areas` is null/undefined, range state remain.
+       */
+
+
+      BrushModel.prototype.setAreas = function (areas) {
+        if ("development" !== 'production') {
+          assert(isArray(areas));
+          each(areas, function (area) {
+            assert(area.brushType, 'Illegal areas');
+          });
+        } // If areas is null/undefined, range state remain.
+        // This helps user to dispatchAction({type: 'brush'}) with no areas
+        // set but just want to get the current brush select info from a `brush` event.
+
+
+        if (!areas) {
+          return;
+        }
+
+        this.areas = map(areas, function (area) {
+          return generateBrushOption(this.option, area);
+        }, this);
+      };
+      /**
+       * Set the current painting brush option.
+       */
+
+
+      BrushModel.prototype.setBrushOption = function (brushOption) {
+        this.brushOption = generateBrushOption(this.option, brushOption);
+        this.brushType = this.brushOption.brushType;
+      };
+
+      BrushModel.type = 'brush';
+      BrushModel.dependencies = ['geo', 'grid', 'xAxis', 'yAxis', 'parallel', 'series'];
+      BrushModel.defaultOption = {
+        seriesIndex: 'all',
+        brushType: 'rect',
+        brushMode: 'single',
+        transformable: true,
+        brushStyle: {
+          borderWidth: 1,
+          color: 'rgba(210,219,238,0.3)',
+          borderColor: '#D2DBEE'
+        },
+        throttleType: 'fixRate',
+        throttleDelay: 0,
+        removeOnClick: true,
+        z: 10000
+      };
+      return BrushModel;
+    }(ComponentModel);
+
+    function generateBrushOption(option, brushOption) {
+      return merge({
+        brushType: option.brushType,
+        brushMode: option.brushMode,
+        transformable: option.transformable,
+        brushStyle: new Model(option.brushStyle).getItemStyle(),
+        removeOnClick: option.removeOnClick,
+        z: option.z
+      }, brushOption, true);
+    }
+
+    var ICON_TYPES = ['rect', 'polygon', 'lineX', 'lineY', 'keep', 'clear'];
+
+    var BrushFeature =
+    /** @class */
+    function (_super) {
+      __extends(BrushFeature, _super);
+
+      function BrushFeature() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+
+      BrushFeature.prototype.render = function (featureModel, ecModel, api) {
+        var brushType;
+        var brushMode;
+        var isBrushed;
+        ecModel.eachComponent({
+          mainType: 'brush'
+        }, function (brushModel) {
+          brushType = brushModel.brushType;
+          brushMode = brushModel.brushOption.brushMode || 'single';
+          isBrushed = isBrushed || !!brushModel.areas.length;
+        });
+        this._brushType = brushType;
+        this._brushMode = brushMode;
+        each(featureModel.get('type', true), function (type) {
+          featureModel.setIconStatus(type, (type === 'keep' ? brushMode === 'multiple' : type === 'clear' ? isBrushed : type === brushType) ? 'emphasis' : 'normal');
+        });
+      };
+
+      BrushFeature.prototype.updateView = function (featureModel, ecModel, api) {
+        this.render(featureModel, ecModel, api);
+      };
+
+      BrushFeature.prototype.getIcons = function () {
+        var model = this.model;
+        var availableIcons = model.get('icon', true);
+        var icons = {};
+        each(model.get('type', true), function (type) {
+          if (availableIcons[type]) {
+            icons[type] = availableIcons[type];
+          }
+        });
+        return icons;
+      };
+
+      BrushFeature.prototype.onclick = function (ecModel, api, type) {
+        var brushType = this._brushType;
+        var brushMode = this._brushMode;
+
+        if (type === 'clear') {
+          // Trigger parallel action firstly
+          api.dispatchAction({
+            type: 'axisAreaSelect',
+            intervals: []
+          });
+          api.dispatchAction({
+            type: 'brush',
+            command: 'clear',
+            // Clear all areas of all brush components.
+            areas: []
+          });
+        } else {
+          api.dispatchAction({
+            type: 'takeGlobalCursor',
+            key: 'brush',
+            brushOption: {
+              brushType: type === 'keep' ? brushType : brushType === type ? false : type,
+              brushMode: type === 'keep' ? brushMode === 'multiple' ? 'single' : 'multiple' : brushMode
+            }
+          });
+        }
+      };
+
+      BrushFeature.getDefaultOption = function (ecModel) {
+        var defaultOption = {
+          show: true,
+          type: ICON_TYPES.slice(),
+          icon: {
+            /* eslint-disable */
+            rect: 'M7.3,34.7 M0.4,10V-0.2h9.8 M89.6,10V-0.2h-9.8 M0.4,60v10.2h9.8 M89.6,60v10.2h-9.8 M12.3,22.4V10.5h13.1 M33.6,10.5h7.8 M49.1,10.5h7.8 M77.5,22.4V10.5h-13 M12.3,31.1v8.2 M77.7,31.1v8.2 M12.3,47.6v11.9h13.1 M33.6,59.5h7.6 M49.1,59.5 h7.7 M77.5,47.6v11.9h-13',
+            polygon: 'M55.2,34.9c1.7,0,3.1,1.4,3.1,3.1s-1.4,3.1-3.1,3.1 s-3.1-1.4-3.1-3.1S53.5,34.9,55.2,34.9z M50.4,51c1.7,0,3.1,1.4,3.1,3.1c0,1.7-1.4,3.1-3.1,3.1c-1.7,0-3.1-1.4-3.1-3.1 C47.3,52.4,48.7,51,50.4,51z M55.6,37.1l1.5-7.8 M60.1,13.5l1.6-8.7l-7.8,4 M59,19l-1,5.3 M24,16.1l6.4,4.9l6.4-3.3 M48.5,11.6 l-5.9,3.1 M19.1,12.8L9.7,5.1l1.1,7.7 M13.4,29.8l1,7.3l6.6,1.6 M11.6,18.4l1,6.1 M32.8,41.9 M26.6,40.4 M27.3,40.2l6.1,1.6 M49.9,52.1l-5.6-7.6l-4.9-1.2',
+            lineX: 'M15.2,30 M19.7,15.6V1.9H29 M34.8,1.9H40.4 M55.3,15.6V1.9H45.9 M19.7,44.4V58.1H29 M34.8,58.1H40.4 M55.3,44.4 V58.1H45.9 M12.5,20.3l-9.4,9.6l9.6,9.8 M3.1,29.9h16.5 M62.5,20.3l9.4,9.6L62.3,39.7 M71.9,29.9H55.4',
+            lineY: 'M38.8,7.7 M52.7,12h13.2v9 M65.9,26.6V32 M52.7,46.3h13.2v-9 M24.9,12H11.8v9 M11.8,26.6V32 M24.9,46.3H11.8v-9 M48.2,5.1l-9.3-9l-9.4,9.2 M38.9-3.9V12 M48.2,53.3l-9.3,9l-9.4-9.2 M38.9,62.3V46.4',
+            keep: 'M4,10.5V1h10.3 M20.7,1h6.1 M33,1h6.1 M55.4,10.5V1H45.2 M4,17.3v6.6 M55.6,17.3v6.6 M4,30.5V40h10.3 M20.7,40 h6.1 M33,40h6.1 M55.4,30.5V40H45.2 M21,18.9h62.9v48.6H21V18.9z',
+            clear: 'M22,14.7l30.9,31 M52.9,14.7L22,45.7 M4.7,16.8V4.2h13.1 M26,4.2h7.8 M41.6,4.2h7.8 M70.3,16.8V4.2H57.2 M4.7,25.9v8.6 M70.3,25.9v8.6 M4.7,43.2v12.6h13.1 M26,55.8h7.8 M41.6,55.8h7.8 M70.3,43.2v12.6H57.2' // jshint ignore:line
+
+            /* eslint-enable */
+
+          },
+          // `rect`, `polygon`, `lineX`, `lineY`, `keep`, `clear`
+          title: ecModel.getLocale(['toolbox', 'brush', 'title'])
+        };
+        return defaultOption;
+      };
+
+      return BrushFeature;
+    }(ToolboxFeature);
+
+    function install$B(registers) {
+      registers.registerComponentView(BrushView);
+      registers.registerComponentModel(BrushModel);
+      registers.registerPreprocessor(brushPreprocessor);
+      registers.registerVisual(registers.PRIORITY.VISUAL.BRUSH, brushVisual);
+      registers.registerAction({
+        type: 'brush',
+        event: 'brush',
+        update: 'updateVisual'
+      }, function (payload, ecModel) {
+        ecModel.eachComponent({
+          mainType: 'brush',
+          query: payload
+        }, function (brushModel) {
+          brushModel.setAreas(payload.areas);
+        });
+      });
+      /**
+       * payload: {
+       *      brushComponents: [
+       *          {
+       *              brushId,
+       *              brushIndex,
+       *              brushName,
+       *              series: [
+       *                  {
+       *                      seriesId,
+       *                      seriesIndex,
+       *                      seriesName,
+       *                      rawIndices: [21, 34, ...]
+       *                  },
+       *                  ...
+       *              ]
+       *          },
+       *          ...
+       *      ]
+       * }
+       */
+
+      registers.registerAction({
+        type: 'brushSelect',
+        event: 'brushSelected',
+        update: 'none'
+      }, function () {});
+      registers.registerAction({
+        type: 'brushEnd',
+        event: 'brushEnd',
+        update: 'none'
+      }, function () {});
+      registerFeature('brush', BrushFeature);
+    }
+
+    var TitleModel =
+    /** @class */
+    function (_super) {
+      __extends(TitleModel, _super);
+
+      function TitleModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TitleModel.type;
+        _this.layoutMode = {
+          type: 'box',
+          ignoreSize: true
+        };
+        return _this;
+      }
+
+      TitleModel.type = 'title';
+      TitleModel.defaultOption = {
+        zlevel: 0,
+        z: 6,
+        show: true,
+        text: '',
+        target: 'blank',
+        subtext: '',
+        subtarget: 'blank',
+        left: 0,
+        top: 0,
+        backgroundColor: 'rgba(0,0,0,0)',
+        borderColor: '#ccc',
+        borderWidth: 0,
+        padding: 5,
+        itemGap: 10,
+        textStyle: {
+          fontSize: 18,
+          fontWeight: 'bold',
+          color: '#464646'
+        },
+        subtextStyle: {
+          fontSize: 12,
+          color: '#6E7079'
+        }
+      };
+      return TitleModel;
+    }(ComponentModel); // View
+
+
+    var TitleView =
+    /** @class */
+    function (_super) {
+      __extends(TitleView, _super);
+
+      function TitleView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TitleView.type;
+        return _this;
+      }
+
+      TitleView.prototype.render = function (titleModel, ecModel, api) {
+        this.group.removeAll();
+
+        if (!titleModel.get('show')) {
+          return;
+        }
+
+        var group = this.group;
+        var textStyleModel = titleModel.getModel('textStyle');
+        var subtextStyleModel = titleModel.getModel('subtextStyle');
+        var textAlign = titleModel.get('textAlign');
+        var textVerticalAlign = retrieve2(titleModel.get('textBaseline'), titleModel.get('textVerticalAlign'));
+        var textEl = new ZRText({
+          style: createTextStyle(textStyleModel, {
+            text: titleModel.get('text'),
+            fill: textStyleModel.getTextColor()
+          }, {
+            disableBox: true
+          }),
+          z2: 10
+        });
+        var textRect = textEl.getBoundingRect();
+        var subText = titleModel.get('subtext');
+        var subTextEl = new ZRText({
+          style: createTextStyle(subtextStyleModel, {
+            text: subText,
+            fill: subtextStyleModel.getTextColor(),
+            y: textRect.height + titleModel.get('itemGap'),
+            verticalAlign: 'top'
+          }, {
+            disableBox: true
+          }),
+          z2: 10
+        });
+        var link = titleModel.get('link');
+        var sublink = titleModel.get('sublink');
+        var triggerEvent = titleModel.get('triggerEvent', true);
+        textEl.silent = !link && !triggerEvent;
+        subTextEl.silent = !sublink && !triggerEvent;
+
+        if (link) {
+          textEl.on('click', function () {
+            windowOpen(link, '_' + titleModel.get('target'));
+          });
+        }
+
+        if (sublink) {
+          subTextEl.on('click', function () {
+            windowOpen(sublink, '_' + titleModel.get('subtarget'));
+          });
+        }
+
+        getECData(textEl).eventData = getECData(subTextEl).eventData = triggerEvent ? {
+          componentType: 'title',
+          componentIndex: titleModel.componentIndex
+        } : null;
+        group.add(textEl);
+        subText && group.add(subTextEl); // If no subText, but add subTextEl, there will be an empty line.
+
+        var groupRect = group.getBoundingRect();
+        var layoutOption = titleModel.getBoxLayoutParams();
+        layoutOption.width = groupRect.width;
+        layoutOption.height = groupRect.height;
+        var layoutRect = getLayoutRect(layoutOption, {
+          width: api.getWidth(),
+          height: api.getHeight()
+        }, titleModel.get('padding')); // Adjust text align based on position
+
+        if (!textAlign) {
+          // Align left if title is on the left. center and right is same
+          textAlign = titleModel.get('left') || titleModel.get('right'); // @ts-ignore
+
+          if (textAlign === 'middle') {
+            textAlign = 'center';
+          } // Adjust layout by text align
+
+
+          if (textAlign === 'right') {
+            layoutRect.x += layoutRect.width;
+          } else if (textAlign === 'center') {
+            layoutRect.x += layoutRect.width / 2;
+          }
+        }
+
+        if (!textVerticalAlign) {
+          textVerticalAlign = titleModel.get('top') || titleModel.get('bottom'); // @ts-ignore
+
+          if (textVerticalAlign === 'center') {
+            textVerticalAlign = 'middle';
+          }
+
+          if (textVerticalAlign === 'bottom') {
+            layoutRect.y += layoutRect.height;
+          } else if (textVerticalAlign === 'middle') {
+            layoutRect.y += layoutRect.height / 2;
+          }
+
+          textVerticalAlign = textVerticalAlign || 'top';
+        }
+
+        group.x = layoutRect.x;
+        group.y = layoutRect.y;
+        group.markRedraw();
+        var alignStyle = {
+          align: textAlign,
+          verticalAlign: textVerticalAlign
+        };
+        textEl.setStyle(alignStyle);
+        subTextEl.setStyle(alignStyle); // Render background
+        // Get groupRect again because textAlign has been changed
+
+        groupRect = group.getBoundingRect();
+        var padding = layoutRect.margin;
+        var style = titleModel.getItemStyle(['color', 'opacity']);
+        style.fill = titleModel.get('backgroundColor');
+        var rect = new Rect({
+          shape: {
+            x: groupRect.x - padding[3],
+            y: groupRect.y - padding[0],
+            width: groupRect.width + padding[1] + padding[3],
+            height: groupRect.height + padding[0] + padding[2],
+            r: titleModel.get('borderRadius')
+          },
+          style: style,
+          subPixelOptimize: true,
+          silent: true
+        });
+        group.add(rect);
+      };
+
+      TitleView.type = 'title';
+      return TitleView;
+    }(ComponentView);
+
+    function install$C(registers) {
+      registers.registerComponentModel(TitleModel);
+      registers.registerComponentView(TitleView);
+    }
+
+    var TimelineModel =
+    /** @class */
+    function (_super) {
+      __extends(TimelineModel, _super);
+
+      function TimelineModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TimelineModel.type;
+        _this.layoutMode = 'box';
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      TimelineModel.prototype.init = function (option, parentModel, ecModel) {
+        this.mergeDefaultAndTheme(option, ecModel);
+
+        this._initData();
+      };
+      /**
+       * @override
+       */
+
+
+      TimelineModel.prototype.mergeOption = function (option) {
+        _super.prototype.mergeOption.apply(this, arguments);
+
+        this._initData();
+      };
+
+      TimelineModel.prototype.setCurrentIndex = function (currentIndex) {
+        if (currentIndex == null) {
+          currentIndex = this.option.currentIndex;
+        }
+
+        var count = this._data.count();
+
+        if (this.option.loop) {
+          currentIndex = (currentIndex % count + count) % count;
+        } else {
+          currentIndex >= count && (currentIndex = count - 1);
+          currentIndex < 0 && (currentIndex = 0);
+        }
+
+        this.option.currentIndex = currentIndex;
+      };
+      /**
+       * @return {number} currentIndex
+       */
+
+
+      TimelineModel.prototype.getCurrentIndex = function () {
+        return this.option.currentIndex;
+      };
+      /**
+       * @return {boolean}
+       */
+
+
+      TimelineModel.prototype.isIndexMax = function () {
+        return this.getCurrentIndex() >= this._data.count() - 1;
+      };
+      /**
+       * @param {boolean} state true: play, false: stop
+       */
+
+
+      TimelineModel.prototype.setPlayState = function (state) {
+        this.option.autoPlay = !!state;
+      };
+      /**
+       * @return {boolean} true: play, false: stop
+       */
+
+
+      TimelineModel.prototype.getPlayState = function () {
+        return !!this.option.autoPlay;
+      };
+      /**
+       * @private
+       */
+
+
+      TimelineModel.prototype._initData = function () {
+        var thisOption = this.option;
+        var dataArr = thisOption.data || [];
+        var axisType = thisOption.axisType;
+        var names = this._names = [];
+        var processedDataArr;
+
+        if (axisType === 'category') {
+          processedDataArr = [];
+          each(dataArr, function (item, index) {
+            var value = convertOptionIdName(getDataItemValue(item), '');
+            var newItem;
+
+            if (isObject(item)) {
+              newItem = clone(item);
+              newItem.value = index;
+            } else {
+              newItem = index;
+            }
+
+            processedDataArr.push(newItem);
+            names.push(value);
+          });
+        } else {
+          processedDataArr = dataArr;
+        }
+
+        var dimType = {
+          category: 'ordinal',
+          time: 'time',
+          value: 'number'
+        }[axisType] || 'number';
+        var data = this._data = new List([{
+          name: 'value',
+          type: dimType
+        }], this);
+        data.initData(processedDataArr, names);
+      };
+
+      TimelineModel.prototype.getData = function () {
+        return this._data;
+      };
+      /**
+       * @public
+       * @return {Array.<string>} categoreis
+       */
+
+
+      TimelineModel.prototype.getCategories = function () {
+        if (this.get('axisType') === 'category') {
+          return this._names.slice();
+        }
+      };
+
+      TimelineModel.type = 'timeline';
+      /**
+       * @protected
+       */
+
+      TimelineModel.defaultOption = {
+        zlevel: 0,
+        z: 4,
+        show: true,
+        axisType: 'time',
+        realtime: true,
+        left: '20%',
+        top: null,
+        right: '20%',
+        bottom: 0,
+        width: null,
+        height: 40,
+        padding: 5,
+        controlPosition: 'left',
+        autoPlay: false,
+        rewind: false,
+        loop: true,
+        playInterval: 2000,
+        currentIndex: 0,
+        itemStyle: {},
+        label: {
+          color: '#000'
+        },
+        data: []
+      };
+      return TimelineModel;
+    }(ComponentModel);
+
+    var SliderTimelineModel =
+    /** @class */
+    function (_super) {
+      __extends(SliderTimelineModel, _super);
+
+      function SliderTimelineModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SliderTimelineModel.type;
+        return _this;
+      }
+
+      SliderTimelineModel.type = 'timeline.slider';
+      /**
+       * @protected
+       */
+
+      SliderTimelineModel.defaultOption = inheritDefaultOption(TimelineModel.defaultOption, {
+        backgroundColor: 'rgba(0,0,0,0)',
+        borderColor: '#ccc',
+        borderWidth: 0,
+        orient: 'horizontal',
+        inverse: false,
+        tooltip: {
+          trigger: 'item' // data item may also have tootip attr.
+
+        },
+        symbol: 'circle',
+        symbolSize: 12,
+        lineStyle: {
+          show: true,
+          width: 2,
+          color: '#DAE1F5'
+        },
+        label: {
+          position: 'auto',
+          // When using number, label position is not
+          // restricted by viewRect.
+          // positive: right/bottom, negative: left/top
+          show: true,
+          interval: 'auto',
+          rotate: 0,
+          // formatter: null,
+          // 其余属性默认使用全局文本样式，详见TEXTSTYLE
+          color: '#A4B1D7'
+        },
+        itemStyle: {
+          color: '#A4B1D7',
+          borderWidth: 1
+        },
+        checkpointStyle: {
+          symbol: 'circle',
+          symbolSize: 15,
+          color: '#316bf3',
+          borderColor: '#fff',
+          borderWidth: 2,
+          shadowBlur: 2,
+          shadowOffsetX: 1,
+          shadowOffsetY: 1,
+          shadowColor: 'rgba(0, 0, 0, 0.3)',
+          // borderColor: 'rgba(194,53,49, 0.5)',
+          animation: true,
+          animationDuration: 300,
+          animationEasing: 'quinticInOut'
+        },
+        controlStyle: {
+          show: true,
+          showPlayBtn: true,
+          showPrevBtn: true,
+          showNextBtn: true,
+          itemSize: 24,
+          itemGap: 12,
+          position: 'left',
+          playIcon: 'path://M31.6,53C17.5,53,6,41.5,6,27.4S17.5,1.8,31.6,1.8C45.7,1.8,57.2,13.3,57.2,27.4S45.7,53,31.6,53z M31.6,3.3 C18.4,3.3,7.5,14.1,7.5,27.4c0,13.3,10.8,24.1,24.1,24.1C44.9,51.5,55.7,40.7,55.7,27.4C55.7,14.1,44.9,3.3,31.6,3.3z M24.9,21.3 c0-2.2,1.6-3.1,3.5-2l10.5,6.1c1.899,1.1,1.899,2.9,0,4l-10.5,6.1c-1.9,1.1-3.5,0.2-3.5-2V21.3z',
+          stopIcon: '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',
+          nextIcon: 'M2,18.5A1.52,1.52,0,0,1,.92,18a1.49,1.49,0,0,1,0-2.12L7.81,9.36,1,3.11A1.5,1.5,0,1,1,3,.89l8,7.34a1.48,1.48,0,0,1,.49,1.09,1.51,1.51,0,0,1-.46,1.1L3,18.08A1.5,1.5,0,0,1,2,18.5Z',
+          prevIcon: 'M10,.5A1.52,1.52,0,0,1,11.08,1a1.49,1.49,0,0,1,0,2.12L4.19,9.64,11,15.89a1.5,1.5,0,1,1-2,2.22L1,10.77A1.48,1.48,0,0,1,.5,9.68,1.51,1.51,0,0,1,1,8.58L9,.92A1.5,1.5,0,0,1,10,.5Z',
+          prevBtnSize: 18,
+          nextBtnSize: 18,
+          color: '#A4B1D7',
+          borderColor: '#A4B1D7',
+          borderWidth: 1
+        },
+        emphasis: {
+          label: {
+            show: true,
+            // 其余属性默认使用全局文本样式，详见TEXTSTYLE
+            color: '#6f778d'
+          },
+          itemStyle: {
+            color: '#316BF3'
+          },
+          controlStyle: {
+            color: '#316BF3',
+            borderColor: '#316BF3',
+            borderWidth: 2
+          }
+        },
+        progress: {
+          lineStyle: {
+            color: '#316BF3'
+          },
+          itemStyle: {
+            color: '#316BF3'
+          },
+          label: {
+            color: '#6f778d'
+          }
+        },
+        data: []
+      });
+      return SliderTimelineModel;
+    }(TimelineModel);
+
+    mixin(SliderTimelineModel, DataFormatMixin.prototype);
+
+    var TimelineView =
+    /** @class */
+    function (_super) {
+      __extends(TimelineView, _super);
+
+      function TimelineView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = TimelineView.type;
+        return _this;
+      }
+
+      TimelineView.type = 'timeline';
+      return TimelineView;
+    }(ComponentView);
+
+    /**
+     * Extend axis 2d
+     */
+
+    var TimelineAxis =
+    /** @class */
+    function (_super) {
+      __extends(TimelineAxis, _super);
+
+      function TimelineAxis(dim, scale, coordExtent, axisType) {
+        var _this = _super.call(this, dim, scale, coordExtent) || this;
+
+        _this.type = axisType || 'value';
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      TimelineAxis.prototype.getLabelModel = function () {
+        // Force override
+        return this.model.getModel('label');
+      };
+      /**
+       * @override
+       */
+
+
+      TimelineAxis.prototype.isHorizontal = function () {
+        return this.model.get('orient') === 'horizontal';
+      };
+
+      return TimelineAxis;
+    }(Axis);
+
+    var PI$8 = Math.PI;
+    var labelDataIndexStore = makeInner();
+
+    var SliderTimelineView =
+    /** @class */
+    function (_super) {
+      __extends(SliderTimelineView, _super);
+
+      function SliderTimelineView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SliderTimelineView.type;
+        return _this;
+      }
+
+      SliderTimelineView.prototype.init = function (ecModel, api) {
+        this.api = api;
+      };
+      /**
+       * @override
+       */
+
+
+      SliderTimelineView.prototype.render = function (timelineModel, ecModel, api) {
+        this.model = timelineModel;
+        this.api = api;
+        this.ecModel = ecModel;
+        this.group.removeAll();
+
+        if (timelineModel.get('show', true)) {
+          var layoutInfo_1 = this._layout(timelineModel, api);
+
+          var mainGroup_1 = this._createGroup('_mainGroup');
+
+          var labelGroup = this._createGroup('_labelGroup');
+
+          var axis_1 = this._axis = this._createAxis(layoutInfo_1, timelineModel);
+
+          timelineModel.formatTooltip = function (dataIndex) {
+            var name = axis_1.scale.getLabel({
+              value: dataIndex
+            });
+            return createTooltipMarkup('nameValue', {
+              noName: true,
+              value: name
+            });
+          };
+
+          each(['AxisLine', 'AxisTick', 'Control', 'CurrentPointer'], function (name) {
+            this['_render' + name](layoutInfo_1, mainGroup_1, axis_1, timelineModel);
+          }, this);
+
+          this._renderAxisLabel(layoutInfo_1, labelGroup, axis_1, timelineModel);
+
+          this._position(layoutInfo_1, timelineModel);
+        }
+
+        this._doPlayStop();
+
+        this._updateTicksStatus();
+      };
+      /**
+       * @override
+       */
+
+
+      SliderTimelineView.prototype.remove = function () {
+        this._clearTimer();
+
+        this.group.removeAll();
+      };
+      /**
+       * @override
+       */
+
+
+      SliderTimelineView.prototype.dispose = function () {
+        this._clearTimer();
+      };
+
+      SliderTimelineView.prototype._layout = function (timelineModel, api) {
+        var labelPosOpt = timelineModel.get(['label', 'position']);
+        var orient = timelineModel.get('orient');
+        var viewRect = getViewRect$5(timelineModel, api);
+        var parsedLabelPos; // Auto label offset.
+
+        if (labelPosOpt == null || labelPosOpt === 'auto') {
+          parsedLabelPos = orient === 'horizontal' ? viewRect.y + viewRect.height / 2 < api.getHeight() / 2 ? '-' : '+' : viewRect.x + viewRect.width / 2 < api.getWidth() / 2 ? '+' : '-';
+        } else if (isString(labelPosOpt)) {
+          parsedLabelPos = {
+            horizontal: {
+              top: '-',
+              bottom: '+'
+            },
+            vertical: {
+              left: '-',
+              right: '+'
+            }
+          }[orient][labelPosOpt];
+        } else {
+          // is number
+          parsedLabelPos = labelPosOpt;
+        }
+
+        var labelAlignMap = {
+          horizontal: 'center',
+          vertical: parsedLabelPos >= 0 || parsedLabelPos === '+' ? 'left' : 'right'
+        };
+        var labelBaselineMap = {
+          horizontal: parsedLabelPos >= 0 || parsedLabelPos === '+' ? 'top' : 'bottom',
+          vertical: 'middle'
+        };
+        var rotationMap = {
+          horizontal: 0,
+          vertical: PI$8 / 2
+        }; // Position
+
+        var mainLength = orient === 'vertical' ? viewRect.height : viewRect.width;
+        var controlModel = timelineModel.getModel('controlStyle');
+        var showControl = controlModel.get('show', true);
+        var controlSize = showControl ? controlModel.get('itemSize') : 0;
+        var controlGap = showControl ? controlModel.get('itemGap') : 0;
+        var sizePlusGap = controlSize + controlGap; // Special label rotate.
+
+        var labelRotation = timelineModel.get(['label', 'rotate']) || 0;
+        labelRotation = labelRotation * PI$8 / 180; // To radian.
+
+        var playPosition;
+        var prevBtnPosition;
+        var nextBtnPosition;
+        var controlPosition = controlModel.get('position', true);
+        var showPlayBtn = showControl && controlModel.get('showPlayBtn', true);
+        var showPrevBtn = showControl && controlModel.get('showPrevBtn', true);
+        var showNextBtn = showControl && controlModel.get('showNextBtn', true);
+        var xLeft = 0;
+        var xRight = mainLength; // position[0] means left, position[1] means middle.
+
+        if (controlPosition === 'left' || controlPosition === 'bottom') {
+          showPlayBtn && (playPosition = [0, 0], xLeft += sizePlusGap);
+          showPrevBtn && (prevBtnPosition = [xLeft, 0], xLeft += sizePlusGap);
+          showNextBtn && (nextBtnPosition = [xRight - controlSize, 0], xRight -= sizePlusGap);
+        } else {
+          // 'top' 'right'
+          showPlayBtn && (playPosition = [xRight - controlSize, 0], xRight -= sizePlusGap);
+          showPrevBtn && (prevBtnPosition = [0, 0], xLeft += sizePlusGap);
+          showNextBtn && (nextBtnPosition = [xRight - controlSize, 0], xRight -= sizePlusGap);
+        }
+
+        var axisExtent = [xLeft, xRight];
+
+        if (timelineModel.get('inverse')) {
+          axisExtent.reverse();
+        }
+
+        return {
+          viewRect: viewRect,
+          mainLength: mainLength,
+          orient: orient,
+          rotation: rotationMap[orient],
+          labelRotation: labelRotation,
+          labelPosOpt: parsedLabelPos,
+          labelAlign: timelineModel.get(['label', 'align']) || labelAlignMap[orient],
+          labelBaseline: timelineModel.get(['label', 'verticalAlign']) || timelineModel.get(['label', 'baseline']) || labelBaselineMap[orient],
+          // Based on mainGroup.
+          playPosition: playPosition,
+          prevBtnPosition: prevBtnPosition,
+          nextBtnPosition: nextBtnPosition,
+          axisExtent: axisExtent,
+          controlSize: controlSize,
+          controlGap: controlGap
+        };
+      };
+
+      SliderTimelineView.prototype._position = function (layoutInfo, timelineModel) {
+        // Position is be called finally, because bounding rect is needed for
+        // adapt content to fill viewRect (auto adapt offset).
+        // Timeline may be not all in the viewRect when 'offset' is specified
+        // as a number, because it is more appropriate that label aligns at
+        // 'offset' but not the other edge defined by viewRect.
+        var mainGroup = this._mainGroup;
+        var labelGroup = this._labelGroup;
+        var viewRect = layoutInfo.viewRect;
+
+        if (layoutInfo.orient === 'vertical') {
+          // transform to horizontal, inverse rotate by left-top point.
+          var m = create$1();
+          var rotateOriginX = viewRect.x;
+          var rotateOriginY = viewRect.y + viewRect.height;
+          translate(m, m, [-rotateOriginX, -rotateOriginY]);
+          rotate(m, m, -PI$8 / 2);
+          translate(m, m, [rotateOriginX, rotateOriginY]);
+          viewRect = viewRect.clone();
+          viewRect.applyTransform(m);
+        }
+
+        var viewBound = getBound(viewRect);
+        var mainBound = getBound(mainGroup.getBoundingRect());
+        var labelBound = getBound(labelGroup.getBoundingRect());
+        var mainPosition = [mainGroup.x, mainGroup.y];
+        var labelsPosition = [labelGroup.x, labelGroup.y];
+        labelsPosition[0] = mainPosition[0] = viewBound[0][0];
+        var labelPosOpt = layoutInfo.labelPosOpt;
+
+        if (labelPosOpt == null || isString(labelPosOpt)) {
+          // '+' or '-'
+          var mainBoundIdx = labelPosOpt === '+' ? 0 : 1;
+          toBound(mainPosition, mainBound, viewBound, 1, mainBoundIdx);
+          toBound(labelsPosition, labelBound, viewBound, 1, 1 - mainBoundIdx);
+        } else {
+          var mainBoundIdx = labelPosOpt >= 0 ? 0 : 1;
+          toBound(mainPosition, mainBound, viewBound, 1, mainBoundIdx);
+          labelsPosition[1] = mainPosition[1] + labelPosOpt;
+        }
+
+        mainGroup.setPosition(mainPosition);
+        labelGroup.setPosition(labelsPosition);
+        mainGroup.rotation = labelGroup.rotation = layoutInfo.rotation;
+        setOrigin(mainGroup);
+        setOrigin(labelGroup);
+
+        function setOrigin(targetGroup) {
+          targetGroup.originX = viewBound[0][0] - targetGroup.x;
+          targetGroup.originY = viewBound[1][0] - targetGroup.y;
+        }
+
+        function getBound(rect) {
+          // [[xmin, xmax], [ymin, ymax]]
+          return [[rect.x, rect.x + rect.width], [rect.y, rect.y + rect.height]];
+        }
+
+        function toBound(fromPos, from, to, dimIdx, boundIdx) {
+          fromPos[dimIdx] += to[dimIdx][boundIdx] - from[dimIdx][boundIdx];
+        }
+      };
+
+      SliderTimelineView.prototype._createAxis = function (layoutInfo, timelineModel) {
+        var data = timelineModel.getData();
+        var axisType = timelineModel.get('axisType');
+        var scale = createScaleByModel$1(timelineModel, axisType); // Customize scale. The `tickValue` is `dataIndex`.
+
+        scale.getTicks = function () {
+          return data.mapArray(['value'], function (value) {
+            return {
+              value: value
+            };
+          });
+        };
+
+        var dataExtent = data.getDataExtent('value');
+        scale.setExtent(dataExtent[0], dataExtent[1]);
+        scale.niceTicks();
+        var axis = new TimelineAxis('value', scale, layoutInfo.axisExtent, axisType);
+        axis.model = timelineModel;
+        return axis;
+      };
+
+      SliderTimelineView.prototype._createGroup = function (key) {
+        var newGroup = this[key] = new Group();
+        this.group.add(newGroup);
+        return newGroup;
+      };
+
+      SliderTimelineView.prototype._renderAxisLine = function (layoutInfo, group, axis, timelineModel) {
+        var axisExtent = axis.getExtent();
+
+        if (!timelineModel.get(['lineStyle', 'show'])) {
+          return;
+        }
+
+        var line = new Line({
+          shape: {
+            x1: axisExtent[0],
+            y1: 0,
+            x2: axisExtent[1],
+            y2: 0
+          },
+          style: extend({
+            lineCap: 'round'
+          }, timelineModel.getModel('lineStyle').getLineStyle()),
+          silent: true,
+          z2: 1
+        });
+        group.add(line);
+        var progressLine = this._progressLine = new Line({
+          shape: {
+            x1: axisExtent[0],
+            x2: this._currentPointer ? this._currentPointer.x : axisExtent[0],
+            y1: 0,
+            y2: 0
+          },
+          style: defaults({
+            lineCap: 'round',
+            lineWidth: line.style.lineWidth
+          }, timelineModel.getModel(['progress', 'lineStyle']).getLineStyle()),
+          silent: true,
+          z2: 1
+        });
+        group.add(progressLine);
+      };
+
+      SliderTimelineView.prototype._renderAxisTick = function (layoutInfo, group, axis, timelineModel) {
+        var _this = this;
+
+        var data = timelineModel.getData(); // Show all ticks, despite ignoring strategy.
+
+        var ticks = axis.scale.getTicks();
+        this._tickSymbols = []; // The value is dataIndex, see the costomized scale.
+
+        each(ticks, function (tick) {
+          var tickCoord = axis.dataToCoord(tick.value);
+          var itemModel = data.getItemModel(tick.value);
+          var itemStyleModel = itemModel.getModel('itemStyle');
+          var hoverStyleModel = itemModel.getModel(['emphasis', 'itemStyle']);
+          var progressStyleModel = itemModel.getModel(['progress', 'itemStyle']);
+          var symbolOpt = {
+            x: tickCoord,
+            y: 0,
+            onclick: bind(_this._changeTimeline, _this, tick.value)
+          };
+          var el = giveSymbol(itemModel, itemStyleModel, group, symbolOpt);
+          el.ensureState('emphasis').style = hoverStyleModel.getItemStyle();
+          el.ensureState('progress').style = progressStyleModel.getItemStyle();
+          enableHoverEmphasis(el);
+          var ecData = getECData(el);
+
+          if (itemModel.get('tooltip')) {
+            ecData.dataIndex = tick.value;
+            ecData.dataModel = timelineModel;
+          } else {
+            ecData.dataIndex = ecData.dataModel = null;
+          }
+
+          _this._tickSymbols.push(el);
+        });
+      };
+
+      SliderTimelineView.prototype._renderAxisLabel = function (layoutInfo, group, axis, timelineModel) {
+        var _this = this;
+
+        var labelModel = axis.getLabelModel();
+
+        if (!labelModel.get('show')) {
+          return;
+        }
+
+        var data = timelineModel.getData();
+        var labels = axis.getViewLabels();
+        this._tickLabels = [];
+        each(labels, function (labelItem) {
+          // The tickValue is dataIndex, see the costomized scale.
+          var dataIndex = labelItem.tickValue;
+          var itemModel = data.getItemModel(dataIndex);
+          var normalLabelModel = itemModel.getModel('label');
+          var hoverLabelModel = itemModel.getModel(['emphasis', 'label']);
+          var progressLabelModel = itemModel.getModel(['progress', 'label']);
+          var tickCoord = axis.dataToCoord(labelItem.tickValue);
+          var textEl = new ZRText({
+            x: tickCoord,
+            y: 0,
+            rotation: layoutInfo.labelRotation - layoutInfo.rotation,
+            onclick: bind(_this._changeTimeline, _this, dataIndex),
+            silent: false,
+            style: createTextStyle(normalLabelModel, {
+              text: labelItem.formattedLabel,
+              align: layoutInfo.labelAlign,
+              verticalAlign: layoutInfo.labelBaseline
+            })
+          });
+          textEl.ensureState('emphasis').style = createTextStyle(hoverLabelModel);
+          textEl.ensureState('progress').style = createTextStyle(progressLabelModel);
+          group.add(textEl);
+          enableHoverEmphasis(textEl);
+          labelDataIndexStore(textEl).dataIndex = dataIndex;
+
+          _this._tickLabels.push(textEl);
+        });
+      };
+
+      SliderTimelineView.prototype._renderControl = function (layoutInfo, group, axis, timelineModel) {
+        var controlSize = layoutInfo.controlSize;
+        var rotation = layoutInfo.rotation;
+        var itemStyle = timelineModel.getModel('controlStyle').getItemStyle();
+        var hoverStyle = timelineModel.getModel(['emphasis', 'controlStyle']).getItemStyle();
+        var playState = timelineModel.getPlayState();
+        var inverse = timelineModel.get('inverse', true);
+        makeBtn(layoutInfo.nextBtnPosition, 'next', bind(this._changeTimeline, this, inverse ? '-' : '+'));
+        makeBtn(layoutInfo.prevBtnPosition, 'prev', bind(this._changeTimeline, this, inverse ? '+' : '-'));
+        makeBtn(layoutInfo.playPosition, playState ? 'stop' : 'play', bind(this._handlePlayClick, this, !playState), true);
+
+        function makeBtn(position, iconName, onclick, willRotate) {
+          if (!position) {
+            return;
+          }
+
+          var iconSize = parsePercent(retrieve2(timelineModel.get(['controlStyle', iconName + 'BtnSize']), controlSize), controlSize);
+          var rect = [0, -iconSize / 2, iconSize, iconSize];
+          var opt = {
+            position: position,
+            origin: [controlSize / 2, 0],
+            rotation: willRotate ? -rotation : 0,
+            rectHover: true,
+            style: itemStyle,
+            onclick: onclick
+          };
+          var btn = makeControlIcon(timelineModel, iconName + 'Icon', rect, opt);
+          btn.ensureState('emphasis').style = hoverStyle;
+          group.add(btn);
+          enableHoverEmphasis(btn);
+        }
+      };
+
+      SliderTimelineView.prototype._renderCurrentPointer = function (layoutInfo, group, axis, timelineModel) {
+        var data = timelineModel.getData();
+        var currentIndex = timelineModel.getCurrentIndex();
+        var pointerModel = data.getItemModel(currentIndex).getModel('checkpointStyle');
+        var me = this;
+        var callback = {
+          onCreate: function (pointer) {
+            pointer.draggable = true;
+            pointer.drift = bind(me._handlePointerDrag, me);
+            pointer.ondragend = bind(me._handlePointerDragend, me);
+            pointerMoveTo(pointer, me._progressLine, currentIndex, axis, timelineModel, true);
+          },
+          onUpdate: function (pointer) {
+            pointerMoveTo(pointer, me._progressLine, currentIndex, axis, timelineModel);
+          }
+        }; // Reuse when exists, for animation and drag.
+
+        this._currentPointer = giveSymbol(pointerModel, pointerModel, this._mainGroup, {}, this._currentPointer, callback);
+      };
+
+      SliderTimelineView.prototype._handlePlayClick = function (nextState) {
+        this._clearTimer();
+
+        this.api.dispatchAction({
+          type: 'timelinePlayChange',
+          playState: nextState,
+          from: this.uid
+        });
+      };
+
+      SliderTimelineView.prototype._handlePointerDrag = function (dx, dy, e) {
+        this._clearTimer();
+
+        this._pointerChangeTimeline([e.offsetX, e.offsetY]);
+      };
+
+      SliderTimelineView.prototype._handlePointerDragend = function (e) {
+        this._pointerChangeTimeline([e.offsetX, e.offsetY], true);
+      };
+
+      SliderTimelineView.prototype._pointerChangeTimeline = function (mousePos, trigger) {
+        var toCoord = this._toAxisCoord(mousePos)[0];
+
+        var axis = this._axis;
+        var axisExtent = asc(axis.getExtent().slice());
+        toCoord > axisExtent[1] && (toCoord = axisExtent[1]);
+        toCoord < axisExtent[0] && (toCoord = axisExtent[0]);
+        this._currentPointer.x = toCoord;
+
+        this._currentPointer.markRedraw();
+
+        this._progressLine.shape.x2 = toCoord;
+
+        this._progressLine.dirty();
+
+        var targetDataIndex = this._findNearestTick(toCoord);
+
+        var timelineModel = this.model;
+
+        if (trigger || targetDataIndex !== timelineModel.getCurrentIndex() && timelineModel.get('realtime')) {
+          this._changeTimeline(targetDataIndex);
+        }
+      };
+
+      SliderTimelineView.prototype._doPlayStop = function () {
+        var _this = this;
+
+        this._clearTimer();
+
+        if (this.model.getPlayState()) {
+          this._timer = setTimeout(function () {
+            // Do not cache
+            var timelineModel = _this.model;
+
+            _this._changeTimeline(timelineModel.getCurrentIndex() + (timelineModel.get('rewind', true) ? -1 : 1));
+          }, this.model.get('playInterval'));
+        }
+      };
+
+      SliderTimelineView.prototype._toAxisCoord = function (vertex) {
+        var trans = this._mainGroup.getLocalTransform();
+
+        return applyTransform$1(vertex, trans, true);
+      };
+
+      SliderTimelineView.prototype._findNearestTick = function (axisCoord) {
+        var data = this.model.getData();
+        var dist = Infinity;
+        var targetDataIndex;
+        var axis = this._axis;
+        data.each(['value'], function (value, dataIndex) {
+          var coord = axis.dataToCoord(value);
+          var d = Math.abs(coord - axisCoord);
+
+          if (d < dist) {
+            dist = d;
+            targetDataIndex = dataIndex;
+          }
+        });
+        return targetDataIndex;
+      };
+
+      SliderTimelineView.prototype._clearTimer = function () {
+        if (this._timer) {
+          clearTimeout(this._timer);
+          this._timer = null;
+        }
+      };
+
+      SliderTimelineView.prototype._changeTimeline = function (nextIndex) {
+        var currentIndex = this.model.getCurrentIndex();
+
+        if (nextIndex === '+') {
+          nextIndex = currentIndex + 1;
+        } else if (nextIndex === '-') {
+          nextIndex = currentIndex - 1;
+        }
+
+        this.api.dispatchAction({
+          type: 'timelineChange',
+          currentIndex: nextIndex,
+          from: this.uid
+        });
+      };
+
+      SliderTimelineView.prototype._updateTicksStatus = function () {
+        var currentIndex = this.model.getCurrentIndex();
+        var tickSymbols = this._tickSymbols;
+        var tickLabels = this._tickLabels;
+
+        if (tickSymbols) {
+          for (var i = 0; i < tickSymbols.length; i++) {
+            tickSymbols && tickSymbols[i] && tickSymbols[i].toggleState('progress', i < currentIndex);
+          }
+        }
+
+        if (tickLabels) {
+          for (var i = 0; i < tickLabels.length; i++) {
+            tickLabels && tickLabels[i] && tickLabels[i].toggleState('progress', labelDataIndexStore(tickLabels[i]).dataIndex <= currentIndex);
+          }
+        }
+      };
+
+      SliderTimelineView.type = 'timeline.slider';
+      return SliderTimelineView;
+    }(TimelineView);
+
+    function createScaleByModel$1(model, axisType) {
+      axisType = axisType || model.get('type');
+
+      if (axisType) {
+        switch (axisType) {
+          // Buildin scale
+          case 'category':
+            return new OrdinalScale({
+              ordinalMeta: model.getCategories(),
+              extent: [Infinity, -Infinity]
+            });
+
+          case 'time':
+            return new TimeScale({
+              locale: model.ecModel.getLocaleModel(),
+              useUTC: model.ecModel.get('useUTC')
+            });
+
+          default:
+            // default to be value
+            return new IntervalScale();
+        }
+      }
+    }
+
+    function getViewRect$5(model, api) {
+      return getLayoutRect(model.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      }, model.get('padding'));
+    }
+
+    function makeControlIcon(timelineModel, objPath, rect, opts) {
+      var style = opts.style;
+      var icon = createIcon(timelineModel.get(['controlStyle', objPath]), opts || {}, new BoundingRect(rect[0], rect[1], rect[2], rect[3])); // TODO createIcon won't use style in opt.
+
+      if (style) {
+        icon.setStyle(style);
+      }
+
+      return icon;
+    }
+    /**
+     * Create symbol or update symbol
+     * opt: basic position and event handlers
+     */
+
+
+    function giveSymbol(hostModel, itemStyleModel, group, opt, symbol, callback) {
+      var color = itemStyleModel.get('color');
+
+      if (!symbol) {
+        var symbolType = hostModel.get('symbol');
+        symbol = createSymbol(symbolType, -1, -1, 2, 2, color);
+        symbol.setStyle('strokeNoScale', true);
+        group.add(symbol);
+        callback && callback.onCreate(symbol);
+      } else {
+        symbol.setColor(color);
+        group.add(symbol); // Group may be new, also need to add.
+
+        callback && callback.onUpdate(symbol);
+      } // Style
+
+
+      var itemStyle = itemStyleModel.getItemStyle(['color']);
+      symbol.setStyle(itemStyle); // Transform and events.
+
+      opt = merge({
+        rectHover: true,
+        z2: 100
+      }, opt, true);
+      var symbolSize = hostModel.get('symbolSize');
+      symbolSize = symbolSize instanceof Array ? symbolSize.slice() : [+symbolSize, +symbolSize];
+      opt.scaleX = symbolSize[0] / 2;
+      opt.scaleY = symbolSize[1] / 2;
+      var symbolOffset = hostModel.get('symbolOffset');
+
+      if (symbolOffset) {
+        opt.x = opt.x || 0;
+        opt.y = opt.y || 0;
+        opt.x += parsePercent$1(symbolOffset[0], symbolSize[0]);
+        opt.y += parsePercent$1(symbolOffset[1], symbolSize[1]);
+      }
+
+      var symbolRotate = hostModel.get('symbolRotate');
+      opt.rotation = (symbolRotate || 0) * Math.PI / 180 || 0;
+      symbol.attr(opt); // FIXME
+      // (1) When symbol.style.strokeNoScale is true and updateTransform is not performed,
+      // getBoundingRect will return wrong result.
+      // (This is supposed to be resolved in zrender, but it is a little difficult to
+      // leverage performance and auto updateTransform)
+      // (2) All of ancesters of symbol do not scale, so we can just updateTransform symbol.
+
+      symbol.updateTransform();
+      return symbol;
+    }
+
+    function pointerMoveTo(pointer, progressLine, dataIndex, axis, timelineModel, noAnimation) {
+      if (pointer.dragging) {
+        return;
+      }
+
+      var pointerModel = timelineModel.getModel('checkpointStyle');
+      var toCoord = axis.dataToCoord(timelineModel.getData().get('value', dataIndex));
+
+      if (noAnimation || !pointerModel.get('animation', true)) {
+        pointer.attr({
+          x: toCoord,
+          y: 0
+        });
+        progressLine && progressLine.attr({
+          shape: {
+            x2: toCoord
+          }
+        });
+      } else {
+        var animationCfg = {
+          duration: pointerModel.get('animationDuration', true),
+          easing: pointerModel.get('animationEasing', true)
+        };
+        pointer.stopAnimation(null, true);
+        pointer.animateTo({
+          x: toCoord,
+          y: 0
+        }, animationCfg);
+        progressLine && progressLine.animateTo({
+          shape: {
+            x2: toCoord
+          }
+        }, animationCfg);
+      }
+    }
+
+    function installTimelineAction(registers) {
+      registers.registerAction({
+        type: 'timelineChange',
+        event: 'timelineChanged',
+        update: 'prepareAndUpdate'
+      }, function (payload, ecModel) {
+        var timelineModel = ecModel.getComponent('timeline');
+
+        if (timelineModel && payload.currentIndex != null) {
+          timelineModel.setCurrentIndex(payload.currentIndex);
+
+          if (!timelineModel.get('loop', true) && timelineModel.isIndexMax()) {
+            timelineModel.setPlayState(false);
+          }
+        } // Set normalized currentIndex to payload.
+
+
+        ecModel.resetOption('timeline', {
+          replaceMerge: timelineModel.get('replaceMerge', true)
+        });
+        return defaults({
+          currentIndex: timelineModel.option.currentIndex
+        }, payload);
+      });
+      registers.registerAction({
+        type: 'timelinePlayChange',
+        event: 'timelinePlayChanged',
+        update: 'update'
+      }, function (payload, ecModel) {
+        var timelineModel = ecModel.getComponent('timeline');
+
+        if (timelineModel && payload.playState != null) {
+          timelineModel.setPlayState(payload.playState);
+        }
+      });
+    }
+
+    function timelinePreprocessor(option) {
+      var timelineOpt = option && option.timeline;
+
+      if (!isArray(timelineOpt)) {
+        timelineOpt = timelineOpt ? [timelineOpt] : [];
+      }
+
+      each(timelineOpt, function (opt) {
+        if (!opt) {
+          return;
+        }
+
+        compatibleEC2(opt);
+      });
+    }
+
+    function compatibleEC2(opt) {
+      var type = opt.type;
+      var ec2Types = {
+        'number': 'value',
+        'time': 'time'
+      }; // Compatible with ec2
+
+      if (ec2Types[type]) {
+        opt.axisType = ec2Types[type];
+        delete opt.type;
+      }
+
+      transferItem(opt);
+
+      if (has(opt, 'controlPosition')) {
+        var controlStyle = opt.controlStyle || (opt.controlStyle = {});
+
+        if (!has(controlStyle, 'position')) {
+          controlStyle.position = opt.controlPosition;
+        }
+
+        if (controlStyle.position === 'none' && !has(controlStyle, 'show')) {
+          controlStyle.show = false;
+          delete controlStyle.position;
+        }
+
+        delete opt.controlPosition;
+      }
+
+      each(opt.data || [], function (dataItem) {
+        if (isObject(dataItem) && !isArray(dataItem)) {
+          if (!has(dataItem, 'value') && has(dataItem, 'name')) {
+            // In ec2, using name as value.
+            dataItem.value = dataItem.name;
+          }
+
+          transferItem(dataItem);
+        }
+      });
+    }
+
+    function transferItem(opt) {
+      var itemStyle = opt.itemStyle || (opt.itemStyle = {});
+      var itemStyleEmphasis = itemStyle.emphasis || (itemStyle.emphasis = {}); // Transfer label out
+
+      var label = opt.label || opt.label || {};
+      var labelNormal = label.normal || (label.normal = {});
+      var excludeLabelAttr = {
+        normal: 1,
+        emphasis: 1
+      };
+      each(label, function (value, name) {
+        if (!excludeLabelAttr[name] && !has(labelNormal, name)) {
+          labelNormal[name] = value;
+        }
+      });
+
+      if (itemStyleEmphasis.label && !has(label, 'emphasis')) {
+        label.emphasis = itemStyleEmphasis.label;
+        delete itemStyleEmphasis.label;
+      }
+    }
+
+    function has(obj, attr) {
+      return obj.hasOwnProperty(attr);
+    }
+
+    function install$D(registers) {
+      registers.registerComponentModel(SliderTimelineModel);
+      registers.registerComponentView(SliderTimelineView);
+      registers.registerSubTypeDefaulter('timeline', function () {
+        // Only slider now.
+        return 'slider';
+      });
+      installTimelineAction(registers);
+      registers.registerPreprocessor(timelinePreprocessor);
+    }
+
+    function fillLabel(opt) {
+      defaultEmphasis(opt, 'label', ['show']);
+    } // { [componentType]: MarkerModel }
+
+
+    var inner$i = makeInner();
+
+    var MarkerModel =
+    /** @class */
+    function (_super) {
+      __extends(MarkerModel, _super);
+
+      function MarkerModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkerModel.type;
+        /**
+         * If marker model is created by self from series
+         */
+
+        _this.createdBySelf = false;
+        return _this;
+      }
+      /**
+       * @overrite
+       */
+
+
+      MarkerModel.prototype.init = function (option, parentModel, ecModel) {
+        if ("development" !== 'production') {
+          if (this.type === 'marker') {
+            throw new Error('Marker component is abstract component. Use markLine, markPoint, markArea instead.');
+          }
+        }
+
+        this.mergeDefaultAndTheme(option, ecModel);
+
+        this._mergeOption(option, ecModel, false, true);
+      };
+
+      MarkerModel.prototype.isAnimationEnabled = function () {
+        if (env.node) {
+          return false;
+        }
+
+        var hostSeries = this.__hostSeries;
+        return this.getShallow('animation') && hostSeries && hostSeries.isAnimationEnabled();
+      };
+      /**
+       * @overrite
+       */
+
+
+      MarkerModel.prototype.mergeOption = function (newOpt, ecModel) {
+        this._mergeOption(newOpt, ecModel, false, false);
+      };
+
+      MarkerModel.prototype._mergeOption = function (newOpt, ecModel, createdBySelf, isInit) {
+        var componentType = this.mainType;
+
+        if (!createdBySelf) {
+          ecModel.eachSeries(function (seriesModel) {
+            // mainType can be markPoint, markLine, markArea
+            var markerOpt = seriesModel.get(this.mainType, true);
+            var markerModel = inner$i(seriesModel)[componentType];
+
+            if (!markerOpt || !markerOpt.data) {
+              inner$i(seriesModel)[componentType] = null;
+              return;
+            }
+
+            if (!markerModel) {
+              if (isInit) {
+                // Default label emphasis `position` and `show`
+                fillLabel(markerOpt);
+              }
+
+              each(markerOpt.data, function (item) {
+                // FIXME Overwrite fillLabel method ?
+                if (item instanceof Array) {
+                  fillLabel(item[0]);
+                  fillLabel(item[1]);
+                } else {
+                  fillLabel(item);
+                }
+              });
+              markerModel = this.createMarkerModelFromSeries(markerOpt, this, ecModel); // markerModel = new ImplementedMarkerModel(
+              //     markerOpt, this, ecModel
+              // );
+
+              extend(markerModel, {
+                mainType: this.mainType,
+                // Use the same series index and name
+                seriesIndex: seriesModel.seriesIndex,
+                name: seriesModel.name,
+                createdBySelf: true
+              });
+              markerModel.__hostSeries = seriesModel;
+            } else {
+              markerModel._mergeOption(markerOpt, ecModel, true);
+            }
+
+            inner$i(seriesModel)[componentType] = markerModel;
+          }, this);
+        }
+      };
+
+      MarkerModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+        var data = this.getData();
+        var value = this.getRawValue(dataIndex);
+        var itemName = data.getName(dataIndex);
+        return createTooltipMarkup('section', {
+          header: this.name,
+          blocks: [createTooltipMarkup('nameValue', {
+            name: itemName,
+            value: value,
+            noName: !itemName,
+            noValue: value == null
+          })]
+        });
+      };
+
+      MarkerModel.prototype.getData = function () {
+        return this._data;
+      };
+
+      MarkerModel.prototype.setData = function (data) {
+        this._data = data;
+      };
+
+      MarkerModel.getMarkerModelFromSeries = function (seriesModel, // Support three types of markers. Strict check.
+      componentType) {
+        return inner$i(seriesModel)[componentType];
+      };
+
+      MarkerModel.type = 'marker';
+      MarkerModel.dependencies = ['series', 'grid', 'polar', 'geo'];
+      return MarkerModel;
+    }(ComponentModel);
+
+    mixin(MarkerModel, DataFormatMixin.prototype);
+
+    var MarkPointModel =
+    /** @class */
+    function (_super) {
+      __extends(MarkPointModel, _super);
+
+      function MarkPointModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkPointModel.type;
+        return _this;
+      }
+
+      MarkPointModel.prototype.createMarkerModelFromSeries = function (markerOpt, masterMarkerModel, ecModel) {
+        return new MarkPointModel(markerOpt, masterMarkerModel, ecModel);
+      };
+
+      MarkPointModel.type = 'markPoint';
+      MarkPointModel.defaultOption = {
+        zlevel: 0,
+        z: 5,
+        symbol: 'pin',
+        symbolSize: 50,
+        //symbolRotate: 0,
+        //symbolOffset: [0, 0]
+        tooltip: {
+          trigger: 'item'
+        },
+        label: {
+          show: true,
+          position: 'inside'
+        },
+        itemStyle: {
+          borderWidth: 2
+        },
+        emphasis: {
+          label: {
+            show: true
+          }
+        }
+      };
+      return MarkPointModel;
+    }(MarkerModel);
+
+    function hasXOrY(item) {
+      return !(isNaN(parseFloat(item.x)) && isNaN(parseFloat(item.y)));
+    }
+
+    function hasXAndY(item) {
+      return !isNaN(parseFloat(item.x)) && !isNaN(parseFloat(item.y));
+    } // Make it simple, do not visit all stacked value to count precision.
+    // function getPrecision(data, valueAxisDim, dataIndex) {
+    //     let precision = -1;
+    //     let stackedDim = data.mapDimension(valueAxisDim);
+    //     do {
+    //         precision = Math.max(
+    //             numberUtil.getPrecision(data.get(stackedDim, dataIndex)),
+    //             precision
+    //         );
+    //         let stackedOnSeries = data.getCalculationInfo('stackedOnSeries');
+    //         if (stackedOnSeries) {
+    //             let byValue = data.get(data.getCalculationInfo('stackedByDimension'), dataIndex);
+    //             data = stackedOnSeries.getData();
+    //             dataIndex = data.indexOf(data.getCalculationInfo('stackedByDimension'), byValue);
+    //             stackedDim = data.getCalculationInfo('stackedDimension');
+    //         }
+    //         else {
+    //             data = null;
+    //         }
+    //     } while (data);
+    //     return precision;
+    // }
+
+
+    function markerTypeCalculatorWithExtent(markerType, data, otherDataDim, targetDataDim, otherCoordIndex, targetCoordIndex) {
+      var coordArr = [];
+      var stacked = isDimensionStacked(data, targetDataDim
+      /*, otherDataDim*/
+      );
+      var calcDataDim = stacked ? data.getCalculationInfo('stackResultDimension') : targetDataDim;
+      var value = numCalculate(data, calcDataDim, markerType);
+      var dataIndex = data.indicesOfNearest(calcDataDim, value)[0];
+      coordArr[otherCoordIndex] = data.get(otherDataDim, dataIndex);
+      coordArr[targetCoordIndex] = data.get(calcDataDim, dataIndex);
+      var coordArrValue = data.get(targetDataDim, dataIndex); // Make it simple, do not visit all stacked value to count precision.
+
+      var precision = getPrecision(data.get(targetDataDim, dataIndex));
+      precision = Math.min(precision, 20);
+
+      if (precision >= 0) {
+        coordArr[targetCoordIndex] = +coordArr[targetCoordIndex].toFixed(precision);
+      }
+
+      return [coordArr, coordArrValue];
+    } // TODO Specified percent
+
+
+    var markerTypeCalculator = {
+      min: curry(markerTypeCalculatorWithExtent, 'min'),
+      max: curry(markerTypeCalculatorWithExtent, 'max'),
+      average: curry(markerTypeCalculatorWithExtent, 'average'),
+      median: curry(markerTypeCalculatorWithExtent, 'median')
+    };
+    /**
+     * Transform markPoint data item to format used in List by do the following
+     * 1. Calculate statistic like `max`, `min`, `average`
+     * 2. Convert `item.xAxis`, `item.yAxis` to `item.coord` array
+     * @param  {module:echarts/model/Series} seriesModel
+     * @param  {module:echarts/coord/*} [coordSys]
+     * @param  {Object} item
+     * @return {Object}
+     */
+
+    function dataTransform(seriesModel, item) {
+      var data = seriesModel.getData();
+      var coordSys = seriesModel.coordinateSystem; // 1. If not specify the position with pixel directly
+      // 2. If `coord` is not a data array. Which uses `xAxis`,
+      // `yAxis` to specify the coord on each dimension
+      // parseFloat first because item.x and item.y can be percent string like '20%'
+
+      if (item && !hasXAndY(item) && !isArray(item.coord) && coordSys) {
+        var dims = coordSys.dimensions;
+        var axisInfo = getAxisInfo$1(item, data, coordSys, seriesModel); // Clone the option
+        // Transform the properties xAxis, yAxis, radiusAxis, angleAxis, geoCoord to value
+
+        item = clone(item);
+
+        if (item.type && markerTypeCalculator[item.type] && axisInfo.baseAxis && axisInfo.valueAxis) {
+          var otherCoordIndex = indexOf(dims, axisInfo.baseAxis.dim);
+          var targetCoordIndex = indexOf(dims, axisInfo.valueAxis.dim);
+          var coordInfo = markerTypeCalculator[item.type](data, axisInfo.baseDataDim, axisInfo.valueDataDim, otherCoordIndex, targetCoordIndex);
+          item.coord = coordInfo[0]; // Force to use the value of calculated value.
+          // let item use the value without stack.
+
+          item.value = coordInfo[1];
+        } else {
+          // FIXME Only has one of xAxis and yAxis.
+          var coord = [item.xAxis != null ? item.xAxis : item.radiusAxis, item.yAxis != null ? item.yAxis : item.angleAxis]; // Each coord support max, min, average
+
+          for (var i = 0; i < 2; i++) {
+            if (markerTypeCalculator[coord[i]]) {
+              coord[i] = numCalculate(data, data.mapDimension(dims[i]), coord[i]);
+            }
+          }
+
+          item.coord = coord;
+        }
+      }
+
+      return item;
+    }
+    function getAxisInfo$1(item, data, coordSys, seriesModel) {
+      var ret = {};
+
+      if (item.valueIndex != null || item.valueDim != null) {
+        ret.valueDataDim = item.valueIndex != null ? data.getDimension(item.valueIndex) : item.valueDim;
+        ret.valueAxis = coordSys.getAxis(dataDimToCoordDim(seriesModel, ret.valueDataDim));
+        ret.baseAxis = coordSys.getOtherAxis(ret.valueAxis);
+        ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+      } else {
+        ret.baseAxis = seriesModel.getBaseAxis();
+        ret.valueAxis = coordSys.getOtherAxis(ret.baseAxis);
+        ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+        ret.valueDataDim = data.mapDimension(ret.valueAxis.dim);
+      }
+
+      return ret;
+    }
+
+    function dataDimToCoordDim(seriesModel, dataDim) {
+      var data = seriesModel.getData();
+      var dimensions = data.dimensions;
+      dataDim = data.getDimension(dataDim);
+
+      for (var i = 0; i < dimensions.length; i++) {
+        var dimItem = data.getDimensionInfo(dimensions[i]);
+
+        if (dimItem.name === dataDim) {
+          return dimItem.coordDim;
+        }
+      }
+    }
+    /**
+     * Filter data which is out of coordinateSystem range
+     * [dataFilter description]
+     */
+
+
+    function dataFilter$1( // Currently only polar and cartesian has containData.
+    coordSys, item) {
+      // Alwalys return true if there is no coordSys
+      return coordSys && coordSys.containData && item.coord && !hasXOrY(item) ? coordSys.containData(item.coord) : true;
+    }
+    function dimValueGetter(item, dimName, dataIndex, dimIndex) {
+      // x, y, radius, angle
+      if (dimIndex < 2) {
+        return item.coord && item.coord[dimIndex];
+      }
+
+      return item.value;
+    }
+    function numCalculate(data, valueDataDim, type) {
+      if (type === 'average') {
+        var sum_1 = 0;
+        var count_1 = 0;
+        data.each(valueDataDim, function (val, idx) {
+          if (!isNaN(val)) {
+            sum_1 += val;
+            count_1++;
+          }
+        });
+        return sum_1 / count_1;
+      } else if (type === 'median') {
+        return data.getMedian(valueDataDim);
+      } else {
+        // max & min
+        return data.getDataExtent(valueDataDim)[type === 'max' ? 1 : 0];
+      }
+    }
+
+    var inner$j = makeInner();
+
+    var MarkerView =
+    /** @class */
+    function (_super) {
+      __extends(MarkerView, _super);
+
+      function MarkerView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkerView.type;
+        return _this;
+      }
+
+      MarkerView.prototype.init = function () {
+        this.markerGroupMap = createHashMap();
+      };
+
+      MarkerView.prototype.render = function (markerModel, ecModel, api) {
+        var _this = this;
+
+        var markerGroupMap = this.markerGroupMap;
+        markerGroupMap.each(function (item) {
+          inner$j(item).keep = false;
+        });
+        ecModel.eachSeries(function (seriesModel) {
+          var markerModel = MarkerModel.getMarkerModelFromSeries(seriesModel, _this.type);
+          markerModel && _this.renderSeries(seriesModel, markerModel, ecModel, api);
+        });
+        markerGroupMap.each(function (item) {
+          !inner$j(item).keep && _this.group.remove(item.group);
+        });
+      };
+
+      MarkerView.prototype.markKeep = function (drawGroup) {
+        inner$j(drawGroup).keep = true;
+      };
+
+      MarkerView.prototype.blurSeries = function (seriesModelList) {
+        var _this = this;
+
+        each(seriesModelList, function (seriesModel) {
+          var markerModel = MarkerModel.getMarkerModelFromSeries(seriesModel, _this.type);
+
+          if (markerModel) {
+            var data = markerModel.getData();
+            data.eachItemGraphicEl(function (el) {
+              if (el) {
+                enterBlur(el);
+              }
+            });
+          }
+        });
+      };
+
+      MarkerView.type = 'marker';
+      return MarkerView;
+    }(ComponentView);
+
+    function updateMarkerLayout(mpData, seriesModel, api) {
+      var coordSys = seriesModel.coordinateSystem;
+      mpData.each(function (idx) {
+        var itemModel = mpData.getItemModel(idx);
+        var point;
+        var xPx = parsePercent$1(itemModel.get('x'), api.getWidth());
+        var yPx = parsePercent$1(itemModel.get('y'), api.getHeight());
+
+        if (!isNaN(xPx) && !isNaN(yPx)) {
+          point = [xPx, yPx];
+        } // Chart like bar may have there own marker positioning logic
+        else if (seriesModel.getMarkerPosition) {
+            // Use the getMarkerPoisition
+            point = seriesModel.getMarkerPosition(mpData.getValues(mpData.dimensions, idx));
+          } else if (coordSys) {
+            var x = mpData.get(coordSys.dimensions[0], idx);
+            var y = mpData.get(coordSys.dimensions[1], idx);
+            point = coordSys.dataToPoint([x, y]);
+          } // Use x, y if has any
+
+
+        if (!isNaN(xPx)) {
+          point[0] = xPx;
+        }
+
+        if (!isNaN(yPx)) {
+          point[1] = yPx;
+        }
+
+        mpData.setItemLayout(idx, point);
+      });
+    }
+
+    var MarkPointView =
+    /** @class */
+    function (_super) {
+      __extends(MarkPointView, _super);
+
+      function MarkPointView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkPointView.type;
+        return _this;
+      }
+
+      MarkPointView.prototype.updateTransform = function (markPointModel, ecModel, api) {
+        ecModel.eachSeries(function (seriesModel) {
+          var mpModel = MarkerModel.getMarkerModelFromSeries(seriesModel, 'markPoint');
+
+          if (mpModel) {
+            updateMarkerLayout(mpModel.getData(), seriesModel, api);
+            this.markerGroupMap.get(seriesModel.id).updateLayout();
+          }
+        }, this);
+      };
+
+      MarkPointView.prototype.renderSeries = function (seriesModel, mpModel, ecModel, api) {
+        var coordSys = seriesModel.coordinateSystem;
+        var seriesId = seriesModel.id;
+        var seriesData = seriesModel.getData();
+        var symbolDrawMap = this.markerGroupMap;
+        var symbolDraw = symbolDrawMap.get(seriesId) || symbolDrawMap.set(seriesId, new SymbolDraw());
+        var mpData = createList$1(coordSys, seriesModel, mpModel); // FIXME
+
+        mpModel.setData(mpData);
+        updateMarkerLayout(mpModel.getData(), seriesModel, api);
+        mpData.each(function (idx) {
+          var itemModel = mpData.getItemModel(idx);
+          var symbol = itemModel.getShallow('symbol');
+          var symbolSize = itemModel.getShallow('symbolSize');
+          var symbolRotate = itemModel.getShallow('symbolRotate');
+
+          if (isFunction(symbol) || isFunction(symbolSize) || isFunction(symbolRotate)) {
+            var rawIdx = mpModel.getRawValue(idx);
+            var dataParams = mpModel.getDataParams(idx);
+
+            if (isFunction(symbol)) {
+              symbol = symbol(rawIdx, dataParams);
+            }
+
+            if (isFunction(symbolSize)) {
+              // FIXME 这里不兼容 ECharts 2.x，2.x 貌似参数是整个数据？
+              symbolSize = symbolSize(rawIdx, dataParams);
+            }
+
+            if (isFunction(symbolRotate)) {
+              symbolRotate = symbolRotate(rawIdx, dataParams);
+            }
+          }
+
+          var style = itemModel.getModel('itemStyle').getItemStyle();
+          var color = getVisualFromData(seriesData, 'color');
+
+          if (!style.fill) {
+            style.fill = color;
+          }
+
+          mpData.setItemVisual(idx, {
+            symbol: symbol,
+            symbolSize: symbolSize,
+            symbolRotate: symbolRotate,
+            style: style
+          });
+        }); // TODO Text are wrong
+
+        symbolDraw.updateData(mpData);
+        this.group.add(symbolDraw.group); // Set host model for tooltip
+        // FIXME
+
+        mpData.eachItemGraphicEl(function (el) {
+          el.traverse(function (child) {
+            getECData(child).dataModel = mpModel;
+          });
+        });
+        this.markKeep(symbolDraw);
+        symbolDraw.group.silent = mpModel.get('silent') || seriesModel.get('silent');
+      };
+
+      MarkPointView.type = 'markPoint';
+      return MarkPointView;
+    }(MarkerView);
+
+    function createList$1(coordSys, seriesModel, mpModel) {
+      var coordDimsInfos;
+
+      if (coordSys) {
+        coordDimsInfos = map(coordSys && coordSys.dimensions, function (coordDim) {
+          var info = seriesModel.getData().getDimensionInfo(seriesModel.getData().mapDimension(coordDim)) || {}; // In map series data don't have lng and lat dimension. Fallback to same with coordSys
+
+          return defaults({
+            name: coordDim
+          }, info);
+        });
+      } else {
+        coordDimsInfos = [{
+          name: 'value',
+          type: 'float'
+        }];
+      }
+
+      var mpData = new List(coordDimsInfos, mpModel);
+      var dataOpt = map(mpModel.get('data'), curry(dataTransform, seriesModel));
+
+      if (coordSys) {
+        dataOpt = filter(dataOpt, curry(dataFilter$1, coordSys));
+      }
+
+      mpData.initData(dataOpt, null, coordSys ? dimValueGetter : function (item) {
+        return item.value;
+      });
+      return mpData;
+    }
+
+    function install$E(registers) {
+      registers.registerComponentModel(MarkPointModel);
+      registers.registerComponentView(MarkPointView);
+      registers.registerPreprocessor(function (opt) {
+        // Make sure markPoint component is enabled
+        opt.markPoint = opt.markPoint || {};
+      });
+    }
+
+    var MarkLineModel =
+    /** @class */
+    function (_super) {
+      __extends(MarkLineModel, _super);
+
+      function MarkLineModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkLineModel.type;
+        return _this;
+      }
+
+      MarkLineModel.prototype.createMarkerModelFromSeries = function (markerOpt, masterMarkerModel, ecModel) {
+        return new MarkLineModel(markerOpt, masterMarkerModel, ecModel);
+      };
+
+      MarkLineModel.type = 'markLine';
+      MarkLineModel.defaultOption = {
+        zlevel: 0,
+        z: 5,
+        symbol: ['circle', 'arrow'],
+        symbolSize: [8, 16],
+        //symbolRotate: 0,
+        precision: 2,
+        tooltip: {
+          trigger: 'item'
+        },
+        label: {
+          show: true,
+          position: 'end',
+          distance: 5
+        },
+        lineStyle: {
+          type: 'dashed'
+        },
+        emphasis: {
+          label: {
+            show: true
+          },
+          lineStyle: {
+            width: 3
+          }
+        },
+        animationEasing: 'linear'
+      };
+      return MarkLineModel;
+    }(MarkerModel);
+
+    var inner$k = makeInner();
+
+    var markLineTransform = function (seriesModel, coordSys, mlModel, item) {
+      var data = seriesModel.getData();
+      var itemArray;
+
+      if (!isArray(item)) {
+        // Special type markLine like 'min', 'max', 'average', 'median'
+        var mlType = item.type;
+
+        if (mlType === 'min' || mlType === 'max' || mlType === 'average' || mlType === 'median' // In case
+        // data: [{
+        //   yAxis: 10
+        // }]
+        || item.xAxis != null || item.yAxis != null) {
+          var valueAxis = void 0;
+          var value = void 0;
+
+          if (item.yAxis != null || item.xAxis != null) {
+            valueAxis = coordSys.getAxis(item.yAxis != null ? 'y' : 'x');
+            value = retrieve(item.yAxis, item.xAxis);
+          } else {
+            var axisInfo = getAxisInfo$1(item, data, coordSys, seriesModel);
+            valueAxis = axisInfo.valueAxis;
+            var valueDataDim = getStackedDimension(data, axisInfo.valueDataDim);
+            value = numCalculate(data, valueDataDim, mlType);
+          }
+
+          var valueIndex = valueAxis.dim === 'x' ? 0 : 1;
+          var baseIndex = 1 - valueIndex; // Normized to 2d data with start and end point
+
+          var mlFrom = clone(item);
+          var mlTo = {
+            coord: []
+          };
+          mlFrom.type = null;
+          mlFrom.coord = [];
+          mlFrom.coord[baseIndex] = -Infinity;
+          mlTo.coord[baseIndex] = Infinity;
+          var precision = mlModel.get('precision');
+
+          if (precision >= 0 && typeof value === 'number') {
+            value = +value.toFixed(Math.min(precision, 20));
+          }
+
+          mlFrom.coord[valueIndex] = mlTo.coord[valueIndex] = value;
+          itemArray = [mlFrom, mlTo, {
+            type: mlType,
+            valueIndex: item.valueIndex,
+            // Force to use the value of calculated value.
+            value: value
+          }];
+        } else {
+          // Invalid data
+          if ("development" !== 'production') {
+            logError('Invalid markLine data.');
+          }
+
+          itemArray = [];
+        }
+      } else {
+        itemArray = item;
+      }
+
+      var normalizedItem = [dataTransform(seriesModel, itemArray[0]), dataTransform(seriesModel, itemArray[1]), extend({}, itemArray[2])]; // Avoid line data type is extended by from(to) data type
+
+      normalizedItem[2].type = normalizedItem[2].type || null; // Merge from option and to option into line option
+
+      merge(normalizedItem[2], normalizedItem[0]);
+      merge(normalizedItem[2], normalizedItem[1]);
+      return normalizedItem;
+    };
+
+    function isInifinity(val) {
+      return !isNaN(val) && !isFinite(val);
+    } // If a markLine has one dim
+
+
+    function ifMarkLineHasOnlyDim(dimIndex, fromCoord, toCoord, coordSys) {
+      var otherDimIndex = 1 - dimIndex;
+      var dimName = coordSys.dimensions[dimIndex];
+      return isInifinity(fromCoord[otherDimIndex]) && isInifinity(toCoord[otherDimIndex]) && fromCoord[dimIndex] === toCoord[dimIndex] && coordSys.getAxis(dimName).containData(fromCoord[dimIndex]);
+    }
+
+    function markLineFilter(coordSys, item) {
+      if (coordSys.type === 'cartesian2d') {
+        var fromCoord = item[0].coord;
+        var toCoord = item[1].coord; // In case
+        // {
+        //  markLine: {
+        //    data: [{ yAxis: 2 }]
+        //  }
+        // }
+
+        if (fromCoord && toCoord && (ifMarkLineHasOnlyDim(1, fromCoord, toCoord, coordSys) || ifMarkLineHasOnlyDim(0, fromCoord, toCoord, coordSys))) {
+          return true;
+        }
+      }
+
+      return dataFilter$1(coordSys, item[0]) && dataFilter$1(coordSys, item[1]);
+    }
+
+    function updateSingleMarkerEndLayout(data, idx, isFrom, seriesModel, api) {
+      var coordSys = seriesModel.coordinateSystem;
+      var itemModel = data.getItemModel(idx);
+      var point;
+      var xPx = parsePercent$1(itemModel.get('x'), api.getWidth());
+      var yPx = parsePercent$1(itemModel.get('y'), api.getHeight());
+
+      if (!isNaN(xPx) && !isNaN(yPx)) {
+        point = [xPx, yPx];
+      } else {
+        // Chart like bar may have there own marker positioning logic
+        if (seriesModel.getMarkerPosition) {
+          // Use the getMarkerPoisition
+          point = seriesModel.getMarkerPosition(data.getValues(data.dimensions, idx));
+        } else {
+          var dims = coordSys.dimensions;
+          var x = data.get(dims[0], idx);
+          var y = data.get(dims[1], idx);
+          point = coordSys.dataToPoint([x, y]);
+        } // Expand line to the edge of grid if value on one axis is Inifnity
+        // In case
+        //  markLine: {
+        //    data: [{
+        //      yAxis: 2
+        //      // or
+        //      type: 'average'
+        //    }]
+        //  }
+
+
+        if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+          // TODO: TYPE ts@4.1 may still infer it as Axis instead of Axis2D. Not sure if it's a bug
+          var xAxis = coordSys.getAxis('x');
+          var yAxis = coordSys.getAxis('y');
+          var dims = coordSys.dimensions;
+
+          if (isInifinity(data.get(dims[0], idx))) {
+            point[0] = xAxis.toGlobalCoord(xAxis.getExtent()[isFrom ? 0 : 1]);
+          } else if (isInifinity(data.get(dims[1], idx))) {
+            point[1] = yAxis.toGlobalCoord(yAxis.getExtent()[isFrom ? 0 : 1]);
+          }
+        } // Use x, y if has any
+
+
+        if (!isNaN(xPx)) {
+          point[0] = xPx;
+        }
+
+        if (!isNaN(yPx)) {
+          point[1] = yPx;
+        }
+      }
+
+      data.setItemLayout(idx, point);
+    }
+
+    var MarkLineView =
+    /** @class */
+    function (_super) {
+      __extends(MarkLineView, _super);
+
+      function MarkLineView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkLineView.type;
+        return _this;
+      }
+
+      MarkLineView.prototype.updateTransform = function (markLineModel, ecModel, api) {
+        ecModel.eachSeries(function (seriesModel) {
+          var mlModel = MarkerModel.getMarkerModelFromSeries(seriesModel, 'markLine');
+
+          if (mlModel) {
+            var mlData_1 = mlModel.getData();
+            var fromData_1 = inner$k(mlModel).from;
+            var toData_1 = inner$k(mlModel).to; // Update visual and layout of from symbol and to symbol
+
+            fromData_1.each(function (idx) {
+              updateSingleMarkerEndLayout(fromData_1, idx, true, seriesModel, api);
+              updateSingleMarkerEndLayout(toData_1, idx, false, seriesModel, api);
+            }); // Update layout of line
+
+            mlData_1.each(function (idx) {
+              mlData_1.setItemLayout(idx, [fromData_1.getItemLayout(idx), toData_1.getItemLayout(idx)]);
+            });
+            this.markerGroupMap.get(seriesModel.id).updateLayout();
+          }
+        }, this);
+      };
+
+      MarkLineView.prototype.renderSeries = function (seriesModel, mlModel, ecModel, api) {
+        var coordSys = seriesModel.coordinateSystem;
+        var seriesId = seriesModel.id;
+        var seriesData = seriesModel.getData();
+        var lineDrawMap = this.markerGroupMap;
+        var lineDraw = lineDrawMap.get(seriesId) || lineDrawMap.set(seriesId, new LineDraw());
+        this.group.add(lineDraw.group);
+        var mlData = createList$2(coordSys, seriesModel, mlModel);
+        var fromData = mlData.from;
+        var toData = mlData.to;
+        var lineData = mlData.line;
+        inner$k(mlModel).from = fromData;
+        inner$k(mlModel).to = toData; // Line data for tooltip and formatter
+
+        mlModel.setData(lineData);
+        var symbolType = mlModel.get('symbol');
+        var symbolSize = mlModel.get('symbolSize');
+
+        if (!isArray(symbolType)) {
+          symbolType = [symbolType, symbolType];
+        }
+
+        if (!isArray(symbolSize)) {
+          symbolSize = [symbolSize, symbolSize];
+        } // Update visual and layout of from symbol and to symbol
+
+
+        mlData.from.each(function (idx) {
+          updateDataVisualAndLayout(fromData, idx, true);
+          updateDataVisualAndLayout(toData, idx, false);
+        }); // Update visual and layout of line
+
+        lineData.each(function (idx) {
+          var lineStyle = lineData.getItemModel(idx).getModel('lineStyle').getLineStyle(); // lineData.setItemVisual(idx, {
+          //     color: lineColor || fromData.getItemVisual(idx, 'color')
+          // });
+
+          lineData.setItemLayout(idx, [fromData.getItemLayout(idx), toData.getItemLayout(idx)]);
+
+          if (lineStyle.stroke == null) {
+            lineStyle.stroke = fromData.getItemVisual(idx, 'style').fill;
+          }
+
+          lineData.setItemVisual(idx, {
+            fromSymbolRotate: fromData.getItemVisual(idx, 'symbolRotate'),
+            fromSymbolSize: fromData.getItemVisual(idx, 'symbolSize'),
+            fromSymbol: fromData.getItemVisual(idx, 'symbol'),
+            toSymbolRotate: toData.getItemVisual(idx, 'symbolRotate'),
+            toSymbolSize: toData.getItemVisual(idx, 'symbolSize'),
+            toSymbol: toData.getItemVisual(idx, 'symbol'),
+            style: lineStyle
+          });
+        });
+        lineDraw.updateData(lineData); // Set host model for tooltip
+        // FIXME
+
+        mlData.line.eachItemGraphicEl(function (el, idx) {
+          el.traverse(function (child) {
+            getECData(child).dataModel = mlModel;
+          });
+        });
+
+        function updateDataVisualAndLayout(data, idx, isFrom) {
+          var itemModel = data.getItemModel(idx);
+          updateSingleMarkerEndLayout(data, idx, isFrom, seriesModel, api);
+          var style = itemModel.getModel('itemStyle').getItemStyle();
+
+          if (style.fill == null) {
+            style.fill = getVisualFromData(seriesData, 'color');
+          }
+
+          data.setItemVisual(idx, {
+            symbolRotate: itemModel.get('symbolRotate'),
+            symbolSize: itemModel.get('symbolSize') || symbolSize[isFrom ? 0 : 1],
+            symbol: itemModel.get('symbol', true) || symbolType[isFrom ? 0 : 1],
+            style: style
+          });
+        }
+
+        this.markKeep(lineDraw);
+        lineDraw.group.silent = mlModel.get('silent') || seriesModel.get('silent');
+      };
+
+      MarkLineView.type = 'markLine';
+      return MarkLineView;
+    }(MarkerView);
+
+    function createList$2(coordSys, seriesModel, mlModel) {
+      var coordDimsInfos;
+
+      if (coordSys) {
+        coordDimsInfos = map(coordSys && coordSys.dimensions, function (coordDim) {
+          var info = seriesModel.getData().getDimensionInfo(seriesModel.getData().mapDimension(coordDim)) || {}; // In map series data don't have lng and lat dimension. Fallback to same with coordSys
+
+          return defaults({
+            name: coordDim
+          }, info);
+        });
+      } else {
+        coordDimsInfos = [{
+          name: 'value',
+          type: 'float'
+        }];
+      }
+
+      var fromData = new List(coordDimsInfos, mlModel);
+      var toData = new List(coordDimsInfos, mlModel); // No dimensions
+
+      var lineData = new List([], mlModel);
+      var optData = map(mlModel.get('data'), curry(markLineTransform, seriesModel, coordSys, mlModel));
+
+      if (coordSys) {
+        optData = filter(optData, curry(markLineFilter, coordSys));
+      }
+
+      var dimValueGetter$1 = coordSys ? dimValueGetter : function (item) {
+        return item.value;
+      };
+      fromData.initData(map(optData, function (item) {
+        return item[0];
+      }), null, dimValueGetter$1);
+      toData.initData(map(optData, function (item) {
+        return item[1];
+      }), null, dimValueGetter$1);
+      lineData.initData(map(optData, function (item) {
+        return item[2];
+      }));
+      lineData.hasItemOption = true;
+      return {
+        from: fromData,
+        to: toData,
+        line: lineData
+      };
+    }
+
+    function install$F(registers) {
+      registers.registerComponentModel(MarkLineModel);
+      registers.registerComponentView(MarkLineView);
+      registers.registerPreprocessor(function (opt) {
+        // Make sure markLine component is enabled
+        opt.markLine = opt.markLine || {};
+      });
+    }
+
+    var MarkAreaModel =
+    /** @class */
+    function (_super) {
+      __extends(MarkAreaModel, _super);
+
+      function MarkAreaModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkAreaModel.type;
+        return _this;
+      }
+
+      MarkAreaModel.prototype.createMarkerModelFromSeries = function (markerOpt, masterMarkerModel, ecModel) {
+        return new MarkAreaModel(markerOpt, masterMarkerModel, ecModel);
+      };
+
+      MarkAreaModel.type = 'markArea';
+      MarkAreaModel.defaultOption = {
+        zlevel: 0,
+        // PENDING
+        z: 1,
+        tooltip: {
+          trigger: 'item'
+        },
+        // markArea should fixed on the coordinate system
+        animation: false,
+        label: {
+          show: true,
+          position: 'top'
+        },
+        itemStyle: {
+          // color and borderColor default to use color from series
+          // color: 'auto'
+          // borderColor: 'auto'
+          borderWidth: 0
+        },
+        emphasis: {
+          label: {
+            show: true,
+            position: 'top'
+          }
+        }
+      };
+      return MarkAreaModel;
+    }(MarkerModel);
+
+    var inner$l = makeInner();
+
+    var markAreaTransform = function (seriesModel, coordSys, maModel, item) {
+      var lt = dataTransform(seriesModel, item[0]);
+      var rb = dataTransform(seriesModel, item[1]); // FIXME make sure lt is less than rb
+
+      var ltCoord = lt.coord;
+      var rbCoord = rb.coord;
+      ltCoord[0] = retrieve(ltCoord[0], -Infinity);
+      ltCoord[1] = retrieve(ltCoord[1], -Infinity);
+      rbCoord[0] = retrieve(rbCoord[0], Infinity);
+      rbCoord[1] = retrieve(rbCoord[1], Infinity); // Merge option into one
+
+      var result = mergeAll([{}, lt, rb]);
+      result.coord = [lt.coord, rb.coord];
+      result.x0 = lt.x;
+      result.y0 = lt.y;
+      result.x1 = rb.x;
+      result.y1 = rb.y;
+      return result;
+    };
+
+    function isInifinity$1(val) {
+      return !isNaN(val) && !isFinite(val);
+    } // If a markArea has one dim
+
+
+    function ifMarkAreaHasOnlyDim(dimIndex, fromCoord, toCoord, coordSys) {
+      var otherDimIndex = 1 - dimIndex;
+      return isInifinity$1(fromCoord[otherDimIndex]) && isInifinity$1(toCoord[otherDimIndex]);
+    }
+
+    function markAreaFilter(coordSys, item) {
+      var fromCoord = item.coord[0];
+      var toCoord = item.coord[1];
+
+      if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+        // In case
+        // {
+        //  markArea: {
+        //    data: [{ yAxis: 2 }]
+        //  }
+        // }
+        if (fromCoord && toCoord && (ifMarkAreaHasOnlyDim(1, fromCoord, toCoord) || ifMarkAreaHasOnlyDim(0, fromCoord, toCoord))) {
+          return true;
+        }
+      }
+
+      return dataFilter$1(coordSys, {
+        coord: fromCoord,
+        x: item.x0,
+        y: item.y0
+      }) || dataFilter$1(coordSys, {
+        coord: toCoord,
+        x: item.x1,
+        y: item.y1
+      });
+    } // dims can be ['x0', 'y0'], ['x1', 'y1'], ['x0', 'y1'], ['x1', 'y0']
+
+
+    function getSingleMarkerEndPoint(data, idx, dims, seriesModel, api) {
+      var coordSys = seriesModel.coordinateSystem;
+      var itemModel = data.getItemModel(idx);
+      var point;
+      var xPx = parsePercent$1(itemModel.get(dims[0]), api.getWidth());
+      var yPx = parsePercent$1(itemModel.get(dims[1]), api.getHeight());
+
+      if (!isNaN(xPx) && !isNaN(yPx)) {
+        point = [xPx, yPx];
+      } else {
+        // Chart like bar may have there own marker positioning logic
+        if (seriesModel.getMarkerPosition) {
+          // Use the getMarkerPoisition
+          point = seriesModel.getMarkerPosition(data.getValues(dims, idx));
+        } else {
+          var x = data.get(dims[0], idx);
+          var y = data.get(dims[1], idx);
+          var pt = [x, y];
+          coordSys.clampData && coordSys.clampData(pt, pt);
+          point = coordSys.dataToPoint(pt, true);
+        }
+
+        if (isCoordinateSystemType(coordSys, 'cartesian2d')) {
+          // TODO: TYPE ts@4.1 may still infer it as Axis instead of Axis2D. Not sure if it's a bug
+          var xAxis = coordSys.getAxis('x');
+          var yAxis = coordSys.getAxis('y');
+          var x = data.get(dims[0], idx);
+          var y = data.get(dims[1], idx);
+
+          if (isInifinity$1(x)) {
+            point[0] = xAxis.toGlobalCoord(xAxis.getExtent()[dims[0] === 'x0' ? 0 : 1]);
+          } else if (isInifinity$1(y)) {
+            point[1] = yAxis.toGlobalCoord(yAxis.getExtent()[dims[1] === 'y0' ? 0 : 1]);
+          }
+        } // Use x, y if has any
+
+
+        if (!isNaN(xPx)) {
+          point[0] = xPx;
+        }
+
+        if (!isNaN(yPx)) {
+          point[1] = yPx;
+        }
+      }
+
+      return point;
+    }
+
+    var dimPermutations = [['x0', 'y0'], ['x1', 'y0'], ['x1', 'y1'], ['x0', 'y1']];
+
+    var MarkAreaView =
+    /** @class */
+    function (_super) {
+      __extends(MarkAreaView, _super);
+
+      function MarkAreaView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = MarkAreaView.type;
+        return _this;
+      }
+
+      MarkAreaView.prototype.updateTransform = function (markAreaModel, ecModel, api) {
+        ecModel.eachSeries(function (seriesModel) {
+          var maModel = MarkerModel.getMarkerModelFromSeries(seriesModel, 'markArea');
+
+          if (maModel) {
+            var areaData_1 = maModel.getData();
+            areaData_1.each(function (idx) {
+              var points = map(dimPermutations, function (dim) {
+                return getSingleMarkerEndPoint(areaData_1, idx, dim, seriesModel, api);
+              }); // Layout
+
+              areaData_1.setItemLayout(idx, points);
+              var el = areaData_1.getItemGraphicEl(idx);
+              el.setShape('points', points);
+            });
+          }
+        }, this);
+      };
+
+      MarkAreaView.prototype.renderSeries = function (seriesModel, maModel, ecModel, api) {
+        var coordSys = seriesModel.coordinateSystem;
+        var seriesId = seriesModel.id;
+        var seriesData = seriesModel.getData();
+        var areaGroupMap = this.markerGroupMap;
+        var polygonGroup = areaGroupMap.get(seriesId) || areaGroupMap.set(seriesId, {
+          group: new Group()
+        });
+        this.group.add(polygonGroup.group);
+        this.markKeep(polygonGroup);
+        var areaData = createList$3(coordSys, seriesModel, maModel); // Line data for tooltip and formatter
+
+        maModel.setData(areaData); // Update visual and layout of line
+
+        areaData.each(function (idx) {
+          // Layout
+          var points = map(dimPermutations, function (dim) {
+            return getSingleMarkerEndPoint(areaData, idx, dim, seriesModel, api);
+          }); // If none of the area is inside coordSys, allClipped is set to be true
+          // in layout so that label will not be displayed. See #12591
+
+          var allClipped = true;
+          each(dimPermutations, function (dim) {
+            if (!allClipped) {
+              return;
+            }
+
+            var xValue = areaData.get(dim[0], idx);
+            var yValue = areaData.get(dim[1], idx); // If is infinity, the axis should be considered not clipped
+
+            if ((isInifinity$1(xValue) || coordSys.getAxis('x').containData(xValue)) && (isInifinity$1(yValue) || coordSys.getAxis('y').containData(yValue))) {
+              allClipped = false;
+            }
+          });
+          areaData.setItemLayout(idx, {
+            points: points,
+            allClipped: allClipped
+          });
+          var style = areaData.getItemModel(idx).getModel('itemStyle').getItemStyle();
+          var color$1 = getVisualFromData(seriesData, 'color');
+
+          if (!style.fill) {
+            style.fill = color$1;
+
+            if (typeof style.fill === 'string') {
+              style.fill = modifyAlpha(style.fill, 0.4);
+            }
+          }
+
+          if (!style.stroke) {
+            style.stroke = color$1;
+          } // Visual
+
+
+          areaData.setItemVisual(idx, 'style', style);
+        });
+        areaData.diff(inner$l(polygonGroup).data).add(function (idx) {
+          var layout = areaData.getItemLayout(idx);
+
+          if (!layout.allClipped) {
+            var polygon = new Polygon({
+              shape: {
+                points: layout.points
+              }
+            });
+            areaData.setItemGraphicEl(idx, polygon);
+            polygonGroup.group.add(polygon);
+          }
+        }).update(function (newIdx, oldIdx) {
+          var polygon = inner$l(polygonGroup).data.getItemGraphicEl(oldIdx);
+          var layout = areaData.getItemLayout(newIdx);
+
+          if (!layout.allClipped) {
+            if (polygon) {
+              updateProps(polygon, {
+                shape: {
+                  points: layout.points
+                }
+              }, maModel, newIdx);
+            } else {
+              polygon = new Polygon({
+                shape: {
+                  points: layout.points
+                }
+              });
+            }
+
+            areaData.setItemGraphicEl(newIdx, polygon);
+            polygonGroup.group.add(polygon);
+          } else if (polygon) {
+            polygonGroup.group.remove(polygon);
+          }
+        }).remove(function (idx) {
+          var polygon = inner$l(polygonGroup).data.getItemGraphicEl(idx);
+          polygonGroup.group.remove(polygon);
+        }).execute();
+        areaData.eachItemGraphicEl(function (polygon, idx) {
+          var itemModel = areaData.getItemModel(idx);
+          var style = areaData.getItemVisual(idx, 'style');
+          polygon.useStyle(areaData.getItemVisual(idx, 'style'));
+          setLabelStyle(polygon, getLabelStatesModels(itemModel), {
+            labelFetcher: maModel,
+            labelDataIndex: idx,
+            defaultText: areaData.getName(idx) || '',
+            inheritColor: typeof style.fill === 'string' ? modifyAlpha(style.fill, 1) : '#000'
+          });
+          setStatesStylesFromModel(polygon, itemModel);
+          enableHoverEmphasis(polygon);
+          getECData(polygon).dataModel = maModel;
+        });
+        inner$l(polygonGroup).data = areaData;
+        polygonGroup.group.silent = maModel.get('silent') || seriesModel.get('silent');
+      };
+
+      MarkAreaView.type = 'markArea';
+      return MarkAreaView;
+    }(MarkerView);
+
+    function createList$3(coordSys, seriesModel, maModel) {
+      var coordDimsInfos;
+      var areaData;
+      var dims = ['x0', 'y0', 'x1', 'y1'];
+
+      if (coordSys) {
+        coordDimsInfos = map(coordSys && coordSys.dimensions, function (coordDim) {
+          var data = seriesModel.getData();
+          var info = data.getDimensionInfo(data.mapDimension(coordDim)) || {}; // In map series data don't have lng and lat dimension. Fallback to same with coordSys
+
+          return defaults({
+            name: coordDim
+          }, info);
+        });
+        areaData = new List(map(dims, function (dim, idx) {
+          return {
+            name: dim,
+            type: coordDimsInfos[idx % 2].type
+          };
+        }), maModel);
+      } else {
+        coordDimsInfos = [{
+          name: 'value',
+          type: 'float'
+        }];
+        areaData = new List(coordDimsInfos, maModel);
+      }
+
+      var optData = map(maModel.get('data'), curry(markAreaTransform, seriesModel, coordSys, maModel));
+
+      if (coordSys) {
+        optData = filter(optData, curry(markAreaFilter, coordSys));
+      }
+
+      var dimValueGetter = coordSys ? function (item, dimName, dataIndex, dimIndex) {
+        // TODO should convert to ParsedValue?
+        return item.coord[Math.floor(dimIndex / 2)][dimIndex % 2];
+      } : function (item) {
+        return item.value;
+      };
+      areaData.initData(optData, null, dimValueGetter);
+      areaData.hasItemOption = true;
+      return areaData;
+    }
+
+    function install$G(registers) {
+      registers.registerComponentModel(MarkAreaModel);
+      registers.registerComponentView(MarkAreaView);
+      registers.registerPreprocessor(function (opt) {
+        // Make sure markArea component is enabled
+        opt.markArea = opt.markArea || {};
+      });
+    }
+
+    var getDefaultSelectorOptions = function (ecModel, type) {
+      if (type === 'all') {
+        return {
+          type: 'all',
+          title: ecModel.getLocale(['legend', 'selector', 'all'])
+        };
+      } else if (type === 'inverse') {
+        return {
+          type: 'inverse',
+          title: ecModel.getLocale(['legend', 'selector', 'inverse'])
+        };
+      }
+    };
+
+    var LegendModel =
+    /** @class */
+    function (_super) {
+      __extends(LegendModel, _super);
+
+      function LegendModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = LegendModel.type;
+        _this.layoutMode = {
+          type: 'box',
+          // legend.width/height are maxWidth/maxHeight actually,
+          // whereas realy width/height is calculated by its content.
+          // (Setting {left: 10, right: 10} does not make sense).
+          // So consider the case:
+          // `setOption({legend: {left: 10});`
+          // then `setOption({legend: {right: 10});`
+          // The previous `left` should be cleared by setting `ignoreSize`.
+          ignoreSize: true
+        };
+        return _this;
+      }
+
+      LegendModel.prototype.init = function (option, parentModel, ecModel) {
+        this.mergeDefaultAndTheme(option, ecModel);
+        option.selected = option.selected || {};
+
+        this._updateSelector(option);
+      };
+
+      LegendModel.prototype.mergeOption = function (option, ecModel) {
+        _super.prototype.mergeOption.call(this, option, ecModel);
+
+        this._updateSelector(option);
+      };
+
+      LegendModel.prototype._updateSelector = function (option) {
+        var selector = option.selector;
+        var ecModel = this.ecModel;
+
+        if (selector === true) {
+          selector = option.selector = ['all', 'inverse'];
+        }
+
+        if (isArray(selector)) {
+          each(selector, function (item, index) {
+            isString(item) && (item = {
+              type: item
+            });
+            selector[index] = merge(item, getDefaultSelectorOptions(ecModel, item.type));
+          });
+        }
+      };
+
+      LegendModel.prototype.optionUpdated = function () {
+        this._updateData(this.ecModel);
+
+        var legendData = this._data; // If selectedMode is single, try to select one
+
+        if (legendData[0] && this.get('selectedMode') === 'single') {
+          var hasSelected = false; // If has any selected in option.selected
+
+          for (var i = 0; i < legendData.length; i++) {
+            var name_1 = legendData[i].get('name');
+
+            if (this.isSelected(name_1)) {
+              // Force to unselect others
+              this.select(name_1);
+              hasSelected = true;
+              break;
+            }
+          } // Try select the first if selectedMode is single
+
+
+          !hasSelected && this.select(legendData[0].get('name'));
+        }
+      };
+
+      LegendModel.prototype._updateData = function (ecModel) {
+        var potentialData = [];
+        var availableNames = [];
+        ecModel.eachRawSeries(function (seriesModel) {
+          var seriesName = seriesModel.name;
+          availableNames.push(seriesName);
+          var isPotential;
+
+          if (seriesModel.legendVisualProvider) {
+            var provider = seriesModel.legendVisualProvider;
+            var names = provider.getAllNames();
+
+            if (!ecModel.isSeriesFiltered(seriesModel)) {
+              availableNames = availableNames.concat(names);
+            }
+
+            if (names.length) {
+              potentialData = potentialData.concat(names);
+            } else {
+              isPotential = true;
+            }
+          } else {
+            isPotential = true;
+          }
+
+          if (isPotential && isNameSpecified(seriesModel)) {
+            potentialData.push(seriesModel.name);
+          }
+        });
+        /**
+         * @type {Array.<string>}
+         * @private
+         */
+
+        this._availableNames = availableNames; // If legend.data not specified in option, use availableNames as data,
+        // which is convinient for user preparing option.
+
+        var rawData = this.get('data') || potentialData;
+        var legendData = map(rawData, function (dataItem) {
+          // Can be string or number
+          if (typeof dataItem === 'string' || typeof dataItem === 'number') {
+            dataItem = {
+              name: dataItem
+            };
+          }
+
+          return new Model(dataItem, this, this.ecModel);
+        }, this);
+        /**
+         * @type {Array.<module:echarts/model/Model>}
+         * @private
+         */
+
+        this._data = legendData;
+      };
+
+      LegendModel.prototype.getData = function () {
+        return this._data;
+      };
+
+      LegendModel.prototype.select = function (name) {
+        var selected = this.option.selected;
+        var selectedMode = this.get('selectedMode');
+
+        if (selectedMode === 'single') {
+          var data = this._data;
+          each(data, function (dataItem) {
+            selected[dataItem.get('name')] = false;
+          });
+        }
+
+        selected[name] = true;
+      };
+
+      LegendModel.prototype.unSelect = function (name) {
+        if (this.get('selectedMode') !== 'single') {
+          this.option.selected[name] = false;
+        }
+      };
+
+      LegendModel.prototype.toggleSelected = function (name) {
+        var selected = this.option.selected; // Default is true
+
+        if (!selected.hasOwnProperty(name)) {
+          selected[name] = true;
+        }
+
+        this[selected[name] ? 'unSelect' : 'select'](name);
+      };
+
+      LegendModel.prototype.allSelect = function () {
+        var data = this._data;
+        var selected = this.option.selected;
+        each(data, function (dataItem) {
+          selected[dataItem.get('name', true)] = true;
+        });
+      };
+
+      LegendModel.prototype.inverseSelect = function () {
+        var data = this._data;
+        var selected = this.option.selected;
+        each(data, function (dataItem) {
+          var name = dataItem.get('name', true); // Initially, default value is true
+
+          if (!selected.hasOwnProperty(name)) {
+            selected[name] = true;
+          }
+
+          selected[name] = !selected[name];
+        });
+      };
+
+      LegendModel.prototype.isSelected = function (name) {
+        var selected = this.option.selected;
+        return !(selected.hasOwnProperty(name) && !selected[name]) && indexOf(this._availableNames, name) >= 0;
+      };
+
+      LegendModel.prototype.getOrient = function () {
+        return this.get('orient') === 'vertical' ? {
+          index: 1,
+          name: 'vertical'
+        } : {
+          index: 0,
+          name: 'horizontal'
+        };
+      };
+
+      LegendModel.type = 'legend.plain';
+      LegendModel.dependencies = ['series'];
+      LegendModel.defaultOption = {
+        zlevel: 0,
+        z: 4,
+        show: true,
+        orient: 'horizontal',
+        left: 'center',
+        // right: 'center',
+        top: 0,
+        // bottom: null,
+        align: 'auto',
+        backgroundColor: 'rgba(0,0,0,0)',
+        borderColor: '#ccc',
+        borderRadius: 0,
+        borderWidth: 0,
+        padding: 5,
+        itemGap: 10,
+        itemWidth: 25,
+        itemHeight: 14,
+        inactiveColor: '#ccc',
+        inactiveBorderColor: '#ccc',
+        itemStyle: {
+          borderWidth: 0
+        },
+        textStyle: {
+          color: '#333'
+        },
+        selectedMode: true,
+        selector: false,
+        selectorLabel: {
+          show: true,
+          borderRadius: 10,
+          padding: [3, 5, 3, 5],
+          fontSize: 12,
+          fontFamily: ' sans-serif',
+          color: '#666',
+          borderWidth: 1,
+          borderColor: '#666'
+        },
+        emphasis: {
+          selectorLabel: {
+            show: true,
+            color: '#eee',
+            backgroundColor: '#666'
+          }
+        },
+        selectorPosition: 'auto',
+        selectorItemGap: 7,
+        selectorButtonGap: 10,
+        tooltip: {
+          show: false
+        }
+      };
+      return LegendModel;
+    }(ComponentModel);
+
+    var curry$1 = curry;
+    var each$e = each;
+    var Group$2 = Group;
+
+    var LegendView =
+    /** @class */
+    function (_super) {
+      __extends(LegendView, _super);
+
+      function LegendView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = LegendView.type;
+        _this.newlineDisabled = false;
+        return _this;
+      }
+
+      LegendView.prototype.init = function () {
+        this.group.add(this._contentGroup = new Group$2());
+        this.group.add(this._selectorGroup = new Group$2());
+        this._isFirstRender = true;
+      };
+      /**
+       * @protected
+       */
+
+
+      LegendView.prototype.getContentGroup = function () {
+        return this._contentGroup;
+      };
+      /**
+       * @protected
+       */
+
+
+      LegendView.prototype.getSelectorGroup = function () {
+        return this._selectorGroup;
+      };
+      /**
+       * @override
+       */
+
+
+      LegendView.prototype.render = function (legendModel, ecModel, api) {
+        var isFirstRender = this._isFirstRender;
+        this._isFirstRender = false;
+        this.resetInner();
+
+        if (!legendModel.get('show', true)) {
+          return;
+        }
+
+        var itemAlign = legendModel.get('align');
+        var orient = legendModel.get('orient');
+
+        if (!itemAlign || itemAlign === 'auto') {
+          itemAlign = legendModel.get('left') === 'right' && orient === 'vertical' ? 'right' : 'left';
+        } // selector has been normalized to an array in model
+
+
+        var selector = legendModel.get('selector', true);
+        var selectorPosition = legendModel.get('selectorPosition', true);
+
+        if (selector && (!selectorPosition || selectorPosition === 'auto')) {
+          selectorPosition = orient === 'horizontal' ? 'end' : 'start';
+        }
+
+        this.renderInner(itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition); // Perform layout.
+
+        var positionInfo = legendModel.getBoxLayoutParams();
+        var viewportSize = {
+          width: api.getWidth(),
+          height: api.getHeight()
+        };
+        var padding = legendModel.get('padding');
+        var maxSize = getLayoutRect(positionInfo, viewportSize, padding);
+        var mainRect = this.layoutInner(legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition); // Place mainGroup, based on the calculated `mainRect`.
+
+        var layoutRect = getLayoutRect(defaults({
+          width: mainRect.width,
+          height: mainRect.height
+        }, positionInfo), viewportSize, padding);
+        this.group.x = layoutRect.x - mainRect.x;
+        this.group.y = layoutRect.y - mainRect.y;
+        this.group.markRedraw(); // Render background after group is layout.
+
+        this.group.add(this._backgroundEl = makeBackground(mainRect, legendModel));
+      };
+
+      LegendView.prototype.resetInner = function () {
+        this.getContentGroup().removeAll();
+        this._backgroundEl && this.group.remove(this._backgroundEl);
+        this.getSelectorGroup().removeAll();
+      };
+
+      LegendView.prototype.renderInner = function (itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) {
+        var contentGroup = this.getContentGroup();
+        var legendDrawnMap = createHashMap();
+        var selectMode = legendModel.get('selectedMode');
+        var excludeSeriesId = [];
+        ecModel.eachRawSeries(function (seriesModel) {
+          !seriesModel.get('legendHoverLink') && excludeSeriesId.push(seriesModel.id);
+        });
+        each$e(legendModel.getData(), function (itemModel, dataIndex) {
+          var name = itemModel.get('name'); // Use empty string or \n as a newline string
+
+          if (!this.newlineDisabled && (name === '' || name === '\n')) {
+            var g = new Group$2(); // @ts-ignore
+
+            g.newline = true;
+            contentGroup.add(g);
+            return;
+          } // Representitive series.
+
+
+          var seriesModel = ecModel.getSeriesByName(name)[0];
+
+          if (legendDrawnMap.get(name)) {
+            // Have been drawed
+            return;
+          } // Legend to control series.
+
+
+          if (seriesModel) {
+            var data = seriesModel.getData();
+            var style = data.getVisual('style');
+            var color = style[data.getVisual('drawType')] || style.fill;
+            var borderColor = style.stroke;
+            var decal = style.decal; // Using rect symbol defaultly
+
+            var legendSymbolType = data.getVisual('legendSymbol') || 'roundRect';
+            var symbolType = data.getVisual('symbol');
+
+            var itemGroup = this._createItem(name, dataIndex, itemModel, legendModel, legendSymbolType, symbolType, itemAlign, color, borderColor, decal, selectMode);
+
+            itemGroup.on('click', curry$1(dispatchSelectAction, name, null, api, excludeSeriesId)).on('mouseover', curry$1(dispatchHighlightAction, seriesModel.name, null, api, excludeSeriesId)).on('mouseout', curry$1(dispatchDownplayAction, seriesModel.name, null, api, excludeSeriesId));
+            legendDrawnMap.set(name, true);
+          } else {
+            // Legend to control data. In pie and funnel.
+            ecModel.eachRawSeries(function (seriesModel) {
+              // In case multiple series has same data name
+              if (legendDrawnMap.get(name)) {
+                return;
+              }
+
+              if (seriesModel.legendVisualProvider) {
+                var provider = seriesModel.legendVisualProvider;
+
+                if (!provider.containName(name)) {
+                  return;
+                }
+
+                var idx = provider.indexOfName(name);
+                var style = provider.getItemVisual(idx, 'style');
+                var borderColor = style.stroke;
+                var decal = style.decal;
+                var color = style.fill;
+                var colorArr = parse(style.fill); // Color may be set to transparent in visualMap when data is out of range.
+                // Do not show nothing.
+
+                if (colorArr && colorArr[3] === 0) {
+                  colorArr[3] = 0.2; // TODO color is set to 0, 0, 0, 0. Should show correct RGBA
+
+                  color = stringify(colorArr, 'rgba');
+                }
+
+                var legendSymbolType = 'roundRect';
+
+                var itemGroup = this._createItem(name, dataIndex, itemModel, legendModel, legendSymbolType, null, itemAlign, color, borderColor, decal, selectMode); // FIXME: consider different series has items with the same name.
+
+
+                itemGroup.on('click', curry$1(dispatchSelectAction, null, name, api, excludeSeriesId)) // Should not specify the series name, consider legend controls
+                // more than one pie series.
+                .on('mouseover', curry$1(dispatchHighlightAction, null, name, api, excludeSeriesId)).on('mouseout', curry$1(dispatchDownplayAction, null, name, api, excludeSeriesId));
+                legendDrawnMap.set(name, true);
+              }
+            }, this);
+          }
+
+          if ("development" !== 'production') {
+            if (!legendDrawnMap.get(name)) {
+              console.warn(name + ' series not exists. Legend data should be same with series name or data name.');
+            }
+          }
+        }, this);
+
+        if (selector) {
+          this._createSelector(selector, legendModel, api, orient, selectorPosition);
+        }
+      };
+
+      LegendView.prototype._createSelector = function (selector, legendModel, api, orient, selectorPosition) {
+        var selectorGroup = this.getSelectorGroup();
+        each$e(selector, function createSelectorButton(selectorItem) {
+          var type = selectorItem.type;
+          var labelText = new ZRText({
+            style: {
+              x: 0,
+              y: 0,
+              align: 'center',
+              verticalAlign: 'middle'
+            },
+            onclick: function () {
+              api.dispatchAction({
+                type: type === 'all' ? 'legendAllSelect' : 'legendInverseSelect'
+              });
+            }
+          });
+          selectorGroup.add(labelText);
+          var labelModel = legendModel.getModel('selectorLabel');
+          var emphasisLabelModel = legendModel.getModel(['emphasis', 'selectorLabel']);
+          setLabelStyle(labelText, {
+            normal: labelModel,
+            emphasis: emphasisLabelModel
+          }, {
+            defaultText: selectorItem.title
+          });
+          enableHoverEmphasis(labelText);
+        });
+      };
+
+      LegendView.prototype._createItem = function (name, dataIndex, itemModel, legendModel, legendSymbolType, symbolType, itemAlign, color, borderColor, decal, selectMode) {
+        var itemWidth = legendModel.get('itemWidth');
+        var itemHeight = legendModel.get('itemHeight');
+        var inactiveColor = legendModel.get('inactiveColor');
+        var inactiveBorderColor = legendModel.get('inactiveBorderColor');
+        var symbolKeepAspect = legendModel.get('symbolKeepAspect');
+        var legendModelItemStyle = legendModel.getModel('itemStyle');
+        var isSelected = legendModel.isSelected(name);
+        var itemGroup = new Group$2();
+        var textStyleModel = itemModel.getModel('textStyle');
+        var itemIcon = itemModel.get('icon');
+        var tooltipModel = itemModel.getModel('tooltip');
+        var legendGlobalTooltipModel = tooltipModel.parentModel; // Use user given icon first
+
+        legendSymbolType = itemIcon || legendSymbolType;
+        var legendSymbol = createSymbol(legendSymbolType, 0, 0, itemWidth, itemHeight, isSelected ? color : inactiveColor, // symbolKeepAspect default true for legend
+        symbolKeepAspect == null ? true : symbolKeepAspect);
+        itemGroup.add(setSymbolStyle(legendSymbol, legendSymbolType, legendModelItemStyle, borderColor, inactiveBorderColor, decal, isSelected)); // Compose symbols
+        // PENDING
+
+        if (!itemIcon && symbolType // At least show one symbol, can't be all none
+        && (symbolType !== legendSymbolType || symbolType === 'none')) {
+          var size = itemHeight * 0.8;
+
+          if (symbolType === 'none') {
+            symbolType = 'circle';
+          }
+
+          var legendSymbolCenter = createSymbol(symbolType, (itemWidth - size) / 2, (itemHeight - size) / 2, size, size, isSelected ? color : inactiveColor, // symbolKeepAspect default true for legend
+          symbolKeepAspect == null ? true : symbolKeepAspect); // Put symbol in the center
+
+          itemGroup.add(setSymbolStyle(legendSymbolCenter, symbolType, legendModelItemStyle, borderColor, inactiveBorderColor, decal, isSelected));
+        }
+
+        var textX = itemAlign === 'left' ? itemWidth + 5 : -5;
+        var textAlign = itemAlign;
+        var formatter = legendModel.get('formatter');
+        var content = name;
+
+        if (typeof formatter === 'string' && formatter) {
+          content = formatter.replace('{name}', name != null ? name : '');
+        } else if (typeof formatter === 'function') {
+          content = formatter(name);
+        }
+
+        itemGroup.add(new ZRText({
+          style: createTextStyle(textStyleModel, {
+            text: content,
+            x: textX,
+            y: itemHeight / 2,
+            fill: isSelected ? textStyleModel.getTextColor() : inactiveColor,
+            align: textAlign,
+            verticalAlign: 'middle'
+          })
+        })); // Add a invisible rect to increase the area of mouse hover
+
+        var hitRect = new Rect({
+          shape: itemGroup.getBoundingRect(),
+          invisible: true
+        });
+
+        if (tooltipModel.get('show')) {
+          var formatterParams = {
+            componentType: 'legend',
+            legendIndex: legendModel.componentIndex,
+            name: name,
+            $vars: ['name']
+          };
+          hitRect.tooltip = extend({
+            content: name,
+            // Defaul formatter
+            formatter: legendGlobalTooltipModel.get('formatter', true) || function (params) {
+              return params.name;
+            },
+            formatterParams: formatterParams
+          }, tooltipModel.option);
+        }
+
+        itemGroup.add(hitRect);
+        itemGroup.eachChild(function (child) {
+          child.silent = true;
+        });
+        hitRect.silent = !selectMode;
+        this.getContentGroup().add(itemGroup);
+        enableHoverEmphasis(itemGroup); // @ts-ignore
+
+        itemGroup.__legendDataIndex = dataIndex;
+        return itemGroup;
+      };
+
+      LegendView.prototype.layoutInner = function (legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) {
+        var contentGroup = this.getContentGroup();
+        var selectorGroup = this.getSelectorGroup(); // Place items in contentGroup.
+
+        box(legendModel.get('orient'), contentGroup, legendModel.get('itemGap'), maxSize.width, maxSize.height);
+        var contentRect = contentGroup.getBoundingRect();
+        var contentPos = [-contentRect.x, -contentRect.y];
+        selectorGroup.markRedraw();
+        contentGroup.markRedraw();
+
+        if (selector) {
+          // Place buttons in selectorGroup
+          box( // Buttons in selectorGroup always layout horizontally
+          'horizontal', selectorGroup, legendModel.get('selectorItemGap', true));
+          var selectorRect = selectorGroup.getBoundingRect();
+          var selectorPos = [-selectorRect.x, -selectorRect.y];
+          var selectorButtonGap = legendModel.get('selectorButtonGap', true);
+          var orientIdx = legendModel.getOrient().index;
+          var wh = orientIdx === 0 ? 'width' : 'height';
+          var hw = orientIdx === 0 ? 'height' : 'width';
+          var yx = orientIdx === 0 ? 'y' : 'x';
+
+          if (selectorPosition === 'end') {
+            selectorPos[orientIdx] += contentRect[wh] + selectorButtonGap;
+          } else {
+            contentPos[orientIdx] += selectorRect[wh] + selectorButtonGap;
+          } //Always align selector to content as 'middle'
+
+
+          selectorPos[1 - orientIdx] += contentRect[hw] / 2 - selectorRect[hw] / 2;
+          selectorGroup.x = selectorPos[0];
+          selectorGroup.y = selectorPos[1];
+          contentGroup.x = contentPos[0];
+          contentGroup.y = contentPos[1];
+          var mainRect = {
+            x: 0,
+            y: 0
+          };
+          mainRect[wh] = contentRect[wh] + selectorButtonGap + selectorRect[wh];
+          mainRect[hw] = Math.max(contentRect[hw], selectorRect[hw]);
+          mainRect[yx] = Math.min(0, selectorRect[yx] + selectorPos[1 - orientIdx]);
+          return mainRect;
+        } else {
+          contentGroup.x = contentPos[0];
+          contentGroup.y = contentPos[1];
+          return this.group.getBoundingRect();
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      LegendView.prototype.remove = function () {
+        this.getContentGroup().removeAll();
+        this._isFirstRender = true;
+      };
+
+      LegendView.type = 'legend.plain';
+      return LegendView;
+    }(ComponentView);
+
+    function setSymbolStyle(symbol, symbolType, legendModelItemStyle, borderColor, inactiveBorderColor, decal, isSelected) {
+      var itemStyle;
+
+      if (symbolType !== 'line' && symbolType.indexOf('empty') < 0) {
+        itemStyle = legendModelItemStyle.getItemStyle();
+        symbol.style.stroke = borderColor;
+        symbol.style.decal = decal;
+
+        if (!isSelected) {
+          itemStyle.stroke = inactiveBorderColor;
+        }
+      } else {
+        itemStyle = legendModelItemStyle.getItemStyle(['borderWidth', 'borderColor']);
+      }
+
+      symbol.setStyle(itemStyle);
+      return symbol;
+    }
+
+    function dispatchSelectAction(seriesName, dataName, api, excludeSeriesId) {
+      // downplay before unselect
+      dispatchDownplayAction(seriesName, dataName, api, excludeSeriesId);
+      api.dispatchAction({
+        type: 'legendToggleSelect',
+        name: seriesName != null ? seriesName : dataName
+      }); // highlight after select
+      // TODO higlight immediately may cause animation loss.
+
+      dispatchHighlightAction(seriesName, dataName, api, excludeSeriesId);
+    }
+
+    function isUseHoverLayer(api) {
+      var list = api.getZr().storage.getDisplayList();
+      var emphasisState;
+      var i = 0;
+      var len = list.length;
+
+      while (i < len && !(emphasisState = list[i].states.emphasis)) {
+        i++;
+      }
+
+      return emphasisState && emphasisState.hoverLayer;
+    }
+
+    function dispatchHighlightAction(seriesName, dataName, api, excludeSeriesId) {
+      // If element hover will move to a hoverLayer.
+      if (!isUseHoverLayer(api)) {
+        api.dispatchAction({
+          type: 'highlight',
+          seriesName: seriesName,
+          name: dataName,
+          excludeSeriesId: excludeSeriesId
+        });
+      }
+    }
+
+    function dispatchDownplayAction(seriesName, dataName, api, excludeSeriesId) {
+      // If element hover will move to a hoverLayer.
+      if (!isUseHoverLayer(api)) {
+        api.dispatchAction({
+          type: 'downplay',
+          seriesName: seriesName,
+          name: dataName,
+          excludeSeriesId: excludeSeriesId
+        });
+      }
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function legendFilter(ecModel) {
+      var legendModels = ecModel.findComponents({
+        mainType: 'legend'
+      });
+
+      if (legendModels && legendModels.length) {
+        ecModel.filterSeries(function (series) {
+          // If in any legend component the status is not selected.
+          // Because in legend series is assumed selected when it is not in the legend data.
+          for (var i = 0; i < legendModels.length; i++) {
+            if (!legendModels[i].isSelected(series.name)) {
+              return false;
+            }
+          }
+
+          return true;
+        });
+      }
+    }
+
+    function legendSelectActionHandler(methodName, payload, ecModel) {
+      var selectedMap = {};
+      var isToggleSelect = methodName === 'toggleSelected';
+      var isSelected; // Update all legend components
+
+      ecModel.eachComponent('legend', function (legendModel) {
+        if (isToggleSelect && isSelected != null) {
+          // Force other legend has same selected status
+          // Or the first is toggled to true and other are toggled to false
+          // In the case one legend has some item unSelected in option. And if other legend
+          // doesn't has the item, they will assume it is selected.
+          legendModel[isSelected ? 'select' : 'unSelect'](payload.name);
+        } else if (methodName === 'allSelect' || methodName === 'inverseSelect') {
+          legendModel[methodName]();
+        } else {
+          legendModel[methodName](payload.name);
+          isSelected = legendModel.isSelected(payload.name);
+        }
+
+        var legendData = legendModel.getData();
+        each(legendData, function (model) {
+          var name = model.get('name'); // Wrap element
+
+          if (name === '\n' || name === '') {
+            return;
+          }
+
+          var isItemSelected = legendModel.isSelected(name);
+
+          if (selectedMap.hasOwnProperty(name)) {
+            // Unselected if any legend is unselected
+            selectedMap[name] = selectedMap[name] && isItemSelected;
+          } else {
+            selectedMap[name] = isItemSelected;
+          }
+        });
+      }); // Return the event explicitly
+
+      return methodName === 'allSelect' || methodName === 'inverseSelect' ? {
+        selected: selectedMap
+      } : {
+        name: payload.name,
+        selected: selectedMap
+      };
+    }
+
+    function installLegendAction(registers) {
+      /**
+       * @event legendToggleSelect
+       * @type {Object}
+       * @property {string} type 'legendToggleSelect'
+       * @property {string} [from]
+       * @property {string} name Series name or data item name
+       */
+      registers.registerAction('legendToggleSelect', 'legendselectchanged', curry(legendSelectActionHandler, 'toggleSelected'));
+      registers.registerAction('legendAllSelect', 'legendselectall', curry(legendSelectActionHandler, 'allSelect'));
+      registers.registerAction('legendInverseSelect', 'legendinverseselect', curry(legendSelectActionHandler, 'inverseSelect'));
+      /**
+       * @event legendSelect
+       * @type {Object}
+       * @property {string} type 'legendSelect'
+       * @property {string} name Series name or data item name
+       */
+
+      registers.registerAction('legendSelect', 'legendselected', curry(legendSelectActionHandler, 'select'));
+      /**
+       * @event legendUnSelect
+       * @type {Object}
+       * @property {string} type 'legendUnSelect'
+       * @property {string} name Series name or data item name
+       */
+
+      registers.registerAction('legendUnSelect', 'legendunselected', curry(legendSelectActionHandler, 'unSelect'));
+    }
+
+    function install$H(registers) {
+      registers.registerComponentModel(LegendModel);
+      registers.registerComponentView(LegendView);
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter);
+      registers.registerSubTypeDefaulter('legend', function () {
+        return 'plain';
+      });
+      installLegendAction(registers);
+    }
+
+    var ScrollableLegendModel =
+    /** @class */
+    function (_super) {
+      __extends(ScrollableLegendModel, _super);
+
+      function ScrollableLegendModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ScrollableLegendModel.type;
+        return _this;
+      }
+      /**
+       * @param {number} scrollDataIndex
+       */
+
+
+      ScrollableLegendModel.prototype.setScrollDataIndex = function (scrollDataIndex) {
+        this.option.scrollDataIndex = scrollDataIndex;
+      };
+
+      ScrollableLegendModel.prototype.init = function (option, parentModel, ecModel) {
+        var inputPositionParams = getLayoutParams(option);
+
+        _super.prototype.init.call(this, option, parentModel, ecModel);
+
+        mergeAndNormalizeLayoutParams$1(this, option, inputPositionParams);
+      };
+      /**
+       * @override
+       */
+
+
+      ScrollableLegendModel.prototype.mergeOption = function (option, ecModel) {
+        _super.prototype.mergeOption.call(this, option, ecModel);
+
+        mergeAndNormalizeLayoutParams$1(this, this.option, option);
+      };
+
+      ScrollableLegendModel.type = 'legend.scroll';
+      ScrollableLegendModel.defaultOption = inheritDefaultOption(LegendModel.defaultOption, {
+        scrollDataIndex: 0,
+        pageButtonItemGap: 5,
+        pageButtonGap: null,
+        pageButtonPosition: 'end',
+        pageFormatter: '{current}/{total}',
+        pageIcons: {
+          horizontal: ['M0,0L12,-10L12,10z', 'M0,0L-12,-10L-12,10z'],
+          vertical: ['M0,0L20,0L10,-20z', 'M0,0L20,0L10,20z']
+        },
+        pageIconColor: '#2f4554',
+        pageIconInactiveColor: '#aaa',
+        pageIconSize: 15,
+        pageTextStyle: {
+          color: '#333'
+        },
+        animationDurationUpdate: 800
+      });
+      return ScrollableLegendModel;
+    }(LegendModel);
+
+    function mergeAndNormalizeLayoutParams$1(legendModel, target, raw) {
+      var orient = legendModel.getOrient();
+      var ignoreSize = [1, 1];
+      ignoreSize[orient.index] = 0;
+      mergeLayoutParam(target, raw, {
+        type: 'box',
+        ignoreSize: !!ignoreSize
+      });
+    }
+
+    var Group$3 = Group;
+    var WH$1 = ['width', 'height'];
+    var XY$1 = ['x', 'y'];
+
+    var ScrollableLegendView =
+    /** @class */
+    function (_super) {
+      __extends(ScrollableLegendView, _super);
+
+      function ScrollableLegendView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ScrollableLegendView.type;
+        _this.newlineDisabled = true;
+        _this._currentIndex = 0;
+        return _this;
+      }
+
+      ScrollableLegendView.prototype.init = function () {
+        _super.prototype.init.call(this);
+
+        this.group.add(this._containerGroup = new Group$3());
+
+        this._containerGroup.add(this.getContentGroup());
+
+        this.group.add(this._controllerGroup = new Group$3());
+      };
+      /**
+       * @override
+       */
+
+
+      ScrollableLegendView.prototype.resetInner = function () {
+        _super.prototype.resetInner.call(this);
+
+        this._controllerGroup.removeAll();
+
+        this._containerGroup.removeClipPath();
+
+        this._containerGroup.__rectSize = null;
+      };
+      /**
+       * @override
+       */
+
+
+      ScrollableLegendView.prototype.renderInner = function (itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) {
+        var self = this; // Render content items.
+
+        _super.prototype.renderInner.call(this, itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition);
+
+        var controllerGroup = this._controllerGroup; // FIXME: support be 'auto' adapt to size number text length,
+        // e.g., '3/12345' should not overlap with the control arrow button.
+
+        var pageIconSize = legendModel.get('pageIconSize', true);
+        var pageIconSizeArr = isArray(pageIconSize) ? pageIconSize : [pageIconSize, pageIconSize];
+        createPageButton('pagePrev', 0);
+        var pageTextStyleModel = legendModel.getModel('pageTextStyle');
+        controllerGroup.add(new ZRText({
+          name: 'pageText',
+          style: {
+            // Placeholder to calculate a proper layout.
+            text: 'xx/xx',
+            fill: pageTextStyleModel.getTextColor(),
+            font: pageTextStyleModel.getFont(),
+            verticalAlign: 'middle',
+            align: 'center'
+          },
+          silent: true
+        }));
+        createPageButton('pageNext', 1);
+
+        function createPageButton(name, iconIdx) {
+          var pageDataIndexName = name + 'DataIndex';
+          var icon = createIcon(legendModel.get('pageIcons', true)[legendModel.getOrient().name][iconIdx], {
+            // Buttons will be created in each render, so we do not need
+            // to worry about avoiding using legendModel kept in scope.
+            onclick: bind(self._pageGo, self, pageDataIndexName, legendModel, api)
+          }, {
+            x: -pageIconSizeArr[0] / 2,
+            y: -pageIconSizeArr[1] / 2,
+            width: pageIconSizeArr[0],
+            height: pageIconSizeArr[1]
+          });
+          icon.name = name;
+          controllerGroup.add(icon);
+        }
+      };
+      /**
+       * @override
+       */
+
+
+      ScrollableLegendView.prototype.layoutInner = function (legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) {
+        var selectorGroup = this.getSelectorGroup();
+        var orientIdx = legendModel.getOrient().index;
+        var wh = WH$1[orientIdx];
+        var xy = XY$1[orientIdx];
+        var hw = WH$1[1 - orientIdx];
+        var yx = XY$1[1 - orientIdx];
+        selector && box( // Buttons in selectorGroup always layout horizontally
+        'horizontal', selectorGroup, legendModel.get('selectorItemGap', true));
+        var selectorButtonGap = legendModel.get('selectorButtonGap', true);
+        var selectorRect = selectorGroup.getBoundingRect();
+        var selectorPos = [-selectorRect.x, -selectorRect.y];
+        var processMaxSize = clone(maxSize);
+        selector && (processMaxSize[wh] = maxSize[wh] - selectorRect[wh] - selectorButtonGap);
+
+        var mainRect = this._layoutContentAndController(legendModel, isFirstRender, processMaxSize, orientIdx, wh, hw, yx, xy);
+
+        if (selector) {
+          if (selectorPosition === 'end') {
+            selectorPos[orientIdx] += mainRect[wh] + selectorButtonGap;
+          } else {
+            var offset = selectorRect[wh] + selectorButtonGap;
+            selectorPos[orientIdx] -= offset;
+            mainRect[xy] -= offset;
+          }
+
+          mainRect[wh] += selectorRect[wh] + selectorButtonGap;
+          selectorPos[1 - orientIdx] += mainRect[yx] + mainRect[hw] / 2 - selectorRect[hw] / 2;
+          mainRect[hw] = Math.max(mainRect[hw], selectorRect[hw]);
+          mainRect[yx] = Math.min(mainRect[yx], selectorRect[yx] + selectorPos[1 - orientIdx]);
+          selectorGroup.x = selectorPos[0];
+          selectorGroup.y = selectorPos[1];
+          selectorGroup.markRedraw();
+        }
+
+        return mainRect;
+      };
+
+      ScrollableLegendView.prototype._layoutContentAndController = function (legendModel, isFirstRender, maxSize, orientIdx, wh, hw, yx, xy) {
+        var contentGroup = this.getContentGroup();
+        var containerGroup = this._containerGroup;
+        var controllerGroup = this._controllerGroup; // Place items in contentGroup.
+
+        box(legendModel.get('orient'), contentGroup, legendModel.get('itemGap'), !orientIdx ? null : maxSize.width, orientIdx ? null : maxSize.height);
+        box( // Buttons in controller are layout always horizontally.
+        'horizontal', controllerGroup, legendModel.get('pageButtonItemGap', true));
+        var contentRect = contentGroup.getBoundingRect();
+        var controllerRect = controllerGroup.getBoundingRect();
+        var showController = this._showController = contentRect[wh] > maxSize[wh]; // In case that the inner elements of contentGroup layout do not based on [0, 0]
+
+        var contentPos = [-contentRect.x, -contentRect.y]; // Remain contentPos when scroll animation perfroming.
+        // If first rendering, `contentGroup.position` is [0, 0], which
+        // does not make sense and may cause unexepcted animation if adopted.
+
+        if (!isFirstRender) {
+          contentPos[orientIdx] = contentGroup[xy];
+        } // Layout container group based on 0.
+
+
+        var containerPos = [0, 0];
+        var controllerPos = [-controllerRect.x, -controllerRect.y];
+        var pageButtonGap = retrieve2(legendModel.get('pageButtonGap', true), legendModel.get('itemGap', true)); // Place containerGroup and controllerGroup and contentGroup.
+
+        if (showController) {
+          var pageButtonPosition = legendModel.get('pageButtonPosition', true); // controller is on the right / bottom.
+
+          if (pageButtonPosition === 'end') {
+            controllerPos[orientIdx] += maxSize[wh] - controllerRect[wh];
+          } // controller is on the left / top.
+          else {
+              containerPos[orientIdx] += controllerRect[wh] + pageButtonGap;
+            }
+        } // Always align controller to content as 'middle'.
+
+
+        controllerPos[1 - orientIdx] += contentRect[hw] / 2 - controllerRect[hw] / 2;
+        contentGroup.setPosition(contentPos);
+        containerGroup.setPosition(containerPos);
+        controllerGroup.setPosition(controllerPos); // Calculate `mainRect` and set `clipPath`.
+        // mainRect should not be calculated by `this.group.getBoundingRect()`
+        // for sake of the overflow.
+
+        var mainRect = {
+          x: 0,
+          y: 0
+        }; // Consider content may be overflow (should be clipped).
+
+        mainRect[wh] = showController ? maxSize[wh] : contentRect[wh];
+        mainRect[hw] = Math.max(contentRect[hw], controllerRect[hw]); // `containerRect[yx] + containerPos[1 - orientIdx]` is 0.
+
+        mainRect[yx] = Math.min(0, controllerRect[yx] + controllerPos[1 - orientIdx]);
+        containerGroup.__rectSize = maxSize[wh];
+
+        if (showController) {
+          var clipShape = {
+            x: 0,
+            y: 0
+          };
+          clipShape[wh] = Math.max(maxSize[wh] - controllerRect[wh] - pageButtonGap, 0);
+          clipShape[hw] = mainRect[hw];
+          containerGroup.setClipPath(new Rect({
+            shape: clipShape
+          })); // Consider content may be larger than container, container rect
+          // can not be obtained from `containerGroup.getBoundingRect()`.
+
+          containerGroup.__rectSize = clipShape[wh];
+        } else {
+          // Do not remove or ignore controller. Keep them set as placeholders.
+          controllerGroup.eachChild(function (child) {
+            child.attr({
+              invisible: true,
+              silent: true
+            });
+          });
+        } // Content translate animation.
+
+
+        var pageInfo = this._getPageInfo(legendModel);
+
+        pageInfo.pageIndex != null && updateProps(contentGroup, {
+          x: pageInfo.contentPosition[0],
+          y: pageInfo.contentPosition[1]
+        }, // When switch from "show controller" to "not show controller", view should be
+        // updated immediately without animation, otherwise causes weird effect.
+        showController ? legendModel : null);
+
+        this._updatePageInfoView(legendModel, pageInfo);
+
+        return mainRect;
+      };
+
+      ScrollableLegendView.prototype._pageGo = function (to, legendModel, api) {
+        var scrollDataIndex = this._getPageInfo(legendModel)[to];
+
+        scrollDataIndex != null && api.dispatchAction({
+          type: 'legendScroll',
+          scrollDataIndex: scrollDataIndex,
+          legendId: legendModel.id
+        });
+      };
+
+      ScrollableLegendView.prototype._updatePageInfoView = function (legendModel, pageInfo) {
+        var controllerGroup = this._controllerGroup;
+        each(['pagePrev', 'pageNext'], function (name) {
+          var key = name + 'DataIndex';
+          var canJump = pageInfo[key] != null;
+          var icon = controllerGroup.childOfName(name);
+
+          if (icon) {
+            icon.setStyle('fill', canJump ? legendModel.get('pageIconColor', true) : legendModel.get('pageIconInactiveColor', true));
+            icon.cursor = canJump ? 'pointer' : 'default';
+          }
+        });
+        var pageText = controllerGroup.childOfName('pageText');
+        var pageFormatter = legendModel.get('pageFormatter');
+        var pageIndex = pageInfo.pageIndex;
+        var current = pageIndex != null ? pageIndex + 1 : 0;
+        var total = pageInfo.pageCount;
+        pageText && pageFormatter && pageText.setStyle('text', isString(pageFormatter) ? pageFormatter.replace('{current}', current == null ? '' : current + '').replace('{total}', total == null ? '' : total + '') : pageFormatter({
+          current: current,
+          total: total
+        }));
+      };
+      /**
+       *  contentPosition: Array.<number>, null when data item not found.
+       *  pageIndex: number, null when data item not found.
+       *  pageCount: number, always be a number, can be 0.
+       *  pagePrevDataIndex: number, null when no previous page.
+       *  pageNextDataIndex: number, null when no next page.
+       * }
+       */
+
+
+      ScrollableLegendView.prototype._getPageInfo = function (legendModel) {
+        var scrollDataIndex = legendModel.get('scrollDataIndex', true);
+        var contentGroup = this.getContentGroup();
+        var containerRectSize = this._containerGroup.__rectSize;
+        var orientIdx = legendModel.getOrient().index;
+        var wh = WH$1[orientIdx];
+        var xy = XY$1[orientIdx];
+
+        var targetItemIndex = this._findTargetItemIndex(scrollDataIndex);
+
+        var children = contentGroup.children();
+        var targetItem = children[targetItemIndex];
+        var itemCount = children.length;
+        var pCount = !itemCount ? 0 : 1;
+        var result = {
+          contentPosition: [contentGroup.x, contentGroup.y],
+          pageCount: pCount,
+          pageIndex: pCount - 1,
+          pagePrevDataIndex: null,
+          pageNextDataIndex: null
+        };
+
+        if (!targetItem) {
+          return result;
+        }
+
+        var targetItemInfo = getItemInfo(targetItem);
+        result.contentPosition[orientIdx] = -targetItemInfo.s; // Strategy:
+        // (1) Always align based on the left/top most item.
+        // (2) It is user-friendly that the last item shown in the
+        // current window is shown at the begining of next window.
+        // Otherwise if half of the last item is cut by the window,
+        // it will have no chance to display entirely.
+        // (3) Consider that item size probably be different, we
+        // have calculate pageIndex by size rather than item index,
+        // and we can not get page index directly by division.
+        // (4) The window is to narrow to contain more than
+        // one item, we should make sure that the page can be fliped.
+
+        for (var i = targetItemIndex + 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i <= itemCount; ++i) {
+          currItemInfo = getItemInfo(children[i]);
+
+          if ( // Half of the last item is out of the window.
+          !currItemInfo && winEndItemInfo.e > winStartItemInfo.s + containerRectSize || // If the current item does not intersect with the window, the new page
+          // can be started at the current item or the last item.
+          currItemInfo && !intersect(currItemInfo, winStartItemInfo.s)) {
+            if (winEndItemInfo.i > winStartItemInfo.i) {
+              winStartItemInfo = winEndItemInfo;
+            } else {
+              // e.g., when page size is smaller than item size.
+              winStartItemInfo = currItemInfo;
+            }
+
+            if (winStartItemInfo) {
+              if (result.pageNextDataIndex == null) {
+                result.pageNextDataIndex = winStartItemInfo.i;
+              }
+
+              ++result.pageCount;
+            }
+          }
+
+          winEndItemInfo = currItemInfo;
+        }
+
+        for (var i = targetItemIndex - 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i >= -1; --i) {
+          currItemInfo = getItemInfo(children[i]);
+
+          if ( // If the the end item does not intersect with the window started
+          // from the current item, a page can be settled.
+          (!currItemInfo || !intersect(winEndItemInfo, currItemInfo.s)) && // e.g., when page size is smaller than item size.
+          winStartItemInfo.i < winEndItemInfo.i) {
+            winEndItemInfo = winStartItemInfo;
+
+            if (result.pagePrevDataIndex == null) {
+              result.pagePrevDataIndex = winStartItemInfo.i;
+            }
+
+            ++result.pageCount;
+            ++result.pageIndex;
+          }
+
+          winStartItemInfo = currItemInfo;
+        }
+
+        return result;
+
+        function getItemInfo(el) {
+          if (el) {
+            var itemRect = el.getBoundingRect();
+            var start = itemRect[xy] + el[xy];
+            return {
+              s: start,
+              e: start + itemRect[wh],
+              i: el.__legendDataIndex
+            };
+          }
+        }
+
+        function intersect(itemInfo, winStart) {
+          return itemInfo.e >= winStart && itemInfo.s <= winStart + containerRectSize;
+        }
+      };
+
+      ScrollableLegendView.prototype._findTargetItemIndex = function (targetDataIndex) {
+        if (!this._showController) {
+          return 0;
+        }
+
+        var index;
+        var contentGroup = this.getContentGroup();
+        var defaultIndex;
+        contentGroup.eachChild(function (child, idx) {
+          var legendDataIdx = child.__legendDataIndex; // FIXME
+          // If the given targetDataIndex (from model) is illegal,
+          // we use defaultIndex. But the index on the legend model and
+          // action payload is still illegal. That case will not be
+          // changed until some scenario requires.
+
+          if (defaultIndex == null && legendDataIdx != null) {
+            defaultIndex = idx;
+          }
+
+          if (legendDataIdx === targetDataIndex) {
+            index = idx;
+          }
+        });
+        return index != null ? index : defaultIndex;
+      };
+
+      ScrollableLegendView.type = 'legend.scroll';
+      return ScrollableLegendView;
+    }(LegendView);
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    function installScrollableLegendAction(registers) {
+      /**
+       * @event legendScroll
+       * @type {Object}
+       * @property {string} type 'legendScroll'
+       * @property {string} scrollDataIndex
+       */
+      registers.registerAction('legendScroll', 'legendscroll', function (payload, ecModel) {
+        var scrollDataIndex = payload.scrollDataIndex;
+        scrollDataIndex != null && ecModel.eachComponent({
+          mainType: 'legend',
+          subType: 'scroll',
+          query: payload
+        }, function (legendModel) {
+          legendModel.setScrollDataIndex(scrollDataIndex);
+        });
+      });
+    }
+
+    function install$I(registers) {
+      use(install$H);
+      registers.registerComponentModel(ScrollableLegendModel);
+      registers.registerComponentView(ScrollableLegendView);
+      installScrollableLegendAction(registers);
+    }
+
+    function install$J(registers) {
+      use(install$H);
+      use(install$I);
+    }
+
+    var InsideZoomModel =
+    /** @class */
+    function (_super) {
+      __extends(InsideZoomModel, _super);
+
+      function InsideZoomModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = InsideZoomModel.type;
+        return _this;
+      }
+
+      InsideZoomModel.type = 'dataZoom.inside';
+      InsideZoomModel.defaultOption = inheritDefaultOption(DataZoomModel.defaultOption, {
+        disabled: false,
+        zoomLock: false,
+        zoomOnMouseWheel: true,
+        moveOnMouseMove: true,
+        moveOnMouseWheel: false,
+        preventDefaultMouseMove: true
+      });
+      return InsideZoomModel;
+    }(DataZoomModel);
+
+    var inner$m = makeInner();
+    function setViewInfoToCoordSysRecord(api, dataZoomModel, getRange) {
+      inner$m(api).coordSysRecordMap.each(function (coordSysRecord) {
+        var dzInfo = coordSysRecord.dataZoomInfoMap.get(dataZoomModel.uid);
+
+        if (dzInfo) {
+          dzInfo.getRange = getRange;
+        }
+      });
+    }
+    function disposeCoordSysRecordIfNeeded(api, dataZoomModel) {
+      var coordSysRecordMap = inner$m(api).coordSysRecordMap;
+      var coordSysKeyArr = coordSysRecordMap.keys();
+
+      for (var i = 0; i < coordSysKeyArr.length; i++) {
+        var coordSysKey = coordSysKeyArr[i];
+        var coordSysRecord = coordSysRecordMap.get(coordSysKey);
+        var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+
+        if (dataZoomInfoMap) {
+          var dzUid = dataZoomModel.uid;
+          var dzInfo = dataZoomInfoMap.get(dzUid);
+
+          if (dzInfo) {
+            dataZoomInfoMap.removeKey(dzUid);
+
+            if (!dataZoomInfoMap.keys().length) {
+              disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+            }
+          }
+        }
+      }
+    }
+
+    function disposeCoordSysRecord(coordSysRecordMap, coordSysRecord) {
+      if (coordSysRecord) {
+        coordSysRecordMap.removeKey(coordSysRecord.model.uid);
+        var controller = coordSysRecord.controller;
+        controller && controller.dispose();
+      }
+    }
+
+    function createCoordSysRecord(api, coordSysModel) {
+      // These init props will never change after record created.
+      var coordSysRecord = {
+        model: coordSysModel,
+        containsPoint: curry(containsPoint, coordSysModel),
+        dispatchAction: curry(dispatchAction$1, api),
+        dataZoomInfoMap: null,
+        controller: null
+      }; // Must not do anything depends on coordSysRecord outside the event handler here,
+      // because coordSysRecord not completed yet.
+
+      var controller = coordSysRecord.controller = new RoamController(api.getZr());
+      each(['pan', 'zoom', 'scrollMove'], function (eventName) {
+        controller.on(eventName, function (event) {
+          var batch = [];
+          coordSysRecord.dataZoomInfoMap.each(function (dzInfo) {
+            // Check whether the behaviors (zoomOnMouseWheel, moveOnMouseMove,
+            // moveOnMouseWheel, ...) enabled.
+            if (!event.isAvailableBehavior(dzInfo.model.option)) {
+              return;
+            }
+
+            var method = (dzInfo.getRange || {})[eventName];
+            var range = method && method(dzInfo.dzReferCoordSysInfo, coordSysRecord.model.mainType, coordSysRecord.controller, event);
+            !dzInfo.model.get('disabled', true) && range && batch.push({
+              dataZoomId: dzInfo.model.id,
+              start: range[0],
+              end: range[1]
+            });
+          });
+          batch.length && coordSysRecord.dispatchAction(batch);
+        });
+      });
+      return coordSysRecord;
+    }
+    /**
+     * This action will be throttled.
+     */
+
+
+    function dispatchAction$1(api, batch) {
+      api.dispatchAction({
+        type: 'dataZoom',
+        animation: {
+          easing: 'cubicOut',
+          duration: 100
+        },
+        batch: batch
+      });
+    }
+
+    function containsPoint(coordSysModel, e, x, y) {
+      return coordSysModel.coordinateSystem.containPoint([x, y]);
+    }
+    /**
+     * Merge roamController settings when multiple dataZooms share one roamController.
+     */
+
+
+    function mergeControllerParams(dataZoomInfoMap) {
+      var controlType; // DO NOT use reserved word (true, false, undefined) as key literally. Even if encapsulated
+      // as string, it is probably revert to reserved word by compress tool. See #7411.
+
+      var prefix = 'type_';
+      var typePriority = {
+        'type_true': 2,
+        'type_move': 1,
+        'type_false': 0,
+        'type_undefined': -1
+      };
+      var preventDefaultMouseMove = true;
+      dataZoomInfoMap.each(function (dataZoomInfo) {
+        var dataZoomModel = dataZoomInfo.model;
+        var oneType = dataZoomModel.get('disabled', true) ? false : dataZoomModel.get('zoomLock', true) ? 'move' : true;
+
+        if (typePriority[prefix + oneType] > typePriority[prefix + controlType]) {
+          controlType = oneType;
+        } // Prevent default move event by default. If one false, do not prevent. Otherwise
+        // users may be confused why it does not work when multiple insideZooms exist.
+
+
+        preventDefaultMouseMove = preventDefaultMouseMove && dataZoomModel.get('preventDefaultMouseMove', true);
+      });
+      return {
+        controlType: controlType,
+        opt: {
+          // RoamController will enable all of these functionalities,
+          // and the final behavior is determined by its event listener
+          // provided by each inside zoom.
+          zoomOnMouseWheel: true,
+          moveOnMouseMove: true,
+          moveOnMouseWheel: true,
+          preventDefaultMouseMove: !!preventDefaultMouseMove
+        }
+      };
+    }
+
+    function installDataZoomRoamProcessor(registers) {
+      registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, function (ecModel, api) {
+        var apiInner = inner$m(api);
+        var coordSysRecordMap = apiInner.coordSysRecordMap || (apiInner.coordSysRecordMap = createHashMap());
+        coordSysRecordMap.each(function (coordSysRecord) {
+          // `coordSysRecordMap` always exists (becuase it hold the `roam controller`, which should
+          // better not re-create each time), but clear `dataZoomInfoMap` each round of the workflow.
+          coordSysRecord.dataZoomInfoMap = null;
+        });
+        ecModel.eachComponent({
+          mainType: 'dataZoom',
+          subType: 'inside'
+        }, function (dataZoomModel) {
+          var dzReferCoordSysWrap = collectReferCoordSysModelInfo(dataZoomModel);
+          each(dzReferCoordSysWrap.infoList, function (dzCoordSysInfo) {
+            var coordSysUid = dzCoordSysInfo.model.uid;
+            var coordSysRecord = coordSysRecordMap.get(coordSysUid) || coordSysRecordMap.set(coordSysUid, createCoordSysRecord(api, dzCoordSysInfo.model));
+            var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap || (coordSysRecord.dataZoomInfoMap = createHashMap()); // Notice these props might be changed each time for a single dataZoomModel.
+
+            dataZoomInfoMap.set(dataZoomModel.uid, {
+              dzReferCoordSysInfo: dzCoordSysInfo,
+              model: dataZoomModel,
+              getRange: null
+            });
+          });
+        }); // (1) Merge dataZoom settings for each coord sys and set to the roam controller.
+        // (2) Clear coord sys if not refered by any dataZoom.
+
+        coordSysRecordMap.each(function (coordSysRecord) {
+          var controller = coordSysRecord.controller;
+          var firstDzInfo;
+          var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+
+          if (dataZoomInfoMap) {
+            var firstDzKey = dataZoomInfoMap.keys()[0];
+
+            if (firstDzKey != null) {
+              firstDzInfo = dataZoomInfoMap.get(firstDzKey);
+            }
+          }
+
+          if (!firstDzInfo) {
+            disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+            return;
+          }
+
+          var controllerParams = mergeControllerParams(dataZoomInfoMap);
+          controller.enable(controllerParams.controlType, controllerParams.opt);
+          controller.setPointerChecker(coordSysRecord.containsPoint);
+          createOrUpdate(coordSysRecord, 'dispatchAction', firstDzInfo.model.get('throttle', true), 'fixRate');
+        });
+      });
+    }
+
+    var InsideZoomView =
+    /** @class */
+    function (_super) {
+      __extends(InsideZoomView, _super);
+
+      function InsideZoomView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'dataZoom.inside';
+        return _this;
+      }
+
+      InsideZoomView.prototype.render = function (dataZoomModel, ecModel, api) {
+        _super.prototype.render.apply(this, arguments);
+
+        if (dataZoomModel.noTarget()) {
+          this._clear();
+
+          return;
+        } // Hence the `throttle` util ensures to preserve command order,
+        // here simply updating range all the time will not cause missing
+        // any of the the roam change.
+
+
+        this.range = dataZoomModel.getPercentRange(); // Reset controllers.
+
+        setViewInfoToCoordSysRecord(api, dataZoomModel, {
+          pan: bind(getRangeHandlers.pan, this),
+          zoom: bind(getRangeHandlers.zoom, this),
+          scrollMove: bind(getRangeHandlers.scrollMove, this)
+        });
+      };
+
+      InsideZoomView.prototype.dispose = function () {
+        this._clear();
+
+        _super.prototype.dispose.apply(this, arguments);
+      };
+
+      InsideZoomView.prototype._clear = function () {
+        disposeCoordSysRecordIfNeeded(this.api, this.dataZoomModel);
+        this.range = null;
+      };
+
+      InsideZoomView.type = 'dataZoom.inside';
+      return InsideZoomView;
+    }(DataZoomView);
+
+    var getRangeHandlers = {
+      zoom: function (coordSysInfo, coordSysMainType, controller, e) {
+        var lastRange = this.range;
+        var range = lastRange.slice(); // Calculate transform by the first axis.
+
+        var axisModel = coordSysInfo.axisModels[0];
+
+        if (!axisModel) {
+          return;
+        }
+
+        var directionInfo = getDirectionInfo[coordSysMainType](null, [e.originX, e.originY], axisModel, controller, coordSysInfo);
+        var percentPoint = (directionInfo.signal > 0 ? directionInfo.pixelStart + directionInfo.pixelLength - directionInfo.pixel : directionInfo.pixel - directionInfo.pixelStart) / directionInfo.pixelLength * (range[1] - range[0]) + range[0];
+        var scale = Math.max(1 / e.scale, 0);
+        range[0] = (range[0] - percentPoint) * scale + percentPoint;
+        range[1] = (range[1] - percentPoint) * scale + percentPoint; // Restrict range.
+
+        var minMaxSpan = this.dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();
+        sliderMove(0, range, [0, 100], 0, minMaxSpan.minSpan, minMaxSpan.maxSpan);
+        this.range = range;
+
+        if (lastRange[0] !== range[0] || lastRange[1] !== range[1]) {
+          return range;
+        }
+      },
+      pan: makeMover(function (range, axisModel, coordSysInfo, coordSysMainType, controller, e) {
+        var directionInfo = getDirectionInfo[coordSysMainType]([e.oldX, e.oldY], [e.newX, e.newY], axisModel, controller, coordSysInfo);
+        return directionInfo.signal * (range[1] - range[0]) * directionInfo.pixel / directionInfo.pixelLength;
+      }),
+      scrollMove: makeMover(function (range, axisModel, coordSysInfo, coordSysMainType, controller, e) {
+        var directionInfo = getDirectionInfo[coordSysMainType]([0, 0], [e.scrollDelta, e.scrollDelta], axisModel, controller, coordSysInfo);
+        return directionInfo.signal * (range[1] - range[0]) * e.scrollDelta;
+      })
+    };
+
+    function makeMover(getPercentDelta) {
+      return function (coordSysInfo, coordSysMainType, controller, e) {
+        var lastRange = this.range;
+        var range = lastRange.slice(); // Calculate transform by the first axis.
+
+        var axisModel = coordSysInfo.axisModels[0];
+
+        if (!axisModel) {
+          return;
+        }
+
+        var percentDelta = getPercentDelta(range, axisModel, coordSysInfo, coordSysMainType, controller, e);
+        sliderMove(percentDelta, range, [0, 100], 'all');
+        this.range = range;
+
+        if (lastRange[0] !== range[0] || lastRange[1] !== range[1]) {
+          return range;
+        }
+      };
+    }
+
+    var getDirectionInfo = {
+      grid: function (oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+        var axis = axisModel.axis;
+        var ret = {};
+        var rect = coordSysInfo.model.coordinateSystem.getRect();
+        oldPoint = oldPoint || [0, 0];
+
+        if (axis.dim === 'x') {
+          ret.pixel = newPoint[0] - oldPoint[0];
+          ret.pixelLength = rect.width;
+          ret.pixelStart = rect.x;
+          ret.signal = axis.inverse ? 1 : -1;
+        } else {
+          // axis.dim === 'y'
+          ret.pixel = newPoint[1] - oldPoint[1];
+          ret.pixelLength = rect.height;
+          ret.pixelStart = rect.y;
+          ret.signal = axis.inverse ? -1 : 1;
+        }
+
+        return ret;
+      },
+      polar: function (oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+        var axis = axisModel.axis;
+        var ret = {};
+        var polar = coordSysInfo.model.coordinateSystem;
+        var radiusExtent = polar.getRadiusAxis().getExtent();
+        var angleExtent = polar.getAngleAxis().getExtent();
+        oldPoint = oldPoint ? polar.pointToCoord(oldPoint) : [0, 0];
+        newPoint = polar.pointToCoord(newPoint);
+
+        if (axisModel.mainType === 'radiusAxis') {
+          ret.pixel = newPoint[0] - oldPoint[0]; // ret.pixelLength = Math.abs(radiusExtent[1] - radiusExtent[0]);
+          // ret.pixelStart = Math.min(radiusExtent[0], radiusExtent[1]);
+
+          ret.pixelLength = radiusExtent[1] - radiusExtent[0];
+          ret.pixelStart = radiusExtent[0];
+          ret.signal = axis.inverse ? 1 : -1;
+        } else {
+          // 'angleAxis'
+          ret.pixel = newPoint[1] - oldPoint[1]; // ret.pixelLength = Math.abs(angleExtent[1] - angleExtent[0]);
+          // ret.pixelStart = Math.min(angleExtent[0], angleExtent[1]);
+
+          ret.pixelLength = angleExtent[1] - angleExtent[0];
+          ret.pixelStart = angleExtent[0];
+          ret.signal = axis.inverse ? -1 : 1;
+        }
+
+        return ret;
+      },
+      singleAxis: function (oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+        var axis = axisModel.axis;
+        var rect = coordSysInfo.model.coordinateSystem.getRect();
+        var ret = {};
+        oldPoint = oldPoint || [0, 0];
+
+        if (axis.orient === 'horizontal') {
+          ret.pixel = newPoint[0] - oldPoint[0];
+          ret.pixelLength = rect.width;
+          ret.pixelStart = rect.x;
+          ret.signal = axis.inverse ? 1 : -1;
+        } else {
+          // 'vertical'
+          ret.pixel = newPoint[1] - oldPoint[1];
+          ret.pixelLength = rect.height;
+          ret.pixelStart = rect.y;
+          ret.signal = axis.inverse ? -1 : 1;
+        }
+
+        return ret;
+      }
+    };
+
+    function install$K(registers) {
+      installCommon(registers);
+      registers.registerComponentModel(InsideZoomModel);
+      registers.registerComponentView(InsideZoomView);
+      installDataZoomRoamProcessor(registers);
+    }
+
+    var SliderZoomModel =
+    /** @class */
+    function (_super) {
+      __extends(SliderZoomModel, _super);
+
+      function SliderZoomModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SliderZoomModel.type;
+        return _this;
+      }
+
+      SliderZoomModel.type = 'dataZoom.slider';
+      SliderZoomModel.layoutMode = 'box';
+      SliderZoomModel.defaultOption = inheritDefaultOption(DataZoomModel.defaultOption, {
+        show: true,
+        // deault value can only be drived in view stage.
+        right: 'ph',
+        top: 'ph',
+        width: 'ph',
+        height: 'ph',
+        left: null,
+        bottom: null,
+        borderColor: '#d2dbee',
+        borderRadius: 3,
+        backgroundColor: 'rgba(47,69,84,0)',
+        // dataBackgroundColor: '#ddd',
+        dataBackground: {
+          lineStyle: {
+            color: '#d2dbee',
+            width: 0.5
+          },
+          areaStyle: {
+            color: '#d2dbee',
+            opacity: 0.2
+          }
+        },
+        selectedDataBackground: {
+          lineStyle: {
+            color: '#8fb0f7',
+            width: 0.5
+          },
+          areaStyle: {
+            color: '#8fb0f7',
+            opacity: 0.2
+          }
+        },
+        // Color of selected window.
+        fillerColor: 'rgba(135,175,274,0.2)',
+        handleIcon: 'path://M-9.35,34.56V42m0-40V9.5m-2,0h4a2,2,0,0,1,2,2v21a2,2,0,0,1-2,2h-4a2,2,0,0,1-2-2v-21A2,2,0,0,1-11.35,9.5Z',
+        // Percent of the slider height
+        handleSize: '100%',
+        handleStyle: {
+          color: '#fff',
+          borderColor: '#ACB8D1'
+        },
+        moveHandleSize: 7,
+        moveHandleIcon: 'path://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',
+        moveHandleStyle: {
+          color: '#D2DBEE',
+          opacity: 0.7
+        },
+        showDetail: true,
+        showDataShadow: 'auto',
+        realtime: true,
+        zoomLock: false,
+        textStyle: {
+          color: '#6E7079'
+        },
+        brushSelect: true,
+        brushStyle: {
+          color: 'rgba(135,175,274,0.15)'
+        },
+        emphasis: {
+          handleStyle: {
+            borderColor: '#8FB0F7'
+          },
+          moveHandleStyle: {
+            color: '#8FB0F7'
+          }
+        }
+      });
+      return SliderZoomModel;
+    }(DataZoomModel);
+
+    var Rect$2 = Rect; // Constants
+
+    var DEFAULT_LOCATION_EDGE_GAP = 7;
+    var DEFAULT_FRAME_BORDER_WIDTH = 1;
+    var DEFAULT_FILLER_SIZE = 30;
+    var DEFAULT_MOVE_HANDLE_SIZE = 7;
+    var HORIZONTAL = 'horizontal';
+    var VERTICAL = 'vertical';
+    var LABEL_GAP = 5;
+    var SHOW_DATA_SHADOW_SERIES_TYPE = ['line', 'bar', 'candlestick', 'scatter'];
+    var REALTIME_ANIMATION_CONFIG = {
+      easing: 'cubicOut',
+      duration: 100
+    };
+
+    var SliderZoomView =
+    /** @class */
+    function (_super) {
+      __extends(SliderZoomView, _super);
+
+      function SliderZoomView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = SliderZoomView.type;
+        _this._displayables = {};
+        return _this;
+      }
+
+      SliderZoomView.prototype.init = function (ecModel, api) {
+        this.api = api; // A unique handler for each dataZoom component
+
+        this._onBrush = bind(this._onBrush, this);
+        this._onBrushEnd = bind(this._onBrushEnd, this);
+      };
+
+      SliderZoomView.prototype.render = function (dataZoomModel, ecModel, api, payload) {
+        _super.prototype.render.apply(this, arguments);
+
+        createOrUpdate(this, '_dispatchZoomAction', dataZoomModel.get('throttle'), 'fixRate');
+        this._orient = dataZoomModel.getOrient();
+
+        if (dataZoomModel.get('show') === false) {
+          this.group.removeAll();
+          return;
+        }
+
+        if (dataZoomModel.noTarget()) {
+          this._clear();
+
+          this.group.removeAll();
+          return;
+        } // Notice: this._resetInterval() should not be executed when payload.type
+        // is 'dataZoom', origin this._range should be maintained, otherwise 'pan'
+        // or 'zoom' info will be missed because of 'throttle' of this.dispatchAction,
+
+
+        if (!payload || payload.type !== 'dataZoom' || payload.from !== this.uid) {
+          this._buildView();
+        }
+
+        this._updateView();
+      };
+
+      SliderZoomView.prototype.dispose = function () {
+        this._clear();
+
+        _super.prototype.dispose.apply(this, arguments);
+      };
+
+      SliderZoomView.prototype._clear = function () {
+        clear(this, '_dispatchZoomAction');
+        var zr = this.api.getZr();
+        zr.off('mousemove', this._onBrush);
+        zr.off('mouseup', this._onBrushEnd);
+      };
+
+      SliderZoomView.prototype._buildView = function () {
+        var thisGroup = this.group;
+        thisGroup.removeAll();
+        this._brushing = false;
+        this._displayables.brushRect = null;
+
+        this._resetLocation();
+
+        this._resetInterval();
+
+        var barGroup = this._displayables.sliderGroup = new Group();
+
+        this._renderBackground();
+
+        this._renderHandle();
+
+        this._renderDataShadow();
+
+        thisGroup.add(barGroup);
+
+        this._positionGroup();
+      };
+
+      SliderZoomView.prototype._resetLocation = function () {
+        var dataZoomModel = this.dataZoomModel;
+        var api = this.api;
+        var showMoveHandle = dataZoomModel.get('brushSelect');
+        var moveHandleSize = showMoveHandle ? DEFAULT_MOVE_HANDLE_SIZE : 0; // If some of x/y/width/height are not specified,
+        // auto-adapt according to target grid.
+
+        var coordRect = this._findCoordRect();
+
+        var ecSize = {
+          width: api.getWidth(),
+          height: api.getHeight()
+        }; // Default align by coordinate system rect.
+
+        var positionInfo = this._orient === HORIZONTAL ? {
+          // Why using 'right', because right should be used in vertical,
+          // and it is better to be consistent for dealing with position param merge.
+          right: ecSize.width - coordRect.x - coordRect.width,
+          top: ecSize.height - DEFAULT_FILLER_SIZE - DEFAULT_LOCATION_EDGE_GAP - moveHandleSize,
+          width: coordRect.width,
+          height: DEFAULT_FILLER_SIZE
+        } : {
+          right: DEFAULT_LOCATION_EDGE_GAP,
+          top: coordRect.y,
+          width: DEFAULT_FILLER_SIZE,
+          height: coordRect.height
+        }; // Do not write back to option and replace value 'ph', because
+        // the 'ph' value should be recalculated when resize.
+
+        var layoutParams = getLayoutParams(dataZoomModel.option); // Replace the placeholder value.
+
+        each(['right', 'top', 'width', 'height'], function (name) {
+          if (layoutParams[name] === 'ph') {
+            layoutParams[name] = positionInfo[name];
+          }
+        });
+        var layoutRect = getLayoutRect(layoutParams, ecSize);
+        this._location = {
+          x: layoutRect.x,
+          y: layoutRect.y
+        };
+        this._size = [layoutRect.width, layoutRect.height];
+        this._orient === VERTICAL && this._size.reverse();
+      };
+
+      SliderZoomView.prototype._positionGroup = function () {
+        var thisGroup = this.group;
+        var location = this._location;
+        var orient = this._orient; // Just use the first axis to determine mapping.
+
+        var targetAxisModel = this.dataZoomModel.getFirstTargetAxisModel();
+        var inverse = targetAxisModel && targetAxisModel.get('inverse');
+        var sliderGroup = this._displayables.sliderGroup;
+        var otherAxisInverse = (this._dataShadowInfo || {}).otherAxisInverse; // Transform barGroup.
+
+        sliderGroup.attr(orient === HORIZONTAL && !inverse ? {
+          scaleY: otherAxisInverse ? 1 : -1,
+          scaleX: 1
+        } : orient === HORIZONTAL && inverse ? {
+          scaleY: otherAxisInverse ? 1 : -1,
+          scaleX: -1
+        } : orient === VERTICAL && !inverse ? {
+          scaleY: otherAxisInverse ? -1 : 1,
+          scaleX: 1,
+          rotation: Math.PI / 2
+        } // Dont use Math.PI, considering shadow direction.
+        : {
+          scaleY: otherAxisInverse ? -1 : 1,
+          scaleX: -1,
+          rotation: Math.PI / 2
+        }); // Position barGroup
+
+        var rect = thisGroup.getBoundingRect([sliderGroup]);
+        thisGroup.x = location.x - rect.x;
+        thisGroup.y = location.y - rect.y;
+        thisGroup.markRedraw();
+      };
+
+      SliderZoomView.prototype._getViewExtent = function () {
+        return [0, this._size[0]];
+      };
+
+      SliderZoomView.prototype._renderBackground = function () {
+        var dataZoomModel = this.dataZoomModel;
+        var size = this._size;
+        var barGroup = this._displayables.sliderGroup;
+        var brushSelect = dataZoomModel.get('brushSelect');
+        barGroup.add(new Rect$2({
+          silent: true,
+          shape: {
+            x: 0,
+            y: 0,
+            width: size[0],
+            height: size[1]
+          },
+          style: {
+            fill: dataZoomModel.get('backgroundColor')
+          },
+          z2: -40
+        })); // Click panel, over shadow, below handles.
+
+        var clickPanel = new Rect$2({
+          shape: {
+            x: 0,
+            y: 0,
+            width: size[0],
+            height: size[1]
+          },
+          style: {
+            fill: 'transparent'
+          },
+          z2: 0,
+          onclick: bind(this._onClickPanel, this)
+        });
+        var zr = this.api.getZr();
+
+        if (brushSelect) {
+          clickPanel.on('mousedown', this._onBrushStart, this);
+          clickPanel.cursor = 'crosshair';
+          zr.on('mousemove', this._onBrush);
+          zr.on('mouseup', this._onBrushEnd);
+        } else {
+          zr.off('mousemove', this._onBrush);
+          zr.off('mouseup', this._onBrushEnd);
+        }
+
+        barGroup.add(clickPanel);
+      };
+
+      SliderZoomView.prototype._renderDataShadow = function () {
+        var info = this._dataShadowInfo = this._prepareDataShadowInfo();
+
+        this._displayables.dataShadowSegs = [];
+
+        if (!info) {
+          return;
+        }
+
+        var size = this._size;
+        var seriesModel = info.series;
+        var data = seriesModel.getRawData();
+        var otherDim = seriesModel.getShadowDim ? seriesModel.getShadowDim() // @see candlestick
+        : info.otherDim;
+
+        if (otherDim == null) {
+          return;
+        }
+
+        var otherDataExtent = data.getDataExtent(otherDim); // Nice extent.
+
+        var otherOffset = (otherDataExtent[1] - otherDataExtent[0]) * 0.3;
+        otherDataExtent = [otherDataExtent[0] - otherOffset, otherDataExtent[1] + otherOffset];
+        var otherShadowExtent = [0, size[1]];
+        var thisShadowExtent = [0, size[0]];
+        var areaPoints = [[size[0], 0], [0, 0]];
+        var linePoints = [];
+        var step = thisShadowExtent[1] / (data.count() - 1);
+        var thisCoord = 0; // Optimize for large data shadow
+
+        var stride = Math.round(data.count() / size[0]);
+        var lastIsEmpty;
+        data.each([otherDim], function (value, index) {
+          if (stride > 0 && index % stride) {
+            thisCoord += step;
+            return;
+          } // FIXME
+          // Should consider axis.min/axis.max when drawing dataShadow.
+          // FIXME
+          // 应该使用统一的空判断？还是在list里进行空判断？
+
+
+          var isEmpty = value == null || isNaN(value) || value === ''; // See #4235.
+
+          var otherCoord = isEmpty ? 0 : linearMap(value, otherDataExtent, otherShadowExtent, true); // Attempt to draw data shadow precisely when there are empty value.
+
+          if (isEmpty && !lastIsEmpty && index) {
+            areaPoints.push([areaPoints[areaPoints.length - 1][0], 0]);
+            linePoints.push([linePoints[linePoints.length - 1][0], 0]);
+          } else if (!isEmpty && lastIsEmpty) {
+            areaPoints.push([thisCoord, 0]);
+            linePoints.push([thisCoord, 0]);
+          }
+
+          areaPoints.push([thisCoord, otherCoord]);
+          linePoints.push([thisCoord, otherCoord]);
+          thisCoord += step;
+          lastIsEmpty = isEmpty;
+        });
+        var dataZoomModel = this.dataZoomModel;
+
+        function createDataShadowGroup(isSelectedArea) {
+          var model = dataZoomModel.getModel(isSelectedArea ? 'selectedDataBackground' : 'dataBackground');
+          var group = new Group();
+          var polygon = new Polygon({
+            shape: {
+              points: areaPoints
+            },
+            segmentIgnoreThreshold: 1,
+            style: model.getModel('areaStyle').getAreaStyle(),
+            silent: true,
+            z2: -20
+          });
+          var polyline = new Polyline({
+            shape: {
+              points: linePoints
+            },
+            segmentIgnoreThreshold: 1,
+            style: model.getModel('lineStyle').getLineStyle(),
+            silent: true,
+            z2: -19
+          });
+          group.add(polygon);
+          group.add(polyline);
+          return group;
+        } // let dataBackgroundModel = dataZoomModel.getModel('dataBackground');
+
+
+        for (var i = 0; i < 3; i++) {
+          var group = createDataShadowGroup(i === 1);
+
+          this._displayables.sliderGroup.add(group);
+
+          this._displayables.dataShadowSegs.push(group);
+        }
+      };
+
+      SliderZoomView.prototype._prepareDataShadowInfo = function () {
+        var dataZoomModel = this.dataZoomModel;
+        var showDataShadow = dataZoomModel.get('showDataShadow');
+
+        if (showDataShadow === false) {
+          return;
+        } // Find a representative series.
+
+
+        var result;
+        var ecModel = this.ecModel;
+        dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+          var seriesModels = dataZoomModel.getAxisProxy(axisDim, axisIndex).getTargetSeriesModels();
+          each(seriesModels, function (seriesModel) {
+            if (result) {
+              return;
+            }
+
+            if (showDataShadow !== true && indexOf(SHOW_DATA_SHADOW_SERIES_TYPE, seriesModel.get('type')) < 0) {
+              return;
+            }
+
+            var thisAxis = ecModel.getComponent(getAxisMainType(axisDim), axisIndex).axis;
+            var otherDim = getOtherDim(axisDim);
+            var otherAxisInverse;
+            var coordSys = seriesModel.coordinateSystem;
+
+            if (otherDim != null && coordSys.getOtherAxis) {
+              otherAxisInverse = coordSys.getOtherAxis(thisAxis).inverse;
+            }
+
+            otherDim = seriesModel.getData().mapDimension(otherDim);
+            result = {
+              thisAxis: thisAxis,
+              series: seriesModel,
+              thisDim: axisDim,
+              otherDim: otherDim,
+              otherAxisInverse: otherAxisInverse
+            };
+          }, this);
+        }, this);
+        return result;
+      };
+
+      SliderZoomView.prototype._renderHandle = function () {
+        var thisGroup = this.group;
+        var displayables = this._displayables;
+        var handles = displayables.handles = [null, null];
+        var handleLabels = displayables.handleLabels = [null, null];
+        var sliderGroup = this._displayables.sliderGroup;
+        var size = this._size;
+        var dataZoomModel = this.dataZoomModel;
+        var api = this.api;
+        var borderRadius = dataZoomModel.get('borderRadius') || 0;
+        var brushSelect = dataZoomModel.get('brushSelect');
+        var filler = displayables.filler = new Rect$2({
+          silent: brushSelect,
+          style: {
+            fill: dataZoomModel.get('fillerColor')
+          },
+          textConfig: {
+            position: 'inside'
+          }
+        });
+        sliderGroup.add(filler); // Frame border.
+
+        sliderGroup.add(new Rect$2({
+          silent: true,
+          subPixelOptimize: true,
+          shape: {
+            x: 0,
+            y: 0,
+            width: size[0],
+            height: size[1],
+            r: borderRadius
+          },
+          style: {
+            stroke: dataZoomModel.get('dataBackgroundColor') // deprecated option
+            || dataZoomModel.get('borderColor'),
+            lineWidth: DEFAULT_FRAME_BORDER_WIDTH,
+            fill: 'rgba(0,0,0,0)'
+          }
+        })); // Left and right handle to resize
+
+        each([0, 1], function (handleIndex) {
+          var iconStr = dataZoomModel.get('handleIcon');
+
+          if (!symbolBuildProxies[iconStr] && iconStr.indexOf('path://') < 0 && iconStr.indexOf('image://') < 0) {
+            // Compatitable with the old icon parsers. Which can use a path string without path://
+            iconStr = 'path://' + iconStr;
+
+            if ("development" !== 'production') {
+              deprecateLog('handleIcon now needs \'path://\' prefix when using a path string');
+            }
+          }
+
+          var path = createSymbol(iconStr, -1, 0, 2, 2, null, true);
+          path.attr({
+            cursor: getCursor(this._orient),
+            draggable: true,
+            drift: bind(this._onDragMove, this, handleIndex),
+            ondragend: bind(this._onDragEnd, this),
+            onmouseover: bind(this._showDataInfo, this, true),
+            onmouseout: bind(this._showDataInfo, this, false),
+            z2: 5
+          });
+          var bRect = path.getBoundingRect();
+          var handleSize = dataZoomModel.get('handleSize');
+          this._handleHeight = parsePercent$1(handleSize, this._size[1]);
+          this._handleWidth = bRect.width / bRect.height * this._handleHeight;
+          path.setStyle(dataZoomModel.getModel('handleStyle').getItemStyle());
+          path.style.strokeNoScale = true;
+          path.rectHover = true;
+          path.ensureState('emphasis').style = dataZoomModel.getModel(['emphasis', 'handleStyle']).getItemStyle();
+          enableHoverEmphasis(path);
+          var handleColor = dataZoomModel.get('handleColor'); // deprecated option
+          // Compatitable with previous version
+
+          if (handleColor != null) {
+            path.style.fill = handleColor;
+          }
+
+          sliderGroup.add(handles[handleIndex] = path);
+          var textStyleModel = dataZoomModel.getModel('textStyle');
+          thisGroup.add(handleLabels[handleIndex] = new ZRText({
+            silent: true,
+            invisible: true,
+            style: {
+              x: 0,
+              y: 0,
+              text: '',
+              verticalAlign: 'middle',
+              align: 'center',
+              fill: textStyleModel.getTextColor(),
+              font: textStyleModel.getFont()
+            },
+            z2: 10
+          }));
+        }, this); // Handle to move. Only visible when brushSelect is set true.
+
+        var actualMoveZone = filler;
+
+        if (brushSelect) {
+          var moveHandleHeight = parsePercent$1(dataZoomModel.get('moveHandleSize'), size[1]);
+          var moveHandle_1 = displayables.moveHandle = new Rect({
+            style: dataZoomModel.getModel('moveHandleStyle').getItemStyle(),
+            silent: true,
+            shape: {
+              r: [0, 0, 2, 2],
+              y: size[1] - 0.5,
+              height: moveHandleHeight
+            }
+          });
+          var iconSize = moveHandleHeight * 0.8;
+          var moveHandleIcon = displayables.moveHandleIcon = createSymbol(dataZoomModel.get('moveHandleIcon'), -iconSize / 2, -iconSize / 2, iconSize, iconSize, '#fff', true);
+          moveHandleIcon.silent = true;
+          moveHandleIcon.y = size[1] + moveHandleHeight / 2 - 0.5;
+          moveHandle_1.ensureState('emphasis').style = dataZoomModel.getModel(['emphasis', 'moveHandleStyle']).getItemStyle();
+          var moveZoneExpandSize = Math.min(size[1] / 2, Math.max(moveHandleHeight, 10));
+          actualMoveZone = displayables.moveZone = new Rect({
+            invisible: true,
+            shape: {
+              y: size[1] - moveZoneExpandSize,
+              height: moveHandleHeight + moveZoneExpandSize
+            }
+          });
+          actualMoveZone.on('mouseover', function () {
+            api.enterEmphasis(moveHandle_1);
+          }).on('mouseout', function () {
+            api.leaveEmphasis(moveHandle_1);
+          });
+          sliderGroup.add(moveHandle_1);
+          sliderGroup.add(moveHandleIcon);
+          sliderGroup.add(actualMoveZone);
+        }
+
+        actualMoveZone.attr({
+          draggable: true,
+          cursor: getCursor(this._orient),
+          drift: bind(this._onDragMove, this, 'all'),
+          ondragstart: bind(this._showDataInfo, this, true),
+          ondragend: bind(this._onDragEnd, this),
+          onmouseover: bind(this._showDataInfo, this, true),
+          onmouseout: bind(this._showDataInfo, this, false)
+        });
+      };
+
+      SliderZoomView.prototype._resetInterval = function () {
+        var range = this._range = this.dataZoomModel.getPercentRange();
+
+        var viewExtent = this._getViewExtent();
+
+        this._handleEnds = [linearMap(range[0], [0, 100], viewExtent, true), linearMap(range[1], [0, 100], viewExtent, true)];
+      };
+
+      SliderZoomView.prototype._updateInterval = function (handleIndex, delta) {
+        var dataZoomModel = this.dataZoomModel;
+        var handleEnds = this._handleEnds;
+
+        var viewExtend = this._getViewExtent();
+
+        var minMaxSpan = dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();
+        var percentExtent = [0, 100];
+        sliderMove(delta, handleEnds, viewExtend, dataZoomModel.get('zoomLock') ? 'all' : handleIndex, minMaxSpan.minSpan != null ? linearMap(minMaxSpan.minSpan, percentExtent, viewExtend, true) : null, minMaxSpan.maxSpan != null ? linearMap(minMaxSpan.maxSpan, percentExtent, viewExtend, true) : null);
+        var lastRange = this._range;
+        var range = this._range = asc([linearMap(handleEnds[0], viewExtend, percentExtent, true), linearMap(handleEnds[1], viewExtend, percentExtent, true)]);
+        return !lastRange || lastRange[0] !== range[0] || lastRange[1] !== range[1];
+      };
+
+      SliderZoomView.prototype._updateView = function (nonRealtime) {
+        var displaybles = this._displayables;
+        var handleEnds = this._handleEnds;
+        var handleInterval = asc(handleEnds.slice());
+        var size = this._size;
+        each([0, 1], function (handleIndex) {
+          // Handles
+          var handle = displaybles.handles[handleIndex];
+          var handleHeight = this._handleHeight;
+          handle.attr({
+            scaleX: handleHeight / 2,
+            scaleY: handleHeight / 2,
+            // This is a trick, by adding an extra tiny offset to let the default handle's end point align to the drag window.
+            // NOTE: It may affect some custom shapes a bit. But we prefer to have better result by default.
+            x: handleEnds[handleIndex] + (handleIndex ? -1 : 1),
+            y: size[1] / 2 - handleHeight / 2
+          });
+        }, this); // Filler
+
+        displaybles.filler.setShape({
+          x: handleInterval[0],
+          y: 0,
+          width: handleInterval[1] - handleInterval[0],
+          height: size[1]
+        });
+        var viewExtent = {
+          x: handleInterval[0],
+          width: handleInterval[1] - handleInterval[0]
+        }; // Move handle
+
+        if (displaybles.moveHandle) {
+          displaybles.moveHandle.setShape(viewExtent);
+          displaybles.moveZone.setShape(viewExtent); // Force update path on the invisible object
+
+          displaybles.moveZone.getBoundingRect();
+          displaybles.moveHandleIcon && displaybles.moveHandleIcon.attr('x', viewExtent.x + viewExtent.width / 2);
+        } // update clip path of shadow.
+
+
+        var dataShadowSegs = displaybles.dataShadowSegs;
+        var segIntervals = [0, handleInterval[0], handleInterval[1], size[0]];
+
+        for (var i = 0; i < dataShadowSegs.length; i++) {
+          var segGroup = dataShadowSegs[i];
+          var clipPath = segGroup.getClipPath();
+
+          if (!clipPath) {
+            clipPath = new Rect();
+            segGroup.setClipPath(clipPath);
+          }
+
+          clipPath.setShape({
+            x: segIntervals[i],
+            y: 0,
+            width: segIntervals[i + 1] - segIntervals[i],
+            height: size[1]
+          });
+        }
+
+        this._updateDataInfo(nonRealtime);
+      };
+
+      SliderZoomView.prototype._updateDataInfo = function (nonRealtime) {
+        var dataZoomModel = this.dataZoomModel;
+        var displaybles = this._displayables;
+        var handleLabels = displaybles.handleLabels;
+        var orient = this._orient;
+        var labelTexts = ['', '']; // FIXME
+        // date型，支持formatter，autoformatter（ec2 date.getAutoFormatter）
+
+        if (dataZoomModel.get('showDetail')) {
+          var axisProxy = dataZoomModel.findRepresentativeAxisProxy();
+
+          if (axisProxy) {
+            var axis = axisProxy.getAxisModel().axis;
+            var range = this._range;
+            var dataInterval = nonRealtime // See #4434, data and axis are not processed and reset yet in non-realtime mode.
+            ? axisProxy.calculateDataWindow({
+              start: range[0],
+              end: range[1]
+            }).valueWindow : axisProxy.getDataValueWindow();
+            labelTexts = [this._formatLabel(dataInterval[0], axis), this._formatLabel(dataInterval[1], axis)];
+          }
+        }
+
+        var orderedHandleEnds = asc(this._handleEnds.slice());
+        setLabel.call(this, 0);
+        setLabel.call(this, 1);
+
+        function setLabel(handleIndex) {
+          // Label
+          // Text should not transform by barGroup.
+          // Ignore handlers transform
+          var barTransform = getTransform(displaybles.handles[handleIndex].parent, this.group);
+          var direction = transformDirection(handleIndex === 0 ? 'right' : 'left', barTransform);
+          var offset = this._handleWidth / 2 + LABEL_GAP;
+          var textPoint = applyTransform$1([orderedHandleEnds[handleIndex] + (handleIndex === 0 ? -offset : offset), this._size[1] / 2], barTransform);
+          handleLabels[handleIndex].setStyle({
+            x: textPoint[0],
+            y: textPoint[1],
+            verticalAlign: orient === HORIZONTAL ? 'middle' : direction,
+            align: orient === HORIZONTAL ? direction : 'center',
+            text: labelTexts[handleIndex]
+          });
+        }
+      };
+
+      SliderZoomView.prototype._formatLabel = function (value, axis) {
+        var dataZoomModel = this.dataZoomModel;
+        var labelFormatter = dataZoomModel.get('labelFormatter');
+        var labelPrecision = dataZoomModel.get('labelPrecision');
+
+        if (labelPrecision == null || labelPrecision === 'auto') {
+          labelPrecision = axis.getPixelPrecision();
+        }
+
+        var valueStr = value == null || isNaN(value) ? '' // FIXME Glue code
+        : axis.type === 'category' || axis.type === 'time' ? axis.scale.getLabel({
+          value: Math.round(value)
+        }) // param of toFixed should less then 20.
+        : value.toFixed(Math.min(labelPrecision, 20));
+        return isFunction(labelFormatter) ? labelFormatter(value, valueStr) : isString(labelFormatter) ? labelFormatter.replace('{value}', valueStr) : valueStr;
+      };
+      /**
+       * @param showOrHide true: show, false: hide
+       */
+
+
+      SliderZoomView.prototype._showDataInfo = function (showOrHide) {
+        // Always show when drgging.
+        showOrHide = this._dragging || showOrHide;
+        var displayables = this._displayables;
+        var handleLabels = displayables.handleLabels;
+        handleLabels[0].attr('invisible', !showOrHide);
+        handleLabels[1].attr('invisible', !showOrHide); // Highlight move handle
+
+        displayables.moveHandle && this.api[showOrHide ? 'enterEmphasis' : 'leaveEmphasis'](displayables.moveHandle, 1);
+      };
+
+      SliderZoomView.prototype._onDragMove = function (handleIndex, dx, dy, event) {
+        this._dragging = true; // For mobile device, prevent screen slider on the button.
+
+        stop(event.event); // Transform dx, dy to bar coordination.
+
+        var barTransform = this._displayables.sliderGroup.getLocalTransform();
+
+        var vertex = applyTransform$1([dx, dy], barTransform, true);
+
+        var changed = this._updateInterval(handleIndex, vertex[0]);
+
+        var realtime = this.dataZoomModel.get('realtime');
+
+        this._updateView(!realtime); // Avoid dispatch dataZoom repeatly but range not changed,
+        // which cause bad visual effect when progressive enabled.
+
+
+        changed && realtime && this._dispatchZoomAction(true);
+      };
+
+      SliderZoomView.prototype._onDragEnd = function () {
+        this._dragging = false;
+
+        this._showDataInfo(false); // While in realtime mode and stream mode, dispatch action when
+        // drag end will cause the whole view rerender, which is unnecessary.
+
+
+        var realtime = this.dataZoomModel.get('realtime');
+        !realtime && this._dispatchZoomAction(false);
+      };
+
+      SliderZoomView.prototype._onClickPanel = function (e) {
+        var size = this._size;
+
+        var localPoint = this._displayables.sliderGroup.transformCoordToLocal(e.offsetX, e.offsetY);
+
+        if (localPoint[0] < 0 || localPoint[0] > size[0] || localPoint[1] < 0 || localPoint[1] > size[1]) {
+          return;
+        }
+
+        var handleEnds = this._handleEnds;
+        var center = (handleEnds[0] + handleEnds[1]) / 2;
+
+        var changed = this._updateInterval('all', localPoint[0] - center);
+
+        this._updateView();
+
+        changed && this._dispatchZoomAction(false);
+      };
+
+      SliderZoomView.prototype._onBrushStart = function (e) {
+        var x = e.offsetX;
+        var y = e.offsetY;
+        this._brushStart = new Point(x, y);
+        this._brushing = true;
+        this._brushStartTime = +new Date(); // this._updateBrushRect(x, y);
+      };
+
+      SliderZoomView.prototype._onBrushEnd = function (e) {
+        if (!this._brushing) {
+          return;
+        }
+
+        var brushRect = this._displayables.brushRect;
+        this._brushing = false;
+
+        if (!brushRect) {
+          return;
+        }
+
+        brushRect.attr('ignore', true);
+        var brushShape = brushRect.shape;
+        var brushEndTime = +new Date(); // console.log(brushEndTime - this._brushStartTime);
+
+        if (brushEndTime - this._brushStartTime < 200 && Math.abs(brushShape.width) < 5) {
+          // Will treat it as a click
+          return;
+        }
+
+        var viewExtend = this._getViewExtent();
+
+        var percentExtent = [0, 100];
+        this._range = asc([linearMap(brushShape.x, viewExtend, percentExtent, true), linearMap(brushShape.x + brushShape.width, viewExtend, percentExtent, true)]);
+        this._handleEnds = [brushShape.x, brushShape.x + brushShape.width];
+
+        this._updateView();
+
+        this._dispatchZoomAction(false);
+      };
+
+      SliderZoomView.prototype._onBrush = function (e) {
+        if (this._brushing) {
+          // For mobile device, prevent screen slider on the button.
+          stop(e.event);
+
+          this._updateBrushRect(e.offsetX, e.offsetY);
+        }
+      };
+
+      SliderZoomView.prototype._updateBrushRect = function (mouseX, mouseY) {
+        var displayables = this._displayables;
+        var dataZoomModel = this.dataZoomModel;
+        var brushRect = displayables.brushRect;
+
+        if (!brushRect) {
+          brushRect = displayables.brushRect = new Rect$2({
+            silent: true,
+            style: dataZoomModel.getModel('brushStyle').getItemStyle()
+          });
+          displayables.sliderGroup.add(brushRect);
+        }
+
+        brushRect.attr('ignore', false);
+        var brushStart = this._brushStart;
+        var sliderGroup = this._displayables.sliderGroup;
+        var endPoint = sliderGroup.transformCoordToLocal(mouseX, mouseY);
+        var startPoint = sliderGroup.transformCoordToLocal(brushStart.x, brushStart.y);
+        var size = this._size;
+        endPoint[0] = Math.max(Math.min(size[0], endPoint[0]), 0);
+        brushRect.setShape({
+          x: startPoint[0],
+          y: 0,
+          width: endPoint[0] - startPoint[0],
+          height: size[1]
+        });
+      };
+      /**
+       * This action will be throttled.
+       */
+
+
+      SliderZoomView.prototype._dispatchZoomAction = function (realtime) {
+        var range = this._range;
+        this.api.dispatchAction({
+          type: 'dataZoom',
+          from: this.uid,
+          dataZoomId: this.dataZoomModel.id,
+          animation: realtime ? REALTIME_ANIMATION_CONFIG : null,
+          start: range[0],
+          end: range[1]
+        });
+      };
+
+      SliderZoomView.prototype._findCoordRect = function () {
+        // Find the grid coresponding to the first axis referred by dataZoom.
+        var rect;
+        var coordSysInfoList = collectReferCoordSysModelInfo(this.dataZoomModel).infoList;
+
+        if (!rect && coordSysInfoList.length) {
+          var coordSys = coordSysInfoList[0].model.coordinateSystem;
+          rect = coordSys.getRect && coordSys.getRect();
+        }
+
+        if (!rect) {
+          var width = this.api.getWidth();
+          var height = this.api.getHeight();
+          rect = {
+            x: width * 0.2,
+            y: height * 0.2,
+            width: width * 0.6,
+            height: height * 0.6
+          };
+        }
+
+        return rect;
+      };
+
+      SliderZoomView.type = 'dataZoom.slider';
+      return SliderZoomView;
+    }(DataZoomView);
+
+    function getOtherDim(thisDim) {
+      // FIXME
+      // 这个逻辑和getOtherAxis里一致，但是写在这里是否不好
+      var map = {
+        x: 'y',
+        y: 'x',
+        radius: 'angle',
+        angle: 'radius'
+      };
+      return map[thisDim];
+    }
+
+    function getCursor(orient) {
+      return orient === 'vertical' ? 'ns-resize' : 'ew-resize';
+    }
+
+    function install$L(registers) {
+      registers.registerComponentModel(SliderZoomModel);
+      registers.registerComponentView(SliderZoomView);
+      installCommon(registers);
+    }
+
+    function install$M(registers) {
+      use(install$K);
+      use(install$L); // Do not install './dataZoomSelect',
+      // since it only work for toolbox dataZoom.
+    }
+
+    var visualDefault = {
+      /**
+       * @public
+       */
+      get: function (visualType, key, isCategory) {
+        var value = clone((defaultOption$1[visualType] || {})[key]);
+        return isCategory ? isArray(value) ? value[value.length - 1] : value : value;
+      }
+    };
+    var defaultOption$1 = {
+      color: {
+        active: ['#006edd', '#e0ffff'],
+        inactive: ['rgba(0,0,0,0)']
+      },
+      colorHue: {
+        active: [0, 360],
+        inactive: [0, 0]
+      },
+      colorSaturation: {
+        active: [0.3, 1],
+        inactive: [0, 0]
+      },
+      colorLightness: {
+        active: [0.9, 0.5],
+        inactive: [0, 0]
+      },
+      colorAlpha: {
+        active: [0.3, 1],
+        inactive: [0, 0]
+      },
+      opacity: {
+        active: [0.3, 1],
+        inactive: [0, 0]
+      },
+      symbol: {
+        active: ['circle', 'roundRect', 'diamond'],
+        inactive: ['none']
+      },
+      symbolSize: {
+        active: [10, 50],
+        inactive: [0, 0]
+      }
+    };
+
+    var mapVisual$1 = VisualMapping.mapVisual;
+    var eachVisual = VisualMapping.eachVisual;
+    var isArray$1 = isArray;
+    var each$f = each;
+    var asc$2 = asc;
+    var linearMap$1 = linearMap;
+
+    var VisualMapModel =
+    /** @class */
+    function (_super) {
+      __extends(VisualMapModel, _super);
+
+      function VisualMapModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = VisualMapModel.type;
+        _this.stateList = ['inRange', 'outOfRange'];
+        _this.replacableOptionKeys = ['inRange', 'outOfRange', 'target', 'controller', 'color'];
+        _this.layoutMode = {
+          type: 'box',
+          ignoreSize: true
+        };
+        /**
+         * [lowerBound, upperBound]
+         */
+
+        _this.dataBound = [-Infinity, Infinity];
+        _this.targetVisuals = {};
+        _this.controllerVisuals = {};
+        return _this;
+      }
+
+      VisualMapModel.prototype.init = function (option, parentModel, ecModel) {
+        this.mergeDefaultAndTheme(option, ecModel);
+      };
+      /**
+       * @protected
+       */
+
+
+      VisualMapModel.prototype.optionUpdated = function (newOption, isInit) {
+        var thisOption = this.option; // FIXME
+        // necessary?
+        // Disable realtime view update if canvas is not supported.
+
+        if (!env.canvasSupported) {
+          thisOption.realtime = false;
+        }
+
+        !isInit && replaceVisualOption(thisOption, newOption, this.replacableOptionKeys);
+        this.textStyleModel = this.getModel('textStyle');
+        this.resetItemSize();
+        this.completeVisualOption();
+      };
+      /**
+       * @protected
+       */
+
+
+      VisualMapModel.prototype.resetVisual = function (supplementVisualOption) {
+        var stateList = this.stateList;
+        supplementVisualOption = bind(supplementVisualOption, this);
+        this.controllerVisuals = createVisualMappings(this.option.controller, stateList, supplementVisualOption);
+        this.targetVisuals = createVisualMappings(this.option.target, stateList, supplementVisualOption);
+      };
+      /**
+       * @protected
+       * @return {Array.<number>} An array of series indices.
+       */
+
+
+      VisualMapModel.prototype.getTargetSeriesIndices = function () {
+        var optionSeriesIndex = this.option.seriesIndex;
+        var seriesIndices = [];
+
+        if (optionSeriesIndex == null || optionSeriesIndex === 'all') {
+          this.ecModel.eachSeries(function (seriesModel, index) {
+            seriesIndices.push(index);
+          });
+        } else {
+          seriesIndices = normalizeToArray(optionSeriesIndex);
+        }
+
+        return seriesIndices;
+      };
+      /**
+       * @public
+       */
+
+
+      VisualMapModel.prototype.eachTargetSeries = function (callback, context) {
+        each(this.getTargetSeriesIndices(), function (seriesIndex) {
+          var seriesModel = this.ecModel.getSeriesByIndex(seriesIndex);
+
+          if (seriesModel) {
+            callback.call(context, seriesModel);
+          }
+        }, this);
+      };
+      /**
+       * @pubilc
+       */
+
+
+      VisualMapModel.prototype.isTargetSeries = function (seriesModel) {
+        var is = false;
+        this.eachTargetSeries(function (model) {
+          model === seriesModel && (is = true);
+        });
+        return is;
+      };
+      /**
+       * @example
+       * this.formatValueText(someVal); // format single numeric value to text.
+       * this.formatValueText(someVal, true); // format single category value to text.
+       * this.formatValueText([min, max]); // format numeric min-max to text.
+       * this.formatValueText([this.dataBound[0], max]); // using data lower bound.
+       * this.formatValueText([min, this.dataBound[1]]); // using data upper bound.
+       *
+       * @param value Real value, or this.dataBound[0 or 1].
+       * @param isCategory Only available when value is number.
+       * @param edgeSymbols Open-close symbol when value is interval.
+       * @protected
+       */
+
+
+      VisualMapModel.prototype.formatValueText = function (value, isCategory, edgeSymbols) {
+        var option = this.option;
+        var precision = option.precision;
+        var dataBound = this.dataBound;
+        var formatter = option.formatter;
+        var isMinMax;
+        edgeSymbols = edgeSymbols || ['<', '>'];
+
+        if (isArray(value)) {
+          value = value.slice();
+          isMinMax = true;
+        }
+
+        var textValue = isCategory ? value // Value is string when isCategory
+        : isMinMax ? [toFixed(value[0]), toFixed(value[1])] : toFixed(value);
+
+        if (isString(formatter)) {
+          return formatter.replace('{value}', isMinMax ? textValue[0] : textValue).replace('{value2}', isMinMax ? textValue[1] : textValue);
+        } else if (isFunction(formatter)) {
+          return isMinMax ? formatter(value[0], value[1]) : formatter(value);
+        }
+
+        if (isMinMax) {
+          if (value[0] === dataBound[0]) {
+            return edgeSymbols[0] + ' ' + textValue[1];
+          } else if (value[1] === dataBound[1]) {
+            return edgeSymbols[1] + ' ' + textValue[0];
+          } else {
+            return textValue[0] + ' - ' + textValue[1];
+          }
+        } else {
+          // Format single value (includes category case).
+          return textValue;
+        }
+
+        function toFixed(val) {
+          return val === dataBound[0] ? 'min' : val === dataBound[1] ? 'max' : (+val).toFixed(Math.min(precision, 20));
+        }
+      };
+      /**
+       * @protected
+       */
+
+
+      VisualMapModel.prototype.resetExtent = function () {
+        var thisOption = this.option; // Can not calculate data extent by data here.
+        // Because series and data may be modified in processing stage.
+        // So we do not support the feature "auto min/max".
+
+        var extent = asc$2([thisOption.min, thisOption.max]);
+        this._dataExtent = extent;
+      };
+      /**
+       * Return  Concrete dimention. If return null/undefined, no dimension used.
+       */
+
+
+      VisualMapModel.prototype.getDataDimension = function (list) {
+        var optDim = this.option.dimension;
+        var listDimensions = list.dimensions;
+
+        if (optDim == null && !listDimensions.length) {
+          return;
+        }
+
+        if (optDim != null) {
+          return list.getDimension(optDim);
+        }
+
+        var dimNames = list.dimensions;
+
+        for (var i = dimNames.length - 1; i >= 0; i--) {
+          var dimName = dimNames[i];
+          var dimInfo = list.getDimensionInfo(dimName);
+
+          if (!dimInfo.isCalculationCoord) {
+            return dimName;
+          }
+        }
+      };
+
+      VisualMapModel.prototype.getExtent = function () {
+        return this._dataExtent.slice();
+      };
+
+      VisualMapModel.prototype.completeVisualOption = function () {
+        var ecModel = this.ecModel;
+        var thisOption = this.option;
+        var base = {
+          inRange: thisOption.inRange,
+          outOfRange: thisOption.outOfRange
+        };
+        var target = thisOption.target || (thisOption.target = {});
+        var controller = thisOption.controller || (thisOption.controller = {});
+        merge(target, base); // Do not override
+
+        merge(controller, base); // Do not override
+
+        var isCategory = this.isCategory();
+        completeSingle.call(this, target);
+        completeSingle.call(this, controller);
+        completeInactive.call(this, target, 'inRange', 'outOfRange'); // completeInactive.call(this, target, 'outOfRange', 'inRange');
+
+        completeController.call(this, controller);
+
+        function completeSingle(base) {
+          // Compatible with ec2 dataRange.color.
+          // The mapping order of dataRange.color is: [high value, ..., low value]
+          // whereas inRange.color and outOfRange.color is [low value, ..., high value]
+          // Notice: ec2 has no inverse.
+          if (isArray$1(thisOption.color) // If there has been inRange: {symbol: ...}, adding color is a mistake.
+          // So adding color only when no inRange defined.
+          && !base.inRange) {
+            base.inRange = {
+              color: thisOption.color.slice().reverse()
+            };
+          } // Compatible with previous logic, always give a defautl color, otherwise
+          // simple config with no inRange and outOfRange will not work.
+          // Originally we use visualMap.color as the default color, but setOption at
+          // the second time the default color will be erased. So we change to use
+          // constant DEFAULT_COLOR.
+          // If user do not want the default color, set inRange: {color: null}.
+
+
+          base.inRange = base.inRange || {
+            color: ecModel.get('gradientColor')
+          };
+        }
+
+        function completeInactive(base, stateExist, stateAbsent) {
+          var optExist = base[stateExist];
+          var optAbsent = base[stateAbsent];
+
+          if (optExist && !optAbsent) {
+            optAbsent = base[stateAbsent] = {};
+            each$f(optExist, function (visualData, visualType) {
+              if (!VisualMapping.isValidType(visualType)) {
+                return;
+              }
+
+              var defa = visualDefault.get(visualType, 'inactive', isCategory);
+
+              if (defa != null) {
+                optAbsent[visualType] = defa; // Compatibable with ec2:
+                // Only inactive color to rgba(0,0,0,0) can not
+                // make label transparent, so use opacity also.
+
+                if (visualType === 'color' && !optAbsent.hasOwnProperty('opacity') && !optAbsent.hasOwnProperty('colorAlpha')) {
+                  optAbsent.opacity = [0, 0];
+                }
+              }
+            });
+          }
+        }
+
+        function completeController(controller) {
+          var symbolExists = (controller.inRange || {}).symbol || (controller.outOfRange || {}).symbol;
+          var symbolSizeExists = (controller.inRange || {}).symbolSize || (controller.outOfRange || {}).symbolSize;
+          var inactiveColor = this.get('inactiveColor');
+          each$f(this.stateList, function (state) {
+            var itemSize = this.itemSize;
+            var visuals = controller[state]; // Set inactive color for controller if no other color
+            // attr (like colorAlpha) specified.
+
+            if (!visuals) {
+              visuals = controller[state] = {
+                color: isCategory ? inactiveColor : [inactiveColor]
+              };
+            } // Consistent symbol and symbolSize if not specified.
+
+
+            if (visuals.symbol == null) {
+              visuals.symbol = symbolExists && clone(symbolExists) || (isCategory ? 'roundRect' : ['roundRect']);
+            }
+
+            if (visuals.symbolSize == null) {
+              visuals.symbolSize = symbolSizeExists && clone(symbolSizeExists) || (isCategory ? itemSize[0] : [itemSize[0], itemSize[0]]);
+            } // Filter square and none.
+
+
+            visuals.symbol = mapVisual$1(visuals.symbol, function (symbol) {
+              return symbol === 'none' || symbol === 'square' ? 'roundRect' : symbol;
+            }); // Normalize symbolSize
+
+            var symbolSize = visuals.symbolSize;
+
+            if (symbolSize != null) {
+              var max_1 = -Infinity; // symbolSize can be object when categories defined.
+
+              eachVisual(symbolSize, function (value) {
+                value > max_1 && (max_1 = value);
+              });
+              visuals.symbolSize = mapVisual$1(symbolSize, function (value) {
+                return linearMap$1(value, [0, max_1], [0, itemSize[0]], true);
+              });
+            }
+          }, this);
+        }
+      };
+
+      VisualMapModel.prototype.resetItemSize = function () {
+        this.itemSize = [parseFloat(this.get('itemWidth')), parseFloat(this.get('itemHeight'))];
+      };
+
+      VisualMapModel.prototype.isCategory = function () {
+        return !!this.option.categories;
+      };
+      /**
+       * @public
+       * @abstract
+       */
+
+
+      VisualMapModel.prototype.setSelected = function (selected) {};
+
+      VisualMapModel.prototype.getSelected = function () {
+        return null;
+      };
+      /**
+       * @public
+       * @abstract
+       */
+
+
+      VisualMapModel.prototype.getValueState = function (value) {
+        return null;
+      };
+      /**
+       * FIXME
+       * Do not publish to thirt-part-dev temporarily
+       * util the interface is stable. (Should it return
+       * a function but not visual meta?)
+       *
+       * @pubilc
+       * @abstract
+       * @param getColorVisual
+       *        params: value, valueState
+       *        return: color
+       * @return {Object} visualMeta
+       *        should includes {stops, outerColors}
+       *        outerColor means [colorBeyondMinValue, colorBeyondMaxValue]
+       */
+
+
+      VisualMapModel.prototype.getVisualMeta = function (getColorVisual) {
+        return null;
+      };
+
+      VisualMapModel.type = 'visualMap';
+      VisualMapModel.dependencies = ['series'];
+      VisualMapModel.defaultOption = {
+        show: true,
+        zlevel: 0,
+        z: 4,
+        seriesIndex: 'all',
+        min: 0,
+        max: 200,
+        left: 0,
+        right: null,
+        top: null,
+        bottom: 0,
+        itemWidth: null,
+        itemHeight: null,
+        inverse: false,
+        orient: 'vertical',
+        backgroundColor: 'rgba(0,0,0,0)',
+        borderColor: '#ccc',
+        contentColor: '#5793f3',
+        inactiveColor: '#aaa',
+        borderWidth: 0,
+        padding: 5,
+        // 接受数组分别设定上右下左边距，同css
+        textGap: 10,
+        precision: 0,
+        textStyle: {
+          color: '#333' // 值域文字颜色
+
+        }
+      };
+      return VisualMapModel;
+    }(ComponentModel);
+
+    var DEFAULT_BAR_BOUND = [20, 140];
+
+    var ContinuousModel =
+    /** @class */
+    function (_super) {
+      __extends(ContinuousModel, _super);
+
+      function ContinuousModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ContinuousModel.type;
+        return _this;
+      }
+      /**
+       * @override
+       */
+
+
+      ContinuousModel.prototype.optionUpdated = function (newOption, isInit) {
+        _super.prototype.optionUpdated.apply(this, arguments);
+
+        this.resetExtent();
+        this.resetVisual(function (mappingOption) {
+          mappingOption.mappingMethod = 'linear';
+          mappingOption.dataExtent = this.getExtent();
+        });
+
+        this._resetRange();
+      };
+      /**
+       * @protected
+       * @override
+       */
+
+
+      ContinuousModel.prototype.resetItemSize = function () {
+        _super.prototype.resetItemSize.apply(this, arguments);
+
+        var itemSize = this.itemSize;
+        (itemSize[0] == null || isNaN(itemSize[0])) && (itemSize[0] = DEFAULT_BAR_BOUND[0]);
+        (itemSize[1] == null || isNaN(itemSize[1])) && (itemSize[1] = DEFAULT_BAR_BOUND[1]);
+      };
+      /**
+       * @private
+       */
+
+
+      ContinuousModel.prototype._resetRange = function () {
+        var dataExtent = this.getExtent();
+        var range = this.option.range;
+
+        if (!range || range.auto) {
+          // `range` should always be array (so we dont use other
+          // value like 'auto') for user-friend. (consider getOption).
+          dataExtent.auto = 1;
+          this.option.range = dataExtent;
+        } else if (isArray(range)) {
+          if (range[0] > range[1]) {
+            range.reverse();
+          }
+
+          range[0] = Math.max(range[0], dataExtent[0]);
+          range[1] = Math.min(range[1], dataExtent[1]);
+        }
+      };
+      /**
+       * @protected
+       * @override
+       */
+
+
+      ContinuousModel.prototype.completeVisualOption = function () {
+        _super.prototype.completeVisualOption.apply(this, arguments);
+
+        each(this.stateList, function (state) {
+          var symbolSize = this.option.controller[state].symbolSize;
+
+          if (symbolSize && symbolSize[0] !== symbolSize[1]) {
+            symbolSize[0] = symbolSize[1] / 3; // For good looking.
+          }
+        }, this);
+      };
+      /**
+       * @override
+       */
+
+
+      ContinuousModel.prototype.setSelected = function (selected) {
+        this.option.range = selected.slice();
+
+        this._resetRange();
+      };
+      /**
+       * @public
+       */
+
+
+      ContinuousModel.prototype.getSelected = function () {
+        var dataExtent = this.getExtent();
+        var dataInterval = asc((this.get('range') || []).slice()); // Clamp
+
+        dataInterval[0] > dataExtent[1] && (dataInterval[0] = dataExtent[1]);
+        dataInterval[1] > dataExtent[1] && (dataInterval[1] = dataExtent[1]);
+        dataInterval[0] < dataExtent[0] && (dataInterval[0] = dataExtent[0]);
+        dataInterval[1] < dataExtent[0] && (dataInterval[1] = dataExtent[0]);
+        return dataInterval;
+      };
+      /**
+       * @override
+       */
+
+
+      ContinuousModel.prototype.getValueState = function (value) {
+        var range = this.option.range;
+        var dataExtent = this.getExtent(); // When range[0] === dataExtent[0], any value larger than dataExtent[0] maps to 'inRange'.
+        // range[1] is processed likewise.
+
+        return (range[0] <= dataExtent[0] || range[0] <= value) && (range[1] >= dataExtent[1] || value <= range[1]) ? 'inRange' : 'outOfRange';
+      };
+
+      ContinuousModel.prototype.findTargetDataIndices = function (range) {
+        var result = [];
+        this.eachTargetSeries(function (seriesModel) {
+          var dataIndices = [];
+          var data = seriesModel.getData();
+          data.each(this.getDataDimension(data), function (value, dataIndex) {
+            range[0] <= value && value <= range[1] && dataIndices.push(dataIndex);
+          }, this);
+          result.push({
+            seriesId: seriesModel.id,
+            dataIndex: dataIndices
+          });
+        }, this);
+        return result;
+      };
+      /**
+       * @implement
+       */
+
+
+      ContinuousModel.prototype.getVisualMeta = function (getColorVisual) {
+        var oVals = getColorStopValues(this, 'outOfRange', this.getExtent());
+        var iVals = getColorStopValues(this, 'inRange', this.option.range.slice());
+        var stops = [];
+
+        function setStop(value, valueState) {
+          stops.push({
+            value: value,
+            color: getColorVisual(value, valueState)
+          });
+        } // Format to: outOfRange -- inRange -- outOfRange.
+
+
+        var iIdx = 0;
+        var oIdx = 0;
+        var iLen = iVals.length;
+        var oLen = oVals.length;
+
+        for (; oIdx < oLen && (!iVals.length || oVals[oIdx] <= iVals[0]); oIdx++) {
+          // If oVal[oIdx] === iVals[iIdx], oVal[oIdx] should be ignored.
+          if (oVals[oIdx] < iVals[iIdx]) {
+            setStop(oVals[oIdx], 'outOfRange');
+          }
+        }
+
+        for (var first = 1; iIdx < iLen; iIdx++, first = 0) {
+          // If range is full, value beyond min, max will be clamped.
+          // make a singularity
+          first && stops.length && setStop(iVals[iIdx], 'outOfRange');
+          setStop(iVals[iIdx], 'inRange');
+        }
+
+        for (var first = 1; oIdx < oLen; oIdx++) {
+          if (!iVals.length || iVals[iVals.length - 1] < oVals[oIdx]) {
+            // make a singularity
+            if (first) {
+              stops.length && setStop(stops[stops.length - 1].value, 'outOfRange');
+              first = 0;
+            }
+
+            setStop(oVals[oIdx], 'outOfRange');
+          }
+        }
+
+        var stopsLen = stops.length;
+        return {
+          stops: stops,
+          outerColors: [stopsLen ? stops[0].color : 'transparent', stopsLen ? stops[stopsLen - 1].color : 'transparent']
+        };
+      };
+
+      ContinuousModel.type = 'visualMap.continuous';
+      ContinuousModel.defaultOption = inheritDefaultOption(VisualMapModel.defaultOption, {
+        align: 'auto',
+        calculable: false,
+        hoverLink: true,
+        realtime: true,
+        handleIcon: 'path://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',
+        handleSize: '120%',
+        handleStyle: {
+          borderColor: '#fff',
+          borderWidth: 1
+        },
+        indicatorIcon: 'circle',
+        indicatorSize: '50%',
+        indicatorStyle: {
+          borderColor: '#fff',
+          borderWidth: 2,
+          shadowBlur: 2,
+          shadowOffsetX: 1,
+          shadowOffsetY: 1,
+          shadowColor: 'rgba(0,0,0,0.2)'
+        } // emphasis: {
+        //     handleStyle: {
+        //         shadowBlur: 3,
+        //         shadowOffsetX: 1,
+        //         shadowOffsetY: 1,
+        //         shadowColor: 'rgba(0,0,0,0.2)'
+        //     }
+        // }
+
+      });
+      return ContinuousModel;
+    }(VisualMapModel);
+
+    function getColorStopValues(visualMapModel, valueState, dataExtent) {
+      if (dataExtent[0] === dataExtent[1]) {
+        return dataExtent.slice();
+      } // When using colorHue mapping, it is not linear color any more.
+      // Moreover, canvas gradient seems not to be accurate linear.
+      // FIXME
+      // Should be arbitrary value 100? or based on pixel size?
+
+
+      var count = 200;
+      var step = (dataExtent[1] - dataExtent[0]) / count;
+      var value = dataExtent[0];
+      var stopValues = [];
+
+      for (var i = 0; i <= count && value < dataExtent[1]; i++) {
+        stopValues.push(value);
+        value += step;
+      }
+
+      stopValues.push(dataExtent[1]);
+      return stopValues;
+    }
+
+    var VisualMapView =
+    /** @class */
+    function (_super) {
+      __extends(VisualMapView, _super);
+
+      function VisualMapView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = VisualMapView.type;
+        _this.autoPositionValues = {
+          left: 1,
+          right: 1,
+          top: 1,
+          bottom: 1
+        };
+        return _this;
+      }
+
+      VisualMapView.prototype.init = function (ecModel, api) {
+        this.ecModel = ecModel;
+        this.api = api;
+      };
+      /**
+       * @protected
+       */
+
+
+      VisualMapView.prototype.render = function (visualMapModel, ecModel, api, payload // TODO: TYPE
+      ) {
+        this.visualMapModel = visualMapModel;
+
+        if (visualMapModel.get('show') === false) {
+          this.group.removeAll();
+          return;
+        }
+
+        this.doRender(visualMapModel, ecModel, api, payload);
+      };
+      /**
+       * @protected
+       */
+
+
+      VisualMapView.prototype.renderBackground = function (group) {
+        var visualMapModel = this.visualMapModel;
+        var padding = normalizeCssArray$1(visualMapModel.get('padding') || 0);
+        var rect = group.getBoundingRect();
+        group.add(new Rect({
+          z2: -1,
+          silent: true,
+          shape: {
+            x: rect.x - padding[3],
+            y: rect.y - padding[0],
+            width: rect.width + padding[3] + padding[1],
+            height: rect.height + padding[0] + padding[2]
+          },
+          style: {
+            fill: visualMapModel.get('backgroundColor'),
+            stroke: visualMapModel.get('borderColor'),
+            lineWidth: visualMapModel.get('borderWidth')
+          }
+        }));
+      };
+      /**
+       * @protected
+       * @param targetValue can be Infinity or -Infinity
+       * @param visualCluster Only can be 'color' 'opacity' 'symbol' 'symbolSize'
+       * @param opts
+       * @param opts.forceState Specify state, instead of using getValueState method.
+       * @param opts.convertOpacityToAlpha For color gradient in controller widget.
+       * @return {*} Visual value.
+       */
+
+
+      VisualMapView.prototype.getControllerVisual = function (targetValue, visualCluster, opts) {
+        opts = opts || {};
+        var forceState = opts.forceState;
+        var visualMapModel = this.visualMapModel;
+        var visualObj = {}; // Default values.
+
+        if (visualCluster === 'symbol') {
+          visualObj.symbol = visualMapModel.get('itemSymbol');
+        }
+
+        if (visualCluster === 'color') {
+          var defaultColor = visualMapModel.get('contentColor');
+          visualObj.color = defaultColor;
+        }
+
+        function getter(key) {
+          return visualObj[key];
+        }
+
+        function setter(key, value) {
+          visualObj[key] = value;
+        }
+
+        var mappings = visualMapModel.controllerVisuals[forceState || visualMapModel.getValueState(targetValue)];
+        var visualTypes = VisualMapping.prepareVisualTypes(mappings);
+        each(visualTypes, function (type) {
+          var visualMapping = mappings[type];
+
+          if (opts.convertOpacityToAlpha && type === 'opacity') {
+            type = 'colorAlpha';
+            visualMapping = mappings.__alphaForOpacity;
+          }
+
+          if (VisualMapping.dependsOn(type, visualCluster)) {
+            visualMapping && visualMapping.applyVisual(targetValue, getter, setter);
+          }
+        });
+        return visualObj[visualCluster];
+      };
+
+      VisualMapView.prototype.positionGroup = function (group) {
+        var model = this.visualMapModel;
+        var api = this.api;
+        positionElement(group, model.getBoxLayoutParams(), {
+          width: api.getWidth(),
+          height: api.getHeight()
+        });
+      };
+
+      VisualMapView.prototype.doRender = function (visualMapModel, ecModel, api, payload) {};
+
+      VisualMapView.type = 'visualMap';
+      return VisualMapView;
+    }(ComponentView);
+
+    var paramsSet = [['left', 'right', 'width'], ['top', 'bottom', 'height']];
+    /**
+     * @param visualMapModel
+     * @param api
+     * @param itemSize always [short, long]
+     * @return {string} 'left' or 'right' or 'top' or 'bottom'
+     */
+
+    function getItemAlign(visualMapModel, api, itemSize) {
+      var modelOption = visualMapModel.option;
+      var itemAlign = modelOption.align;
+
+      if (itemAlign != null && itemAlign !== 'auto') {
+        return itemAlign;
+      } // Auto decision align.
+
+
+      var ecSize = {
+        width: api.getWidth(),
+        height: api.getHeight()
+      };
+      var realIndex = modelOption.orient === 'horizontal' ? 1 : 0;
+      var reals = paramsSet[realIndex];
+      var fakeValue = [0, null, 10];
+      var layoutInput = {};
+
+      for (var i = 0; i < 3; i++) {
+        layoutInput[paramsSet[1 - realIndex][i]] = fakeValue[i];
+        layoutInput[reals[i]] = i === 2 ? itemSize[0] : modelOption[reals[i]];
+      }
+
+      var rParam = [['x', 'width', 3], ['y', 'height', 0]][realIndex];
+      var rect = getLayoutRect(layoutInput, ecSize, modelOption.padding);
+      return reals[(rect.margin[rParam[2]] || 0) + rect[rParam[0]] + rect[rParam[1]] * 0.5 < ecSize[rParam[1]] * 0.5 ? 0 : 1];
+    }
+    /**
+     * Prepare dataIndex for outside usage, where dataIndex means rawIndex, and
+     * dataIndexInside means filtered index.
+     */
+    // TODO: TYPE more specified payload types.
+
+    function makeHighDownBatch(batch, visualMapModel) {
+      each(batch || [], function (batchItem) {
+        if (batchItem.dataIndex != null) {
+          batchItem.dataIndexInside = batchItem.dataIndex;
+          batchItem.dataIndex = null;
+        }
+
+        batchItem.highlightKey = 'visualMap' + (visualMapModel ? visualMapModel.componentIndex : '');
+      });
+      return batch;
+    }
+
+    var linearMap$2 = linearMap;
+    var each$g = each;
+    var mathMin$a = Math.min;
+    var mathMax$a = Math.max; // Arbitrary value
+
+    var HOVER_LINK_SIZE = 12;
+    var HOVER_LINK_OUT = 6; // Notice:
+    // Any "interval" should be by the order of [low, high].
+    // "handle0" (handleIndex === 0) maps to
+    // low data value: this._dataInterval[0] and has low coord.
+    // "handle1" (handleIndex === 1) maps to
+    // high data value: this._dataInterval[1] and has high coord.
+    // The logic of transform is implemented in this._createBarGroup.
+
+    var ContinuousView =
+    /** @class */
+    function (_super) {
+      __extends(ContinuousView, _super);
+
+      function ContinuousView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = ContinuousView.type;
+        _this._shapes = {};
+        _this._dataInterval = [];
+        _this._handleEnds = [];
+        _this._hoverLinkDataIndices = [];
+        return _this;
+      }
+
+      ContinuousView.prototype.doRender = function (visualMapModel, ecModel, api, payload) {
+        this._api = api;
+
+        if (!payload || payload.type !== 'selectDataRange' || payload.from !== this.uid) {
+          this._buildView();
+        }
+      };
+
+      ContinuousView.prototype._buildView = function () {
+        this.group.removeAll();
+        var visualMapModel = this.visualMapModel;
+        var thisGroup = this.group;
+        this._orient = visualMapModel.get('orient');
+        this._useHandle = visualMapModel.get('calculable');
+
+        this._resetInterval();
+
+        this._renderBar(thisGroup);
+
+        var dataRangeText = visualMapModel.get('text');
+
+        this._renderEndsText(thisGroup, dataRangeText, 0);
+
+        this._renderEndsText(thisGroup, dataRangeText, 1); // Do this for background size calculation.
+
+
+        this._updateView(true); // After updating view, inner shapes is built completely,
+        // and then background can be rendered.
+
+
+        this.renderBackground(thisGroup); // Real update view
+
+        this._updateView();
+
+        this._enableHoverLinkToSeries();
+
+        this._enableHoverLinkFromSeries();
+
+        this.positionGroup(thisGroup);
+      };
+
+      ContinuousView.prototype._renderEndsText = function (group, dataRangeText, endsIndex) {
+        if (!dataRangeText) {
+          return;
+        } // Compatible with ec2, text[0] map to high value, text[1] map low value.
+
+
+        var text = dataRangeText[1 - endsIndex];
+        text = text != null ? text + '' : '';
+        var visualMapModel = this.visualMapModel;
+        var textGap = visualMapModel.get('textGap');
+        var itemSize = visualMapModel.itemSize;
+        var barGroup = this._shapes.mainGroup;
+
+        var position = this._applyTransform([itemSize[0] / 2, endsIndex === 0 ? -textGap : itemSize[1] + textGap], barGroup);
+
+        var align = this._applyTransform(endsIndex === 0 ? 'bottom' : 'top', barGroup);
+
+        var orient = this._orient;
+        var textStyleModel = this.visualMapModel.textStyleModel;
+        this.group.add(new ZRText({
+          style: {
+            x: position[0],
+            y: position[1],
+            verticalAlign: orient === 'horizontal' ? 'middle' : align,
+            align: orient === 'horizontal' ? align : 'center',
+            text: text,
+            font: textStyleModel.getFont(),
+            fill: textStyleModel.getTextColor()
+          }
+        }));
+      };
+
+      ContinuousView.prototype._renderBar = function (targetGroup) {
+        var visualMapModel = this.visualMapModel;
+        var shapes = this._shapes;
+        var itemSize = visualMapModel.itemSize;
+        var orient = this._orient;
+        var useHandle = this._useHandle;
+        var itemAlign = getItemAlign(visualMapModel, this.api, itemSize);
+
+        var mainGroup = shapes.mainGroup = this._createBarGroup(itemAlign);
+
+        var gradientBarGroup = new Group();
+        mainGroup.add(gradientBarGroup); // Bar
+
+        gradientBarGroup.add(shapes.outOfRange = createPolygon());
+        gradientBarGroup.add(shapes.inRange = createPolygon(null, useHandle ? getCursor$1(this._orient) : null, bind(this._dragHandle, this, 'all', false), bind(this._dragHandle, this, 'all', true))); // A border radius clip.
+
+        gradientBarGroup.setClipPath(new Rect({
+          shape: {
+            x: 0,
+            y: 0,
+            width: itemSize[0],
+            height: itemSize[1],
+            r: 3
+          }
+        }));
+        var textRect = visualMapModel.textStyleModel.getTextRect('国');
+        var textSize = mathMax$a(textRect.width, textRect.height); // Handle
+
+        if (useHandle) {
+          shapes.handleThumbs = [];
+          shapes.handleLabels = [];
+          shapes.handleLabelPoints = [];
+
+          this._createHandle(visualMapModel, mainGroup, 0, itemSize, textSize, orient);
+
+          this._createHandle(visualMapModel, mainGroup, 1, itemSize, textSize, orient);
+        }
+
+        this._createIndicator(visualMapModel, mainGroup, itemSize, textSize, orient);
+
+        targetGroup.add(mainGroup);
+      };
+
+      ContinuousView.prototype._createHandle = function (visualMapModel, mainGroup, handleIndex, itemSize, textSize, orient) {
+        var onDrift = bind(this._dragHandle, this, handleIndex, false);
+        var onDragEnd = bind(this._dragHandle, this, handleIndex, true);
+        var handleSize = parsePercent(visualMapModel.get('handleSize'), itemSize[0]);
+        var handleThumb = createSymbol(visualMapModel.get('handleIcon'), -handleSize / 2, -handleSize / 2, handleSize, handleSize, null, true);
+        var cursor = getCursor$1(this._orient);
+        handleThumb.attr({
+          cursor: cursor,
+          draggable: true,
+          drift: onDrift,
+          ondragend: onDragEnd,
+          onmousemove: function (e) {
+            stop(e.event);
+          }
+        });
+        handleThumb.x = itemSize[0] / 2;
+        handleThumb.useStyle(visualMapModel.getModel('handleStyle').getItemStyle());
+        handleThumb.setStyle({
+          strokeNoScale: true,
+          strokeFirst: true
+        });
+        handleThumb.style.lineWidth *= 2;
+        handleThumb.ensureState('emphasis').style = visualMapModel.getModel(['emphasis', 'handleStyle']).getItemStyle();
+        setAsHighDownDispatcher(handleThumb, true);
+        mainGroup.add(handleThumb); // Text is always horizontal layout but should not be effected by
+        // transform (orient/inverse). So label is built separately but not
+        // use zrender/graphic/helper/RectText, and is located based on view
+        // group (according to handleLabelPoint) but not barGroup.
+
+        var textStyleModel = this.visualMapModel.textStyleModel;
+        var handleLabel = new ZRText({
+          cursor: cursor,
+          draggable: true,
+          drift: onDrift,
+          onmousemove: function (e) {
+            // Fot mobile devicem, prevent screen slider on the button.
+            stop(e.event);
+          },
+          ondragend: onDragEnd,
+          style: {
+            x: 0,
+            y: 0,
+            text: '',
+            font: textStyleModel.getFont(),
+            fill: textStyleModel.getTextColor()
+          }
+        });
+        handleLabel.ensureState('blur').style = {
+          opacity: 0.1
+        };
+        handleLabel.stateTransition = {
+          duration: 200
+        };
+        this.group.add(handleLabel);
+        var handleLabelPoint = [handleSize, 0];
+        var shapes = this._shapes;
+        shapes.handleThumbs[handleIndex] = handleThumb;
+        shapes.handleLabelPoints[handleIndex] = handleLabelPoint;
+        shapes.handleLabels[handleIndex] = handleLabel;
+      };
+
+      ContinuousView.prototype._createIndicator = function (visualMapModel, mainGroup, itemSize, textSize, orient) {
+        var scale = parsePercent(visualMapModel.get('indicatorSize'), itemSize[0]);
+        var indicator = createSymbol(visualMapModel.get('indicatorIcon'), -scale / 2, -scale / 2, scale, scale, null, true);
+        indicator.attr({
+          cursor: 'move',
+          invisible: true,
+          silent: true,
+          x: itemSize[0] / 2
+        });
+        var indicatorStyle = visualMapModel.getModel('indicatorStyle').getItemStyle();
+
+        if (indicator instanceof ZRImage) {
+          var pathStyle = indicator.style;
+          indicator.useStyle(extend({
+            // TODO other properties like x, y ?
+            image: pathStyle.image,
+            x: pathStyle.x,
+            y: pathStyle.y,
+            width: pathStyle.width,
+            height: pathStyle.height
+          }, indicatorStyle));
+        } else {
+          indicator.useStyle(indicatorStyle);
+        }
+
+        mainGroup.add(indicator);
+        var textStyleModel = this.visualMapModel.textStyleModel;
+        var indicatorLabel = new ZRText({
+          silent: true,
+          invisible: true,
+          style: {
+            x: 0,
+            y: 0,
+            text: '',
+            font: textStyleModel.getFont(),
+            fill: textStyleModel.getTextColor()
+          }
+        });
+        this.group.add(indicatorLabel);
+        var indicatorLabelPoint = [(orient === 'horizontal' ? textSize / 2 : HOVER_LINK_OUT) + itemSize[0] / 2, 0];
+        var shapes = this._shapes;
+        shapes.indicator = indicator;
+        shapes.indicatorLabel = indicatorLabel;
+        shapes.indicatorLabelPoint = indicatorLabelPoint;
+        this._firstShowIndicator = true;
+      };
+
+      ContinuousView.prototype._dragHandle = function (handleIndex, isEnd, // dx is event from ondragend if isEnd is true. It's not used
+      dx, dy) {
+        if (!this._useHandle) {
+          return;
+        }
+
+        this._dragging = !isEnd;
+
+        if (!isEnd) {
+          // Transform dx, dy to bar coordination.
+          var vertex = this._applyTransform([dx, dy], this._shapes.mainGroup, true);
+
+          this._updateInterval(handleIndex, vertex[1]);
+
+          this._hideIndicator(); // Considering realtime, update view should be executed
+          // before dispatch action.
+
+
+          this._updateView();
+        } // dragEnd do not dispatch action when realtime.
+
+
+        if (isEnd === !this.visualMapModel.get('realtime')) {
+          // jshint ignore:line
+          this.api.dispatchAction({
+            type: 'selectDataRange',
+            from: this.uid,
+            visualMapId: this.visualMapModel.id,
+            selected: this._dataInterval.slice()
+          });
+        }
+
+        if (isEnd) {
+          !this._hovering && this._clearHoverLinkToSeries();
+        } else if (useHoverLinkOnHandle(this.visualMapModel)) {
+          this._doHoverLinkToSeries(this._handleEnds[handleIndex], false);
+        }
+      };
+
+      ContinuousView.prototype._resetInterval = function () {
+        var visualMapModel = this.visualMapModel;
+        var dataInterval = this._dataInterval = visualMapModel.getSelected();
+        var dataExtent = visualMapModel.getExtent();
+        var sizeExtent = [0, visualMapModel.itemSize[1]];
+        this._handleEnds = [linearMap$2(dataInterval[0], dataExtent, sizeExtent, true), linearMap$2(dataInterval[1], dataExtent, sizeExtent, true)];
+      };
+      /**
+       * @private
+       * @param {(number|string)} handleIndex 0 or 1 or 'all'
+       * @param {number} dx
+       * @param {number} dy
+       */
+
+
+      ContinuousView.prototype._updateInterval = function (handleIndex, delta) {
+        delta = delta || 0;
+        var visualMapModel = this.visualMapModel;
+        var handleEnds = this._handleEnds;
+        var sizeExtent = [0, visualMapModel.itemSize[1]];
+        sliderMove(delta, handleEnds, sizeExtent, handleIndex, // cross is forbiden
+        0);
+        var dataExtent = visualMapModel.getExtent(); // Update data interval.
+
+        this._dataInterval = [linearMap$2(handleEnds[0], sizeExtent, dataExtent, true), linearMap$2(handleEnds[1], sizeExtent, dataExtent, true)];
+      };
+
+      ContinuousView.prototype._updateView = function (forSketch) {
+        var visualMapModel = this.visualMapModel;
+        var dataExtent = visualMapModel.getExtent();
+        var shapes = this._shapes;
+        var outOfRangeHandleEnds = [0, visualMapModel.itemSize[1]];
+        var inRangeHandleEnds = forSketch ? outOfRangeHandleEnds : this._handleEnds;
+
+        var visualInRange = this._createBarVisual(this._dataInterval, dataExtent, inRangeHandleEnds, 'inRange');
+
+        var visualOutOfRange = this._createBarVisual(dataExtent, dataExtent, outOfRangeHandleEnds, 'outOfRange');
+
+        shapes.inRange.setStyle({
+          fill: visualInRange.barColor // opacity: visualInRange.opacity
+
+        }).setShape('points', visualInRange.barPoints);
+        shapes.outOfRange.setStyle({
+          fill: visualOutOfRange.barColor // opacity: visualOutOfRange.opacity
+
+        }).setShape('points', visualOutOfRange.barPoints);
+
+        this._updateHandle(inRangeHandleEnds, visualInRange);
+      };
+
+      ContinuousView.prototype._createBarVisual = function (dataInterval, dataExtent, handleEnds, forceState) {
+        var opts = {
+          forceState: forceState,
+          convertOpacityToAlpha: true
+        };
+
+        var colorStops = this._makeColorGradient(dataInterval, opts);
+
+        var symbolSizes = [this.getControllerVisual(dataInterval[0], 'symbolSize', opts), this.getControllerVisual(dataInterval[1], 'symbolSize', opts)];
+
+        var barPoints = this._createBarPoints(handleEnds, symbolSizes);
+
+        return {
+          barColor: new LinearGradient(0, 0, 0, 1, colorStops),
+          barPoints: barPoints,
+          handlesColor: [colorStops[0].color, colorStops[colorStops.length - 1].color]
+        };
+      };
+
+      ContinuousView.prototype._makeColorGradient = function (dataInterval, opts) {
+        // Considering colorHue, which is not linear, so we have to sample
+        // to calculate gradient color stops, but not only caculate head
+        // and tail.
+        var sampleNumber = 100; // Arbitrary value.
+
+        var colorStops = [];
+        var step = (dataInterval[1] - dataInterval[0]) / sampleNumber;
+        colorStops.push({
+          color: this.getControllerVisual(dataInterval[0], 'color', opts),
+          offset: 0
+        });
+
+        for (var i = 1; i < sampleNumber; i++) {
+          var currValue = dataInterval[0] + step * i;
+
+          if (currValue > dataInterval[1]) {
+            break;
+          }
+
+          colorStops.push({
+            color: this.getControllerVisual(currValue, 'color', opts),
+            offset: i / sampleNumber
+          });
+        }
+
+        colorStops.push({
+          color: this.getControllerVisual(dataInterval[1], 'color', opts),
+          offset: 1
+        });
+        return colorStops;
+      };
+
+      ContinuousView.prototype._createBarPoints = function (handleEnds, symbolSizes) {
+        var itemSize = this.visualMapModel.itemSize;
+        return [[itemSize[0] - symbolSizes[0], handleEnds[0]], [itemSize[0], handleEnds[0]], [itemSize[0], handleEnds[1]], [itemSize[0] - symbolSizes[1], handleEnds[1]]];
+      };
+
+      ContinuousView.prototype._createBarGroup = function (itemAlign) {
+        var orient = this._orient;
+        var inverse = this.visualMapModel.get('inverse');
+        return new Group(orient === 'horizontal' && !inverse ? {
+          scaleX: itemAlign === 'bottom' ? 1 : -1,
+          rotation: Math.PI / 2
+        } : orient === 'horizontal' && inverse ? {
+          scaleX: itemAlign === 'bottom' ? -1 : 1,
+          rotation: -Math.PI / 2
+        } : orient === 'vertical' && !inverse ? {
+          scaleX: itemAlign === 'left' ? 1 : -1,
+          scaleY: -1
+        } : {
+          scaleX: itemAlign === 'left' ? 1 : -1
+        });
+      };
+
+      ContinuousView.prototype._updateHandle = function (handleEnds, visualInRange) {
+        if (!this._useHandle) {
+          return;
+        }
+
+        var shapes = this._shapes;
+        var visualMapModel = this.visualMapModel;
+        var handleThumbs = shapes.handleThumbs;
+        var handleLabels = shapes.handleLabels;
+        var itemSize = visualMapModel.itemSize;
+        var dataExtent = visualMapModel.getExtent();
+        each$g([0, 1], function (handleIndex) {
+          var handleThumb = handleThumbs[handleIndex];
+          handleThumb.setStyle('fill', visualInRange.handlesColor[handleIndex]);
+          handleThumb.y = handleEnds[handleIndex];
+          var val = linearMap$2(handleEnds[handleIndex], [0, itemSize[1]], dataExtent, true);
+          var symbolSize = this.getControllerVisual(val, 'symbolSize');
+          handleThumb.scaleX = handleThumb.scaleY = symbolSize / itemSize[0];
+          handleThumb.x = itemSize[0] - symbolSize / 2; // Update handle label position.
+
+          var textPoint = applyTransform$1(shapes.handleLabelPoints[handleIndex], getTransform(handleThumb, this.group));
+          handleLabels[handleIndex].setStyle({
+            x: textPoint[0],
+            y: textPoint[1],
+            text: visualMapModel.formatValueText(this._dataInterval[handleIndex]),
+            verticalAlign: 'middle',
+            align: this._orient === 'vertical' ? this._applyTransform('left', shapes.mainGroup) : 'center'
+          });
+        }, this);
+      };
+
+      ContinuousView.prototype._showIndicator = function (cursorValue, textValue, rangeSymbol, halfHoverLinkSize) {
+        var visualMapModel = this.visualMapModel;
+        var dataExtent = visualMapModel.getExtent();
+        var itemSize = visualMapModel.itemSize;
+        var sizeExtent = [0, itemSize[1]];
+        var shapes = this._shapes;
+        var indicator = shapes.indicator;
+
+        if (!indicator) {
+          return;
+        }
+
+        indicator.attr('invisible', false);
+        var opts = {
+          convertOpacityToAlpha: true
+        };
+        var color = this.getControllerVisual(cursorValue, 'color', opts);
+        var symbolSize = this.getControllerVisual(cursorValue, 'symbolSize');
+        var y = linearMap$2(cursorValue, dataExtent, sizeExtent, true);
+        var x = itemSize[0] - symbolSize / 2;
+        var oldIndicatorPos = {
+          x: indicator.x,
+          y: indicator.y
+        }; // Update handle label position.
+
+        indicator.y = y;
+        indicator.x = x;
+        var textPoint = applyTransform$1(shapes.indicatorLabelPoint, getTransform(indicator, this.group));
+        var indicatorLabel = shapes.indicatorLabel;
+        indicatorLabel.attr('invisible', false);
+
+        var align = this._applyTransform('left', shapes.mainGroup);
+
+        var orient = this._orient;
+        var isHorizontal = orient === 'horizontal';
+        indicatorLabel.setStyle({
+          text: (rangeSymbol ? rangeSymbol : '') + visualMapModel.formatValueText(textValue),
+          verticalAlign: isHorizontal ? align : 'middle',
+          align: isHorizontal ? 'center' : align
+        });
+        var indicatorNewProps = {
+          x: x,
+          y: y,
+          style: {
+            fill: color
+          }
+        };
+        var labelNewProps = {
+          style: {
+            x: textPoint[0],
+            y: textPoint[1]
+          }
+        };
+
+        if (visualMapModel.ecModel.isAnimationEnabled() && !this._firstShowIndicator) {
+          var animationCfg = {
+            duration: 100,
+            easing: 'cubicInOut',
+            additive: true
+          };
+          indicator.x = oldIndicatorPos.x;
+          indicator.y = oldIndicatorPos.y;
+          indicator.animateTo(indicatorNewProps, animationCfg);
+          indicatorLabel.animateTo(labelNewProps, animationCfg);
+        } else {
+          indicator.attr(indicatorNewProps);
+          indicatorLabel.attr(labelNewProps);
+        }
+
+        this._firstShowIndicator = false;
+        var handleLabels = this._shapes.handleLabels;
+
+        if (handleLabels) {
+          for (var i = 0; i < handleLabels.length; i++) {
+            // Fade out handle labels.
+            // NOTE: Must use api enter/leave on emphasis/blur/select state. Or the global states manager will change it.
+            this._api.enterBlur(handleLabels[i]);
+          }
+        }
+      };
+
+      ContinuousView.prototype._enableHoverLinkToSeries = function () {
+        var self = this;
+
+        this._shapes.mainGroup.on('mousemove', function (e) {
+          self._hovering = true;
+
+          if (!self._dragging) {
+            var itemSize = self.visualMapModel.itemSize;
+
+            var pos = self._applyTransform([e.offsetX, e.offsetY], self._shapes.mainGroup, true, true); // For hover link show when hover handle, which might be
+            // below or upper than sizeExtent.
+
+
+            pos[1] = mathMin$a(mathMax$a(0, pos[1]), itemSize[1]);
+
+            self._doHoverLinkToSeries(pos[1], 0 <= pos[0] && pos[0] <= itemSize[0]);
+          }
+        }).on('mouseout', function () {
+          // When mouse is out of handle, hoverLink still need
+          // to be displayed when realtime is set as false.
+          self._hovering = false;
+          !self._dragging && self._clearHoverLinkToSeries();
+        });
+      };
+
+      ContinuousView.prototype._enableHoverLinkFromSeries = function () {
+        var zr = this.api.getZr();
+
+        if (this.visualMapModel.option.hoverLink) {
+          zr.on('mouseover', this._hoverLinkFromSeriesMouseOver, this);
+          zr.on('mouseout', this._hideIndicator, this);
+        } else {
+          this._clearHoverLinkFromSeries();
+        }
+      };
+
+      ContinuousView.prototype._doHoverLinkToSeries = function (cursorPos, hoverOnBar) {
+        var visualMapModel = this.visualMapModel;
+        var itemSize = visualMapModel.itemSize;
+
+        if (!visualMapModel.option.hoverLink) {
+          return;
+        }
+
+        var sizeExtent = [0, itemSize[1]];
+        var dataExtent = visualMapModel.getExtent(); // For hover link show when hover handle, which might be below or upper than sizeExtent.
+
+        cursorPos = mathMin$a(mathMax$a(sizeExtent[0], cursorPos), sizeExtent[1]);
+        var halfHoverLinkSize = getHalfHoverLinkSize(visualMapModel, dataExtent, sizeExtent);
+        var hoverRange = [cursorPos - halfHoverLinkSize, cursorPos + halfHoverLinkSize];
+        var cursorValue = linearMap$2(cursorPos, sizeExtent, dataExtent, true);
+        var valueRange = [linearMap$2(hoverRange[0], sizeExtent, dataExtent, true), linearMap$2(hoverRange[1], sizeExtent, dataExtent, true)]; // Consider data range is out of visualMap range, see test/visualMap-continuous.html,
+        // where china and india has very large population.
+
+        hoverRange[0] < sizeExtent[0] && (valueRange[0] = -Infinity);
+        hoverRange[1] > sizeExtent[1] && (valueRange[1] = Infinity); // Do not show indicator when mouse is over handle,
+        // otherwise labels overlap, especially when dragging.
+
+        if (hoverOnBar) {
+          if (valueRange[0] === -Infinity) {
+            this._showIndicator(cursorValue, valueRange[1], '< ', halfHoverLinkSize);
+          } else if (valueRange[1] === Infinity) {
+            this._showIndicator(cursorValue, valueRange[0], '> ', halfHoverLinkSize);
+          } else {
+            this._showIndicator(cursorValue, cursorValue, '≈ ', halfHoverLinkSize);
+          }
+        } // When realtime is set as false, handles, which are in barGroup,
+        // also trigger hoverLink, which help user to realize where they
+        // focus on when dragging. (see test/heatmap-large.html)
+        // When realtime is set as true, highlight will not show when hover
+        // handle, because the label on handle, which displays a exact value
+        // but not range, might mislead users.
+
+
+        var oldBatch = this._hoverLinkDataIndices;
+        var newBatch = [];
+
+        if (hoverOnBar || useHoverLinkOnHandle(visualMapModel)) {
+          newBatch = this._hoverLinkDataIndices = visualMapModel.findTargetDataIndices(valueRange);
+        }
+
+        var resultBatches = compressBatches(oldBatch, newBatch);
+
+        this._dispatchHighDown('downplay', makeHighDownBatch(resultBatches[0], visualMapModel));
+
+        this._dispatchHighDown('highlight', makeHighDownBatch(resultBatches[1], visualMapModel));
+      };
+
+      ContinuousView.prototype._hoverLinkFromSeriesMouseOver = function (e) {
+        var el = e.target;
+        var visualMapModel = this.visualMapModel;
+
+        if (!el || getECData(el).dataIndex == null) {
+          return;
+        }
+
+        var ecData = getECData(el);
+        var dataModel = this.ecModel.getSeriesByIndex(ecData.seriesIndex);
+
+        if (!visualMapModel.isTargetSeries(dataModel)) {
+          return;
+        }
+
+        var data = dataModel.getData(ecData.dataType);
+        var value = data.get(visualMapModel.getDataDimension(data), ecData.dataIndex);
+
+        if (!isNaN(value)) {
+          this._showIndicator(value, value);
+        }
+      };
+
+      ContinuousView.prototype._hideIndicator = function () {
+        var shapes = this._shapes;
+        shapes.indicator && shapes.indicator.attr('invisible', true);
+        shapes.indicatorLabel && shapes.indicatorLabel.attr('invisible', true);
+        var handleLabels = this._shapes.handleLabels;
+
+        if (handleLabels) {
+          for (var i = 0; i < handleLabels.length; i++) {
+            // Fade out handle labels.
+            // NOTE: Must use api enter/leave on emphasis/blur/select state. Or the global states manager will change it.
+            this._api.leaveBlur(handleLabels[i]);
+          }
+        }
+      };
+
+      ContinuousView.prototype._clearHoverLinkToSeries = function () {
+        this._hideIndicator();
+
+        var indices = this._hoverLinkDataIndices;
+
+        this._dispatchHighDown('downplay', makeHighDownBatch(indices, this.visualMapModel));
+
+        indices.length = 0;
+      };
+
+      ContinuousView.prototype._clearHoverLinkFromSeries = function () {
+        this._hideIndicator();
+
+        var zr = this.api.getZr();
+        zr.off('mouseover', this._hoverLinkFromSeriesMouseOver);
+        zr.off('mouseout', this._hideIndicator);
+      };
+
+      ContinuousView.prototype._applyTransform = function (vertex, element, inverse, global) {
+        var transform = getTransform(element, global ? null : this.group);
+        return isArray(vertex) ? applyTransform$1(vertex, transform, inverse) : transformDirection(vertex, transform, inverse);
+      }; // TODO: TYPE more specified payload types.
+
+
+      ContinuousView.prototype._dispatchHighDown = function (type, batch) {
+        batch && batch.length && this.api.dispatchAction({
+          type: type,
+          batch: batch
+        });
+      };
+      /**
+       * @override
+       */
+
+
+      ContinuousView.prototype.dispose = function () {
+        this._clearHoverLinkFromSeries();
+
+        this._clearHoverLinkToSeries();
+      };
+      /**
+       * @override
+       */
+
+
+      ContinuousView.prototype.remove = function () {
+        this._clearHoverLinkFromSeries();
+
+        this._clearHoverLinkToSeries();
+      };
+
+      ContinuousView.type = 'visualMap.continuous';
+      return ContinuousView;
+    }(VisualMapView);
+
+    function createPolygon(points, cursor, onDrift, onDragEnd) {
+      return new Polygon({
+        shape: {
+          points: points
+        },
+        draggable: !!onDrift,
+        cursor: cursor,
+        drift: onDrift,
+        onmousemove: function (e) {
+          // Fot mobile devicem, prevent screen slider on the button.
+          stop(e.event);
+        },
+        ondragend: onDragEnd
+      });
+    }
+
+    function getHalfHoverLinkSize(visualMapModel, dataExtent, sizeExtent) {
+      var halfHoverLinkSize = HOVER_LINK_SIZE / 2;
+      var hoverLinkDataSize = visualMapModel.get('hoverLinkDataSize');
+
+      if (hoverLinkDataSize) {
+        halfHoverLinkSize = linearMap$2(hoverLinkDataSize, dataExtent, sizeExtent, true) / 2;
+      }
+
+      return halfHoverLinkSize;
+    }
+
+    function useHoverLinkOnHandle(visualMapModel) {
+      var hoverLinkOnHandle = visualMapModel.get('hoverLinkOnHandle');
+      return !!(hoverLinkOnHandle == null ? visualMapModel.get('realtime') : hoverLinkOnHandle);
+    }
+
+    function getCursor$1(orient) {
+      return orient === 'vertical' ? 'ns-resize' : 'ew-resize';
+    }
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+
+
+    /**
+     * AUTO-GENERATED FILE. DO NOT MODIFY.
+     */
+
+    /*
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    *
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.
+    */
+    var visualMapActionInfo = {
+      type: 'selectDataRange',
+      event: 'dataRangeSelected',
+      // FIXME use updateView appears wrong
+      update: 'update'
+    };
+    var visualMapActionHander = function (payload, ecModel) {
+      ecModel.eachComponent({
+        mainType: 'visualMap',
+        query: payload
+      }, function (model) {
+        model.setSelected(payload.selected);
+      });
+    };
+
+    var visualMapEncodingHandlers = [{
+      createOnAllSeries: true,
+      reset: function (seriesModel, ecModel) {
+        var resetDefines = [];
+        ecModel.eachComponent('visualMap', function (visualMapModel) {
+          var pipelineContext = seriesModel.pipelineContext;
+
+          if (!visualMapModel.isTargetSeries(seriesModel) || pipelineContext && pipelineContext.large) {
+            return;
+          }
+
+          resetDefines.push(incrementalApplyVisual(visualMapModel.stateList, visualMapModel.targetVisuals, bind(visualMapModel.getValueState, visualMapModel), visualMapModel.getDataDimension(seriesModel.getData())));
+        });
+        return resetDefines;
+      }
+    }, // Only support color.
+    {
+      createOnAllSeries: true,
+      reset: function (seriesModel, ecModel) {
+        var data = seriesModel.getData();
+        var visualMetaList = [];
+        ecModel.eachComponent('visualMap', function (visualMapModel) {
+          if (visualMapModel.isTargetSeries(seriesModel)) {
+            var visualMeta = visualMapModel.getVisualMeta(bind(getColorVisual, null, seriesModel, visualMapModel)) || {
+              stops: [],
+              outerColors: []
+            };
+            var concreteDim = visualMapModel.getDataDimension(data);
+            var dimInfo = data.getDimensionInfo(concreteDim);
+
+            if (dimInfo != null) {
+              // visualMeta.dimension should be dimension index, but not concrete dimension.
+              visualMeta.dimension = dimInfo.index;
+              visualMetaList.push(visualMeta);
+            }
+          }
+        }); // console.log(JSON.stringify(visualMetaList.map(a => a.stops)));
+
+        seriesModel.getData().setVisual('visualMeta', visualMetaList);
+      }
+    }]; // FIXME
+    // performance and export for heatmap?
+    // value can be Infinity or -Infinity
+
+    function getColorVisual(seriesModel, visualMapModel, value, valueState) {
+      var mappings = visualMapModel.targetVisuals[valueState];
+      var visualTypes = VisualMapping.prepareVisualTypes(mappings);
+      var resultVisual = {
+        color: getVisualFromData(seriesModel.getData(), 'color') // default color.
+
+      };
+
+      for (var i = 0, len = visualTypes.length; i < len; i++) {
+        var type = visualTypes[i];
+        var mapping = mappings[type === 'opacity' ? '__alphaForOpacity' : type];
+        mapping && mapping.applyVisual(value, getVisual, setVisual);
+      }
+
+      return resultVisual.color;
+
+      function getVisual(key) {
+        return resultVisual[key];
+      }
+
+      function setVisual(key, value) {
+        resultVisual[key] = value;
+      }
+    }
+
+    var each$h = each;
+    function visualMapPreprocessor(option) {
+      var visualMap = option && option.visualMap;
+
+      if (!isArray(visualMap)) {
+        visualMap = visualMap ? [visualMap] : [];
+      }
+
+      each$h(visualMap, function (opt) {
+        if (!opt) {
+          return;
+        } // rename splitList to pieces
+
+
+        if (has$1(opt, 'splitList') && !has$1(opt, 'pieces')) {
+          opt.pieces = opt.splitList;
+          delete opt.splitList;
+        }
+
+        var pieces = opt.pieces;
+
+        if (pieces && isArray(pieces)) {
+          each$h(pieces, function (piece) {
+            if (isObject(piece)) {
+              if (has$1(piece, 'start') && !has$1(piece, 'min')) {
+                piece.min = piece.start;
+              }
+
+              if (has$1(piece, 'end') && !has$1(piece, 'max')) {
+                piece.max = piece.end;
+              }
+            }
+          });
+        }
+      });
+    }
+
+    function has$1(obj, name) {
+      return obj && obj.hasOwnProperty && obj.hasOwnProperty(name);
+    }
+
+    var installed$1 = false;
+    function installCommon$1(registers) {
+      if (installed$1) {
+        return;
+      }
+
+      installed$1 = true;
+      registers.registerSubTypeDefaulter('visualMap', function (option) {
+        // Compatible with ec2, when splitNumber === 0, continuous visualMap will be used.
+        return !option.categories && (!(option.pieces ? option.pieces.length > 0 : option.splitNumber > 0) || option.calculable) ? 'continuous' : 'piecewise';
+      });
+      registers.registerAction(visualMapActionInfo, visualMapActionHander);
+      each(visualMapEncodingHandlers, function (handler) {
+        registers.registerVisual(registers.PRIORITY.VISUAL.COMPONENT, handler);
+      });
+      registers.registerPreprocessor(visualMapPreprocessor);
+    }
+
+    function install$N(registers) {
+      registers.registerComponentModel(ContinuousModel);
+      registers.registerComponentView(ContinuousView);
+      installCommon$1(registers);
+    }
+
+    var PiecewiseModel =
+    /** @class */
+    function (_super) {
+      __extends(PiecewiseModel, _super);
+
+      function PiecewiseModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PiecewiseModel.type;
+        /**
+         * The order is always [low, ..., high].
+         * [{text: string, interval: Array.<number>}, ...]
+         */
+
+        _this._pieceList = [];
+        return _this;
+      }
+
+      PiecewiseModel.prototype.optionUpdated = function (newOption, isInit) {
+        _super.prototype.optionUpdated.apply(this, arguments);
+
+        this.resetExtent();
+
+        var mode = this._mode = this._determineMode();
+
+        this._pieceList = [];
+
+        resetMethods[this._mode].call(this, this._pieceList);
+
+        this._resetSelected(newOption, isInit);
+
+        var categories = this.option.categories;
+        this.resetVisual(function (mappingOption, state) {
+          if (mode === 'categories') {
+            mappingOption.mappingMethod = 'category';
+            mappingOption.categories = clone(categories);
+          } else {
+            mappingOption.dataExtent = this.getExtent();
+            mappingOption.mappingMethod = 'piecewise';
+            mappingOption.pieceList = map(this._pieceList, function (piece) {
+              piece = clone(piece);
+
+              if (state !== 'inRange') {
+                // FIXME
+                // outOfRange do not support special visual in pieces.
+                piece.visual = null;
+              }
+
+              return piece;
+            });
+          }
+        });
+      };
+      /**
+       * @protected
+       * @override
+       */
+
+
+      PiecewiseModel.prototype.completeVisualOption = function () {
+        // Consider this case:
+        // visualMap: {
+        //      pieces: [{symbol: 'circle', lt: 0}, {symbol: 'rect', gte: 0}]
+        // }
+        // where no inRange/outOfRange set but only pieces. So we should make
+        // default inRange/outOfRange for this case, otherwise visuals that only
+        // appear in `pieces` will not be taken into account in visual encoding.
+        var option = this.option;
+        var visualTypesInPieces = {};
+        var visualTypes = VisualMapping.listVisualTypes();
+        var isCategory = this.isCategory();
+        each(option.pieces, function (piece) {
+          each(visualTypes, function (visualType) {
+            if (piece.hasOwnProperty(visualType)) {
+              visualTypesInPieces[visualType] = 1;
+            }
+          });
+        });
+        each(visualTypesInPieces, function (v, visualType) {
+          var exists = false;
+          each(this.stateList, function (state) {
+            exists = exists || has(option, state, visualType) || has(option.target, state, visualType);
+          }, this);
+          !exists && each(this.stateList, function (state) {
+            (option[state] || (option[state] = {}))[visualType] = visualDefault.get(visualType, state === 'inRange' ? 'active' : 'inactive', isCategory);
+          });
+        }, this);
+
+        function has(obj, state, visualType) {
+          return obj && obj[state] && obj[state].hasOwnProperty(visualType);
+        }
+
+        _super.prototype.completeVisualOption.apply(this, arguments);
+      };
+
+      PiecewiseModel.prototype._resetSelected = function (newOption, isInit) {
+        var thisOption = this.option;
+        var pieceList = this._pieceList; // Selected do not merge but all override.
+
+        var selected = (isInit ? thisOption : newOption).selected || {};
+        thisOption.selected = selected; // Consider 'not specified' means true.
+
+        each(pieceList, function (piece, index) {
+          var key = this.getSelectedMapKey(piece);
+
+          if (!selected.hasOwnProperty(key)) {
+            selected[key] = true;
+          }
+        }, this);
+
+        if (thisOption.selectedMode === 'single') {
+          // Ensure there is only one selected.
+          var hasSel_1 = false;
+          each(pieceList, function (piece, index) {
+            var key = this.getSelectedMapKey(piece);
+
+            if (selected[key]) {
+              hasSel_1 ? selected[key] = false : hasSel_1 = true;
+            }
+          }, this);
+        } // thisOption.selectedMode === 'multiple', default: all selected.
+
+      };
+      /**
+       * @public
+       */
+
+
+      PiecewiseModel.prototype.getSelectedMapKey = function (piece) {
+        return this._mode === 'categories' ? piece.value + '' : piece.index + '';
+      };
+      /**
+       * @public
+       */
+
+
+      PiecewiseModel.prototype.getPieceList = function () {
+        return this._pieceList;
+      };
+      /**
+       * @return {string}
+       */
+
+
+      PiecewiseModel.prototype._determineMode = function () {
+        var option = this.option;
+        return option.pieces && option.pieces.length > 0 ? 'pieces' : this.option.categories ? 'categories' : 'splitNumber';
+      };
+      /**
+       * @override
+       */
+
+
+      PiecewiseModel.prototype.setSelected = function (selected) {
+        this.option.selected = clone(selected);
+      };
+      /**
+       * @override
+       */
+
+
+      PiecewiseModel.prototype.getValueState = function (value) {
+        var index = VisualMapping.findPieceIndex(value, this._pieceList);
+        return index != null ? this.option.selected[this.getSelectedMapKey(this._pieceList[index])] ? 'inRange' : 'outOfRange' : 'outOfRange';
+      };
+      /**
+       * @public
+       * @param pieceIndex piece index in visualMapModel.getPieceList()
+       */
+
+
+      PiecewiseModel.prototype.findTargetDataIndices = function (pieceIndex) {
+        var result = [];
+        var pieceList = this._pieceList;
+        this.eachTargetSeries(function (seriesModel) {
+          var dataIndices = [];
+          var data = seriesModel.getData();
+          data.each(this.getDataDimension(data), function (value, dataIndex) {
+            // Should always base on model pieceList, because it is order sensitive.
+            var pIdx = VisualMapping.findPieceIndex(value, pieceList);
+            pIdx === pieceIndex && dataIndices.push(dataIndex);
+          }, this);
+          result.push({
+            seriesId: seriesModel.id,
+            dataIndex: dataIndices
+          });
+        }, this);
+        return result;
+      };
+      /**
+       * @private
+       * @param piece piece.value or piece.interval is required.
+       * @return  Can be Infinity or -Infinity
+       */
+
+
+      PiecewiseModel.prototype.getRepresentValue = function (piece) {
+        var representValue;
+
+        if (this.isCategory()) {
+          representValue = piece.value;
+        } else {
+          if (piece.value != null) {
+            representValue = piece.value;
+          } else {
+            var pieceInterval = piece.interval || [];
+            representValue = pieceInterval[0] === -Infinity && pieceInterval[1] === Infinity ? 0 : (pieceInterval[0] + pieceInterval[1]) / 2;
+          }
+        }
+
+        return representValue;
+      };
+
+      PiecewiseModel.prototype.getVisualMeta = function (getColorVisual) {
+        // Do not support category. (category axis is ordinal, numerical)
+        if (this.isCategory()) {
+          return;
+        }
+
+        var stops = [];
+        var outerColors = ['', ''];
+        var visualMapModel = this;
+
+        function setStop(interval, valueState) {
+          var representValue = visualMapModel.getRepresentValue({
+            interval: interval
+          }); // Not category
+
+          if (!valueState) {
+            valueState = visualMapModel.getValueState(representValue);
+          }
+
+          var color = getColorVisual(representValue, valueState);
+
+          if (interval[0] === -Infinity) {
+            outerColors[0] = color;
+          } else if (interval[1] === Infinity) {
+            outerColors[1] = color;
+          } else {
+            stops.push({
+              value: interval[0],
+              color: color
+            }, {
+              value: interval[1],
+              color: color
+            });
+          }
+        } // Suplement
+
+
+        var pieceList = this._pieceList.slice();
+
+        if (!pieceList.length) {
+          pieceList.push({
+            interval: [-Infinity, Infinity]
+          });
+        } else {
+          var edge = pieceList[0].interval[0];
+          edge !== -Infinity && pieceList.unshift({
+            interval: [-Infinity, edge]
+          });
+          edge = pieceList[pieceList.length - 1].interval[1];
+          edge !== Infinity && pieceList.push({
+            interval: [edge, Infinity]
+          });
+        }
+
+        var curr = -Infinity;
+        each(pieceList, function (piece) {
+          var interval = piece.interval;
+
+          if (interval) {
+            // Fulfill gap.
+            interval[0] > curr && setStop([curr, interval[0]], 'outOfRange');
+            setStop(interval.slice());
+            curr = interval[1];
+          }
+        }, this);
+        return {
+          stops: stops,
+          outerColors: outerColors
+        };
+      };
+
+      PiecewiseModel.type = 'visualMap.piecewise';
+      PiecewiseModel.defaultOption = inheritDefaultOption(VisualMapModel.defaultOption, {
+        selected: null,
+        minOpen: false,
+        maxOpen: false,
+        align: 'auto',
+        itemWidth: 20,
+        itemHeight: 14,
+        itemSymbol: 'roundRect',
+        pieces: null,
+        categories: null,
+        splitNumber: 5,
+        selectedMode: 'multiple',
+        itemGap: 10,
+        hoverLink: true // Enable hover highlight.
+
+      });
+      return PiecewiseModel;
+    }(VisualMapModel);
+    /**
+     * Key is this._mode
+     * @type {Object}
+     * @this {module:echarts/component/viusalMap/PiecewiseMode}
+     */
+
+    var resetMethods = {
+      splitNumber: function (outPieceList) {
+        var thisOption = this.option;
+        var precision = Math.min(thisOption.precision, 20);
+        var dataExtent = this.getExtent();
+        var splitNumber = thisOption.splitNumber;
+        splitNumber = Math.max(parseInt(splitNumber, 10), 1);
+        thisOption.splitNumber = splitNumber;
+        var splitStep = (dataExtent[1] - dataExtent[0]) / splitNumber; // Precision auto-adaption
+
+        while (+splitStep.toFixed(precision) !== splitStep && precision < 5) {
+          precision++;
+        }
+
+        thisOption.precision = precision;
+        splitStep = +splitStep.toFixed(precision);
+
+        if (thisOption.minOpen) {
+          outPieceList.push({
+            interval: [-Infinity, dataExtent[0]],
+            close: [0, 0]
+          });
+        }
+
+        for (var index = 0, curr = dataExtent[0]; index < splitNumber; curr += splitStep, index++) {
+          var max = index === splitNumber - 1 ? dataExtent[1] : curr + splitStep;
+          outPieceList.push({
+            interval: [curr, max],
+            close: [1, 1]
+          });
+        }
+
+        if (thisOption.maxOpen) {
+          outPieceList.push({
+            interval: [dataExtent[1], Infinity],
+            close: [0, 0]
+          });
+        }
+
+        reformIntervals(outPieceList);
+        each(outPieceList, function (piece, index) {
+          piece.index = index;
+          piece.text = this.formatValueText(piece.interval);
+        }, this);
+      },
+      categories: function (outPieceList) {
+        var thisOption = this.option;
+        each(thisOption.categories, function (cate) {
+          // FIXME category模式也使用pieceList，但在visualMapping中不是使用pieceList。
+          // 是否改一致。
+          outPieceList.push({
+            text: this.formatValueText(cate, true),
+            value: cate
+          });
+        }, this); // See "Order Rule".
+
+        normalizeReverse(thisOption, outPieceList);
+      },
+      pieces: function (outPieceList) {
+        var thisOption = this.option;
+        each(thisOption.pieces, function (pieceListItem, index) {
+          if (!isObject(pieceListItem)) {
+            pieceListItem = {
+              value: pieceListItem
+            };
+          }
+
+          var item = {
+            text: '',
+            index: index
+          };
+
+          if (pieceListItem.label != null) {
+            item.text = pieceListItem.label;
+          }
+
+          if (pieceListItem.hasOwnProperty('value')) {
+            var value = item.value = pieceListItem.value;
+            item.interval = [value, value];
+            item.close = [1, 1];
+          } else {
+            // `min` `max` is legacy option.
+            // `lt` `gt` `lte` `gte` is recommanded.
+            var interval = item.interval = [];
+            var close_1 = item.close = [0, 0];
+            var closeList = [1, 0, 1];
+            var infinityList = [-Infinity, Infinity];
+            var useMinMax = [];
+
+            for (var lg = 0; lg < 2; lg++) {
+              var names = [['gte', 'gt', 'min'], ['lte', 'lt', 'max']][lg];
+
+              for (var i = 0; i < 3 && interval[lg] == null; i++) {
+                interval[lg] = pieceListItem[names[i]];
+                close_1[lg] = closeList[i];
+                useMinMax[lg] = i === 2;
+              }
+
+              interval[lg] == null && (interval[lg] = infinityList[lg]);
+            }
+
+            useMinMax[0] && interval[1] === Infinity && (close_1[0] = 0);
+            useMinMax[1] && interval[0] === -Infinity && (close_1[1] = 0);
+
+            if ("development" !== 'production') {
+              if (interval[0] > interval[1]) {
+                console.warn('Piece ' + index + 'is illegal: ' + interval + ' lower bound should not greater then uppper bound.');
+              }
+            }
+
+            if (interval[0] === interval[1] && close_1[0] && close_1[1]) {
+              // Consider: [{min: 5, max: 5, visual: {...}}, {min: 0, max: 5}],
+              // we use value to lift the priority when min === max
+              item.value = interval[0];
+            }
+          }
+
+          item.visual = VisualMapping.retrieveVisuals(pieceListItem);
+          outPieceList.push(item);
+        }, this); // See "Order Rule".
+
+        normalizeReverse(thisOption, outPieceList); // Only pieces
+
+        reformIntervals(outPieceList);
+        each(outPieceList, function (piece) {
+          var close = piece.close;
+          var edgeSymbols = [['<', '≤'][close[1]], ['>', '≥'][close[0]]];
+          piece.text = piece.text || this.formatValueText(piece.value != null ? piece.value : piece.interval, false, edgeSymbols);
+        }, this);
+      }
+    };
+
+    function normalizeReverse(thisOption, pieceList) {
+      var inverse = thisOption.inverse;
+
+      if (thisOption.orient === 'vertical' ? !inverse : inverse) {
+        pieceList.reverse();
+      }
+    }
+
+    var PiecewiseVisualMapView =
+    /** @class */
+    function (_super) {
+      __extends(PiecewiseVisualMapView, _super);
+
+      function PiecewiseVisualMapView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = PiecewiseVisualMapView.type;
+        return _this;
+      }
+
+      PiecewiseVisualMapView.prototype.doRender = function () {
+        var thisGroup = this.group;
+        thisGroup.removeAll();
+        var visualMapModel = this.visualMapModel;
+        var textGap = visualMapModel.get('textGap');
+        var textStyleModel = visualMapModel.textStyleModel;
+        var textFont = textStyleModel.getFont();
+        var textFill = textStyleModel.getTextColor();
+
+        var itemAlign = this._getItemAlign();
+
+        var itemSize = visualMapModel.itemSize;
+
+        var viewData = this._getViewData();
+
+        var endsText = viewData.endsText;
+        var showLabel = retrieve(visualMapModel.get('showLabel', true), !endsText);
+        endsText && this._renderEndsText(thisGroup, endsText[0], itemSize, showLabel, itemAlign);
+        each(viewData.viewPieceList, function (item) {
+          var piece = item.piece;
+          var itemGroup = new Group();
+          itemGroup.onclick = bind(this._onItemClick, this, piece);
+
+          this._enableHoverLink(itemGroup, item.indexInModelPieceList); // TODO Category
+
+
+          var representValue = visualMapModel.getRepresentValue(piece);
+
+          this._createItemSymbol(itemGroup, representValue, [0, 0, itemSize[0], itemSize[1]]);
+
+          if (showLabel) {
+            var visualState = this.visualMapModel.getValueState(representValue);
+            itemGroup.add(new ZRText({
+              style: {
+                x: itemAlign === 'right' ? -textGap : itemSize[0] + textGap,
+                y: itemSize[1] / 2,
+                text: piece.text,
+                verticalAlign: 'middle',
+                align: itemAlign,
+                font: textFont,
+                fill: textFill,
+                opacity: visualState === 'outOfRange' ? 0.5 : 1
+              }
+            }));
+          }
+
+          thisGroup.add(itemGroup);
+        }, this);
+        endsText && this._renderEndsText(thisGroup, endsText[1], itemSize, showLabel, itemAlign);
+        box(visualMapModel.get('orient'), thisGroup, visualMapModel.get('itemGap'));
+        this.renderBackground(thisGroup);
+        this.positionGroup(thisGroup);
+      };
+
+      PiecewiseVisualMapView.prototype._enableHoverLink = function (itemGroup, pieceIndex) {
+        var _this = this;
+
+        itemGroup.on('mouseover', function () {
+          return onHoverLink('highlight');
+        }).on('mouseout', function () {
+          return onHoverLink('downplay');
+        });
+
+        var onHoverLink = function (method) {
+          var visualMapModel = _this.visualMapModel; // TODO: TYPE More detailed action types
+
+          visualMapModel.option.hoverLink && _this.api.dispatchAction({
+            type: method,
+            batch: makeHighDownBatch(visualMapModel.findTargetDataIndices(pieceIndex), visualMapModel)
+          });
+        };
+      };
+
+      PiecewiseVisualMapView.prototype._getItemAlign = function () {
+        var visualMapModel = this.visualMapModel;
+        var modelOption = visualMapModel.option;
+
+        if (modelOption.orient === 'vertical') {
+          return getItemAlign(visualMapModel, this.api, visualMapModel.itemSize);
+        } else {
+          // horizontal, most case left unless specifying right.
+          var align = modelOption.align;
+
+          if (!align || align === 'auto') {
+            align = 'left';
+          }
+
+          return align;
+        }
+      };
+
+      PiecewiseVisualMapView.prototype._renderEndsText = function (group, text, itemSize, showLabel, itemAlign) {
+        if (!text) {
+          return;
+        }
+
+        var itemGroup = new Group();
+        var textStyleModel = this.visualMapModel.textStyleModel;
+        itemGroup.add(new ZRText({
+          style: {
+            x: showLabel ? itemAlign === 'right' ? itemSize[0] : 0 : itemSize[0] / 2,
+            y: itemSize[1] / 2,
+            verticalAlign: 'middle',
+            align: showLabel ? itemAlign : 'center',
+            text: text,
+            font: textStyleModel.getFont(),
+            fill: textStyleModel.getTextColor()
+          }
+        }));
+        group.add(itemGroup);
+      };
+      /**
+       * @private
+       * @return {Object} {peiceList, endsText} The order is the same as screen pixel order.
+       */
+
+
+      PiecewiseVisualMapView.prototype._getViewData = function () {
+        var visualMapModel = this.visualMapModel;
+        var viewPieceList = map(visualMapModel.getPieceList(), function (piece, index) {
+          return {
+            piece: piece,
+            indexInModelPieceList: index
+          };
+        });
+        var endsText = visualMapModel.get('text'); // Consider orient and inverse.
+
+        var orient = visualMapModel.get('orient');
+        var inverse = visualMapModel.get('inverse'); // Order of model pieceList is always [low, ..., high]
+
+        if (orient === 'horizontal' ? inverse : !inverse) {
+          viewPieceList.reverse();
+        } // Origin order of endsText is [high, low]
+        else if (endsText) {
+            endsText = endsText.slice().reverse();
+          }
+
+        return {
+          viewPieceList: viewPieceList,
+          endsText: endsText
+        };
+      };
+
+      PiecewiseVisualMapView.prototype._createItemSymbol = function (group, representValue, shapeParam) {
+        group.add(createSymbol( // symbol will be string
+        this.getControllerVisual(representValue, 'symbol'), shapeParam[0], shapeParam[1], shapeParam[2], shapeParam[3], // color will be string
+        this.getControllerVisual(representValue, 'color')));
+      };
+
+      PiecewiseVisualMapView.prototype._onItemClick = function (piece) {
+        var visualMapModel = this.visualMapModel;
+        var option = visualMapModel.option;
+        var selected = clone(option.selected);
+        var newKey = visualMapModel.getSelectedMapKey(piece);
+
+        if (option.selectedMode === 'single') {
+          selected[newKey] = true;
+          each(selected, function (o, key) {
+            selected[key] = key === newKey;
+          });
+        } else {
+          selected[newKey] = !selected[newKey];
+        }
+
+        this.api.dispatchAction({
+          type: 'selectDataRange',
+          from: this.uid,
+          visualMapId: this.visualMapModel.id,
+          selected: selected
+        });
+      };
+
+      PiecewiseVisualMapView.type = 'visualMap.piecewise';
+      return PiecewiseVisualMapView;
+    }(VisualMapView);
+
+    function install$O(registers) {
+      registers.registerComponentModel(PiecewiseModel);
+      registers.registerComponentView(PiecewiseVisualMapView);
+      installCommon$1(registers);
+    }
+
+    function install$P(registers) {
+      use(install$N);
+      use(install$O); // Do not install './dataZoomSelect',
+      // since it only work for toolbox dataZoom.
+    }
+
+    var DEFAULT_OPTION = {
+      label: {
+        enabled: true
+      },
+      decal: {
+        show: false
+      }
+    };
+    var inner$n = makeInner();
+    var decalPaletteScope = {};
+    function ariaVisual(ecModel, api) {
+      var ariaModel = ecModel.getModel('aria'); // See "area enabled" detection code in `GlobalModel.ts`.
+
+      if (!ariaModel.get('enabled')) {
+        return;
+      }
+
+      var defaultOption = clone(DEFAULT_OPTION);
+      merge(defaultOption.label, ecModel.getLocaleModel().get('aria'), false);
+      merge(ariaModel.option, defaultOption, false);
+      setDecal();
+      setLabel();
+
+      function setDecal() {
+        var decalModel = ariaModel.getModel('decal');
+        var useDecal = decalModel.get('show');
+
+        if (useDecal) {
+          // Each type of series use one scope.
+          // Pie and funnel are using diferrent scopes
+          var paletteScopeGroupByType_1 = createHashMap();
+          ecModel.eachSeries(function (seriesModel) {
+            if (!seriesModel.useColorPaletteOnData) {
+              return;
+            }
+
+            var decalScope = paletteScopeGroupByType_1.get(seriesModel.type);
+
+            if (!decalScope) {
+              decalScope = {};
+              paletteScopeGroupByType_1.set(seriesModel.type, decalScope);
+            }
+
+            inner$n(seriesModel).scope = decalScope;
+          });
+          ecModel.eachRawSeries(function (seriesModel) {
+            if (ecModel.isSeriesFiltered(seriesModel)) {
+              return;
+            }
+
+            if (typeof seriesModel.enableAriaDecal === 'function') {
+              // Let series define how to use decal palette on data
+              seriesModel.enableAriaDecal();
+              return;
+            }
+
+            var data = seriesModel.getData();
+
+            if (seriesModel.useColorPaletteOnData) {
+              var dataAll_1 = seriesModel.getRawData();
+              var idxMap_1 = {};
+              var decalScope_1 = inner$n(seriesModel).scope;
+              data.each(function (idx) {
+                var rawIdx = data.getRawIndex(idx);
+                idxMap_1[rawIdx] = idx;
+              });
+              var dataCount_1 = dataAll_1.count();
+              dataAll_1.each(function (rawIdx) {
+                var idx = idxMap_1[rawIdx];
+                var name = dataAll_1.getName(rawIdx) || rawIdx + '';
+                var paletteDecal = getDecalFromPalette(seriesModel.ecModel, name, decalScope_1, dataCount_1);
+                var specifiedDecal = data.getItemVisual(idx, 'decal');
+                data.setItemVisual(idx, 'decal', mergeDecal(specifiedDecal, paletteDecal));
+              });
+            } else {
+              var paletteDecal = getDecalFromPalette(seriesModel.ecModel, seriesModel.name, decalPaletteScope, ecModel.getSeriesCount());
+              var specifiedDecal = data.getVisual('decal');
+              data.setVisual('decal', mergeDecal(specifiedDecal, paletteDecal));
+            }
+
+            function mergeDecal(specifiedDecal, paletteDecal) {
+              // Merge decal from palette to decal from itemStyle.
+              // User do not need to specify all of the decal props.
+              var resultDecal = specifiedDecal ? extend(extend({}, paletteDecal), specifiedDecal) : paletteDecal;
+              resultDecal.dirty = true;
+              return resultDecal;
+            }
+          });
+        }
+      }
+
+      function setLabel() {
+        var labelLocale = ecModel.getLocaleModel().get('aria');
+        var labelModel = ariaModel.getModel('label');
+        labelModel.option = defaults(labelModel.option, labelLocale);
+
+        if (!labelModel.get('enabled')) {
+          return;
+        }
+
+        var dom = api.getZr().dom;
+
+        if (labelModel.get('description')) {
+          dom.setAttribute('aria-label', labelModel.get('description'));
+          return;
+        }
+
+        var seriesCnt = ecModel.getSeriesCount();
+        var maxDataCnt = labelModel.get(['data', 'maxCount']) || 10;
+        var maxSeriesCnt = labelModel.get(['series', 'maxCount']) || 10;
+        var displaySeriesCnt = Math.min(seriesCnt, maxSeriesCnt);
+        var ariaLabel;
+
+        if (seriesCnt < 1) {
+          // No series, no aria label
+          return;
+        } else {
+          var title = getTitle();
+
+          if (title) {
+            var withTitle = labelModel.get(['general', 'withTitle']);
+            ariaLabel = replace(withTitle, {
+              title: title
+            });
+          } else {
+            ariaLabel = labelModel.get(['general', 'withoutTitle']);
+          }
+
+          var seriesLabels_1 = [];
+          var prefix = seriesCnt > 1 ? labelModel.get(['series', 'multiple', 'prefix']) : labelModel.get(['series', 'single', 'prefix']);
+          ariaLabel += replace(prefix, {
+            seriesCount: seriesCnt
+          });
+          ecModel.eachSeries(function (seriesModel, idx) {
+            if (idx < displaySeriesCnt) {
+              var seriesLabel = void 0;
+              var seriesName = seriesModel.get('name');
+              var withName = seriesName ? 'withName' : 'withoutName';
+              seriesLabel = seriesCnt > 1 ? labelModel.get(['series', 'multiple', withName]) : labelModel.get(['series', 'single', withName]);
+              seriesLabel = replace(seriesLabel, {
+                seriesId: seriesModel.seriesIndex,
+                seriesName: seriesModel.get('name'),
+                seriesType: getSeriesTypeName(seriesModel.subType)
+              });
+              var data = seriesModel.getData();
+
+              if (data.count() > maxDataCnt) {
+                // Show part of data
+                var partialLabel = labelModel.get(['data', 'partialData']);
+                seriesLabel += replace(partialLabel, {
+                  displayCnt: maxDataCnt
+                });
+              } else {
+                seriesLabel += labelModel.get(['data', 'allData']);
+              }
+
+              var dataLabels = [];
+
+              for (var i = 0; i < data.count(); i++) {
+                if (i < maxDataCnt) {
+                  var name_1 = data.getName(i);
+                  var value = retrieveRawValue(data, i);
+                  var dataLabel = labelModel.get(['data', name_1 ? 'withName' : 'withoutName']);
+                  dataLabels.push(replace(dataLabel, {
+                    name: name_1,
+                    value: value
+                  }));
+                }
+              }
+
+              var middleSeparator_1 = labelModel.get(['data', 'separator', 'middle']);
+              var endSeparator_1 = labelModel.get(['data', 'separator', 'end']);
+              seriesLabel += dataLabels.join(middleSeparator_1) + endSeparator_1;
+              seriesLabels_1.push(seriesLabel);
+            }
+          });
+          var separatorModel = labelModel.getModel(['series', 'multiple', 'separator']);
+          var middleSeparator = separatorModel.get('middle');
+          var endSeparator = separatorModel.get('end');
+          ariaLabel += seriesLabels_1.join(middleSeparator) + endSeparator;
+          dom.setAttribute('aria-label', ariaLabel);
+        }
+      }
+
+      function replace(str, keyValues) {
+        if (typeof str !== 'string') {
+          return str;
+        }
+
+        var result = str;
+        each(keyValues, function (value, key) {
+          result = result.replace(new RegExp('\\{\\s*' + key + '\\s*\\}', 'g'), value);
+        });
+        return result;
+      }
+
+      function getTitle() {
+        var title = ecModel.get('title');
+
+        if (title && title.length) {
+          title = title[0];
+        }
+
+        return title && title.text;
+      }
+
+      function getSeriesTypeName(type) {
+        return ecModel.getLocaleModel().get(['series', 'typeNames'])[type] || '自定义图';
+      }
+    }
+
+    function ariaPreprocessor(option) {
+      if (!option || !option.aria) {
+        return;
+      }
+
+      var aria = option.aria; // aria.show is deprecated and should use aria.enabled instead
+
+      if (aria.show != null) {
+        aria.enabled = aria.show;
+      }
+
+      aria.label = aria.label || {}; // move description, general, series, data to be under aria.label
+
+      each(['description', 'general', 'series', 'data'], function (name) {
+        if (aria[name] != null) {
+          aria.label[name] = aria[name];
+        }
+      });
+    }
+
+    function install$Q(registers) {
+      registers.registerPreprocessor(ariaPreprocessor);
+      registers.registerVisual(registers.PRIORITY.VISUAL.ARIA, ariaVisual);
+    }
+
+    var RELATIONAL_EXPRESSION_OP_ALIAS_MAP = {
+      value: 'eq',
+      // PENDING: not good for literal semantic?
+      '<': 'lt',
+      '<=': 'lte',
+      '>': 'gt',
+      '>=': 'gte',
+      '=': 'eq',
+      '!=': 'ne',
+      '<>': 'ne' // Might mileading for sake of the different between '==' and '===',
+      // So dont support them.
+      // '==': 'eq',
+      // '===': 'seq',
+      // '!==': 'sne'
+      // PENDING: Whether support some common alias "ge", "le", "neq"?
+      // ge: 'gte',
+      // le: 'lte',
+      // neq: 'ne',
+
+    };
+
+    var RegExpEvaluator =
+    /** @class */
+    function () {
+      function RegExpEvaluator(rVal) {
+        // Support condVal: RegExp | string
+        var condValue = this._condVal = isString(rVal) ? new RegExp(rVal) : isRegExp(rVal) ? rVal : null;
+
+        if (condValue == null) {
+          var errMsg = '';
+
+          if ("development" !== 'production') {
+            errMsg = makePrintable('Illegal regexp', rVal, 'in');
+          }
+
+          throwError(errMsg);
+        }
+      }
+
+      RegExpEvaluator.prototype.evaluate = function (lVal) {
+        var type = typeof lVal;
+        return type === 'string' ? this._condVal.test(lVal) : type === 'number' ? this._condVal.test(lVal + '') : false;
+      };
+
+      return RegExpEvaluator;
+    }();
+
+    var ConstConditionInternal =
+    /** @class */
+    function () {
+      function ConstConditionInternal() {}
+
+      ConstConditionInternal.prototype.evaluate = function () {
+        return this.value;
+      };
+
+      return ConstConditionInternal;
+    }();
+
+    var AndConditionInternal =
+    /** @class */
+    function () {
+      function AndConditionInternal() {}
+
+      AndConditionInternal.prototype.evaluate = function () {
+        var children = this.children;
+
+        for (var i = 0; i < children.length; i++) {
+          if (!children[i].evaluate()) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+
+      return AndConditionInternal;
+    }();
+
+    var OrConditionInternal =
+    /** @class */
+    function () {
+      function OrConditionInternal() {}
+
+      OrConditionInternal.prototype.evaluate = function () {
+        var children = this.children;
+
+        for (var i = 0; i < children.length; i++) {
+          if (children[i].evaluate()) {
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      return OrConditionInternal;
+    }();
+
+    var NotConditionInternal =
+    /** @class */
+    function () {
+      function NotConditionInternal() {}
+
+      NotConditionInternal.prototype.evaluate = function () {
+        return !this.child.evaluate();
+      };
+
+      return NotConditionInternal;
+    }();
+
+    var RelationalConditionInternal =
+    /** @class */
+    function () {
+      function RelationalConditionInternal() {}
+
+      RelationalConditionInternal.prototype.evaluate = function () {
+        var needParse = !!this.valueParser; // Call getValue with no `this`.
+
+        var getValue = this.getValue;
+        var tarValRaw = getValue(this.valueGetterParam);
+        var tarValParsed = needParse ? this.valueParser(tarValRaw) : null; // Relational cond follow "and" logic internally.
+
+        for (var i = 0; i < this.subCondList.length; i++) {
+          if (!this.subCondList[i].evaluate(needParse ? tarValParsed : tarValRaw)) {
+            return false;
+          }
+        }
+
+        return true;
+      };
+
+      return RelationalConditionInternal;
+    }();
+
+    function parseOption(exprOption, getters) {
+      if (exprOption === true || exprOption === false) {
+        var cond = new ConstConditionInternal();
+        cond.value = exprOption;
+        return cond;
+      }
+
+      var errMsg = '';
+
+      if (!isObjectNotArray(exprOption)) {
+        if ("development" !== 'production') {
+          errMsg = makePrintable('Illegal config. Expect a plain object but actually', exprOption);
+        }
+
+        throwError(errMsg);
+      }
+
+      if (exprOption.and) {
+        return parseAndOrOption('and', exprOption, getters);
+      } else if (exprOption.or) {
+        return parseAndOrOption('or', exprOption, getters);
+      } else if (exprOption.not) {
+        return parseNotOption(exprOption, getters);
+      }
+
+      return parseRelationalOption(exprOption, getters);
+    }
+
+    function parseAndOrOption(op, exprOption, getters) {
+      var subOptionArr = exprOption[op];
+      var errMsg = '';
+
+      if ("development" !== 'production') {
+        errMsg = makePrintable('"and"/"or" condition should only be `' + op + ': [...]` and must not be empty array.', 'Illegal condition:', exprOption);
+      }
+
+      if (!isArray(subOptionArr)) {
+        throwError(errMsg);
+      }
+
+      if (!subOptionArr.length) {
+        throwError(errMsg);
+      }
+
+      var cond = op === 'and' ? new AndConditionInternal() : new OrConditionInternal();
+      cond.children = map(subOptionArr, function (subOption) {
+        return parseOption(subOption, getters);
+      });
+
+      if (!cond.children.length) {
+        throwError(errMsg);
+      }
+
+      return cond;
+    }
+
+    function parseNotOption(exprOption, getters) {
+      var subOption = exprOption.not;
+      var errMsg = '';
+
+      if ("development" !== 'production') {
+        errMsg = makePrintable('"not" condition should only be `not: {}`.', 'Illegal condition:', exprOption);
+      }
+
+      if (!isObjectNotArray(subOption)) {
+        throwError(errMsg);
+      }
+
+      var cond = new NotConditionInternal();
+      cond.child = parseOption(subOption, getters);
+
+      if (!cond.child) {
+        throwError(errMsg);
+      }
+
+      return cond;
+    }
+
+    function parseRelationalOption(exprOption, getters) {
+      var errMsg = '';
+      var valueGetterParam = getters.prepareGetValue(exprOption);
+      var subCondList = [];
+      var exprKeys = keys(exprOption);
+      var parserName = exprOption.parser;
+      var valueParser = parserName ? getRawValueParser(parserName) : null;
+
+      for (var i = 0; i < exprKeys.length; i++) {
+        var keyRaw = exprKeys[i];
+
+        if (keyRaw === 'parser' || getters.valueGetterAttrMap.get(keyRaw)) {
+          continue;
+        }
+
+        var op = hasOwn(RELATIONAL_EXPRESSION_OP_ALIAS_MAP, keyRaw) ? RELATIONAL_EXPRESSION_OP_ALIAS_MAP[keyRaw] : keyRaw;
+        var condValueRaw = exprOption[keyRaw];
+        var condValueParsed = valueParser ? valueParser(condValueRaw) : condValueRaw;
+        var evaluator = createFilterComparator(op, condValueParsed) || op === 'reg' && new RegExpEvaluator(condValueParsed);
+
+        if (!evaluator) {
+          if ("development" !== 'production') {
+            errMsg = makePrintable('Illegal relational operation: "' + keyRaw + '" in condition:', exprOption);
+          }
+
+          throwError(errMsg);
+        }
+
+        subCondList.push(evaluator);
+      }
+
+      if (!subCondList.length) {
+        if ("development" !== 'production') {
+          errMsg = makePrintable('Relational condition must have at least one operator.', 'Illegal condition:', exprOption);
+        } // No relational operator always disabled in case of dangers result.
+
+
+        throwError(errMsg);
+      }
+
+      var cond = new RelationalConditionInternal();
+      cond.valueGetterParam = valueGetterParam;
+      cond.valueParser = valueParser;
+      cond.getValue = getters.getValue;
+      cond.subCondList = subCondList;
+      return cond;
+    }
+
+    function isObjectNotArray(val) {
+      return isObject(val) && !isArrayLike(val);
+    }
+
+    var ConditionalExpressionParsed =
+    /** @class */
+    function () {
+      function ConditionalExpressionParsed(exprOption, getters) {
+        this._cond = parseOption(exprOption, getters);
+      }
+
+      ConditionalExpressionParsed.prototype.evaluate = function () {
+        return this._cond.evaluate();
+      };
+
+      return ConditionalExpressionParsed;
+    }();
+    function parseConditionalExpression(exprOption, getters) {
+      return new ConditionalExpressionParsed(exprOption, getters);
+    }
+
+    var filterTransform = {
+      type: 'echarts:filter',
+      // PEDING: enhance to filter by index rather than create new data
+      transform: function (params) {
+        // [Caveat] Fail-Fast:
+        // Do not return the whole dataset unless user config indicate it explicitly.
+        // For example, if no condition specified by mistake, return an empty result
+        // is better than return the entire raw soruce for user to find the mistake.
+        var upstream = params.upstream;
+        var rawItem;
+        var condition = parseConditionalExpression(params.config, {
+          valueGetterAttrMap: createHashMap({
+            dimension: true
+          }),
+          prepareGetValue: function (exprOption) {
+            var errMsg = '';
+            var dimLoose = exprOption.dimension;
+
+            if (!hasOwn(exprOption, 'dimension')) {
+              if ("development" !== 'production') {
+                errMsg = makePrintable('Relation condition must has prop "dimension" specified.', 'Illegal condition:', exprOption);
+              }
+
+              throwError(errMsg);
+            }
+
+            var dimInfo = upstream.getDimensionInfo(dimLoose);
+
+            if (!dimInfo) {
+              if ("development" !== 'production') {
+                errMsg = makePrintable('Can not find dimension info via: ' + dimLoose + '.\n', 'Existing dimensions: ', upstream.cloneAllDimensionInfo(), '.\n', 'Illegal condition:', exprOption, '.\n');
+              }
+
+              throwError(errMsg);
+            }
+
+            return {
+              dimIdx: dimInfo.index
+            };
+          },
+          getValue: function (param) {
+            return upstream.retrieveValueFromItem(rawItem, param.dimIdx);
+          }
+        });
+        var resultData = [];
+
+        for (var i = 0, len = upstream.count(); i < len; i++) {
+          rawItem = upstream.getRawDataItem(i);
+
+          if (condition.evaluate()) {
+            resultData.push(rawItem);
+          }
+        }
+
+        return {
+          data: resultData
+        };
+      }
+    };
+
+    var sampleLog = '';
+
+    if ("development" !== 'production') {
+      sampleLog = ['Valid config is like:', '{ dimension: "age", order: "asc" }', 'or [{ dimension: "age", order: "asc"], { dimension: "date", order: "desc" }]'].join(' ');
+    }
+
+    var sortTransform = {
+      type: 'echarts:sort',
+      transform: function (params) {
+        var upstream = params.upstream;
+        var config = params.config;
+        var errMsg = ''; // Normalize
+        // const orderExprList: OrderExpression[] = isArray(config[0])
+        //     ? config as OrderExpression[]
+        //     : [config as OrderExpression];
+
+        var orderExprList = normalizeToArray(config);
+
+        if (!orderExprList.length) {
+          if ("development" !== 'production') {
+            errMsg = 'Empty `config` in sort transform.';
+          }
+
+          throwError(errMsg);
+        }
+
+        var orderDefList = [];
+        each(orderExprList, function (orderExpr) {
+          var dimLoose = orderExpr.dimension;
+          var order = orderExpr.order;
+          var parserName = orderExpr.parser;
+          var incomparable = orderExpr.incomparable;
+
+          if (dimLoose == null) {
+            if ("development" !== 'production') {
+              errMsg = 'Sort transform config must has "dimension" specified.' + sampleLog;
+            }
+
+            throwError(errMsg);
+          }
+
+          if (order !== 'asc' && order !== 'desc') {
+            if ("development" !== 'production') {
+              errMsg = 'Sort transform config must has "order" specified.' + sampleLog;
+            }
+
+            throwError(errMsg);
+          }
+
+          if (incomparable && incomparable !== 'min' && incomparable !== 'max') {
+            var errMsg_1 = '';
+
+            if ("development" !== 'production') {
+              errMsg_1 = 'incomparable must be "min" or "max" rather than "' + incomparable + '".';
+            }
+
+            throwError(errMsg_1);
+          }
+
+          if (order !== 'asc' && order !== 'desc') {
+            var errMsg_2 = '';
+
+            if ("development" !== 'production') {
+              errMsg_2 = 'order must be "asc" or "desc" rather than "' + order + '".';
+            }
+
+            throwError(errMsg_2);
+          }
+
+          var dimInfo = upstream.getDimensionInfo(dimLoose);
+
+          if (!dimInfo) {
+            if ("development" !== 'production') {
+              errMsg = makePrintable('Can not find dimension info via: ' + dimLoose + '.\n', 'Existing dimensions: ', upstream.cloneAllDimensionInfo(), '.\n', 'Illegal config:', orderExpr, '.\n');
+            }
+
+            throwError(errMsg);
+          }
+
+          var parser = parserName ? getRawValueParser(parserName) : null;
+
+          if (parserName && !parser) {
+            if ("development" !== 'production') {
+              errMsg = makePrintable('Invalid parser name ' + parserName + '.\n', 'Illegal config:', orderExpr, '.\n');
+            }
+
+            throwError(errMsg);
+          }
+
+          orderDefList.push({
+            dimIdx: dimInfo.index,
+            parser: parser,
+            comparator: new SortOrderComparator(order, incomparable)
+          });
+        }); // TODO: support it?
+
+        var sourceFormat = upstream.sourceFormat;
+
+        if (sourceFormat !== SOURCE_FORMAT_ARRAY_ROWS && sourceFormat !== SOURCE_FORMAT_OBJECT_ROWS) {
+          if ("development" !== 'production') {
+            errMsg = 'sourceFormat "' + sourceFormat + '" is not supported yet';
+          }
+
+          throwError(errMsg);
+        } // Other upstream format are all array.
+
+
+        var resultData = [];
+
+        for (var i = 0, len = upstream.count(); i < len; i++) {
+          resultData.push(upstream.getRawDataItem(i));
+        }
+
+        resultData.sort(function (item0, item1) {
+          for (var i = 0; i < orderDefList.length; i++) {
+            var orderDef = orderDefList[i];
+            var val0 = upstream.retrieveValueFromItem(item0, orderDef.dimIdx);
+            var val1 = upstream.retrieveValueFromItem(item1, orderDef.dimIdx);
+
+            if (orderDef.parser) {
+              val0 = orderDef.parser(val0);
+              val1 = orderDef.parser(val1);
+            }
+
+            var result = orderDef.comparator.evaluate(val0, val1);
+
+            if (result !== 0) {
+              return result;
+            }
+          }
+
+          return 0;
+        });
+        return {
+          data: resultData
+        };
+      }
+    };
+
+    function install$R(registers) {
+      registers.registerTransform(filterTransform);
+      registers.registerTransform(sortTransform);
+    }
+
+    var DatasetModel =
+    /** @class */
+    function (_super) {
+      __extends(DatasetModel, _super);
+
+      function DatasetModel() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'dataset';
+        return _this;
+      }
+
+      DatasetModel.prototype.init = function (option, parentModel, ecModel) {
+        _super.prototype.init.call(this, option, parentModel, ecModel);
+
+        this._sourceManager = new SourceManager(this);
+        disableTransformOptionMerge(this);
+      };
+
+      DatasetModel.prototype.mergeOption = function (newOption, ecModel) {
+        _super.prototype.mergeOption.call(this, newOption, ecModel);
+
+        disableTransformOptionMerge(this);
+      };
+
+      DatasetModel.prototype.optionUpdated = function () {
+        this._sourceManager.dirty();
+      };
+
+      DatasetModel.prototype.getSourceManager = function () {
+        return this._sourceManager;
+      };
+
+      DatasetModel.type = 'dataset';
+      DatasetModel.defaultOption = {
+        seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN
+      };
+      return DatasetModel;
+    }(ComponentModel);
+
+    var DatasetView =
+    /** @class */
+    function (_super) {
+      __extends(DatasetView, _super);
+
+      function DatasetView() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+
+        _this.type = 'dataset';
+        return _this;
+      }
+
+      DatasetView.type = 'dataset';
+      return DatasetView;
+    }(ComponentView);
+
+    function install$S(registers) {
+      registers.registerComponentModel(DatasetModel);
+      registers.registerComponentView(DatasetView);
+    }
+
+    // Render engines
+    // -----------------
+    // Render via Canvas.
+    // echarts.init(dom, null, { renderer: 'canvas' })
+
+    use([install$1]); // Render via SVG.
+    // echarts.init(dom, null, { renderer: 'svg' })
+
+    use([install]); // ----------------
+    // Charts (series)
+    // ----------------
+    // All of the series types, for example:
+    // chart.setOption({
+    //     series: [{
+    //         type: 'line' // or 'bar', 'pie', ...
+    //     }]
+    // });
+
+    use([install$2, install$3, install$4, install$6, install$8, install$a, install$b, install$c, install$d, install$e, install$f, install$h, install$i, install$j, install$k, install$l, install$m, install$n, install$o, install$p, install$q, install$r]); // -------------------
+    // Coordinate systems
+    // -------------------
+    // All of the axis modules have been included in the
+    // coordinate system module below, do not need to
+    // make extra import.
+    // `cartesian` coordinate system. For some historical
+    // reasons, it is named as grid, for example:
+    // chart.setOption({
+    //     grid: {...},
+    //     xAxis: {...},
+    //     yAxis: {...},
+    //     series: [{...}]
+    // });
+
+    use(install$t); // `polar` coordinate system, for example:
+    // chart.setOption({
+    //     polar: {...},
+    //     radiusAxis: {...},
+    //     angleAxis: {...},
+    //     series: [{
+    //         coordinateSystem: 'polar'
+    //     }]
+    // });
+
+    use(install$u); // `geo` coordinate system, for example:
+    // chart.setOption({
+    //     geo: {...},
+    //     series: [{
+    //         coordinateSystem: 'geo'
+    //     }]
+    // });
+
+    use(install$9); // `singleAxis` coordinate system (notice, it is a coordinate system
+    // with only one axis, work for chart like theme river), for example:
+    // chart.setOption({
+    //     singleAxis: {...}
+    //     series: [{type: 'themeRiver', ...}]
+    // });
+
+    use(install$v); // `parallel` coordinate system, only work for parallel series, for example:
+    // chart.setOption({
+    //     parallel: {...},
+    //     parallelAxis: [{...}, ...],
+    //     series: [{
+    //         type: 'parallel'
+    //     }]
+    // });
+
+    use(install$g); // `calendar` coordinate system. for example,
+    // chart.setOptionp({
+    //     calendar: {...},
+    //     series: [{
+    //         coordinateSystem: 'calendar'
+    //     }]
+    // );
+
+    use(install$w); // ------------------
+    // Other components
+    // ------------------
+    // `graphic` component, for example:
+    // chart.setOption({
+    //     graphic: {...}
+    // });
+
+    use(install$x); // `toolbox` component, for example:
+    // chart.setOption({
+    //     toolbox: {...}
+    // });
+
+    use(install$z); // `tooltip` component, for example:
+    // chart.setOption({
+    //     tooltip: {...}
+    // });
+
+    use(install$A); // `axisPointer` component, for example:
+    // chart.setOption({
+    //     tooltip: {axisPointer: {...}, ...}
+    // });
+    // Or
+    // chart.setOption({
+    //     axisPointer: {...}
+    // });
+
+    use(install$s); // `brush` component, for example:
+    // chart.setOption({
+    //     brush: {...}
+    // });
+    // Or
+    // chart.setOption({
+    //     tooltip: {feature: {brush: {...}}
+    // })
+
+    use(install$B); // `title` component, for example:
+    // chart.setOption({
+    //     title: {...}
+    // });
+
+    use(install$C); // `timeline` component, for example:
+    // chart.setOption({
+    //     timeline: {...}
+    // });
+
+    use(install$D); // `markPoint` component, for example:
+    // chart.setOption({
+    //     series: [{markPoint: {...}}]
+    // });
+
+    use(install$E); // `markLine` component, for example:
+    // chart.setOption({
+    //     series: [{markLine: {...}}]
+    // });
+
+    use(install$F); // `markArea` component, for example:
+    // chart.setOption({
+    //     series: [{markArea: {...}}]
+    // });
+
+    use(install$G); // `legend` component not scrollable. for example:
+    // chart.setOption({
+    //     legend: {...}
+    // });
+
+    use(install$J); // `dataZoom` component including both `dataZoomInside` and `dataZoomSlider`.
+
+    use(install$M); // `dataZoom` component providing drag, pinch, wheel behaviors
+    // inside coodinate system, for example:
+    // chart.setOption({
+    //     dataZoom: {type: 'inside'}
+    // });
+
+    use(install$K); // `dataZoom` component providing a slider bar, for example:
+    // chart.setOption({
+    //     dataZoom: {type: 'slider'}
+    // });
+
+    use(install$L); // `dataZoom` component including both `visualMapContinuous` and `visualMapPiecewise`.
+
+    use(install$P); // `visualMap` component providing continuous bar, for example:
+    // chart.setOption({
+    //     visualMap: {type: 'continuous'}
+    // });
+
+    use(install$N); // `visualMap` component providing pieces bar, for example:
+    // chart.setOption({
+    //     visualMap: {type: 'piecewise'}
+    // });
+
+    use(install$O); // `aria` component providing aria, for example:
+    // chart.setOption({
+    //     aria: {...}
+    // });
+
+    use(install$Q); // dataset transform
+    // chart.setOption({
+    //     dataset: {
+    //          transform: []
+    //     }
+    // });
+
+    use(install$R);
+    use(install$S);
+
+    exports.Axis = Axis;
+    exports.ChartView = ChartView;
+    exports.ComponentModel = ComponentModel;
+    exports.ComponentView = ComponentView;
+    exports.List = List;
+    exports.Model = Model;
+    exports.PRIORITY = PRIORITY;
+    exports.SeriesModel = SeriesModel;
+    exports.color = color;
+    exports.connect = connect;
+    exports.dataTool = dataTool;
+    exports.dependencies = dependencies;
+    exports.disConnect = disConnect;
+    exports.disconnect = disconnect;
+    exports.dispose = dispose$1;
+    exports.env = env;
+    exports.extendChartView = extendChartView;
+    exports.extendComponentModel = extendComponentModel;
+    exports.extendComponentView = extendComponentView;
+    exports.extendSeriesModel = extendSeriesModel;
+    exports.format = format$1;
+    exports.getCoordinateSystemDimensions = getCoordinateSystemDimensions;
+    exports.getInstanceByDom = getInstanceByDom;
+    exports.getInstanceById = getInstanceById;
+    exports.getMap = getMap;
+    exports.graphic = graphic$1;
+    exports.helper = helper;
+    exports.init = init$1;
+    exports.innerDrawElementOnCanvas = brushSingle;
+    exports.matrix = matrix;
+    exports.number = number;
+    exports.parseGeoJSON = parseGeoJSON;
+    exports.parseGeoJson = parseGeoJSON;
+    exports.registerAction = registerAction;
+    exports.registerCoordinateSystem = registerCoordinateSystem;
+    exports.registerLayout = registerLayout;
+    exports.registerLoading = registerLoading;
+    exports.registerLocale = registerLocale;
+    exports.registerMap = registerMap;
+    exports.registerPostInit = registerPostInit;
+    exports.registerPostUpdate = registerPostUpdate;
+    exports.registerPreprocessor = registerPreprocessor;
+    exports.registerProcessor = registerProcessor;
+    exports.registerTheme = registerTheme;
+    exports.registerTransform = registerTransform;
+    exports.registerVisual = registerVisual;
+    exports.setCanvasCreator = setCanvasCreator;
+    exports.throttle = throttle;
+    exports.time = time;
+    exports.use = use;
+    exports.util = util$1;
+    exports.vector = vector;
+    exports.version = version$1;
+    exports.zrUtil = util;
+    exports.zrender = zrender;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=echarts.js.map
diff --git a/src/main/resources/web/js/echarts.min.js b/src/main/resources/web/js/echarts.min.js
new file mode 100644
index 0000000..4beb85a
--- /dev/null
+++ b/src/main/resources/web/js/echarts.min.js
@@ -0,0 +1,45 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).echarts={})}(this,(function(t){"use strict";
+/*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])})(t,n)};function n(t,n){function i(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}var i=function(){return(i=Object.assign||function(t){for(var e,n=1,i=arguments.length;n<i;n++)for(var r in e=arguments[n])Object.prototype.hasOwnProperty.call(e,r)&&(t[r]=e[r]);return t}).apply(this,arguments)};function r(){for(var t=0,e=0,n=arguments.length;e<n;e++)t+=arguments[e].length;var i=Array(t),r=0;for(e=0;e<n;e++)for(var o=arguments[e],a=0,s=o.length;a<s;a++,r++)i[r]=o[a];return i}var o=function(){this.firefox=!1,this.ie=!1,this.edge=!1,this.newEdge=!1,this.weChat=!1},a=new function(){this.browser=new o,this.node=!1,this.wxa=!1,this.worker=!1,this.canvasSupported=!1,this.svgSupported=!1,this.touchEventsSupported=!1,this.pointerEventsSupported=!1,this.domSupported=!1};"object"==typeof wx&&"function"==typeof wx.getSystemInfoSync?(a.wxa=!0,a.canvasSupported=!0,a.touchEventsSupported=!0):"undefined"==typeof document&&"undefined"!=typeof self?(a.worker=!0,a.canvasSupported=!0):"undefined"==typeof navigator?(a.node=!0,a.canvasSupported=!0,a.svgSupported=!0):function(t,e){var n=e.browser,i=t.match(/Firefox\/([\d.]+)/),r=t.match(/MSIE\s([\d.]+)/)||t.match(/Trident\/.+?rv:(([\d.]+))/),o=t.match(/Edge?\/([\d.]+)/),a=/micromessenger/i.test(t);i&&(n.firefox=!0,n.version=i[1]);r&&(n.ie=!0,n.version=r[1]);o&&(n.edge=!0,n.version=o[1],n.newEdge=+o[1].split(".")[0]>18);a&&(n.weChat=!0);e.canvasSupported=!!document.createElement("canvas").getContext,e.svgSupported="undefined"!=typeof SVGRect,e.touchEventsSupported="ontouchstart"in window&&!n.ie&&!n.edge,e.pointerEventsSupported="onpointerdown"in window&&(n.edge||n.ie&&+n.version>=11),e.domSupported="undefined"!=typeof document}(navigator.userAgent,a);var s={"[object Function]":!0,"[object RegExp]":!0,"[object Date]":!0,"[object Error]":!0,"[object CanvasGradient]":!0,"[object CanvasPattern]":!0,"[object Image]":!0,"[object Canvas]":!0},l={"[object Int8Array]":!0,"[object Uint8Array]":!0,"[object Uint8ClampedArray]":!0,"[object Int16Array]":!0,"[object Uint16Array]":!0,"[object Int32Array]":!0,"[object Uint32Array]":!0,"[object Float32Array]":!0,"[object Float64Array]":!0},u=Object.prototype.toString,h=Array.prototype,c=h.forEach,p=h.filter,d=h.slice,f=h.map,g=function(){}.constructor,y=g?g.prototype:null,v={};function m(t,e){v[t]=e}var _=2311;function x(){return _++}function b(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];"undefined"!=typeof console&&console.error.apply(console,t)}function w(t){if(null==t||"object"!=typeof t)return t;var e=t,n=u.call(t);if("[object Array]"===n){if(!lt(t)){e=[];for(var i=0,r=t.length;i<r;i++)e[i]=w(t[i])}}else if(l[n]){if(!lt(t)){var o=t.constructor;if(o.from)e=o.from(t);else{e=new o(t.length);for(i=0,r=t.length;i<r;i++)e[i]=w(t[i])}}}else if(!s[n]&&!lt(t)&&!j(t))for(var a in e={},t)t.hasOwnProperty(a)&&(e[a]=w(t[a]));return e}function S(t,e,n){if(!X(e)||!X(t))return n?w(e):t;for(var i in e)if(e.hasOwnProperty(i)){var r=t[i],o=e[i];!X(o)||!X(r)||F(o)||F(r)||j(o)||j(r)||U(o)||U(r)||lt(o)||lt(r)?!n&&i in t||(t[i]=w(e[i])):S(r,o,n)}return t}function M(t,e){for(var n=t[0],i=1,r=t.length;i<r;i++)n=S(n,t[i],e);return n}function I(t,e){if(Object.assign)Object.assign(t,e);else for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}function T(t,e,n){for(var i=z(e),r=0;r<i.length;r++){var o=i[r];(n?null!=e[o]:null==t[o])&&(t[o]=e[o])}return t}var C=function(){return v.createCanvas()};function A(t,e){if(t){if(t.indexOf)return t.indexOf(e);for(var n=0,i=t.length;n<i;n++)if(t[n]===e)return n}return-1}function D(t,e){var n=t.prototype;function i(){}for(var r in i.prototype=e.prototype,t.prototype=new i,n)n.hasOwnProperty(r)&&(t.prototype[r]=n[r]);t.prototype.constructor=t,t.superClass=e}function L(t,e,n){if(t="prototype"in t?t.prototype:t,e="prototype"in e?e.prototype:e,Object.getOwnPropertyNames)for(var i=Object.getOwnPropertyNames(e),r=0;r<i.length;r++){var o=i[r];"constructor"!==o&&(n?null!=e[o]:null==t[o])&&(t[o]=e[o])}else T(t,e,n)}function k(t){return!!t&&("string"!=typeof t&&"number"==typeof t.length)}function P(t,e,n){if(t&&e)if(t.forEach&&t.forEach===c)t.forEach(e,n);else if(t.length===+t.length)for(var i=0,r=t.length;i<r;i++)e.call(n,t[i],i,t);else for(var o in t)t.hasOwnProperty(o)&&e.call(n,t[o],o,t)}function O(t,e,n){if(!t)return[];if(!e)return nt(t);if(t.map&&t.map===f)return t.map(e,n);for(var i=[],r=0,o=t.length;r<o;r++)i.push(e.call(n,t[r],r,t));return i}function R(t,e,n,i){if(t&&e){for(var r=0,o=t.length;r<o;r++)n=e.call(i,n,t[r],r,t);return n}}function N(t,e,n){if(!t)return[];if(!e)return nt(t);if(t.filter&&t.filter===p)return t.filter(e,n);for(var i=[],r=0,o=t.length;r<o;r++)e.call(n,t[r],r,t)&&i.push(t[r]);return i}function E(t,e,n){if(t&&e)for(var i=0,r=t.length;i<r;i++)if(e.call(n,t[i],i,t))return t[i]}function z(t){if(!t)return[];if(Object.keys)return Object.keys(t);var e=[];for(var n in t)t.hasOwnProperty(n)&&e.push(n);return e}v.createCanvas=function(){return document.createElement("canvas")};var B=y&&G(y.bind)?y.call.bind(y.bind):function(t,e){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];return function(){return t.apply(e,n.concat(d.call(arguments)))}};function V(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];return function(){return t.apply(this,e.concat(d.call(arguments)))}}function F(t){return Array.isArray?Array.isArray(t):"[object Array]"===u.call(t)}function G(t){return"function"==typeof t}function H(t){return"string"==typeof t}function W(t){return"[object String]"===u.call(t)}function Y(t){return"number"==typeof t}function X(t){var e=typeof t;return"function"===e||!!t&&"object"===e}function U(t){return!!s[u.call(t)]}function Z(t){return!!l[u.call(t)]}function j(t){return"object"==typeof t&&"number"==typeof t.nodeType&&"object"==typeof t.ownerDocument}function q(t){return null!=t.colorStops}function K(t){return null!=t.image}function $(t){return"[object RegExp]"===u.call(t)}function J(t){return t!=t}function Q(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];for(var n=0,i=t.length;n<i;n++)if(null!=t[n])return t[n]}function tt(t,e){return null!=t?t:e}function et(t,e,n){return null!=t?t:null!=e?e:n}function nt(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];return d.apply(t,e)}function it(t){if("number"==typeof t)return[t,t,t,t];var e=t.length;return 2===e?[t[0],t[1],t[0],t[1]]:3===e?[t[0],t[1],t[2],t[1]]:t}function rt(t,e){if(!t)throw new Error(e)}function ot(t){return null==t?null:"function"==typeof t.trim?t.trim():t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"")}var at="__ec_primitive__";function st(t){t[at]=!0}function lt(t){return t[at]}var ut=function(){function t(e){this.data={};var n=F(e);this.data={};var i=this;function r(t,e){n?i.set(t,e):i.set(e,t)}e instanceof t?e.each(r):e&&P(e,r)}return t.prototype.get=function(t){return this.data.hasOwnProperty(t)?this.data[t]:null},t.prototype.set=function(t,e){return this.data[t]=e},t.prototype.each=function(t,e){for(var n in this.data)this.data.hasOwnProperty(n)&&t.call(e,this.data[n],n)},t.prototype.keys=function(){return z(this.data)},t.prototype.removeKey=function(t){delete this.data[t]},t}();function ht(t){return new ut(t)}function ct(t,e){for(var n=new t.constructor(t.length+e.length),i=0;i<t.length;i++)n[i]=t[i];var r=t.length;for(i=0;i<e.length;i++)n[i+r]=e[i];return n}function pt(t,e){var n;if(Object.create)n=Object.create(t);else{var i=function(){};i.prototype=t,n=new i}return e&&I(n,e),n}function dt(t,e){return t.hasOwnProperty(e)}function ft(){}var gt=Object.freeze({__proto__:null,$override:m,guid:x,logError:b,clone:w,merge:S,mergeAll:M,extend:I,defaults:T,createCanvas:C,indexOf:A,inherits:D,mixin:L,isArrayLike:k,each:P,map:O,reduce:R,filter:N,find:E,keys:z,bind:B,curry:V,isArray:F,isFunction:G,isString:H,isStringSafe:W,isNumber:Y,isObject:X,isBuiltInObject:U,isTypedArray:Z,isDom:j,isGradientObject:q,isPatternObject:K,isRegExp:$,eqNaN:J,retrieve:Q,retrieve2:tt,retrieve3:et,slice:nt,normalizeCssArray:it,assert:rt,trim:ot,setAsPrimitive:st,isPrimitive:lt,HashMap:ut,createHashMap:ht,concatArray:ct,createObject:pt,hasOwn:dt,noop:ft});function yt(t,e){return null==t&&(t=0),null==e&&(e=0),[t,e]}function vt(t,e){return t[0]=e[0],t[1]=e[1],t}function mt(t){return[t[0],t[1]]}function _t(t,e,n){return t[0]=e,t[1]=n,t}function xt(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t}function bt(t,e,n,i){return t[0]=e[0]+n[0]*i,t[1]=e[1]+n[1]*i,t}function wt(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t}function St(t){return Math.sqrt(It(t))}var Mt=St;function It(t){return t[0]*t[0]+t[1]*t[1]}var Tt=It;function Ct(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t}function At(t,e){var n=St(e);return 0===n?(t[0]=0,t[1]=0):(t[0]=e[0]/n,t[1]=e[1]/n),t}function Dt(t,e){return Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1]))}var Lt=Dt;function kt(t,e){return(t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])}var Pt=kt;function Ot(t,e,n,i){return t[0]=e[0]+i*(n[0]-e[0]),t[1]=e[1]+i*(n[1]-e[1]),t}function Rt(t,e,n){var i=e[0],r=e[1];return t[0]=n[0]*i+n[2]*r+n[4],t[1]=n[1]*i+n[3]*r+n[5],t}function Nt(t,e,n){return t[0]=Math.min(e[0],n[0]),t[1]=Math.min(e[1],n[1]),t}function Et(t,e,n){return t[0]=Math.max(e[0],n[0]),t[1]=Math.max(e[1],n[1]),t}var zt=Object.freeze({__proto__:null,create:yt,copy:vt,clone:mt,set:_t,add:xt,scaleAndAdd:bt,sub:wt,len:St,length:Mt,lenSquare:It,lengthSquare:Tt,mul:function(t,e,n){return t[0]=e[0]*n[0],t[1]=e[1]*n[1],t},div:function(t,e,n){return t[0]=e[0]/n[0],t[1]=e[1]/n[1],t},dot:function(t,e){return t[0]*e[0]+t[1]*e[1]},scale:Ct,normalize:At,distance:Dt,dist:Lt,distanceSquare:kt,distSquare:Pt,negate:function(t,e){return t[0]=-e[0],t[1]=-e[1],t},lerp:Ot,applyTransform:Rt,min:Nt,max:Et}),Bt=function(t,e){this.target=t,this.topTarget=e&&e.topTarget},Vt=function(){function t(t){this.handler=t,t.on("mousedown",this._dragStart,this),t.on("mousemove",this._drag,this),t.on("mouseup",this._dragEnd,this)}return t.prototype._dragStart=function(t){for(var e=t.target;e&&!e.draggable;)e=e.parent;e&&(this._draggingTarget=e,e.dragging=!0,this._x=t.offsetX,this._y=t.offsetY,this.handler.dispatchToElement(new Bt(e,t),"dragstart",t.event))},t.prototype._drag=function(t){var e=this._draggingTarget;if(e){var n=t.offsetX,i=t.offsetY,r=n-this._x,o=i-this._y;this._x=n,this._y=i,e.drift(r,o,t),this.handler.dispatchToElement(new Bt(e,t),"drag",t.event);var a=this.handler.findHover(n,i,e).target,s=this._dropTarget;this._dropTarget=a,e!==a&&(s&&a!==s&&this.handler.dispatchToElement(new Bt(s,t),"dragleave",t.event),a&&a!==s&&this.handler.dispatchToElement(new Bt(a,t),"dragenter",t.event))}},t.prototype._dragEnd=function(t){var e=this._draggingTarget;e&&(e.dragging=!1),this.handler.dispatchToElement(new Bt(e,t),"dragend",t.event),this._dropTarget&&this.handler.dispatchToElement(new Bt(this._dropTarget,t),"drop",t.event),this._draggingTarget=null,this._dropTarget=null},t}(),Ft=function(){function t(t){t&&(this._$eventProcessor=t)}return t.prototype.on=function(t,e,n,i){this._$handlers||(this._$handlers={});var r=this._$handlers;if("function"==typeof e&&(i=n,n=e,e=null),!n||!t)return this;var o=this._$eventProcessor;null!=e&&o&&o.normalizeQuery&&(e=o.normalizeQuery(e)),r[t]||(r[t]=[]);for(var a=0;a<r[t].length;a++)if(r[t][a].h===n)return this;var s={h:n,query:e,ctx:i||this,callAtLast:n.zrEventfulCallAtLast},l=r[t].length-1,u=r[t][l];return u&&u.callAtLast?r[t].splice(l,0,s):r[t].push(s),this},t.prototype.isSilent=function(t){var e=this._$handlers;return!e||!e[t]||!e[t].length},t.prototype.off=function(t,e){var n=this._$handlers;if(!n)return this;if(!t)return this._$handlers={},this;if(e){if(n[t]){for(var i=[],r=0,o=n[t].length;r<o;r++)n[t][r].h!==e&&i.push(n[t][r]);n[t]=i}n[t]&&0===n[t].length&&delete n[t]}else delete n[t];return this},t.prototype.trigger=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];if(!this._$handlers)return this;var i=this._$handlers[t],r=this._$eventProcessor;if(i)for(var o=e.length,a=i.length,s=0;s<a;s++){var l=i[s];if(!r||!r.filter||null==l.query||r.filter(t,l.query))switch(o){case 0:l.h.call(l.ctx);break;case 1:l.h.call(l.ctx,e[0]);break;case 2:l.h.call(l.ctx,e[0],e[1]);break;default:l.h.apply(l.ctx,e)}}return r&&r.afterTrigger&&r.afterTrigger(t),this},t.prototype.triggerWithContext=function(t){if(!this._$handlers)return this;var e=this._$handlers[t],n=this._$eventProcessor;if(e)for(var i=arguments,r=i.length,o=i[r-1],a=e.length,s=0;s<a;s++){var l=e[s];if(!n||!n.filter||null==l.query||n.filter(t,l.query))switch(r){case 0:l.h.call(o);break;case 1:l.h.call(o,i[0]);break;case 2:l.h.call(o,i[0],i[1]);break;default:l.h.apply(o,i.slice(1,r-1))}}return n&&n.afterTrigger&&n.afterTrigger(t),this},t}(),Gt=Math.log(2);function Ht(t,e,n,i,r,o){var a=i+"-"+r,s=t.length;if(o.hasOwnProperty(a))return o[a];if(1===e){var l=Math.round(Math.log((1<<s)-1&~r)/Gt);return t[n][l]}for(var u=i|1<<n,h=n+1;i&1<<h;)h++;for(var c=0,p=0,d=0;p<s;p++){var f=1<<p;f&r||(c+=(d%2?-1:1)*t[n][p]*Ht(t,e-1,h,u,r|f,o),d++)}return o[a]=c,c}function Wt(t,e){var n=[[t[0],t[1],1,0,0,0,-e[0]*t[0],-e[0]*t[1]],[0,0,0,t[0],t[1],1,-e[1]*t[0],-e[1]*t[1]],[t[2],t[3],1,0,0,0,-e[2]*t[2],-e[2]*t[3]],[0,0,0,t[2],t[3],1,-e[3]*t[2],-e[3]*t[3]],[t[4],t[5],1,0,0,0,-e[4]*t[4],-e[4]*t[5]],[0,0,0,t[4],t[5],1,-e[5]*t[4],-e[5]*t[5]],[t[6],t[7],1,0,0,0,-e[6]*t[6],-e[6]*t[7]],[0,0,0,t[6],t[7],1,-e[7]*t[6],-e[7]*t[7]]],i={},r=Ht(n,8,0,0,0,i);if(0!==r){for(var o=[],a=0;a<8;a++)for(var s=0;s<8;s++)null==o[s]&&(o[s]=0),o[s]+=((a+s)%2?-1:1)*Ht(n,7,0===a?1:0,1<<a,1<<s,i)/r*e[a];return function(t,e,n){var i=e*o[6]+n*o[7]+1;t[0]=(e*o[0]+n*o[1]+o[2])/i,t[1]=(e*o[3]+n*o[4]+o[5])/i}}}var Yt=[];function Xt(t,e,n,i,r){if(e.getBoundingClientRect&&a.domSupported&&!Ut(e)){var o=e.___zrEVENTSAVED||(e.___zrEVENTSAVED={}),s=function(t,e,n){for(var i=n?"invTrans":"trans",r=e[i],o=e.srcCoords,a=[],s=[],l=!0,u=0;u<4;u++){var h=t[u].getBoundingClientRect(),c=2*u,p=h.left,d=h.top;a.push(p,d),l=l&&o&&p===o[c]&&d===o[c+1],s.push(t[u].offsetLeft,t[u].offsetTop)}return l&&r?r:(e.srcCoords=a,e[i]=n?Wt(s,a):Wt(a,s))}(function(t,e){var n=e.markers;if(n)return n;n=e.markers=[];for(var i=["left","right"],r=["top","bottom"],o=0;o<4;o++){var a=document.createElement("div"),s=o%2,l=(o>>1)%2;a.style.cssText=["position: absolute","visibility: hidden","padding: 0","margin: 0","border-width: 0","user-select: none","width:0","height:0",i[s]+":0",r[l]+":0",i[1-s]+":auto",r[1-l]+":auto",""].join("!important;"),t.appendChild(a),n.push(a)}return n}(e,o),o,r);if(s)return s(t,n,i),!0}return!1}function Ut(t){return"CANVAS"===t.nodeName.toUpperCase()}var Zt="undefined"!=typeof window&&!!window.addEventListener,jt=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,qt=[];function Kt(t,e,n,i){return n=n||{},i||!a.canvasSupported?$t(t,e,n):a.browser.firefox&&null!=e.layerX&&e.layerX!==e.offsetX?(n.zrX=e.layerX,n.zrY=e.layerY):null!=e.offsetX?(n.zrX=e.offsetX,n.zrY=e.offsetY):$t(t,e,n),n}function $t(t,e,n){if(a.domSupported&&t.getBoundingClientRect){var i=e.clientX,r=e.clientY;if(Ut(t)){var o=t.getBoundingClientRect();return n.zrX=i-o.left,void(n.zrY=r-o.top)}if(Xt(qt,t,i,r))return n.zrX=qt[0],void(n.zrY=qt[1])}n.zrX=n.zrY=0}function Jt(t){return t||window.event}function Qt(t,e,n){if(null!=(e=Jt(e)).zrX)return e;var i=e.type;if(i&&i.indexOf("touch")>=0){var r="touchend"!==i?e.targetTouches[0]:e.changedTouches[0];r&&Kt(t,r,e,n)}else{Kt(t,e,e,n);var o=function(t){var e=t.wheelDelta;if(e)return e;var n=t.deltaX,i=t.deltaY;if(null==n||null==i)return e;return 3*(0!==i?Math.abs(i):Math.abs(n))*(i>0?-1:i<0?1:n>0?-1:1)}(e);e.zrDelta=o?o/120:-(e.detail||0)/3}var a=e.button;return null==e.which&&void 0!==a&&jt.test(e.type)&&(e.which=1&a?1:2&a?3:4&a?2:0),e}function te(t,e,n,i){Zt?t.addEventListener(e,n,i):t.attachEvent("on"+e,n)}var ee=Zt?function(t){t.preventDefault(),t.stopPropagation(),t.cancelBubble=!0}:function(t){t.returnValue=!1,t.cancelBubble=!0};function ne(t){return 2===t.which||3===t.which}var ie=function(){function t(){this._track=[]}return t.prototype.recognize=function(t,e,n){return this._doTrack(t,e,n),this._recognize(t)},t.prototype.clear=function(){return this._track.length=0,this},t.prototype._doTrack=function(t,e,n){var i=t.touches;if(i){for(var r={points:[],touches:[],target:e,event:t},o=0,a=i.length;o<a;o++){var s=i[o],l=Kt(n,s,{});r.points.push([l.zrX,l.zrY]),r.touches.push(s)}this._track.push(r)}},t.prototype._recognize=function(t){for(var e in oe)if(oe.hasOwnProperty(e)){var n=oe[e](this._track,t);if(n)return n}},t}();function re(t){var e=t[1][0]-t[0][0],n=t[1][1]-t[0][1];return Math.sqrt(e*e+n*n)}var oe={pinch:function(t,e){var n=t.length;if(n){var i,r=(t[n-1]||{}).points,o=(t[n-2]||{}).points||r;if(o&&o.length>1&&r&&r.length>1){var a=re(r)/re(o);!isFinite(a)&&(a=1),e.pinchScale=a;var s=[((i=r)[0][0]+i[1][0])/2,(i[0][1]+i[1][1])/2];return e.pinchX=s[0],e.pinchY=s[1],{type:"pinch",target:t[0].target,event:e}}}}},ae="silent";function se(){ee(this.event)}var le=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.handler=null,e}return n(e,t),e.prototype.dispose=function(){},e.prototype.setCursor=function(){},e}(Ft),ue=function(t,e){this.x=t,this.y=e},he=["click","dblclick","mousewheel","mouseout","mouseup","mousedown","mousemove","contextmenu"],ce=function(t){function e(e,n,i,r){var o=t.call(this)||this;return o._hovered=new ue(0,0),o.storage=e,o.painter=n,o.painterRoot=r,i=i||new le,o.proxy=null,o.setHandlerProxy(i),o._draggingMgr=new Vt(o),o}return n(e,t),e.prototype.setHandlerProxy=function(t){this.proxy&&this.proxy.dispose(),t&&(P(he,(function(e){t.on&&t.on(e,this[e],this)}),this),t.handler=this),this.proxy=t},e.prototype.mousemove=function(t){var e=t.zrX,n=t.zrY,i=de(this,e,n),r=this._hovered,o=r.target;o&&!o.__zr&&(o=(r=this.findHover(r.x,r.y)).target);var a=this._hovered=i?new ue(e,n):this.findHover(e,n),s=a.target,l=this.proxy;l.setCursor&&l.setCursor(s?s.cursor:"default"),o&&s!==o&&this.dispatchToElement(r,"mouseout",t),this.dispatchToElement(a,"mousemove",t),s&&s!==o&&this.dispatchToElement(a,"mouseover",t)},e.prototype.mouseout=function(t){var e=t.zrEventControl;"only_globalout"!==e&&this.dispatchToElement(this._hovered,"mouseout",t),"no_globalout"!==e&&this.trigger("globalout",{type:"globalout",event:t})},e.prototype.resize=function(){this._hovered=new ue(0,0)},e.prototype.dispatch=function(t,e){var n=this[t];n&&n.call(this,e)},e.prototype.dispose=function(){this.proxy.dispose(),this.storage=null,this.proxy=null,this.painter=null},e.prototype.setCursorStyle=function(t){var e=this.proxy;e.setCursor&&e.setCursor(t)},e.prototype.dispatchToElement=function(t,e,n){var i=(t=t||{}).target;if(!i||!i.silent){for(var r="on"+e,o=function(t,e,n){return{type:t,event:n,target:e.target,topTarget:e.topTarget,cancelBubble:!1,offsetX:n.zrX,offsetY:n.zrY,gestureEvent:n.gestureEvent,pinchX:n.pinchX,pinchY:n.pinchY,pinchScale:n.pinchScale,wheelDelta:n.zrDelta,zrByTouch:n.zrByTouch,which:n.which,stop:se}}(e,t,n);i&&(i[r]&&(o.cancelBubble=!!i[r].call(i,o)),i.trigger(e,o),i=i.__hostTarget?i.__hostTarget:i.parent,!o.cancelBubble););o.cancelBubble||(this.trigger(e,o),this.painter&&this.painter.eachOtherLayer&&this.painter.eachOtherLayer((function(t){"function"==typeof t[r]&&t[r].call(t,o),t.trigger&&t.trigger(e,o)})))}},e.prototype.findHover=function(t,e,n){for(var i=this.storage.getDisplayList(),r=new ue(t,e),o=i.length-1;o>=0;o--){var a=void 0;if(i[o]!==n&&!i[o].ignore&&(a=pe(i[o],t,e))&&(!r.topTarget&&(r.topTarget=i[o]),a!==ae)){r.target=i[o];break}}return r},e.prototype.processGesture=function(t,e){this._gestureMgr||(this._gestureMgr=new ie);var n=this._gestureMgr;"start"===e&&n.clear();var i=n.recognize(t,this.findHover(t.zrX,t.zrY,null).target,this.proxy.dom);if("end"===e&&n.clear(),i){var r=i.type;t.gestureEvent=r;var o=new ue;o.target=i.target,this.dispatchToElement(o,r,i.event)}},e}(Ft);function pe(t,e,n){if(t[t.rectHover?"rectContain":"contain"](e,n)){for(var i=t,r=void 0,o=!1;i;){if(i.ignoreClip&&(o=!0),!o){var a=i.getClipPath();if(a&&!a.contain(e,n))return!1;i.silent&&(r=!0)}var s=i.__hostTarget;i=s||i.parent}return!r||ae}return!1}function de(t,e,n){var i=t.painter;return e<0||e>i.getWidth()||n<0||n>i.getHeight()}function fe(){return[1,0,0,1,0,0]}function ge(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=1,t[4]=0,t[5]=0,t}function ye(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t}function ve(t,e,n){var i=e[0]*n[0]+e[2]*n[1],r=e[1]*n[0]+e[3]*n[1],o=e[0]*n[2]+e[2]*n[3],a=e[1]*n[2]+e[3]*n[3],s=e[0]*n[4]+e[2]*n[5]+e[4],l=e[1]*n[4]+e[3]*n[5]+e[5];return t[0]=i,t[1]=r,t[2]=o,t[3]=a,t[4]=s,t[5]=l,t}function me(t,e,n){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4]+n[0],t[5]=e[5]+n[1],t}function _e(t,e,n){var i=e[0],r=e[2],o=e[4],a=e[1],s=e[3],l=e[5],u=Math.sin(n),h=Math.cos(n);return t[0]=i*h+a*u,t[1]=-i*u+a*h,t[2]=r*h+s*u,t[3]=-r*u+h*s,t[4]=h*o+u*l,t[5]=h*l-u*o,t}function xe(t,e,n){var i=n[0],r=n[1];return t[0]=e[0]*i,t[1]=e[1]*r,t[2]=e[2]*i,t[3]=e[3]*r,t[4]=e[4]*i,t[5]=e[5]*r,t}function be(t,e){var n=e[0],i=e[2],r=e[4],o=e[1],a=e[3],s=e[5],l=n*a-o*i;return l?(l=1/l,t[0]=a*l,t[1]=-o*l,t[2]=-i*l,t[3]=n*l,t[4]=(i*s-a*r)*l,t[5]=(o*r-n*s)*l,t):null}function we(t){var e=[1,0,0,1,0,0];return ye(e,t),e}P(["click","mousedown","mouseup","mousewheel","dblclick","contextmenu"],(function(t){ce.prototype[t]=function(e){var n,i,r=e.zrX,o=e.zrY,a=de(this,r,o);if("mouseup"===t&&a||(i=(n=this.findHover(r,o)).target),"mousedown"===t)this._downEl=i,this._downPoint=[e.zrX,e.zrY],this._upEl=i;else if("mouseup"===t)this._upEl=i;else if("click"===t){if(this._downEl!==this._upEl||!this._downPoint||Lt(this._downPoint,[e.zrX,e.zrY])>4)return;this._downPoint=null}this.dispatchToElement(n,t,e)}}));var Se=Object.freeze({__proto__:null,create:fe,identity:ge,copy:ye,mul:ve,translate:me,rotate:_e,scale:xe,invert:be,clone:we}),Me=ge,Ie=5e-5;function Te(t){return t>Ie||t<-5e-5}var Ce=[],Ae=[],De=[1,0,0,1,0,0],Le=Math.abs,ke=function(){function t(){}return t.prototype.setPosition=function(t){this.x=t[0],this.y=t[1]},t.prototype.setScale=function(t){this.scaleX=t[0],this.scaleY=t[1]},t.prototype.setOrigin=function(t){this.originX=t[0],this.originY=t[1]},t.prototype.needLocalTransform=function(){return Te(this.rotation)||Te(this.x)||Te(this.y)||Te(this.scaleX-1)||Te(this.scaleY-1)},t.prototype.updateTransform=function(){var t=this.parent,e=t&&t.transform,n=this.needLocalTransform(),i=this.transform;n||e?(i=i||[1,0,0,1,0,0],n?this.getLocalTransform(i):Me(i),e&&(n?ve(i,t.transform,i):ye(i,t.transform)),this.transform=i,this._resolveGlobalScaleRatio(i)):i&&Me(i)},t.prototype._resolveGlobalScaleRatio=function(t){var e=this.globalScaleRatio;if(null!=e&&1!==e){this.getGlobalScale(Ce);var n=Ce[0]<0?-1:1,i=Ce[1]<0?-1:1,r=((Ce[0]-n)*e+n)/Ce[0]||0,o=((Ce[1]-i)*e+i)/Ce[1]||0;t[0]*=r,t[1]*=r,t[2]*=o,t[3]*=o}this.invTransform=this.invTransform||[1,0,0,1,0,0],be(this.invTransform,t)},t.prototype.getLocalTransform=function(e){return t.getLocalTransform(this,e)},t.prototype.getComputedTransform=function(){for(var t=this,e=[];t;)e.push(t),t=t.parent;for(;t=e.pop();)t.updateTransform();return this.transform},t.prototype.setLocalTransform=function(t){if(t){var e=t[0]*t[0]+t[1]*t[1],n=t[2]*t[2]+t[3]*t[3];Te(e-1)&&(e=Math.sqrt(e)),Te(n-1)&&(n=Math.sqrt(n)),t[0]<0&&(e=-e),t[3]<0&&(n=-n),this.rotation=Math.atan2(-t[1]/n,t[0]/e),e<0&&n<0&&(this.rotation+=Math.PI,e=-e,n=-n),this.x=t[4],this.y=t[5],this.scaleX=e,this.scaleY=n}},t.prototype.decomposeTransform=function(){if(this.transform){var t=this.parent,e=this.transform;t&&t.transform&&(ve(Ae,t.invTransform,e),e=Ae);var n=this.originX,i=this.originY;(n||i)&&(De[4]=n,De[5]=i,ve(Ae,e,De),Ae[4]-=n,Ae[5]-=i,e=Ae),this.setLocalTransform(e)}},t.prototype.getGlobalScale=function(t){var e=this.transform;return t=t||[],e?(t[0]=Math.sqrt(e[0]*e[0]+e[1]*e[1]),t[1]=Math.sqrt(e[2]*e[2]+e[3]*e[3]),e[0]<0&&(t[0]=-t[0]),e[3]<0&&(t[1]=-t[1]),t):(t[0]=1,t[1]=1,t)},t.prototype.transformCoordToLocal=function(t,e){var n=[t,e],i=this.invTransform;return i&&Rt(n,n,i),n},t.prototype.transformCoordToGlobal=function(t,e){var n=[t,e],i=this.transform;return i&&Rt(n,n,i),n},t.prototype.getLineScale=function(){var t=this.transform;return t&&Le(t[0]-1)>1e-10&&Le(t[3]-1)>1e-10?Math.sqrt(Le(t[0]*t[3]-t[2]*t[1])):1},t.getLocalTransform=function(t,e){Me(e=e||[]);var n=t.originX||0,i=t.originY||0,r=t.scaleX,o=t.scaleY,a=t.rotation||0,s=t.x,l=t.y;return e[4]-=n,e[5]-=i,e[0]*=r,e[1]*=o,e[2]*=r,e[3]*=o,e[4]*=r,e[5]*=o,a&&_e(e,e,a),e[4]+=n,e[5]+=i,e[4]+=s,e[5]+=l,e},t.initDefaultProps=function(){var e=t.prototype;e.x=0,e.y=0,e.scaleX=1,e.scaleY=1,e.originX=0,e.originY=0,e.rotation=0,e.globalScaleRatio=1}(),t}(),Pe={linear:function(t){return t},quadraticIn:function(t){return t*t},quadraticOut:function(t){return t*(2-t)},quadraticInOut:function(t){return(t*=2)<1?.5*t*t:-.5*(--t*(t-2)-1)},cubicIn:function(t){return t*t*t},cubicOut:function(t){return--t*t*t+1},cubicInOut:function(t){return(t*=2)<1?.5*t*t*t:.5*((t-=2)*t*t+2)},quarticIn:function(t){return t*t*t*t},quarticOut:function(t){return 1- --t*t*t*t},quarticInOut:function(t){return(t*=2)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2)},quinticIn:function(t){return t*t*t*t*t},quinticOut:function(t){return--t*t*t*t*t+1},quinticInOut:function(t){return(t*=2)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2)},sinusoidalIn:function(t){return 1-Math.cos(t*Math.PI/2)},sinusoidalOut:function(t){return Math.sin(t*Math.PI/2)},sinusoidalInOut:function(t){return.5*(1-Math.cos(Math.PI*t))},exponentialIn:function(t){return 0===t?0:Math.pow(1024,t-1)},exponentialOut:function(t){return 1===t?1:1-Math.pow(2,-10*t)},exponentialInOut:function(t){return 0===t?0:1===t?1:(t*=2)<1?.5*Math.pow(1024,t-1):.5*(2-Math.pow(2,-10*(t-1)))},circularIn:function(t){return 1-Math.sqrt(1-t*t)},circularOut:function(t){return Math.sqrt(1- --t*t)},circularInOut:function(t){return(t*=2)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1)},elasticIn:function(t){var e,n=.1;return 0===t?0:1===t?1:(!n||n<1?(n=1,e=.1):e=.4*Math.asin(1/n)/(2*Math.PI),-n*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/.4))},elasticOut:function(t){var e,n=.1;return 0===t?0:1===t?1:(!n||n<1?(n=1,e=.1):e=.4*Math.asin(1/n)/(2*Math.PI),n*Math.pow(2,-10*t)*Math.sin((t-e)*(2*Math.PI)/.4)+1)},elasticInOut:function(t){var e,n=.1,i=.4;return 0===t?0:1===t?1:(!n||n<1?(n=1,e=.1):e=i*Math.asin(1/n)/(2*Math.PI),(t*=2)<1?n*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/i)*-.5:n*Math.pow(2,-10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/i)*.5+1)},backIn:function(t){var e=1.70158;return t*t*((e+1)*t-e)},backOut:function(t){var e=1.70158;return--t*t*((e+1)*t+e)+1},backInOut:function(t){var e=2.5949095;return(t*=2)<1?t*t*((e+1)*t-e)*.5:.5*((t-=2)*t*((e+1)*t+e)+2)},bounceIn:function(t){return 1-Pe.bounceOut(1-t)},bounceOut:function(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375},bounceInOut:function(t){return t<.5?.5*Pe.bounceIn(2*t):.5*Pe.bounceOut(2*t-1)+.5}},Oe=function(){function t(t){this._initialized=!1,this._startTime=0,this._pausedTime=0,this._paused=!1,this._life=t.life||1e3,this._delay=t.delay||0,this.loop=null!=t.loop&&t.loop,this.gap=t.gap||0,this.easing=t.easing||"linear",this.onframe=t.onframe,this.ondestroy=t.ondestroy,this.onrestart=t.onrestart}return t.prototype.step=function(t,e){if(this._initialized||(this._startTime=t+this._delay,this._initialized=!0),!this._paused){var n=(t-this._startTime-this._pausedTime)/this._life;n<0&&(n=0),n=Math.min(n,1);var i=this.easing,r="string"==typeof i?Pe[i]:i,o="function"==typeof r?r(n):n;if(this.onframe&&this.onframe(o),1===n){if(!this.loop)return!0;this._restart(t),this.onrestart&&this.onrestart()}return!1}this._pausedTime+=e},t.prototype._restart=function(t){var e=(t-this._startTime-this._pausedTime)%this._life;this._startTime=t-e+this.gap,this._pausedTime=0},t.prototype.pause=function(){this._paused=!0},t.prototype.resume=function(){this._paused=!1},t}(),Re=function(t){this.value=t},Ne=function(){function t(){this._len=0}return t.prototype.insert=function(t){var e=new Re(t);return this.insertEntry(e),e},t.prototype.insertEntry=function(t){this.head?(this.tail.next=t,t.prev=this.tail,t.next=null,this.tail=t):this.head=this.tail=t,this._len++},t.prototype.remove=function(t){var e=t.prev,n=t.next;e?e.next=n:this.head=n,n?n.prev=e:this.tail=e,t.next=t.prev=null,this._len--},t.prototype.len=function(){return this._len},t.prototype.clear=function(){this.head=this.tail=null,this._len=0},t}(),Ee=function(){function t(t){this._list=new Ne,this._maxSize=10,this._map={},this._maxSize=t}return t.prototype.put=function(t,e){var n=this._list,i=this._map,r=null;if(null==i[t]){var o=n.len(),a=this._lastRemovedEntry;if(o>=this._maxSize&&o>0){var s=n.head;n.remove(s),delete i[s.key],r=s.value,this._lastRemovedEntry=s}a?a.value=e:a=new Re(e),a.key=t,n.insertEntry(a),i[t]=a}return r},t.prototype.get=function(t){var e=this._map[t],n=this._list;if(null!=e)return e!==n.tail&&(n.remove(e),n.insertEntry(e)),e.value},t.prototype.clear=function(){this._list.clear(),this._map={}},t.prototype.len=function(){return this._list.len()},t}(),ze={transparent:[0,0,0,0],aliceblue:[240,248,255,1],antiquewhite:[250,235,215,1],aqua:[0,255,255,1],aquamarine:[127,255,212,1],azure:[240,255,255,1],beige:[245,245,220,1],bisque:[255,228,196,1],black:[0,0,0,1],blanchedalmond:[255,235,205,1],blue:[0,0,255,1],blueviolet:[138,43,226,1],brown:[165,42,42,1],burlywood:[222,184,135,1],cadetblue:[95,158,160,1],chartreuse:[127,255,0,1],chocolate:[210,105,30,1],coral:[255,127,80,1],cornflowerblue:[100,149,237,1],cornsilk:[255,248,220,1],crimson:[220,20,60,1],cyan:[0,255,255,1],darkblue:[0,0,139,1],darkcyan:[0,139,139,1],darkgoldenrod:[184,134,11,1],darkgray:[169,169,169,1],darkgreen:[0,100,0,1],darkgrey:[169,169,169,1],darkkhaki:[189,183,107,1],darkmagenta:[139,0,139,1],darkolivegreen:[85,107,47,1],darkorange:[255,140,0,1],darkorchid:[153,50,204,1],darkred:[139,0,0,1],darksalmon:[233,150,122,1],darkseagreen:[143,188,143,1],darkslateblue:[72,61,139,1],darkslategray:[47,79,79,1],darkslategrey:[47,79,79,1],darkturquoise:[0,206,209,1],darkviolet:[148,0,211,1],deeppink:[255,20,147,1],deepskyblue:[0,191,255,1],dimgray:[105,105,105,1],dimgrey:[105,105,105,1],dodgerblue:[30,144,255,1],firebrick:[178,34,34,1],floralwhite:[255,250,240,1],forestgreen:[34,139,34,1],fuchsia:[255,0,255,1],gainsboro:[220,220,220,1],ghostwhite:[248,248,255,1],gold:[255,215,0,1],goldenrod:[218,165,32,1],gray:[128,128,128,1],green:[0,128,0,1],greenyellow:[173,255,47,1],grey:[128,128,128,1],honeydew:[240,255,240,1],hotpink:[255,105,180,1],indianred:[205,92,92,1],indigo:[75,0,130,1],ivory:[255,255,240,1],khaki:[240,230,140,1],lavender:[230,230,250,1],lavenderblush:[255,240,245,1],lawngreen:[124,252,0,1],lemonchiffon:[255,250,205,1],lightblue:[173,216,230,1],lightcoral:[240,128,128,1],lightcyan:[224,255,255,1],lightgoldenrodyellow:[250,250,210,1],lightgray:[211,211,211,1],lightgreen:[144,238,144,1],lightgrey:[211,211,211,1],lightpink:[255,182,193,1],lightsalmon:[255,160,122,1],lightseagreen:[32,178,170,1],lightskyblue:[135,206,250,1],lightslategray:[119,136,153,1],lightslategrey:[119,136,153,1],lightsteelblue:[176,196,222,1],lightyellow:[255,255,224,1],lime:[0,255,0,1],limegreen:[50,205,50,1],linen:[250,240,230,1],magenta:[255,0,255,1],maroon:[128,0,0,1],mediumaquamarine:[102,205,170,1],mediumblue:[0,0,205,1],mediumorchid:[186,85,211,1],mediumpurple:[147,112,219,1],mediumseagreen:[60,179,113,1],mediumslateblue:[123,104,238,1],mediumspringgreen:[0,250,154,1],mediumturquoise:[72,209,204,1],mediumvioletred:[199,21,133,1],midnightblue:[25,25,112,1],mintcream:[245,255,250,1],mistyrose:[255,228,225,1],moccasin:[255,228,181,1],navajowhite:[255,222,173,1],navy:[0,0,128,1],oldlace:[253,245,230,1],olive:[128,128,0,1],olivedrab:[107,142,35,1],orange:[255,165,0,1],orangered:[255,69,0,1],orchid:[218,112,214,1],palegoldenrod:[238,232,170,1],palegreen:[152,251,152,1],paleturquoise:[175,238,238,1],palevioletred:[219,112,147,1],papayawhip:[255,239,213,1],peachpuff:[255,218,185,1],peru:[205,133,63,1],pink:[255,192,203,1],plum:[221,160,221,1],powderblue:[176,224,230,1],purple:[128,0,128,1],red:[255,0,0,1],rosybrown:[188,143,143,1],royalblue:[65,105,225,1],saddlebrown:[139,69,19,1],salmon:[250,128,114,1],sandybrown:[244,164,96,1],seagreen:[46,139,87,1],seashell:[255,245,238,1],sienna:[160,82,45,1],silver:[192,192,192,1],skyblue:[135,206,235,1],slateblue:[106,90,205,1],slategray:[112,128,144,1],slategrey:[112,128,144,1],snow:[255,250,250,1],springgreen:[0,255,127,1],steelblue:[70,130,180,1],tan:[210,180,140,1],teal:[0,128,128,1],thistle:[216,191,216,1],tomato:[255,99,71,1],turquoise:[64,224,208,1],violet:[238,130,238,1],wheat:[245,222,179,1],white:[255,255,255,1],whitesmoke:[245,245,245,1],yellow:[255,255,0,1],yellowgreen:[154,205,50,1]};function Be(t){return(t=Math.round(t))<0?0:t>255?255:t}function Ve(t){return t<0?0:t>1?1:t}function Fe(t){var e=t;return e.length&&"%"===e.charAt(e.length-1)?Be(parseFloat(e)/100*255):Be(parseInt(e,10))}function Ge(t){var e=t;return e.length&&"%"===e.charAt(e.length-1)?Ve(parseFloat(e)/100):Ve(parseFloat(e))}function He(t,e,n){return n<0?n+=1:n>1&&(n-=1),6*n<1?t+(e-t)*n*6:2*n<1?e:3*n<2?t+(e-t)*(2/3-n)*6:t}function We(t,e,n){return t+(e-t)*n}function Ye(t,e,n,i,r){return t[0]=e,t[1]=n,t[2]=i,t[3]=r,t}function Xe(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t}var Ue=new Ee(20),Ze=null;function je(t,e){Ze&&Xe(Ze,e),Ze=Ue.put(t,Ze||e.slice())}function qe(t,e){if(t){e=e||[];var n=Ue.get(t);if(n)return Xe(e,n);var i=(t+="").replace(/ /g,"").toLowerCase();if(i in ze)return Xe(e,ze[i]),je(t,e),e;var r,o=i.length;if("#"===i.charAt(0))return 4===o||5===o?(r=parseInt(i.slice(1,4),16))>=0&&r<=4095?(Ye(e,(3840&r)>>4|(3840&r)>>8,240&r|(240&r)>>4,15&r|(15&r)<<4,5===o?parseInt(i.slice(4),16)/15:1),je(t,e),e):void Ye(e,0,0,0,1):7===o||9===o?(r=parseInt(i.slice(1,7),16))>=0&&r<=16777215?(Ye(e,(16711680&r)>>16,(65280&r)>>8,255&r,9===o?parseInt(i.slice(7),16)/255:1),je(t,e),e):void Ye(e,0,0,0,1):void 0;var a=i.indexOf("("),s=i.indexOf(")");if(-1!==a&&s+1===o){var l=i.substr(0,a),u=i.substr(a+1,s-(a+1)).split(","),h=1;switch(l){case"rgba":if(4!==u.length)return 3===u.length?Ye(e,+u[0],+u[1],+u[2],1):Ye(e,0,0,0,1);h=Ge(u.pop());case"rgb":return 3!==u.length?void Ye(e,0,0,0,1):(Ye(e,Fe(u[0]),Fe(u[1]),Fe(u[2]),h),je(t,e),e);case"hsla":return 4!==u.length?void Ye(e,0,0,0,1):(u[3]=Ge(u[3]),Ke(u,e),je(t,e),e);case"hsl":return 3!==u.length?void Ye(e,0,0,0,1):(Ke(u,e),je(t,e),e);default:return}}Ye(e,0,0,0,1)}}function Ke(t,e){var n=(parseFloat(t[0])%360+360)%360/360,i=Ge(t[1]),r=Ge(t[2]),o=r<=.5?r*(i+1):r+i-r*i,a=2*r-o;return Ye(e=e||[],Be(255*He(a,o,n+1/3)),Be(255*He(a,o,n)),Be(255*He(a,o,n-1/3)),1),4===t.length&&(e[3]=t[3]),e}function $e(t,e){var n=qe(t);if(n){for(var i=0;i<3;i++)n[i]=e<0?n[i]*(1-e)|0:(255-n[i])*e+n[i]|0,n[i]>255?n[i]=255:n[i]<0&&(n[i]=0);return an(n,4===n.length?"rgba":"rgb")}}function Je(t){var e=qe(t);if(e)return((1<<24)+(e[0]<<16)+(e[1]<<8)+ +e[2]).toString(16).slice(1)}function Qe(t,e,n){if(e&&e.length&&t>=0&&t<=1){n=n||[];var i=t*(e.length-1),r=Math.floor(i),o=Math.ceil(i),a=e[r],s=e[o],l=i-r;return n[0]=Be(We(a[0],s[0],l)),n[1]=Be(We(a[1],s[1],l)),n[2]=Be(We(a[2],s[2],l)),n[3]=Ve(We(a[3],s[3],l)),n}}var tn=Qe;function en(t,e,n){if(e&&e.length&&t>=0&&t<=1){var i=t*(e.length-1),r=Math.floor(i),o=Math.ceil(i),a=qe(e[r]),s=qe(e[o]),l=i-r,u=an([Be(We(a[0],s[0],l)),Be(We(a[1],s[1],l)),Be(We(a[2],s[2],l)),Ve(We(a[3],s[3],l))],"rgba");return n?{color:u,leftIndex:r,rightIndex:o,value:i}:u}}var nn=en;function rn(t,e,n,i){var r=qe(t);if(t)return r=function(t){if(t){var e,n,i=t[0]/255,r=t[1]/255,o=t[2]/255,a=Math.min(i,r,o),s=Math.max(i,r,o),l=s-a,u=(s+a)/2;if(0===l)e=0,n=0;else{n=u<.5?l/(s+a):l/(2-s-a);var h=((s-i)/6+l/2)/l,c=((s-r)/6+l/2)/l,p=((s-o)/6+l/2)/l;i===s?e=p-c:r===s?e=1/3+h-p:o===s&&(e=2/3+c-h),e<0&&(e+=1),e>1&&(e-=1)}var d=[360*e,n,u];return null!=t[3]&&d.push(t[3]),d}}(r),null!=e&&(r[0]=function(t){return(t=Math.round(t))<0?0:t>360?360:t}(e)),null!=n&&(r[1]=Ge(n)),null!=i&&(r[2]=Ge(i)),an(Ke(r),"rgba")}function on(t,e){var n=qe(t);if(n&&null!=e)return n[3]=Ve(e),an(n,"rgba")}function an(t,e){if(t&&t.length){var n=t[0]+","+t[1]+","+t[2];return"rgba"!==e&&"hsva"!==e&&"hsla"!==e||(n+=","+t[3]),e+"("+n+")"}}function sn(t,e){var n=qe(t);return n?(.299*n[0]+.587*n[1]+.114*n[2])*n[3]/255+(1-n[3])*e:0}var ln=Object.freeze({__proto__:null,parse:qe,lift:$e,toHex:Je,fastLerp:Qe,fastMapToColor:tn,lerp:en,mapToColor:nn,modifyHSL:rn,modifyAlpha:on,stringify:an,lum:sn,random:function(){return"rgb("+Math.round(255*Math.random())+","+Math.round(255*Math.random())+","+Math.round(255*Math.random())+")"}}),un=Array.prototype.slice;function hn(t,e,n){return(e-t)*n+t}function cn(t,e,n,i){for(var r=e.length,o=0;o<r;o++)t[o]=hn(e[o],n[o],i)}function pn(t,e,n,i){for(var r=e.length,o=0;o<r;o++)t[o]=e[o]+n[o]*i;return t}function dn(t,e,n,i){for(var r=e.length,o=r&&e[0].length,a=0;a<r;a++){t[a]||(t[a]=[]);for(var s=0;s<o;s++)t[a][s]=e[a][s]+n[a][s]*i}return t}function fn(t,e,n){var i=t,r=e;if(i.push&&r.push){var o=i.length,a=r.length;if(o!==a)if(o>a)i.length=a;else for(var s=o;s<a;s++)i.push(1===n?r[s]:un.call(r[s]));var l=i[0]&&i[0].length;for(s=0;s<i.length;s++)if(1===n)isNaN(i[s])&&(i[s]=r[s]);else for(var u=0;u<l;u++)isNaN(i[s][u])&&(i[s][u]=r[s][u])}}function gn(t,e){var n=t.length;if(n!==e.length)return!1;for(var i=0;i<n;i++)if(t[i]!==e[i])return!1;return!0}function yn(t,e,n,i,r,o,a){var s=.5*(n-t),l=.5*(i-e);return(2*(e-n)+s+l)*a+(-3*(e-n)-2*s-l)*o+s*r+e}function vn(t,e,n,i,r,o,a,s){for(var l=e.length,u=0;u<l;u++)t[u]=yn(e[u],n[u],i[u],r[u],o,a,s)}function mn(t){if(k(t)){var e=t.length;if(k(t[0])){for(var n=[],i=0;i<e;i++)n.push(un.call(t[i]));return n}return un.call(t)}return t}function _n(t){return t[0]=Math.floor(t[0]),t[1]=Math.floor(t[1]),t[2]=Math.floor(t[2]),"rgba("+t.join(",")+")"}var xn,bn,wn=[0,0,0,0],Sn=function(){function t(t){this.keyframes=[],this.maxTime=0,this.arrDim=0,this.interpolable=!0,this._needsSort=!1,this._isAllValueEqual=!0,this._lastFrame=0,this._lastFramePercent=0,this.propName=t}return t.prototype.isFinished=function(){return this._finished},t.prototype.setFinished=function(){this._finished=!0,this._additiveTrack&&this._additiveTrack.setFinished()},t.prototype.needsAnimate=function(){return!this._isAllValueEqual&&this.keyframes.length>=2&&this.interpolable},t.prototype.getAdditiveTrack=function(){return this._additiveTrack},t.prototype.addKeyframe=function(t,e){t>=this.maxTime?this.maxTime=t:this._needsSort=!0;var n=this.keyframes,i=n.length;if(this.interpolable)if(k(e)){var r=function(t){return k(t&&t[0])?2:1}(e);if(i>0&&this.arrDim!==r)return void(this.interpolable=!1);if(1===r&&"number"!=typeof e[0]||2===r&&"number"!=typeof e[0][0])return void(this.interpolable=!1);if(i>0){var o=n[i-1];this._isAllValueEqual&&(1===r&&gn(e,o.value)||(this._isAllValueEqual=!1))}this.arrDim=r}else{if(this.arrDim>0)return void(this.interpolable=!1);if("string"==typeof e){var a=qe(e);a?(e=a,this.isValueColor=!0):this.interpolable=!1}else if("number"!=typeof e)return void(this.interpolable=!1);if(this._isAllValueEqual&&i>0){o=n[i-1];(this.isValueColor&&!gn(o.value,e)||o.value!==e)&&(this._isAllValueEqual=!1)}}var s={time:t,value:e,percent:0};return this.keyframes.push(s),s},t.prototype.prepare=function(t){var e=this.keyframes;this._needsSort&&e.sort((function(t,e){return t.time-e.time}));for(var n=this.arrDim,i=e.length,r=e[i-1],o=0;o<i;o++)e[o].percent=e[o].time/this.maxTime,n>0&&o!==i-1&&fn(e[o].value,r.value,n);if(t&&this.needsAnimate()&&t.needsAnimate()&&n===t.arrDim&&this.isValueColor===t.isValueColor&&!t._finished){this._additiveTrack=t;var a=e[0].value;for(o=0;o<i;o++)0===n?this.isValueColor?e[o].additiveValue=pn([],e[o].value,a,-1):e[o].additiveValue=e[o].value-a:1===n?e[o].additiveValue=pn([],e[o].value,a,-1):2===n&&(e[o].additiveValue=dn([],e[o].value,a,-1))}},t.prototype.step=function(t,e){if(!this._finished){this._additiveTrack&&this._additiveTrack._finished&&(this._additiveTrack=null);var n,i=null!=this._additiveTrack,r=i?"additiveValue":"value",o=this.keyframes,a=this.keyframes.length,s=this.propName,l=this.arrDim,u=this.isValueColor;if(e<0)n=0;else if(e<this._lastFramePercent){for(n=Math.min(this._lastFrame+1,a-1);n>=0&&!(o[n].percent<=e);n--);n=Math.min(n,a-2)}else{for(n=this._lastFrame;n<a&&!(o[n].percent>e);n++);n=Math.min(n-1,a-2)}var h=o[n+1],c=o[n];if(c&&h){this._lastFrame=n,this._lastFramePercent=e;var p=h.percent-c.percent;if(0!==p){var d=(e-c.percent)/p,f=i?this._additiveValue:u?wn:t[s];if((l>0||u)&&!f&&(f=this._additiveValue=[]),this.useSpline){var g=o[n][r],y=o[0===n?n:n-1][r],v=o[n>a-2?a-1:n+1][r],m=o[n>a-3?a-1:n+2][r];if(l>0)1===l?vn(f,y,g,v,m,d,d*d,d*d*d):function(t,e,n,i,r,o,a,s){for(var l=e.length,u=e[0].length,h=0;h<l;h++){t[h]||(t[1]=[]);for(var c=0;c<u;c++)t[h][c]=yn(e[h][c],n[h][c],i[h][c],r[h][c],o,a,s)}}(f,y,g,v,m,d,d*d,d*d*d);else if(u)vn(f,y,g,v,m,d,d*d,d*d*d),i||(t[s]=_n(f));else{var _=void 0;_=this.interpolable?yn(y,g,v,m,d,d*d,d*d*d):v,i?this._additiveValue=_:t[s]=_}}else if(l>0)1===l?cn(f,c[r],h[r],d):function(t,e,n,i){for(var r=e.length,o=r&&e[0].length,a=0;a<r;a++){t[a]||(t[a]=[]);for(var s=0;s<o;s++)t[a][s]=hn(e[a][s],n[a][s],i)}}(f,c[r],h[r],d);else if(u)cn(f,c[r],h[r],d),i||(t[s]=_n(f));else{_=void 0;_=this.interpolable?hn(c[r],h[r],d):function(t,e,n){return n>.5?e:t}(c[r],h[r],d),i?this._additiveValue=_:t[s]=_}i&&this._addToTarget(t)}}}},t.prototype._addToTarget=function(t){var e=this.arrDim,n=this.propName,i=this._additiveValue;0===e?this.isValueColor?(qe(t[n],wn),pn(wn,wn,i,1),t[n]=_n(wn)):t[n]=t[n]+i:1===e?pn(t[n],t[n],i,1):2===e&&dn(t[n],t[n],i,1)},t}(),Mn=function(){function t(t,e,n){this._tracks={},this._trackKeys=[],this._delay=0,this._maxTime=0,this._paused=!1,this._started=0,this._clip=null,this._target=t,this._loop=e,e&&n?b("Can' use additive animation on looped animation."):this._additiveAnimators=n}return t.prototype.getTarget=function(){return this._target},t.prototype.changeTarget=function(t){this._target=t},t.prototype.when=function(t,e){return this.whenWithKeys(t,e,z(e))},t.prototype.whenWithKeys=function(t,e,n){for(var i=this._tracks,r=0;r<n.length;r++){var o=n[r],a=i[o];if(!a){a=i[o]=new Sn(o);var s=void 0,l=this._getAdditiveTrack(o);if(l){var u=l.keyframes[l.keyframes.length-1];s=u&&u.value,l.isValueColor&&s&&(s=_n(s))}else s=this._target[o];if(null==s)continue;0!==t&&a.addKeyframe(0,mn(s)),this._trackKeys.push(o)}a.addKeyframe(t,mn(e[o]))}return this._maxTime=Math.max(this._maxTime,t),this},t.prototype.pause=function(){this._clip.pause(),this._paused=!0},t.prototype.resume=function(){this._clip.resume(),this._paused=!1},t.prototype.isPaused=function(){return!!this._paused},t.prototype._doneCallback=function(){this._setTracksFinished(),this._clip=null;var t=this._doneList;if(t)for(var e=t.length,n=0;n<e;n++)t[n].call(this)},t.prototype._abortedCallback=function(){this._setTracksFinished();var t=this.animation,e=this._abortedList;if(t&&t.removeClip(this._clip),this._clip=null,e)for(var n=0;n<e.length;n++)e[n].call(this)},t.prototype._setTracksFinished=function(){for(var t=this._tracks,e=this._trackKeys,n=0;n<e.length;n++)t[e[n]].setFinished()},t.prototype._getAdditiveTrack=function(t){var e,n=this._additiveAnimators;if(n)for(var i=0;i<n.length;i++){var r=n[i].getTrack(t);r&&(e=r)}return e},t.prototype.start=function(t,e){if(!(this._started>0)){this._started=1;for(var n=this,i=[],r=0;r<this._trackKeys.length;r++){var o=this._trackKeys[r],a=this._tracks[o],s=this._getAdditiveTrack(o),l=a.keyframes;if(a.prepare(s),a.needsAnimate())i.push(a);else if(!a.interpolable){var u=l[l.length-1];u&&(n._target[a.propName]=u.value)}}if(i.length||e){var h=new Oe({life:this._maxTime,loop:this._loop,delay:this._delay,onframe:function(t){n._started=2;var e=n._additiveAnimators;if(e){for(var r=!1,o=0;o<e.length;o++)if(e[o]._clip){r=!0;break}r||(n._additiveAnimators=null)}for(o=0;o<i.length;o++)i[o].step(n._target,t);var a=n._onframeList;if(a)for(o=0;o<a.length;o++)a[o](n._target,t)},ondestroy:function(){n._doneCallback()}});this._clip=h,this.animation&&this.animation.addClip(h),t&&"spline"!==t&&(h.easing=t)}else this._doneCallback();return this}},t.prototype.stop=function(t){if(this._clip){var e=this._clip;t&&e.onframe(1),this._abortedCallback()}},t.prototype.delay=function(t){return this._delay=t,this},t.prototype.during=function(t){return t&&(this._onframeList||(this._onframeList=[]),this._onframeList.push(t)),this},t.prototype.done=function(t){return t&&(this._doneList||(this._doneList=[]),this._doneList.push(t)),this},t.prototype.aborted=function(t){return t&&(this._abortedList||(this._abortedList=[]),this._abortedList.push(t)),this},t.prototype.getClip=function(){return this._clip},t.prototype.getTrack=function(t){return this._tracks[t]},t.prototype.stopTracks=function(t,e){if(!t.length||!this._clip)return!0;for(var n=this._tracks,i=this._trackKeys,r=0;r<t.length;r++){var o=n[t[r]];o&&(e?o.step(this._target,1):1===this._started&&o.step(this._target,0),o.setFinished())}var a=!0;for(r=0;r<i.length;r++)if(!n[i[r]].isFinished()){a=!1;break}return a&&this._abortedCallback(),a},t.prototype.saveFinalToTarget=function(t,e){if(t){e=e||this._trackKeys;for(var n=0;n<e.length;n++){var i=e[n],r=this._tracks[i];if(r&&!r.isFinished()){var o=r.keyframes,a=o[o.length-1];if(a){var s=mn(a.value);r.isValueColor&&(s=_n(s)),t[i]=s}}}}},t.prototype.__changeFinalValue=function(t,e){e=e||z(t);for(var n=0;n<e.length;n++){var i=e[n],r=this._tracks[i];if(r){var o=r.keyframes;if(o.length>1){var a=o.pop();r.addKeyframe(a.time,t[i]),r.prepare(r.getAdditiveTrack())}}}},t}(),In=function(){function t(t,e){this.x=t||0,this.y=e||0}return t.prototype.copy=function(t){return this.x=t.x,this.y=t.y,this},t.prototype.clone=function(){return new t(this.x,this.y)},t.prototype.set=function(t,e){return this.x=t,this.y=e,this},t.prototype.equal=function(t){return t.x===this.x&&t.y===this.y},t.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},t.prototype.scale=function(t){this.x*=t,this.y*=t},t.prototype.scaleAndAdd=function(t,e){this.x+=t.x*e,this.y+=t.y*e},t.prototype.sub=function(t){return this.x-=t.x,this.y-=t.y,this},t.prototype.dot=function(t){return this.x*t.x+this.y*t.y},t.prototype.len=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},t.prototype.lenSquare=function(){return this.x*this.x+this.y*this.y},t.prototype.normalize=function(){var t=this.len();return this.x/=t,this.y/=t,this},t.prototype.distance=function(t){var e=this.x-t.x,n=this.y-t.y;return Math.sqrt(e*e+n*n)},t.prototype.distanceSquare=function(t){var e=this.x-t.x,n=this.y-t.y;return e*e+n*n},t.prototype.negate=function(){return this.x=-this.x,this.y=-this.y,this},t.prototype.transform=function(t){if(t){var e=this.x,n=this.y;return this.x=t[0]*e+t[2]*n+t[4],this.y=t[1]*e+t[3]*n+t[5],this}},t.prototype.toArray=function(t){return t[0]=this.x,t[1]=this.y,t},t.prototype.fromArray=function(t){this.x=t[0],this.y=t[1]},t.set=function(t,e,n){t.x=e,t.y=n},t.copy=function(t,e){t.x=e.x,t.y=e.y},t.len=function(t){return Math.sqrt(t.x*t.x+t.y*t.y)},t.lenSquare=function(t){return t.x*t.x+t.y*t.y},t.dot=function(t,e){return t.x*e.x+t.y*e.y},t.add=function(t,e,n){t.x=e.x+n.x,t.y=e.y+n.y},t.sub=function(t,e,n){t.x=e.x-n.x,t.y=e.y-n.y},t.scale=function(t,e,n){t.x=e.x*n,t.y=e.y*n},t.scaleAndAdd=function(t,e,n,i){t.x=e.x+n.x*i,t.y=e.y+n.y*i},t.lerp=function(t,e,n,i){var r=1-i;t.x=r*e.x+i*n.x,t.y=r*e.y+i*n.y},t}(),Tn=Math.min,Cn=Math.max,An=new In,Dn=new In,Ln=new In,kn=new In,Pn=new In,On=new In,Rn=function(){function t(t,e,n,i){n<0&&isFinite(n)&&(t+=n,n=-n),i<0&&isFinite(i)&&(e+=i,i=-i),this.x=t,this.y=e,this.width=n,this.height=i}return t.prototype.union=function(t){var e=Tn(t.x,this.x),n=Tn(t.y,this.y);isFinite(this.x)&&isFinite(this.width)?this.width=Cn(t.x+t.width,this.x+this.width)-e:this.width=t.width,isFinite(this.y)&&isFinite(this.height)?this.height=Cn(t.y+t.height,this.y+this.height)-n:this.height=t.height,this.x=e,this.y=n},t.prototype.applyTransform=function(e){t.applyTransform(this,this,e)},t.prototype.calculateTransform=function(t){var e=this,n=t.width/e.width,i=t.height/e.height,r=[1,0,0,1,0,0];return me(r,r,[-e.x,-e.y]),xe(r,r,[n,i]),me(r,r,[t.x,t.y]),r},t.prototype.intersect=function(e,n){if(!e)return!1;e instanceof t||(e=t.create(e));var i=this,r=i.x,o=i.x+i.width,a=i.y,s=i.y+i.height,l=e.x,u=e.x+e.width,h=e.y,c=e.y+e.height,p=!(o<l||u<r||s<h||c<a);if(n){var d=1/0,f=0,g=Math.abs(o-l),y=Math.abs(u-r),v=Math.abs(s-h),m=Math.abs(c-a),_=Math.min(g,y),x=Math.min(v,m);o<l||u<r?_>f&&(f=_,g<y?In.set(On,-g,0):In.set(On,y,0)):_<d&&(d=_,g<y?In.set(Pn,g,0):In.set(Pn,-y,0)),s<h||c<a?x>f&&(f=x,v<m?In.set(On,0,-v):In.set(On,0,m)):_<d&&(d=_,v<m?In.set(Pn,0,v):In.set(Pn,0,-m))}return n&&In.copy(n,p?Pn:On),p},t.prototype.contain=function(t,e){var n=this;return t>=n.x&&t<=n.x+n.width&&e>=n.y&&e<=n.y+n.height},t.prototype.clone=function(){return new t(this.x,this.y,this.width,this.height)},t.prototype.copy=function(e){t.copy(this,e)},t.prototype.plain=function(){return{x:this.x,y:this.y,width:this.width,height:this.height}},t.prototype.isFinite=function(){return isFinite(this.x)&&isFinite(this.y)&&isFinite(this.width)&&isFinite(this.height)},t.prototype.isZero=function(){return 0===this.width||0===this.height},t.create=function(e){return new t(e.x,e.y,e.width,e.height)},t.copy=function(t,e){t.x=e.x,t.y=e.y,t.width=e.width,t.height=e.height},t.applyTransform=function(e,n,i){if(i){if(i[1]<1e-5&&i[1]>-1e-5&&i[2]<1e-5&&i[2]>-1e-5){var r=i[0],o=i[3],a=i[4],s=i[5];return e.x=n.x*r+a,e.y=n.y*o+s,e.width=n.width*r,e.height=n.height*o,e.width<0&&(e.x+=e.width,e.width=-e.width),void(e.height<0&&(e.y+=e.height,e.height=-e.height))}An.x=Ln.x=n.x,An.y=kn.y=n.y,Dn.x=kn.x=n.x+n.width,Dn.y=Ln.y=n.y+n.height,An.transform(i),kn.transform(i),Dn.transform(i),Ln.transform(i),e.x=Tn(An.x,Dn.x,Ln.x,kn.x),e.y=Tn(An.y,Dn.y,Ln.y,kn.y);var l=Cn(An.x,Dn.x,Ln.x,kn.x),u=Cn(An.y,Dn.y,Ln.y,kn.y);e.width=l-e.x,e.height=u-e.y}else e!==n&&t.copy(e,n)},t}(),Nn={},En="12px sans-serif";var zn={measureText:function(t,e){return xn||(xn=C().getContext("2d")),bn!==e&&(bn=xn.font=e||En),xn.measureText(t)}};function Bn(t,e){var n=Nn[e=e||En];n||(n=Nn[e]=new Ee(500));var i=n.get(t);return null==i&&(i=zn.measureText(t,e).width,n.put(t,i)),i}function Vn(t,e,n,i){var r=Bn(t,e),o=Wn(e),a=Gn(0,r,n),s=Hn(0,o,i);return new Rn(a,s,r,o)}function Fn(t,e,n,i){var r=((t||"")+"").split("\n");if(1===r.length)return Vn(r[0],e,n,i);for(var o=new Rn(0,0,0,0),a=0;a<r.length;a++){var s=Vn(r[a],e,n,i);0===a?o.copy(s):o.union(s)}return o}function Gn(t,e,n){return"right"===n?t-=e:"center"===n&&(t-=e/2),t}function Hn(t,e,n){return"middle"===n?t-=e/2:"bottom"===n&&(t-=e),t}function Wn(t){return Bn("国",t)}function Yn(t,e){return"string"==typeof t?t.lastIndexOf("%")>=0?parseFloat(t)/100*e:parseFloat(t):t}function Xn(t,e,n){var i=e.position||"inside",r=null!=e.distance?e.distance:5,o=n.height,a=n.width,s=o/2,l=n.x,u=n.y,h="left",c="top";if(i instanceof Array)l+=Yn(i[0],n.width),u+=Yn(i[1],n.height),h=null,c=null;else switch(i){case"left":l-=r,u+=s,h="right",c="middle";break;case"right":l+=r+a,u+=s,c="middle";break;case"top":l+=a/2,u-=r,h="center",c="bottom";break;case"bottom":l+=a/2,u+=o+r,h="center";break;case"inside":l+=a/2,u+=s,h="center",c="middle";break;case"insideLeft":l+=r,u+=s,c="middle";break;case"insideRight":l+=a-r,u+=s,h="right",c="middle";break;case"insideTop":l+=a/2,u+=r,h="center";break;case"insideBottom":l+=a/2,u+=o-r,h="center",c="bottom";break;case"insideTopLeft":l+=r,u+=r;break;case"insideTopRight":l+=a-r,u+=r,h="right";break;case"insideBottomLeft":l+=r,u+=o-r,c="bottom";break;case"insideBottomRight":l+=a-r,u+=o-r,h="right",c="bottom"}return(t=t||{}).x=l,t.y=u,t.align=h,t.verticalAlign=c,t}var Un=1;"undefined"!=typeof window&&(Un=Math.max(window.devicePixelRatio||window.screen&&window.screen.deviceXDPI/window.screen.logicalXDPI||1,1));var Zn=Un,jn="#333",qn="#ccc",Kn="__zr_normal__",$n=["x","y","scaleX","scaleY","originX","originY","rotation","ignore"],Jn={x:!0,y:!0,scaleX:!0,scaleY:!0,originX:!0,originY:!0,rotation:!0,ignore:!1},Qn={},ti=new Rn(0,0,0,0),ei=function(){function t(t){this.id=x(),this.animators=[],this.currentStates=[],this.states={},this._init(t)}return t.prototype._init=function(t){this.attr(t)},t.prototype.drift=function(t,e,n){switch(this.draggable){case"horizontal":e=0;break;case"vertical":t=0}var i=this.transform;i||(i=this.transform=[1,0,0,1,0,0]),i[4]+=t,i[5]+=e,this.decomposeTransform(),this.markRedraw()},t.prototype.beforeUpdate=function(){},t.prototype.afterUpdate=function(){},t.prototype.update=function(){this.updateTransform(),this.__dirty&&this.updateInnerText()},t.prototype.updateInnerText=function(t){var e=this._textContent;if(e&&(!e.ignore||t)){this.textConfig||(this.textConfig={});var n=this.textConfig,i=n.local,r=e.attachedTransform,o=void 0,a=void 0,s=!1;r.parent=i?this:null;var l=!1;if(r.x=e.x,r.y=e.y,r.originX=e.originX,r.originY=e.originY,r.rotation=e.rotation,r.scaleX=e.scaleX,r.scaleY=e.scaleY,null!=n.position){var u=ti;n.layoutRect?u.copy(n.layoutRect):u.copy(this.getBoundingRect()),i||u.applyTransform(this.transform),this.calculateTextPosition?this.calculateTextPosition(Qn,n,u):Xn(Qn,n,u),r.x=Qn.x,r.y=Qn.y,o=Qn.align,a=Qn.verticalAlign;var h=n.origin;if(h&&null!=n.rotation){var c=void 0,p=void 0;"center"===h?(c=.5*u.width,p=.5*u.height):(c=Yn(h[0],u.width),p=Yn(h[1],u.height)),l=!0,r.originX=-r.x+c+(i?0:u.x),r.originY=-r.y+p+(i?0:u.y)}}null!=n.rotation&&(r.rotation=n.rotation);var d=n.offset;d&&(r.x+=d[0],r.y+=d[1],l||(r.originX=-d[0],r.originY=-d[1]));var f=null==n.inside?"string"==typeof n.position&&n.position.indexOf("inside")>=0:n.inside,g=this._innerTextDefaultStyle||(this._innerTextDefaultStyle={}),y=void 0,v=void 0,m=void 0;f&&this.canBeInsideText()?(y=n.insideFill,v=n.insideStroke,null!=y&&"auto"!==y||(y=this.getInsideTextFill()),null!=v&&"auto"!==v||(v=this.getInsideTextStroke(y),m=!0)):(y=n.outsideFill,v=n.outsideStroke,null!=y&&"auto"!==y||(y=this.getOutsideFill()),null!=v&&"auto"!==v||(v=this.getOutsideStroke(y),m=!0)),(y=y||"#000")===g.fill&&v===g.stroke&&m===g.autoStroke&&o===g.align&&a===g.verticalAlign||(s=!0,g.fill=y,g.stroke=v,g.autoStroke=m,g.align=o,g.verticalAlign=a,e.setDefaultTextStyle(g)),s&&e.dirtyStyle(),e.markRedraw()}},t.prototype.canBeInsideText=function(){return!0},t.prototype.getInsideTextFill=function(){return"#fff"},t.prototype.getInsideTextStroke=function(t){return"#000"},t.prototype.getOutsideFill=function(){return this.__zr&&this.__zr.isDarkMode()?qn:jn},t.prototype.getOutsideStroke=function(t){var e=this.__zr&&this.__zr.getBackgroundColor(),n="string"==typeof e&&qe(e);n||(n=[255,255,255,1]);for(var i=n[3],r=this.__zr.isDarkMode(),o=0;o<3;o++)n[o]=n[o]*i+(r?0:255)*(1-i);return n[3]=1,an(n,"rgba")},t.prototype.traverse=function(t,e){},t.prototype.attrKV=function(t,e){"textConfig"===t?this.setTextConfig(e):"textContent"===t?this.setTextContent(e):"clipPath"===t?this.setClipPath(e):"extra"===t?(this.extra=this.extra||{},I(this.extra,e)):this[t]=e},t.prototype.hide=function(){this.ignore=!0,this.markRedraw()},t.prototype.show=function(){this.ignore=!1,this.markRedraw()},t.prototype.attr=function(t,e){if("string"==typeof t)this.attrKV(t,e);else if(X(t))for(var n=z(t),i=0;i<n.length;i++){var r=n[i];this.attrKV(r,t[r])}return this.markRedraw(),this},t.prototype.saveCurrentToNormalState=function(t){this._innerSaveToNormal(t);for(var e=this._normalState,n=0;n<this.animators.length;n++){var i=this.animators[n],r=i.__fromStateTransition;if(!r||r===Kn){var o=i.targetName,a=o?e[o]:e;i.saveFinalToTarget(a)}}},t.prototype._innerSaveToNormal=function(t){var e=this._normalState;e||(e=this._normalState={}),t.textConfig&&!e.textConfig&&(e.textConfig=this.textConfig),this._savePrimaryToNormal(t,e,$n)},t.prototype._savePrimaryToNormal=function(t,e,n){for(var i=0;i<n.length;i++){var r=n[i];null==t[r]||r in e||(e[r]=this[r])}},t.prototype.hasState=function(){return this.currentStates.length>0},t.prototype.getState=function(t){return this.states[t]},t.prototype.ensureState=function(t){var e=this.states;return e[t]||(e[t]={}),e[t]},t.prototype.clearStates=function(t){this.useState(Kn,!1,t)},t.prototype.useState=function(e,n,i){var r=e===Kn;if(this.hasState()||!r){var o=this.currentStates,a=this.stateTransition;if(!(A(o,e)>=0)||!n&&1!==o.length){var s;if(this.stateProxy&&!r&&(s=this.stateProxy(e)),s||(s=this.states&&this.states[e]),s||r){r||this.saveCurrentToNormalState(s);var l=!(!s||!s.hoverLayer);return l&&this._toggleHoverLayerFlag(!0),this._applyStateObj(e,s,this._normalState,n,!i&&!this.__inHover&&a&&a.duration>0,a),this._textContent&&this._textContent.useState(e,n),this._textGuide&&this._textGuide.useState(e,n),r?(this.currentStates=[],this._normalState={}):n?this.currentStates.push(e):this.currentStates=[e],this._updateAnimationTargets(),this.markRedraw(),!l&&this.__inHover&&(this._toggleHoverLayerFlag(!1),this.__dirty&=~t.REDARAW_BIT),s}b("State "+e+" not exists.")}}},t.prototype.useStates=function(e,n){if(e.length){var i=[],r=this.currentStates,o=e.length,a=o===r.length;if(a)for(var s=0;s<o;s++)if(e[s]!==r[s]){a=!1;break}if(a)return;for(s=0;s<o;s++){var l=e[s],u=void 0;this.stateProxy&&(u=this.stateProxy(l,e)),u||(u=this.states[l]),u&&i.push(u)}var h=!(!i[o-1]||!i[o-1].hoverLayer);h&&this._toggleHoverLayerFlag(!0);var c=this._mergeStates(i),p=this.stateTransition;this.saveCurrentToNormalState(c),this._applyStateObj(e.join(","),c,this._normalState,!1,!n&&!this.__inHover&&p&&p.duration>0,p),this._textContent&&this._textContent.useStates(e),this._textGuide&&this._textGuide.useStates(e),this._updateAnimationTargets(),this.currentStates=e.slice(),this.markRedraw(),!h&&this.__inHover&&(this._toggleHoverLayerFlag(!1),this.__dirty&=~t.REDARAW_BIT)}else this.clearStates()},t.prototype._updateAnimationTargets=function(){for(var t=0;t<this.animators.length;t++){var e=this.animators[t];e.targetName&&e.changeTarget(this[e.targetName])}},t.prototype.removeState=function(t){var e=A(this.currentStates,t);if(e>=0){var n=this.currentStates.slice();n.splice(e,1),this.useStates(n)}},t.prototype.replaceState=function(t,e,n){var i=this.currentStates.slice(),r=A(i,t),o=A(i,e)>=0;r>=0?o?i.splice(r,1):i[r]=e:n&&!o&&i.push(e),this.useStates(i)},t.prototype.toggleState=function(t,e){e?this.useState(t,!0):this.removeState(t)},t.prototype._mergeStates=function(t){for(var e,n={},i=0;i<t.length;i++){var r=t[i];I(n,r),r.textConfig&&I(e=e||{},r.textConfig)}return e&&(n.textConfig=e),n},t.prototype._applyStateObj=function(t,e,n,i,r,o){var a=!(e&&i);e&&e.textConfig?(this.textConfig=I({},i?this.textConfig:n.textConfig),I(this.textConfig,e.textConfig)):a&&n.textConfig&&(this.textConfig=n.textConfig);for(var s={},l=!1,u=0;u<$n.length;u++){var h=$n[u],c=r&&Jn[h];e&&null!=e[h]?c?(l=!0,s[h]=e[h]):this[h]=e[h]:a&&null!=n[h]&&(c?(l=!0,s[h]=n[h]):this[h]=n[h])}if(!r)for(u=0;u<this.animators.length;u++){var p=this.animators[u],d=p.targetName;p.__changeFinalValue(d?(e||n)[d]:e||n)}l&&this._transitionState(t,s,o)},t.prototype._attachComponent=function(t){if(t.__zr&&!t.__hostTarget)throw new Error("Text element has been added to zrender.");if(t===this)throw new Error("Recursive component attachment.");var e=this.__zr;e&&t.addSelfToZr(e),t.__zr=e,t.__hostTarget=this},t.prototype._detachComponent=function(t){t.__zr&&t.removeSelfFromZr(t.__zr),t.__zr=null,t.__hostTarget=null},t.prototype.getClipPath=function(){return this._clipPath},t.prototype.setClipPath=function(t){this._clipPath&&this._clipPath!==t&&this.removeClipPath(),this._attachComponent(t),this._clipPath=t,this.markRedraw()},t.prototype.removeClipPath=function(){var t=this._clipPath;t&&(this._detachComponent(t),this._clipPath=null,this.markRedraw())},t.prototype.getTextContent=function(){return this._textContent},t.prototype.setTextContent=function(t){var e=this._textContent;if(e!==t){if(e&&e!==t&&this.removeTextContent(),t.__zr&&!t.__hostTarget)throw new Error("Text element has been added to zrender.");t.attachedTransform=new ke,this._attachComponent(t),this._textContent=t,this.markRedraw()}},t.prototype.setTextConfig=function(t){this.textConfig||(this.textConfig={}),I(this.textConfig,t),this.markRedraw()},t.prototype.removeTextContent=function(){var t=this._textContent;t&&(t.attachedTransform=null,this._detachComponent(t),this._textContent=null,this._innerTextDefaultStyle=null,this.markRedraw())},t.prototype.getTextGuideLine=function(){return this._textGuide},t.prototype.setTextGuideLine=function(t){this._textGuide&&this._textGuide!==t&&this.removeTextGuideLine(),this._attachComponent(t),this._textGuide=t,this.markRedraw()},t.prototype.removeTextGuideLine=function(){var t=this._textGuide;t&&(this._detachComponent(t),this._textGuide=null,this.markRedraw())},t.prototype.markRedraw=function(){this.__dirty|=t.REDARAW_BIT;var e=this.__zr;e&&(this.__inHover?e.refreshHover():e.refresh()),this.__hostTarget&&this.__hostTarget.markRedraw()},t.prototype.dirty=function(){this.markRedraw()},t.prototype._toggleHoverLayerFlag=function(t){this.__inHover=t;var e=this._textContent,n=this._textGuide;e&&(e.__inHover=t),n&&(n.__inHover=t)},t.prototype.addSelfToZr=function(t){this.__zr=t;var e=this.animators;if(e)for(var n=0;n<e.length;n++)t.animation.addAnimator(e[n]);this._clipPath&&this._clipPath.addSelfToZr(t),this._textContent&&this._textContent.addSelfToZr(t),this._textGuide&&this._textGuide.addSelfToZr(t)},t.prototype.removeSelfFromZr=function(t){this.__zr=null;var e=this.animators;if(e)for(var n=0;n<e.length;n++)t.animation.removeAnimator(e[n]);this._clipPath&&this._clipPath.removeSelfFromZr(t),this._textContent&&this._textContent.removeSelfFromZr(t),this._textGuide&&this._textGuide.removeSelfFromZr(t)},t.prototype.animate=function(t,e){var n=t?this[t]:this;if(n){var i=new Mn(n,e);return this.addAnimator(i,t),i}b('Property "'+t+'" is not existed in element '+this.id)},t.prototype.addAnimator=function(t,e){var n=this.__zr,i=this;t.during((function(){i.updateDuringAnimation(e)})).done((function(){var e=i.animators,n=A(e,t);n>=0&&e.splice(n,1)})),this.animators.push(t),n&&n.animation.addAnimator(t),n&&n.wakeUp()},t.prototype.updateDuringAnimation=function(t){this.markRedraw()},t.prototype.stopAnimation=function(t,e){for(var n=this.animators,i=n.length,r=[],o=0;o<i;o++){var a=n[o];t&&t!==a.scope?r.push(a):a.stop(e)}return this.animators=r,this},t.prototype.animateTo=function(t,e,n){ni(this,t,e,n)},t.prototype.animateFrom=function(t,e,n){ni(this,t,e,n,!0)},t.prototype._transitionState=function(t,e,n,i){for(var r=ni(this,e,n,i),o=0;o<r.length;o++)r[o].__fromStateTransition=t},t.prototype.getBoundingRect=function(){return null},t.prototype.getPaintRect=function(){return null},t.REDARAW_BIT=1,t.initDefaultProps=function(){var e=t.prototype;e.type="element",e.name="",e.ignore=!1,e.silent=!1,e.isGroup=!1,e.draggable=!1,e.dragging=!1,e.ignoreClip=!1,e.__inHover=!1,e.__dirty=t.REDARAW_BIT;var n={};function i(t,e,i){n[t+e+i]||(console.warn("DEPRECATED: '"+t+"' has been deprecated. use '"+e+"', '"+i+"' instead"),n[t+e+i]=!0)}function r(t,n,r,o){function a(t,e){Object.defineProperty(e,0,{get:function(){return t[r]},set:function(e){t[r]=e}}),Object.defineProperty(e,1,{get:function(){return t[o]},set:function(e){t[o]=e}})}Object.defineProperty(e,t,{get:function(){(i(t,r,o),this[n])||a(this,this[n]=[]);return this[n]},set:function(e){i(t,r,o),this[r]=e[0],this[o]=e[1],this[n]=e,a(this,e)}})}Object.defineProperty&&(!a.browser.ie||a.browser.version>8)&&(r("position","_legacyPos","x","y"),r("scale","_legacyScale","scaleX","scaleY"),r("origin","_legacyOrigin","originX","originY"))}(),t}();function ni(t,e,n,i,r){var o=[];oi(t,"",t,e,n=n||{},i,o,r);var a=o.length,s=!1,l=n.done,u=n.aborted,h=function(){s=!0,--a<=0&&(s?l&&l():u&&u())},c=function(){--a<=0&&(s?l&&l():u&&u())};a||l&&l(),o.length>0&&n.during&&o[0].during((function(t,e){n.during(e)}));for(var p=0;p<o.length;p++){var d=o[p];h&&d.done(h),c&&d.aborted(c),d.start(n.easing,n.force)}return o}function ii(t,e,n){for(var i=0;i<n;i++)t[i]=e[i]}function ri(t,e,n){if(k(e[n]))if(k(t[n])||(t[n]=[]),Z(e[n])){var i=e[n].length;t[n].length!==i&&(t[n]=new e[n].constructor(i),ii(t[n],e[n],i))}else{var r=e[n],o=t[n],a=r.length;if(k(r[0]))for(var s=r[0].length,l=0;l<a;l++)o[l]?ii(o[l],r[l],s):o[l]=Array.prototype.slice.call(r[l]);else ii(o,r,a);o.length=r.length}else t[n]=e[n]}function oi(t,e,n,i,r,o,a,s){for(var l=[],u=[],h=z(i),c=r.duration,p=r.delay,d=r.additive,f=r.setToFinal,g=!X(o),y=0;y<h.length;y++){if(null!=n[I=h[y]]&&null!=i[I]&&(g||o[I]))if(X(i[I])&&!k(i[I])){if(e){s||(n[I]=i[I],t.updateDuringAnimation(e));continue}oi(t,I,n[I],i[I],r,o&&o[I],a,s)}else l.push(I),u.push(I);else s||(n[I]=i[I],t.updateDuringAnimation(e),u.push(I))}var v=l.length;if(v>0||r.force&&!a.length){for(var m=t.animators,_=[],x=0;x<m.length;x++)m[x].targetName===e&&_.push(m[x]);if(!d&&_.length)for(x=0;x<_.length;x++){if(_[x].stopTracks(u)){var b=A(m,_[x]);m.splice(b,1)}}var w=void 0,S=void 0,M=void 0;if(s){S={},f&&(w={});for(x=0;x<v;x++){S[I=l[x]]=n[I],f?w[I]=i[I]:n[I]=i[I]}}else if(f){M={};for(x=0;x<v;x++){var I;M[I=l[x]]=mn(n[I]),ri(n,i,I)}}var T=new Mn(n,!1,d?_:null);T.targetName=e,r.scope&&(T.scope=r.scope),f&&w&&T.whenWithKeys(0,w,l),M&&T.whenWithKeys(0,M,l),T.whenWithKeys(null==c?500:c,s?S:i,l).delay(p||0),t.addAnimator(T,e),a.push(T)}}L(ei,Ft),L(ei,ke);function ai(t,e,n,i){var r=e+1;if(r===n)return 1;if(i(t[r++],t[e])<0){for(;r<n&&i(t[r],t[r-1])<0;)r++;!function(t,e,n){n--;for(;e<n;){var i=t[e];t[e++]=t[n],t[n--]=i}}(t,e,r)}else for(;r<n&&i(t[r],t[r-1])>=0;)r++;return r-e}function si(t,e,n,i,r){for(i===e&&i++;i<n;i++){for(var o,a=t[i],s=e,l=i;s<l;)r(a,t[o=s+l>>>1])<0?l=o:s=o+1;var u=i-s;switch(u){case 3:t[s+3]=t[s+2];case 2:t[s+2]=t[s+1];case 1:t[s+1]=t[s];break;default:for(;u>0;)t[s+u]=t[s+u-1],u--}t[s]=a}}function li(t,e,n,i,r,o){var a=0,s=0,l=1;if(o(t,e[n+r])>0){for(s=i-r;l<s&&o(t,e[n+r+l])>0;)a=l,(l=1+(l<<1))<=0&&(l=s);l>s&&(l=s),a+=r,l+=r}else{for(s=r+1;l<s&&o(t,e[n+r-l])<=0;)a=l,(l=1+(l<<1))<=0&&(l=s);l>s&&(l=s);var u=a;a=r-l,l=r-u}for(a++;a<l;){var h=a+(l-a>>>1);o(t,e[n+h])>0?a=h+1:l=h}return l}function ui(t,e,n,i,r,o){var a=0,s=0,l=1;if(o(t,e[n+r])<0){for(s=r+1;l<s&&o(t,e[n+r-l])<0;)a=l,(l=1+(l<<1))<=0&&(l=s);l>s&&(l=s);var u=a;a=r-l,l=r-u}else{for(s=i-r;l<s&&o(t,e[n+r+l])>=0;)a=l,(l=1+(l<<1))<=0&&(l=s);l>s&&(l=s),a+=r,l+=r}for(a++;a<l;){var h=a+(l-a>>>1);o(t,e[n+h])<0?l=h:a=h+1}return l}function hi(t,e){var n,i,r=7,o=0;t.length;var a=[];function s(s){var l=n[s],u=i[s],h=n[s+1],c=i[s+1];i[s]=u+c,s===o-3&&(n[s+1]=n[s+2],i[s+1]=i[s+2]),o--;var p=ui(t[h],t,l,u,0,e);l+=p,0!==(u-=p)&&0!==(c=li(t[l+u-1],t,h,c,c-1,e))&&(u<=c?function(n,i,o,s){var l=0;for(l=0;l<i;l++)a[l]=t[n+l];var u=0,h=o,c=n;if(t[c++]=t[h++],0==--s){for(l=0;l<i;l++)t[c+l]=a[u+l];return}if(1===i){for(l=0;l<s;l++)t[c+l]=t[h+l];return void(t[c+s]=a[u])}var p,d,f,g=r;for(;;){p=0,d=0,f=!1;do{if(e(t[h],a[u])<0){if(t[c++]=t[h++],d++,p=0,0==--s){f=!0;break}}else if(t[c++]=a[u++],p++,d=0,1==--i){f=!0;break}}while((p|d)<g);if(f)break;do{if(0!==(p=ui(t[h],a,u,i,0,e))){for(l=0;l<p;l++)t[c+l]=a[u+l];if(c+=p,u+=p,(i-=p)<=1){f=!0;break}}if(t[c++]=t[h++],0==--s){f=!0;break}if(0!==(d=li(a[u],t,h,s,0,e))){for(l=0;l<d;l++)t[c+l]=t[h+l];if(c+=d,h+=d,0===(s-=d)){f=!0;break}}if(t[c++]=a[u++],1==--i){f=!0;break}g--}while(p>=7||d>=7);if(f)break;g<0&&(g=0),g+=2}if((r=g)<1&&(r=1),1===i){for(l=0;l<s;l++)t[c+l]=t[h+l];t[c+s]=a[u]}else{if(0===i)throw new Error;for(l=0;l<i;l++)t[c+l]=a[u+l]}}(l,u,h,c):function(n,i,o,s){var l=0;for(l=0;l<s;l++)a[l]=t[o+l];var u=n+i-1,h=s-1,c=o+s-1,p=0,d=0;if(t[c--]=t[u--],0==--i){for(p=c-(s-1),l=0;l<s;l++)t[p+l]=a[l];return}if(1===s){for(d=(c-=i)+1,p=(u-=i)+1,l=i-1;l>=0;l--)t[d+l]=t[p+l];return void(t[c]=a[h])}var f=r;for(;;){var g=0,y=0,v=!1;do{if(e(a[h],t[u])<0){if(t[c--]=t[u--],g++,y=0,0==--i){v=!0;break}}else if(t[c--]=a[h--],y++,g=0,1==--s){v=!0;break}}while((g|y)<f);if(v)break;do{if(0!==(g=i-ui(a[h],t,n,i,i-1,e))){for(i-=g,d=(c-=g)+1,p=(u-=g)+1,l=g-1;l>=0;l--)t[d+l]=t[p+l];if(0===i){v=!0;break}}if(t[c--]=a[h--],1==--s){v=!0;break}if(0!==(y=s-li(t[u],a,0,s,s-1,e))){for(s-=y,d=(c-=y)+1,p=(h-=y)+1,l=0;l<y;l++)t[d+l]=a[p+l];if(s<=1){v=!0;break}}if(t[c--]=t[u--],0==--i){v=!0;break}f--}while(g>=7||y>=7);if(v)break;f<0&&(f=0),f+=2}(r=f)<1&&(r=1);if(1===s){for(d=(c-=i)+1,p=(u-=i)+1,l=i-1;l>=0;l--)t[d+l]=t[p+l];t[c]=a[h]}else{if(0===s)throw new Error;for(p=c-(s-1),l=0;l<s;l++)t[p+l]=a[l]}}(l,u,h,c))}return n=[],i=[],{mergeRuns:function(){for(;o>1;){var t=o-2;if(t>=1&&i[t-1]<=i[t]+i[t+1]||t>=2&&i[t-2]<=i[t]+i[t-1])i[t-1]<i[t+1]&&t--;else if(i[t]>i[t+1])break;s(t)}},forceMergeRuns:function(){for(;o>1;){var t=o-2;t>0&&i[t-1]<i[t+1]&&t--,s(t)}},pushRun:function(t,e){n[o]=t,i[o]=e,o+=1}}}function ci(t,e,n,i){n||(n=0),i||(i=t.length);var r=i-n;if(!(r<2)){var o=0;if(r<32)si(t,n,i,n+(o=ai(t,n,i,e)),e);else{var a=hi(t,e),s=function(t){for(var e=0;t>=32;)e|=1&t,t>>=1;return t+e}(r);do{if((o=ai(t,n,i,e))<s){var l=r;l>s&&(l=s),si(t,n,n+l,n+o,e),o=l}a.pushRun(n,o),a.mergeRuns(),r-=o,n+=o}while(0!==r);a.forceMergeRuns()}}}var pi=!1;function di(){pi||(pi=!0,console.warn("z / z2 / zlevel of displayable is invalid, which may cause unexpected errors"))}function fi(t,e){return t.zlevel===e.zlevel?t.z===e.z?t.z2-e.z2:t.z-e.z:t.zlevel-e.zlevel}var gi,yi,vi=function(){function t(){this._roots=[],this._displayList=[],this._displayListLen=0,this.displayableSortFunc=fi}return t.prototype.traverse=function(t,e){for(var n=0;n<this._roots.length;n++)this._roots[n].traverse(t,e)},t.prototype.getDisplayList=function(t,e){e=e||!1;var n=this._displayList;return!t&&n.length||this.updateDisplayList(e),n},t.prototype.updateDisplayList=function(t){this._displayListLen=0;for(var e=this._roots,n=this._displayList,i=0,r=e.length;i<r;i++)this._updateAndAddDisplayable(e[i],null,t);n.length=this._displayListLen,a.canvasSupported&&ci(n,fi)},t.prototype._updateAndAddDisplayable=function(t,e,n){if(!t.ignore||n){t.beforeUpdate(),t.update(),t.afterUpdate();var i=t.getClipPath();if(t.ignoreClip)e=null;else if(i){e=e?e.slice():[];for(var r=i,o=t;r;)r.parent=o,r.updateTransform(),e.push(r),o=r,r=r.getClipPath()}if(t.childrenRef){for(var a=t.childrenRef(),s=0;s<a.length;s++){var l=a[s];t.__dirty&&(l.__dirty|=ei.REDARAW_BIT),this._updateAndAddDisplayable(l,e,n)}t.__dirty=0}else{var u=t;e&&e.length?u.__clipPaths=e:u.__clipPaths&&u.__clipPaths.length>0&&(u.__clipPaths=[]),isNaN(u.z)&&(di(),u.z=0),isNaN(u.z2)&&(di(),u.z2=0),isNaN(u.zlevel)&&(di(),u.zlevel=0),this._displayList[this._displayListLen++]=u}var h=t.getDecalElement&&t.getDecalElement();h&&this._updateAndAddDisplayable(h,e,n);var c=t.getTextGuideLine();c&&this._updateAndAddDisplayable(c,e,n);var p=t.getTextContent();p&&this._updateAndAddDisplayable(p,e,n)}},t.prototype.addRoot=function(t){t.__zr&&t.__zr.storage===this||this._roots.push(t)},t.prototype.delRoot=function(t){if(t instanceof Array)for(var e=0,n=t.length;e<n;e++)this.delRoot(t[e]);else{var i=A(this._roots,t);i>=0&&this._roots.splice(i,1)}},t.prototype.delAllRoots=function(){this._roots=[],this._displayList=[],this._displayListLen=0},t.prototype.getRoots=function(){return this._roots},t.prototype.dispose=function(){this._displayList=null,this._roots=null},t}(),mi="undefined"!=typeof window&&(window.requestAnimationFrame&&window.requestAnimationFrame.bind(window)||window.msRequestAnimationFrame&&window.msRequestAnimationFrame.bind(window)||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame)||function(t){return setTimeout(t,16)},_i=function(t){function e(e){var n=t.call(this)||this;return n._running=!1,n._time=0,n._pausedTime=0,n._pauseStart=0,n._paused=!1,e=e||{},n.stage=e.stage||{},n.onframe=e.onframe||function(){},n}return n(e,t),e.prototype.addClip=function(t){t.animation&&this.removeClip(t),this._clipsHead?(this._clipsTail.next=t,t.prev=this._clipsTail,t.next=null,this._clipsTail=t):this._clipsHead=this._clipsTail=t,t.animation=this},e.prototype.addAnimator=function(t){t.animation=this;var e=t.getClip();e&&this.addClip(e)},e.prototype.removeClip=function(t){if(t.animation){var e=t.prev,n=t.next;e?e.next=n:this._clipsHead=n,n?n.prev=e:this._clipsTail=e,t.next=t.prev=t.animation=null}},e.prototype.removeAnimator=function(t){var e=t.getClip();e&&this.removeClip(e),t.animation=null},e.prototype.update=function(t){for(var e=(new Date).getTime()-this._pausedTime,n=e-this._time,i=this._clipsHead;i;){var r=i.next;i.step(e,n)?(i.ondestroy&&i.ondestroy(),this.removeClip(i),i=r):i=r}this._time=e,t||(this.onframe(n),this.trigger("frame",n),this.stage.update&&this.stage.update())},e.prototype._startLoop=function(){var t=this;this._running=!0,mi((function e(){t._running&&(mi(e),!t._paused&&t.update())}))},e.prototype.start=function(){this._running||(this._time=(new Date).getTime(),this._pausedTime=0,this._startLoop())},e.prototype.stop=function(){this._running=!1},e.prototype.pause=function(){this._paused||(this._pauseStart=(new Date).getTime(),this._paused=!0)},e.prototype.resume=function(){this._paused&&(this._pausedTime+=(new Date).getTime()-this._pauseStart,this._paused=!1)},e.prototype.clear=function(){for(var t=this._clipsHead;t;){var e=t.next;t.prev=t.next=t.animation=null,t=e}this._clipsHead=this._clipsTail=null},e.prototype.isFinished=function(){return null==this._clipsHead},e.prototype.animate=function(t,e){e=e||{},this.start();var n=new Mn(t,e.loop);return this.addAnimator(n),n},e}(Ft),xi=a.domSupported,bi=(yi={pointerdown:1,pointerup:1,pointermove:1,pointerout:1},{mouse:gi=["click","dblclick","mousewheel","wheel","mouseout","mouseup","mousedown","mousemove","contextmenu"],touch:["touchstart","touchend","touchmove"],pointer:O(gi,(function(t){var e=t.replace("mouse","pointer");return yi.hasOwnProperty(e)?e:t}))}),wi=["mousemove","mouseup"],Si=["pointermove","pointerup"],Mi=!1;function Ii(t){var e=t.pointerType;return"pen"===e||"touch"===e}function Ti(t){t&&(t.zrByTouch=!0)}function Ci(t,e){for(var n=e,i=!1;n&&9!==n.nodeType&&!(i=n.domBelongToZr||n!==e&&n===t.painterRoot);)n=n.parentNode;return i}var Ai=function(t,e){this.stopPropagation=ft,this.stopImmediatePropagation=ft,this.preventDefault=ft,this.type=e.type,this.target=this.currentTarget=t.dom,this.pointerType=e.pointerType,this.clientX=e.clientX,this.clientY=e.clientY},Di={mousedown:function(t){t=Qt(this.dom,t),this.__mayPointerCapture=[t.zrX,t.zrY],this.trigger("mousedown",t)},mousemove:function(t){t=Qt(this.dom,t);var e=this.__mayPointerCapture;!e||t.zrX===e[0]&&t.zrY===e[1]||this.__togglePointerCapture(!0),this.trigger("mousemove",t)},mouseup:function(t){t=Qt(this.dom,t),this.__togglePointerCapture(!1),this.trigger("mouseup",t)},mouseout:function(t){Ci(this,(t=Qt(this.dom,t)).toElement||t.relatedTarget)||(this.__pointerCapturing&&(t.zrEventControl="no_globalout"),this.trigger("mouseout",t))},wheel:function(t){Mi=!0,t=Qt(this.dom,t),this.trigger("mousewheel",t)},mousewheel:function(t){Mi||(t=Qt(this.dom,t),this.trigger("mousewheel",t))},touchstart:function(t){Ti(t=Qt(this.dom,t)),this.__lastTouchMoment=new Date,this.handler.processGesture(t,"start"),Di.mousemove.call(this,t),Di.mousedown.call(this,t)},touchmove:function(t){Ti(t=Qt(this.dom,t)),this.handler.processGesture(t,"change"),Di.mousemove.call(this,t)},touchend:function(t){Ti(t=Qt(this.dom,t)),this.handler.processGesture(t,"end"),Di.mouseup.call(this,t),+new Date-+this.__lastTouchMoment<300&&Di.click.call(this,t)},pointerdown:function(t){Di.mousedown.call(this,t)},pointermove:function(t){Ii(t)||Di.mousemove.call(this,t)},pointerup:function(t){Di.mouseup.call(this,t)},pointerout:function(t){Ii(t)||Di.mouseout.call(this,t)}};P(["click","dblclick","contextmenu"],(function(t){Di[t]=function(e){e=Qt(this.dom,e),this.trigger(t,e)}}));var Li={pointermove:function(t){Ii(t)||Li.mousemove.call(this,t)},pointerup:function(t){Li.mouseup.call(this,t)},mousemove:function(t){this.trigger("mousemove",t)},mouseup:function(t){var e=this.__pointerCapturing;this.__togglePointerCapture(!1),this.trigger("mouseup",t),e&&(t.zrEventControl="only_globalout",this.trigger("mouseout",t))}};function ki(t,e){var n=e.domHandlers;a.pointerEventsSupported?P(bi.pointer,(function(i){Oi(e,i,(function(e){n[i].call(t,e)}))})):(a.touchEventsSupported&&P(bi.touch,(function(i){Oi(e,i,(function(r){n[i].call(t,r),function(t){t.touching=!0,null!=t.touchTimer&&(clearTimeout(t.touchTimer),t.touchTimer=null),t.touchTimer=setTimeout((function(){t.touching=!1,t.touchTimer=null}),700)}(e)}))})),P(bi.mouse,(function(i){Oi(e,i,(function(r){r=Jt(r),e.touching||n[i].call(t,r)}))})))}function Pi(t,e){function n(n){Oi(e,n,(function(i){i=Jt(i),Ci(t,i.target)||(i=function(t,e){return Qt(t.dom,new Ai(t,e),!0)}(t,i),e.domHandlers[n].call(t,i))}),{capture:!0})}a.pointerEventsSupported?P(Si,n):a.touchEventsSupported||P(wi,n)}function Oi(t,e,n,i){t.mounted[e]=n,t.listenerOpts[e]=i,te(t.domTarget,e,n,i)}function Ri(t){var e,n,i,r,o=t.mounted;for(var a in o)o.hasOwnProperty(a)&&(e=t.domTarget,n=a,i=o[a],r=t.listenerOpts[a],Zt?e.removeEventListener(n,i,r):e.detachEvent("on"+n,i));t.mounted={}}var Ni=function(t,e){this.mounted={},this.listenerOpts={},this.touching=!1,this.domTarget=t,this.domHandlers=e},Ei=function(t){function e(e,n){var i=t.call(this)||this;return i.__pointerCapturing=!1,i.dom=e,i.painterRoot=n,i._localHandlerScope=new Ni(e,Di),xi&&(i._globalHandlerScope=new Ni(document,Li)),ki(i,i._localHandlerScope),i}return n(e,t),e.prototype.dispose=function(){Ri(this._localHandlerScope),xi&&Ri(this._globalHandlerScope)},e.prototype.setCursor=function(t){this.dom.style&&(this.dom.style.cursor=t||"default")},e.prototype.__togglePointerCapture=function(t){if(this.__mayPointerCapture=null,xi&&+this.__pointerCapturing^+t){this.__pointerCapturing=t;var e=this._globalHandlerScope;t?Pi(this,e):Ri(e)}},e}(Ft),zi=function(t){function e(e){var n=t.call(this)||this;return n.isGroup=!0,n._children=[],n.attr(e),n}return n(e,t),e.prototype.childrenRef=function(){return this._children},e.prototype.children=function(){return this._children.slice()},e.prototype.childAt=function(t){return this._children[t]},e.prototype.childOfName=function(t){for(var e=this._children,n=0;n<e.length;n++)if(e[n].name===t)return e[n]},e.prototype.childCount=function(){return this._children.length},e.prototype.add=function(t){if(t&&(t!==this&&t.parent!==this&&(this._children.push(t),this._doAdd(t)),t.__hostTarget))throw"This elemenet has been used as an attachment";return this},e.prototype.addBefore=function(t,e){if(t&&t!==this&&t.parent!==this&&e&&e.parent===this){var n=this._children,i=n.indexOf(e);i>=0&&(n.splice(i,0,t),this._doAdd(t))}return this},e.prototype.replaceAt=function(t,e){var n=this._children,i=n[e];if(t&&t!==this&&t.parent!==this&&t!==i){n[e]=t,i.parent=null;var r=this.__zr;r&&i.removeSelfFromZr(r),this._doAdd(t)}return this},e.prototype._doAdd=function(t){t.parent&&t.parent.remove(t),t.parent=this;var e=this.__zr;e&&e!==t.__zr&&t.addSelfToZr(e),e&&e.refresh()},e.prototype.remove=function(t){var e=this.__zr,n=this._children,i=A(n,t);return i<0||(n.splice(i,1),t.parent=null,e&&t.removeSelfFromZr(e),e&&e.refresh()),this},e.prototype.removeAll=function(){for(var t=this._children,e=this.__zr,n=0;n<t.length;n++){var i=t[n];e&&i.removeSelfFromZr(e),i.parent=null}return t.length=0,this},e.prototype.eachChild=function(t,e){for(var n=this._children,i=0;i<n.length;i++){var r=n[i];t.call(e,r,i)}return this},e.prototype.traverse=function(t,e){for(var n=0;n<this._children.length;n++){var i=this._children[n],r=t.call(e,i);i.isGroup&&!r&&i.traverse(t,e)}return this},e.prototype.addSelfToZr=function(e){t.prototype.addSelfToZr.call(this,e);for(var n=0;n<this._children.length;n++){this._children[n].addSelfToZr(e)}},e.prototype.removeSelfFromZr=function(e){t.prototype.removeSelfFromZr.call(this,e);for(var n=0;n<this._children.length;n++){this._children[n].removeSelfFromZr(e)}},e.prototype.getBoundingRect=function(t){for(var e=new Rn(0,0,0,0),n=t||this._children,i=[],r=null,o=0;o<n.length;o++){var a=n[o];if(!a.ignore&&!a.invisible){var s=a.getBoundingRect(),l=a.getLocalTransform(i);l?(Rn.applyTransform(e,s,l),(r=r||e.clone()).union(e)):(r=r||s.clone()).union(s)}}return r||e},e}(ei);zi.prototype.type="group";
+/*!
+    * ZRender, a high performance 2d drawing library.
+    *
+    * Copyright (c) 2013, Baidu Inc.
+    * All rights reserved.
+    *
+    * LICENSE
+    * https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+    */
+var Bi=!a.canvasSupported,Vi={},Fi={};var Gi=function(){function t(t,e,n){var i=this;this._sleepAfterStill=10,this._stillFrameAccum=0,this._needsRefresh=!0,this._needsRefreshHover=!0,this._darkMode=!1,n=n||{},this.dom=e,this.id=t;var r=new vi,o=n.renderer||"canvas";if(Bi)throw new Error("IE8 support has been dropped since 5.0");if(Vi[o]||(o=z(Vi)[0]),!Vi[o])throw new Error("Renderer '"+o+"' is not imported. Please import it first.");n.useDirtyRect=null!=n.useDirtyRect&&n.useDirtyRect;var s=new Vi[o](e,r,n,t);this.storage=r,this.painter=s;var l=a.node||a.worker?null:new Ei(s.getViewportRoot(),s.root);this.handler=new ce(r,s,l,s.root),this.animation=new _i({stage:{update:function(){return i._flush(!0)}}}),this.animation.start()}return t.prototype.add=function(t){t&&(this.storage.addRoot(t),t.addSelfToZr(this),this.refresh())},t.prototype.remove=function(t){t&&(this.storage.delRoot(t),t.removeSelfFromZr(this),this.refresh())},t.prototype.configLayer=function(t,e){this.painter.configLayer&&this.painter.configLayer(t,e),this.refresh()},t.prototype.setBackgroundColor=function(t){this.painter.setBackgroundColor&&this.painter.setBackgroundColor(t),this.refresh(),this._backgroundColor=t,this._darkMode=function(t){if(!t)return!1;if("string"==typeof t)return sn(t,1)<.4;if(t.colorStops){for(var e=t.colorStops,n=0,i=e.length,r=0;r<i;r++)n+=sn(e[r].color,1);return(n/=i)<.4}return!1}(t)},t.prototype.getBackgroundColor=function(){return this._backgroundColor},t.prototype.setDarkMode=function(t){this._darkMode=t},t.prototype.isDarkMode=function(){return this._darkMode},t.prototype.refreshImmediately=function(t){t||this.animation.update(!0),this._needsRefresh=!1,this.painter.refresh(),this._needsRefresh=!1},t.prototype.refresh=function(){this._needsRefresh=!0,this.animation.start()},t.prototype.flush=function(){this._flush(!1)},t.prototype._flush=function(t){var e,n=(new Date).getTime();this._needsRefresh&&(e=!0,this.refreshImmediately(t)),this._needsRefreshHover&&(e=!0,this.refreshHoverImmediately());var i=(new Date).getTime();e?(this._stillFrameAccum=0,this.trigger("rendered",{elapsedTime:i-n})):this._sleepAfterStill>0&&(this._stillFrameAccum++,this._stillFrameAccum>this._sleepAfterStill&&this.animation.stop())},t.prototype.setSleepAfterStill=function(t){this._sleepAfterStill=t},t.prototype.wakeUp=function(){this.animation.start(),this._stillFrameAccum=0},t.prototype.addHover=function(t){},t.prototype.removeHover=function(t){},t.prototype.clearHover=function(){},t.prototype.refreshHover=function(){this._needsRefreshHover=!0},t.prototype.refreshHoverImmediately=function(){this._needsRefreshHover=!1,this.painter.refreshHover&&"canvas"===this.painter.getType()&&this.painter.refreshHover()},t.prototype.resize=function(t){t=t||{},this.painter.resize(t.width,t.height),this.handler.resize()},t.prototype.clearAnimation=function(){this.animation.clear()},t.prototype.getWidth=function(){return this.painter.getWidth()},t.prototype.getHeight=function(){return this.painter.getHeight()},t.prototype.pathToImage=function(t,e){if(this.painter.pathToImage)return this.painter.pathToImage(t,e)},t.prototype.setCursorStyle=function(t){this.handler.setCursorStyle(t)},t.prototype.findHover=function(t,e){return this.handler.findHover(t,e)},t.prototype.on=function(t,e,n){return this.handler.on(t,e,n),this},t.prototype.off=function(t,e){this.handler.off(t,e)},t.prototype.trigger=function(t,e){this.handler.trigger(t,e)},t.prototype.clear=function(){for(var t=this.storage.getRoots(),e=0;e<t.length;e++)t[e]instanceof zi&&t[e].removeSelfFromZr(this);this.storage.delAllRoots(),this.painter.clear()},t.prototype.dispose=function(){var t;this.animation.stop(),this.clear(),this.storage.dispose(),this.painter.dispose(),this.handler.dispose(),this.animation=this.storage=this.painter=this.handler=null,t=this.id,delete Fi[t]},t}();function Hi(t,e){var n=new Gi(x(),t,e);return Fi[n.id]=n,n}function Wi(t,e){Vi[t]=e}var Yi=Object.freeze({__proto__:null,init:Hi,dispose:function(t){t.dispose()},disposeAll:function(){for(var t in Fi)Fi.hasOwnProperty(t)&&Fi[t].dispose();Fi={}},getInstance:function(t){return Fi[t]},registerPainter:Wi,version:"5.0.4"}),Xi=1e-4;function Ui(t,e,n,i){var r=e[1]-e[0],o=n[1]-n[0];if(0===r)return 0===o?n[0]:(n[0]+n[1])/2;if(i)if(r>0){if(t<=e[0])return n[0];if(t>=e[1])return n[1]}else{if(t>=e[0])return n[0];if(t<=e[1])return n[1]}else{if(t===e[0])return n[0];if(t===e[1])return n[1]}return(t-e[0])/r*o+n[0]}function Zi(t,e){switch(t){case"center":case"middle":t="50%";break;case"left":case"top":t="0%";break;case"right":case"bottom":t="100%"}return"string"==typeof t?(n=t,n.replace(/^\s+|\s+$/g,"")).match(/%$/)?parseFloat(t)/100*e:parseFloat(t):null==t?NaN:+t;var n}function ji(t,e,n){return null==e&&(e=10),e=Math.min(Math.max(0,e),20),t=(+t).toFixed(e),n?t:+t}function qi(t){return t.sort((function(t,e){return t-e})),t}function Ki(t){if(t=+t,isNaN(t))return 0;for(var e=1,n=0;Math.round(t*e)/e!==t;)e*=10,n++;return n}function $i(t){var e=t.toString(),n=e.indexOf("e");if(n>0){var i=+e.slice(n+1);return i<0?-i:0}var r=e.indexOf(".");return r<0?0:e.length-1-r}function Ji(t,e){var n=Math.log,i=Math.LN10,r=Math.floor(n(t[1]-t[0])/i),o=Math.round(n(Math.abs(e[1]-e[0]))/i),a=Math.min(Math.max(-r+o,0),20);return isFinite(a)?a:20}function Qi(t,e,n){if(!t[e])return 0;var i=R(t,(function(t,e){return t+(isNaN(e)?0:e)}),0);if(0===i)return 0;for(var r=Math.pow(10,n),o=O(t,(function(t){return(isNaN(t)?0:t)/i*r*100})),a=100*r,s=O(o,(function(t){return Math.floor(t)})),l=R(s,(function(t,e){return t+e}),0),u=O(o,(function(t,e){return t-s[e]}));l<a;){for(var h=Number.NEGATIVE_INFINITY,c=null,p=0,d=u.length;p<d;++p)u[p]>h&&(h=u[p],c=p);++s[c],u[c]=0,++l}return s[e]/r}var tr=9007199254740991;function er(t){var e=2*Math.PI;return(t%e+e)%e}function nr(t){return t>-1e-4&&t<Xi}var ir=/^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/;function rr(t){if(t instanceof Date)return t;if("string"==typeof t){var e=ir.exec(t);if(!e)return new Date(NaN);if(e[8]){var n=+e[4]||0;return"Z"!==e[8].toUpperCase()&&(n-=+e[8].slice(0,3)),new Date(Date.UTC(+e[1],+(e[2]||1)-1,+e[3]||1,n,+(e[5]||0),+e[6]||0,+e[7]||0))}return new Date(+e[1],+(e[2]||1)-1,+e[3]||1,+e[4]||0,+(e[5]||0),+e[6]||0,+e[7]||0)}return null==t?new Date(NaN):new Date(Math.round(t))}function or(t){return Math.pow(10,ar(t))}function ar(t){if(0===t)return 0;var e=Math.floor(Math.log(t)/Math.LN10);return t/Math.pow(10,e)>=10&&e++,e}function sr(t,e){var n=ar(t),i=Math.pow(10,n),r=t/i;return t=(e?r<1.5?1:r<2.5?2:r<4?3:r<7?5:10:r<1?1:r<2?2:r<3?3:r<5?5:10)*i,n>=-20?+t.toFixed(n<0?-n:0):t}function lr(t,e){var n=(t.length-1)*e+1,i=Math.floor(n),r=+t[i-1],o=n-i;return o?r+o*(t[i]-r):r}function ur(t){t.sort((function(t,e){return s(t,e,0)?-1:1}));for(var e=-1/0,n=1,i=0;i<t.length;){for(var r=t[i].interval,o=t[i].close,a=0;a<2;a++)r[a]<=e&&(r[a]=e,o[a]=a?1:1-n),e=r[a],n=o[a];r[0]===r[1]&&o[0]*o[1]!=1?t.splice(i,1):i++}return t;function s(t,e,n){return t.interval[n]<e.interval[n]||t.interval[n]===e.interval[n]&&(t.close[n]-e.close[n]==(n?-1:1)||!n&&s(t,e,1))}}function hr(t){var e=parseFloat(t);return e==t&&(0!==e||"string"!=typeof t||t.indexOf("x")<=0)?e:NaN}function cr(t){return!isNaN(hr(t))}function pr(){return Math.round(9*Math.random())}function dr(t,e){return 0===e?t:dr(e,t%e)}function fr(t,e){return null==t?e:null==e?t:t*e/dr(t,e)}"undefined"!=typeof console&&console.warn&&console.log;function gr(t){0}function yr(t){throw new Error(t)}var vr="series\0",mr="\0_ec_\0";function _r(t){return t instanceof Array?t:null==t?[]:[t]}function xr(t,e,n){if(t){t[e]=t[e]||{},t.emphasis=t.emphasis||{},t.emphasis[e]=t.emphasis[e]||{};for(var i=0,r=n.length;i<r;i++){var o=n[i];!t.emphasis[e].hasOwnProperty(o)&&t[e].hasOwnProperty(o)&&(t.emphasis[e][o]=t[e][o])}}}var br=["fontStyle","fontWeight","fontSize","fontFamily","rich","tag","color","textBorderColor","textBorderWidth","width","height","lineHeight","align","verticalAlign","baseline","shadowColor","shadowBlur","shadowOffsetX","shadowOffsetY","textShadowColor","textShadowBlur","textShadowOffsetX","textShadowOffsetY","backgroundColor","borderColor","borderWidth","borderRadius","padding"];function wr(t){return!X(t)||F(t)||t instanceof Date?t:t.value}function Sr(t,e,n){var i="normalMerge"===n,r="replaceMerge"===n,o="replaceAll"===n;t=t||[],e=(e||[]).slice();var a=ht();P(e,(function(t,n){X(t)||(e[n]=null)}));var s,l,u=function(t,e,n){var i=[];if("replaceAll"===n)return i;for(var r=0;r<t.length;r++){var o=t[r];o&&null!=o.id&&e.set(o.id,r),i.push({existing:"replaceMerge"===n||Ar(o)?null:o,newOption:null,keyInfo:null,brandNew:null})}return i}(t,a,n);return(i||r)&&function(t,e,n,i){P(i,(function(r,o){if(r&&null!=r.id){var a=Ir(r.id),s=n.get(a);if(null!=s){var l=t[s];rt(!l.newOption,'Duplicated option on id "'+a+'".'),l.newOption=r,l.existing=e[s],i[o]=null}}}))}(u,t,a,e),i&&function(t,e){P(e,(function(n,i){if(n&&null!=n.name)for(var r=0;r<t.length;r++){var o=t[r].existing;if(!t[r].newOption&&o&&(null==o.id||null==n.id)&&!Ar(n)&&!Ar(o)&&Mr("name",o,n))return t[r].newOption=n,void(e[i]=null)}}))}(u,e),i||r?function(t,e,n){P(e,(function(e){if(e){for(var i,r=0;(i=t[r])&&(i.newOption||Ar(i.existing)||i.existing&&null!=e.id&&!Mr("id",e,i.existing));)r++;i?(i.newOption=e,i.brandNew=n):t.push({newOption:e,brandNew:n,existing:null,keyInfo:null}),r++}}))}(u,e,r):o&&function(t,e){P(e,(function(e){t.push({newOption:e,brandNew:!0,existing:null,keyInfo:null})}))}(u,e),s=u,l=ht(),P(s,(function(t){var e=t.existing;e&&l.set(e.id,t)})),P(s,(function(t){var e=t.newOption;rt(!e||null==e.id||!l.get(e.id)||l.get(e.id)===t,"id duplicates: "+(e&&e.id)),e&&null!=e.id&&l.set(e.id,t),!t.keyInfo&&(t.keyInfo={})})),P(s,(function(t,e){var n=t.existing,i=t.newOption,r=t.keyInfo;if(X(i)){if(r.name=null!=i.name?Ir(i.name):n?n.name:vr+e,n)r.id=Ir(n.id);else if(null!=i.id)r.id=Ir(i.id);else{var o=0;do{r.id="\0"+r.name+"\0"+o++}while(l.get(r.id))}l.set(r.id,t)}})),u}function Mr(t,e,n){var i=Tr(e[t],null),r=Tr(n[t],null);return null!=i&&null!=r&&i===r}function Ir(t){return Tr(t,"")}function Tr(t,e){if(null==t)return e;var n=typeof t;return"string"===n?t:"number"===n||W(t)?t+"":e}function Cr(t){var e=t.name;return!(!e||!e.indexOf(vr))}function Ar(t){return t&&null!=t.id&&0===Ir(t.id).indexOf(mr)}function Dr(t,e){return null!=e.dataIndexInside?e.dataIndexInside:null!=e.dataIndex?F(e.dataIndex)?O(e.dataIndex,(function(e){return t.indexOfRawIndex(e)})):t.indexOfRawIndex(e.dataIndex):null!=e.name?F(e.name)?O(e.name,(function(e){return t.indexOfName(e)})):t.indexOfName(e.name):void 0}function Lr(){var t="__ec_inner_"+kr++;return function(e){return e[t]||(e[t]={})}}var kr=pr();function Pr(t,e,n){var i;if(H(e)){var r={};r[e+"Index"]=0,i=r}else i=e;var o=ht(),a={},s=!1;P(i,(function(t,e){if("dataIndex"!==e&&"dataIndexInside"!==e){var i=e.match(/^(\w+)(Index|Id|Name)$/)||[],r=i[1],l=(i[2]||"").toLowerCase();if(r&&l&&!(n&&n.includeMainTypes&&A(n.includeMainTypes,r)<0))s=s||!!r,(o.get(r)||o.set(r,{}))[l]=t}else a[e]=t}));var l=n?n.defaultMainType:null;return!s&&l&&o.set(l,{}),o.each((function(e,i){var r=Nr(t,i,e,{useDefault:l===i,enableAll:!n||null==n.enableAll||n.enableAll,enableNone:!n||null==n.enableNone||n.enableNone});a[i+"Models"]=r.models,a[i+"Model"]=r.models[0]})),a}var Or={useDefault:!0,enableAll:!1,enableNone:!1},Rr={useDefault:!1,enableAll:!0,enableNone:!0};function Nr(t,e,n,i){i=i||Or;var r=n.index,o=n.id,a=n.name,s={models:null,specified:null!=r||null!=o||null!=a};if(!s.specified){var l=void 0;return s.models=i.useDefault&&(l=t.getComponent(e))?[l]:[],s}return"none"===r||!1===r?(rt(i.enableNone,'`"none"` or `false` is not a valid value on index option.'),s.models=[],s):("all"===r&&(rt(i.enableAll,'`"all"` is not a valid value on index option.'),r=o=a=null),s.models=t.queryComponents({mainType:e,index:r,id:o,name:a}),s)}function Er(t,e,n){t.setAttribute?t.setAttribute(e,n):t[e]=n}function zr(t,e){var n=ht(),i=[];return P(t,(function(t){var r=e(t);(n.get(r)||(i.push(r),n.set(r,[]))).push(t)})),{keys:i,buckets:n}}function Br(t,e,n,i,r){var o=null==e||"auto"===e;if(null==i)return i;if("number"==typeof i)return ji(d=hn(n||0,i,r),o?Math.max($i(n||0),$i(i)):e);if("string"==typeof i)return r<1?n:i;for(var a=[],s=n,l=i,u=Math.max(s?s.length:0,l.length),h=0;h<u;++h){if("ordinal"===t.getDimensionInfo(h).type)a[h]=(r<1&&s?s:l)[h];else{var c=s&&s[h]?s[h]:0,p=l[h],d=hn(c,p,r);a[h]=ji(d,o?Math.max($i(c),$i(p)):e)}}return a}var Vr="___EC__COMPONENT__CONTAINER___",Fr="___EC__EXTENDED_CLASS___";function Gr(t){var e={main:"",sub:""};if(t){var n=t.split(".");e.main=n[0]||"",e.sub=n[1]||""}return e}function Hr(t,e){t.$constructor=t,t.extend=function(t){var e=this;function n(){for(var i=[],o=0;o<arguments.length;o++)i[o]=arguments[o];if(t.$constructor)t.$constructor.apply(this,arguments);else{if(Wr(e)){var a=pt(n.prototype,new(e.bind.apply(e,r([void 0],i))));return a}e.apply(this,arguments)}}return n[Fr]=!0,I(n.prototype,t),n.extend=this.extend,n.superCall=Ur,n.superApply=Zr,D(n,this),n.superClass=e,n}}function Wr(t){return"function"==typeof t&&/^class\s/.test(Function.prototype.toString.call(t))}function Yr(t,e){t.extend=e.extend}var Xr=Math.round(10*Math.random());function Ur(t,e){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];return this.superClass.prototype[e].apply(t,n)}function Zr(t,e,n){return this.superClass.prototype[e].apply(t,n)}function jr(t){var e={};t.registerClass=function(t){var n,i=t.type||t.prototype.type;if(i){rt(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(n=i),'componentType "'+n+'" illegal'),t.prototype.type=i;var r=Gr(i);if(r.sub){if(r.sub!==Vr){(function(t){var n=e[t.main];n&&n[Vr]||((n=e[t.main]={})[Vr]=!0);return n}(r))[r.sub]=t}}else e[r.main]=t}return t},t.getClass=function(t,n,i){var r=e[t];if(r&&r[Vr]&&(r=n?r[n]:null),i&&!r)throw new Error(n?"Component "+t+"."+(n||"")+" not exists. Load it first.":t+".type should be specified.");return r},t.getClassesByMainType=function(t){var n=Gr(t),i=[],r=e[n.main];return r&&r[Vr]?P(r,(function(t,e){e!==Vr&&i.push(t)})):i.push(r),i},t.hasClass=function(t){var n=Gr(t);return!!e[n.main]},t.getAllClassMainTypes=function(){var t=[];return P(e,(function(e,n){t.push(n)})),t},t.hasSubTypes=function(t){var n=Gr(t),i=e[n.main];return i&&i[Vr]}}function qr(t,e){for(var n=0;n<t.length;n++)t[n][1]||(t[n][1]=t[n][0]);return e=e||!1,function(n,i,r){for(var o={},a=0;a<t.length;a++){var s=t[a][1];if(!(i&&A(i,s)>=0||r&&A(r,s)<0)){var l=n.getShallow(s,e);null!=l&&(o[t[a][0]]=l)}}return o}}var Kr=qr([["fill","color"],["shadowBlur"],["shadowOffsetX"],["shadowOffsetY"],["opacity"],["shadowColor"]]),$r=function(){function t(){}return t.prototype.getAreaStyle=function(t,e){return Kr(this,t,e)},t}(),Jr=new Ee(50);function Qr(t){if("string"==typeof t){var e=Jr.get(t);return e&&e.image}return t}function to(t,e,n,i,r){if(t){if("string"==typeof t){if(e&&e.__zrImageSrc===t||!n)return e;var o=Jr.get(t),a={hostEl:n,cb:i,cbPayload:r};return o?!no(e=o.image)&&o.pending.push(a):((e=new Image).onload=e.onerror=eo,Jr.put(t,e.__cachedImgObj={image:e,pending:[a]}),e.src=e.__zrImageSrc=t),e}return t}return e}function eo(){var t=this.__cachedImgObj;this.onload=this.onerror=this.__cachedImgObj=null;for(var e=0;e<t.pending.length;e++){var n=t.pending[e],i=n.cb;i&&i(this,n.cbPayload),n.hostEl.dirty()}t.pending.length=0}function no(t){return t&&t.width&&t.height}var io=/\{([a-zA-Z0-9_]+)\|([^}]*)\}/g;function ro(t,e,n,i,r){if(!e)return"";var o=(t+"").split("\n");r=oo(e,n,i,r);for(var a=0,s=o.length;a<s;a++)o[a]=ao(o[a],r);return o.join("\n")}function oo(t,e,n,i){var r=I({},i=i||{});r.font=e,n=tt(n,"..."),r.maxIterations=tt(i.maxIterations,2);var o=r.minChar=tt(i.minChar,0);r.cnCharWidth=Bn("国",e);var a=r.ascCharWidth=Bn("a",e);r.placeholder=tt(i.placeholder,"");for(var s=t=Math.max(0,t-1),l=0;l<o&&s>=a;l++)s-=a;var u=Bn(n,e);return u>s&&(n="",u=0),s=t-u,r.ellipsis=n,r.ellipsisWidth=u,r.contentWidth=s,r.containerWidth=t,r}function ao(t,e){var n=e.containerWidth,i=e.font,r=e.contentWidth;if(!n)return"";var o=Bn(t,i);if(o<=n)return t;for(var a=0;;a++){if(o<=r||a>=e.maxIterations){t+=e.ellipsis;break}var s=0===a?so(t,r,e.ascCharWidth,e.cnCharWidth):o>0?Math.floor(t.length*r/o):0;o=Bn(t=t.substr(0,s),i)}return""===t&&(t=e.placeholder),t}function so(t,e,n,i){for(var r=0,o=0,a=t.length;o<a&&r<e;o++){var s=t.charCodeAt(o);r+=0<=s&&s<=127?n:i}return o}var lo=function(){},uo=function(t){this.tokens=[],t&&(this.tokens=t)},ho=function(){this.width=0,this.height=0,this.contentWidth=0,this.contentHeight=0,this.outerWidth=0,this.outerHeight=0,this.lines=[]};function co(t,e,n,i,r){var o,a,s=""===e,l=r&&n.rich[r]||{},u=t.lines,h=l.font||n.font,c=!1;if(i){var p=l.padding,d=p?p[1]+p[3]:0;if(null!=l.width&&"auto"!==l.width){var f=function(t,e){if("string"==typeof t)return t.lastIndexOf("%")>=0?parseFloat(t)/100*e:parseFloat(t);return t}(l.width,i.width)+d;u.length>0&&f+i.accumWidth>i.width&&(o=e.split("\n"),c=!0),i.accumWidth=f}else{var g=go(e,h,i.width,i.breakAll,i.accumWidth);i.accumWidth=g.accumWidth+d,a=g.linesWidths,o=g.lines}}else o=e.split("\n");for(var y=0;y<o.length;y++){var v=o[y],m=new lo;if(m.styleName=r,m.text=v,m.isLineHolder=!v&&!s,"number"==typeof l.width?m.width=l.width:m.width=a?a[y]:Bn(v,h),y||c)u.push(new uo([m]));else{var _=(u[u.length-1]||(u[0]=new uo)).tokens,x=_.length;1===x&&_[0].isLineHolder?_[0]=m:(v||!x||s)&&_.push(m)}}}var po=R(",&?/;] ".split(""),(function(t,e){return t[e]=!0,t}),{});function fo(t){return!function(t){var e=t.charCodeAt(0);return e>=33&&e<=255}(t)||!!po[t]}function go(t,e,n,i,r){for(var o=[],a=[],s="",l="",u=0,h=0,c=0;c<t.length;c++){var p=t.charAt(c);if("\n"!==p){var d=Bn(p,e),f=!i&&!fo(p);(o.length?h+d>n:r+h+d>n)?h?(s||l)&&(f?(s||(s=l,l="",h=u=0),o.push(s),a.push(h-u),l+=p,s="",h=u+=d):(l&&(s+=l,h+=u,l="",u=0),o.push(s),a.push(h),s=p,h=d)):f?(o.push(l),a.push(u),l=p,u=d):(o.push(p),a.push(d)):(h+=d,f?(l+=p,u+=d):(l&&(s+=l,l="",u=0),s+=p))}else l&&(s+=l,h+=u),o.push(s),a.push(h),s="",l="",u=0,h=0}return o.length||s||(s=t,l="",u=0),l&&(s+=l),s&&(o.push(s),a.push(h)),1===o.length&&(h+=r),{accumWidth:h,lines:o,linesWidths:a}}var yo="__zr_style_"+Math.round(10*Math.random()),vo={shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,shadowColor:"#000",opacity:1,blend:"source-over"},mo={style:{shadowBlur:!0,shadowOffsetX:!0,shadowOffsetY:!0,shadowColor:!0,opacity:!0}};vo[yo]=!0;var _o=["z","z2","invisible"],xo=function(t){function e(e){return t.call(this,e)||this}var i;return n(e,t),e.prototype._init=function(e){for(var n=z(e),i=0;i<n.length;i++){var r=n[i];"style"===r?this.useStyle(e[r]):t.prototype.attrKV.call(this,r,e[r])}this.style||this.useStyle({})},e.prototype.beforeBrush=function(){},e.prototype.afterBrush=function(){},e.prototype.innerBeforeBrush=function(){},e.prototype.innerAfterBrush=function(){},e.prototype.shouldBePainted=function(t,e,n,i){var r=this.transform;if(this.ignore||this.invisible||0===this.style.opacity||this.culling&&function(t,e,n){bo.copy(t.getBoundingRect()),t.transform&&bo.applyTransform(t.transform);return wo.width=e,wo.height=n,!bo.intersect(wo)}(this,t,e)||r&&!r[0]&&!r[3])return!1;if(n&&this.__clipPaths)for(var o=0;o<this.__clipPaths.length;++o)if(this.__clipPaths[o].isZeroArea())return!1;if(i&&this.parent)for(var a=this.parent;a;){if(a.ignore)return!1;a=a.parent}return!0},e.prototype.contain=function(t,e){return this.rectContain(t,e)},e.prototype.traverse=function(t,e){t.call(e,this)},e.prototype.rectContain=function(t,e){var n=this.transformCoordToLocal(t,e);return this.getBoundingRect().contain(n[0],n[1])},e.prototype.getPaintRect=function(){var t=this._paintRect;if(!this._paintRect||this.__dirty){var e=this.transform,n=this.getBoundingRect(),i=this.style,r=i.shadowBlur||0,o=i.shadowOffsetX||0,a=i.shadowOffsetY||0;t=this._paintRect||(this._paintRect=new Rn(0,0,0,0)),e?Rn.applyTransform(t,n,e):t.copy(n),(r||o||a)&&(t.width+=2*r+Math.abs(o),t.height+=2*r+Math.abs(a),t.x=Math.min(t.x,t.x+o-r),t.y=Math.min(t.y,t.y+a-r));var s=this.dirtyRectTolerance;t.isZero()||(t.x=Math.floor(t.x-s),t.y=Math.floor(t.y-s),t.width=Math.ceil(t.width+1+2*s),t.height=Math.ceil(t.height+1+2*s))}return t},e.prototype.setPrevPaintRect=function(t){t?(this._prevPaintRect=this._prevPaintRect||new Rn(0,0,0,0),this._prevPaintRect.copy(t)):this._prevPaintRect=null},e.prototype.getPrevPaintRect=function(){return this._prevPaintRect},e.prototype.animateStyle=function(t){return this.animate("style",t)},e.prototype.updateDuringAnimation=function(t){"style"===t?this.dirtyStyle():this.markRedraw()},e.prototype.attrKV=function(e,n){"style"!==e?t.prototype.attrKV.call(this,e,n):this.style?this.setStyle(n):this.useStyle(n)},e.prototype.setStyle=function(t,e){return"string"==typeof t?this.style[t]=e:I(this.style,t),this.dirtyStyle(),this},e.prototype.dirtyStyle=function(){this.markRedraw(),this.__dirty|=e.STYLE_CHANGED_BIT,this._rect&&(this._rect=null)},e.prototype.dirty=function(){this.dirtyStyle()},e.prototype.styleChanged=function(){return!!(this.__dirty&e.STYLE_CHANGED_BIT)},e.prototype.styleUpdated=function(){this.__dirty&=~e.STYLE_CHANGED_BIT},e.prototype.createStyle=function(t){return pt(vo,t)},e.prototype.useStyle=function(t){t[yo]||(t=this.createStyle(t)),this.__inHover?this.__hoverStyle=t:this.style=t,this.dirtyStyle()},e.prototype.isStyleObject=function(t){return t[yo]},e.prototype._innerSaveToNormal=function(e){t.prototype._innerSaveToNormal.call(this,e);var n=this._normalState;e.style&&!n.style&&(n.style=this._mergeStyle(this.createStyle(),this.style)),this._savePrimaryToNormal(e,n,_o)},e.prototype._applyStateObj=function(e,n,i,r,o,a){t.prototype._applyStateObj.call(this,e,n,i,r,o,a);var s,l=!(n&&r);if(n&&n.style?o?r?s=n.style:(s=this._mergeStyle(this.createStyle(),i.style),this._mergeStyle(s,n.style)):(s=this._mergeStyle(this.createStyle(),r?this.style:i.style),this._mergeStyle(s,n.style)):l&&(s=i.style),s)if(o){var u=this.style;if(this.style=this.createStyle(l?{}:u),l)for(var h=z(u),c=0;c<h.length;c++){(d=h[c])in s&&(s[d]=s[d],this.style[d]=u[d])}var p=z(s);for(c=0;c<p.length;c++){var d=p[c];this.style[d]=this.style[d]}this._transitionState(e,{style:s},a,this.getAnimationStyleProps())}else this.useStyle(s);for(c=0;c<_o.length;c++){d=_o[c];n&&null!=n[d]?this[d]=n[d]:l&&null!=i[d]&&(this[d]=i[d])}},e.prototype._mergeStates=function(e){for(var n,i=t.prototype._mergeStates.call(this,e),r=0;r<e.length;r++){var o=e[r];o.style&&(n=n||{},this._mergeStyle(n,o.style))}return n&&(i.style=n),i},e.prototype._mergeStyle=function(t,e){return I(t,e),t},e.prototype.getAnimationStyleProps=function(){return mo},e.STYLE_CHANGED_BIT=2,e.initDefaultProps=((i=e.prototype).type="displayable",i.invisible=!1,i.z=0,i.z2=0,i.zlevel=0,i.culling=!1,i.cursor="pointer",i.rectHover=!1,i.incremental=!1,i._rect=null,i.dirtyRectTolerance=0,void(i.__dirty=ei.REDARAW_BIT|e.STYLE_CHANGED_BIT)),e}(ei),bo=new Rn(0,0,0,0),wo=new Rn(0,0,0,0);var So=Math.pow,Mo=Math.sqrt,Io=1e-8,To=1e-4,Co=Mo(3),Ao=1/3,Do=yt(),Lo=yt(),ko=yt();function Po(t){return t>-1e-8&&t<Io}function Oo(t){return t>Io||t<-1e-8}function Ro(t,e,n,i,r){var o=1-r;return o*o*(o*t+3*r*e)+r*r*(r*i+3*o*n)}function No(t,e,n,i,r){var o=1-r;return 3*(((e-t)*o+2*(n-e)*r)*o+(i-n)*r*r)}function Eo(t,e,n,i,r,o){var a=i+3*(e-n)-t,s=3*(n-2*e+t),l=3*(e-t),u=t-r,h=s*s-3*a*l,c=s*l-9*a*u,p=l*l-3*s*u,d=0;if(Po(h)&&Po(c)){if(Po(s))o[0]=0;else(M=-l/s)>=0&&M<=1&&(o[d++]=M)}else{var f=c*c-4*h*p;if(Po(f)){var g=c/h,y=-g/2;(M=-s/a+g)>=0&&M<=1&&(o[d++]=M),y>=0&&y<=1&&(o[d++]=y)}else if(f>0){var v=Mo(f),m=h*s+1.5*a*(-c+v),_=h*s+1.5*a*(-c-v);(M=(-s-((m=m<0?-So(-m,Ao):So(m,Ao))+(_=_<0?-So(-_,Ao):So(_,Ao))))/(3*a))>=0&&M<=1&&(o[d++]=M)}else{var x=(2*h*s-3*a*c)/(2*Mo(h*h*h)),b=Math.acos(x)/3,w=Mo(h),S=Math.cos(b),M=(-s-2*w*S)/(3*a),I=(y=(-s+w*(S+Co*Math.sin(b)))/(3*a),(-s+w*(S-Co*Math.sin(b)))/(3*a));M>=0&&M<=1&&(o[d++]=M),y>=0&&y<=1&&(o[d++]=y),I>=0&&I<=1&&(o[d++]=I)}}return d}function zo(t,e,n,i,r){var o=6*n-12*e+6*t,a=9*e+3*i-3*t-9*n,s=3*e-3*t,l=0;if(Po(a)){if(Oo(o))(h=-s/o)>=0&&h<=1&&(r[l++]=h)}else{var u=o*o-4*a*s;if(Po(u))r[0]=-o/(2*a);else if(u>0){var h,c=Mo(u),p=(-o-c)/(2*a);(h=(-o+c)/(2*a))>=0&&h<=1&&(r[l++]=h),p>=0&&p<=1&&(r[l++]=p)}}return l}function Bo(t,e,n,i,r,o){var a=(e-t)*r+t,s=(n-e)*r+e,l=(i-n)*r+n,u=(s-a)*r+a,h=(l-s)*r+s,c=(h-u)*r+u;o[0]=t,o[1]=a,o[2]=u,o[3]=c,o[4]=c,o[5]=h,o[6]=l,o[7]=i}function Vo(t,e,n,i,r,o,a,s,l,u,h){var c,p,d,f,g,y=.005,v=1/0;Do[0]=l,Do[1]=u;for(var m=0;m<1;m+=.05)Lo[0]=Ro(t,n,r,a,m),Lo[1]=Ro(e,i,o,s,m),(f=Pt(Do,Lo))<v&&(c=m,v=f);v=1/0;for(var _=0;_<32&&!(y<To);_++)p=c-y,d=c+y,Lo[0]=Ro(t,n,r,a,p),Lo[1]=Ro(e,i,o,s,p),f=Pt(Lo,Do),p>=0&&f<v?(c=p,v=f):(ko[0]=Ro(t,n,r,a,d),ko[1]=Ro(e,i,o,s,d),g=Pt(ko,Do),d<=1&&g<v?(c=d,v=g):y*=.5);return h&&(h[0]=Ro(t,n,r,a,c),h[1]=Ro(e,i,o,s,c)),Mo(v)}function Fo(t,e,n,i,r,o,a,s,l){for(var u=t,h=e,c=0,p=1/l,d=1;d<=l;d++){var f=d*p,g=Ro(t,n,r,a,f),y=Ro(e,i,o,s,f),v=g-u,m=y-h;c+=Math.sqrt(v*v+m*m),u=g,h=y}return c}function Go(t,e,n,i){var r=1-i;return r*(r*t+2*i*e)+i*i*n}function Ho(t,e,n,i){return 2*((1-i)*(e-t)+i*(n-e))}function Wo(t,e,n){var i=t+n-2*e;return 0===i?.5:(t-e)/i}function Yo(t,e,n,i,r){var o=(e-t)*i+t,a=(n-e)*i+e,s=(a-o)*i+o;r[0]=t,r[1]=o,r[2]=s,r[3]=s,r[4]=a,r[5]=n}function Xo(t,e,n,i,r,o,a,s,l){var u,h=.005,c=1/0;Do[0]=a,Do[1]=s;for(var p=0;p<1;p+=.05){Lo[0]=Go(t,n,r,p),Lo[1]=Go(e,i,o,p),(y=Pt(Do,Lo))<c&&(u=p,c=y)}c=1/0;for(var d=0;d<32&&!(h<To);d++){var f=u-h,g=u+h;Lo[0]=Go(t,n,r,f),Lo[1]=Go(e,i,o,f);var y=Pt(Lo,Do);if(f>=0&&y<c)u=f,c=y;else{ko[0]=Go(t,n,r,g),ko[1]=Go(e,i,o,g);var v=Pt(ko,Do);g<=1&&v<c?(u=g,c=v):h*=.5}}return l&&(l[0]=Go(t,n,r,u),l[1]=Go(e,i,o,u)),Mo(c)}function Uo(t,e,n,i,r,o,a){for(var s=t,l=e,u=0,h=1/a,c=1;c<=a;c++){var p=c*h,d=Go(t,n,r,p),f=Go(e,i,o,p),g=d-s,y=f-l;u+=Math.sqrt(g*g+y*y),s=d,l=f}return u}var Zo=Math.min,jo=Math.max,qo=Math.sin,Ko=Math.cos,$o=2*Math.PI,Jo=yt(),Qo=yt(),ta=yt();function ea(t,e,n){if(0!==t.length){for(var i=t[0],r=i[0],o=i[0],a=i[1],s=i[1],l=1;l<t.length;l++)i=t[l],r=Zo(r,i[0]),o=jo(o,i[0]),a=Zo(a,i[1]),s=jo(s,i[1]);e[0]=r,e[1]=a,n[0]=o,n[1]=s}}function na(t,e,n,i,r,o){r[0]=Zo(t,n),r[1]=Zo(e,i),o[0]=jo(t,n),o[1]=jo(e,i)}var ia=[],ra=[];function oa(t,e,n,i,r,o,a,s,l,u){var h=zo,c=Ro,p=h(t,n,r,a,ia);l[0]=1/0,l[1]=1/0,u[0]=-1/0,u[1]=-1/0;for(var d=0;d<p;d++){var f=c(t,n,r,a,ia[d]);l[0]=Zo(f,l[0]),u[0]=jo(f,u[0])}p=h(e,i,o,s,ra);for(d=0;d<p;d++){var g=c(e,i,o,s,ra[d]);l[1]=Zo(g,l[1]),u[1]=jo(g,u[1])}l[0]=Zo(t,l[0]),u[0]=jo(t,u[0]),l[0]=Zo(a,l[0]),u[0]=jo(a,u[0]),l[1]=Zo(e,l[1]),u[1]=jo(e,u[1]),l[1]=Zo(s,l[1]),u[1]=jo(s,u[1])}function aa(t,e,n,i,r,o,a,s){var l=Wo,u=Go,h=jo(Zo(l(t,n,r),1),0),c=jo(Zo(l(e,i,o),1),0),p=u(t,n,r,h),d=u(e,i,o,c);a[0]=Zo(t,r,p),a[1]=Zo(e,o,d),s[0]=jo(t,r,p),s[1]=jo(e,o,d)}function sa(t,e,n,i,r,o,a,s,l){var u=Nt,h=Et,c=Math.abs(r-o);if(c%$o<1e-4&&c>1e-4)return s[0]=t-n,s[1]=e-i,l[0]=t+n,void(l[1]=e+i);if(Jo[0]=Ko(r)*n+t,Jo[1]=qo(r)*i+e,Qo[0]=Ko(o)*n+t,Qo[1]=qo(o)*i+e,u(s,Jo,Qo),h(l,Jo,Qo),(r%=$o)<0&&(r+=$o),(o%=$o)<0&&(o+=$o),r>o&&!a?o+=$o:r<o&&a&&(r+=$o),a){var p=o;o=r,r=p}for(var d=0;d<o;d+=Math.PI/2)d>r&&(ta[0]=Ko(d)*n+t,ta[1]=qo(d)*i+e,u(s,ta,s),h(l,ta,l))}var la={M:1,L:2,C:3,Q:4,A:5,Z:6,R:7},ua=[],ha=[],ca=[],pa=[],da=[],fa=[],ga=Math.min,ya=Math.max,va=Math.cos,ma=Math.sin,_a=Math.sqrt,xa=Math.abs,ba=Math.PI,wa=2*ba,Sa="undefined"!=typeof Float32Array,Ma=[];function Ia(t){return Math.round(t/ba*1e8)/1e8%2*ba}function Ta(t,e){var n=Ia(t[0]);n<0&&(n+=wa);var i=n-t[0],r=t[1];r+=i,!e&&r-n>=wa?r=n+wa:e&&n-r>=wa?r=n-wa:!e&&n>r?r=n+(wa-Ia(n-r)):e&&n<r&&(r=n-(wa-Ia(r-n))),t[0]=n,t[1]=r}var Ca=function(){function t(t){this.dpr=1,this._version=0,this._xi=0,this._yi=0,this._x0=0,this._y0=0,this._len=0,t&&(this._saveData=!1),this._saveData&&(this.data=[])}return t.prototype.increaseVersion=function(){this._version++},t.prototype.getVersion=function(){return this._version},t.prototype.setScale=function(t,e,n){(n=n||0)>0&&(this._ux=xa(n/Zn/t)||0,this._uy=xa(n/Zn/e)||0)},t.prototype.setDPR=function(t){this.dpr=t},t.prototype.setContext=function(t){this._ctx=t},t.prototype.getContext=function(){return this._ctx},t.prototype.beginPath=function(){return this._ctx&&this._ctx.beginPath(),this.reset(),this},t.prototype.reset=function(){this._saveData&&(this._len=0),this._lineDash&&(this._lineDash=null,this._dashOffset=0),this._pathSegLen&&(this._pathSegLen=null,this._pathLen=0),this._version++},t.prototype.moveTo=function(t,e){return this.addData(la.M,t,e),this._ctx&&this._ctx.moveTo(t,e),this._x0=t,this._y0=e,this._xi=t,this._yi=e,this},t.prototype.lineTo=function(t,e){var n=xa(t-this._xi)>this._ux||xa(e-this._yi)>this._uy||this._len<5;return this.addData(la.L,t,e),this._ctx&&n&&(this._needsDash?this._dashedLineTo(t,e):this._ctx.lineTo(t,e)),n&&(this._xi=t,this._yi=e),this},t.prototype.bezierCurveTo=function(t,e,n,i,r,o){return this.addData(la.C,t,e,n,i,r,o),this._ctx&&(this._needsDash?this._dashedBezierTo(t,e,n,i,r,o):this._ctx.bezierCurveTo(t,e,n,i,r,o)),this._xi=r,this._yi=o,this},t.prototype.quadraticCurveTo=function(t,e,n,i){return this.addData(la.Q,t,e,n,i),this._ctx&&(this._needsDash?this._dashedQuadraticTo(t,e,n,i):this._ctx.quadraticCurveTo(t,e,n,i)),this._xi=n,this._yi=i,this},t.prototype.arc=function(t,e,n,i,r,o){Ma[0]=i,Ma[1]=r,Ta(Ma,o),i=Ma[0];var a=(r=Ma[1])-i;return this.addData(la.A,t,e,n,n,i,a,0,o?0:1),this._ctx&&this._ctx.arc(t,e,n,i,r,o),this._xi=va(r)*n+t,this._yi=ma(r)*n+e,this},t.prototype.arcTo=function(t,e,n,i,r){return this._ctx&&this._ctx.arcTo(t,e,n,i,r),this},t.prototype.rect=function(t,e,n,i){return this._ctx&&this._ctx.rect(t,e,n,i),this.addData(la.R,t,e,n,i),this},t.prototype.closePath=function(){this.addData(la.Z);var t=this._ctx,e=this._x0,n=this._y0;return t&&(this._needsDash&&this._dashedLineTo(e,n),t.closePath()),this._xi=e,this._yi=n,this},t.prototype.fill=function(t){t&&t.fill(),this.toStatic()},t.prototype.stroke=function(t){t&&t.stroke(),this.toStatic()},t.prototype.setLineDash=function(t){if(t instanceof Array){this._lineDash=t,this._dashIdx=0;for(var e=0,n=0;n<t.length;n++)e+=t[n];this._dashSum=e,this._needsDash=!0}else this._lineDash=null,this._needsDash=!1;return this},t.prototype.setLineDashOffset=function(t){return this._dashOffset=t,this},t.prototype.len=function(){return this._len},t.prototype.setData=function(t){var e=t.length;this.data&&this.data.length===e||!Sa||(this.data=new Float32Array(e));for(var n=0;n<e;n++)this.data[n]=t[n];this._len=e},t.prototype.appendPath=function(t){t instanceof Array||(t=[t]);for(var e=t.length,n=0,i=this._len,r=0;r<e;r++)n+=t[r].len();Sa&&this.data instanceof Float32Array&&(this.data=new Float32Array(i+n));for(r=0;r<e;r++)for(var o=t[r].data,a=0;a<o.length;a++)this.data[i++]=o[a];this._len=i},t.prototype.addData=function(t,e,n,i,r,o,a,s,l){if(this._saveData){var u=this.data;this._len+arguments.length>u.length&&(this._expandData(),u=this.data);for(var h=0;h<arguments.length;h++)u[this._len++]=arguments[h]}},t.prototype._expandData=function(){if(!(this.data instanceof Array)){for(var t=[],e=0;e<this._len;e++)t[e]=this.data[e];this.data=t}},t.prototype._dashedLineTo=function(t,e){var n,i,r=this._dashSum,o=this._lineDash,a=this._ctx,s=this._dashOffset,l=this._xi,u=this._yi,h=t-l,c=e-u,p=_a(h*h+c*c),d=l,f=u,g=o.length;for(s<0&&(s=r+s),d-=(s%=r)*(h/=p),f-=s*(c/=p);h>0&&d<=t||h<0&&d>=t||0===h&&(c>0&&f<=e||c<0&&f>=e);)d+=h*(n=o[i=this._dashIdx]),f+=c*n,this._dashIdx=(i+1)%g,h>0&&d<l||h<0&&d>l||c>0&&f<u||c<0&&f>u||a[i%2?"moveTo":"lineTo"](h>=0?ga(d,t):ya(d,t),c>=0?ga(f,e):ya(f,e));h=d-t,c=f-e,this._dashOffset=-_a(h*h+c*c)},t.prototype._dashedBezierTo=function(t,e,n,i,r,o){var a,s,l,u,h,c=this._ctx,p=this._dashSum,d=this._dashOffset,f=this._lineDash,g=this._xi,y=this._yi,v=0,m=this._dashIdx,_=f.length,x=0;for(d<0&&(d=p+d),d%=p,a=0;a<1;a+=.1)s=Ro(g,t,n,r,a+.1)-Ro(g,t,n,r,a),l=Ro(y,e,i,o,a+.1)-Ro(y,e,i,o,a),v+=_a(s*s+l*l);for(;m<_&&!((x+=f[m])>d);m++);for(a=(x-d)/v;a<=1;)u=Ro(g,t,n,r,a),h=Ro(y,e,i,o,a),m%2?c.moveTo(u,h):c.lineTo(u,h),a+=f[m]/v,m=(m+1)%_;m%2!=0&&c.lineTo(r,o),s=r-u,l=o-h,this._dashOffset=-_a(s*s+l*l)},t.prototype._dashedQuadraticTo=function(t,e,n,i){var r=n,o=i;n=(n+2*t)/3,i=(i+2*e)/3,t=(this._xi+2*t)/3,e=(this._yi+2*e)/3,this._dashedBezierTo(t,e,n,i,r,o)},t.prototype.toStatic=function(){if(this._saveData){var t=this.data;t instanceof Array&&(t.length=this._len,Sa&&this._len>11&&(this.data=new Float32Array(t)))}},t.prototype.getBoundingRect=function(){ca[0]=ca[1]=da[0]=da[1]=Number.MAX_VALUE,pa[0]=pa[1]=fa[0]=fa[1]=-Number.MAX_VALUE;var t,e=this.data,n=0,i=0,r=0,o=0;for(t=0;t<this._len;){var a=e[t++],s=1===t;switch(s&&(r=n=e[t],o=i=e[t+1]),a){case la.M:n=r=e[t++],i=o=e[t++],da[0]=r,da[1]=o,fa[0]=r,fa[1]=o;break;case la.L:na(n,i,e[t],e[t+1],da,fa),n=e[t++],i=e[t++];break;case la.C:oa(n,i,e[t++],e[t++],e[t++],e[t++],e[t],e[t+1],da,fa),n=e[t++],i=e[t++];break;case la.Q:aa(n,i,e[t++],e[t++],e[t],e[t+1],da,fa),n=e[t++],i=e[t++];break;case la.A:var l=e[t++],u=e[t++],h=e[t++],c=e[t++],p=e[t++],d=e[t++]+p;t+=1;var f=!e[t++];s&&(r=va(p)*h+l,o=ma(p)*c+u),sa(l,u,h,c,p,d,f,da,fa),n=va(d)*h+l,i=ma(d)*c+u;break;case la.R:na(r=n=e[t++],o=i=e[t++],r+e[t++],o+e[t++],da,fa);break;case la.Z:n=r,i=o}Nt(ca,ca,da),Et(pa,pa,fa)}return 0===t&&(ca[0]=ca[1]=pa[0]=pa[1]=0),new Rn(ca[0],ca[1],pa[0]-ca[0],pa[1]-ca[1])},t.prototype._calculateLength=function(){var t=this.data,e=this._len,n=this._ux,i=this._uy,r=0,o=0,a=0,s=0;this._pathSegLen||(this._pathSegLen=[]);for(var l=this._pathSegLen,u=0,h=0,c=0;c<e;){var p=t[c++],d=1===c;d&&(a=r=t[c],s=o=t[c+1]);var f=-1;switch(p){case la.M:r=a=t[c++],o=s=t[c++];break;case la.L:var g=t[c++],y=(_=t[c++])-o;(xa(D=g-r)>n||xa(y)>i||c===e-1)&&(f=Math.sqrt(D*D+y*y),r=g,o=_);break;case la.C:var v=t[c++],m=t[c++],_=(g=t[c++],t[c++]),x=t[c++],b=t[c++];f=Fo(r,o,v,m,g,_,x,b,10),r=x,o=b;break;case la.Q:f=Uo(r,o,v=t[c++],m=t[c++],g=t[c++],_=t[c++],10),r=g,o=_;break;case la.A:var w=t[c++],S=t[c++],M=t[c++],I=t[c++],T=t[c++],C=t[c++],A=C+T;c+=1;t[c++];d&&(a=va(T)*M+w,s=ma(T)*I+S),f=ya(M,I)*ga(wa,Math.abs(C)),r=va(A)*M+w,o=ma(A)*I+S;break;case la.R:a=r=t[c++],s=o=t[c++],f=2*t[c++]+2*t[c++];break;case la.Z:var D=a-r;y=s-o;f=Math.sqrt(D*D+y*y),r=a,o=s}f>=0&&(l[h++]=f,u+=f)}return this._pathLen=u,u},t.prototype.rebuildPath=function(t,e){var n,i,r,o,a,s,l,u,h=this.data,c=this._ux,p=this._uy,d=this._len,f=e<1,g=0,y=0;if(!f||(this._pathSegLen||this._calculateLength(),l=this._pathSegLen,u=e*this._pathLen))t:for(var v=0;v<d;){var m=h[v++],_=1===v;switch(_&&(n=r=h[v],i=o=h[v+1]),m){case la.M:n=r=h[v++],i=o=h[v++],t.moveTo(r,o);break;case la.L:if(a=h[v++],s=h[v++],xa(a-r)>c||xa(s-o)>p||v===d-1){if(f){if(g+(H=l[y++])>u){var x=(u-g)/H;t.lineTo(r*(1-x)+a*x,o*(1-x)+s*x);break t}g+=H}t.lineTo(a,s),r=a,o=s}break;case la.C:var b=h[v++],w=h[v++],S=h[v++],M=h[v++],I=h[v++],T=h[v++];if(f){if(g+(H=l[y++])>u){Bo(r,b,S,I,x=(u-g)/H,ua),Bo(o,w,M,T,x,ha),t.bezierCurveTo(ua[1],ha[1],ua[2],ha[2],ua[3],ha[3]);break t}g+=H}t.bezierCurveTo(b,w,S,M,I,T),r=I,o=T;break;case la.Q:b=h[v++],w=h[v++],S=h[v++],M=h[v++];if(f){if(g+(H=l[y++])>u){Yo(r,b,S,x=(u-g)/H,ua),Yo(o,w,M,x,ha),t.quadraticCurveTo(ua[1],ha[1],ua[2],ha[2]);break t}g+=H}t.quadraticCurveTo(b,w,S,M),r=S,o=M;break;case la.A:var C=h[v++],A=h[v++],D=h[v++],L=h[v++],k=h[v++],P=h[v++],O=h[v++],R=!h[v++],N=D>L?D:L,E=xa(D-L)>.001,z=k+P,B=!1;if(f)g+(H=l[y++])>u&&(z=k+P*(u-g)/H,B=!0),g+=H;if(E&&t.ellipse?t.ellipse(C,A,D,L,O,k,z,R):t.arc(C,A,N,k,z,R),B)break t;_&&(n=va(k)*D+C,i=ma(k)*L+A),r=va(z)*D+C,o=ma(z)*L+A;break;case la.R:n=r=h[v],i=o=h[v+1],a=h[v++],s=h[v++];var V=h[v++],F=h[v++];if(f){if(g+(H=l[y++])>u){var G=u-g;t.moveTo(a,s),t.lineTo(a+ga(G,V),s),(G-=V)>0&&t.lineTo(a+V,s+ga(G,F)),(G-=F)>0&&t.lineTo(a+ya(V-G,0),s+F),(G-=V)>0&&t.lineTo(a,s+ya(F-G,0));break t}g+=H}t.rect(a,s,V,F);break;case la.Z:if(f){var H;if(g+(H=l[y++])>u){x=(u-g)/H;t.lineTo(r*(1-x)+n*x,o*(1-x)+i*x);break t}g+=H}t.closePath(),r=n,o=i}}},t.CMD=la,t.initDefaultProps=function(){var e=t.prototype;e._saveData=!0,e._needsDash=!1,e._dashOffset=0,e._dashIdx=0,e._dashSum=0,e._ux=0,e._uy=0}(),t}();function Aa(t,e,n,i,r,o,a){if(0===r)return!1;var s=r,l=0;if(a>e+s&&a>i+s||a<e-s&&a<i-s||o>t+s&&o>n+s||o<t-s&&o<n-s)return!1;if(t===n)return Math.abs(o-t)<=s/2;var u=(l=(e-i)/(t-n))*o-a+(t*i-n*e)/(t-n);return u*u/(l*l+1)<=s/2*s/2}function Da(t,e,n,i,r,o,a,s,l,u,h){if(0===l)return!1;var c=l;return!(h>e+c&&h>i+c&&h>o+c&&h>s+c||h<e-c&&h<i-c&&h<o-c&&h<s-c||u>t+c&&u>n+c&&u>r+c&&u>a+c||u<t-c&&u<n-c&&u<r-c&&u<a-c)&&Vo(t,e,n,i,r,o,a,s,u,h,null)<=c/2}function La(t,e,n,i,r,o,a,s,l){if(0===a)return!1;var u=a;return!(l>e+u&&l>i+u&&l>o+u||l<e-u&&l<i-u&&l<o-u||s>t+u&&s>n+u&&s>r+u||s<t-u&&s<n-u&&s<r-u)&&Xo(t,e,n,i,r,o,s,l,null)<=u/2}var ka=2*Math.PI;function Pa(t){return(t%=ka)<0&&(t+=ka),t}var Oa=2*Math.PI;function Ra(t,e,n,i,r,o,a,s,l){if(0===a)return!1;var u=a;s-=t,l-=e;var h=Math.sqrt(s*s+l*l);if(h-u>n||h+u<n)return!1;if(Math.abs(i-r)%Oa<1e-4)return!0;if(o){var c=i;i=Pa(r),r=Pa(c)}else i=Pa(i),r=Pa(r);i>r&&(r+=Oa);var p=Math.atan2(l,s);return p<0&&(p+=Oa),p>=i&&p<=r||p+Oa>=i&&p+Oa<=r}function Na(t,e,n,i,r,o){if(o>e&&o>i||o<e&&o<i)return 0;if(i===e)return 0;var a=(o-e)/(i-e),s=i<e?1:-1;1!==a&&0!==a||(s=i<e?.5:-.5);var l=a*(n-t)+t;return l===r?1/0:l>r?s:0}var Ea=Ca.CMD,za=2*Math.PI;var Ba=[-1,-1,-1],Va=[-1,-1];function Fa(t,e,n,i,r,o,a,s,l,u){if(u>e&&u>i&&u>o&&u>s||u<e&&u<i&&u<o&&u<s)return 0;var h,c=Eo(e,i,o,s,u,Ba);if(0===c)return 0;for(var p=0,d=-1,f=void 0,g=void 0,y=0;y<c;y++){var v=Ba[y],m=0===v||1===v?.5:1;Ro(t,n,r,a,v)<l||(d<0&&(d=zo(e,i,o,s,Va),Va[1]<Va[0]&&d>1&&(h=void 0,h=Va[0],Va[0]=Va[1],Va[1]=h),f=Ro(e,i,o,s,Va[0]),d>1&&(g=Ro(e,i,o,s,Va[1]))),2===d?v<Va[0]?p+=f<e?m:-m:v<Va[1]?p+=g<f?m:-m:p+=s<g?m:-m:v<Va[0]?p+=f<e?m:-m:p+=s<f?m:-m)}return p}function Ga(t,e,n,i,r,o,a,s){if(s>e&&s>i&&s>o||s<e&&s<i&&s<o)return 0;var l=function(t,e,n,i,r){var o=t-2*e+n,a=2*(e-t),s=t-i,l=0;if(Po(o))Oo(a)&&(h=-s/a)>=0&&h<=1&&(r[l++]=h);else{var u=a*a-4*o*s;if(Po(u))(h=-a/(2*o))>=0&&h<=1&&(r[l++]=h);else if(u>0){var h,c=Mo(u),p=(-a-c)/(2*o);(h=(-a+c)/(2*o))>=0&&h<=1&&(r[l++]=h),p>=0&&p<=1&&(r[l++]=p)}}return l}(e,i,o,s,Ba);if(0===l)return 0;var u=Wo(e,i,o);if(u>=0&&u<=1){for(var h=0,c=Go(e,i,o,u),p=0;p<l;p++){var d=0===Ba[p]||1===Ba[p]?.5:1;Go(t,n,r,Ba[p])<a||(Ba[p]<u?h+=c<e?d:-d:h+=o<c?d:-d)}return h}d=0===Ba[0]||1===Ba[0]?.5:1;return Go(t,n,r,Ba[0])<a?0:o<e?d:-d}function Ha(t,e,n,i,r,o,a,s){if((s-=e)>n||s<-n)return 0;var l=Math.sqrt(n*n-s*s);Ba[0]=-l,Ba[1]=l;var u=Math.abs(i-r);if(u<1e-4)return 0;if(u>=za-1e-4){i=0,r=za;var h=o?1:-1;return a>=Ba[0]+t&&a<=Ba[1]+t?h:0}if(i>r){var c=i;i=r,r=c}i<0&&(i+=za,r+=za);for(var p=0,d=0;d<2;d++){var f=Ba[d];if(f+t>a){var g=Math.atan2(s,f);h=o?1:-1;g<0&&(g=za+g),(g>=i&&g<=r||g+za>=i&&g+za<=r)&&(g>Math.PI/2&&g<1.5*Math.PI&&(h=-h),p+=h)}}return p}function Wa(t,e,n,i,r){for(var o,a,s,l,u=t.data,h=t.len(),c=0,p=0,d=0,f=0,g=0,y=0;y<h;){var v=u[y++],m=1===y;switch(v===Ea.M&&y>1&&(n||(c+=Na(p,d,f,g,i,r))),m&&(f=p=u[y],g=d=u[y+1]),v){case Ea.M:p=f=u[y++],d=g=u[y++];break;case Ea.L:if(n){if(Aa(p,d,u[y],u[y+1],e,i,r))return!0}else c+=Na(p,d,u[y],u[y+1],i,r)||0;p=u[y++],d=u[y++];break;case Ea.C:if(n){if(Da(p,d,u[y++],u[y++],u[y++],u[y++],u[y],u[y+1],e,i,r))return!0}else c+=Fa(p,d,u[y++],u[y++],u[y++],u[y++],u[y],u[y+1],i,r)||0;p=u[y++],d=u[y++];break;case Ea.Q:if(n){if(La(p,d,u[y++],u[y++],u[y],u[y+1],e,i,r))return!0}else c+=Ga(p,d,u[y++],u[y++],u[y],u[y+1],i,r)||0;p=u[y++],d=u[y++];break;case Ea.A:var _=u[y++],x=u[y++],b=u[y++],w=u[y++],S=u[y++],M=u[y++];y+=1;var I=!!(1-u[y++]);o=Math.cos(S)*b+_,a=Math.sin(S)*w+x,m?(f=o,g=a):c+=Na(p,d,o,a,i,r);var T=(i-_)*w/b+_;if(n){if(Ra(_,x,w,S,S+M,I,e,T,r))return!0}else c+=Ha(_,x,w,S,S+M,I,T,r);p=Math.cos(S+M)*b+_,d=Math.sin(S+M)*w+x;break;case Ea.R:if(f=p=u[y++],g=d=u[y++],o=f+u[y++],a=g+u[y++],n){if(Aa(f,g,o,g,e,i,r)||Aa(o,g,o,a,e,i,r)||Aa(o,a,f,a,e,i,r)||Aa(f,a,f,g,e,i,r))return!0}else c+=Na(o,g,o,a,i,r),c+=Na(f,a,f,g,i,r);break;case Ea.Z:if(n){if(Aa(p,d,f,g,e,i,r))return!0}else c+=Na(p,d,f,g,i,r);p=f,d=g}}return n||(s=d,l=g,Math.abs(s-l)<1e-4)||(c+=Na(p,d,f,g,i,r)||0),0!==c}var Ya=T({fill:"#000",stroke:null,strokePercent:1,fillOpacity:1,strokeOpacity:1,lineDashOffset:0,lineWidth:1,lineCap:"butt",miterLimit:10,strokeNoScale:!1,strokeFirst:!1},vo),Xa={style:T({fill:!0,stroke:!0,strokePercent:!0,fillOpacity:!0,strokeOpacity:!0,lineDashOffset:!0,lineWidth:!0,miterLimit:!0},mo.style)},Ua=["x","y","rotation","scaleX","scaleY","originX","originY","invisible","culling","z","z2","zlevel","parent"],Za=function(t){function e(e){return t.call(this,e)||this}var i;return n(e,t),e.prototype.update=function(){var n=this;t.prototype.update.call(this);var i=this.style;if(i.decal){var r=this._decalEl=this._decalEl||new e;r.buildPath===e.prototype.buildPath&&(r.buildPath=function(t){n.buildPath(t,n.shape)}),r.silent=!0;var o=r.style;for(var a in i)o[a]!==i[a]&&(o[a]=i[a]);o.fill=i.fill?i.decal:null,o.decal=null,o.shadowColor=null,i.strokeFirst&&(o.stroke=null);for(var s=0;s<Ua.length;++s)r[Ua[s]]=this[Ua[s]];r.__dirty|=ei.REDARAW_BIT}else this._decalEl&&(this._decalEl=null)},e.prototype.getDecalElement=function(){return this._decalEl},e.prototype._init=function(e){var n=z(e);this.shape=this.getDefaultShape();var i=this.getDefaultStyle();i&&this.useStyle(i);for(var r=0;r<n.length;r++){var o=n[r],a=e[o];"style"===o?this.style?I(this.style,a):this.useStyle(a):"shape"===o?I(this.shape,a):t.prototype.attrKV.call(this,o,a)}this.style||this.useStyle({})},e.prototype.getDefaultStyle=function(){return null},e.prototype.getDefaultShape=function(){return{}},e.prototype.canBeInsideText=function(){return this.hasFill()},e.prototype.getInsideTextFill=function(){var t=this.style.fill;if("none"!==t){if(H(t)){var e=sn(t,0);return e>.5?jn:e>.2?"#eee":qn}if(t)return qn}return jn},e.prototype.getInsideTextStroke=function(t){var e=this.style.fill;if(H(e)){var n=this.__zr;if(!(!n||!n.isDarkMode())===sn(t,0)<.4)return e}},e.prototype.buildPath=function(t,e,n){},e.prototype.pathUpdated=function(){this.__dirty&=~e.SHAPE_CHANGED_BIT},e.prototype.createPathProxy=function(){this.path=new Ca(!1)},e.prototype.hasStroke=function(){var t=this.style,e=t.stroke;return!(null==e||"none"===e||!(t.lineWidth>0))},e.prototype.hasFill=function(){var t=this.style.fill;return null!=t&&"none"!==t},e.prototype.getBoundingRect=function(){var t=this._rect,n=this.style,i=!t;if(i){var r=!1;this.path||(r=!0,this.createPathProxy());var o=this.path;(r||this.__dirty&e.SHAPE_CHANGED_BIT)&&(o.beginPath(),this.buildPath(o,this.shape,!1),this.pathUpdated()),t=o.getBoundingRect()}if(this._rect=t,this.hasStroke()&&this.path&&this.path.len()>0){var a=this._rectWithStroke||(this._rectWithStroke=t.clone());if(this.__dirty||i){a.copy(t);var s=n.strokeNoScale?this.getLineScale():1,l=n.lineWidth;if(!this.hasFill()){var u=this.strokeContainThreshold;l=Math.max(l,null==u?4:u)}s>1e-10&&(a.width+=l/s,a.height+=l/s,a.x-=l/s/2,a.y-=l/s/2)}return a}return t},e.prototype.contain=function(t,e){var n=this.transformCoordToLocal(t,e),i=this.getBoundingRect(),r=this.style;if(t=n[0],e=n[1],i.contain(t,e)){var o=this.path;if(this.hasStroke()){var a=r.lineWidth,s=r.strokeNoScale?this.getLineScale():1;if(s>1e-10&&(this.hasFill()||(a=Math.max(a,this.strokeContainThreshold)),function(t,e,n,i){return Wa(t,e,!0,n,i)}(o,a/s,t,e)))return!0}if(this.hasFill())return function(t,e,n){return Wa(t,0,!1,e,n)}(o,t,e)}return!1},e.prototype.dirtyShape=function(){this.__dirty|=e.SHAPE_CHANGED_BIT,this._rect&&(this._rect=null),this._decalEl&&this._decalEl.dirtyShape(),this.markRedraw()},e.prototype.dirty=function(){this.dirtyStyle(),this.dirtyShape()},e.prototype.animateShape=function(t){return this.animate("shape",t)},e.prototype.updateDuringAnimation=function(t){"style"===t?this.dirtyStyle():"shape"===t?this.dirtyShape():this.markRedraw()},e.prototype.attrKV=function(e,n){"shape"===e?this.setShape(n):t.prototype.attrKV.call(this,e,n)},e.prototype.setShape=function(t,e){var n=this.shape;return n||(n=this.shape={}),"string"==typeof t?n[t]=e:I(n,t),this.dirtyShape(),this},e.prototype.shapeChanged=function(){return!!(this.__dirty&e.SHAPE_CHANGED_BIT)},e.prototype.createStyle=function(t){return pt(Ya,t)},e.prototype._innerSaveToNormal=function(e){t.prototype._innerSaveToNormal.call(this,e);var n=this._normalState;e.shape&&!n.shape&&(n.shape=I({},this.shape))},e.prototype._applyStateObj=function(e,n,i,r,o,a){t.prototype._applyStateObj.call(this,e,n,i,r,o,a);var s,l=!(n&&r);if(n&&n.shape?o?r?s=n.shape:(s=I({},i.shape),I(s,n.shape)):(s=I({},r?this.shape:i.shape),I(s,n.shape)):l&&(s=i.shape),s)if(o){this.shape=I({},this.shape);for(var u={},h=z(s),c=0;c<h.length;c++){var p=h[c];"object"==typeof s[p]?this.shape[p]=s[p]:u[p]=s[p]}this._transitionState(e,{shape:u},a)}else this.shape=s,this.dirtyShape()},e.prototype._mergeStates=function(e){for(var n,i=t.prototype._mergeStates.call(this,e),r=0;r<e.length;r++){var o=e[r];o.shape&&(n=n||{},this._mergeStyle(n,o.shape))}return n&&(i.shape=n),i},e.prototype.getAnimationStyleProps=function(){return Xa},e.prototype.isZeroArea=function(){return!1},e.extend=function(t){var i=function(e){function i(n){var i=e.call(this,n)||this;return t.init&&t.init.call(i,n),i}return n(i,e),i.prototype.getDefaultStyle=function(){return w(t.style)},i.prototype.getDefaultShape=function(){return w(t.shape)},i}(e);for(var r in t)"function"==typeof t[r]&&(i.prototype[r]=t[r]);return i},e.SHAPE_CHANGED_BIT=4,e.initDefaultProps=((i=e.prototype).type="path",i.strokeContainThreshold=5,i.segmentIgnoreThreshold=0,i.subPixelOptimize=!1,i.autoBatch=!1,void(i.__dirty=ei.REDARAW_BIT|xo.STYLE_CHANGED_BIT|e.SHAPE_CHANGED_BIT)),e}(xo),ja=T({strokeFirst:!0,font:En,x:0,y:0,textAlign:"left",textBaseline:"top",miterLimit:2},Ya),qa=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.hasStroke=function(){var t=this.style,e=t.stroke;return null!=e&&"none"!==e&&t.lineWidth>0},e.prototype.hasFill=function(){var t=this.style.fill;return null!=t&&"none"!==t},e.prototype.createStyle=function(t){return pt(ja,t)},e.prototype.setBoundingRect=function(t){this._rect=t},e.prototype.getBoundingRect=function(){var t=this.style;if(!this._rect){var e=t.text;null!=e?e+="":e="";var n=Fn(e,t.font,t.textAlign,t.textBaseline);if(n.x+=t.x||0,n.y+=t.y||0,this.hasStroke()){var i=t.lineWidth;n.x-=i/2,n.y-=i/2,n.width+=i,n.height+=i}this._rect=n}return this._rect},e.initDefaultProps=void(e.prototype.dirtyRectTolerance=10),e}(xo);qa.prototype.type="tspan";var Ka=T({x:0,y:0},vo),$a={style:T({x:!0,y:!0,width:!0,height:!0,sx:!0,sy:!0,sWidth:!0,sHeight:!0},mo.style)};var Ja=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.createStyle=function(t){return pt(Ka,t)},e.prototype._getSize=function(t){var e=this.style,n=e[t];if(null!=n)return n;var i,r=(i=e.image)&&"string"!=typeof i&&i.width&&i.height?e.image:this.__image;if(!r)return 0;var o="width"===t?"height":"width",a=e[o];return null==a?r[t]:r[t]/r[o]*a},e.prototype.getWidth=function(){return this._getSize("width")},e.prototype.getHeight=function(){return this._getSize("height")},e.prototype.getAnimationStyleProps=function(){return $a},e.prototype.getBoundingRect=function(){var t=this.style;return this._rect||(this._rect=new Rn(t.x||0,t.y||0,this.getWidth(),this.getHeight())),this._rect},e}(xo);Ja.prototype.type="image";var Qa=Math.round;function ts(t,e,n){if(e){var i=e.x1,r=e.x2,o=e.y1,a=e.y2;t.x1=i,t.x2=r,t.y1=o,t.y2=a;var s=n&&n.lineWidth;return s?(Qa(2*i)===Qa(2*r)&&(t.x1=t.x2=ns(i,s,!0)),Qa(2*o)===Qa(2*a)&&(t.y1=t.y2=ns(o,s,!0)),t):t}}function es(t,e,n){if(e){var i=e.x,r=e.y,o=e.width,a=e.height;t.x=i,t.y=r,t.width=o,t.height=a;var s=n&&n.lineWidth;return s?(t.x=ns(i,s,!0),t.y=ns(r,s,!0),t.width=Math.max(ns(i+o,s,!1)-t.x,0===o?0:1),t.height=Math.max(ns(r+a,s,!1)-t.y,0===a?0:1),t):t}}function ns(t,e,n){if(!e)return t;var i=Qa(2*t);return(i+Qa(e))%2==0?i/2:(i+(n?1:-1))/2}var is=function(){this.x=0,this.y=0,this.width=0,this.height=0},rs={},os=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new is},e.prototype.buildPath=function(t,e){var n,i,r,o;if(this.subPixelOptimize){var a=es(rs,e,this.style);n=a.x,i=a.y,r=a.width,o=a.height,a.r=e.r,e=a}else n=e.x,i=e.y,r=e.width,o=e.height;e.r?function(t,e){var n,i,r,o,a,s=e.x,l=e.y,u=e.width,h=e.height,c=e.r;u<0&&(s+=u,u=-u),h<0&&(l+=h,h=-h),"number"==typeof c?n=i=r=o=c:c instanceof Array?1===c.length?n=i=r=o=c[0]:2===c.length?(n=r=c[0],i=o=c[1]):3===c.length?(n=c[0],i=o=c[1],r=c[2]):(n=c[0],i=c[1],r=c[2],o=c[3]):n=i=r=o=0,n+i>u&&(n*=u/(a=n+i),i*=u/a),r+o>u&&(r*=u/(a=r+o),o*=u/a),i+r>h&&(i*=h/(a=i+r),r*=h/a),n+o>h&&(n*=h/(a=n+o),o*=h/a),t.moveTo(s+n,l),t.lineTo(s+u-i,l),0!==i&&t.arc(s+u-i,l+i,i,-Math.PI/2,0),t.lineTo(s+u,l+h-r),0!==r&&t.arc(s+u-r,l+h-r,r,0,Math.PI/2),t.lineTo(s+o,l+h),0!==o&&t.arc(s+o,l+h-o,o,Math.PI/2,Math.PI),t.lineTo(s,l+n),0!==n&&t.arc(s+n,l+n,n,Math.PI,1.5*Math.PI)}(t,e):t.rect(n,i,r,o)},e.prototype.isZeroArea=function(){return!this.shape.width||!this.shape.height},e}(Za);os.prototype.type="rect";var as={fill:"#000"},ss={style:T({fill:!0,stroke:!0,fillOpacity:!0,strokeOpacity:!0,lineWidth:!0,fontSize:!0,lineHeight:!0,width:!0,height:!0,textShadowColor:!0,textShadowBlur:!0,textShadowOffsetX:!0,textShadowOffsetY:!0,backgroundColor:!0,padding:!0,borderColor:!0,borderWidth:!0,borderRadius:!0},mo.style)},ls=function(t){function e(e){var n=t.call(this)||this;return n.type="text",n._children=[],n._defaultStyle=as,n.attr(e),n}return n(e,t),e.prototype.childrenRef=function(){return this._children},e.prototype.update=function(){this.styleChanged()&&this._updateSubTexts();for(var e=0;e<this._children.length;e++){var n=this._children[e];n.zlevel=this.zlevel,n.z=this.z,n.z2=this.z2,n.culling=this.culling,n.cursor=this.cursor,n.invisible=this.invisible}var i=this.attachedTransform;if(i){i.updateTransform();var r=i.transform;r?(this.transform=this.transform||[],ye(this.transform,r)):this.transform=null}else t.prototype.update.call(this)},e.prototype.getComputedTransform=function(){return this.__hostTarget&&(this.__hostTarget.getComputedTransform(),this.__hostTarget.updateInnerText(!0)),this.attachedTransform?this.attachedTransform.getComputedTransform():t.prototype.getComputedTransform.call(this)},e.prototype._updateSubTexts=function(){var t;this._childCursor=0,cs(t=this.style),P(t.rich,cs),this.style.rich?this._updateRichTexts():this._updatePlainTexts(),this._children.length=this._childCursor,this.styleUpdated()},e.prototype.addSelfToZr=function(e){t.prototype.addSelfToZr.call(this,e);for(var n=0;n<this._children.length;n++)this._children[n].__zr=e},e.prototype.removeSelfFromZr=function(e){t.prototype.removeSelfFromZr.call(this,e);for(var n=0;n<this._children.length;n++)this._children[n].__zr=null},e.prototype.getBoundingRect=function(){if(this.styleChanged()&&this._updateSubTexts(),!this._rect){for(var t=new Rn(0,0,0,0),e=this._children,n=[],i=null,r=0;r<e.length;r++){var o=e[r],a=o.getBoundingRect(),s=o.getLocalTransform(n);s?(t.copy(a),t.applyTransform(s),(i=i||t.clone()).union(t)):(i=i||a.clone()).union(a)}this._rect=i||t}return this._rect},e.prototype.setDefaultTextStyle=function(t){this._defaultStyle=t||as},e.prototype.setTextContent=function(t){throw new Error("Can't attach text on another text")},e.prototype._mergeStyle=function(t,e){if(!e)return t;var n=e.rich,i=t.rich||n&&{};return I(t,e),n&&i?(this._mergeRich(i,n),t.rich=i):i&&(t.rich=i),t},e.prototype._mergeRich=function(t,e){for(var n=z(e),i=0;i<n.length;i++){var r=n[i];t[r]=t[r]||{},I(t[r],e[r])}},e.prototype.getAnimationStyleProps=function(){return ss},e.prototype._getOrCreateChild=function(t){var e=this._children[this._childCursor];return e&&e instanceof t||(e=new t),this._children[this._childCursor++]=e,e.__zr=this.__zr,e.parent=this,e},e.prototype._updatePlainTexts=function(){var t=this.style,e=t.font||En,n=t.padding,i=function(t,e){null!=t&&(t+="");var n,i=e.overflow,r=e.padding,o=e.font,a="truncate"===i,s=Wn(o),l=tt(e.lineHeight,s),u="truncate"===e.lineOverflow,h=e.width,c=(n=null!=h&&"break"===i||"breakAll"===i?t?go(t,e.font,h,"breakAll"===i,0).lines:[]:t?t.split("\n"):[]).length*l,p=tt(e.height,c);if(c>p&&u){var d=Math.floor(p/l);n=n.slice(0,d)}var f=p,g=h;if(r&&(f+=r[0]+r[2],null!=g&&(g+=r[1]+r[3])),t&&a&&null!=g)for(var y=oo(h,o,e.ellipsis,{minChar:e.truncateMinChar,placeholder:e.placeholder}),v=0;v<n.length;v++)n[v]=ao(n[v],y);if(null==h){var m=0;for(v=0;v<n.length;v++)m=Math.max(Bn(n[v],o),m);h=m}return{lines:n,height:p,outerHeight:f,lineHeight:l,calculatedLineHeight:s,contentHeight:c,width:h}}(fs(t),t),r=gs(t),o=!!t.backgroundColor,a=i.outerHeight,s=i.lines,l=i.lineHeight,u=this._defaultStyle,h=t.x||0,c=t.y||0,p=t.align||u.align||"left",d=t.verticalAlign||u.verticalAlign||"top",f=h,g=Hn(c,i.contentHeight,d);if(r||n){var y=i.width;n&&(y+=n[1]+n[3]);var v=Gn(h,y,p),m=Hn(c,a,d);r&&this._renderBackground(t,t,v,m,y,a)}g+=l/2,n&&(f=ds(h,p,n),"top"===d?g+=n[0]:"bottom"===d&&(g-=n[2]));for(var _,x=0,b=!1,w=(null==(_="fill"in t?t.fill:(b=!0,u.fill))||"none"===_?null:_.image||_.colorStops?"#000":_),S=(ps("stroke"in t?t.stroke:o||u.autoStroke&&!b?null:(x=2,u.stroke))),M=t.textShadowBlur>0,I=null!=t.width&&("truncate"===t.overflow||"break"===t.overflow||"breakAll"===t.overflow),T=i.calculatedLineHeight,C=0;C<s.length;C++){var A=this._getOrCreateChild(qa),D=A.createStyle();A.useStyle(D),D.text=s[C],D.x=f,D.y=g,p&&(D.textAlign=p),D.textBaseline="middle",D.opacity=t.opacity,D.strokeFirst=!0,M&&(D.shadowBlur=t.textShadowBlur||0,D.shadowColor=t.textShadowColor||"transparent",D.shadowOffsetX=t.textShadowOffsetX||0,D.shadowOffsetY=t.textShadowOffsetY||0),S&&(D.stroke=S,D.lineWidth=t.lineWidth||x,D.lineDash=t.lineDash,D.lineDashOffset=t.lineDashOffset||0),w&&(D.fill=w),D.font=e,g+=l,I&&A.setBoundingRect(new Rn(Gn(D.x,t.width,D.textAlign),Hn(D.y,T,D.textBaseline),t.width,T))}},e.prototype._updateRichTexts=function(){var t=this.style,e=function(t,e){var n=new ho;if(null!=t&&(t+=""),!t)return n;for(var i,r=e.width,o=e.height,a=e.overflow,s="break"!==a&&"breakAll"!==a||null==r?null:{width:r,accumWidth:0,breakAll:"breakAll"===a},l=io.lastIndex=0;null!=(i=io.exec(t));){var u=i.index;u>l&&co(n,t.substring(l,u),e,s),co(n,i[2],e,s,i[1]),l=io.lastIndex}l<t.length&&co(n,t.substring(l,t.length),e,s);var h=[],c=0,p=0,d=e.padding,f="truncate"===a,g="truncate"===e.lineOverflow;function y(t,e,n){t.width=e,t.lineHeight=n,c+=n,p=Math.max(p,e)}t:for(var v=0;v<n.lines.length;v++){for(var m=n.lines[v],_=0,x=0,b=0;b<m.tokens.length;b++){var w=(P=m.tokens[b]).styleName&&e.rich[P.styleName]||{},S=P.textPadding=w.padding,M=S?S[1]+S[3]:0,I=P.font=w.font||e.font;P.contentHeight=Wn(I);var T=tt(w.height,P.contentHeight);if(P.innerHeight=T,S&&(T+=S[0]+S[2]),P.height=T,P.lineHeight=et(w.lineHeight,e.lineHeight,T),P.align=w&&w.align||e.align,P.verticalAlign=w&&w.verticalAlign||"middle",g&&null!=o&&c+P.lineHeight>o){b>0?(m.tokens=m.tokens.slice(0,b),y(m,x,_),n.lines=n.lines.slice(0,v+1)):n.lines=n.lines.slice(0,v);break t}var C=w.width,A=null==C||"auto"===C;if("string"==typeof C&&"%"===C.charAt(C.length-1))P.percentWidth=C,h.push(P),P.contentWidth=Bn(P.text,I);else{if(A){var D=w.backgroundColor,L=D&&D.image;L&&no(L=Qr(L))&&(P.width=Math.max(P.width,L.width*T/L.height))}var k=f&&null!=r?r-x:null;null!=k&&k<P.width?!A||k<M?(P.text="",P.width=P.contentWidth=0):(P.text=ro(P.text,k-M,I,e.ellipsis,{minChar:e.truncateMinChar}),P.width=P.contentWidth=Bn(P.text,I)):P.contentWidth=Bn(P.text,I)}P.width+=M,x+=P.width,w&&(_=Math.max(_,P.lineHeight))}y(m,x,_)}for(n.outerWidth=n.width=tt(r,p),n.outerHeight=n.height=tt(o,c),n.contentHeight=c,n.contentWidth=p,d&&(n.outerWidth+=d[1]+d[3],n.outerHeight+=d[0]+d[2]),v=0;v<h.length;v++){var P,O=(P=h[v]).percentWidth;P.width=parseInt(O,10)/100*n.width}return n}(fs(t),t),n=e.width,i=e.outerWidth,r=e.outerHeight,o=t.padding,a=t.x||0,s=t.y||0,l=this._defaultStyle,u=t.align||l.align,h=t.verticalAlign||l.verticalAlign,c=Gn(a,i,u),p=Hn(s,r,h),d=c,f=p;o&&(d+=o[3],f+=o[0]);var g=d+n;gs(t)&&this._renderBackground(t,t,c,p,i,r);for(var y=!!t.backgroundColor,v=0;v<e.lines.length;v++){for(var m=e.lines[v],_=m.tokens,x=_.length,b=m.lineHeight,w=m.width,S=0,M=d,I=g,T=x-1,C=void 0;S<x&&(!(C=_[S]).align||"left"===C.align);)this._placeToken(C,t,b,f,M,"left",y),w-=C.width,M+=C.width,S++;for(;T>=0&&"right"===(C=_[T]).align;)this._placeToken(C,t,b,f,I,"right",y),w-=C.width,I-=C.width,T--;for(M+=(n-(M-d)-(g-I)-w)/2;S<=T;)C=_[S],this._placeToken(C,t,b,f,M+C.width/2,"center",y),M+=C.width,S++;f+=b}},e.prototype._placeToken=function(t,e,n,i,r,o,a){var s=e.rich[t.styleName]||{};s.text=t.text;var l=t.verticalAlign,u=i+n/2;"top"===l?u=i+t.height/2:"bottom"===l&&(u=i+n-t.height/2),!t.isLineHolder&&gs(s)&&this._renderBackground(s,e,"right"===o?r-t.width:"center"===o?r-t.width/2:r,u-t.height/2,t.width,t.height);var h=!!s.backgroundColor,c=t.textPadding;c&&(r=ds(r,o,c),u-=t.height/2-c[0]-t.innerHeight/2);var p=this._getOrCreateChild(qa),d=p.createStyle();p.useStyle(d);var f=this._defaultStyle,g=!1,y=0,v=ps("fill"in s?s.fill:"fill"in e?e.fill:(g=!0,f.fill)),m=ps("stroke"in s?s.stroke:"stroke"in e?e.stroke:h||a||f.autoStroke&&!g?null:(y=2,f.stroke)),_=s.textShadowBlur>0||e.textShadowBlur>0;d.text=t.text,d.x=r,d.y=u,_&&(d.shadowBlur=s.textShadowBlur||e.textShadowBlur||0,d.shadowColor=s.textShadowColor||e.textShadowColor||"transparent",d.shadowOffsetX=s.textShadowOffsetX||e.textShadowOffsetX||0,d.shadowOffsetY=s.textShadowOffsetY||e.textShadowOffsetY||0),d.textAlign=o,d.textBaseline="middle",d.font=t.font||En,d.opacity=et(s.opacity,e.opacity,1),m&&(d.lineWidth=et(s.lineWidth,e.lineWidth,y),d.lineDash=tt(s.lineDash,e.lineDash),d.lineDashOffset=e.lineDashOffset||0,d.stroke=m),v&&(d.fill=v);var x=t.contentWidth,b=t.contentHeight;p.setBoundingRect(new Rn(Gn(d.x,x,d.textAlign),Hn(d.y,b,d.textBaseline),x,b))},e.prototype._renderBackground=function(t,e,n,i,r,o){var a,s,l,u=t.backgroundColor,h=t.borderWidth,c=t.borderColor,p=H(u),d=t.borderRadius,f=this;if(p||h&&c){(a=this._getOrCreateChild(os)).useStyle(a.createStyle()),a.style.fill=null;var g=a.shape;g.x=n,g.y=i,g.width=r,g.height=o,g.r=d,a.dirtyShape()}if(p)(l=a.style).fill=u||null,l.fillOpacity=tt(t.fillOpacity,1);else if(u&&u.image){(s=this._getOrCreateChild(Ja)).onload=function(){f.dirtyStyle()};var y=s.style;y.image=u.image,y.x=n,y.y=i,y.width=r,y.height=o}h&&c&&((l=a.style).lineWidth=h,l.stroke=c,l.strokeOpacity=tt(t.strokeOpacity,1),l.lineDash=t.borderDash,l.lineDashOffset=t.borderDashOffset||0,a.strokeContainThreshold=0,a.hasFill()&&a.hasStroke()&&(l.strokeFirst=!0,l.lineWidth*=2));var v=(a||s).style;v.shadowBlur=t.shadowBlur||0,v.shadowColor=t.shadowColor||"transparent",v.shadowOffsetX=t.shadowOffsetX||0,v.shadowOffsetY=t.shadowOffsetY||0,v.opacity=et(t.opacity,e.opacity,1)},e.makeFont=function(t){var e="";if(t.fontSize||t.fontFamily||t.fontWeight){var n="";n="string"!=typeof t.fontSize||-1===t.fontSize.indexOf("px")&&-1===t.fontSize.indexOf("rem")&&-1===t.fontSize.indexOf("em")?isNaN(+t.fontSize)?"12px":t.fontSize+"px":t.fontSize,e=[t.fontStyle,t.fontWeight,n,t.fontFamily||"sans-serif"].join(" ")}return e&&ot(e)||t.textFont||t.font},e}(xo),us={left:!0,right:1,center:1},hs={top:1,bottom:1,middle:1};function cs(t){if(t){t.font=ls.makeFont(t);var e=t.align;"middle"===e&&(e="center"),t.align=null==e||us[e]?e:"left";var n=t.verticalAlign;"center"===n&&(n="middle"),t.verticalAlign=null==n||hs[n]?n:"top",t.padding&&(t.padding=it(t.padding))}}function ps(t,e){return null==t||e<=0||"transparent"===t||"none"===t?null:t.image||t.colorStops?"#000":t}function ds(t,e,n){return"right"===e?t-n[1]:"center"===e?t+n[3]/2-n[1]/2:t+n[3]}function fs(t){var e=t.text;return null!=e&&(e+=""),e}function gs(t){return!!(t.backgroundColor||t.borderWidth&&t.borderColor)}var ys=Lr(),vs=1,ms={},_s=Lr(),xs=["emphasis","blur","select"],bs=["normal","emphasis","blur","select"],ws="highlight",Ss="downplay",Ms="select",Is="unselect",Ts="toggleSelect";function Cs(t){return null!=t&&"none"!==t}var As=new Ee(100);function Ds(t){if("string"!=typeof t)return t;var e=As.get(t);return e||(e=$e(t,-.1),As.put(t,e)),e}function Ls(t,e,n){t.onHoverStateChange&&(t.hoverState||0)!==n&&t.onHoverStateChange(e),t.hoverState=n}function ks(t){Ls(t,"emphasis",2)}function Ps(t){2===t.hoverState&&Ls(t,"normal",0)}function Os(t){Ls(t,"blur",1)}function Rs(t){1===t.hoverState&&Ls(t,"normal",0)}function Ns(t){t.selected=!0}function Es(t){t.selected=!1}function zs(t,e,n){e(t,n)}function Bs(t,e,n){zs(t,e,n),t.isGroup&&t.traverse((function(t){zs(t,e,n)}))}function Vs(t,e){switch(e){case"emphasis":t.hoverState=2;break;case"normal":t.hoverState=0;break;case"blur":t.hoverState=1;break;case"select":t.selected=!0}}function Fs(t,e){var n=this.states[t];if(this.style){if("emphasis"===t)return function(t,e,n,i){var r=n&&A(n,"select")>=0,o=!1;if(t instanceof Za){var a=_s(t),s=r&&a.selectFill||a.normalFill,l=r&&a.selectStroke||a.normalStroke;if(Cs(s)||Cs(l)){var u=(i=i||{}).style||{};!Cs(u.fill)&&Cs(s)?(o=!0,i=I({},i),(u=I({},u)).fill=Ds(s)):!Cs(u.stroke)&&Cs(l)&&(o||(i=I({},i),u=I({},u)),u.stroke=Ds(l)),i.style=u}}if(i&&null==i.z2){o||(i=I({},i));var h=t.z2EmphasisLift;i.z2=t.z2+(null!=h?h:10)}return i}(this,0,e,n);if("blur"===t)return function(t,e,n){var i=A(t.currentStates,e)>=0,r=t.style.opacity,o=i?null:function(t,e,n,i){for(var r=t.style,o={},a=0;a<e.length;a++){var s=e[a],l=r[s];o[s]=null==l?i&&i[s]:l}for(a=0;a<t.animators.length;a++){var u=t.animators[a];u.__fromStateTransition&&u.__fromStateTransition.indexOf(n)<0&&"style"===u.targetName&&u.saveFinalToTarget(o,e)}return o}(t,["opacity"],e,{opacity:1}),a=(n=n||{}).style||{};return null==a.opacity&&(n=I({},n),a=I({opacity:i?r:.1*o.opacity},a),n.style=a),n}(this,t,n);if("select"===t)return function(t,e,n){if(n&&null==n.z2){n=I({},n);var i=t.z2SelectLift;n.z2=t.z2+(null!=i?i:9)}return n}(this,0,n)}return n}function Gs(t){t.stateProxy=Fs;var e=t.getTextContent(),n=t.getTextGuideLine();e&&(e.stateProxy=Fs),n&&(n.stateProxy=Fs)}function Hs(t,e){t.__highByOuter|=1<<(e||0),Bs(t,ks)}function Ws(t,e){!(t.__highByOuter&=~(1<<(e||0)))&&Bs(t,Ps)}function Ys(t){Bs(t,Os)}function Xs(t){Bs(t,Rs)}function Us(t){Bs(t,Ns)}function Zs(t){Bs(t,Es)}function js(t,e){return t.__highDownSilentOnTouch&&e.zrByTouch}function qs(t,e,n,i,r){var o=i.getModel();function a(t,e){for(var n=0;n<e.length;n++){var i=t.getItemGraphicEl(e[n]);i&&Xs(i)}}if(n=n||"coordinateSystem",r){if(null!=t&&e&&"none"!==e){var s=o.getSeriesByIndex(t),l=s.coordinateSystem;l&&l.master&&(l=l.master);var u=[];o.eachSeries((function(t){var r=s===t,o=t.coordinateSystem;if(o&&o.master&&(o=o.master),!("series"===n&&!r||"coordinateSystem"===n&&!(o&&l?o===l:r)||"series"===e&&r)){if(i.getViewOfSeriesModel(t).group.traverse((function(t){Os(t)})),k(e))a(t.getData(),e);else if(X(e))for(var h=z(e),c=0;c<h.length;c++)a(t.getData(h[c]),e[h[c]]);u.push(t)}})),o.eachComponent((function(t,e){if("series"!==t){var n=i.getViewOfComponentModel(e);n&&n.blurSeries&&n.blurSeries(u,o)}}))}}else!function(t){t.getModel().eachComponent((function(e,n){("series"===e?t.getViewOfSeriesModel(n):t.getViewOfComponentModel(n)).group.traverse((function(t){Rs(t)}))}))}(i)}function Ks(t){P(t.getAllData(),(function(e){var n=e.data,i=e.type;n.eachItemGraphicEl((function(e,n){t.isSelected(n,i)?Us(e):Zs(e)}))}))}function $s(t){var e=[];return t.eachSeries((function(t){P(t.getAllData(),(function(n){n.data;var i=n.type,r=t.getSelectedDataIndices();if(r.length>0){var o={dataIndex:r,seriesIndex:t.seriesIndex};null!=i&&(o.dataType=i),e.push(o)}}))})),e}function Js(t,e,n){il(t,!0),Bs(t,Gs),Qs(t,e,n)}function Qs(t,e,n){var i=ys(t);null!=e?(i.focus=e,i.blurScope=n):i.focus&&(i.focus=null)}var tl=["emphasis","blur","select"],el={itemStyle:"getItemStyle",lineStyle:"getLineStyle",areaStyle:"getAreaStyle"};function nl(t,e,n,i){n=n||"itemStyle";for(var r=0;r<tl.length;r++){var o=tl[r],a=e.getModel([o,n]);t.ensureState(o).style=i?i(a):a[el[n]]()}}function il(t,e){var n=!1===e,i=t;t.highDownSilentOnTouch&&(i.__highDownSilentOnTouch=t.highDownSilentOnTouch),n&&!i.__highDownDispatcher||(i.__highByOuter=i.__highByOuter||0,i.__highDownDispatcher=!n)}function rl(t){return!(!t||!t.__highDownDispatcher)}function ol(t){var e=t.type;return e===Ms||e===Is||e===Ts}function al(t){var e=t.type;return e===ws||e===Ss}var sl=Ca.CMD,ll=[[],[],[]],ul=Math.sqrt,hl=Math.atan2;var cl=Math.sqrt,pl=Math.sin,dl=Math.cos,fl=Math.PI;function gl(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1])}function yl(t,e){return(t[0]*e[0]+t[1]*e[1])/(gl(t)*gl(e))}function vl(t,e){return(t[0]*e[1]<t[1]*e[0]?-1:1)*Math.acos(yl(t,e))}function ml(t,e,n,i,r,o,a,s,l,u,h){var c=l*(fl/180),p=dl(c)*(t-n)/2+pl(c)*(e-i)/2,d=-1*pl(c)*(t-n)/2+dl(c)*(e-i)/2,f=p*p/(a*a)+d*d/(s*s);f>1&&(a*=cl(f),s*=cl(f));var g=(r===o?-1:1)*cl((a*a*(s*s)-a*a*(d*d)-s*s*(p*p))/(a*a*(d*d)+s*s*(p*p)))||0,y=g*a*d/s,v=g*-s*p/a,m=(t+n)/2+dl(c)*y-pl(c)*v,_=(e+i)/2+pl(c)*y+dl(c)*v,x=vl([1,0],[(p-y)/a,(d-v)/s]),b=[(p-y)/a,(d-v)/s],w=[(-1*p-y)/a,(-1*d-v)/s],S=vl(b,w);if(yl(b,w)<=-1&&(S=fl),yl(b,w)>=1&&(S=0),S<0){var M=Math.round(S/fl*1e6)/1e6;S=2*fl+M%2*fl}h.addData(u,m,_,a,s,x,S,c,o)}var _l=/([mlvhzcqtsa])([^mlvhzcqtsa]*)/gi,xl=/-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g;var bl=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.applyTransform=function(t){},e}(Za);function wl(t){return null!=t.setData}function Sl(t,e){var n=function(t){var e=new Ca;if(!t)return e;var n,i=0,r=0,o=i,a=r,s=Ca.CMD,l=t.match(_l);if(!l)return e;for(var u=0;u<l.length;u++){for(var h=l[u],c=h.charAt(0),p=void 0,d=h.match(xl)||[],f=d.length,g=0;g<f;g++)d[g]=parseFloat(d[g]);for(var y=0;y<f;){var v=void 0,m=void 0,_=void 0,x=void 0,b=void 0,w=void 0,S=void 0,M=i,I=r,T=void 0,C=void 0;switch(c){case"l":i+=d[y++],r+=d[y++],p=s.L,e.addData(p,i,r);break;case"L":i=d[y++],r=d[y++],p=s.L,e.addData(p,i,r);break;case"m":i+=d[y++],r+=d[y++],p=s.M,e.addData(p,i,r),o=i,a=r,c="l";break;case"M":i=d[y++],r=d[y++],p=s.M,e.addData(p,i,r),o=i,a=r,c="L";break;case"h":i+=d[y++],p=s.L,e.addData(p,i,r);break;case"H":i=d[y++],p=s.L,e.addData(p,i,r);break;case"v":r+=d[y++],p=s.L,e.addData(p,i,r);break;case"V":r=d[y++],p=s.L,e.addData(p,i,r);break;case"C":p=s.C,e.addData(p,d[y++],d[y++],d[y++],d[y++],d[y++],d[y++]),i=d[y-2],r=d[y-1];break;case"c":p=s.C,e.addData(p,d[y++]+i,d[y++]+r,d[y++]+i,d[y++]+r,d[y++]+i,d[y++]+r),i+=d[y-2],r+=d[y-1];break;case"S":v=i,m=r,T=e.len(),C=e.data,n===s.C&&(v+=i-C[T-4],m+=r-C[T-3]),p=s.C,M=d[y++],I=d[y++],i=d[y++],r=d[y++],e.addData(p,v,m,M,I,i,r);break;case"s":v=i,m=r,T=e.len(),C=e.data,n===s.C&&(v+=i-C[T-4],m+=r-C[T-3]),p=s.C,M=i+d[y++],I=r+d[y++],i+=d[y++],r+=d[y++],e.addData(p,v,m,M,I,i,r);break;case"Q":M=d[y++],I=d[y++],i=d[y++],r=d[y++],p=s.Q,e.addData(p,M,I,i,r);break;case"q":M=d[y++]+i,I=d[y++]+r,i+=d[y++],r+=d[y++],p=s.Q,e.addData(p,M,I,i,r);break;case"T":v=i,m=r,T=e.len(),C=e.data,n===s.Q&&(v+=i-C[T-4],m+=r-C[T-3]),i=d[y++],r=d[y++],p=s.Q,e.addData(p,v,m,i,r);break;case"t":v=i,m=r,T=e.len(),C=e.data,n===s.Q&&(v+=i-C[T-4],m+=r-C[T-3]),i+=d[y++],r+=d[y++],p=s.Q,e.addData(p,v,m,i,r);break;case"A":_=d[y++],x=d[y++],b=d[y++],w=d[y++],S=d[y++],ml(M=i,I=r,i=d[y++],r=d[y++],w,S,_,x,b,p=s.A,e);break;case"a":_=d[y++],x=d[y++],b=d[y++],w=d[y++],S=d[y++],ml(M=i,I=r,i+=d[y++],r+=d[y++],w,S,_,x,b,p=s.A,e)}}"z"!==c&&"Z"!==c||(p=s.Z,e.addData(p),i=o,r=a),n=p}return e.toStatic(),e}(t),i=I({},e);return i.buildPath=function(t){if(wl(t)){t.setData(n.data),(e=t.getContext())&&t.rebuildPath(e,1)}else{var e=t;n.rebuildPath(e,1)}},i.applyTransform=function(t){!function(t,e){var n,i,r,o,a,s,l=t.data,u=t.len(),h=sl.M,c=sl.C,p=sl.L,d=sl.R,f=sl.A,g=sl.Q;for(r=0,o=0;r<u;){switch(n=l[r++],o=r,i=0,n){case h:case p:i=1;break;case c:i=3;break;case g:i=2;break;case f:var y=e[4],v=e[5],m=ul(e[0]*e[0]+e[1]*e[1]),_=ul(e[2]*e[2]+e[3]*e[3]),x=hl(-e[1]/_,e[0]/m);l[r]*=m,l[r++]+=y,l[r]*=_,l[r++]+=v,l[r++]*=m,l[r++]*=_,l[r++]+=x,l[r++]+=x,o=r+=2;break;case d:s[0]=l[r++],s[1]=l[r++],Rt(s,s,e),l[o++]=s[0],l[o++]=s[1],s[0]+=l[r++],s[1]+=l[r++],Rt(s,s,e),l[o++]=s[0],l[o++]=s[1]}for(a=0;a<i;a++){var b=ll[a];b[0]=l[r++],b[1]=l[r++],Rt(b,b,e),l[o++]=b[0],l[o++]=b[1]}}t.increaseVersion()}(n,t),this.dirtyShape()},i}function Ml(t,e){return new bl(Sl(t,e))}var Il=function(){this.cx=0,this.cy=0,this.r=0},Tl=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new Il},e.prototype.buildPath=function(t,e,n){n&&t.moveTo(e.cx+e.r,e.cy),t.arc(e.cx,e.cy,e.r,0,2*Math.PI)},e}(Za);Tl.prototype.type="circle";var Cl=function(){this.cx=0,this.cy=0,this.rx=0,this.ry=0},Al=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new Cl},e.prototype.buildPath=function(t,e){var n=.5522848,i=e.cx,r=e.cy,o=e.rx,a=e.ry,s=o*n,l=a*n;t.moveTo(i-o,r),t.bezierCurveTo(i-o,r-l,i-s,r-a,i,r-a),t.bezierCurveTo(i+s,r-a,i+o,r-l,i+o,r),t.bezierCurveTo(i+o,r+l,i+s,r+a,i,r+a),t.bezierCurveTo(i-s,r+a,i-o,r+l,i-o,r),t.closePath()},e}(Za);Al.prototype.type="ellipse";var Dl=Math.PI,Ll=2*Dl,kl=Math.sin,Pl=Math.cos,Ol=Math.acos,Rl=Math.atan2,Nl=Math.abs,El=Math.sqrt,zl=Math.max,Bl=Math.min,Vl=1e-4;function Fl(t,e,n,i,r,o,a){var s=t-n,l=e-i,u=(a?o:-o)/El(s*s+l*l),h=u*l,c=-u*s,p=t+h,d=e+c,f=n+h,g=i+c,y=(p+f)/2,v=(d+g)/2,m=f-p,_=g-d,x=m*m+_*_,b=r-o,w=p*g-f*d,S=(_<0?-1:1)*El(zl(0,b*b*x-w*w)),M=(w*_-m*S)/x,I=(-w*m-_*S)/x,T=(w*_+m*S)/x,C=(-w*m+_*S)/x,A=M-y,D=I-v,L=T-y,k=C-v;return A*A+D*D>L*L+k*k&&(M=T,I=C),{cx:M,cy:I,x01:-h,y01:-c,x11:M*(r/b-1),y11:I*(r/b-1)}}function Gl(t,e){var n=zl(e.r,0),i=zl(e.r0||0,0),r=n>0;if(r||i>0){if(r||(n=i,i=0),i>n){var o=n;n=i,i=o}var a,s=!!e.clockwise,l=e.startAngle,u=e.endAngle;if(l===u)a=0;else{var h=[l,u];Ta(h,!s),a=Nl(h[0]-h[1])}var c=e.cx,p=e.cy,d=e.cornerRadius||0,f=e.innerCornerRadius||0;if(n>Vl)if(a>Ll-Vl)t.moveTo(c+n*Pl(l),p+n*kl(l)),t.arc(c,p,n,l,u,!s),i>Vl&&(t.moveTo(c+i*Pl(u),p+i*kl(u)),t.arc(c,p,i,u,l,s));else{var g=Nl(n-i)/2,y=Bl(g,d),v=Bl(g,f),m=v,_=y,x=n*Pl(l),b=n*kl(l),w=i*Pl(u),S=i*kl(u),M=void 0,I=void 0,T=void 0,C=void 0;if((y>Vl||v>Vl)&&(M=n*Pl(u),I=n*kl(u),T=i*Pl(l),C=i*kl(l),a<Dl)){var A=function(t,e,n,i,r,o,a,s){var l=n-t,u=i-e,h=a-r,c=s-o,p=c*l-h*u;if(!(p*p<Vl))return[t+(p=(h*(e-o)-c*(t-r))/p)*l,e+p*u]}(x,b,T,C,M,I,w,S);if(A){var D=x-A[0],L=b-A[1],k=M-A[0],P=I-A[1],O=1/kl(Ol((D*k+L*P)/(El(D*D+L*L)*El(k*k+P*P)))/2),R=El(A[0]*A[0]+A[1]*A[1]);m=Bl(v,(i-R)/(O-1)),_=Bl(y,(n-R)/(O+1))}}if(a>Vl)if(_>Vl){var N=Fl(T,C,x,b,n,_,s),E=Fl(M,I,w,S,n,_,s);t.moveTo(c+N.cx+N.x01,p+N.cy+N.y01),_<y?t.arc(c+N.cx,p+N.cy,_,Rl(N.y01,N.x01),Rl(E.y01,E.x01),!s):(t.arc(c+N.cx,p+N.cy,_,Rl(N.y01,N.x01),Rl(N.y11,N.x11),!s),t.arc(c,p,n,Rl(N.cy+N.y11,N.cx+N.x11),Rl(E.cy+E.y11,E.cx+E.x11),!s),t.arc(c+E.cx,p+E.cy,_,Rl(E.y11,E.x11),Rl(E.y01,E.x01),!s))}else t.moveTo(c+x,p+b),t.arc(c,p,n,l,u,!s);else t.moveTo(c+x,p+b);if(i>Vl&&a>Vl)if(m>Vl){N=Fl(w,S,M,I,i,-m,s),E=Fl(x,b,T,C,i,-m,s);t.lineTo(c+N.cx+N.x01,p+N.cy+N.y01),m<v?t.arc(c+N.cx,p+N.cy,m,Rl(N.y01,N.x01),Rl(E.y01,E.x01),!s):(t.arc(c+N.cx,p+N.cy,m,Rl(N.y01,N.x01),Rl(N.y11,N.x11),!s),t.arc(c,p,i,Rl(N.cy+N.y11,N.cx+N.x11),Rl(E.cy+E.y11,E.cx+E.x11),s),t.arc(c+E.cx,p+E.cy,m,Rl(E.y11,E.x11),Rl(E.y01,E.x01),!s))}else t.lineTo(c+w,p+S),t.arc(c,p,i,u,l,s);else t.lineTo(c+w,p+S)}else t.moveTo(c,p);t.closePath()}}var Hl=function(){this.cx=0,this.cy=0,this.r0=0,this.r=0,this.startAngle=0,this.endAngle=2*Math.PI,this.clockwise=!0,this.cornerRadius=0,this.innerCornerRadius=0},Wl=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new Hl},e.prototype.buildPath=function(t,e){Gl(t,e)},e.prototype.isZeroArea=function(){return this.shape.startAngle===this.shape.endAngle||this.shape.r===this.shape.r0},e}(Za);Wl.prototype.type="sector";var Yl=function(){this.cx=0,this.cy=0,this.r=0,this.r0=0},Xl=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new Yl},e.prototype.buildPath=function(t,e){var n=e.cx,i=e.cy,r=2*Math.PI;t.moveTo(n+e.r,i),t.arc(n,i,e.r,0,r,!1),t.moveTo(n+e.r0,i),t.arc(n,i,e.r0,0,r,!0)},e}(Za);function Ul(t,e,n,i,r,o,a){var s=.5*(n-t),l=.5*(i-e);return(2*(e-n)+s+l)*a+(-3*(e-n)-2*s-l)*o+s*r+e}function Zl(t,e,n){var i=e.smooth,r=e.points;if(r&&r.length>=2){if(i&&"spline"!==i){var o=function(t,e,n,i){var r,o,a,s,l=[],u=[],h=[],c=[];if(i){a=[1/0,1/0],s=[-1/0,-1/0];for(var p=0,d=t.length;p<d;p++)Nt(a,a,t[p]),Et(s,s,t[p]);Nt(a,a,i[0]),Et(s,s,i[1])}for(p=0,d=t.length;p<d;p++){var f=t[p];if(n)r=t[p?p-1:d-1],o=t[(p+1)%d];else{if(0===p||p===d-1){l.push(mt(t[p]));continue}r=t[p-1],o=t[p+1]}wt(u,o,r),Ct(u,u,e);var g=Dt(f,r),y=Dt(f,o),v=g+y;0!==v&&(g/=v,y/=v),Ct(h,u,-g),Ct(c,u,y);var m=xt([],f,h),_=xt([],f,c);i&&(Et(m,m,a),Nt(m,m,s),Et(_,_,a),Nt(_,_,s)),l.push(m),l.push(_)}return n&&l.push(l.shift()),l}(r,i,n,e.smoothConstraint);t.moveTo(r[0][0],r[0][1]);for(var a=r.length,s=0;s<(n?a:a-1);s++){var l=o[2*s],u=o[2*s+1],h=r[(s+1)%a];t.bezierCurveTo(l[0],l[1],u[0],u[1],h[0],h[1])}}else{"spline"===i&&(r=function(t,e){for(var n=t.length,i=[],r=0,o=1;o<n;o++)r+=Dt(t[o-1],t[o]);var a=r/2;for(a=a<n?n:a,o=0;o<a;o++){var s=o/(a-1)*(e?n:n-1),l=Math.floor(s),u=s-l,h=void 0,c=t[l%n],p=void 0,d=void 0;e?(h=t[(l-1+n)%n],p=t[(l+1)%n],d=t[(l+2)%n]):(h=t[0===l?l:l-1],p=t[l>n-2?n-1:l+1],d=t[l>n-3?n-1:l+2]);var f=u*u,g=u*f;i.push([Ul(h[0],c[0],p[0],d[0],u,f,g),Ul(h[1],c[1],p[1],d[1],u,f,g)])}return i}(r,n)),t.moveTo(r[0][0],r[0][1]);s=1;for(var c=r.length;s<c;s++)t.lineTo(r[s][0],r[s][1])}n&&t.closePath()}}Xl.prototype.type="ring";var jl=function(){this.points=null,this.smooth=0,this.smoothConstraint=null},ql=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new jl},e.prototype.buildPath=function(t,e){Zl(t,e,!0)},e}(Za);ql.prototype.type="polygon";var Kl=function(){this.points=null,this.percent=1,this.smooth=0,this.smoothConstraint=null},$l=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new Kl},e.prototype.buildPath=function(t,e){Zl(t,e,!1)},e}(Za);$l.prototype.type="polyline";var Jl={},Ql=function(){this.x1=0,this.y1=0,this.x2=0,this.y2=0,this.percent=1},tu=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new Ql},e.prototype.buildPath=function(t,e){var n,i,r,o;if(this.subPixelOptimize){var a=ts(Jl,e,this.style);n=a.x1,i=a.y1,r=a.x2,o=a.y2}else n=e.x1,i=e.y1,r=e.x2,o=e.y2;var s=e.percent;0!==s&&(t.moveTo(n,i),s<1&&(r=n*(1-s)+r*s,o=i*(1-s)+o*s),t.lineTo(r,o))},e.prototype.pointAt=function(t){var e=this.shape;return[e.x1*(1-t)+e.x2*t,e.y1*(1-t)+e.y2*t]},e}(Za);tu.prototype.type="line";var eu=[],nu=function(){this.x1=0,this.y1=0,this.x2=0,this.y2=0,this.cpx1=0,this.cpy1=0,this.percent=1};function iu(t,e,n){var i=t.cpx2,r=t.cpy2;return null===i||null===r?[(n?No:Ro)(t.x1,t.cpx1,t.cpx2,t.x2,e),(n?No:Ro)(t.y1,t.cpy1,t.cpy2,t.y2,e)]:[(n?Ho:Go)(t.x1,t.cpx1,t.x2,e),(n?Ho:Go)(t.y1,t.cpy1,t.y2,e)]}var ru=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new nu},e.prototype.buildPath=function(t,e){var n=e.x1,i=e.y1,r=e.x2,o=e.y2,a=e.cpx1,s=e.cpy1,l=e.cpx2,u=e.cpy2,h=e.percent;0!==h&&(t.moveTo(n,i),null==l||null==u?(h<1&&(Yo(n,a,r,h,eu),a=eu[1],r=eu[2],Yo(i,s,o,h,eu),s=eu[1],o=eu[2]),t.quadraticCurveTo(a,s,r,o)):(h<1&&(Bo(n,a,l,r,h,eu),a=eu[1],l=eu[2],r=eu[3],Bo(i,s,u,o,h,eu),s=eu[1],u=eu[2],o=eu[3]),t.bezierCurveTo(a,s,l,u,r,o)))},e.prototype.pointAt=function(t){return iu(this.shape,t,!1)},e.prototype.tangentAt=function(t){var e=iu(this.shape,t,!0);return At(e,e)},e}(Za);ru.prototype.type="bezier-curve";var ou=function(){this.cx=0,this.cy=0,this.r=0,this.startAngle=0,this.endAngle=2*Math.PI,this.clockwise=!0},au=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new ou},e.prototype.buildPath=function(t,e){var n=e.cx,i=e.cy,r=Math.max(e.r,0),o=e.startAngle,a=e.endAngle,s=e.clockwise,l=Math.cos(o),u=Math.sin(o);t.moveTo(l*r+n,u*r+i),t.arc(n,i,r,o,a,!s)},e}(Za);au.prototype.type="arc";var su=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="compound",e}return n(e,t),e.prototype._updatePathDirty=function(){for(var t=this.shape.paths,e=this.shapeChanged(),n=0;n<t.length;n++)e=e||t[n].shapeChanged();e&&this.dirtyShape()},e.prototype.beforeBrush=function(){this._updatePathDirty();for(var t=this.shape.paths||[],e=this.getGlobalScale(),n=0;n<t.length;n++)t[n].path||t[n].createPathProxy(),t[n].path.setScale(e[0],e[1],t[n].segmentIgnoreThreshold)},e.prototype.buildPath=function(t,e){for(var n=e.paths||[],i=0;i<n.length;i++)n[i].buildPath(t,n[i].shape,!0)},e.prototype.afterBrush=function(){for(var t=this.shape.paths||[],e=0;e<t.length;e++)t[e].pathUpdated()},e.prototype.getBoundingRect=function(){return this._updatePathDirty.call(this),Za.prototype.getBoundingRect.call(this)},e}(Za),lu=function(){function t(t){this.colorStops=t||[]}return t.prototype.addColorStop=function(t,e){this.colorStops.push({offset:t,color:e})},t}(),uu=function(t){function e(e,n,i,r,o,a){var s=t.call(this,o)||this;return s.x=null==e?0:e,s.y=null==n?0:n,s.x2=null==i?1:i,s.y2=null==r?0:r,s.type="linear",s.global=a||!1,s}return n(e,t),e}(lu),hu=function(t){function e(e,n,i,r,o){var a=t.call(this,r)||this;return a.x=null==e?.5:e,a.y=null==n?.5:n,a.r=null==i?.5:i,a.type="radial",a.global=o||!1,a}return n(e,t),e}(lu),cu=[0,0],pu=[0,0],du=new In,fu=new In,gu=function(){function t(t,e){this._corners=[],this._axes=[],this._origin=[0,0];for(var n=0;n<4;n++)this._corners[n]=new In;for(n=0;n<2;n++)this._axes[n]=new In;t&&this.fromBoundingRect(t,e)}return t.prototype.fromBoundingRect=function(t,e){var n=this._corners,i=this._axes,r=t.x,o=t.y,a=r+t.width,s=o+t.height;if(n[0].set(r,o),n[1].set(a,o),n[2].set(a,s),n[3].set(r,s),e)for(var l=0;l<4;l++)n[l].transform(e);In.sub(i[0],n[1],n[0]),In.sub(i[1],n[3],n[0]),i[0].normalize(),i[1].normalize();for(l=0;l<2;l++)this._origin[l]=i[l].dot(n[0])},t.prototype.intersect=function(t,e){var n=!0,i=!e;return du.set(1/0,1/0),fu.set(0,0),!this._intersectCheckOneSide(this,t,du,fu,i,1)&&(n=!1,i)||!this._intersectCheckOneSide(t,this,du,fu,i,-1)&&(n=!1,i)||i||In.copy(e,n?du:fu),n},t.prototype._intersectCheckOneSide=function(t,e,n,i,r,o){for(var a=!0,s=0;s<2;s++){var l=this._axes[s];if(this._getProjMinMaxOnAxis(s,t._corners,cu),this._getProjMinMaxOnAxis(s,e._corners,pu),cu[1]<pu[0]||cu[0]>pu[1]){if(a=!1,r)return a;var u=Math.abs(pu[0]-cu[1]),h=Math.abs(cu[0]-pu[1]);Math.min(u,h)>i.len()&&(u<h?In.scale(i,l,-u*o):In.scale(i,l,h*o))}else if(n){u=Math.abs(pu[0]-cu[1]),h=Math.abs(cu[0]-pu[1]);Math.min(u,h)<n.len()&&(u<h?In.scale(n,l,u*o):In.scale(n,l,-h*o))}}return a},t.prototype._getProjMinMaxOnAxis=function(t,e,n){for(var i=this._axes[t],r=this._origin,o=e[0].dot(i)+r[t],a=o,s=o,l=1;l<e.length;l++){var u=e[l].dot(i)+r[t];a=Math.min(u,a),s=Math.max(u,s)}n[0]=a,n[1]=s},t}(),yu=[],vu=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.notClear=!0,e.incremental=!0,e._displayables=[],e._temporaryDisplayables=[],e._cursor=0,e}return n(e,t),e.prototype.traverse=function(t,e){t.call(e,this)},e.prototype.useStyle=function(){this.style={}},e.prototype.getCursor=function(){return this._cursor},e.prototype.innerAfterBrush=function(){this._cursor=this._displayables.length},e.prototype.clearDisplaybles=function(){this._displayables=[],this._temporaryDisplayables=[],this._cursor=0,this.markRedraw(),this.notClear=!1},e.prototype.clearTemporalDisplayables=function(){this._temporaryDisplayables=[]},e.prototype.addDisplayable=function(t,e){e?this._temporaryDisplayables.push(t):this._displayables.push(t),this.markRedraw()},e.prototype.addDisplayables=function(t,e){e=e||!1;for(var n=0;n<t.length;n++)this.addDisplayable(t[n],e)},e.prototype.getDisplayables=function(){return this._displayables},e.prototype.getTemporalDisplayables=function(){return this._temporaryDisplayables},e.prototype.eachPendingDisplayable=function(t){for(var e=this._cursor;e<this._displayables.length;e++)t&&t(this._displayables[e]);for(e=0;e<this._temporaryDisplayables.length;e++)t&&t(this._temporaryDisplayables[e])},e.prototype.update=function(){this.updateTransform();for(var t=this._cursor;t<this._displayables.length;t++){(e=this._displayables[t]).parent=this,e.update(),e.parent=null}for(t=0;t<this._temporaryDisplayables.length;t++){var e;(e=this._temporaryDisplayables[t]).parent=this,e.update(),e.parent=null}},e.prototype.getBoundingRect=function(){if(!this._rect){for(var t=new Rn(1/0,1/0,-1/0,-1/0),e=0;e<this._displayables.length;e++){var n=this._displayables[e],i=n.getBoundingRect().clone();n.needLocalTransform()&&i.applyTransform(n.getLocalTransform(yu)),t.union(i)}this._rect=t}return this._rect},e.prototype.contain=function(t,e){var n=this.transformCoordToLocal(t,e);if(this.getBoundingRect().contain(n[0],n[1]))for(var i=0;i<this._displayables.length;i++){if(this._displayables[i].contain(t,e))return!0}return!1},e}(xo),mu=Math.max,_u=Math.min,xu={};function bu(t){return Za.extend(t)}var wu=function(t,e){var i=Sl(t,e);return function(t){function e(e){var n=t.call(this,e)||this;return n.applyTransform=i.applyTransform,n.buildPath=i.buildPath,n}return n(e,t),e}(bl)};function Su(t,e){return wu(t,e)}function Mu(t,e){xu[t]=e}function Iu(t){if(xu.hasOwnProperty(t))return xu[t]}function Tu(t,e,n,i){var r=Ml(t,e);return n&&("center"===i&&(n=Au(n,r.getBoundingRect())),Lu(r,n)),r}function Cu(t,e,n){var i=new Ja({style:{image:t,x:e.x,y:e.y,width:e.width,height:e.height},onload:function(t){if("center"===n){var r={width:t.width,height:t.height};i.setStyle(Au(e,r))}}});return i}function Au(t,e){var n,i=e.width/e.height,r=t.height*i;return n=r<=t.width?t.height:(r=t.width)/i,{x:t.x+t.width/2-r/2,y:t.y+t.height/2-n/2,width:r,height:n}}var Du=function(t,e){for(var n=[],i=t.length,r=0;r<i;r++){var o=t[r];o.path||o.createPathProxy(),o.shapeChanged()&&o.buildPath(o.path,o.shape,!0),n.push(o.path)}var a=new Za(e);return a.createPathProxy(),a.buildPath=function(t){if(wl(t)){t.appendPath(n);var e=t.getContext();e&&t.rebuildPath(e,1)}},a};function Lu(t,e){if(t.applyTransform){var n=t.getBoundingRect().calculateTransform(e);t.applyTransform(n)}}var ku=ns;function Pu(t,e,n,i,r,o,a){var s,l=!1;"function"==typeof r?(a=o,o=r,r=null):X(r)&&(o=r.cb,a=r.during,l=r.isFrom,s=r.removeOpt,r=r.dataIndex);var u,h="update"===t,c="remove"===t;if(i&&i.ecModel){var p=i.ecModel.getUpdatePayload();u=p&&p.animation}var d=i&&i.isAnimationEnabled();if(c||e.stopAnimation("remove"),d){var f=void 0,g=void 0,y=void 0;u?(f=u.duration||0,g=u.easing||"cubicOut",y=u.delay||0):c?(f=tt((s=s||{}).duration,200),g=tt(s.easing,"cubicOut"),y=0):(f=i.getShallow(h?"animationDurationUpdate":"animationDuration"),g=i.getShallow(h?"animationEasingUpdate":"animationEasing"),y=i.getShallow(h?"animationDelayUpdate":"animationDelay")),"function"==typeof y&&(y=y(r,i.getAnimationDelayParams?i.getAnimationDelayParams(e,r):null)),"function"==typeof f&&(f=f(r)),f>0?l?e.animateFrom(n,{duration:f,delay:y||0,easing:g,done:o,force:!!o||!!a,scope:t,during:a}):e.animateTo(n,{duration:f,delay:y||0,easing:g,done:o,force:!!o||!!a,setToFinal:!0,scope:t,during:a}):(e.stopAnimation(),!l&&e.attr(n),o&&o())}else e.stopAnimation(),!l&&e.attr(n),a&&a(1),o&&o()}function Ou(t,e,n,i,r,o){Pu("update",t,e,n,i,r,o)}function Ru(t,e,n,i,r,o){Pu("init",t,e,n,i,r,o)}function Nu(t,e,n,i,r,o){Bu(t)||Pu("remove",t,e,n,i,r,o)}function Eu(t,e,n,i){t.removeTextContent(),t.removeTextGuideLine(),Nu(t,{style:{opacity:0}},e,n,i)}function zu(t,e,n){function i(){t.parent&&t.parent.remove(t)}t.isGroup?t.traverse((function(t){t.isGroup||Eu(t,e,n,i)})):Eu(t,e,n,i)}function Bu(t){if(!t.__zr)return!0;for(var e=0;e<t.animators.length;e++){if("remove"===t.animators[e].scope)return!0}return!1}function Vu(t,e){for(var n=ge([]);t&&t!==e;)ve(n,t.getLocalTransform(),n),t=t.parent;return n}function Fu(t,e,n){return e&&!k(e)&&(e=ke.getLocalTransform(e)),n&&(e=be([],e)),Rt([],t,e)}function Gu(t,e,n){var i=0===e[4]||0===e[5]||0===e[0]?1:Math.abs(2*e[4]/e[0]),r=0===e[4]||0===e[5]||0===e[2]?1:Math.abs(2*e[4]/e[2]),o=["left"===t?-i:"right"===t?i:0,"top"===t?-r:"bottom"===t?r:0];return o=Fu(o,e,n),Math.abs(o[0])>Math.abs(o[1])?o[0]>0?"right":"left":o[1]>0?"bottom":"top"}function Hu(t){return!t.isGroup}function Wu(t,e,n){if(t&&e){var i,r=(i={},t.traverse((function(t){Hu(t)&&t.anid&&(i[t.anid]=t)})),i);e.traverse((function(t){if(Hu(t)&&t.anid){var e=r[t.anid];if(e){var i=o(t);t.attr(o(e)),Ou(t,i,n,ys(t).dataIndex)}}}))}function o(t){var e={x:t.x,y:t.y,rotation:t.rotation};return function(t){return null!=t.shape}(t)&&(e.shape=I({},t.shape)),e}}function Yu(t,e){return O(t,(function(t){var n=t[0];n=mu(n,e.x),n=_u(n,e.x+e.width);var i=t[1];return i=mu(i,e.y),[n,i=_u(i,e.y+e.height)]}))}function Xu(t,e){var n=mu(t.x,e.x),i=_u(t.x+t.width,e.x+e.width),r=mu(t.y,e.y),o=_u(t.y+t.height,e.y+e.height);if(i>=n&&o>=r)return{x:n,y:r,width:i-n,height:o-r}}function Uu(t,e,n){var i=I({rectHover:!0},e),r=i.style={strokeNoScale:!0};if(n=n||{x:-1,y:-1,width:2,height:2},t)return 0===t.indexOf("image://")?(r.image=t.slice(8),T(r,n),new Ja(i)):Tu(t.replace("path://",""),i,n,"center")}function Zu(t,e,n,i,r){for(var o=0,a=r[r.length-1];o<r.length;o++){var s=r[o];if(ju(t,e,n,i,s[0],s[1],a[0],a[1]))return!0;a=s}}function ju(t,e,n,i,r,o,a,s){var l,u=n-t,h=i-e,c=a-r,p=s-o,d=qu(c,p,u,h);if((l=d)<=1e-6&&l>=-1e-6)return!1;var f=t-r,g=e-o,y=qu(f,g,u,h)/d;if(y<0||y>1)return!1;var v=qu(f,g,c,p)/d;return!(v<0||v>1)}function qu(t,e,n,i){return t*i-n*e}Mu("circle",Tl),Mu("ellipse",Al),Mu("sector",Wl),Mu("ring",Xl),Mu("polygon",ql),Mu("polyline",$l),Mu("rect",os),Mu("line",tu),Mu("bezierCurve",ru),Mu("arc",au);var Ku=Object.freeze({__proto__:null,extendShape:bu,extendPath:Su,registerShape:Mu,getShapeClass:Iu,makePath:Tu,makeImage:Cu,mergePath:Du,resizePath:Lu,subPixelOptimizeLine:function(t){return ts(t.shape,t.shape,t.style),t},subPixelOptimizeRect:function(t){return es(t.shape,t.shape,t.style),t},subPixelOptimize:ku,updateProps:Ou,initProps:Ru,removeElement:Nu,removeElementWithFadeOut:zu,isElementRemoved:Bu,getTransform:Vu,applyTransform:Fu,transformDirection:Gu,groupTransition:Wu,clipPointsByRect:Yu,clipRectByRect:Xu,createIcon:Uu,linePolygonIntersect:Zu,lineLineIntersect:ju,Group:zi,Image:Ja,Text:ls,Circle:Tl,Ellipse:Al,Sector:Wl,Ring:Xl,Polygon:ql,Polyline:$l,Rect:os,Line:tu,BezierCurve:ru,Arc:au,IncrementalDisplayable:vu,CompoundPath:su,LinearGradient:uu,RadialGradient:hu,BoundingRect:Rn,OrientedBoundingRect:gu,Point:In,Path:Za}),$u={};function Ju(t,e){for(var n=0;n<xs.length;n++){var i=xs[n],r=e[i],o=t.ensureState(i);o.style=o.style||{},o.style.text=r}var a=t.currentStates.slice();t.clearStates(!0),t.setStyle({text:e.normal}),t.useStates(a,!0)}function Qu(t,e,n){var i,r=t.labelFetcher,o=t.labelDataIndex,a=t.labelDimIndex,s=e.normal;r&&(i=r.getFormattedLabel(o,"normal",null,a,s&&s.get("formatter"),null!=n?{interpolatedValue:n}:null)),null==i&&(i=G(t.defaultText)?t.defaultText(o,t,n):t.defaultText);for(var l={normal:i},u=0;u<xs.length;u++){var h=xs[u],c=e[h];l[h]=tt(r?r.getFormattedLabel(o,h,null,a,c&&c.get("formatter")):null,i)}return l}function th(t,e,n,i){n=n||$u;for(var r=t instanceof ls,o=!1,a=0;a<bs.length;a++){if((p=e[bs[a]])&&p.getShallow("show")){o=!0;break}}var s=r?t:t.getTextContent();if(o){r||(s||(s=new ls,t.setTextContent(s)),t.stateProxy&&(s.stateProxy=t.stateProxy));var l=Qu(n,e),u=e.normal,h=!!u.getShallow("show"),c=nh(u,i&&i.normal,n,!1,!r);c.text=l.normal,r||t.setTextConfig(ih(u,n,!1));for(a=0;a<xs.length;a++){var p,d=xs[a];if(p=e[d]){var f=s.ensureState(d),g=!!tt(p.getShallow("show"),h);if(g!==h&&(f.ignore=!g),f.style=nh(p,i&&i[d],n,!0,!r),f.style.text=l[d],!r)t.ensureState(d).textConfig=ih(p,n,!0)}}s.silent=!!u.getShallow("silent"),null!=s.style.x&&(c.x=s.style.x),null!=s.style.y&&(c.y=s.style.y),s.ignore=!h,s.useStyle(c),s.dirty(),n.enableTextSetter&&(uh(s).setLabelText=function(t){var i=Qu(n,e,t);Ju(s,i)})}else s&&(s.ignore=!0);t.dirty()}function eh(t,e){e=e||"label";for(var n={normal:t.getModel(e)},i=0;i<xs.length;i++){var r=xs[i];n[r]=t.getModel([r,e])}return n}function nh(t,e,n,i,r){var o={};return function(t,e,n,i,r){n=n||$u;var o,a=e.ecModel,s=a&&a.option.textStyle,l=function(t){var e;for(;t&&t!==t.ecModel;){var n=(t.option||$u).rich;if(n){e=e||{};for(var i=z(n),r=0;r<i.length;r++){e[i[r]]=1}}t=t.parentModel}return e}(e);if(l)for(var u in o={},l)if(l.hasOwnProperty(u)){var h=e.getModel(["rich",u]);sh(o[u]={},h,s,n,i,r,!1,!0)}o&&(t.rich=o);var c=e.get("overflow");c&&(t.overflow=c);var p=e.get("minMargin");null!=p&&(t.margin=p);sh(t,e,s,n,i,r,!0,!1)}(o,t,n,i,r),e&&I(o,e),o}function ih(t,e,n){e=e||{};var i,r={},o=t.getShallow("rotate"),a=tt(t.getShallow("distance"),n?null:5),s=t.getShallow("offset");return"outside"===(i=t.getShallow("position")||(n?null:"inside"))&&(i=e.defaultOutsidePosition||"top"),null!=i&&(r.position=i),null!=s&&(r.offset=s),null!=o&&(o*=Math.PI/180,r.rotation=o),null!=a&&(r.distance=a),r.outsideFill="inherit"===t.get("color")?e.inheritColor||null:"auto",r}var rh=["fontStyle","fontWeight","fontSize","fontFamily","textShadowColor","textShadowBlur","textShadowOffsetX","textShadowOffsetY"],oh=["align","lineHeight","width","height","tag","verticalAlign"],ah=["padding","borderWidth","borderRadius","borderDashOffset","backgroundColor","borderColor","shadowColor","shadowBlur","shadowOffsetX","shadowOffsetY"];function sh(t,e,n,i,r,o,a,s){n=!r&&n||$u;var l=i&&i.inheritColor,u=e.getShallow("color"),h=e.getShallow("textBorderColor"),c=tt(e.getShallow("opacity"),n.opacity);"inherit"!==u&&"auto"!==u||(u=l||null),"inherit"!==h&&"auto"!==h||(h=l||null),o||(u=u||n.color,h=h||n.textBorderColor),null!=u&&(t.fill=u),null!=h&&(t.stroke=h);var p=tt(e.getShallow("textBorderWidth"),n.textBorderWidth);null!=p&&(t.lineWidth=p);var d=tt(e.getShallow("textBorderType"),n.textBorderType);null!=d&&(t.lineDash=d);var f=tt(e.getShallow("textBorderDashOffset"),n.textBorderDashOffset);null!=f&&(t.lineDashOffset=f),r||null!=c||s||(c=i&&i.defaultOpacity),null!=c&&(t.opacity=c),r||o||null==t.fill&&i.inheritColor&&(t.fill=i.inheritColor);for(var g=0;g<rh.length;g++){var y=rh[g];null!=(m=tt(e.getShallow(y),n[y]))&&(t[y]=m)}for(g=0;g<oh.length;g++){y=oh[g];null!=(m=e.getShallow(y))&&(t[y]=m)}if(null==t.verticalAlign){var v=e.getShallow("baseline");null!=v&&(t.verticalAlign=v)}if(!a||!i.disableBox){for(g=0;g<ah.length;g++){var m;y=ah[g];null!=(m=e.getShallow(y))&&(t[y]=m)}var _=e.getShallow("borderType");null!=_&&(t.borderDash=_),"auto"!==t.backgroundColor&&"inherit"!==t.backgroundColor||!l||(t.backgroundColor=l),"auto"!==t.borderColor&&"inherit"!==t.borderColor||!l||(t.borderColor=l)}}function lh(t,e){var n=e&&e.getModel("textStyle");return ot([t.fontStyle||n&&n.getShallow("fontStyle")||"",t.fontWeight||n&&n.getShallow("fontWeight")||"",(t.fontSize||n&&n.getShallow("fontSize")||12)+"px",t.fontFamily||n&&n.getShallow("fontFamily")||"sans-serif"].join(" "))}var uh=Lr();function hh(t,e,n,i){if(t){var r=uh(t);r.prevValue=r.value,r.value=n;var o=e.normal;r.valueAnimation=o.get("valueAnimation"),r.valueAnimation&&(r.precision=o.get("precision"),r.defaultInterpolatedText=i,r.statesModels=e)}}function ch(t,e,n,i,r){var o=uh(t);if(o.valueAnimation){var a=o.defaultInterpolatedText,s=tt(o.interpolatedValue,o.prevValue),l=o.value;(null==s?Ru:Ou)(t,{},i,e,null,(function(i){var u=Br(n,o.precision,s,l,i);o.interpolatedValue=1===i?null:u;var h=Qu({labelDataIndex:e,labelFetcher:r,defaultText:a?a(u):u+""},o.statesModels,u);Ju(t,h)}))}}var ph,dh,fh=["textStyle","color"],gh=new ls,yh=function(){function t(){}return t.prototype.getTextColor=function(t){var e=this.ecModel;return this.getShallow("color")||(!t&&e?e.get(fh):null)},t.prototype.getFont=function(){return lh({fontStyle:this.getShallow("fontStyle"),fontWeight:this.getShallow("fontWeight"),fontSize:this.getShallow("fontSize"),fontFamily:this.getShallow("fontFamily")},this.ecModel)},t.prototype.getTextRect=function(t){return gh.useStyle({text:t,fontStyle:this.getShallow("fontStyle"),fontWeight:this.getShallow("fontWeight"),fontSize:this.getShallow("fontSize"),fontFamily:this.getShallow("fontFamily"),verticalAlign:this.getShallow("verticalAlign")||this.getShallow("baseline"),padding:this.getShallow("padding"),lineHeight:this.getShallow("lineHeight"),rich:this.getShallow("rich")}),gh.update(),gh.getBoundingRect()},t}(),vh=[["lineWidth","width"],["stroke","color"],["opacity"],["shadowBlur"],["shadowOffsetX"],["shadowOffsetY"],["shadowColor"],["lineDash","type"],["lineDashOffset","dashOffset"],["lineCap","cap"],["lineJoin","join"],["miterLimit"]],mh=qr(vh),_h=function(){function t(){}return t.prototype.getLineStyle=function(t){return mh(this,t)},t}(),xh=[["fill","color"],["stroke","borderColor"],["lineWidth","borderWidth"],["opacity"],["shadowBlur"],["shadowOffsetX"],["shadowOffsetY"],["shadowColor"],["lineDash","borderType"],["lineDashOffset","borderDashOffset"],["lineCap","borderCap"],["lineJoin","borderJoin"],["miterLimit","borderMiterLimit"]],bh=qr(xh),wh=function(){function t(){}return t.prototype.getItemStyle=function(t,e){return bh(this,t,e)},t}(),Sh=function(){function t(t,e,n){this.parentModel=e,this.ecModel=n,this.option=t}return t.prototype.init=function(t,e,n){for(var i=[],r=3;r<arguments.length;r++)i[r-3]=arguments[r]},t.prototype.mergeOption=function(t,e){S(this.option,t,!0)},t.prototype.get=function(t,e){return null==t?this.option:this._doGet(this.parsePath(t),!e&&this.parentModel)},t.prototype.getShallow=function(t,e){var n=this.option,i=null==n?n:n[t];if(null==i&&!e){var r=this.parentModel;r&&(i=r.getShallow(t))}return i},t.prototype.getModel=function(e,n){var i=null!=e,r=i?this.parsePath(e):null;return new t(i?this._doGet(r):this.option,n=n||this.parentModel&&this.parentModel.getModel(this.resolveParentPath(r)),this.ecModel)},t.prototype.isEmpty=function(){return null==this.option},t.prototype.restoreData=function(){},t.prototype.clone=function(){return new(0,this.constructor)(w(this.option))},t.prototype.parsePath=function(t){return"string"==typeof t?t.split("."):t},t.prototype.resolveParentPath=function(t){return t},t.prototype.isAnimationEnabled=function(){if(!a.node&&this.option){if(null!=this.option.animation)return!!this.option.animation;if(this.parentModel)return this.parentModel.isAnimationEnabled()}},t.prototype._doGet=function(t,e){var n=this.option;if(!t)return n;for(var i=0;i<t.length&&(!t[i]||null!=(n=n&&"object"==typeof n?n[t[i]]:null));i++);return null==n&&e&&(n=e._doGet(this.resolveParentPath(t),e.parentModel)),n},t}();Hr(Sh),ph=Sh,dh=["__\0is_clz",Xr++].join("_"),ph.prototype[dh]=!0,ph.isInstance=function(t){return!(!t||!t[dh])},L(Sh,_h),L(Sh,wh),L(Sh,$r),L(Sh,yh);var Mh=Math.round(10*Math.random());function Ih(t){return[t||"",Mh++].join("_")}function Th(t,e){return S(S({},t,!0),e,!0)}var Ch="ZH",Ah="EN",Dh=Ah,Lh={},kh={},Ph=a.domSupported&&(document.documentElement.lang||navigator.language||navigator.browserLanguage).toUpperCase().indexOf(Ch)>-1?Ch:Dh;function Oh(t,e){t=t.toUpperCase(),kh[t]=new Sh(e),Lh[t]=e}Oh(Ah,{time:{month:["January","February","March","April","May","June","July","August","September","October","November","December"],monthAbbr:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayOfWeek:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayOfWeekAbbr:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]},legend:{selector:{all:"All",inverse:"Inv"}},toolbox:{brush:{title:{rect:"Box Select",polygon:"Lasso Select",lineX:"Horizontally Select",lineY:"Vertically Select",keep:"Keep Selections",clear:"Clear Selections"}},dataView:{title:"Data View",lang:["Data View","Close","Refresh"]},dataZoom:{title:{zoom:"Zoom",back:"Zoom Reset"}},magicType:{title:{line:"Switch to Line Chart",bar:"Switch to Bar Chart",stack:"Stack",tiled:"Tile"}},restore:{title:"Restore"},saveAsImage:{title:"Save as Image",lang:["Right Click to Save Image"]}},series:{typeNames:{pie:"Pie chart",bar:"Bar chart",line:"Line chart",scatter:"Scatter plot",effectScatter:"Ripple scatter plot",radar:"Radar chart",tree:"Tree",treemap:"Treemap",boxplot:"Boxplot",candlestick:"Candlestick",k:"K line chart",heatmap:"Heat map",map:"Map",parallel:"Parallel coordinate map",lines:"Line graph",graph:"Relationship graph",sankey:"Sankey diagram",funnel:"Funnel chart",gauge:"Guage",pictorialBar:"Pictorial bar",themeRiver:"Theme River Map",sunburst:"Sunburst"}},aria:{general:{withTitle:'This is a chart about "{title}"',withoutTitle:"This is a chart"},series:{single:{prefix:"",withName:" with type {seriesType} named {seriesName}.",withoutName:" with type {seriesType}."},multiple:{prefix:". It consists of {seriesCount} series count.",withName:" The {seriesId} series is a {seriesType} representing {seriesName}.",withoutName:" The {seriesId} series is a {seriesType}.",separator:{middle:"",end:""}}},data:{allData:"The data is as follows: ",partialData:"The first {displayCnt} items are: ",withName:"the data for {name} is {value}",withoutName:"{value}",separator:{middle:", ",end:". "}}}}),Oh(Ch,{time:{month:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"],monthAbbr:["1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"],dayOfWeek:["星期日","星期一","星期二","星期三","星期四","星期五","星期六"],dayOfWeekAbbr:["日","一","二","三","四","五","六"]},legend:{selector:{all:"全选",inverse:"反选"}},toolbox:{brush:{title:{rect:"矩形选择",polygon:"圈选",lineX:"横向选择",lineY:"纵向选择",keep:"保持选择",clear:"清除选择"}},dataView:{title:"数据视图",lang:["数据视图","关闭","刷新"]},dataZoom:{title:{zoom:"区域缩放",back:"区域缩放还原"}},magicType:{title:{line:"切换为折线图",bar:"切换为柱状图",stack:"切换为堆叠",tiled:"切换为平铺"}},restore:{title:"还原"},saveAsImage:{title:"保存为图片",lang:["右键另存为图片"]}},series:{typeNames:{pie:"饼图",bar:"柱状图",line:"折线图",scatter:"散点图",effectScatter:"涟漪散点图",radar:"雷达图",tree:"树图",treemap:"矩形树图",boxplot:"箱型图",candlestick:"K线图",k:"K线图",heatmap:"热力图",map:"地图",parallel:"平行坐标图",lines:"线图",graph:"关系图",sankey:"桑基图",funnel:"漏斗图",gauge:"仪表盘图",pictorialBar:"象形柱图",themeRiver:"主题河流图",sunburst:"旭日图"}},aria:{general:{withTitle:"这是一个关于“{title}”的图表。",withoutTitle:"这是一个图表，"},series:{single:{prefix:"",withName:"图表类型是{seriesType}，表示{seriesName}。",withoutName:"图表类型是{seriesType}。"},multiple:{prefix:"它由{seriesCount}个图表系列组成。",withName:"第{seriesId}个系列是一个表示{seriesName}的{seriesType}，",withoutName:"第{seriesId}个系列是一个{seriesType}，",separator:{middle:"；",end:"。"}}},data:{allData:"其数据是——",partialData:"其中，前{displayCnt}项是——",withName:"{name}的数据是{value}",withoutName:"{value}",separator:{middle:"，",end:""}}}});var Rh=1e3,Nh=6e4,Eh=36e5,zh=864e5,Bh=31536e6,Vh={year:"{yyyy}",month:"{MMM}",day:"{d}",hour:"{HH}:{mm}",minute:"{HH}:{mm}",second:"{HH}:{mm}:{ss}",millisecond:"{hh}:{mm}:{ss} {SSS}",none:"{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}"},Fh="{yyyy}-{MM}-{dd}",Gh={year:"{yyyy}",month:"{yyyy}-{MM}",day:Fh,hour:"{yyyy}-{MM}-{dd} "+Vh.hour,minute:"{yyyy}-{MM}-{dd} "+Vh.minute,second:"{yyyy}-{MM}-{dd} "+Vh.second,millisecond:Vh.none},Hh=["year","month","day","hour","minute","second","millisecond"],Wh=["year","half-year","quarter","month","week","half-week","day","half-day","quarter-day","hour","minute","second","millisecond"];function Yh(t,e){return"0000".substr(0,e-(t+="").length)+t}function Xh(t){switch(t){case"half-year":case"quarter":return"month";case"week":case"half-week":return"day";case"half-day":case"quarter-day":return"hour";default:return t}}function Uh(t){return t===Xh(t)}function Zh(t,e,n,i){var r=rr(t),o=r[Kh(n)](),a=r[$h(n)]()+1,s=Math.floor((a-1)/4)+1,l=r[Jh(n)](),u=r["get"+(n?"UTC":"")+"Day"](),h=r[Qh(n)](),c=(h-1)%12+1,p=r[tc(n)](),d=r[ec(n)](),f=r[nc(n)](),g=(i instanceof Sh?i:function(t){return kh[t]}(i||Ph)||kh.EN).getModel("time"),y=g.get("month"),v=g.get("monthAbbr"),m=g.get("dayOfWeek"),_=g.get("dayOfWeekAbbr");return(e||"").replace(/{yyyy}/g,o+"").replace(/{yy}/g,o%100+"").replace(/{Q}/g,s+"").replace(/{MMMM}/g,y[a-1]).replace(/{MMM}/g,v[a-1]).replace(/{MM}/g,Yh(a,2)).replace(/{M}/g,a+"").replace(/{dd}/g,Yh(l,2)).replace(/{d}/g,l+"").replace(/{eeee}/g,m[u]).replace(/{ee}/g,_[u]).replace(/{e}/g,u+"").replace(/{HH}/g,Yh(h,2)).replace(/{H}/g,h+"").replace(/{hh}/g,Yh(c+"",2)).replace(/{h}/g,c+"").replace(/{mm}/g,Yh(p,2)).replace(/{m}/g,p+"").replace(/{ss}/g,Yh(d,2)).replace(/{s}/g,d+"").replace(/{SSS}/g,Yh(f,3)).replace(/{S}/g,f+"")}function jh(t,e){var n=rr(t),i=n[$h(e)]()+1,r=n[Jh(e)](),o=n[Qh(e)](),a=n[tc(e)](),s=n[ec(e)](),l=0===n[nc(e)](),u=l&&0===s,h=u&&0===a,c=h&&0===o,p=c&&1===r;return p&&1===i?"year":p?"month":c?"day":h?"hour":u?"minute":l?"second":"millisecond"}function qh(t,e,n){var i="number"==typeof t?rr(t):t;switch(e=e||jh(t,n)){case"year":return i[Kh(n)]();case"half-year":return i[$h(n)]()>=6?1:0;case"quarter":return Math.floor((i[$h(n)]()+1)/4);case"month":return i[$h(n)]();case"day":return i[Jh(n)]();case"half-day":return i[Qh(n)]()/24;case"hour":return i[Qh(n)]();case"minute":return i[tc(n)]();case"second":return i[ec(n)]();case"millisecond":return i[nc(n)]()}}function Kh(t){return t?"getUTCFullYear":"getFullYear"}function $h(t){return t?"getUTCMonth":"getMonth"}function Jh(t){return t?"getUTCDate":"getDate"}function Qh(t){return t?"getUTCHours":"getHours"}function tc(t){return t?"getUTCMinutes":"getMinutes"}function ec(t){return t?"getUTCSeconds":"getSeconds"}function nc(t){return t?"getUTCSeconds":"getSeconds"}function ic(t){return t?"setUTCFullYear":"setFullYear"}function rc(t){return t?"setUTCMonth":"setMonth"}function oc(t){return t?"setUTCDate":"setDate"}function ac(t){return t?"setUTCHours":"setHours"}function sc(t){return t?"setUTCMinutes":"setMinutes"}function lc(t){return t?"setUTCSeconds":"setSeconds"}function uc(t){return t?"setUTCSeconds":"setSeconds"}function hc(t){if(!cr(t))return H(t)?t:"-";var e=(t+"").split(".");return e[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g,"$1,")+(e.length>1?"."+e[1]:"")}function cc(t,e){return t=(t||"").toLowerCase().replace(/-(.)/g,(function(t,e){return e.toUpperCase()})),e&&t&&(t=t.charAt(0).toUpperCase()+t.slice(1)),t}var pc=it,dc=/([&<>"'])/g,fc={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"};function gc(t){return null==t?"":(t+"").replace(dc,(function(t,e){return fc[e]}))}function yc(t,e,n){function i(t){return t&&ot(t)?t:"-"}function r(t){return!(null==t||isNaN(t)||!isFinite(t))}var o="time"===e,a=t instanceof Date;if(o||a){var s=o?rr(t):t;if(!isNaN(+s))return Zh(s,"yyyy-MM-dd hh:mm:ss",n);if(a)return"-"}if("ordinal"===e)return W(t)?i(t):Y(t)&&r(t)?t+"":"-";var l=hr(t);return r(l)?hc(l):W(t)?i(t):"-"}var vc=["a","b","c","d","e","f","g"],mc=function(t,e){return"{"+t+(null==e?"":e)+"}"};function _c(t,e,n){F(e)||(e=[e]);var i=e.length;if(!i)return"";for(var r=e[0].$vars||[],o=0;o<r.length;o++){var a=vc[o];t=t.replace(mc(a),mc(a,0))}for(var s=0;s<i;s++)for(var l=0;l<r.length;l++){var u=e[s][r[l]];t=t.replace(mc(vc[l],s),n?gc(u):u)}return t}function xc(t,e){var n=H(t)?{color:t,extraCssText:e}:t||{},i=n.color,r=n.type;e=n.extraCssText;var o=n.renderMode||"html";return i?"html"===o?"subItem"===r?'<span style="display:inline-block;vertical-align:middle;margin-right:8px;margin-left:3px;border-radius:4px;width:4px;height:4px;background-color:'+gc(i)+";"+(e||"")+'"></span>':'<span style="display:inline-block;margin-right:4px;border-radius:10px;width:10px;height:10px;background-color:'+gc(i)+";"+(e||"")+'"></span>':{renderMode:o,content:"{"+(n.markerId||"markerX")+"|}  ",style:"subItem"===r?{width:4,height:4,borderRadius:2,backgroundColor:i}:{width:10,height:10,borderRadius:5,backgroundColor:i}}:""}function bc(t,e){return e=e||"transparent",H(t)?t:X(t)&&t.colorStops&&(t.colorStops[0]||{}).color||e}function wc(t,e){if("_blank"===e||"blank"===e){var n=window.open();n.opener=null,n.location.href=t}else window.open(t,e)}var Sc=P,Mc=["left","right","top","bottom","width","height"],Ic=[["width","left","right"],["height","top","bottom"]];function Tc(t,e,n,i,r){var o=0,a=0;null==i&&(i=1/0),null==r&&(r=1/0);var s=0;e.eachChild((function(l,u){var h,c,p=l.getBoundingRect(),d=e.childAt(u+1),f=d&&d.getBoundingRect();if("horizontal"===t){var g=p.width+(f?-f.x+p.x:0);(h=o+g)>i||l.newline?(o=0,h=g,a+=s+n,s=p.height):s=Math.max(s,p.height)}else{var y=p.height+(f?-f.y+p.y:0);(c=a+y)>r||l.newline?(o+=s+n,a=0,c=y,s=p.width):s=Math.max(s,p.width)}l.newline||(l.x=o,l.y=a,l.markRedraw(),"horizontal"===t?o=h+n:a=c+n)}))}var Cc=Tc;V(Tc,"vertical"),V(Tc,"horizontal");function Ac(t,e,n){n=pc(n||0);var i=e.width,r=e.height,o=Zi(t.left,i),a=Zi(t.top,r),s=Zi(t.right,i),l=Zi(t.bottom,r),u=Zi(t.width,i),h=Zi(t.height,r),c=n[2]+n[0],p=n[1]+n[3],d=t.aspect;switch(isNaN(u)&&(u=i-s-p-o),isNaN(h)&&(h=r-l-c-a),null!=d&&(isNaN(u)&&isNaN(h)&&(d>i/r?u=.8*i:h=.8*r),isNaN(u)&&(u=d*h),isNaN(h)&&(h=u/d)),isNaN(o)&&(o=i-s-u-p),isNaN(a)&&(a=r-l-h-c),t.left||t.right){case"center":o=i/2-u/2-n[3];break;case"right":o=i-u-p}switch(t.top||t.bottom){case"middle":case"center":a=r/2-h/2-n[0];break;case"bottom":a=r-h-c}o=o||0,a=a||0,isNaN(u)&&(u=i-p-o-(s||0)),isNaN(h)&&(h=r-c-a-(l||0));var f=new Rn(o+n[3],a+n[0],u,h);return f.margin=n,f}function Dc(t,e,n,i,r){var o=!r||!r.hv||r.hv[0],a=!r||!r.hv||r.hv[1],s=r&&r.boundingMode||"all";if(o||a){var l;if("raw"===s)l="group"===t.type?new Rn(0,0,+e.width||0,+e.height||0):t.getBoundingRect();else if(l=t.getBoundingRect(),t.needLocalTransform()){var u=t.getLocalTransform();(l=l.clone()).applyTransform(u)}var h=Ac(T({width:l.width,height:l.height},e),n,i),c=o?h.x-l.x:0,p=a?h.y-l.y:0;"raw"===s?(t.x=c,t.y=p):(t.x+=c,t.y+=p),t.markRedraw()}}function Lc(t){var e=t.layoutMode||t.constructor.layoutMode;return X(e)?e:e?{type:e}:null}function kc(t,e,n){var i=n&&n.ignoreSize;!F(i)&&(i=[i,i]);var r=a(Ic[0],0),o=a(Ic[1],1);function a(n,r){var o={},a=0,u={},h=0;if(Sc(n,(function(e){u[e]=t[e]})),Sc(n,(function(t){s(e,t)&&(o[t]=u[t]=e[t]),l(o,t)&&a++,l(u,t)&&h++})),i[r])return l(e,n[1])?u[n[2]]=null:l(e,n[2])&&(u[n[1]]=null),u;if(2!==h&&a){if(a>=2)return o;for(var c=0;c<n.length;c++){var p=n[c];if(!s(o,p)&&s(t,p)){o[p]=t[p];break}}return o}return u}function s(t,e){return t.hasOwnProperty(e)}function l(t,e){return null!=t[e]&&"auto"!==t[e]}function u(t,e,n){Sc(t,(function(t){e[t]=n[t]}))}u(Ic[0],t,r),u(Ic[1],t,o)}function Pc(t){return Oc({},t)}function Oc(t,e){return e&&t&&Sc(Mc,(function(n){e.hasOwnProperty(n)&&(t[n]=e[n])})),t}var Rc=Lr(),Nc=function(t){function e(e,n,i){var r=t.call(this,e,n,i)||this;return r.uid=Ih("ec_cpt_model"),r}return n(e,t),e.prototype.init=function(t,e,n){this.mergeDefaultAndTheme(t,n)},e.prototype.mergeDefaultAndTheme=function(t,e){var n=Lc(this),i=n?Pc(t):{};S(t,e.getTheme().get(this.mainType)),S(t,this.getDefaultOption()),n&&kc(t,i,n)},e.prototype.mergeOption=function(t,e){S(this.option,t,!0);var n=Lc(this);n&&kc(this.option,t,n)},e.prototype.optionUpdated=function(t,e){},e.prototype.getDefaultOption=function(){var t=this.constructor;if(!function(t){return!(!t||!t[Fr])}(t))return t.defaultOption;var e=Rc(this);if(!e.defaultOption){for(var n=[],i=t;i;){var r=i.prototype.defaultOption;r&&n.push(r),i=i.superClass}for(var o={},a=n.length-1;a>=0;a--)o=S(o,n[a],!0);e.defaultOption=o}return e.defaultOption},e.prototype.getReferringComponents=function(t,e){var n=t+"Index",i=t+"Id";return Nr(this.ecModel,t,{index:this.get(n,!0),id:this.get(i,!0)},e)},e.prototype.getBoxLayoutParams=function(){var t=this;return{left:t.get("left"),top:t.get("top"),right:t.get("right"),bottom:t.get("bottom"),width:t.get("width"),height:t.get("height")}},e.protoInitialize=function(){var t=e.prototype;t.type="component",t.id="",t.name="",t.mainType="",t.subType="",t.componentIndex=0}(),e}(Sh);Yr(Nc,Sh),jr(Nc),function(t){var e={};t.registerSubTypeDefaulter=function(t,n){var i=Gr(t);e[i.main]=n},t.determineSubType=function(n,i){var r=i.type;if(!r){var o=Gr(n).main;t.hasSubTypes(n)&&e[o]&&(r=e[o](i))}return r}}(Nc),function(t,e){function n(t,e){return t[e]||(t[e]={predecessor:[],successor:[]}),t[e]}t.topologicalTravel=function(t,i,r,o){if(t.length){var a=function(t){var i={},r=[];return P(t,(function(o){var a=n(i,o),s=function(t,e){var n=[];return P(t,(function(t){A(e,t)>=0&&n.push(t)})),n}(a.originalDeps=e(o),t);a.entryCount=s.length,0===a.entryCount&&r.push(o),P(s,(function(t){A(a.predecessor,t)<0&&a.predecessor.push(t);var e=n(i,t);A(e.successor,t)<0&&e.successor.push(o)}))})),{graph:i,noEntryList:r}}(i),s=a.graph,l=a.noEntryList,u={};for(P(t,(function(t){u[t]=!0}));l.length;){var h=l.pop(),c=s[h],p=!!u[h];p&&(r.call(o,h,c.originalDeps.slice()),delete u[h]),P(c.successor,p?f:d)}P(u,(function(){var t="";throw new Error(t)}))}function d(t){s[t].entryCount--,0===s[t].entryCount&&l.push(t)}function f(t){u[t]=!0,d(t)}}}(Nc,(function(t){var e=[];P(Nc.getClassesByMainType(t),(function(t){e=e.concat(t.dependencies||t.prototype.dependencies||[])})),e=O(e,(function(t){return Gr(t).main})),"dataset"!==t&&A(e,"dataset")<=0&&e.unshift("dataset");return e}));var Ec="";"undefined"!=typeof navigator&&(Ec=navigator.platform||"");var zc="rgba(0, 0, 0, 0.2)",Bc={darkMode:"auto",color:["#5470c6","#91cc75","#fac858","#ee6666","#73c0de","#3ba272","#fc8452","#9a60b4","#ea7ccc"],gradientColor:["#f6efa6","#d88273","#bf444c"],aria:{decal:{decals:[{color:zc,dashArrayX:[1,0],dashArrayY:[2,5],symbolSize:1,rotation:Math.PI/6},{color:zc,symbol:"circle",dashArrayX:[[8,8],[0,8,8,0]],dashArrayY:[6,0],symbolSize:.8},{color:zc,dashArrayX:[1,0],dashArrayY:[4,3],rotation:-Math.PI/4},{color:zc,dashArrayX:[[6,6],[0,6,6,0]],dashArrayY:[6,0]},{color:zc,dashArrayX:[[1,0],[1,6]],dashArrayY:[1,0,6,0],rotation:Math.PI/4},{color:zc,symbol:"triangle",dashArrayX:[[9,9],[0,9,9,0]],dashArrayY:[7,2],symbolSize:.75}]}},textStyle:{fontFamily:Ec.match(/^Win/)?"Microsoft YaHei":"sans-serif",fontSize:12,fontStyle:"normal",fontWeight:"normal"},blendMode:null,stateAnimation:{duration:300,easing:"cubicOut"},animation:"auto",animationDuration:1e3,animationDurationUpdate:500,animationEasing:"cubicInOut",animationEasingUpdate:"cubicInOut",animationThreshold:2e3,progressiveThreshold:3e3,progressive:400,hoverLayerThreshold:3e3,useUTC:!1},Vc=ht(["tooltip","label","itemName","itemId","seriesName"]),Fc="original",Gc="arrayRows",Hc="objectRows",Wc="keyedColumns",Yc="typedArray",Xc="unknown",Uc="column",Zc="row",jc=1,qc=2,Kc=3,$c=Lr();function Jc(t,e,n){var i={},r=tp(e);if(!r||!t)return i;var o,a,s=[],l=[],u=e.ecModel,h=$c(u).datasetMap,c=r.uid+"_"+n.seriesLayoutBy;P(t=t.slice(),(function(e,n){var r=X(e)?e:t[n]={name:e};"ordinal"===r.type&&null==o&&(o=n,a=f(r)),i[r.name]=[]}));var p=h.get(c)||h.set(c,{categoryWayDim:a,valueWayDim:0});function d(t,e,n){for(var i=0;i<n;i++)t.push(e+i)}function f(t){var e=t.dimsDef;return e?e.length:1}return P(t,(function(t,e){var n=t.name,r=f(t);if(null==o){var a=p.valueWayDim;d(i[n],a,r),d(l,a,r),p.valueWayDim+=r}else if(o===e)d(i[n],0,r),d(s,0,r);else{a=p.categoryWayDim;d(i[n],a,r),d(l,a,r),p.categoryWayDim+=r}})),s.length&&(i.itemName=s),l.length&&(i.seriesName=l),i}function Qc(t,e,n){var i={};if(!tp(t))return i;var r,o=e.sourceFormat,a=e.dimensionsDefine;o!==Hc&&o!==Wc||P(a,(function(t,e){"name"===(X(t)?t.name:t)&&(r=e)}));var s=function(){for(var t={},i={},s=[],l=0,u=Math.min(5,n);l<u;l++){var h=np(e.data,o,e.seriesLayoutBy,a,e.startIndex,l);s.push(h);var c=h===Kc;if(c&&null==t.v&&l!==r&&(t.v=l),(null==t.n||t.n===t.v||!c&&s[t.n]===Kc)&&(t.n=l),p(t)&&s[t.n]!==Kc)return t;c||(h===qc&&null==i.v&&l!==r&&(i.v=l),null!=i.n&&i.n!==i.v||(i.n=l))}function p(t){return null!=t.v&&null!=t.n}return p(t)?t:p(i)?i:null}();if(s){i.value=[s.v];var l=null!=r?r:s.n;i.itemName=[l],i.seriesName=[l]}return i}function tp(t){if(!t.get("data",!0))return Nr(t.ecModel,"dataset",{index:t.get("datasetIndex",!0),id:t.get("datasetId",!0)},Or).models[0]}function ep(t,e){return np(t.data,t.sourceFormat,t.seriesLayoutBy,t.dimensionsDefine,t.startIndex,e)}function np(t,e,n,i,r,o){var a,s,l;if(Z(t))return Kc;if(i){var u=i[o];X(u)?(s=u.name,l=u.type):H(u)&&(s=u)}if(null!=l)return"ordinal"===l?jc:Kc;if(e===Gc){var h=t;if(n===Zc){for(var c=h[o],p=0;p<(c||[]).length&&p<5;p++)if(null!=(a=m(c[r+p])))return a}else for(p=0;p<h.length&&p<5;p++){var d=h[r+p];if(d&&null!=(a=m(d[o])))return a}}else if(e===Hc){var f=t;if(!s)return Kc;for(p=0;p<f.length&&p<5;p++){if((y=f[p])&&null!=(a=m(y[s])))return a}}else if(e===Wc){if(!s)return Kc;if(!(c=t[s])||Z(c))return Kc;for(p=0;p<c.length&&p<5;p++)if(null!=(a=m(c[p])))return a}else if(e===Fc){var g=t;for(p=0;p<g.length&&p<5;p++){var y,v=wr(y=g[p]);if(!F(v))return Kc;if(null!=(a=m(v[o])))return a}}function m(t){var e=H(t);return null!=t&&isFinite(t)&&""!==t?e?qc:Kc:e&&"-"!==t?jc:void 0}return Kc}var ip=ht();var rp,op,ap,sp=Lr(),lp=Lr(),up=function(){function t(){}return t.prototype.getColorFromPalette=function(t,e,n){var i=_r(this.get("color",!0)),r=this.get("colorLayer",!0);return cp(this,sp,i,r,t,e,n)},t.prototype.clearColorPalette=function(){!function(t,e){e(t).paletteIdx=0,e(t).paletteNameMap={}}(this,sp)},t}();function hp(t,e,n,i){var r=_r(t.get(["aria","decal","decals"]));return cp(t,lp,r,null,e,n,i)}function cp(t,e,n,i,r,o,a){var s=e(o=o||t),l=s.paletteIdx||0,u=s.paletteNameMap=s.paletteNameMap||{};if(u.hasOwnProperty(r))return u[r];var h=null!=a&&i?function(t,e){for(var n=t.length,i=0;i<n;i++)if(t[i].length>e)return t[i];return t[n-1]}(i,a):n;if((h=h||n)&&h.length){var c=h[l];return r&&(u[r]=c),s.paletteIdx=(l+1)%h.length,c}}var pp=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.init=function(t,e,n,i,r,o){i=i||{},this.option=null,this._theme=new Sh(i),this._locale=new Sh(r),this._optionManager=o},e.prototype.setOption=function(t,e,n){var i=gp(e);this._optionManager.setOption(t,n,i),this._resetOption(null,i)},e.prototype.resetOption=function(t,e){return this._resetOption(t,gp(e))},e.prototype._resetOption=function(t,e){var n=!1,i=this._optionManager;if(!t||"recreate"===t){var r=i.mountOption("recreate"===t);this.option&&"recreate"!==t?(this.restoreData(),this._mergeOption(r,e)):ap(this,r),n=!0}if("timeline"!==t&&"media"!==t||this.restoreData(),!t||"recreate"===t||"timeline"===t){var o=i.getTimelineOption(this);o&&(n=!0,this._mergeOption(o,e))}if(!t||"recreate"===t||"media"===t){var a=i.getMediaOption(this);a.length&&P(a,(function(t){n=!0,this._mergeOption(t,e)}),this)}return n},e.prototype.mergeOption=function(t){this._mergeOption(t,null)},e.prototype._mergeOption=function(t,e){var n=this.option,i=this._componentsMap,r=this._componentsCount,o=[],a=ht(),s=e&&e.replaceMergeMainTypeMap;$c(this).datasetMap=ht(),P(t,(function(t,e){null!=t&&(Nc.hasClass(e)?e&&(o.push(e),a.set(e,!0)):n[e]=null==n[e]?w(t):S(n[e],t,!0))})),s&&s.each((function(t,e){Nc.hasClass(e)&&!a.get(e)&&(o.push(e),a.set(e,!0))})),Nc.topologicalTravel(o,Nc.getAllClassMainTypes(),(function(e){var o=function(t,e,n){var i=ip.get(e);if(!i)return n;var r=i(t);return r?n.concat(r):n}(this,e,_r(t[e])),a=i.get(e),l=a?s&&s.get(e)?"replaceMerge":"normalMerge":"replaceAll",u=Sr(a,o,l);(function(t,e,n){P(t,(function(t){var i=t.newOption;X(i)&&(t.keyInfo.mainType=e,t.keyInfo.subType=function(t,e,n,i){return e.type?e.type:n?n.subType:i.determineSubType(t,e)}(e,i,t.existing,n))}))})(u,e,Nc),n[e]=null,i.set(e,null),r.set(e,0);var h=[],c=[],p=0;P(u,(function(t,n){var i=t.existing,r=t.newOption;if(r){var o=Nc.getClass(e,t.keyInfo.subType,!0);if(i&&i.constructor===o)i.name=t.keyInfo.name,i.mergeOption(r,this),i.optionUpdated(r,!1);else{var a=I({componentIndex:n},t.keyInfo);I(i=new o(r,this,this,a),a),t.brandNew&&(i.__requireNewView=!0),i.init(r,this,this),i.optionUpdated(null,!0)}}else i&&(i.mergeOption({},this),i.optionUpdated({},!1));i?(h.push(i.option),c.push(i),p++):(h.push(void 0),c.push(void 0))}),this),n[e]=h,i.set(e,c),r.set(e,p),"series"===e&&rp(this)}),this),this._seriesIndices||rp(this)},e.prototype.getOption=function(){var t=w(this.option);return P(t,(function(e,n){if(Nc.hasClass(n)){for(var i=_r(e),r=i.length,o=!1,a=r-1;a>=0;a--)i[a]&&!Ar(i[a])?o=!0:(i[a]=null,!o&&r--);i.length=r,t[n]=i}})),delete t["\0_ec_inner"],t},e.prototype.getTheme=function(){return this._theme},e.prototype.getLocaleModel=function(){return this._locale},e.prototype.getLocale=function(t){return this.getLocaleModel().get(t)},e.prototype.setUpdatePayload=function(t){this._payload=t},e.prototype.getUpdatePayload=function(){return this._payload},e.prototype.getComponent=function(t,e){var n=this._componentsMap.get(t);if(n){var i=n[e||0];if(i)return i;if(null==e)for(var r=0;r<n.length;r++)if(n[r])return n[r]}},e.prototype.queryComponents=function(t){var e=t.mainType;if(!e)return[];var n,i=t.index,r=t.id,o=t.name,a=this._componentsMap.get(e);return a&&a.length?(null!=i?(n=[],P(_r(i),(function(t){a[t]&&n.push(a[t])}))):n=null!=r?dp("id",r,a):null!=o?dp("name",o,a):N(a,(function(t){return!!t})),fp(n,t)):[]},e.prototype.findComponents=function(t){var e,n,i,r,o,a=t.query,s=t.mainType,l=(n=s+"Index",i=s+"Id",r=s+"Name",!(e=a)||null==e[n]&&null==e[i]&&null==e[r]?null:{mainType:s,index:e[n],id:e[i],name:e[r]}),u=l?this.queryComponents(l):N(this._componentsMap.get(s),(function(t){return!!t}));return o=fp(u,t),t.filter?N(o,t.filter):o},e.prototype.eachComponent=function(t,e,n){var i=this._componentsMap;if(G(t)){var r=e,o=t;i.each((function(t,e){for(var n=0;t&&n<t.length;n++){var i=t[n];i&&o.call(r,e,i,i.componentIndex)}}))}else for(var a=H(t)?i.get(t):X(t)?this.findComponents(t):null,s=0;a&&s<a.length;s++){var l=a[s];l&&e.call(n,l,l.componentIndex)}},e.prototype.getSeriesByName=function(t){var e=Tr(t,null);return N(this._componentsMap.get("series"),(function(t){return!!t&&null!=e&&t.name===e}))},e.prototype.getSeriesByIndex=function(t){return this._componentsMap.get("series")[t]},e.prototype.getSeriesByType=function(t){return N(this._componentsMap.get("series"),(function(e){return!!e&&e.subType===t}))},e.prototype.getSeries=function(){return N(this._componentsMap.get("series").slice(),(function(t){return!!t}))},e.prototype.getSeriesCount=function(){return this._componentsCount.get("series")},e.prototype.eachSeries=function(t,e){op(this),P(this._seriesIndices,(function(n){var i=this._componentsMap.get("series")[n];t.call(e,i,n)}),this)},e.prototype.eachRawSeries=function(t,e){P(this._componentsMap.get("series"),(function(n){n&&t.call(e,n,n.componentIndex)}))},e.prototype.eachSeriesByType=function(t,e,n){op(this),P(this._seriesIndices,(function(i){var r=this._componentsMap.get("series")[i];r.subType===t&&e.call(n,r,i)}),this)},e.prototype.eachRawSeriesByType=function(t,e,n){return P(this.getSeriesByType(t),e,n)},e.prototype.isSeriesFiltered=function(t){return op(this),null==this._seriesIndicesMap.get(t.componentIndex)},e.prototype.getCurrentSeriesIndices=function(){return(this._seriesIndices||[]).slice()},e.prototype.filterSeries=function(t,e){op(this);var n=[];P(this._seriesIndices,(function(i){var r=this._componentsMap.get("series")[i];t.call(e,r,i)&&n.push(i)}),this),this._seriesIndices=n,this._seriesIndicesMap=ht(n)},e.prototype.restoreData=function(t){rp(this);var e=this._componentsMap,n=[];e.each((function(t,e){Nc.hasClass(e)&&n.push(e)})),Nc.topologicalTravel(n,Nc.getAllClassMainTypes(),(function(n){P(e.get(n),(function(e){!e||"series"===n&&function(t,e){if(e){var n=e.seriesIndex,i=e.seriesId,r=e.seriesName;return null!=n&&t.componentIndex!==n||null!=i&&t.id!==i||null!=r&&t.name!==r}}(e,t)||e.restoreData()}))}))},e.internalField=(rp=function(t){var e=t._seriesIndices=[];P(t._componentsMap.get("series"),(function(t){t&&e.push(t.componentIndex)})),t._seriesIndicesMap=ht(e)},op=function(t){},void(ap=function(t,e){t.option={},t.option["\0_ec_inner"]=1,t._componentsMap=ht({series:[]}),t._componentsCount=ht();var n=e.aria;X(n)&&null==n.enabled&&(n.enabled=!0),function(t,e){var n=t.color&&!t.colorLayer;P(e,(function(e,i){"colorLayer"===i&&n||Nc.hasClass(i)||("object"==typeof e?t[i]=t[i]?S(t[i],e,!1):w(e):null==t[i]&&(t[i]=e))}))}(e,t._theme.option),S(e,Bc,!1),t._mergeOption(e,null)})),e}(Sh);function dp(t,e,n){if(F(e)){var i=ht();return P(e,(function(t){null!=t&&(null!=Tr(t,null)&&i.set(t,!0))})),N(n,(function(e){return e&&i.get(e[t])}))}var r=Tr(e,null);return N(n,(function(e){return e&&null!=r&&e[t]===r}))}function fp(t,e){return e.hasOwnProperty("subType")?N(t,(function(t){return t&&t.subType===e.subType})):t}function gp(t){var e=ht();return t&&P(_r(t.replaceMerge),(function(t){e.set(t,!0)})),{replaceMergeMainTypeMap:e}}L(pp,up);var yp=["getDom","getZr","getWidth","getHeight","getDevicePixelRatio","dispatchAction","isDisposed","on","off","getDataURL","getConnectedDataURL","getOption","getId","updateLabelLayout"],vp=function(t){P(yp,(function(e){this[e]=B(t[e],t)}),this)},mp={},_p=function(){function t(){this._coordinateSystems=[]}return t.prototype.create=function(t,e){var n=[];P(mp,(function(i,r){var o=i.create(t,e);n=n.concat(o||[])})),this._coordinateSystems=n},t.prototype.update=function(t,e){P(this._coordinateSystems,(function(n){n.update&&n.update(t,e)}))},t.prototype.getCoordinateSystems=function(){return this._coordinateSystems.slice()},t.register=function(t,e){mp[t]=e},t.get=function(t){return mp[t]},t}(),xp=/^(min|max)?(.+)$/,bp=function(){function t(t){this._timelineOptions=[],this._mediaList=[],this._currentMediaIndices=[],this._api=t}return t.prototype.setOption=function(t,e,n){t&&(P(_r(t.series),(function(t){t&&t.data&&Z(t.data)&&st(t.data)})),P(_r(t.dataset),(function(t){t&&t.source&&Z(t.source)&&st(t.source)}))),t=w(t);var i=this._optionBackup,r=function(t,e,n){var i,r,o=[],a=t.baseOption,s=t.timeline,l=t.options,u=t.media,h=!!t.media,c=!!(l||s||a&&a.timeline);a?(r=a).timeline||(r.timeline=s):((c||h)&&(t.options=t.media=null),r=t);h&&F(u)&&P(u,(function(t){t&&t.option&&(t.query?o.push(t):i||(i=t))}));function p(t){P(e,(function(e){e(t,n)}))}return p(r),P(l,(function(t){return p(t)})),P(o,(function(t){return p(t.option)})),{baseOption:r,timelineOptions:l||[],mediaDefault:i,mediaList:o}}(t,e,!i);this._newBaseOption=r.baseOption,i?(r.timelineOptions.length&&(i.timelineOptions=r.timelineOptions),r.mediaList.length&&(i.mediaList=r.mediaList),r.mediaDefault&&(i.mediaDefault=r.mediaDefault)):this._optionBackup=r},t.prototype.mountOption=function(t){var e=this._optionBackup;return this._timelineOptions=e.timelineOptions,this._mediaList=e.mediaList,this._mediaDefault=e.mediaDefault,this._currentMediaIndices=[],w(t?e.baseOption:this._newBaseOption)},t.prototype.getTimelineOption=function(t){var e,n=this._timelineOptions;if(n.length){var i=t.getComponent("timeline");i&&(e=w(n[i.getCurrentIndex()]))}return e},t.prototype.getMediaOption=function(t){var e,n,i=this._api.getWidth(),r=this._api.getHeight(),o=this._mediaList,a=this._mediaDefault,s=[],l=[];if(!o.length&&!a)return l;for(var u=0,h=o.length;u<h;u++)wp(o[u].query,i,r)&&s.push(u);return!s.length&&a&&(s=[-1]),s.length&&(e=s,n=this._currentMediaIndices,e.join(",")!==n.join(","))&&(l=O(s,(function(t){return w(-1===t?a.option:o[t].option)}))),this._currentMediaIndices=s,l},t}();function wp(t,e,n){var i={width:e,height:n,aspectratio:e/n},r=!0;return P(t,(function(t,e){var n=e.match(xp);if(n&&n[1]&&n[2]){var o=n[1],a=n[2].toLowerCase();(function(t,e,n){return"min"===n?t>=e:"max"===n?t<=e:t===e})(i[a],t,o)||(r=!1)}})),r}var Sp=P,Mp=X,Ip=["areaStyle","lineStyle","nodeStyle","linkStyle","chordStyle","label","labelLine"];function Tp(t){var e=t&&t.itemStyle;if(e)for(var n=0,i=Ip.length;n<i;n++){var r=Ip[n],o=e.normal,a=e.emphasis;o&&o[r]&&(t[r]=t[r]||{},t[r].normal?S(t[r].normal,o[r]):t[r].normal=o[r],o[r]=null),a&&a[r]&&(t[r]=t[r]||{},t[r].emphasis?S(t[r].emphasis,a[r]):t[r].emphasis=a[r],a[r]=null)}}function Cp(t,e,n){if(t&&t[e]&&(t[e].normal||t[e].emphasis)){var i=t[e].normal,r=t[e].emphasis;i&&(n?(t[e].normal=t[e].emphasis=null,T(t[e],i)):t[e]=i),r&&(t.emphasis=t.emphasis||{},t.emphasis[e]=r,r.focus&&(t.emphasis.focus=r.focus),r.blurScope&&(t.emphasis.blurScope=r.blurScope))}}function Ap(t){Cp(t,"itemStyle"),Cp(t,"lineStyle"),Cp(t,"areaStyle"),Cp(t,"label"),Cp(t,"labelLine"),Cp(t,"upperLabel"),Cp(t,"edgeLabel")}function Dp(t,e){var n=Mp(t)&&t[e],i=Mp(n)&&n.textStyle;if(i){0;for(var r=0,o=br.length;r<o;r++){var a=br[r];i.hasOwnProperty(a)&&(n[a]=i[a])}}}function Lp(t){t&&(Ap(t),Dp(t,"label"),t.emphasis&&Dp(t.emphasis,"label"))}function kp(t){return F(t)?t:t?[t]:[]}function Pp(t){return(F(t)?t[0]:t)||{}}function Op(t,e){Sp(kp(t.series),(function(t){Mp(t)&&function(t){if(Mp(t)){Tp(t),Ap(t),Dp(t,"label"),Dp(t,"upperLabel"),Dp(t,"edgeLabel"),t.emphasis&&(Dp(t.emphasis,"label"),Dp(t.emphasis,"upperLabel"),Dp(t.emphasis,"edgeLabel"));var e=t.markPoint;e&&(Tp(e),Lp(e));var n=t.markLine;n&&(Tp(n),Lp(n));var i=t.markArea;i&&Lp(i);var r=t.data;if("graph"===t.type){r=r||t.nodes;var o=t.links||t.edges;if(o&&!Z(o))for(var a=0;a<o.length;a++)Lp(o[a]);P(t.categories,(function(t){Ap(t)}))}if(r&&!Z(r))for(a=0;a<r.length;a++)Lp(r[a]);if((e=t.markPoint)&&e.data){var s=e.data;for(a=0;a<s.length;a++)Lp(s[a])}if((n=t.markLine)&&n.data){var l=n.data;for(a=0;a<l.length;a++)F(l[a])?(Lp(l[a][0]),Lp(l[a][1])):Lp(l[a])}"gauge"===t.type?(Dp(t,"axisLabel"),Dp(t,"title"),Dp(t,"detail")):"treemap"===t.type?(Cp(t.breadcrumb,"itemStyle"),P(t.levels,(function(t){Ap(t)}))):"tree"===t.type&&Ap(t.leaves)}}(t)}));var n=["xAxis","yAxis","radiusAxis","angleAxis","singleAxis","parallelAxis","radar"];e&&n.push("valueAxis","categoryAxis","logAxis","timeAxis"),Sp(n,(function(e){Sp(kp(t[e]),(function(t){t&&(Dp(t,"axisLabel"),Dp(t.axisPointer,"label"))}))})),Sp(kp(t.parallel),(function(t){var e=t&&t.parallelAxisDefault;Dp(e,"axisLabel"),Dp(e&&e.axisPointer,"label")})),Sp(kp(t.calendar),(function(t){Cp(t,"itemStyle"),Dp(t,"dayLabel"),Dp(t,"monthLabel"),Dp(t,"yearLabel")})),Sp(kp(t.radar),(function(t){Dp(t,"name"),t.name&&null==t.axisName&&(t.axisName=t.name,delete t.name),null!=t.nameGap&&null==t.axisNameGap&&(t.axisNameGap=t.nameGap,delete t.nameGap)})),Sp(kp(t.geo),(function(t){Mp(t)&&(Lp(t),Sp(kp(t.regions),(function(t){Lp(t)})))})),Sp(kp(t.timeline),(function(t){Lp(t),Cp(t,"label"),Cp(t,"itemStyle"),Cp(t,"controlStyle",!0);var e=t.data;F(e)&&P(e,(function(t){X(t)&&(Cp(t,"label"),Cp(t,"itemStyle"))}))})),Sp(kp(t.toolbox),(function(t){Cp(t,"iconStyle"),Sp(t.feature,(function(t){Cp(t,"iconStyle")}))})),Dp(Pp(t.axisPointer),"label"),Dp(Pp(t.tooltip).axisPointer,"label")}function Rp(t){t&&P(Np,(function(e){e[0]in t&&!(e[1]in t)&&(t[e[1]]=t[e[0]])}))}var Np=[["x","left"],["y","top"],["x2","right"],["y2","bottom"]],Ep=["grid","geo","parallel","legend","toolbox","title","visualMap","dataZoom","timeline"],zp=[["borderRadius","barBorderRadius"],["borderColor","barBorderColor"],["borderWidth","barBorderWidth"]];function Bp(t){var e=t&&t.itemStyle;if(e)for(var n=0;n<zp.length;n++){var i=zp[n][1],r=zp[n][0];null!=e[i]&&(e[r]=e[i])}}function Vp(t){t&&"edge"===t.alignTo&&null!=t.margin&&null==t.edgeDistance&&(t.edgeDistance=t.margin)}function Fp(t){t&&t.downplay&&!t.blur&&(t.blur=t.downplay)}function Gp(t,e){if(t)for(var n=0;n<t.length;n++)e(t[n]),t[n]&&Gp(t[n].children,e)}function Hp(t,e){Op(t,e),t.series=_r(t.series),P(t.series,(function(t){if(X(t)){var e=t.type;if("line"===e)null!=t.clipOverflow&&(t.clip=t.clipOverflow);else if("pie"===e||"gauge"===e){if(null!=t.clockWise&&(t.clockwise=t.clockWise),Vp(t.label),(r=t.data)&&!Z(r))for(var n=0;n<r.length;n++)Vp(r[n]);null!=t.hoverOffset&&(t.emphasis=t.emphasis||{},(t.emphasis.scaleSize=null)&&(t.emphasis.scaleSize=t.hoverOffset))}else if("gauge"===e){var i=function(t,e){for(var n=e.split(","),i=t,r=0;r<n.length&&null!=(i=i&&i[n[r]]);r++);return i}(t,"pointer.color");null!=i&&function(t,e,n,i){for(var r,o=e.split(","),a=t,s=0;s<o.length-1;s++)null==a[r=o[s]]&&(a[r]={}),a=a[r];(i||null==a[o[s]])&&(a[o[s]]=n)}(t,"itemStyle.color",i)}else if("bar"===e){var r;if(Bp(t),Bp(t.backgroundStyle),Bp(t.emphasis),(r=t.data)&&!Z(r))for(n=0;n<r.length;n++)"object"==typeof r[n]&&(Bp(r[n]),Bp(r[n]&&r[n].emphasis))}else if("sunburst"===e){var o=t.highlightPolicy;o&&(t.emphasis=t.emphasis||{},t.emphasis.focus||(t.emphasis.focus=o)),Fp(t),Gp(t.data,Fp)}else"graph"===e||"sankey"===e?function(t){t&&null!=t.focusNodeAdjacency&&(t.emphasis=t.emphasis||{},null==t.emphasis.focus&&(t.emphasis.focus="adjacency"))}(t):"map"===e&&(t.mapType&&!t.map&&(t.map=t.mapType),t.mapLocation&&T(t,t.mapLocation));null!=t.hoverAnimation&&(t.emphasis=t.emphasis||{},t.emphasis&&null==t.emphasis.scale&&(t.emphasis.scale=t.hoverAnimation)),Rp(t)}})),t.dataRange&&(t.visualMap=t.dataRange),P(Ep,(function(e){var n=t[e];n&&(F(n)||(n=[n]),P(n,(function(t){Rp(t)})))}))}function Wp(t){P(t,(function(e,n){var i=[],r=[NaN,NaN],o=[e.stackResultDimension,e.stackedOverDimension],a=e.data,s=e.isStackedByIndex,l=a.map(o,(function(o,l,u){var h,c,p=a.get(e.stackedDimension,u);if(isNaN(p))return r;s?c=a.getRawIndex(u):h=a.get(e.stackedByDimension,u);for(var d=NaN,f=n-1;f>=0;f--){var g=t[f];if(s||(c=g.data.rawIndexOf(g.stackedByDimension,h)),c>=0){var y=g.data.getByRawIndex(g.stackResultDimension,c);if(p>=0&&y>0||p<=0&&y<0){p+=y,d=y;break}}}return i[0]=p,i[1]=d,i}));a.hostModel.setData(l),e.data=l}))}var Yp,Xp,Up,Zp,jp,qp=function(t){this.data=t.data||(t.sourceFormat===Wc?{}:[]),this.sourceFormat=t.sourceFormat||Xc,this.seriesLayoutBy=t.seriesLayoutBy||Uc,this.startIndex=t.startIndex||0,this.dimensionsDefine=t.dimensionsDefine,this.dimensionsDetectedCount=t.dimensionsDetectedCount,this.encodeDefine=t.encodeDefine,this.metaRawOption=t.metaRawOption};function Kp(t){return t instanceof qp}function $p(t,e,n,i){n=n||td(t);var r=e.seriesLayoutBy,o=function(t,e,n,i,r){var o,a;if(!t)return{dimensionsDefine:ed(r),startIndex:a,dimensionsDetectedCount:o};if(e===Gc){var s=t;"auto"===i||null==i?nd((function(t){null!=t&&"-"!==t&&(H(t)?null==a&&(a=1):a=0)}),n,s,10):a=Y(i)?i:i?1:0,r||1!==a||(r=[],nd((function(t,e){r[e]=null!=t?t+"":""}),n,s,1/0)),o=r?r.length:n===Zc?s.length:s[0]?s[0].length:null}else if(e===Hc)r||(r=function(t){var e,n=0;for(;n<t.length&&!(e=t[n++]););if(e){var i=[];return P(e,(function(t,e){i.push(e)})),i}}(t));else if(e===Wc)r||(r=[],P(t,(function(t,e){r.push(e)})));else if(e===Fc){var l=wr(t[0]);o=F(l)&&l.length||1}return{startIndex:a,dimensionsDefine:ed(r),dimensionsDetectedCount:o}}(t,n,r,e.sourceHeader,e.dimensions);return new qp({data:t,sourceFormat:n,seriesLayoutBy:r,dimensionsDefine:o.dimensionsDefine,startIndex:o.startIndex,dimensionsDetectedCount:o.dimensionsDetectedCount,encodeDefine:Qp(i),metaRawOption:w(e)})}function Jp(t){return new qp({data:t,sourceFormat:Z(t)?Yc:Fc})}function Qp(t){return t?ht(t):null}function td(t){var e=Xc;if(Z(t))e=Yc;else if(F(t)){0===t.length&&(e=Gc);for(var n=0,i=t.length;n<i;n++){var r=t[n];if(null!=r){if(F(r)){e=Gc;break}if(X(r)){e=Hc;break}}}}else if(X(t))for(var o in t)if(dt(t,o)&&k(t[o])){e=Wc;break}return e}function ed(t){if(t){var e=ht();return O(t,(function(t,n){var i={name:(t=X(t)?t:{name:t}).name,displayName:t.displayName,type:t.type};if(null==i.name)return i;i.name+="",null==i.displayName&&(i.displayName=i.name);var r=e.get(i.name);return r?i.name+="-"+r.count++:e.set(i.name,{count:1}),i}))}}function nd(t,e,n,i){if(e===Zc)for(var r=0;r<n.length&&r<i;r++)t(n[r]?n[r][0]:null,r);else{var o=n[0]||[];for(r=0;r<o.length&&r<i;r++)t(o[r],r)}}var id=function(){function t(t,e){var n=Kp(t)?t:Jp(t);this._source=n;var i=this._data=n.data;n.sourceFormat===Yc&&(this._offset=0,this._dimSize=e,this._data=i),jp(this,i,n)}return t.prototype.getSource=function(){return this._source},t.prototype.count=function(){return 0},t.prototype.getItem=function(t,e){},t.prototype.appendData=function(t){},t.prototype.clean=function(){},t.protoInitialize=function(){var e=t.prototype;e.pure=!1,e.persistent=!0}(),t.internalField=function(){var t;jp=function(t,r,o){var a=o.sourceFormat,s=o.seriesLayoutBy,l=o.startIndex,u=o.dimensionsDefine,h=Zp[dd(a,s)];if(I(t,h),a===Yc)t.getItem=e,t.count=i,t.fillStorage=n;else{var c=ad(a,s);t.getItem=B(c,null,r,l,u);var p=ud(a,s);t.count=B(p,null,r,l,u)}};var e=function(t,e){t-=this._offset,e=e||[];for(var n=this._data,i=this._dimSize,r=i*t,o=0;o<i;o++)e[o]=n[r+o];return e},n=function(t,e,n,i){for(var r=this._data,o=this._dimSize,a=0;a<o;a++){for(var s=i[a],l=null==s[0]?1/0:s[0],u=null==s[1]?-1/0:s[1],h=e-t,c=n[a],p=0;p<h;p++){var d=r[p*o+a];c[t+p]=d,d<l&&(l=d),d>u&&(u=d)}s[0]=l,s[1]=u}},i=function(){return this._data?this._data.length/this._dimSize:0};function r(t){for(var e=0;e<t.length;e++)this._data.push(t[e])}(t={}).arrayRows_column={pure:!0,appendData:r},t.arrayRows_row={pure:!0,appendData:function(){throw new Error('Do not support appendData when set seriesLayoutBy: "row".')}},t.objectRows={pure:!0,appendData:r},t.keyedColumns={pure:!0,appendData:function(t){var e=this._data;P(t,(function(t,n){for(var i=e[n]||(e[n]=[]),r=0;r<(t||[]).length;r++)i.push(t[r])}))}},t.original={appendData:r},t.typedArray={persistent:!1,pure:!0,appendData:function(t){this._data=t},clean:function(){this._offset+=this.count(),this._data=null}},Zp=t}(),t}(),rd=function(t,e,n,i){return t[i]},od=((Yp={}).arrayRows_column=function(t,e,n,i){return t[i+e]},Yp.arrayRows_row=function(t,e,n,i){i+=e;for(var r=[],o=t,a=0;a<o.length;a++){var s=o[a];r.push(s?s[i]:null)}return r},Yp.objectRows=rd,Yp.keyedColumns=function(t,e,n,i){for(var r=[],o=0;o<n.length;o++){var a=n[o].name;0;var s=t[a];r.push(s?s[i]:null)}return r},Yp.original=rd,Yp);function ad(t,e){var n=od[dd(t,e)];return n}var sd=function(t,e,n){return t.length},ld=((Xp={}).arrayRows_column=function(t,e,n){return Math.max(0,t.length-e)},Xp.arrayRows_row=function(t,e,n){var i=t[0];return i?Math.max(0,i.length-e):0},Xp.objectRows=sd,Xp.keyedColumns=function(t,e,n){var i=n[0].name;var r=t[i];return r?r.length:0},Xp.original=sd,Xp);function ud(t,e){var n=ld[dd(t,e)];return n}var hd=function(t,e,n){return null!=e?t[e]:t},cd=((Up={}).arrayRows=hd,Up.objectRows=function(t,e,n){return null!=e?t[n]:t},Up.keyedColumns=hd,Up.original=function(t,e,n){var i=wr(t);return null!=e&&i instanceof Array?i[e]:i},Up.typedArray=hd,Up);function pd(t){var e=cd[t];return e}function dd(t,e){return t===Gc?t+"_"+e:t}function fd(t,e,n){if(t){var i=t.getRawDataItem(e);if(null!=i){var r,o,a=t.getProvider().getSource().sourceFormat,s=t.getDimensionInfo(n);return s&&(r=s.name,o=s.index),pd(a)(i,o,r)}}}var gd=/\{@(.+?)\}/g,yd=function(){function t(){}return t.prototype.getDataParams=function(t,e){var n=this.getData(e),i=this.getRawValue(t,e),r=n.getRawIndex(t),o=n.getName(t),a=n.getRawDataItem(t),s=n.getItemVisual(t,"style"),l=s&&s[n.getItemVisual(t,"drawType")||"fill"],u=s&&s.stroke,h=this.mainType,c="series"===h,p=n.userOutput;return{componentType:h,componentSubType:this.subType,componentIndex:this.componentIndex,seriesType:c?this.subType:null,seriesIndex:this.seriesIndex,seriesId:c?this.id:null,seriesName:c?this.name:null,name:o,dataIndex:r,data:a,dataType:e,value:i,color:l,borderColor:u,dimensionNames:p?p.dimensionNames:null,encode:p?p.encode:null,$vars:["seriesName","name","value"]}},t.prototype.getFormattedLabel=function(t,e,n,i,r,o){e=e||"normal";var a=this.getData(n),s=this.getDataParams(t,n);(o&&(s.value=o.interpolatedValue),null!=i&&F(s.value)&&(s.value=s.value[i]),r)||(r=a.getItemModel(t).get("normal"===e?["label","formatter"]:[e,"label","formatter"]));return"function"==typeof r?(s.status=e,s.dimensionIndex=i,r(s)):"string"==typeof r?_c(r,s).replace(gd,(function(e,n){var i=n.length,r="["===n.charAt(0)&&"]"===n.charAt(i-1)?+n.slice(1,i-1):n,s=fd(a,t,r);if(o&&F(o.interpolatedValue)){var l=a.getDimensionInfo(r);l&&(s=o.interpolatedValue[l.index])}return null!=s?s+"":""})):void 0},t.prototype.getRawValue=function(t,e){return fd(this.getData(e),t)},t.prototype.formatTooltip=function(t,e,n){},t}();function vd(t){var e,n;return X(t)?t.type&&(n=t):e=t,{markupText:e,markupFragment:n}}function md(t){return new _d(t)}var _d=function(){function t(t){t=t||{},this._reset=t.reset,this._plan=t.plan,this._count=t.count,this._onDirty=t.onDirty,this._dirty=!0}return t.prototype.perform=function(t){var e,n=this._upstream,i=t&&t.skip;if(this._dirty&&n){var r=this.context;r.data=r.outputData=n.context.outputData}this.__pipeline&&(this.__pipeline.currentTask=this),this._plan&&!i&&(e=this._plan(this.context));var o,a=h(this._modBy),s=this._modDataCount||0,l=h(t&&t.modBy),u=t&&t.modDataCount||0;function h(t){return!(t>=1)&&(t=1),t}a===l&&s===u||(e="reset"),(this._dirty||"reset"===e)&&(this._dirty=!1,o=this._doReset(i)),this._modBy=l,this._modDataCount=u;var c=t&&t.step;if(this._dueEnd=n?n._outputDueEnd:this._count?this._count(this.context):1/0,this._progress){var p=this._dueIndex,d=Math.min(null!=c?this._dueIndex+c:1/0,this._dueEnd);if(!i&&(o||p<d)){var f=this._progress;if(F(f))for(var g=0;g<f.length;g++)this._doProgress(f[g],p,d,l,u);else this._doProgress(f,p,d,l,u)}this._dueIndex=d;var y=null!=this._settedOutputEnd?this._settedOutputEnd:d;0,this._outputDueEnd=y}else this._dueIndex=this._outputDueEnd=null!=this._settedOutputEnd?this._settedOutputEnd:this._dueEnd;return this.unfinished()},t.prototype.dirty=function(){this._dirty=!0,this._onDirty&&this._onDirty(this.context)},t.prototype._doProgress=function(t,e,n,i,r){xd.reset(e,n,i,r),this._callingProgress=t,this._callingProgress({start:e,end:n,count:n-e,next:xd.next},this.context)},t.prototype._doReset=function(t){var e,n;this._dueIndex=this._outputDueEnd=this._dueEnd=0,this._settedOutputEnd=null,!t&&this._reset&&((e=this._reset(this.context))&&e.progress&&(n=e.forceFirstProgress,e=e.progress),F(e)&&!e.length&&(e=null)),this._progress=e,this._modBy=this._modDataCount=null;var i=this._downstream;return i&&i.dirty(),n},t.prototype.unfinished=function(){return this._progress&&this._dueIndex<this._dueEnd},t.prototype.pipe=function(t){(this._downstream!==t||this._dirty)&&(this._downstream=t,t._upstream=this,t.dirty())},t.prototype.dispose=function(){this._disposed||(this._upstream&&(this._upstream._downstream=null),this._downstream&&(this._downstream._upstream=null),this._dirty=!1,this._disposed=!0)},t.prototype.getUpstream=function(){return this._upstream},t.prototype.getDownstream=function(){return this._downstream},t.prototype.setOutputEnd=function(t){this._outputDueEnd=this._settedOutputEnd=t},t}(),xd=function(){var t,e,n,i,r,o={reset:function(l,u,h,c){e=l,t=u,n=h,i=c,r=Math.ceil(i/n),o.next=n>1&&i>0?s:a}};return o;function a(){return e<t?e++:null}function s(){var o=e%r*n+Math.ceil(e/r),a=e>=t?null:o<i?o:e;return e++,a}}();function bd(t,e){var n=e&&e.type;if("ordinal"===n){var i=e&&e.ordinalMeta;return i?i.parseAndCollect(t):t}return"time"===n&&"number"!=typeof t&&null!=t&&"-"!==t&&(t=+rr(t)),null==t||""===t?NaN:+t}var wd=ht({number:function(t){return parseFloat(t)},time:function(t){return+rr(t)},trim:function(t){return"string"==typeof t?ot(t):t}});function Sd(t){return wd.get(t)}var Md={lt:function(t,e){return t<e},lte:function(t,e){return t<=e},gt:function(t,e){return t>e},gte:function(t,e){return t>=e}},Id=function(){function t(t,e){if("number"!=typeof e){var n="";0,yr(n)}this._opFn=Md[t],this._rvalFloat=hr(e)}return t.prototype.evaluate=function(t){return"number"==typeof t?this._opFn(t,this._rvalFloat):this._opFn(hr(t),this._rvalFloat)},t}(),Td=function(){function t(t,e){var n="desc"===t;this._resultLT=n?1:-1,null==e&&(e=n?"min":"max"),this._incomparable="min"===e?-1/0:1/0}return t.prototype.evaluate=function(t,e){var n=typeof t,i=typeof e,r="number"===n?t:hr(t),o="number"===i?e:hr(e),a=isNaN(r),s=isNaN(o);if(a&&(r=this._incomparable),s&&(o=this._incomparable),a&&s){var l="string"===n,u="string"===i;l&&(r=u?t:0),u&&(o=l?e:0)}return r<o?this._resultLT:r>o?-this._resultLT:0},t}(),Cd=function(){function t(t,e){this._rval=e,this._isEQ=t,this._rvalTypeof=typeof e,this._rvalFloat=hr(e)}return t.prototype.evaluate=function(t){var e=t===this._rval;if(!e){var n=typeof t;n===this._rvalTypeof||"number"!==n&&"number"!==this._rvalTypeof||(e=hr(t)===this._rvalFloat)}return this._isEQ?e:!e},t}();function Ad(t,e){return"eq"===t||"ne"===t?new Cd("eq"===t,e):dt(Md,t)?new Id(t,e):null}var Dd=function(){function t(){}return t.prototype.getRawData=function(){throw new Error("not supported")},t.prototype.getRawDataItem=function(t){throw new Error("not supported")},t.prototype.cloneRawData=function(){},t.prototype.getDimensionInfo=function(t){},t.prototype.cloneAllDimensionInfo=function(){},t.prototype.count=function(){},t.prototype.retrieveValue=function(t,e){},t.prototype.retrieveValueFromItem=function(t,e){},t.prototype.convertValue=function(t,e){return bd(t,e)},t}();function Ld(t){var e=t.sourceFormat;if(!Ed(e)){var n="";0,yr(n)}return t.data}function kd(t){var e=t.sourceFormat,n=t.data;if(!Ed(e)){var i="";0,yr(i)}if(e===Gc){for(var r=[],o=0,a=n.length;o<a;o++)r.push(n[o].slice());return r}if(e===Hc){for(r=[],o=0,a=n.length;o<a;o++)r.push(I({},n[o]));return r}}function Pd(t,e,n){if(null!=n)return"number"==typeof n||!isNaN(n)&&!dt(e,n)?t[n]:dt(e,n)?e[n]:void 0}function Od(t){return w(t)}var Rd=ht();function Nd(t,e,n,i){var r="";e.length||yr(r),X(t)||yr(r);var o=t.type,a=Rd.get(o);a||yr(r);var s=O(e,(function(t){return function(t,e){var n=new Dd,i=t.data,r=n.sourceFormat=t.sourceFormat,o=t.startIndex,a="";t.seriesLayoutBy!==Uc&&yr(a);var s=[],l={},u=t.dimensionsDefine;if(u)P(u,(function(t,e){var n=t.name,i={index:e,name:n,displayName:t.displayName};if(s.push(i),null!=n){var r="";dt(l,n)&&yr(r),l[n]=i}}));else for(var h=0;h<t.dimensionsDetectedCount;h++)s.push({index:h});var c=ad(r,Uc);e.__isBuiltIn&&(n.getRawDataItem=function(t){return c(i,o,s,t)},n.getRawData=B(Ld,null,t)),n.cloneRawData=B(kd,null,t);var p=ud(r,Uc);n.count=B(p,null,i,o,s);var d=pd(r);n.retrieveValue=function(t,e){var n=c(i,o,s,t);return f(n,e)};var f=n.retrieveValueFromItem=function(t,e){if(null!=t){var n=s[e];return n?d(t,e,n.name):void 0}};return n.getDimensionInfo=B(Pd,null,s,l),n.cloneAllDimensionInfo=B(Od,null,s),n}(t,a)})),l=_r(a.transform({upstream:s[0],upstreamList:s,config:w(t.config)}));return O(l,(function(t,n){var i,r="";X(t)||yr(r),t.data||yr(r),Ed(td(t.data))||yr(r);var o=e[0];if(o&&0===n&&!t.dimensions){var a=o.startIndex;a&&(t.data=o.data.slice(0,a).concat(t.data)),i={seriesLayoutBy:Uc,sourceHeader:a,dimensions:o.metaRawOption.dimensions}}else i={seriesLayoutBy:Uc,sourceHeader:0,dimensions:t.dimensions};return $p(t.data,i,null,null)}))}function Ed(t){return t===Gc||t===Hc}var zd=function(){function t(t){this._sourceList=[],this._upstreamSignList=[],this._versionSignBase=0,this._sourceHost=t}return t.prototype.dirty=function(){this._setLocalSource([],[])},t.prototype._setLocalSource=function(t,e){this._sourceList=t,this._upstreamSignList=e,this._versionSignBase++,this._versionSignBase>9e10&&(this._versionSignBase=0)},t.prototype._getVersionSign=function(){return this._sourceHost.uid+"_"+this._versionSignBase},t.prototype.prepareSource=function(){this._isDirty()&&this._createSource()},t.prototype._createSource=function(){this._setLocalSource([],[]);var t,e,n=this._sourceHost,i=this._getUpstreamSourceManagers(),r=!!i.length;if(Vd(n)){var o=n,a=void 0,s=void 0,l=void 0;if(r){var u=i[0];u.prepareSource(),a=(l=u.getSource()).data,s=l.sourceFormat,e=[u._getVersionSign()]}else s=Z(a=o.get("data",!0))?Yc:Fc,e=[];var h=this._getSourceMetaRawOption(),c=l?l.metaRawOption:null;t=[$p(a,{seriesLayoutBy:tt(h.seriesLayoutBy,c?c.seriesLayoutBy:null),sourceHeader:tt(h.sourceHeader,c?c.sourceHeader:null),dimensions:tt(h.dimensions,c?c.dimensions:null)},s,o.get("encode",!0))]}else{var p=n;if(r){var d=this._applyTransform(i);t=d.sourceList,e=d.upstreamSignList}else{t=[$p(p.get("source",!0),this._getSourceMetaRawOption(),null,null)],e=[]}}this._setLocalSource(t,e)},t.prototype._applyTransform=function(t){var e,n=this._sourceHost,i=n.get("transform",!0),r=n.get("fromTransformResult",!0);if(null!=r){var o="";1!==t.length&&Fd(o)}var a,s=[],l=[];return P(t,(function(t){t.prepareSource();var e=t.getSource(r||0),n="";null==r||e||Fd(n),s.push(e),l.push(t._getVersionSign())})),i?e=function(t,e,n){var i=_r(t),r=i.length,o="";r||yr(o);for(var a=0,s=r;a<s;a++)e=Nd(i[a],e),a!==s-1&&(e.length=Math.max(e.length,1));return e}(i,s,n.componentIndex):null!=r&&(e=[(a=s[0],new qp({data:a.data,sourceFormat:a.sourceFormat,seriesLayoutBy:a.seriesLayoutBy,dimensionsDefine:w(a.dimensionsDefine),startIndex:a.startIndex,dimensionsDetectedCount:a.dimensionsDetectedCount,encodeDefine:Qp(a.encodeDefine)}))]),{sourceList:e,upstreamSignList:l}},t.prototype._isDirty=function(){if(!this._sourceList.length)return!0;for(var t=this._getUpstreamSourceManagers(),e=0;e<t.length;e++){var n=t[e];if(n._isDirty()||this._upstreamSignList[e]!==n._getVersionSign())return!0}},t.prototype.getSource=function(t){return this._sourceList[t||0]},t.prototype._getUpstreamSourceManagers=function(){var t=this._sourceHost;if(Vd(t)){var e=tp(t);return e?[e.getSourceManager()]:[]}return O(function(t){return t.get("transform",!0)||t.get("fromTransformResult",!0)?Nr(t.ecModel,"dataset",{index:t.get("fromDatasetIndex",!0),id:t.get("fromDatasetId",!0)},Or).models:[]}(t),(function(t){return t.getSourceManager()}))},t.prototype._getSourceMetaRawOption=function(){var t,e,n,i=this._sourceHost;if(Vd(i))t=i.get("seriesLayoutBy",!0),e=i.get("sourceHeader",!0),n=i.get("dimensions",!0);else if(!this._getUpstreamSourceManagers().length){var r=i;t=r.get("seriesLayoutBy",!0),e=r.get("sourceHeader",!0),n=r.get("dimensions",!0)}return{seriesLayoutBy:t,sourceHeader:e,dimensions:n}},t}();function Bd(t){t.option.transform&&st(t.option.transform)}function Vd(t){return"series"===t.mainType}function Fd(t){throw new Error(t)}function Gd(t,e){var n=t.color||"#6e7079",i=t.fontSize||12,r=t.fontWeight||"400",o=t.color||"#464646",a=t.fontSize||14,s=t.fontWeight||"900";return"html"===e?{nameStyle:"font-size:"+gc(i+"")+"px;color:"+gc(n)+";font-weight:"+gc(r+""),valueStyle:"font-size:"+gc(a+"")+"px;color:"+gc(o)+";font-weight:"+gc(s+"")}:{nameStyle:{fontSize:i,fill:n,fontWeight:r},valueStyle:{fontSize:a,fill:o,fontWeight:s}}}var Hd=[0,10,20,30],Wd=["","\n","\n\n","\n\n\n"];function Yd(t,e){return e.type=t,e}function Xd(t){return dt(Ud,t.type)&&Ud[t.type]}var Ud={section:{planLayout:function(t){var e=t.blocks.length,n=e>1||e>0&&!t.noHeader,i=0;P(t.blocks,(function(t){Xd(t).planLayout(t);var e=t.__gapLevelBetweenSubBlocks;e>=i&&(i=e+(!n||e&&("section"!==t.type||t.noHeader)?0:1))})),t.__gapLevelBetweenSubBlocks=i},build:function(t,e,n,i){var r=e.noHeader,o=jd(e),a=function(t,e,n,i){var r=[],o=e.blocks||[];rt(!o||F(o)),o=o||[];var a=t.orderMode;if(e.sortBlocks&&a){o=o.slice();var s={valueAsc:"asc",valueDesc:"desc"};if(dt(s,a)){var l=new Td(s[a],null);o.sort((function(t,e){return l.evaluate(t.sortParam,e.sortParam)}))}else"seriesDesc"===a&&o.reverse()}var u=jd(e);if(P(o,(function(e,n){var o=Xd(e).build(t,e,n>0?u.html:0,i);null!=o&&r.push(o)})),!r.length)return;return"richText"===t.renderMode?r.join(u.richText):qd(r.join(""),n)}(t,e,r?n:o.html,i);if(r)return a;var s=yc(e.header,"ordinal",t.useUTC),l=Gd(i,t.renderMode).nameStyle;return"richText"===t.renderMode?Kd(t,s,l)+o.richText+a:qd('<div style="'+l+";"+'line-height:1;">'+gc(s)+"</div>"+a,n)}},nameValue:{planLayout:function(t){t.__gapLevelBetweenSubBlocks=0},build:function(t,e,n,i){var r=t.renderMode,o=e.noName,a=e.noValue,s=!e.markerType,l=e.name,u=e.value,h=t.useUTC;if(!o||!a){var c=s?"":t.markupStyleCreator.makeTooltipMarker(e.markerType,e.markerColor||"#333",r),p=o?"":yc(l,"ordinal",h),d=e.valueType,f=a?[]:F(u)?O(u,(function(t,e){return yc(t,F(d)?d[e]:d,h)})):[yc(u,F(d)?d[0]:d,h)],g=!s||!o,y=!s&&o,v=Gd(i,r),m=v.nameStyle,_=v.valueStyle;return"richText"===r?(s?"":c)+(o?"":Kd(t,p,m))+(a?"":function(t,e,n,i,r){var o=[r],a=i?10:20;return n&&o.push({padding:[0,0,0,a],align:"right"}),t.markupStyleCreator.wrapRichTextStyle(e.join("  "),o)}(t,f,g,y,_)):qd((s?"":c)+(o?"":function(t,e,n){return'<span style="'+n+";"+(e?"margin-left:2px":"")+'">'+gc(t)+"</span>"}(p,!s,m))+(a?"":function(t,e,n,i){var r=n?"10px":"20px";return'<span style="'+(e?"float:right;margin-left:"+r:"")+";"+i+'">'+O(t,(function(t){return gc(t)})).join("&nbsp;&nbsp;")+"</span>"}(f,g,y,_)),n)}}}};function Zd(t,e,n,i,r,o){if(t){var a=Xd(t);a.planLayout(t);var s={useUTC:r,renderMode:n,orderMode:i,markupStyleCreator:e};return a.build(s,t,0,o)}}function jd(t){var e=t.__gapLevelBetweenSubBlocks;return{html:Hd[e],richText:Wd[e]}}function qd(t,e){return'<div style="'+("margin: "+e+"px 0 0")+";"+'line-height:1;">'+t+'<div style="clear:both"></div></div>'}function Kd(t,e,n){return t.markupStyleCreator.wrapRichTextStyle(e,n)}function $d(t,e){return bc(t.getData().getItemVisual(e,"style")[t.visualDrawType])}function Jd(t,e){var n=t.get("padding");return null!=n?n:"richText"===e?[8,10]:10}var Qd=function(){function t(){this.richTextStyles={},this._nextStyleNameId=pr()}return t.prototype._generateStyleName=function(){return"__EC_aUTo_"+this._nextStyleNameId++},t.prototype.makeTooltipMarker=function(t,e,n){var i="richText"===n?this._generateStyleName():null,r=xc({color:e,type:t,renderMode:n,markerId:i});return H(r)?r:(this.richTextStyles[i]=r.style,r.content)},t.prototype.wrapRichTextStyle=function(t,e){var n={};F(e)?P(e,(function(t){return I(n,t)})):I(n,e);var i=this._generateStyleName();return this.richTextStyles[i]=n,"{"+i+"|"+t+"}"},t}();function tf(t){var e,n,i,r,o=t.series,a=t.dataIndex,s=t.multipleSeries,l=o.getData(),u=l.mapDimensionsAll("defaultedTooltip"),h=u.length,c=o.getRawValue(a),p=F(c),d=$d(o,a);if(h>1||p&&!h){var f=function(t,e,n,i,r){var o=e.getData(),a=R(t,(function(t,e,n){var i=o.getDimensionInfo(n);return t||i&&!1!==i.tooltip&&null!=i.displayName}),!1),s=[],l=[],u=[];function h(t,e){var n=o.getDimensionInfo(e);n&&!1!==n.otherDims.tooltip&&(a?u.push(Yd("nameValue",{markerType:"subItem",markerColor:r,name:n.displayName,value:t,valueType:n.type})):(s.push(t),l.push(n.type)))}return i.length?P(i,(function(t){h(fd(o,n,t),t)})):P(t,h),{inlineValues:s,inlineValueTypes:l,blocks:u}}(c,o,a,u,d);e=f.inlineValues,n=f.inlineValueTypes,i=f.blocks,r=f.inlineValues[0]}else if(h){var g=l.getDimensionInfo(u[0]);r=e=fd(l,a,u[0]),n=g.type}else r=e=p?c[0]:c;var y=Cr(o),v=y&&o.name||"",m=l.getName(a),_=s?v:m;return Yd("section",{header:v,noHeader:s||!y,sortParam:r,blocks:[Yd("nameValue",{markerType:"item",markerColor:d,name:_,noName:!ot(_),value:e,valueType:n})].concat(i||[])})}var ef=Lr();function nf(t,e){return t.getName(e)||t.getId(e)}var rf=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._selectedDataIndicesMap={},e}return n(e,t),e.prototype.init=function(t,e,n){this.seriesIndex=this.componentIndex,this.dataTask=md({count:af,reset:sf}),this.dataTask.context={model:this},this.mergeDefaultAndTheme(t,n),(ef(this).sourceManager=new zd(this)).prepareSource();var i=this.getInitialData(t,n);uf(i,this),this.dataTask.context.data=i,ef(this).dataBeforeProcessed=i,of(this),this._initSelectedMapFromData(i)},e.prototype.mergeDefaultAndTheme=function(t,e){var n=Lc(this),i=n?Pc(t):{},r=this.subType;Nc.hasClass(r)&&(r+="Series"),S(t,e.getTheme().get(this.subType)),S(t,this.getDefaultOption()),xr(t,"label",["show"]),this.fillDataTextStyle(t.data),n&&kc(t,i,n)},e.prototype.mergeOption=function(t,e){t=S(this.option,t,!0),this.fillDataTextStyle(t.data);var n=Lc(this);n&&kc(this.option,t,n);var i=ef(this).sourceManager;i.dirty(),i.prepareSource();var r=this.getInitialData(t,e);uf(r,this),this.dataTask.dirty(),this.dataTask.context.data=r,ef(this).dataBeforeProcessed=r,of(this),this._initSelectedMapFromData(r)},e.prototype.fillDataTextStyle=function(t){if(t&&!Z(t))for(var e=["show"],n=0;n<t.length;n++)t[n]&&t[n].label&&xr(t[n],"label",e)},e.prototype.getInitialData=function(t,e){},e.prototype.appendData=function(t){this.getRawData().appendData(t.data)},e.prototype.getData=function(t){var e=cf(this);if(e){var n=e.context.data;return null==t?n:n.getLinkedData(t)}return ef(this).data},e.prototype.getAllData=function(){var t=this.getData();return t&&t.getLinkedDataAll?t.getLinkedDataAll():[{data:t}]},e.prototype.setData=function(t){var e=cf(this);if(e){var n=e.context;n.outputData=t,e!==this.dataTask&&(n.data=t)}ef(this).data=t},e.prototype.getSource=function(){return ef(this).sourceManager.getSource()},e.prototype.getRawData=function(){return ef(this).dataBeforeProcessed},e.prototype.getBaseAxis=function(){var t=this.coordinateSystem;return t&&t.getBaseAxis&&t.getBaseAxis()},e.prototype.formatTooltip=function(t,e,n){return tf({series:this,dataIndex:t,multipleSeries:e})},e.prototype.isAnimationEnabled=function(){if(a.node)return!1;var t=this.getShallow("animation");return t&&this.getData().count()>this.getShallow("animationThreshold")&&(t=!1),!!t},e.prototype.restoreData=function(){this.dataTask.dirty()},e.prototype.getColorFromPalette=function(t,e,n){var i=this.ecModel,r=up.prototype.getColorFromPalette.call(this,t,e,n);return r||(r=i.getColorFromPalette(t,e,n)),r},e.prototype.coordDimToDataDim=function(t){return this.getRawData().mapDimensionsAll(t)},e.prototype.getProgressive=function(){return this.get("progressive")},e.prototype.getProgressiveThreshold=function(){return this.get("progressiveThreshold")},e.prototype.select=function(t,e){this._innerSelect(this.getData(e),t)},e.prototype.unselect=function(t,e){var n=this.option.selectedMap;if(n)for(var i=this.getData(e),r=0;r<t.length;r++){var o=nf(i,t[r]);n[o]=!1,this._selectedDataIndicesMap[o]=-1}},e.prototype.toggleSelect=function(t,e){for(var n=[],i=0;i<t.length;i++)n[0]=t[i],this.isSelected(t[i],e)?this.unselect(n,e):this.select(n,e)},e.prototype.getSelectedDataIndices=function(){for(var t=this._selectedDataIndicesMap,e=z(t),n=[],i=0;i<e.length;i++){var r=t[e[i]];r>=0&&n.push(r)}return n},e.prototype.isSelected=function(t,e){var n=this.option.selectedMap;return n&&n[nf(this.getData(e),t)]||!1},e.prototype._innerSelect=function(t,e){var n,i,r=this.option.selectedMode,o=e.length;if(r&&o)if("multiple"===r)for(var a=this.option.selectedMap||(this.option.selectedMap={}),s=0;s<o;s++){var l=e[s];a[h=nf(t,l)]=!0,this._selectedDataIndicesMap[h]=t.getRawIndex(l)}else if("single"===r||!0===r){var u=e[o-1],h=nf(t,u);this.option.selectedMap=((n={})[h]=!0,n),this._selectedDataIndicesMap=((i={})[h]=t.getRawIndex(u),i)}},e.prototype._initSelectedMapFromData=function(t){if(!this.option.selectedMap){var e=[];t.hasItemOption&&t.each((function(n){var i=t.getRawDataItem(n);"object"==typeof i&&i.selected&&e.push(n)})),e.length>0&&this._innerSelect(t,e)}},e.registerClass=function(t){return Nc.registerClass(t)},e.protoInitialize=function(){var t=e.prototype;t.type="series.__base__",t.seriesIndex=0,t.useColorPaletteOnData=!1,t.ignoreStyleOnData=!1,t.hasSymbolVisual=!1,t.defaultSymbol="circle",t.visualStyleAccessPath="itemStyle",t.visualDrawType="fill"}(),e}(Nc);function of(t){var e=t.name;Cr(t)||(t.name=function(t){var e=t.getRawData(),n=e.mapDimensionsAll("seriesName"),i=[];return P(n,(function(t){var n=e.getDimensionInfo(t);n.displayName&&i.push(n.displayName)})),i.join(" ")}(t)||e)}function af(t){return t.model.getRawData().count()}function sf(t){var e=t.model;return e.setData(e.getRawData().cloneShallow()),lf}function lf(t,e){e.outputData&&t.end>e.outputData.count()&&e.model.getRawData().cloneShallow(e.outputData)}function uf(t,e){P(r(t.CHANGABLE_METHODS,t.DOWNSAMPLE_METHODS),(function(n){t.wrapMethod(n,V(hf,e))}))}function hf(t,e){var n=cf(t);return n&&n.setOutputEnd((e||this).count()),e}function cf(t){var e=(t.ecModel||{}).scheduler,n=e&&e.getPipeline(t.uid);if(n){var i=n.currentTask;if(i){var r=i.agentStubMap;r&&(i=r.get(t.uid))}return i}}L(rf,yd),L(rf,up),Yr(rf,Nc);var pf=function(){function t(){this.group=new zi,this.uid=Ih("viewComponent")}return t.prototype.init=function(t,e){},t.prototype.render=function(t,e,n,i){},t.prototype.dispose=function(t,e){},t.prototype.updateView=function(t,e,n,i){},t.prototype.updateLayout=function(t,e,n,i){},t.prototype.updateVisual=function(t,e,n,i){},t.prototype.blurSeries=function(t,e){},t}();function df(){var t=Lr();return function(e){var n=t(e),i=e.pipelineContext,r=!!n.large,o=!!n.progressiveRender,a=n.large=!(!i||!i.large),s=n.progressiveRender=!(!i||!i.progressiveRender);return!(r===a&&o===s)&&"reset"}}Hr(pf),jr(pf);var ff=Lr(),gf=df(),yf=function(){function t(){this.group=new zi,this.uid=Ih("viewChart"),this.renderTask=md({plan:_f,reset:xf}),this.renderTask.context={view:this}}return t.prototype.init=function(t,e){},t.prototype.render=function(t,e,n,i){},t.prototype.highlight=function(t,e,n,i){mf(t.getData(),i,"emphasis")},t.prototype.downplay=function(t,e,n,i){mf(t.getData(),i,"normal")},t.prototype.remove=function(t,e){this.group.removeAll()},t.prototype.dispose=function(t,e){},t.prototype.updateView=function(t,e,n,i){this.render(t,e,n,i)},t.prototype.updateLayout=function(t,e,n,i){this.render(t,e,n,i)},t.prototype.updateVisual=function(t,e,n,i){this.render(t,e,n,i)},t.markUpdateMethod=function(t,e){ff(t).updateMethod=e},t.protoInitialize=void(t.prototype.type="chart"),t}();function vf(t,e,n){t&&("emphasis"===e?Hs:Ws)(t,n)}function mf(t,e,n){var i=Dr(t,e),r=e&&null!=e.highlightKey?function(t){var e=ms[t];return null==e&&vs<=32&&(e=ms[t]=vs++),e}(e.highlightKey):null;null!=i?P(_r(i),(function(e){vf(t.getItemGraphicEl(e),n,r)})):t.eachItemGraphicEl((function(t){vf(t,n,r)}))}function _f(t){return gf(t.model)}function xf(t){var e=t.model,n=t.ecModel,i=t.api,r=t.payload,o=e.pipelineContext.progressiveRender,a=t.view,s=r&&ff(r).updateMethod,l=o?"incrementalPrepareRender":s&&a[s]?s:"render";return"render"!==l&&a[l](e,n,i,r),bf[l]}Hr(yf),jr(yf);var bf={incrementalPrepareRender:{progress:function(t,e){e.view.incrementalRender(t,e.model,e.ecModel,e.api,e.payload)}},render:{forceFirstProgress:!0,progress:function(t,e){e.view.render(e.model,e.ecModel,e.api,e.payload)}}},wf="\0__throttleOriginMethod",Sf="\0__throttleRate",Mf="\0__throttleType";function If(t,e,n){var i,r,o,a,s,l=0,u=0,h=null;function c(){u=(new Date).getTime(),h=null,t.apply(o,a||[])}e=e||0;var p=function(){for(var t=[],p=0;p<arguments.length;p++)t[p]=arguments[p];i=(new Date).getTime(),o=this,a=t;var d=s||e,f=s||n;s=null,r=i-(f?l:u)-d,clearTimeout(h),f?h=setTimeout(c,d):r>=0?c():h=setTimeout(c,-r),l=i};return p.clear=function(){h&&(clearTimeout(h),h=null)},p.debounceNextCall=function(t){s=t},p}function Tf(t,e,n,i){var r=t[e];if(r){var o=r[wf]||r,a=r[Mf];if(r[Sf]!==n||a!==i){if(null==n||!i)return t[e]=o;(r=t[e]=If(o,n,"debounce"===i))[wf]=o,r[Mf]=i,r[Sf]=n}return r}}var Cf=Lr(),Af={itemStyle:qr(xh,!0),lineStyle:qr(vh,!0)},Df={lineStyle:"stroke",itemStyle:"fill"};function Lf(t,e){var n=t.visualStyleMapper||Af[e];return n||(console.warn("Unkown style type '"+e+"'."),Af.itemStyle)}function kf(t,e){var n=t.visualDrawType||Df[e];return n||(console.warn("Unkown style type '"+e+"'."),"fill")}var Pf={createOnAllSeries:!0,performRawSeries:!0,reset:function(t,e){var n=t.getData(),i=t.visualStyleAccessPath||"itemStyle",r=t.getModel(i),o=Lf(t,i)(r),a=r.getShallow("decal");a&&(n.setVisual("decal",a),a.dirty=!0);var s=kf(t,i),l=o[s],u=G(l)?l:null;if(o[s]&&!u||(o[s]=t.getColorFromPalette(t.name,null,e.getSeriesCount()),n.setVisual("colorFromPalette",!0)),n.setVisual("style",o),n.setVisual("drawType",s),!e.isSeriesFiltered(t)&&u)return n.setVisual("colorFromPalette",!1),{dataEach:function(e,n){var i=t.getDataParams(n),r=I({},o);r[s]=u(i),e.setItemVisual(n,"style",r)}}}},Of=new Sh,Rf={createOnAllSeries:!0,performRawSeries:!0,reset:function(t,e){if(!t.ignoreStyleOnData&&!e.isSeriesFiltered(t)){var n=t.getData(),i=t.visualStyleAccessPath||"itemStyle",r=Lf(t,i),o=n.getVisual("drawType");return{dataEach:n.hasItemOption?function(t,e){var n=t.getRawDataItem(e);if(n&&n[i]){Of.option=n[i];var a=r(Of);I(t.ensureUniqueItemVisual(e,"style"),a),Of.option.decal&&(t.setItemVisual(e,"decal",Of.option.decal),Of.option.decal.dirty=!0),o in a&&t.setItemVisual(e,"colorFromPalette",!1)}}:null}}}},Nf={performRawSeries:!0,overallReset:function(t){var e=ht();t.eachSeries((function(t){if(t.useColorPaletteOnData){var n=e.get(t.type);n||(n={},e.set(t.type,n)),Cf(t).scope=n}})),t.eachSeries((function(e){if(e.useColorPaletteOnData&&!t.isSeriesFiltered(e)){var n=e.getRawData(),i={},r=e.getData(),o=Cf(e).scope,a=e.visualStyleAccessPath||"itemStyle",s=kf(e,a);r.each((function(t){var e=r.getRawIndex(t);i[e]=t})),n.each((function(t){var a=i[t];if(r.getItemVisual(a,"colorFromPalette")){var l=r.ensureUniqueItemVisual(a,"style"),u=n.getName(t)||t+"",h=n.count();l[s]=e.getColorFromPalette(u,o,h)}}))}}))}},Ef=Math.PI;var zf=function(){function t(t,e,n,i){this._stageTaskMap=ht(),this.ecInstance=t,this.api=e,n=this._dataProcessorHandlers=n.slice(),i=this._visualHandlers=i.slice(),this._allHandlers=n.concat(i)}return t.prototype.restoreData=function(t,e){t.restoreData(e),this._stageTaskMap.each((function(t){var e=t.overallTask;e&&e.dirty()}))},t.prototype.getPerformArgs=function(t,e){if(t.__pipeline){var n=this._pipelineMap.get(t.__pipeline.id),i=n.context,r=!e&&n.progressiveEnabled&&(!i||i.progressiveRender)&&t.__idxInPipeline>n.blockIndex?n.step:null,o=i&&i.modDataCount;return{step:r,modBy:null!=o?Math.ceil(o/r):null,modDataCount:o}}},t.prototype.getPipeline=function(t){return this._pipelineMap.get(t)},t.prototype.updateStreamModes=function(t,e){var n=this._pipelineMap.get(t.uid),i=t.getData().count(),r=n.progressiveEnabled&&e.incrementalPrepareRender&&i>=n.threshold,o=t.get("large")&&i>=t.get("largeThreshold"),a="mod"===t.get("progressiveChunkMode")?i:null;t.pipelineContext=n.context={progressiveRender:r,modDataCount:a,large:o}},t.prototype.restorePipelines=function(t){var e=this,n=e._pipelineMap=ht();t.eachSeries((function(t){var i=t.getProgressive(),r=t.uid;n.set(r,{id:r,head:null,tail:null,threshold:t.getProgressiveThreshold(),progressiveEnabled:i&&!(t.preventIncremental&&t.preventIncremental()),blockIndex:-1,step:Math.round(i||700),count:0}),e._pipe(t,t.dataTask)}))},t.prototype.prepareStageTasks=function(){var t=this._stageTaskMap,e=this.api.getModel(),n=this.api;P(this._allHandlers,(function(i){var r=t.get(i.uid)||t.set(i.uid,{}),o="";rt(!(i.reset&&i.overallReset),o),i.reset&&this._createSeriesStageTask(i,r,e,n),i.overallReset&&this._createOverallStageTask(i,r,e,n)}),this)},t.prototype.prepareView=function(t,e,n,i){var r=t.renderTask,o=r.context;o.model=e,o.ecModel=n,o.api=i,r.__block=!t.incrementalPrepareRender,this._pipe(e,r)},t.prototype.performDataProcessorTasks=function(t,e){this._performStageTasks(this._dataProcessorHandlers,t,e,{block:!0})},t.prototype.performVisualTasks=function(t,e,n){this._performStageTasks(this._visualHandlers,t,e,n)},t.prototype._performStageTasks=function(t,e,n,i){i=i||{};var r=!1,o=this;function a(t,e){return t.setDirty&&(!t.dirtyMap||t.dirtyMap.get(e.__pipeline.id))}P(t,(function(t,s){if(!i.visualType||i.visualType===t.visualType){var l=o._stageTaskMap.get(t.uid),u=l.seriesTaskMap,h=l.overallTask;if(h){var c,p=h.agentStubMap;p.each((function(t){a(i,t)&&(t.dirty(),c=!0)})),c&&h.dirty(),o.updatePayload(h,n);var d=o.getPerformArgs(h,i.block);p.each((function(t){t.perform(d)})),h.perform(d)&&(r=!0)}else u&&u.each((function(s,l){a(i,s)&&s.dirty();var u=o.getPerformArgs(s,i.block);u.skip=!t.performRawSeries&&e.isSeriesFiltered(s.context.model),o.updatePayload(s,n),s.perform(u)&&(r=!0)}))}})),this.unfinished=r||this.unfinished},t.prototype.performSeriesTasks=function(t){var e;t.eachSeries((function(t){e=t.dataTask.perform()||e})),this.unfinished=e||this.unfinished},t.prototype.plan=function(){this._pipelineMap.each((function(t){var e=t.tail;do{if(e.__block){t.blockIndex=e.__idxInPipeline;break}e=e.getUpstream()}while(e)}))},t.prototype.updatePayload=function(t,e){"remain"!==e&&(t.context.payload=e)},t.prototype._createSeriesStageTask=function(t,e,n,i){var r=this,o=e.seriesTaskMap,a=e.seriesTaskMap=ht(),s=t.seriesType,l=t.getTargetSeries;function u(e){var s=e.uid,l=a.set(s,o&&o.get(s)||md({plan:Hf,reset:Wf,count:Uf}));l.context={model:e,ecModel:n,api:i,useClearVisual:t.isVisual&&!t.isLayout,plan:t.plan,reset:t.reset,scheduler:r},r._pipe(e,l)}t.createOnAllSeries?n.eachRawSeries(u):s?n.eachRawSeriesByType(s,u):l&&l(n,i).each(u)},t.prototype._createOverallStageTask=function(t,e,n,i){var r=this,o=e.overallTask=e.overallTask||md({reset:Bf});o.context={ecModel:n,api:i,overallReset:t.overallReset,scheduler:r};var a=o.agentStubMap,s=o.agentStubMap=ht(),l=t.seriesType,u=t.getTargetSeries,h=!0,c=!1,p="";function d(t){var e=t.uid,n=s.set(e,a&&a.get(e)||(c=!0,md({reset:Vf,onDirty:Gf})));n.context={model:t,overallProgress:h},n.agent=o,n.__block=h,r._pipe(t,n)}rt(!t.createOnAllSeries,p),l?n.eachRawSeriesByType(l,d):u?u(n,i).each(d):(h=!1,P(n.getSeries(),d)),c&&o.dirty()},t.prototype._pipe=function(t,e){var n=t.uid,i=this._pipelineMap.get(n);!i.head&&(i.head=e),i.tail&&i.tail.pipe(e),i.tail=e,e.__idxInPipeline=i.count++,e.__pipeline=i},t.wrapStageHandler=function(t,e){return G(t)&&(t={overallReset:t,seriesType:Zf(t)}),t.uid=Ih("stageHandler"),e&&(t.visualType=e),t},t}();function Bf(t){t.overallReset(t.ecModel,t.api,t.payload)}function Vf(t){return t.overallProgress&&Ff}function Ff(){this.agent.dirty(),this.getDownstream().dirty()}function Gf(){this.agent&&this.agent.dirty()}function Hf(t){return t.plan?t.plan(t.model,t.ecModel,t.api,t.payload):null}function Wf(t){t.useClearVisual&&t.data.clearAllVisual();var e=t.resetDefines=_r(t.reset(t.model,t.ecModel,t.api,t.payload));return e.length>1?O(e,(function(t,e){return Xf(e)})):Yf}var Yf=Xf(0);function Xf(t){return function(e,n){var i=n.data,r=n.resetDefines[t];if(r&&r.dataEach)for(var o=e.start;o<e.end;o++)r.dataEach(i,o);else r&&r.progress&&r.progress(e,i)}}function Uf(t){return t.data.count()}function Zf(t){jf=null;try{t(qf,Kf)}catch(t){}return jf}var jf,qf={},Kf={};function $f(t,e){for(var n in e.prototype)t[n]=ft}$f(qf,pp),$f(Kf,vp),qf.eachSeriesByType=qf.eachRawSeriesByType=function(t){jf=t},qf.eachComponent=function(t){"series"===t.mainType&&t.subType&&(jf=t.subType)};var Jf=["#37A2DA","#32C5E9","#67E0E3","#9FE6B8","#FFDB5C","#ff9f7f","#fb7293","#E062AE","#E690D1","#e7bcf3","#9d96f5","#8378EA","#96BFFF"],Qf={color:Jf,colorLayer:[["#37A2DA","#ffd85c","#fd7b5f"],["#37A2DA","#67E0E3","#FFDB5C","#ff9f7f","#E062AE","#9d96f5"],["#37A2DA","#32C5E9","#9FE6B8","#FFDB5C","#ff9f7f","#fb7293","#e7bcf3","#8378EA","#96BFFF"],Jf]},tg="#B9B8CE",eg="#100C2A",ng=function(){return{axisLine:{lineStyle:{color:tg}},splitLine:{lineStyle:{color:"#484753"}},splitArea:{areaStyle:{color:["rgba(255,255,255,0.02)","rgba(255,255,255,0.05)"]}},minorSplitLine:{lineStyle:{color:"#20203B"}}}},ig=["#4992ff","#7cffb2","#fddd60","#ff6e76","#58d9f9","#05c091","#ff8a45","#8d48e3","#dd79ff"],rg={darkMode:!0,color:ig,backgroundColor:eg,axisPointer:{lineStyle:{color:"#817f91"},crossStyle:{color:"#817f91"},label:{color:"#fff"}},legend:{textStyle:{color:tg}},textStyle:{color:tg},title:{textStyle:{color:"#EEF1FA"},subtextStyle:{color:"#B9B8CE"}},toolbox:{iconStyle:{borderColor:tg}},dataZoom:{borderColor:"#71708A",textStyle:{color:tg},brushStyle:{color:"rgba(135,163,206,0.3)"},handleStyle:{color:"#353450",borderColor:"#C5CBE3"},moveHandleStyle:{color:"#B0B6C3",opacity:.3},fillerColor:"rgba(135,163,206,0.2)",emphasis:{handleStyle:{borderColor:"#91B7F2",color:"#4D587D"},moveHandleStyle:{color:"#636D9A",opacity:.7}},dataBackground:{lineStyle:{color:"#71708A",width:1},areaStyle:{color:"#71708A"}},selectedDataBackground:{lineStyle:{color:"#87A3CE"},areaStyle:{color:"#87A3CE"}}},visualMap:{textStyle:{color:tg}},timeline:{lineStyle:{color:tg},label:{color:tg},controlStyle:{color:tg,borderColor:tg}},calendar:{itemStyle:{color:eg},dayLabel:{color:tg},monthLabel:{color:tg},yearLabel:{color:tg}},timeAxis:ng(),logAxis:ng(),valueAxis:ng(),categoryAxis:ng(),line:{symbol:"circle"},graph:{color:ig},gauge:{title:{color:tg},axisLine:{lineStyle:{color:[[1,"rgba(207,212,219,0.2)"]]}},axisLabel:{color:tg},detail:{color:"#EEF1FA"}},candlestick:{itemStyle:{color:"#f64e56",color0:"#54ea92",borderColor:"#f64e56",borderColor0:"#54ea92"}}};function og(t){H(t)&&(t=(new DOMParser).parseFromString(t,"text/xml"));var e=t;for(9===e.nodeType&&(e=e.firstChild);"svg"!==e.nodeName.toLowerCase()||1!==e.nodeType;)e=e.nextSibling;return e}rg.categoryAxis.splitLine.show=!1;var ag=ht(),sg=function(t,e,n){var i;if(F(e))i=e;else if(e.svg)i=[{type:"svg",source:e.svg,specialAreas:e.specialAreas}];else{var r=e.geoJson||e.geoJSON;r&&!e.features&&(n=e.specialAreas,e=r),i=[{type:"geoJSON",source:e,specialAreas:n}]}return P(i,(function(t){var e=t.type;"geoJson"===e&&(e=t.type="geoJSON");var n=ug[e];n(t)})),ag.set(t,i)},lg=function(t){return ag.get(t)},ug={geoJSON:function(t){var e=t.source;t.geoJSON=H(e)?"undefined"!=typeof JSON&&JSON.parse?JSON.parse(e):new Function("return ("+e+");")():e},svg:function(t){t.svgXML=og(t.source)}},hg=function(){function t(){}return t.prototype.normalizeQuery=function(t){var e={},n={},i={};if(H(t)){var r=Gr(t);e.mainType=r.main||null,e.subType=r.sub||null}else{var o=["Index","Name","Id"],a={name:1,dataIndex:1,dataType:1};P(t,(function(t,r){for(var s=!1,l=0;l<o.length;l++){var u=o[l],h=r.lastIndexOf(u);if(h>0&&h===r.length-u.length){var c=r.slice(0,h);"data"!==c&&(e.mainType=c,e[u.toLowerCase()]=t,s=!0)}}a.hasOwnProperty(r)&&(n[r]=t,s=!0),s||(i[r]=t)}))}return{cptQuery:e,dataQuery:n,otherQuery:i}},t.prototype.filter=function(t,e){var n=this.eventInfo;if(!n)return!0;var i=n.targetEl,r=n.packedEvent,o=n.model,a=n.view;if(!o||!a)return!0;var s=e.cptQuery,l=e.dataQuery;return u(s,o,"mainType")&&u(s,o,"subType")&&u(s,o,"index","componentIndex")&&u(s,o,"name")&&u(s,o,"id")&&u(l,r,"name")&&u(l,r,"dataIndex")&&u(l,r,"dataType")&&(!a.filterForExposedEvent||a.filterForExposedEvent(t,e.otherQuery,i,r));function u(t,e,n,i){return null==t[n]||e[i||n]===t[n]}},t.prototype.afterTrigger=function(){this.eventInfo=null},t}(),cg={createOnAllSeries:!0,performRawSeries:!0,reset:function(t,e){var n=t.getData();if(t.legendSymbol&&n.setVisual("legendSymbol",t.legendSymbol),t.hasSymbolVisual){var i=t.get("symbol"),r=t.get("symbolSize"),o=t.get("symbolKeepAspect"),a=t.get("symbolRotate"),s=G(i),l=G(r),u=G(a),h=s||l||u,c=!s&&i?i:t.defaultSymbol,p=l?null:r,d=u?null:a;if(n.setVisual({legendSymbol:t.legendSymbol||c,symbol:c,symbolSize:p,symbolKeepAspect:o,symbolRotate:d}),!e.isSeriesFiltered(t))return{dataEach:h?function(e,n){var o=t.getRawValue(n),h=t.getDataParams(n);s&&e.setItemVisual(n,"symbol",i(o,h)),l&&e.setItemVisual(n,"symbolSize",r(o,h)),u&&e.setItemVisual(n,"symbolRotate",a(o,h))}:null}}}};function pg(t,e,n){switch(n){case"color":return t.getItemVisual(e,"style")[t.getVisual("drawType")];case"opacity":return t.getItemVisual(e,"style").opacity;case"symbol":case"symbolSize":case"liftZ":return t.getItemVisual(e,n);default:0}}function dg(t,e){switch(e){case"color":return t.getVisual("style")[t.getVisual("drawType")];case"opacity":return t.getVisual("style").opacity;case"symbol":case"symbolSize":case"liftZ":return t.getVisual(e);default:0}}function fg(t,e,n,i){switch(n){case"color":t.ensureUniqueItemVisual(e,"style")[t.getVisual("drawType")]=i,t.setItemVisual(e,"colorFromPalette",!1);break;case"opacity":t.ensureUniqueItemVisual(e,"style").opacity=i;break;case"symbol":case"symbolSize":case"liftZ":t.setItemVisual(e,n,i);break;default:0}}var gg=2*Math.PI,yg=Ca.CMD,vg=["top","right","bottom","left"];function mg(t,e,n,i,r){var o=n.width,a=n.height;switch(t){case"top":i.set(n.x+o/2,n.y-e),r.set(0,-1);break;case"bottom":i.set(n.x+o/2,n.y+a+e),r.set(0,1);break;case"left":i.set(n.x-e,n.y+a/2),r.set(-1,0);break;case"right":i.set(n.x+o+e,n.y+a/2),r.set(1,0)}}function _g(t,e,n,i,r,o,a,s,l){a-=t,s-=e;var u=Math.sqrt(a*a+s*s),h=(a/=u)*n+t,c=(s/=u)*n+e;if(Math.abs(i-r)%gg<1e-4)return l[0]=h,l[1]=c,u-n;if(o){var p=i;i=Pa(r),r=Pa(p)}else i=Pa(i),r=Pa(r);i>r&&(r+=gg);var d=Math.atan2(s,a);if(d<0&&(d+=gg),d>=i&&d<=r||d+gg>=i&&d+gg<=r)return l[0]=h,l[1]=c,u-n;var f=n*Math.cos(i)+t,g=n*Math.sin(i)+e,y=n*Math.cos(r)+t,v=n*Math.sin(r)+e,m=(f-a)*(f-a)+(g-s)*(g-s),_=(y-a)*(y-a)+(v-s)*(v-s);return m<_?(l[0]=f,l[1]=g,Math.sqrt(m)):(l[0]=y,l[1]=v,Math.sqrt(_))}function xg(t,e,n,i,r,o,a,s){var l=r-t,u=o-e,h=n-t,c=i-e,p=Math.sqrt(h*h+c*c),d=(l*(h/=p)+u*(c/=p))/p;s&&(d=Math.min(Math.max(d,0),1)),d*=p;var f=a[0]=t+d*h,g=a[1]=e+d*c;return Math.sqrt((f-r)*(f-r)+(g-o)*(g-o))}function bg(t,e,n,i,r,o,a){n<0&&(t+=n,n=-n),i<0&&(e+=i,i=-i);var s=t+n,l=e+i,u=a[0]=Math.min(Math.max(r,t),s),h=a[1]=Math.min(Math.max(o,e),l);return Math.sqrt((u-r)*(u-r)+(h-o)*(h-o))}var wg=[];function Sg(t,e,n){var i=bg(e.x,e.y,e.width,e.height,t.x,t.y,wg);return n.set(wg[0],wg[1]),i}function Mg(t,e,n){for(var i,r,o=0,a=0,s=0,l=0,u=1/0,h=e.data,c=t.x,p=t.y,d=0;d<h.length;){var f=h[d++];1===d&&(s=o=h[d],l=a=h[d+1]);var g=u;switch(f){case yg.M:o=s=h[d++],a=l=h[d++];break;case yg.L:g=xg(o,a,h[d],h[d+1],c,p,wg,!0),o=h[d++],a=h[d++];break;case yg.C:g=Vo(o,a,h[d++],h[d++],h[d++],h[d++],h[d],h[d+1],c,p,wg),o=h[d++],a=h[d++];break;case yg.Q:g=Xo(o,a,h[d++],h[d++],h[d],h[d+1],c,p,wg),o=h[d++],a=h[d++];break;case yg.A:var y=h[d++],v=h[d++],m=h[d++],_=h[d++],x=h[d++],b=h[d++];d+=1;var w=!!(1-h[d++]);i=Math.cos(x)*m+y,r=Math.sin(x)*_+v,d<=1&&(s=i,l=r),g=_g(y,v,_,x,x+b,w,(c-y)*_/m+y,p,wg),o=Math.cos(x+b)*m+y,a=Math.sin(x+b)*_+v;break;case yg.R:g=bg(s=o=h[d++],l=a=h[d++],h[d++],h[d++],c,p,wg);break;case yg.Z:g=xg(o,a,s,l,c,p,wg,!0),o=s,a=l}g<u&&(u=g,n.set(wg[0],wg[1]))}return u}var Ig=new In,Tg=new In,Cg=new In,Ag=new In,Dg=new In;function Lg(t,e){if(t){var n=t.getTextGuideLine(),i=t.getTextContent();if(i&&n){var r=t.textGuideLineConfig||{},o=[[0,0],[0,0],[0,0]],a=r.candidates||vg,s=i.getBoundingRect().clone();s.applyTransform(i.getComputedTransform());var l=1/0,u=r.anchor,h=t.getComputedTransform(),c=h&&be([],h),p=e.get("length2")||0;u&&Cg.copy(u);for(var d=0;d<a.length;d++){mg(a[d],0,s,Ig,Ag),In.scaleAndAdd(Tg,Ig,Ag,p),Tg.transform(c);var f=t.getBoundingRect(),g=u?u.distance(Tg):t instanceof Za?Mg(Tg,t.path,Cg):Sg(Tg,f,Cg);g<l&&(l=g,Tg.transform(h),Cg.transform(h),Cg.toArray(o[0]),Tg.toArray(o[1]),Ig.toArray(o[2]))}Og(o,e.get("minTurnAngle")),n.setShape({points:o})}}}var kg=[],Pg=new In;function Og(t,e){if(e<=180&&e>0){e=e/180*Math.PI,Ig.fromArray(t[0]),Tg.fromArray(t[1]),Cg.fromArray(t[2]),In.sub(Ag,Ig,Tg),In.sub(Dg,Cg,Tg);var n=Ag.len(),i=Dg.len();if(!(n<.001||i<.001)){Ag.scale(1/n),Dg.scale(1/i);var r=Ag.dot(Dg);if(Math.cos(e)<r){var o=xg(Tg.x,Tg.y,Cg.x,Cg.y,Ig.x,Ig.y,kg,!1);Pg.fromArray(kg),Pg.scaleAndAdd(Dg,o/Math.tan(Math.PI-e));var a=Cg.x!==Tg.x?(Pg.x-Tg.x)/(Cg.x-Tg.x):(Pg.y-Tg.y)/(Cg.y-Tg.y);if(isNaN(a))return;a<0?In.copy(Pg,Tg):a>1&&In.copy(Pg,Cg),Pg.toArray(t[1])}}}}function Rg(t,e,n){if(n<=180&&n>0){n=n/180*Math.PI,Ig.fromArray(t[0]),Tg.fromArray(t[1]),Cg.fromArray(t[2]),In.sub(Ag,Tg,Ig),In.sub(Dg,Cg,Tg);var i=Ag.len(),r=Dg.len();if(!(i<.001||r<.001))if(Ag.scale(1/i),Dg.scale(1/r),Ag.dot(e)<Math.cos(n)){var o=xg(Tg.x,Tg.y,Cg.x,Cg.y,Ig.x,Ig.y,kg,!1);Pg.fromArray(kg);var a=Math.PI/2,s=a+Math.acos(Dg.dot(e))-n;if(s>=a)In.copy(Pg,Cg);else{Pg.scaleAndAdd(Dg,o/Math.tan(Math.PI/2-s));var l=Cg.x!==Tg.x?(Pg.x-Tg.x)/(Cg.x-Tg.x):(Pg.y-Tg.y)/(Cg.y-Tg.y);if(isNaN(l))return;l<0?In.copy(Pg,Tg):l>1&&In.copy(Pg,Cg)}Pg.toArray(t[1])}}}function Ng(t,e,n,i){var r="normal"===n,o=r?t:t.ensureState(n);o.ignore=e;var a=i.get("smooth");a&&!0===a&&(a=.3),o.shape=o.shape||{},a>0&&(o.shape.smooth=a);var s=i.getModel("lineStyle").getLineStyle();r?t.useStyle(s):o.style=s}function Eg(t,e){var n=e.smooth,i=e.points;if(i)if(t.moveTo(i[0][0],i[0][1]),n>0&&i.length>=3){var r=Lt(i[0],i[1]),o=Lt(i[1],i[2]);if(!r||!o)return t.lineTo(i[1][0],i[1][1]),void t.lineTo(i[2][0],i[2][1]);var a=Math.min(r,o)*n,s=Ot([],i[1],i[0],a/r),l=Ot([],i[1],i[2],a/o),u=Ot([],s,l,.5);t.bezierCurveTo(s[0],s[1],s[0],s[1],u[0],u[1]),t.bezierCurveTo(l[0],l[1],l[0],l[1],i[2][0],i[2][1])}else for(var h=1;h<i.length;h++)t.lineTo(i[h][0],i[h][1])}function zg(t,e,n){var i=t.getTextGuideLine(),r=t.getTextContent();if(r){for(var o=e.normal,a=o.get("show"),s=r.ignore,l=0;l<bs.length;l++){var u=bs[l],h=e[u],c="normal"===u;if(h){var p=h.get("show");if((c?s:tt(r.states[u]&&r.states[u].ignore,s))||!tt(p,a)){var d=c?i:i&&i.states.normal;d&&(d.ignore=!0);continue}i||(i=new $l,t.setTextGuideLine(i),c||!s&&a||Ng(i,!0,"normal",e.normal),t.stateProxy&&(i.stateProxy=t.stateProxy)),Ng(i,!1,u,h)}}if(i){T(i.style,n),i.style.fill=null;var f=o.get("showAbove");(t.textGuideLineConfig=t.textGuideLineConfig||{}).showAbove=f||!1,i.buildPath=Eg}}else i&&t.removeTextGuideLine()}function Bg(t,e){e=e||"labelLine";for(var n={normal:t.getModel(e)},i=0;i<xs.length;i++){var r=xs[i];n[r]=t.getModel([r,e])}return n}function Vg(t,e,n,i,r,o){var a=t.length;if(!(a<2)){t.sort((function(t,n){return t.rect[e]-n.rect[e]}));for(var s,l=0,u=!1,h=0,c=0;c<a;c++){var p=t[c],d=p.rect;(s=d[e]-l)<0&&(d[e]-=s,p.label[e]-=s,u=!0),h+=Math.max(-s,0),l=d[e]+d[n]}h>0&&o&&x(-h/a,0,a);var f,g,y=t[0],v=t[a-1];return m(),f<0&&b(-f,.8),g<0&&b(g,.8),m(),_(f,g,1),_(g,f,-1),m(),f<0&&w(-f),g<0&&w(g),u}function m(){f=y.rect[e]-i,g=r-v.rect[e]-v.rect[n]}function _(t,e,n){if(t<0){var i=Math.min(e,-t);if(i>0){x(i*n,0,a);var r=i+t;r<0&&b(-r*n,1)}else b(-t*n,1)}}function x(n,i,r){0!==n&&(u=!0);for(var o=i;o<r;o++){var a=t[o];a.rect[e]+=n,a.label[e]+=n}}function b(i,r){for(var o=[],s=0,l=1;l<a;l++){var u=t[l-1].rect,h=Math.max(t[l].rect[e]-u[e]-u[n],0);o.push(h),s+=h}if(s){var c=Math.min(Math.abs(i)/s,r);if(i>0)for(l=0;l<a-1;l++){x(o[l]*c,0,l+1)}else for(l=a-1;l>0;l--){x(-(o[l-1]*c),l,a)}}}function w(t){var e=t<0?-1:1;t=Math.abs(t);for(var n=Math.ceil(t/(a-1)),i=0;i<a-1;i++)if(e>0?x(n,0,i+1):x(-n,a-i-1,a),(t-=n)<=0)return}}function Fg(t,e,n,i){return Vg(t,"y","height",e,n,i)}function Gg(t){if(t){for(var e=[],n=0;n<t.length;n++)e.push(t[n].slice());return e}}function Hg(t,e){var n=t.label,i=e&&e.getTextGuideLine();return{dataIndex:t.dataIndex,dataType:t.dataType,seriesIndex:t.seriesModel.seriesIndex,text:t.label.style.text,rect:t.hostRect,labelRect:t.rect,align:n.style.align,verticalAlign:n.style.verticalAlign,labelLinePoints:Gg(i&&i.shape.points)}}var Wg=["align","verticalAlign","width","height","fontSize"],Yg=new ke,Xg=Lr(),Ug=Lr();function Zg(t,e,n){for(var i=0;i<n.length;i++){var r=n[i];null!=e[r]&&(t[r]=e[r])}}var jg=["x","y","rotation"],qg=function(){function t(){this._labelList=[],this._chartViewList=[]}return t.prototype.clearLabels=function(){this._labelList=[],this._chartViewList=[]},t.prototype._addLabel=function(t,e,n,i,r){var o=i.style,a=i.__hostTarget.textConfig||{},s=i.getComputedTransform(),l=i.getBoundingRect().plain();Rn.applyTransform(l,l,s),s?Yg.setLocalTransform(s):(Yg.x=Yg.y=Yg.rotation=Yg.originX=Yg.originY=0,Yg.scaleX=Yg.scaleY=1);var u,h=i.__hostTarget;if(h){u=h.getBoundingRect().plain();var c=h.getComputedTransform();Rn.applyTransform(u,u,c)}var p=u&&h.getTextGuideLine();this._labelList.push({label:i,labelLine:p,seriesModel:n,dataIndex:t,dataType:e,layoutOption:r,computedLayoutOption:null,rect:l,hostRect:u,priority:u?u.width*u.height:0,defaultAttr:{ignore:i.ignore,labelGuideIgnore:p&&p.ignore,x:Yg.x,y:Yg.y,rotation:Yg.rotation,style:{x:o.x,y:o.y,align:o.align,verticalAlign:o.verticalAlign,width:o.width,height:o.height,fontSize:o.fontSize},cursor:i.cursor,attachedPos:a.position,attachedRot:a.rotation}})},t.prototype.addLabelsOfSeries=function(t){var e=this;this._chartViewList.push(t);var n=t.__model,i=n.get("labelLayout");(G(i)||z(i).length)&&t.group.traverse((function(t){if(t.ignore)return!0;var r=t.getTextContent(),o=ys(t);r&&!r.disableLabelLayout&&e._addLabel(o.dataIndex,o.dataType,n,r,i)}))},t.prototype.updateLayoutConfig=function(t){var e=t.getWidth(),n=t.getHeight();function i(t,e){return function(){Lg(t,e)}}for(var r=0;r<this._labelList.length;r++){var o=this._labelList[r],a=o.label,s=a.__hostTarget,l=o.defaultAttr,u=void 0;u=(u="function"==typeof o.layoutOption?o.layoutOption(Hg(o,s)):o.layoutOption)||{},o.computedLayoutOption=u;var h=Math.PI/180;s&&s.setTextConfig({local:!1,position:null!=u.x||null!=u.y?null:l.attachedPos,rotation:null!=u.rotate?u.rotate*h:l.attachedRot,offset:[u.dx||0,u.dy||0]});var c=!1;if(null!=u.x?(a.x=Zi(u.x,e),a.setStyle("x",0),c=!0):(a.x=l.x,a.setStyle("x",l.style.x)),null!=u.y?(a.y=Zi(u.y,n),a.setStyle("y",0),c=!0):(a.y=l.y,a.setStyle("y",l.style.y)),u.labelLinePoints){var p=s.getTextGuideLine();p&&(p.setShape({points:u.labelLinePoints}),c=!1)}Xg(a).needsUpdateLabelLine=c,a.rotation=null!=u.rotate?u.rotate*h:l.rotation;for(var d=0;d<Wg.length;d++){var f=Wg[d];a.setStyle(f,null!=u[f]?u[f]:l.style[f])}if(u.draggable){if(a.draggable=!0,a.cursor="move",s){var g=o.seriesModel;if(null!=o.dataIndex)g=o.seriesModel.getData(o.dataType).getItemModel(o.dataIndex);a.on("drag",i(s,g.getModel("labelLine")))}}else a.off("drag"),a.cursor=l.cursor}},t.prototype.layout=function(t){var e,n=t.getWidth(),i=t.getHeight(),r=function(t){for(var e=[],n=0;n<t.length;n++){var i=t[n];if(!i.defaultAttr.ignore){var r=i.label,o=r.getComputedTransform(),a=r.getBoundingRect(),s=!o||o[1]<1e-5&&o[2]<1e-5,l=r.style.margin||0,u=a.clone();u.applyTransform(o),u.x-=l/2,u.y-=l/2,u.width+=l,u.height+=l;var h=s?new gu(a,o):null;e.push({label:r,labelLine:i.labelLine,rect:u,localRect:a,obb:h,priority:i.priority,defaultAttr:i.defaultAttr,layoutOption:i.computedLayoutOption,axisAligned:s,transform:o})}}return e}(this._labelList),o=N(r,(function(t){return"shiftX"===t.layoutOption.moveOverlap})),a=N(r,(function(t){return"shiftY"===t.layoutOption.moveOverlap}));Vg(o,"x","width",0,n,e),Fg(a,0,i),function(t){var e=[];t.sort((function(t,e){return e.priority-t.priority}));var n=new Rn(0,0,0,0);function i(t){if(!t.ignore){var e=t.ensureState("emphasis");null==e.ignore&&(e.ignore=!1)}t.ignore=!0}for(var r=0;r<t.length;r++){var o=t[r],a=o.axisAligned,s=o.localRect,l=o.transform,u=o.label,h=o.labelLine;n.copy(o.rect),n.width-=.1,n.height-=.1,n.x+=.05,n.y+=.05;for(var c=o.obb,p=!1,d=0;d<e.length;d++){var f=e[d];if(n.intersect(f.rect)){if(a&&f.axisAligned){p=!0;break}if(f.obb||(f.obb=new gu(f.localRect,f.transform)),c||(c=new gu(s,l)),c.intersect(f.obb)){p=!0;break}}}p?(i(u),h&&i(h)):(u.attr("ignore",o.defaultAttr.ignore),h&&h.attr("ignore",o.defaultAttr.labelGuideIgnore),e.push(o))}}(N(r,(function(t){return t.layoutOption.hideOverlap})))},t.prototype.processLabelsOverall=function(){var t=this;P(this._chartViewList,(function(e){var n=e.__model,i=e.ignoreLabelLineUpdate,r=n.isAnimationEnabled();e.group.traverse((function(e){if(e.ignore)return!0;var o=!i,a=e.getTextContent();!o&&a&&(o=Xg(a).needsUpdateLabelLine),o&&t._updateLabelLine(e,n),r&&t._animateLabels(e,n)}))}))},t.prototype._updateLabelLine=function(t,e){var n=t.getTextContent(),i=ys(t),r=i.dataIndex;if(n&&null!=r){var o=e.getData(i.dataType),a=o.getItemModel(r),s={},l=o.getItemVisual(r,"style"),u=o.getVisual("drawType");s.stroke=l[u];var h=a.getModel("labelLine");zg(t,Bg(a),s),Lg(t,h)}},t.prototype._animateLabels=function(t,e){var n=t.getTextContent(),i=t.getTextGuideLine();if(n&&!n.ignore&&!n.invisible&&!t.disableLabelAnimation&&!Bu(t)){var r=(d=Xg(n)).oldLayout,o=ys(t),a=o.dataIndex,s={x:n.x,y:n.y,rotation:n.rotation},l=e.getData(o.dataType);if(r){n.attr(r);var u=t.prevStates;u&&(A(u,"select")>=0&&n.attr(d.oldLayoutSelect),A(u,"emphasis")>=0&&n.attr(d.oldLayoutEmphasis)),Ou(n,s,e,a)}else if(n.attr(s),!uh(n).valueAnimation){var h=tt(n.style.opacity,1);n.style.opacity=0,Ru(n,{style:{opacity:h}},e,a)}if(d.oldLayout=s,n.states.select){var c=d.oldLayoutSelect={};Zg(c,s,jg),Zg(c,n.states.select,jg)}if(n.states.emphasis){var p=d.oldLayoutEmphasis={};Zg(p,s,jg),Zg(p,n.states.emphasis,jg)}ch(n,a,l,e,e)}if(i&&!i.ignore&&!i.invisible){r=(d=Ug(i)).oldLayout;var d,f={points:i.shape.points};r?(i.attr({shape:r}),Ou(i,{shape:f},e)):(i.setShape(f),i.style.strokePercent=0,Ru(i,{style:{strokePercent:1}},e)),d.oldLayout=f}},t}();function Kg(t,e){function n(e,n){var i=[];return e.eachComponent({mainType:"series",subType:t,query:n},(function(t){i.push(t.seriesIndex)})),i}P([[t+"ToggleSelect","toggleSelect"],[t+"Select","select"],[t+"UnSelect","unselect"]],(function(t){e(t[0],(function(e,i,r){e=I({},e),r.dispatchAction(I(e,{type:t[1],seriesIndex:n(i,e)}))}))}))}function $g(t,e,n,i,r){var o=t+e;n.isSilent(o)||i.eachComponent({mainType:"series",subType:"pie"},(function(t){for(var e=t.seriesIndex,i=r.selected,a=0;a<i.length;a++)if(i[a].seriesIndex===e){var s=t.getData(),l=Dr(s,r.fromActionPayload);n.trigger(o,{type:o,seriesId:t.id,name:F(l)?s.getName(l[0]):s.getName(l),selected:I({},t.option.selectedMap)})}}))}function Jg(t,e,n){for(var i;t&&(!e(t)||(i=t,!n));)t=t.__hostTarget||t.parent;return i}var Qg=Math.round(9*Math.random()),ty=function(){function t(){this._id="__ec_inner_"+Qg++}return t.prototype.get=function(t){return this._guard(t)[this._id]},t.prototype.set=function(t,e){var n=this._guard(t);return"function"==typeof Object.defineProperty?Object.defineProperty(n,this._id,{value:e,enumerable:!1,configurable:!0}):n[this._id]=e,this},t.prototype.delete=function(t){return!!this.has(t)&&(delete this._guard(t)[this._id],!0)},t.prototype.has=function(t){return!!this._guard(t)[this._id]},t.prototype._guard=function(t){if(t!==Object(t))throw TypeError("Value of WeakMap is not a non-null object.");return t},t}(),ey=Za.extend({type:"triangle",shape:{cx:0,cy:0,width:0,height:0},buildPath:function(t,e){var n=e.cx,i=e.cy,r=e.width/2,o=e.height/2;t.moveTo(n,i-o),t.lineTo(n+r,i+o),t.lineTo(n-r,i+o),t.closePath()}}),ny=Za.extend({type:"diamond",shape:{cx:0,cy:0,width:0,height:0},buildPath:function(t,e){var n=e.cx,i=e.cy,r=e.width/2,o=e.height/2;t.moveTo(n,i-o),t.lineTo(n+r,i),t.lineTo(n,i+o),t.lineTo(n-r,i),t.closePath()}}),iy=Za.extend({type:"pin",shape:{x:0,y:0,width:0,height:0},buildPath:function(t,e){var n=e.x,i=e.y,r=e.width/5*3,o=Math.max(r,e.height),a=r/2,s=a*a/(o-a),l=i-o+a+s,u=Math.asin(s/a),h=Math.cos(u)*a,c=Math.sin(u),p=Math.cos(u),d=.6*a,f=.7*a;t.moveTo(n-h,l+s),t.arc(n,l,a,Math.PI-u,2*Math.PI+u),t.bezierCurveTo(n+h-c*d,l+s+p*d,n,i-f,n,i),t.bezierCurveTo(n,i-f,n-h+c*d,l+s+p*d,n-h,l+s),t.closePath()}}),ry=Za.extend({type:"arrow",shape:{x:0,y:0,width:0,height:0},buildPath:function(t,e){var n=e.height,i=e.width,r=e.x,o=e.y,a=i/3*2;t.moveTo(r,o),t.lineTo(r+a,o+n),t.lineTo(r,o+n/4*3),t.lineTo(r-a,o+n),t.lineTo(r,o),t.closePath()}}),oy={line:function(t,e,n,i,r){r.x=t,r.y=e+i/2-1,r.width=n,r.height=2},rect:function(t,e,n,i,r){r.x=t,r.y=e,r.width=n,r.height=i},roundRect:function(t,e,n,i,r){r.x=t,r.y=e,r.width=n,r.height=i,r.r=Math.min(n,i)/4},square:function(t,e,n,i,r){var o=Math.min(n,i);r.x=t,r.y=e,r.width=o,r.height=o},circle:function(t,e,n,i,r){r.cx=t+n/2,r.cy=e+i/2,r.r=Math.min(n,i)/2},diamond:function(t,e,n,i,r){r.cx=t+n/2,r.cy=e+i/2,r.width=n,r.height=i},pin:function(t,e,n,i,r){r.x=t+n/2,r.y=e+i/2,r.width=n,r.height=i},arrow:function(t,e,n,i,r){r.x=t+n/2,r.y=e+i/2,r.width=n,r.height=i},triangle:function(t,e,n,i,r){r.cx=t+n/2,r.cy=e+i/2,r.width=n,r.height=i}},ay={};P({line:os,rect:os,roundRect:os,square:os,circle:Tl,diamond:ny,pin:iy,arrow:ry,triangle:ey},(function(t,e){ay[e]=new t}));var sy=Za.extend({type:"symbol",shape:{symbolType:"",x:0,y:0,width:0,height:0},calculateTextPosition:function(t,e,n){var i=Xn(t,e,n),r=this.shape;return r&&"pin"===r.symbolType&&"inside"===e.position&&(i.y=n.y+.4*n.height),i},buildPath:function(t,e,n){var i=e.symbolType;if("none"!==i){var r=ay[i];r||(r=ay[i="rect"]),oy[i](e.x,e.y,e.width,e.height,r.shape),r.buildPath(t,r.shape,n)}}});function ly(t,e){if("image"!==this.type){var n=this.style;this.__isEmptyBrush?(n.stroke=t,n.fill=e||"#fff",n.lineWidth=2):n.fill=t,this.markRedraw()}}function uy(t,e,n,i,r,o,a){var s,l=0===t.indexOf("empty");return l&&(t=t.substr(5,1).toLowerCase()+t.substr(6)),(s=0===t.indexOf("image://")?Cu(t.slice(8),new Rn(e,n,i,r),a?"center":"cover"):0===t.indexOf("path://")?Tu(t.slice(7),{},new Rn(e,n,i,r),a?"center":"cover"):new sy({shape:{symbolType:t,x:e,y:n,width:i,height:r}})).__isEmptyBrush=l,s.setColor=ly,o&&s.setColor(o),s}function hy(t,e,n){for(var i="radial"===e.type?function(t,e,n){var i=n.width,r=n.height,o=Math.min(i,r),a=null==e.x?.5:e.x,s=null==e.y?.5:e.y,l=null==e.r?.5:e.r;return e.global||(a=a*i+n.x,s=s*r+n.y,l*=o),t.createRadialGradient(a,s,0,a,s,l)}(t,e,n):function(t,e,n){var i=null==e.x?0:e.x,r=null==e.x2?1:e.x2,o=null==e.y?0:e.y,a=null==e.y2?0:e.y2;return e.global||(i=i*n.width+n.x,r=r*n.width+n.x,o=o*n.height+n.y,a=a*n.height+n.y),i=isNaN(i)?0:i,r=isNaN(r)?1:r,o=isNaN(o)?0:o,a=isNaN(a)?0:a,t.createLinearGradient(i,o,r,a)}(t,e,n),r=e.colorStops,o=0;o<r.length;o++)i.addColorStop(r[o].offset,r[o].color);return i}function cy(t,e){if(t===e||!t&&!e)return!1;if(!t||!e||t.length!==e.length)return!0;for(var n=0;n<t.length;n++)if(t[n]!==e[n])return!0;return!1}function py(t,e){return t&&"solid"!==t&&e>0?(e=e||1,"dashed"===t?[4*e,2*e]:"dotted"===t?[e]:Y(t)?[t]:F(t)?t:null):null}var dy=new Ca(!0);function fy(t){var e=t.stroke;return!(null==e||"none"===e||!(t.lineWidth>0))}function gy(t){var e=t.fill;return null!=e&&"none"!==e}function yy(t,e){if(null!=e.fillOpacity&&1!==e.fillOpacity){var n=t.globalAlpha;t.globalAlpha=e.fillOpacity*e.opacity,t.fill(),t.globalAlpha=n}else t.fill()}function vy(t,e){if(null!=e.strokeOpacity&&1!==e.strokeOpacity){var n=t.globalAlpha;t.globalAlpha=e.strokeOpacity*e.opacity,t.stroke(),t.globalAlpha=n}else t.stroke()}function my(t,e,n){var i=to(e.image,e.__image,n);if(no(i)){var r=t.createPattern(i,e.repeat||"repeat");if("function"==typeof DOMMatrix){var o=new DOMMatrix;o.rotateSelf(0,0,(e.rotation||0)/Math.PI*180),o.scaleSelf(e.scaleX||1,e.scaleY||1),o.translateSelf(e.x||0,e.y||0),r.setTransform(o)}return r}}var _y=["shadowBlur","shadowOffsetX","shadowOffsetY"],xy=[["lineCap","butt"],["lineJoin","miter"],["miterLimit",10]];function by(t,e,n,i,r){var o=!1;if(!i&&e===(n=n||{}))return!1;(i||e.opacity!==n.opacity)&&(o||(My(t,r),o=!0),t.globalAlpha=null==e.opacity?vo.opacity:e.opacity),(i||e.blend!==n.blend)&&(o||(My(t,r),o=!0),t.globalCompositeOperation=e.blend||vo.blend);for(var a=0;a<_y.length;a++){var s=_y[a];(i||e[s]!==n[s])&&(o||(My(t,r),o=!0),t[s]=t.dpr*(e[s]||0))}return(i||e.shadowColor!==n.shadowColor)&&(o||(My(t,r),o=!0),t.shadowColor=e.shadowColor||vo.shadowColor),o}function wy(t,e,n,i,r){var o=Iy(e,r.inHover),a=i?null:n&&Iy(n,r.inHover)||{};if(o===a)return!1;var s=by(t,o,a,i,r);if((i||o.fill!==a.fill)&&(s||(My(t,r),s=!0),t.fillStyle=o.fill),(i||o.stroke!==a.stroke)&&(s||(My(t,r),s=!0),t.strokeStyle=o.stroke),(i||o.opacity!==a.opacity)&&(s||(My(t,r),s=!0),t.globalAlpha=null==o.opacity?1:o.opacity),e.hasStroke()){var l=o.lineWidth/(o.strokeNoScale&&e&&e.getLineScale?e.getLineScale():1);t.lineWidth!==l&&(s||(My(t,r),s=!0),t.lineWidth=l)}for(var u=0;u<xy.length;u++){var h=xy[u],c=h[0];(i||o[c]!==a[c])&&(s||(My(t,r),s=!0),t[c]=o[c]||h[1])}return s}function Sy(t,e){var n=e.transform,i=t.dpr||1;n?t.setTransform(i*n[0],i*n[1],i*n[2],i*n[3],i*n[4],i*n[5]):t.setTransform(i,0,0,i,0,0)}function My(t,e){e.batchFill&&t.fill(),e.batchStroke&&t.stroke(),e.batchFill="",e.batchStroke=""}function Iy(t,e){return e&&t.__hoverStyle||t.style}function Ty(t,e){Cy(t,e,{inHover:!1,viewWidth:0,viewHeight:0},!0)}function Cy(t,e,n,i){var r=e.transform;if(!e.shouldBePainted(n.viewWidth,n.viewHeight,!1,!1))return e.__dirty&=~ei.REDARAW_BIT,void(e.__isRendered=!1);var o=e.__clipPaths,a=n.prevElClipPaths,s=!1,l=!1;if(a&&!cy(o,a)||(a&&a.length&&(My(t,n),t.restore(),l=s=!0,n.prevElClipPaths=null,n.allClipped=!1,n.prevEl=null),o&&o.length&&(My(t,n),t.save(),function(t,e,n){for(var i=!1,r=0;r<t.length;r++){var o=t[r];i=i||o.isZeroArea(),Sy(e,o),e.beginPath(),o.buildPath(e,o.shape),e.clip()}n.allClipped=i}(o,t,n),s=!0),n.prevElClipPaths=o),n.allClipped)e.__isRendered=!1;else{e.beforeBrush&&e.beforeBrush(),e.innerBeforeBrush();var u=n.prevEl;u||(l=s=!0);var h,c,p=e instanceof Za&&e.autoBatch&&function(t){var e=gy(t),n=fy(t);return!(t.lineDash||!(+e^+n)||e&&"string"!=typeof t.fill||n&&"string"!=typeof t.stroke||t.strokePercent<1||t.strokeOpacity<1||t.fillOpacity<1)}(e.style);s||(h=r,c=u.transform,h&&c?h[0]!==c[0]||h[1]!==c[1]||h[2]!==c[2]||h[3]!==c[3]||h[4]!==c[4]||h[5]!==c[5]:h||c)?(My(t,n),Sy(t,e)):p||My(t,n);var d=Iy(e,n.inHover);e instanceof Za?(1!==n.lastDrawType&&(l=!0,n.lastDrawType=1),wy(t,e,u,l,n),p&&(n.batchFill||n.batchStroke)||t.beginPath(),function(t,e,n,i){var r=fy(n),o=gy(n),a=n.strokePercent,s=a<1,l=!e.path;e.silent&&!s||!l||e.createPathProxy();var u=e.path||dy;if(!i){var h=n.fill,c=n.stroke,p=o&&!!h.colorStops,d=r&&!!c.colorStops,f=o&&!!h.image,g=r&&!!c.image,y=void 0,v=void 0,m=void 0,_=void 0,x=void 0;(p||d)&&(x=e.getBoundingRect()),p&&(y=e.__dirty?hy(t,h,x):e.__canvasFillGradient,e.__canvasFillGradient=y),d&&(v=e.__dirty?hy(t,c,x):e.__canvasStrokeGradient,e.__canvasStrokeGradient=v),f&&(m=e.__dirty||!e.__canvasFillPattern?my(t,h,e):e.__canvasFillPattern,e.__canvasFillPattern=m),g&&(_=e.__dirty||!e.__canvasStrokePattern?my(t,c,e):e.__canvasStrokePattern,e.__canvasStrokePattern=m),p?t.fillStyle=y:f&&(m?t.fillStyle=m:o=!1),d?t.strokeStyle=v:g&&(_?t.strokeStyle=_:r=!1)}var b=n.lineDash&&n.lineWidth>0&&py(n.lineDash,n.lineWidth),w=n.lineDashOffset,S=!!t.setLineDash,M=e.getGlobalScale();if(u.setScale(M[0],M[1],e.segmentIgnoreThreshold),b){var I=n.strokeNoScale&&e.getLineScale?e.getLineScale():1;I&&1!==I&&(b=O(b,(function(t){return t/I})),w/=I)}var T=!0;(l||e.__dirty&Za.SHAPE_CHANGED_BIT||b&&!S&&r)&&(u.setDPR(t.dpr),s?u.setContext(null):(u.setContext(t),T=!1),u.reset(),b&&!S&&(u.setLineDash(b),u.setLineDashOffset(w)),e.buildPath(u,e.shape,i),u.toStatic(),e.pathUpdated()),T&&u.rebuildPath(t,s?a:1),b&&S&&(t.setLineDash(b),t.lineDashOffset=w),i||(n.strokeFirst?(r&&vy(t,n),o&&yy(t,n)):(o&&yy(t,n),r&&vy(t,n))),b&&S&&t.setLineDash([])}(t,e,d,p),p&&(n.batchFill=d.fill||"",n.batchStroke=d.stroke||"")):e instanceof qa?(3!==n.lastDrawType&&(l=!0,n.lastDrawType=3),wy(t,e,u,l,n),function(t,e,n){var i=n.text;if(null!=i&&(i+=""),i){t.font=n.font||En,t.textAlign=n.textAlign,t.textBaseline=n.textBaseline;var r=void 0;if(t.setLineDash){var o=n.lineDash&&n.lineWidth>0&&py(n.lineDash,n.lineWidth),a=n.lineDashOffset;if(o){var s=n.strokeNoScale&&e.getLineScale?e.getLineScale():1;s&&1!==s&&(o=O(o,(function(t){return t/s})),a/=s),t.setLineDash(o),t.lineDashOffset=a,r=!0}}n.strokeFirst?(fy(n)&&t.strokeText(i,n.x,n.y),gy(n)&&t.fillText(i,n.x,n.y)):(gy(n)&&t.fillText(i,n.x,n.y),fy(n)&&t.strokeText(i,n.x,n.y)),r&&t.setLineDash([])}}(t,e,d)):e instanceof Ja?(2!==n.lastDrawType&&(l=!0,n.lastDrawType=2),function(t,e,n,i,r){by(t,Iy(e,r.inHover),n&&Iy(n,r.inHover),i,r)}(t,e,u,l,n),function(t,e,n){var i=e.__image=to(n.image,e.__image,e,e.onload);if(i&&no(i)){var r=n.x||0,o=n.y||0,a=e.getWidth(),s=e.getHeight(),l=i.width/i.height;if(null==a&&null!=s?a=s*l:null==s&&null!=a?s=a/l:null==a&&null==s&&(a=i.width,s=i.height),n.sWidth&&n.sHeight){var u=n.sx||0,h=n.sy||0;t.drawImage(i,u,h,n.sWidth,n.sHeight,r,o,a,s)}else if(n.sx&&n.sy){var c=a-(u=n.sx),p=s-(h=n.sy);t.drawImage(i,u,h,c,p,r,o,a,s)}else t.drawImage(i,r,o,a,s)}}(t,e,d)):e instanceof vu&&(4!==n.lastDrawType&&(l=!0,n.lastDrawType=4),function(t,e,n){var i=e.getDisplayables(),r=e.getTemporalDisplayables();t.save();var o,a,s={prevElClipPaths:null,prevEl:null,allClipped:!1,viewWidth:n.viewWidth,viewHeight:n.viewHeight,inHover:n.inHover};for(o=e.getCursor(),a=i.length;o<a;o++){(h=i[o]).beforeBrush&&h.beforeBrush(),h.innerBeforeBrush(),Cy(t,h,s,o===a-1),h.innerAfterBrush(),h.afterBrush&&h.afterBrush(),s.prevEl=h}for(var l=0,u=r.length;l<u;l++){var h;(h=r[l]).beforeBrush&&h.beforeBrush(),h.innerBeforeBrush(),Cy(t,h,s,l===u-1),h.innerAfterBrush(),h.afterBrush&&h.afterBrush(),s.prevEl=h}e.clearTemporalDisplayables(),e.notClear=!0,t.restore()}(t,e,n)),p&&i&&My(t,n),e.innerAfterBrush(),e.afterBrush&&e.afterBrush(),n.prevEl=e,e.__dirty=0,e.__isRendered=!0}}var Ay=new ty,Dy=new Ee(100),Ly=["symbol","symbolSize","symbolKeepAspect","color","backgroundColor","dashArrayX","dashArrayY","maxTileWidth","maxTileHeight"];function ky(t,e){if("none"===t)return null;var n=e.getDevicePixelRatio(),i=e.getZr(),r="svg"===i.painter.type;t.dirty&&Ay.delete(t);var o=Ay.get(t);if(o)return o;var a=T(t,{symbol:"rect",symbolSize:1,symbolKeepAspect:!0,color:"rgba(0, 0, 0, 0.2)",backgroundColor:null,dashArrayX:5,dashArrayY:5,rotation:0,maxTileWidth:512,maxTileHeight:512});"none"===a.backgroundColor&&(a.backgroundColor=null);var s={repeat:"repeat"};return function(t){for(var e,o=[n],s=!0,l=0;l<Ly.length;++l){var u=a[Ly[l]],h=typeof u;if(null!=u&&!F(u)&&"string"!==h&&"number"!==h&&"boolean"!==h){s=!1;break}o.push(u)}if(s){e=o.join(",")+(r?"-svg":"");var c=Dy.get(e);c&&(r?t.svgElement=c:t.image=c)}var p,d=Oy(a.dashArrayX),f=function(t){if(!t||"object"==typeof t&&0===t.length)return[0,0];if("number"==typeof t){var e=Math.ceil(t);return[e,e]}var n=O(t,(function(t){return Math.ceil(t)}));return t.length%2?n.concat(n):n}(a.dashArrayY),g=Py(a.symbol),y=(b=d,O(b,(function(t){return Ry(t)}))),v=Ry(f),m=!r&&C(),_=r&&i.painter.createSVGElement("g"),x=function(){for(var t=1,e=0,n=y.length;e<n;++e)t=fr(t,y[e]);var i=1;for(e=0,n=g.length;e<n;++e)i=fr(i,g[e].length);t*=i;var r=v*y.length*g.length;return{width:Math.max(1,Math.min(t,a.maxTileWidth)),height:Math.max(1,Math.min(r,a.maxTileHeight))}}();var b;m&&(m.width=x.width*n,m.height=x.height*n,p=m.getContext("2d"));(function(){p&&(p.clearRect(0,0,m.width,m.height),a.backgroundColor&&(p.fillStyle=a.backgroundColor,p.fillRect(0,0,m.width,m.height)));for(var t=0,e=0;e<f.length;++e)t+=f[e];if(t<=0)return;var o=-v,s=0,l=0,u=0;for(;o<x.height;){if(s%2==0){for(var h=l/2%g.length,c=0,y=0,b=0;c<2*x.width;){var w=0;for(e=0;e<d[u].length;++e)w+=d[u][e];if(w<=0)break;if(y%2==0){var S=.5*(1-a.symbolSize),M=c+d[u][y]*S,I=o+f[s]*S,T=d[u][y]*a.symbolSize,C=f[s]*a.symbolSize,A=b/2%g[h].length;D(M,I,T,C,g[h][A])}c+=d[u][y],++b,++y===d[u].length&&(y=0)}++u===d.length&&(u=0)}o+=f[s],++l,++s===f.length&&(s=0)}function D(t,e,o,s,l){var u=r?1:n,h=uy(l,t*u,e*u,o*u,s*u,a.color,a.symbolKeepAspect);r?_.appendChild(i.painter.paintOne(h)):Ty(p,h)}})(),s&&Dy.put(e,m||_);t.image=m,t.svgElement=_,t.svgWidth=x.width,t.svgHeight=x.height}(s),s.rotation=a.rotation,s.scaleX=s.scaleY=r?1:1/n,Ay.set(t,s),t.dirty=!1,s}function Py(t){if(!t||0===t.length)return[["rect"]];if("string"==typeof t)return[[t]];for(var e=!0,n=0;n<t.length;++n)if("string"!=typeof t[n]){e=!1;break}if(e)return Py([t]);var i=[];for(n=0;n<t.length;++n)"string"==typeof t[n]?i.push([t[n]]):i.push(t[n]);return i}function Oy(t){if(!t||0===t.length)return[[0,0]];if("number"==typeof t)return[[r=Math.ceil(t),r]];for(var e=!0,n=0;n<t.length;++n)if("number"!=typeof t[n]){e=!1;break}if(e)return Oy([t]);var i=[];for(n=0;n<t.length;++n)if("number"==typeof t[n]){var r=Math.ceil(t[n]);i.push([r,r])}else{(r=O(t[n],(function(t){return Math.ceil(t)}))).length%2==1?i.push(r.concat(r)):i.push(r)}return i}function Ry(t){for(var e=0,n=0;n<t.length;++n)e+=t[n];return t.length%2==1?2*e:e}var Ny=rt,Ey=P,zy=G,By=X,Vy=A,Fy="undefined"!=typeof window,Gy=2e3,Hy=4500,Wy={PROCESSOR:{FILTER:1e3,SERIES_FILTER:800,STATISTIC:5e3},VISUAL:{LAYOUT:1e3,PROGRESSIVE_LAYOUT:1100,GLOBAL:Gy,CHART:3e3,POST_CHART_LAYOUT:4600,COMPONENT:4e3,BRUSH:5e3,CHART_ITEM:Hy,ARIA:6e3,DECAL:7e3}},Yy=/^[a-zA-Z0-9_]+$/,Xy="__connectUpdateStatus";function Uy(t){return function(){for(var e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];if(!this.isDisposed())return jy(this,t,e);bv(this.id)}}function Zy(t){return function(){for(var e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return jy(this,t,e)}}function jy(t,e,n){return n[0]=n[0]&&n[0].toLowerCase(),Ft.prototype[e].apply(t,n)}var qy,Ky,$y,Jy,Qy,tv,ev,nv,iv,rv,ov,av,sv,lv,uv,hv,cv,pv,dv,fv,gv,yv=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e}(Ft),vv=yv.prototype;vv.on=Zy("on"),vv.off=Zy("off");var mv=function(t){function e(e,n,i){var r=t.call(this,new hg)||this;r._chartsViews=[],r._chartsMap={},r._componentsViews=[],r._componentsMap={},r._pendingActions=[],i=i||{},"string"==typeof n&&(n=Dv[n]),r._dom=e;var o="canvas",a=!1,s=r._zr=Hi(e,{renderer:i.renderer||o,devicePixelRatio:i.devicePixelRatio,width:i.width,height:i.height,useDirtyRect:null==i.useDirtyRect?a:i.useDirtyRect});r._throttledZrFlush=If(B(s.flush,s),17),(n=w(n))&&Hp(n,!0),r._theme=n,r._locale=function(t){if(H(t)){var e=Lh[t.toUpperCase()]||{};return t===Ch||t===Ah?w(e):S(w(e),w(Lh.EN),!1)}return S(w(t),w(Lh.EN),!1)}(i.locale||Ph),r._coordSysMgr=new _p;var l=r._api=cv(r);function u(t,e){return t.__prio-e.__prio}return ci(Av,u),ci(Mv,u),r._scheduler=new zf(r,l,Mv,Av),r._messageCenter=new yv,r._labelManager=new qg,r._initEvents(),r.resize=B(r.resize,r),s.animation.on("frame",r._onframe,r),rv(s,r),ov(s,r),st(r),r}return n(e,t),e.prototype._onframe=function(){if(!this._disposed){gv(this);var t=this._scheduler;if(this.__optionUpdated){var e=this.__optionUpdated.silent;this.__flagInMainProcess=!0,qy(this),Jy.update.call(this),this._zr.flush(),this.__flagInMainProcess=!1,this.__optionUpdated=!1,nv.call(this,e),iv.call(this,e)}else if(t.unfinished){var n=1,i=this._model,r=this._api;t.unfinished=!1;do{var o=+new Date;t.performSeriesTasks(i),t.performDataProcessorTasks(i),tv(this,i),t.performVisualTasks(i),uv(this,this._model,r,"remain"),n-=+new Date-o}while(n>0&&t.unfinished);t.unfinished||this._zr.flush()}}},e.prototype.getDom=function(){return this._dom},e.prototype.getId=function(){return this.id},e.prototype.getZr=function(){return this._zr},e.prototype.setOption=function(t,e,n){if(this._disposed)bv(this.id);else{var i,r,o;if(By(e)&&(n=e.lazyUpdate,i=e.silent,r=e.replaceMerge,o=e.transition,e=e.notMerge),this.__flagInMainProcess=!0,!this._model||e){var a=new bp(this._api),s=this._theme,l=this._model=new pp;l.scheduler=this._scheduler,l.init(null,null,null,s,this._locale,a)}this._model.setOption(t,{replaceMerge:r},Iv),dv(this,o),n?(this.__optionUpdated={silent:i},this.__flagInMainProcess=!1,this.getZr().wakeUp()):(qy(this),Jy.update.call(this),this._zr.flush(),this.__optionUpdated=!1,this.__flagInMainProcess=!1,nv.call(this,i),iv.call(this,i))}},e.prototype.setTheme=function(){console.error("ECharts#setTheme() is DEPRECATED in ECharts 3.0")},e.prototype.getModel=function(){return this._model},e.prototype.getOption=function(){return this._model&&this._model.getOption()},e.prototype.getWidth=function(){return this._zr.getWidth()},e.prototype.getHeight=function(){return this._zr.getHeight()},e.prototype.getDevicePixelRatio=function(){return this._zr.painter.dpr||Fy&&window.devicePixelRatio||1},e.prototype.getRenderedCanvas=function(t){if(a.canvasSupported)return(t=I({},t||{})).pixelRatio=t.pixelRatio||this.getDevicePixelRatio(),t.backgroundColor=t.backgroundColor||this._model.get("backgroundColor"),this._zr.painter.getRenderedCanvas(t)},e.prototype.getSvgDataURL=function(){if(a.svgSupported){var t=this._zr;return P(t.storage.getDisplayList(),(function(t){t.stopAnimation(null,!0)})),t.painter.toDataURL()}},e.prototype.getDataURL=function(t){if(!this._disposed){var e=(t=t||{}).excludeComponents,n=this._model,i=[],r=this;Ey(e,(function(t){n.eachComponent({mainType:t},(function(t){var e=r._componentsMap[t.__viewId];e.group.ignore||(i.push(e),e.group.ignore=!0)}))}));var o="svg"===this._zr.painter.getType()?this.getSvgDataURL():this.getRenderedCanvas(t).toDataURL("image/"+(t&&t.type||"png"));return Ey(i,(function(t){t.group.ignore=!1})),o}bv(this.id)},e.prototype.getConnectedDataURL=function(t){if(this._disposed)bv(this.id);else if(a.canvasSupported){var e="svg"===t.type,n=this.group,i=Math.min,r=Math.max,o=1/0;if(Pv[n]){var s=o,l=o,u=-1/0,h=-1/0,c=[],p=t&&t.pixelRatio||this.getDevicePixelRatio();P(kv,(function(o,a){if(o.group===n){var p=e?o.getZr().painter.getSvgDom().innerHTML:o.getRenderedCanvas(w(t)),d=o.getDom().getBoundingClientRect();s=i(d.left,s),l=i(d.top,l),u=r(d.right,u),h=r(d.bottom,h),c.push({dom:p,left:d.left,top:d.top})}}));var d=(u*=p)-(s*=p),f=(h*=p)-(l*=p),g=C(),y=Hi(g,{renderer:e?"svg":"canvas"});if(y.resize({width:d,height:f}),e){var v="";return Ey(c,(function(t){var e=t.left-s,n=t.top-l;v+='<g transform="translate('+e+","+n+')">'+t.dom+"</g>"})),y.painter.getSvgRoot().innerHTML=v,t.connectedBackgroundColor&&y.painter.setBackgroundColor(t.connectedBackgroundColor),y.refreshImmediately(),y.painter.toDataURL()}return t.connectedBackgroundColor&&y.add(new os({shape:{x:0,y:0,width:d,height:f},style:{fill:t.connectedBackgroundColor}})),Ey(c,(function(t){var e=new Ja({style:{x:t.left*p-s,y:t.top*p-l,image:t.dom}});y.add(e)})),y.refreshImmediately(),g.toDataURL("image/"+(t&&t.type||"png"))}return this.getDataURL(t)}},e.prototype.convertToPixel=function(t,e){return Qy(this,"convertToPixel",t,e)},e.prototype.convertFromPixel=function(t,e){return Qy(this,"convertFromPixel",t,e)},e.prototype.containPixel=function(t,e){var n;if(!this._disposed)return P(Pr(this._model,t),(function(t,i){i.indexOf("Models")>=0&&P(t,(function(t){var r=t.coordinateSystem;if(r&&r.containPoint)n=n||!!r.containPoint(e);else if("seriesModels"===i){var o=this._chartsMap[t.__viewId];o&&o.containPoint&&(n=n||o.containPoint(e,t))}else 0}),this)}),this),!!n;bv(this.id)},e.prototype.getVisual=function(t,e){var n=Pr(this._model,t,{defaultMainType:"series"}),i=n.seriesModel;var r=i.getData(),o=n.hasOwnProperty("dataIndexInside")?n.dataIndexInside:n.hasOwnProperty("dataIndex")?r.indexOfRawIndex(n.dataIndex):null;return null!=o?pg(r,o,e):dg(r,e)},e.prototype.getViewOfComponentModel=function(t){return this._componentsMap[t.__viewId]},e.prototype.getViewOfSeriesModel=function(t){return this._chartsMap[t.__viewId]},e.prototype._initEvents=function(){var t,e,n,i=this;Ey(xv,(function(t){var e=function(e){var n,r=i.getModel(),o=e.target,a="globalout"===t;if(a?n={}:o&&Jg(o,(function(t){var e=ys(t);if(e&&null!=e.dataIndex){var i=e.dataModel||r.getSeriesByIndex(e.seriesIndex);return n=i&&i.getDataParams(e.dataIndex,e.dataType)||{},!0}if(e.eventData)return n=I({},e.eventData),!0}),!0),n){var s=n.componentType,l=n.componentIndex;"markLine"!==s&&"markPoint"!==s&&"markArea"!==s||(s="series",l=n.seriesIndex);var u=s&&null!=l&&r.getComponent(s,l),h=u&&i["series"===u.mainType?"_chartsMap":"_componentsMap"][u.__viewId];0,n.event=e,n.type=t,i._$eventProcessor.eventInfo={targetEl:o,packedEvent:n,model:u,view:h},i.trigger(t,n)}};e.zrEventfulCallAtLast=!0,i._zr.on(t,e,i)})),Ey(Sv,(function(t,e){i._messageCenter.on(e,(function(t){this.trigger(e,t)}),i)})),Ey(["selectchanged"],(function(t){i._messageCenter.on(t,(function(e){this.trigger(t,e)}),i)})),t=this._messageCenter,e=this,n=this._api,t.on("selectchanged",(function(t){var i=n.getModel();t.isFromClick?($g("map","selectchanged",e,i,t),$g("pie","selectchanged",e,i,t)):"select"===t.fromAction?($g("map","selected",e,i,t),$g("pie","selected",e,i,t)):"unselect"===t.fromAction&&($g("map","unselected",e,i,t),$g("pie","unselected",e,i,t))}))},e.prototype.isDisposed=function(){return this._disposed},e.prototype.clear=function(){this._disposed?bv(this.id):this.setOption({series:[]},!0)},e.prototype.dispose=function(){if(this._disposed)bv(this.id);else{this._disposed=!0,Er(this.getDom(),Nv,"");var t=this._api,e=this._model;Ey(this._componentsViews,(function(n){n.dispose(e,t)})),Ey(this._chartsViews,(function(n){n.dispose(e,t)})),this._zr.dispose(),delete kv[this.id]}},e.prototype.resize=function(t){if(this._disposed)bv(this.id);else{this._zr.resize(t);var e=this._model;if(this._loadingFX&&this._loadingFX.resize(),e){var n=e.resetOption("media"),i=t&&t.silent;this.__flagInMainProcess=!0,n&&qy(this),Jy.update.call(this,{type:"resize",animation:{duration:0}}),this.__flagInMainProcess=!1,nv.call(this,i),iv.call(this,i)}}},e.prototype.showLoading=function(t,e){if(this._disposed)bv(this.id);else if(By(t)&&(e=t,t=""),t=t||"default",this.hideLoading(),Lv[t]){var n=Lv[t](this._api,e),i=this._zr;this._loadingFX=n,i.add(n)}},e.prototype.hideLoading=function(){this._disposed?bv(this.id):(this._loadingFX&&this._zr.remove(this._loadingFX),this._loadingFX=null)},e.prototype.makeActionFromEvent=function(t){var e=I({},t);return e.type=Sv[t.type],e},e.prototype.dispatchAction=function(t,e){if(this._disposed)bv(this.id);else if(By(e)||(e={silent:!!e}),wv[t.type]&&this._model)if(this.__flagInMainProcess)this._pendingActions.push(t);else{var n=e.silent;ev.call(this,t,n);var i=e.flush;i?this._zr.flush():!1!==i&&a.browser.weChat&&this._throttledZrFlush(),nv.call(this,n),iv.call(this,n)}},e.prototype.updateLabelLayout=function(){var t=this._labelManager;t.updateLayoutConfig(this._api),t.layout(this._api),t.processLabelsOverall()},e.prototype.appendData=function(t){if(this._disposed)bv(this.id);else{var e=t.seriesIndex,n=this.getModel().getSeriesByIndex(e);0,n.appendData(t),this._scheduler.unfinished=!0,this.getZr().wakeUp()}},e.internalField=function(){function t(t){for(var e=[],n=t.currentStates,i=0;i<n.length;i++){var r=n[i];"emphasis"!==r&&"blur"!==r&&"select"!==r&&e.push(r)}t.selected&&t.states.select&&e.push("select"),2===t.hoverState&&t.states.emphasis?e.push("emphasis"):1===t.hoverState&&t.states.blur&&e.push("blur"),t.useStates(e)}function e(t,e){if(!t.preventAutoZ){var n=t.get("z"),i=t.get("zlevel");e.group.traverse((function(t){if(!t.isGroup){null!=n&&(t.z=n),null!=i&&(t.zlevel=i);var e=t.getTextContent(),r=t.getTextGuideLine();if(e&&(e.z=t.z,e.zlevel=t.zlevel,e.z2=t.z2+2),r){var o=t.textGuideLineConfig&&t.textGuideLineConfig.showAbove;r.z=t.z,r.zlevel=t.zlevel,r.z2=t.z2+(o?1:-1)}}}))}}function i(t,e){e.group.traverse((function(t){if(!Bu(t)){var e=t.getTextContent(),n=t.getTextGuideLine();t.stateTransition&&(t.stateTransition=null),e&&e.stateTransition&&(e.stateTransition=null),n&&n.stateTransition&&(n.stateTransition=null),t.hasState()?(t.prevStates=t.currentStates,t.clearStates()):t.prevStates&&(t.prevStates=null)}}))}function r(e,n){var i=e.getModel("stateAnimation"),r=e.isAnimationEnabled(),o=i.get("duration"),a=o>0?{duration:o,delay:i.get("delay"),easing:i.get("easing")}:null;n.group.traverse((function(e){if(e.states&&e.states.emphasis){if(Bu(e))return;if(e instanceof Za&&function(t){var e=_s(t);e.normalFill=t.style.fill,e.normalStroke=t.style.stroke;var n=t.states.select||{};e.selectFill=n.style&&n.style.fill||null,e.selectStroke=n.style&&n.style.stroke||null}(e),e.__dirty){var n=e.prevStates;n&&e.useStates(n)}if(r){e.stateTransition=a;var i=e.getTextContent(),o=e.getTextGuideLine();i&&(i.stateTransition=a),o&&(o.stateTransition=a)}e.__dirty&&t(e)}}))}qy=function(t){var e=t._scheduler;e.restorePipelines(t._model),e.prepareStageTasks(),Ky(t,!0),Ky(t,!1),e.plan()},Ky=function(t,e){for(var n=t._model,i=t._scheduler,r=e?t._componentsViews:t._chartsViews,o=e?t._componentsMap:t._chartsMap,a=t._zr,s=t._api,l=0;l<r.length;l++)r[l].__alive=!1;function u(t){var l=t.__requireNewView;t.__requireNewView=!1;var u="_ec_"+t.id+"_"+t.type,h=!l&&o[u];if(!h){var c=Gr(t.type),p=e?pf.getClass(c.main,c.sub):yf.getClass(c.sub);0,(h=new p).init(n,s),o[u]=h,r.push(h),a.add(h.group)}t.__viewId=h.__id=u,h.__alive=!0,h.__model=t,h.group.__ecComponentInfo={mainType:t.mainType,index:t.componentIndex},!e&&i.prepareView(h,t,n,s)}e?n.eachComponent((function(t,e){"series"!==t&&u(e)})):n.eachSeries(u);for(l=0;l<r.length;){var h=r[l];h.__alive?l++:(!e&&h.renderTask.dispose(),a.remove(h.group),h.dispose(n,s),r.splice(l,1),o[h.__id]===h&&delete o[h.__id],h.__id=h.group.__ecComponentInfo=null)}},$y=function(t,e,n,i,r){var o=t._model;if(o.setUpdatePayload(n),i){var a={};a[i+"Id"]=n[i+"Id"],a[i+"Index"]=n[i+"Index"],a[i+"Name"]=n[i+"Name"];var s={mainType:i,query:a};r&&(s.subType=r);var l,u=n.excludeSeriesId;null!=u&&(l=ht(),Ey(_r(u),(function(t){var e=Tr(t,null);null!=e&&l.set(e,!0)}))),o&&o.eachComponent(s,(function(e){l&&null!=l.get(e.id)||(al(n)&&!n.notBlur?e instanceof rf&&function(t,e,n){if(al(e)){var i=e.type===ws,r=t.seriesIndex,o=t.getData(e.dataType),a=Dr(o,e);a=(F(a)?a[0]:a)||0;var s=o.getItemGraphicEl(a);if(!s)for(var l=o.count(),u=0;!s&&u<l;)s=o.getItemGraphicEl(u++);if(s){var h=ys(s);qs(r,h.focus,h.blurScope,n,i)}else{var c=t.get(["emphasis","focus"]),p=t.get(["emphasis","blurScope"]);null!=c&&qs(r,c,p,n,i)}}}(e,n,t._api):ol(n)&&e instanceof rf&&(!function(t,e,n){if(ol(e)){var i=e.dataType,r=Dr(t.getData(i),e);F(r)||(r=[r]),t[e.type===Ts?"toggleSelect":e.type===Ms?"select":"unselect"](r,i)}}(e,n,t._api),Ks(e),fv(t)),h(t["series"===i?"_chartsMap":"_componentsMap"][e.__viewId]))}),t)}else Ey([].concat(t._componentsViews).concat(t._chartsViews),h);function h(i){i&&i.__alive&&i[e]&&i[e](i.__model,o,t._api,n)}},Jy={prepareAndUpdate:function(t){qy(this),Jy.update.call(this,t)},update:function(t){var e=this._model,n=this._api,i=this._zr,r=this._coordSysMgr,o=this._scheduler;if(e){e.setUpdatePayload(t),o.restoreData(e,t),o.performSeriesTasks(e),r.create(e,n),o.performDataProcessorTasks(e,t),tv(this,e),r.update(e,n),av(e),o.performVisualTasks(e,t),sv(this,e,n,t);var s=e.get("backgroundColor")||"transparent",l=e.get("darkMode");if(a.canvasSupported)i.setBackgroundColor(s),null!=l&&"auto"!==l&&i.setDarkMode(l);else{var u=qe(s);s=an(u,"rgb"),0===u[3]&&(s="transparent")}hv(e,n)}},updateTransform:function(t){var e=this,n=this._model,i=this._api;if(n){n.setUpdatePayload(t);var r=[];n.eachComponent((function(o,a){if("series"!==o){var s=e.getViewOfComponentModel(a);if(s&&s.__alive)if(s.updateTransform){var l=s.updateTransform(a,n,i,t);l&&l.update&&r.push(s)}else r.push(s)}}));var o=ht();n.eachSeries((function(r){var a=e._chartsMap[r.__viewId];if(a.updateTransform){var s=a.updateTransform(r,n,i,t);s&&s.update&&o.set(r.uid,1)}else o.set(r.uid,1)})),av(n),this._scheduler.performVisualTasks(n,t,{setDirty:!0,dirtyMap:o}),uv(this,n,i,t,o),hv(n,this._api)}},updateView:function(t){var e=this._model;e&&(e.setUpdatePayload(t),yf.markUpdateMethod(t,"updateView"),av(e),this._scheduler.performVisualTasks(e,t,{setDirty:!0}),sv(this,this._model,this._api,t),hv(e,this._api))},updateVisual:function(t){var e=this,n=this._model;n&&(n.setUpdatePayload(t),n.eachSeries((function(t){t.getData().clearAllVisual()})),yf.markUpdateMethod(t,"updateVisual"),av(n),this._scheduler.performVisualTasks(n,t,{visualType:"visual",setDirty:!0}),n.eachComponent((function(i,r){if("series"!==i){var o=e.getViewOfComponentModel(r);o&&o.__alive&&o.updateVisual(r,n,e._api,t)}})),n.eachSeries((function(i){e._chartsMap[i.__viewId].updateVisual(i,n,e._api,t)})),hv(n,this._api))},updateLayout:function(t){Jy.update.call(this,t)}},Qy=function(t,e,n,i){if(t._disposed)bv(t.id);else{for(var r,o=t._model,a=t._coordSysMgr.getCoordinateSystems(),s=Pr(o,n),l=0;l<a.length;l++){var u=a[l];if(u[e]&&null!=(r=u[e](o,s,i)))return r}0}},tv=function(t,e){var n=t._chartsMap,i=t._scheduler;e.eachSeries((function(t){i.updateStreamModes(t,n[t.__viewId])}))},ev=function(t,e){var n=this,i=this.getModel(),r=t.type,o=t.escapeConnect,a=wv[r],s=a.actionInfo,l=(s.update||"update").split(":"),u=l.pop(),h=null!=l[0]&&Gr(l[0]);this.__flagInMainProcess=!0;var c=[t],p=!1;t.batch&&(p=!0,c=O(t.batch,(function(e){return(e=T(I({},e),t)).batch=null,e})));var d,f=[],g=ol(t),y=al(t)||g;if(Ey(c,(function(t){(d=(d=a.action(t,n._model,n._api))||I({},t)).type=s.event||d.type,f.push(d),y?($y(n,u,t,"series"),fv(n)):h&&$y(n,u,t,h.main,h.sub)})),"none"===u||y||h||(this.__optionUpdated?(qy(this),Jy.update.call(this,t),this.__optionUpdated=!1):Jy[u].call(this,t)),d=p?{type:s.event||r,escapeConnect:o,batch:f}:f[0],this.__flagInMainProcess=!1,!e){var v=this._messageCenter;if(v.trigger(d.type,d),g){var m={type:"selectchanged",escapeConnect:o,selected:$s(i),isFromClick:t.isFromClick||!1,fromAction:t.type,fromActionPayload:t};v.trigger(m.type,m)}}},nv=function(t){for(var e=this._pendingActions;e.length;){var n=e.shift();ev.call(this,n,t)}},iv=function(t){!t&&this.trigger("updated")},rv=function(t,e){t.on("rendered",(function(n){e.trigger("rendered",n),!t.animation.isFinished()||e.__optionUpdated||e._scheduler.unfinished||e._pendingActions.length||e.trigger("finished")}))},ov=function(t,e){t.on("mouseover",(function(t){var n=Jg(t.target,rl);if(n){var i=ys(n);qs(i.seriesIndex,i.focus,i.blurScope,e._api,!0),function(t,e){!js(t,e)&&!t.__highByOuter&&Bs(t,ks)}(n,t),fv(e)}})).on("mouseout",(function(t){var n=Jg(t.target,rl);if(n){var i=ys(n);qs(i.seriesIndex,i.focus,i.blurScope,e._api,!1),function(t,e){!js(t,e)&&!t.__highByOuter&&Bs(t,Ps)}(n,t),fv(e)}})).on("click",(function(t){var n=Jg(t.target,(function(t){return null!=ys(t).dataIndex}),!0);if(n){var i=n.selected?"unselect":"select",r=ys(n);e._api.dispatchAction({type:i,dataType:r.dataType,dataIndexInside:r.dataIndex,seriesIndex:r.seriesIndex,isFromClick:!0})}}))},av=function(t){t.clearColorPalette(),t.eachSeries((function(t){t.clearColorPalette()}))},sv=function(t,e,n,i){lv(t,e,n,i),Ey(t._chartsViews,(function(t){t.__alive=!1})),uv(t,e,n,i),Ey(t._chartsViews,(function(t){t.__alive||t.remove(e,n)}))},lv=function(t,n,o,a,s){Ey(s||t._componentsViews,(function(t){var s=t.__model;i(s,t),t.render(s,n,o,a),e(s,t),r(s,t)}))},uv=function(t,n,o,s,l){var u=t._scheduler,h=t._labelManager;h.clearLabels();var c=!1;n.eachSeries((function(e){var n=t._chartsMap[e.__viewId];n.__alive=!0;var r=n.renderTask;u.updatePayload(r,s),i(e,n),l&&l.get(e.uid)&&r.dirty(),r.perform(u.getPerformArgs(r))&&(c=!0),e.__transientTransitionOpt=null,n.group.silent=!!e.get("silent"),function(t,e){var n=t.get("blendMode")||null;0;e.group.traverse((function(t){t.isGroup||(t.style.blend=n),t.eachPendingDisplayable&&t.eachPendingDisplayable((function(t){t.style.blend=n}))}))}(e,n),Ks(e),h.addLabelsOfSeries(n)})),u.unfinished=c||u.unfinished,h.updateLayoutConfig(o),h.layout(o),h.processLabelsOverall(),n.eachSeries((function(n){var i=t._chartsMap[n.__viewId];e(n,i),r(n,i)})),function(t,e){var n=t._zr.storage,i=0;n.traverse((function(t){t.isGroup||i++})),i>e.get("hoverLayerThreshold")&&!a.node&&!a.worker&&e.eachSeries((function(e){if(!e.preventUsingHoverLayer){var n=t._chartsMap[e.__viewId];n.__alive&&n.group.traverse((function(t){t.states.emphasis&&(t.states.emphasis.hoverLayer=!0)}))}}))}(t,n)},hv=function(t,e){Ey(Cv,(function(n){n(t,e)}))},fv=function(t){t.__needsUpdateStatus=!0,t.getZr().wakeUp()},gv=function(e){e.__needsUpdateStatus&&(e.getZr().storage.traverse((function(e){Bu(e)||t(e)})),e.__needsUpdateStatus=!1)},cv=function(t){return new(function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return n(i,e),i.prototype.getCoordinateSystems=function(){return t._coordSysMgr.getCoordinateSystems()},i.prototype.getComponentByElement=function(e){for(;e;){var n=e.__ecComponentInfo;if(null!=n)return t._model.getComponent(n.mainType,n.index);e=e.parent}},i.prototype.enterEmphasis=function(e,n){Hs(e,n),fv(t)},i.prototype.leaveEmphasis=function(e,n){Ws(e,n),fv(t)},i.prototype.enterBlur=function(e){Ys(e),fv(t)},i.prototype.leaveBlur=function(e){Xs(e),fv(t)},i.prototype.enterSelect=function(e){Us(e),fv(t)},i.prototype.leaveSelect=function(e){Zs(e),fv(t)},i.prototype.getModel=function(){return t.getModel()},i.prototype.getViewOfComponentModel=function(e){return t.getViewOfComponentModel(e)},i.prototype.getViewOfSeriesModel=function(e){return t.getViewOfSeriesModel(e)},i}(vp))(t)},pv=function(t){function e(t,e){for(var n=0;n<t.length;n++){t[n][Xy]=e}}Ey(Sv,(function(n,i){t._messageCenter.on(i,(function(n){if(Pv[t.group]&&0!==t[Xy]){if(n&&n.escapeConnect)return;var i=t.makeActionFromEvent(n),r=[];Ey(kv,(function(e){e!==t&&e.group===t.group&&r.push(e)})),e(r,0),Ey(r,(function(t){1!==t[Xy]&&t.dispatchAction(i)})),e(r,2)}}))}))},dv=function(t,e){var n=t._model;P(_r(e),(function(t){var e,i=t.from,r=t.to;null==r&&yr(e);var o={includeMainTypes:["series"],enableAll:!1,enableNone:!1},a=i?Pr(n,i,o):null,s=Pr(n,r,o).seriesModel;null==s&&(e=""),a&&a.seriesModel!==s&&(e=""),null!=e&&yr(e),s.__transientTransitionOpt={from:i?i.dimension:null,to:r.dimension,dividingMethod:t.dividingMethod}}))}}(),e}(Ft),_v=mv.prototype;_v.on=Uy("on"),_v.off=Uy("off"),_v.one=function(t,e,n){var i=this;gr(),this.on.call(this,t,(function n(){for(var r=[],o=0;o<arguments.length;o++)r[o]=arguments[o];e&&e.apply&&e.apply(this,r),i.off(t,n)}),n)};var xv=["click","dblclick","mouseover","mouseout","mousemove","mousedown","mouseup","globalout","contextmenu"];function bv(t){0}var wv={},Sv={},Mv=[],Iv=[],Tv=[],Cv=[],Av=[],Dv={},Lv={},kv={},Pv={},Ov=+new Date-0,Rv=+new Date-0,Nv="_echarts_instance_";function Ev(t){Pv[t]=!1}var zv=Ev;function Bv(t){return kv[function(t,e){return t.getAttribute?t.getAttribute(e):t[e]}(t,Nv)]}function Vv(t,e){Dv[t]=e}function Fv(t){Vy(Iv,t)<0&&Iv.push(t)}function Gv(t,e){qv(Mv,t,e,2e3)}function Hv(t){Vy(Tv,t)<0&&t&&Tv.push(t)}function Wv(t){Vy(Cv,t)<0&&t&&Cv.push(t)}function Yv(t,e,n){"function"==typeof e&&(n=e,e="");var i=By(t)?t.type:[t,t={event:e}][0];t.event=(t.event||i).toLowerCase(),e=t.event,Sv[e]||(Ny(Yy.test(i)&&Yy.test(e)),wv[i]||(wv[i]={action:n,actionInfo:t}),Sv[e]=i)}function Xv(t,e){_p.register(t,e)}function Uv(t,e){qv(Av,t,e,1e3,"layout")}function Zv(t,e){qv(Av,t,e,3e3,"visual")}var jv=[];function qv(t,e,n,i,r){if((zy(e)||By(e))&&(n=e,e=i),!(Vy(jv,n)>=0)){jv.push(n);var o=zf.wrapStageHandler(n,r);o.__prio=e,o.__raw=n,t.push(o)}}function Kv(t,e){Lv[t]=e}function $v(t,e,n){sg(t,e,n)}var Jv=function(t){var e=(t=w(t)).type,n="";e||yr(n);var i=e.split(":");2!==i.length&&yr(n);var r=!1;"echarts"===i[0]&&(e=i[1],r=!0),t.__isBuiltIn=r,Rd.set(e,t)};Zv(Gy,Pf),Zv(Hy,Rf),Zv(Hy,Nf),Zv(Gy,cg),Zv(Hy,{createOnAllSeries:!0,performRawSeries:!0,reset:function(t,e){if(t.hasSymbolVisual&&!e.isSeriesFiltered(t))return{dataEach:t.getData().hasItemOption?function(t,e){var n=t.getItemModel(e),i=n.getShallow("symbol",!0),r=n.getShallow("symbolSize",!0),o=n.getShallow("symbolRotate",!0),a=n.getShallow("symbolKeepAspect",!0);null!=i&&t.setItemVisual(e,"symbol",i),null!=r&&t.setItemVisual(e,"symbolSize",r),null!=o&&t.setItemVisual(e,"symbolRotate",o),null!=a&&t.setItemVisual(e,"symbolKeepAspect",a)}:null}}}),Zv(7e3,(function(t,e){t.eachRawSeries((function(n){if(!t.isSeriesFiltered(n)){var i=n.getData();i.hasItemVisual()&&i.each((function(t){var n=i.getItemVisual(t,"decal");n&&(i.ensureUniqueItemVisual(t,"style").decal=ky(n,e))}));var r=i.getVisual("decal");if(r)i.getVisual("style").decal=ky(r,e)}}))})),Fv(Hp),Gv(900,(function(t){var e=ht();t.eachSeries((function(t){var n=t.get("stack");if(n){var i=e.get(n)||e.set(n,[]),r=t.getData(),o={stackResultDimension:r.getCalculationInfo("stackResultDimension"),stackedOverDimension:r.getCalculationInfo("stackedOverDimension"),stackedDimension:r.getCalculationInfo("stackedDimension"),stackedByDimension:r.getCalculationInfo("stackedByDimension"),isStackedByIndex:r.getCalculationInfo("isStackedByIndex"),data:r,seriesModel:t};if(!o.stackedDimension||!o.isStackedByIndex&&!o.stackedByDimension)return;i.length&&r.setCalculationInfo("stackedOnSeries",i[i.length-1].seriesModel),i.push(o)}})),e.each(Wp)})),Kv("default",(function(t,e){T(e=e||{},{text:"loading",textColor:"#000",fontSize:12,fontWeight:"normal",fontStyle:"normal",fontFamily:"sans-serif",maskColor:"rgba(255, 255, 255, 0.8)",showSpinner:!0,color:"#5470c6",spinnerRadius:10,lineWidth:5,zlevel:0});var n=new zi,i=new os({style:{fill:e.maskColor},zlevel:e.zlevel,z:1e4});n.add(i);var r,o=new ls({style:{text:e.text,fill:e.textColor,fontSize:e.fontSize,fontWeight:e.fontWeight,fontStyle:e.fontStyle,fontFamily:e.fontFamily}}),a=new os({style:{fill:"none"},textContent:o,textConfig:{position:"right",distance:10},zlevel:e.zlevel,z:10001});return n.add(a),e.showSpinner&&((r=new au({shape:{startAngle:-Ef/2,endAngle:-Ef/2+.1,r:e.spinnerRadius},style:{stroke:e.color,lineCap:"round",lineWidth:e.lineWidth},zlevel:e.zlevel,z:10001})).animateShape(!0).when(1e3,{endAngle:3*Ef/2}).start("circularInOut"),r.animateShape(!0).when(1e3,{startAngle:3*Ef/2}).delay(300).start("circularInOut"),n.add(r)),n.resize=function(){var n=o.getBoundingRect().width,s=e.showSpinner?e.spinnerRadius:0,l=(t.getWidth()-2*s-(e.showSpinner&&n?10:0)-n)/2-(e.showSpinner&&n?0:5+n/2)+(e.showSpinner?0:n/2)+(n?0:s),u=t.getHeight()/2;e.showSpinner&&r.setShape({cx:l,cy:u}),a.setShape({x:l-s,y:u-s,width:2*s,height:2*s}),i.setShape({x:0,y:0,width:t.getWidth(),height:t.getHeight()})},n.resize(),n})),Yv({type:ws,event:ws,update:ws},ft),Yv({type:Ss,event:Ss,update:Ss},ft),Yv({type:Ms,event:Ms,update:Ms},ft),Yv({type:Is,event:Is,update:Is},ft),Yv({type:Ts,event:Ts,update:Ts},ft),Vv("light",Qf),Vv("dark",rg);var Qv=[],tm={registerPreprocessor:Fv,registerProcessor:Gv,registerPostInit:Hv,registerPostUpdate:Wv,registerAction:Yv,registerCoordinateSystem:Xv,registerLayout:Uv,registerVisual:Zv,registerTransform:Jv,registerLoading:Kv,registerMap:$v,PRIORITY:Wy,ComponentModel:Nc,ComponentView:pf,SeriesModel:rf,ChartView:yf,registerComponentModel:function(t){Nc.registerClass(t)},registerComponentView:function(t){pf.registerClass(t)},registerSeriesModel:function(t){rf.registerClass(t)},registerChartView:function(t){yf.registerClass(t)},registerSubTypeDefaulter:function(t,e){Nc.registerSubTypeDefaulter(t,e)},registerPainter:function(t,e){Wi(t,e)}};function em(t){F(t)?P(t,(function(t){em(t)})):A(Qv,t)>=0||(Qv.push(t),G(t)&&(t={install:t}),t.install(tm))}function nm(t){return null==t?0:t.length||1}function im(t){return t}var rm=function(){function t(t,e,n,i,r,o){this._old=t,this._new=e,this._oldKeyGetter=n||im,this._newKeyGetter=i||im,this.context=r,this._diffModeMultiple="multiple"===o}return t.prototype.add=function(t){return this._add=t,this},t.prototype.update=function(t){return this._update=t,this},t.prototype.updateManyToOne=function(t){return this._updateManyToOne=t,this},t.prototype.updateOneToMany=function(t){return this._updateOneToMany=t,this},t.prototype.remove=function(t){return this._remove=t,this},t.prototype.execute=function(){this[this._diffModeMultiple?"_executeMultiple":"_executeOneToOne"]()},t.prototype._executeOneToOne=function(){var t=this._old,e=this._new,n={},i=new Array(t.length),r=new Array(e.length);this._initIndexMap(t,null,i,"_oldKeyGetter"),this._initIndexMap(e,n,r,"_newKeyGetter");for(var o=0;o<t.length;o++){var a=i[o],s=n[a],l=nm(s);if(l>1){var u=s.shift();1===s.length&&(n[a]=s[0]),this._update&&this._update(u,o)}else 1===l?(n[a]=null,this._update&&this._update(s,o)):this._remove&&this._remove(o)}this._performRestAdd(r,n)},t.prototype._executeMultiple=function(){var t=this._old,e=this._new,n={},i={},r=[],o=[];this._initIndexMap(t,n,r,"_oldKeyGetter"),this._initIndexMap(e,i,o,"_newKeyGetter");for(var a=0;a<r.length;a++){var s=r[a],l=n[s],u=i[s],h=nm(l),c=nm(u);if(h>1&&1===c)this._updateManyToOne&&this._updateManyToOne(u,l),i[s]=null;else if(1===h&&c>1)this._updateOneToMany&&this._updateOneToMany(u,l),i[s]=null;else if(1===h&&1===c)this._update&&this._update(u,l),i[s]=null;else if(h>1)for(var p=0;p<h;p++)this._remove&&this._remove(l[p]);else this._remove&&this._remove(l)}this._performRestAdd(o,i)},t.prototype._performRestAdd=function(t,e){for(var n=0;n<t.length;n++){var i=t[n],r=e[i],o=nm(r);if(o>1)for(var a=0;a<o;a++)this._add&&this._add(r[a]);else 1===o&&this._add&&this._add(r);e[i]=null}},t.prototype._initIndexMap=function(t,e,n,i){for(var r=this._diffModeMultiple,o=0;o<t.length;o++){var a="_ec_"+this[i](t[o],o);if(r||(n[o]=a),e){var s=e[a],l=nm(s);0===l?(e[a]=o,r&&n.push(a)):1===l?e[a]=[s,o]:s.push(o)}}},t}();function om(t,e){return t.hasOwnProperty(e)||(t[e]=[]),t[e]}function am(t){return"category"===t?"ordinal":"time"===t?"time":"float"}var sm,lm,um,hm,cm,pm,dm,fm,gm,ym,vm,mm,_m,xm,bm=function(t){this.otherDims={},null!=t&&I(this,t)},wm=Math.floor,Sm=X,Mm=O,Im="undefined",Tm={float:typeof Float64Array===Im?Array:Float64Array,int:typeof Int32Array===Im?Array:Int32Array,ordinal:Array,number:Array,time:Array},Cm=typeof Uint32Array===Im?Array:Uint32Array,Am=typeof Int32Array===Im?Array:Int32Array,Dm=typeof Uint16Array===Im?Array:Uint16Array,Lm=["hasItemOption","_nameList","_idList","_invertedIndicesMap","_rawData","_dimValueGetter","_count","_rawCount","_nameDimIdx","_idDimIdx","_nameRepeatCount"],km=["_extent","_approximateExtent","_rawExtent"],Pm=function(){function t(t,e){this.type="list",this._count=0,this._rawCount=0,this._storage={},this._storageArr=[],this._nameList=[],this._idList=[],this._visual={},this._layout={},this._itemVisuals=[],this._itemLayouts=[],this._graphicEls=[],this._rawExtent={},this._extent={},this._approximateExtent={},this._calculationInfo={},this.hasItemOption=!0,this.TRANSFERABLE_METHODS=["cloneShallow","downSample","lttbDownSample","map"],this.CHANGABLE_METHODS=["filterSelf","selectRange"],this.DOWNSAMPLE_METHODS=["downSample","lttbDownSample"],this.getRawIndex=cm,t=t||["x","y"];for(var n={},i=[],r={},o=0;o<t.length;o++){var a=t[o],s=H(a)?new bm({name:a}):a instanceof bm?a:new bm(a),l=s.name;s.type=s.type||"float",s.coordDim||(s.coordDim=l,s.coordDimIndex=0);var u=s.otherDims=s.otherDims||{};i.push(l),n[l]=s,s.index=o,s.createInvertedIndices&&(r[l]=[]),0===u.itemName&&(this._nameDimIdx=o,this._nameOrdinalMeta=s.ordinalMeta),0===u.itemId&&(this._idDimIdx=o,this._idOrdinalMeta=s.ordinalMeta)}this.dimensions=i,this._dimensionInfos=n,this.hostModel=e,this._dimensionsSummary=function(t){var e={},n=e.encode={},i=ht(),r=[],o=[],a=e.userOutput={dimensionNames:t.dimensions.slice(),encode:{}};P(t.dimensions,(function(e){var s,l=t.getDimensionInfo(e),u=l.coordDim;if(u){var h=l.coordDimIndex;om(n,u)[h]=e,l.isExtraCoord||(i.set(u,1),"ordinal"!==(s=l.type)&&"time"!==s&&(r[0]=e),om(a.encode,u)[h]=l.index),l.defaultTooltip&&o.push(e)}Vc.each((function(t,e){var i=om(n,e),r=l.otherDims[e];null!=r&&!1!==r&&(i[r]=l.name)}))}));var s=[],l={};i.each((function(t,e){var i=n[e];l[e]=i[0],s=s.concat(i)})),e.dataDimsOnCoord=s,e.encodeFirstDimNotExtra=l;var u=n.label;u&&u.length&&(r=u.slice());var h=n.tooltip;return h&&h.length?o=h.slice():o.length||(o=r.slice()),n.defaultedLabel=r,n.defaultedTooltip=o,e}(this),this._invertedIndicesMap=r,this.userOutput=this._dimensionsSummary.userOutput}return t.prototype.getDimension=function(t){return"number"!=typeof t&&(isNaN(t)||this._dimensionInfos.hasOwnProperty(t))||(t=this.dimensions[t]),t},t.prototype.getDimensionInfo=function(t){return this._dimensionInfos[this.getDimension(t)]},t.prototype.getDimensionsOnCoord=function(){return this._dimensionsSummary.dataDimsOnCoord.slice()},t.prototype.mapDimension=function(t,e){var n=this._dimensionsSummary;if(null==e)return n.encodeFirstDimNotExtra[t];var i=n.encode[t];return i?i[e]:null},t.prototype.mapDimensionsAll=function(t){return(this._dimensionsSummary.encode[t]||[]).slice()},t.prototype.initData=function(t,e,n){var i=Kp(t)||k(t),r=i?new id(t,this.dimensions.length):t;this._rawData=r;var o=r.getSource().sourceFormat;this._storage={},this._indices=null,this._dontMakeIdFromName=null!=this._idDimIdx||o===Yc||!!r.fillStorage,this._nameList=(e||[]).slice(),this._idList=[],this._nameRepeatCount={},n||(this.hasItemOption=!1),this.defaultDimValueGetter=sm[o],this._dimValueGetter=n=n||this.defaultDimValueGetter,this._dimValueGetterArrayRows=sm.arrayRows,this._rawExtent={},this._initDataFromProvider(0,r.count()),r.pure&&(this.hasItemOption=!1)},t.prototype.getProvider=function(){return this._rawData},t.prototype.appendData=function(t){var e=this._rawData,n=this.count();e.appendData(t);var i=e.count();e.persistent||(i+=n),this._initDataFromProvider(n,i,!0)},t.prototype.appendValues=function(t,e){for(var n=this._storage,i=this.dimensions,r=i.length,o=this._rawExtent,a=this.count(),s=a+Math.max(t.length,e?e.length:0),l=0;l<r;l++){var u=i[l];o[u]||(o[u]=mm()),hm(n,this._dimensionInfos[u],s,!0)}for(var h=Mm(i,(function(t){return o[t]})),c=this._storageArr=Mm(i,(function(t){return n[t]})),p=[],d=a;d<s;d++){for(var f=d-a,g=0;g<r;g++){u=i[g];var y=this._dimValueGetterArrayRows(t[f]||p,u,f,g);c[g][d]=y;var v=h[g];y<v[0]&&(v[0]=y),y>v[1]&&(v[1]=y)}e&&(this._nameList[d]=e[f],this._dontMakeIdFromName||gm(this,d))}this._rawCount=this._count=s,this._extent={},lm(this)},t.prototype._initDataFromProvider=function(t,e,n){if(!(t>=e)){for(var i=this._rawData,r=this._storage,o=this.dimensions,a=o.length,s=this._dimensionInfos,l=this._nameList,u=this._idList,h=this._rawExtent,c=i.getSource().sourceFormat===Fc,p=0;p<a;p++){var d=o[p];h[d]||(h[d]=mm()),hm(r,s[d],e,n)}var f=this._storageArr=Mm(o,(function(t){return r[t]})),g=Mm(o,(function(t){return h[t]}));if(i.fillStorage)i.fillStorage(t,e,f,g);else for(var y=[],v=t;v<e;v++){y=i.getItem(v,y);for(var m=0;m<a;m++){d=o[m];var _=f[m],x=this._dimValueGetter(y,d,v,m);_[v]=x;var b=g[m];x<b[0]&&(b[0]=x),x>b[1]&&(b[1]=x)}if(c&&!i.pure&&y){var w=y.name;null==l[v]&&null!=w&&(l[v]=Tr(w,null));var S=y.id;null==u[v]&&null!=S&&(u[v]=Tr(S,null))}this._dontMakeIdFromName||gm(this,v)}!i.persistent&&i.clean&&i.clean(),this._rawCount=this._count=e,this._extent={},lm(this)}},t.prototype.count=function(){return this._count},t.prototype.getIndices=function(){var t,e=this._indices;if(e){var n=e.constructor,i=this._count;if(n===Array){t=new n(i);for(var r=0;r<i;r++)t[r]=e[r]}else t=new n(e.buffer,0,i)}else{t=new(n=um(this))(this.count());for(r=0;r<t.length;r++)t[r]=r}return t},t.prototype.getByDimIdx=function(t,e){if(!(e>=0&&e<this._count))return NaN;var n=this._storageArr[t];return n?n[this.getRawIndex(e)]:NaN},t.prototype.get=function(t,e){if(!(e>=0&&e<this._count))return NaN;var n=this._storage[t];return n?n[this.getRawIndex(e)]:NaN},t.prototype.getByRawIndex=function(t,e){if(!(e>=0&&e<this._rawCount))return NaN;var n=this._storage[t];return n?n[e]:NaN},t.prototype.getValues=function(t,e){var n=[];F(t)||(e=t,t=this.dimensions);for(var i=0,r=t.length;i<r;i++)n.push(this.get(t[i],e));return n},t.prototype.hasValue=function(t){for(var e=this._dimensionsSummary.dataDimsOnCoord,n=0,i=e.length;n<i;n++)if(isNaN(this.get(e[n],t)))return!1;return!0},t.prototype.getDataExtent=function(t){t=this.getDimension(t);var e=this._storage[t],n=mm();if(!e)return n;var i,r=this.count();if(!this._indices)return this._rawExtent[t].slice();if(i=this._extent[t])return i.slice();for(var o=(i=n)[0],a=i[1],s=0;s<r;s++){var l=e[this.getRawIndex(s)];l<o&&(o=l),l>a&&(a=l)}return i=[o,a],this._extent[t]=i,i},t.prototype.getApproximateExtent=function(t){return t=this.getDimension(t),this._approximateExtent[t]||this.getDataExtent(t)},t.prototype.setApproximateExtent=function(t,e){e=this.getDimension(e),this._approximateExtent[e]=t.slice()},t.prototype.getCalculationInfo=function(t){return this._calculationInfo[t]},t.prototype.setCalculationInfo=function(t,e){Sm(t)?I(this._calculationInfo,t):this._calculationInfo[t]=e},t.prototype.getSum=function(t){var e=0;if(this._storage[t])for(var n=0,i=this.count();n<i;n++){var r=this.get(t,n);isNaN(r)||(e+=r)}return e},t.prototype.getMedian=function(t){var e=[];this.each(t,(function(t){isNaN(t)||e.push(t)}));var n=e.sort((function(t,e){return t-e})),i=this.count();return 0===i?0:i%2==1?n[(i-1)/2]:(n[i/2]+n[i/2-1])/2},t.prototype.rawIndexOf=function(t,e){var n=t&&this._invertedIndicesMap[t];var i=n[e];return null==i||isNaN(i)?-1:i},t.prototype.indexOfName=function(t){for(var e=0,n=this.count();e<n;e++)if(this.getName(e)===t)return e;return-1},t.prototype.indexOfRawIndex=function(t){if(t>=this._rawCount||t<0)return-1;if(!this._indices)return t;var e=this._indices,n=e[t];if(null!=n&&n<this._count&&n===t)return t;for(var i=0,r=this._count-1;i<=r;){var o=(i+r)/2|0;if(e[o]<t)i=o+1;else{if(!(e[o]>t))return o;r=o-1}}return-1},t.prototype.indicesOfNearest=function(t,e,n){var i=this._storage[t],r=[];if(!i)return r;null==n&&(n=1/0);for(var o=1/0,a=-1,s=0,l=0,u=this.count();l<u;l++){var h=e-i[this.getRawIndex(l)],c=Math.abs(h);c<=n&&((c<o||c===o&&h>=0&&a<0)&&(o=c,a=h,s=0),h===a&&(r[s++]=l))}return r.length=s,r},t.prototype.getRawDataItem=function(t){if(this._rawData.persistent)return this._rawData.getItem(this.getRawIndex(t));for(var e=[],n=0;n<this.dimensions.length;n++){var i=this.dimensions[n];e.push(this.get(i,t))}return e},t.prototype.getName=function(t){var e=this.getRawIndex(t),n=this._nameList[e];return null==n&&null!=this._nameDimIdx&&(n=fm(this,this._nameDimIdx,this._nameOrdinalMeta,e)),null==n&&(n=""),n},t.prototype.getId=function(t){return dm(this,this.getRawIndex(t))},t.prototype.each=function(t,e,n,i){var r=this;if(this._count){"function"==typeof t&&(i=n,n=e,e=t,t=[]);var o=n||i||this,a=Mm(ym(t),this.getDimension,this);0;for(var s=a.length,l=Mm(a,(function(t){return r._dimensionInfos[t].index})),u=this._storageArr,h=0,c=this.count();h<c;h++){var p=this.getRawIndex(h);switch(s){case 0:e.call(o,h);break;case 1:e.call(o,u[l[0]][p],h);break;case 2:e.call(o,u[l[0]][p],u[l[1]][p],h);break;default:for(var d=0,f=[];d<s;d++)f[d]=u[l[d]][p];f[d]=h,e.apply(o,f)}}}},t.prototype.filterSelf=function(t,e,n,i){var r=this;if(this._count){"function"==typeof t&&(i=n,n=e,e=t,t=[]);var o=n||i||this,a=Mm(ym(t),this.getDimension,this);0;for(var s=this.count(),l=new(um(this))(s),u=[],h=a.length,c=0,p=Mm(a,(function(t){return r._dimensionInfos[t].index})),d=p[0],f=this._storageArr,g=0;g<s;g++){var y=void 0,v=this.getRawIndex(g);if(0===h)y=e.call(o,g);else if(1===h){var m=f[d][v];y=e.call(o,m,g)}else{for(var _=0;_<h;_++)u[_]=f[p[_]][v];u[_]=g,y=e.apply(o,u)}y&&(l[c++]=v)}return c<s&&(this._indices=l),this._count=c,this._extent={},this.getRawIndex=this._indices?pm:cm,this}},t.prototype.selectRange=function(t){var e=this,n=this._count;if(n){var i=[];for(var r in t)t.hasOwnProperty(r)&&i.push(r);0;var o=i.length;if(o){var a=this.count(),s=new(um(this))(a),l=0,u=i[0],h=Mm(i,(function(t){return e._dimensionInfos[t].index})),c=t[u][0],p=t[u][1],d=this._storageArr,f=!1;if(!this._indices){var g=0;if(1===o){for(var y=d[h[0]],v=0;v<n;v++){((b=y[v])>=c&&b<=p||isNaN(b))&&(s[l++]=g),g++}f=!0}else if(2===o){y=d[h[0]];var m=d[h[1]],_=t[i[1]][0],x=t[i[1]][1];for(v=0;v<n;v++){var b=y[v],w=m[v];(b>=c&&b<=p||isNaN(b))&&(w>=_&&w<=x||isNaN(w))&&(s[l++]=g),g++}f=!0}}if(!f)if(1===o)for(v=0;v<a;v++){var S=this.getRawIndex(v);((b=d[h[0]][S])>=c&&b<=p||isNaN(b))&&(s[l++]=S)}else for(v=0;v<a;v++){for(var M=!0,I=(S=this.getRawIndex(v),0);I<o;I++){var T=i[I];((b=d[h[I]][S])<t[T][0]||b>t[T][1])&&(M=!1)}M&&(s[l++]=this.getRawIndex(v))}return l<a&&(this._indices=s),this._count=l,this._extent={},this.getRawIndex=this._indices?pm:cm,this}}},t.prototype.mapArray=function(t,e,n,i){"function"==typeof t&&(i=n,n=e,e=t,t=[]),n=n||i||this;var r=[];return this.each(t,(function(){r.push(e&&e.apply(this,arguments))}),n),r},t.prototype.map=function(t,e,n,i){var r=n||i||this,o=Mm(ym(t),this.getDimension,this);var a=vm(this,o),s=a._storage;a._indices=this._indices,a.getRawIndex=a._indices?pm:cm;for(var l=[],u=o.length,h=this.count(),c=[],p=a._rawExtent,d=0;d<h;d++){for(var f=0;f<u;f++)c[f]=this.get(o[f],d);c[u]=d;var g=e&&e.apply(r,c);if(null!=g){"object"!=typeof g&&(l[0]=g,g=l);for(var y=this.getRawIndex(d),v=0;v<g.length;v++){var m=o[v],_=g[v],x=p[m],b=s[m];b&&(b[y]=_),_<x[0]&&(x[0]=_),_>x[1]&&(x[1]=_)}}}return a},t.prototype.downSample=function(t,e,n,i){for(var r=vm(this,[t]),o=r._storage,a=[],s=wm(1/e),l=o[t],u=this.count(),h=r._rawExtent[t],c=new(um(this))(u),p=0,d=0;d<u;d+=s){s>u-d&&(s=u-d,a.length=s);for(var f=0;f<s;f++){var g=this.getRawIndex(d+f);a[f]=l[g]}var y=n(a),v=this.getRawIndex(Math.min(d+i(a,y)||0,u-1));l[v]=y,y<h[0]&&(h[0]=y),y>h[1]&&(h[1]=y),c[p++]=v}return r._count=p,r._indices=c,r.getRawIndex=pm,r},t.prototype.lttbDownSample=function(t,e){var n,i,r,o=vm(this,[]),a=o._storage[t],s=this.count(),l=new(um(this))(s),u=0,h=wm(1/e),c=this.getRawIndex(0);l[u++]=c;for(var p=1;p<s-1;p+=h){for(var d=Math.min(p+h,s-1),f=Math.min(p+2*h,s),g=(f+d)/2,y=0,v=d;v<f;v++){var m=a[S=this.getRawIndex(v)];isNaN(m)||(y+=m)}y/=f-d;var _=p,x=Math.min(p+h,s),b=p-1,w=a[c];n=-1,r=_;for(v=_;v<x;v++){var S;m=a[S=this.getRawIndex(v)];isNaN(m)||(i=Math.abs((b-g)*(m-w)-(b-v)*(y-w)))>n&&(n=i,r=S)}l[u++]=r,c=r}return l[u++]=this.getRawIndex(s-1),o._count=u,o._indices=l,o.getRawIndex=pm,o},t.prototype.getItemModel=function(t){var e=this.hostModel,n=this.getRawDataItem(t);return new Sh(n,e,e&&e.ecModel)},t.prototype.diff=function(t){var e=this;return new rm(t?t.getIndices():[],this.getIndices(),(function(e){return dm(t,e)}),(function(t){return dm(e,t)}))},t.prototype.getVisual=function(t){var e=this._visual;return e&&e[t]},t.prototype.setVisual=function(t,e){this._visual=this._visual||{},Sm(t)?I(this._visual,t):this._visual[t]=e},t.prototype.getItemVisual=function(t,e){var n=this._itemVisuals[t],i=n&&n[e];return null==i?this.getVisual(e):i},t.prototype.hasItemVisual=function(){return this._itemVisuals.length>0},t.prototype.ensureUniqueItemVisual=function(t,e){var n=this._itemVisuals,i=n[t];i||(i=n[t]={});var r=i[e];return null==r&&(F(r=this.getVisual(e))?r=r.slice():Sm(r)&&(r=I({},r)),i[e]=r),r},t.prototype.setItemVisual=function(t,e,n){var i=this._itemVisuals[t]||{};this._itemVisuals[t]=i,Sm(e)?I(i,e):i[e]=n},t.prototype.clearAllVisual=function(){this._visual={},this._itemVisuals=[]},t.prototype.setLayout=function(t,e){if(Sm(t))for(var n in t)t.hasOwnProperty(n)&&this.setLayout(n,t[n]);else this._layout[t]=e},t.prototype.getLayout=function(t){return this._layout[t]},t.prototype.getItemLayout=function(t){return this._itemLayouts[t]},t.prototype.setItemLayout=function(t,e,n){this._itemLayouts[t]=n?I(this._itemLayouts[t]||{},e):e},t.prototype.clearItemLayouts=function(){this._itemLayouts.length=0},t.prototype.setItemGraphicEl=function(t,e){var n=this.hostModel;if(e){var i=ys(e);i.dataIndex=t,i.dataType=this.dataType,i.seriesIndex=n&&n.seriesIndex,"group"===e.type&&e.traverse(_m,e)}this._graphicEls[t]=e},t.prototype.getItemGraphicEl=function(t){return this._graphicEls[t]},t.prototype.eachItemGraphicEl=function(t,e){P(this._graphicEls,(function(n,i){n&&t&&t.call(e,n,i)}))},t.prototype.cloneShallow=function(e){e||(e=new t(Mm(this.dimensions,this.getDimensionInfo,this),this.hostModel));if(e._storage=this._storage,e._storageArr=this._storageArr,xm(e,this),this._indices){var n=this._indices.constructor;if(n===Array){var i=this._indices.length;e._indices=new n(i);for(var r=0;r<i;r++)e._indices[r]=this._indices[r]}else e._indices=new n(this._indices)}else e._indices=null;return e.getRawIndex=e._indices?pm:cm,e},t.prototype.wrapMethod=function(t,e){var n=this[t];"function"==typeof n&&(this.__wrappedMethods=this.__wrappedMethods||[],this.__wrappedMethods.push(t),this[t]=function(){var t=n.apply(this,arguments);return e.apply(this,[t].concat(nt(arguments)))})},t.internalField=function(){function e(t,e,n,i){return bd(t[i],this._dimensionInfos[e])}sm={arrayRows:e,objectRows:function(t,e,n,i){return bd(t[e],this._dimensionInfos[e])},keyedColumns:e,original:function(t,e,n,i){var r=t&&(null==t.value?t:t.value);return!this._rawData.pure&&function(t){return X(t)&&!(t instanceof Array)}(t)&&(this.hasItemOption=!0),bd(r instanceof Array?r[i]:r,this._dimensionInfos[e])},typedArray:function(t,e,n,i){return t[i]}},lm=function(t){var e=t._invertedIndicesMap;P(e,(function(n,i){var r=t._dimensionInfos[i].ordinalMeta;if(r){n=e[i]=new Am(r.categories.length);for(var o=0;o<n.length;o++)n[o]=-1;for(o=0;o<t._count;o++)n[t.get(i,o)]=o}}))},fm=function(t,e,n,i){var r,o=t._storageArr[e];return o&&(r=o[i],n&&n.categories.length&&(r=n.categories[r])),Tr(r,null)},um=function(t){return t._rawCount>65535?Cm:Dm},hm=function(t,e,n,i){var r=Tm[e.type],o=e.name;if(i){var a=t[o],s=a&&a.length;if(s!==n){for(var l=new r(n),u=0;u<s;u++)l[u]=a[u];t[o]=l}}else t[o]=new r(n)},cm=function(t){return t},pm=function(t){return t<this._count&&t>=0?this._indices[t]:-1},dm=function(t,e){var n=t._idList[e];return null==n&&null!=t._idDimIdx&&(n=fm(t,t._idDimIdx,t._idOrdinalMeta,e)),null==n&&(n="e\0\0"+e),n},ym=function(t){return F(t)||(t=null!=t?[t]:[]),t},function(t,e){for(var n=0;n<e.length;n++)t._dimensionInfos[e[n]]||console.error("Unkown dimension "+e[n])},vm=function(e,n){var i=e.dimensions,r=new t(Mm(i,e.getDimensionInfo,e),e.hostModel);xm(r,e);for(var o,a,s=r._storage={},l=e._storage,u=r._storageArr=[],h=0;h<i.length;h++){var c=i[h];l[c]&&(A(n,c)>=0?(s[c]=(o=l[c],a=void 0,(a=o.constructor)===Array?o.slice():new a(o)),r._rawExtent[c]=mm(),r._extent[c]=null):s[c]=l[c],u.push(s[c]))}return r},mm=function(){return[1/0,-1/0]},_m=function(t){var e=ys(t),n=ys(this);e.seriesIndex=n.seriesIndex,e.dataIndex=n.dataIndex,e.dataType=n.dataType},xm=function(t,e){P(Lm.concat(e.__wrappedMethods||[]),(function(n){e.hasOwnProperty(n)&&(t[n]=e[n])})),t.__wrappedMethods=e.__wrappedMethods,P(km,(function(n){t[n]=w(e[n])})),t._calculationInfo=I({},e._calculationInfo)},gm=function(t,e){var n=t._nameList,i=t._idList,r=t._nameDimIdx,o=t._idDimIdx,a=n[e],s=i[e];if(null==a&&null!=r&&(n[e]=a=fm(t,r,t._nameOrdinalMeta,e)),null==s&&null!=o&&(i[e]=s=fm(t,o,t._idOrdinalMeta,e)),null==s&&null!=a){var l=t._nameRepeatCount,u=l[a]=(l[a]||0)+1;s=a,u>1&&(s+="__ec__"+u),i[e]=s}}}(),t}();function Om(t,e,n){Kp(e)||(e=Jp(e)),n=n||{},t=(t||[]).slice();for(var i=(n.dimsDef||[]).slice(),r=ht(),o=ht(),a=[],s=function(t,e,n,i){var r=Math.max(t.dimensionsDetectedCount||1,e.length,n.length,i||0);return P(e,(function(t){var e;X(t)&&(e=t.dimsDef)&&(r=Math.max(r,e.length))})),r}(e,t,i,n.dimCount),l=0;l<s;l++){var u=i[l],h=i[l]=I({},X(u)?u:{name:u}),c=h.name,p=a[l]=new bm;null!=c&&null==r.get(c)&&(p.name=p.displayName=c,r.set(c,l)),null!=h.type&&(p.type=h.type),null!=h.displayName&&(p.displayName=h.displayName)}var d=n.encodeDef;!d&&n.encodeDefaulter&&(d=n.encodeDefaulter(e,s));var f=ht(d);f.each((function(t,e){var n=_r(t).slice();if(1===n.length&&!H(n[0])&&n[0]<0)f.set(e,!1);else{var i=f.set(e,[]);P(n,(function(t,n){var o=H(t)?r.get(t):t;null!=o&&o<s&&(i[n]=o,y(a[o],e,n))}))}}));var g=0;function y(t,e,n){null!=Vc.get(e)?t.otherDims[e]=n:(t.coordDim=e,t.coordDimIndex=n,o.set(e,!0))}P(t,(function(t){var e,n,i,r;if(H(t))e=t,r={};else{e=(r=t).name;var o=r.ordinalMeta;r.ordinalMeta=null,(r=w(r)).ordinalMeta=o,n=r.dimsDef,i=r.otherDims,r.name=r.coordDim=r.coordDimIndex=r.dimsDef=r.otherDims=null}var s=f.get(e);if(!1!==s){if(!(s=_r(s)).length)for(var l=0;l<(n&&n.length||1);l++){for(;g<a.length&&null!=a[g].coordDim;)g++;g<a.length&&s.push(g++)}P(s,(function(t,o){var s=a[t];if(y(T(s,r),e,o),null==s.name&&n){var l=n[o];!X(l)&&(l={name:l}),s.name=s.displayName=l.name,s.defaultTooltip=l.defaultTooltip}i&&T(s.otherDims,i)}))}}));var v=n.generateCoord,m=n.generateCoordCount,_=null!=m;m=v?m||1:0;for(var x=v||"value",b=0;b<s;b++){null==(p=a[b]=a[b]||new bm).coordDim&&(p.coordDim=Rm(x,o,_),p.coordDimIndex=0,(!v||m<=0)&&(p.isExtraCoord=!0),m--),null==p.name&&(p.name=Rm(p.coordDim,r,!1)),null!=p.type||ep(e,b)!==jc&&(!p.isExtraCoord||null==p.otherDims.itemName&&null==p.otherDims.seriesName)||(p.type="ordinal")}return a}function Rm(t,e,n){if(n||null!=e.get(t)){for(var i=0;null!=e.get(t+i);)i++;t+=i}return e.set(t,!0),t}function Nm(t,e){return Om((e=e||{}).coordDimensions||[],t,{dimsDef:e.dimensionsDefine||t.dimensionsDefine,encodeDef:e.encodeDefine||t.encodeDefine,dimCount:e.dimensionsCount,encodeDefaulter:e.encodeDefaulter,generateCoord:e.generateCoord,generateCoordCount:e.generateCoordCount})}var Em=function(t){this.coordSysDims=[],this.axisMap=ht(),this.categoryAxisMap=ht(),this.coordSysName=t};var zm={cartesian2d:function(t,e,n,i){var r=t.getReferringComponents("xAxis",Or).models[0],o=t.getReferringComponents("yAxis",Or).models[0];e.coordSysDims=["x","y"],n.set("x",r),n.set("y",o),Bm(r)&&(i.set("x",r),e.firstCategoryDimIndex=0),Bm(o)&&(i.set("y",o),null==e.firstCategoryDimIndex&&(e.firstCategoryDimIndex=1))},singleAxis:function(t,e,n,i){var r=t.getReferringComponents("singleAxis",Or).models[0];e.coordSysDims=["single"],n.set("single",r),Bm(r)&&(i.set("single",r),e.firstCategoryDimIndex=0)},polar:function(t,e,n,i){var r=t.getReferringComponents("polar",Or).models[0],o=r.findAxisModel("radiusAxis"),a=r.findAxisModel("angleAxis");e.coordSysDims=["radius","angle"],n.set("radius",o),n.set("angle",a),Bm(o)&&(i.set("radius",o),e.firstCategoryDimIndex=0),Bm(a)&&(i.set("angle",a),null==e.firstCategoryDimIndex&&(e.firstCategoryDimIndex=1))},geo:function(t,e,n,i){e.coordSysDims=["lng","lat"]},parallel:function(t,e,n,i){var r=t.ecModel,o=r.getComponent("parallel",t.get("parallelIndex")),a=e.coordSysDims=o.dimensions.slice();P(o.parallelAxisIndex,(function(t,o){var s=r.getComponent("parallelAxis",t),l=a[o];n.set(l,s),Bm(s)&&(i.set(l,s),null==e.firstCategoryDimIndex&&(e.firstCategoryDimIndex=o))}))}};function Bm(t){return"category"===t.get("type")}function Vm(t,e,n){var i,r,o,a,s=(n=n||{}).byIndex,l=n.stackedCoordDimension,u=!(!t||!t.get("stack"));if(P(e,(function(t,n){H(t)&&(e[n]=t={name:t}),u&&!t.isExtraCoord&&(s||i||!t.ordinalMeta||(i=t),r||"ordinal"===t.type||"time"===t.type||l&&l!==t.coordDim||(r=t))})),!r||s||i||(s=!0),r){o="__\0ecstackresult",a="__\0ecstackedover",i&&(i.createInvertedIndices=!0);var h=r.coordDim,c=r.type,p=0;P(e,(function(t){t.coordDim===h&&p++})),e.push({name:o,coordDim:h,coordDimIndex:p,type:c,isExtraCoord:!0,isCalculationCoord:!0}),p++,e.push({name:a,coordDim:a,coordDimIndex:p,type:c,isExtraCoord:!0,isCalculationCoord:!0})}return{stackedDimension:r&&r.name,stackedByDimension:i&&i.name,isStackedByIndex:s,stackedOverDimension:a,stackResultDimension:o}}function Fm(t,e){return!!e&&e===t.getCalculationInfo("stackedDimension")}function Gm(t,e){return Fm(t,e)?t.getCalculationInfo("stackResultDimension"):e}function Hm(t,e,n){n=n||{},Kp(t)||(t=Jp(t));var i,r=e.get("coordinateSystem"),o=_p.get(r),a=function(t){var e=t.get("coordinateSystem"),n=new Em(e),i=zm[e];if(i)return i(t,n,n.axisMap,n.categoryAxisMap),n}(e);a&&a.coordSysDims&&(i=O(a.coordSysDims,(function(t){var e={name:t},n=a.axisMap.get(t);if(n){var i=n.get("type");e.type=am(i)}return e}))),i||(i=o&&(o.getDimensionsInfo?o.getDimensionsInfo():o.dimensions.slice())||["x","y"]);var s,l,u=n.useEncodeDefaulter,h=Nm(t,{coordDimensions:i,generateCoord:n.generateCoord,encodeDefaulter:G(u)?u:u?V(Jc,i,e):null});a&&P(h,(function(t,e){var i=t.coordDim,r=a.categoryAxisMap.get(i);r&&(null==s&&(s=e),t.ordinalMeta=r.getOrdinalMeta(),n.createInvertedIndices&&(t.createInvertedIndices=!0)),null!=t.otherDims.itemName&&(l=!0)})),l||null==s||(h[s].otherDims.itemName=0);var c=Vm(e,h),p=new Pm(h,e);p.setCalculationInfo(c);var d=null!=s&&function(t){if(t.sourceFormat===Fc){var e=function(t){var e=0;for(;e<t.length&&null==t[e];)e++;return t[e]}(t.data||[]);return null!=e&&!F(wr(e))}}(t)?function(t,e,n,i){return i===s?n:this.defaultDimValueGetter(t,e,n,i)}:null;return p.hasItemOption=!1,p.initData(t,null,d),p}var Wm=function(){function t(t){this._setting=t||{},this._extent=[1/0,-1/0]}return t.prototype.getSetting=function(t){return this._setting[t]},t.prototype.unionExtent=function(t){var e=this._extent;t[0]<e[0]&&(e[0]=t[0]),t[1]>e[1]&&(e[1]=t[1])},t.prototype.unionExtentFromData=function(t,e){this.unionExtent(t.getApproximateExtent(e))},t.prototype.getExtent=function(){return this._extent.slice()},t.prototype.setExtent=function(t,e){var n=this._extent;isNaN(t)||(n[0]=t),isNaN(e)||(n[1]=e)},t.prototype.isInExtentRange=function(t){return this._extent[0]<=t&&this._extent[1]>=t},t.prototype.isBlank=function(){return this._isBlank},t.prototype.setBlank=function(t){this._isBlank=t},t}();jr(Wm);var Ym=function(){function t(t){this.categories=t.categories||[],this._needCollect=t.needCollect,this._deduplication=t.deduplication}return t.createByAxisModel=function(e){var n=e.option,i=n.data,r=i&&O(i,Xm);return new t({categories:r,needCollect:!r,deduplication:!1!==n.dedplication})},t.prototype.getOrdinal=function(t){return this._getOrCreateMap().get(t)},t.prototype.parseAndCollect=function(t){var e,n=this._needCollect;if("string"!=typeof t&&!n)return t;if(n&&!this._deduplication)return e=this.categories.length,this.categories[e]=t,e;var i=this._getOrCreateMap();return null==(e=i.get(t))&&(n?(e=this.categories.length,this.categories[e]=t,i.set(t,e)):e=NaN),e},t.prototype._getOrCreateMap=function(){return this._map||(this._map=ht(this.categories))},t}();function Xm(t){return X(t)&&null!=t.value?t.value:t+""}var Um=ji;function Zm(t,e,n,i){var r={},o=t[1]-t[0],a=r.interval=sr(o/e,!0);null!=n&&a<n&&(a=r.interval=n),null!=i&&a>i&&(a=r.interval=i);var s=r.intervalPrecision=jm(a);return function(t,e){!isFinite(t[0])&&(t[0]=e[0]),!isFinite(t[1])&&(t[1]=e[1]),qm(t,0,e),qm(t,1,e),t[0]>t[1]&&(t[0]=t[1])}(r.niceTickExtent=[Um(Math.ceil(t[0]/a)*a,s),Um(Math.floor(t[1]/a)*a,s)],t),r}function jm(t){return $i(t)+2}function qm(t,e,n){t[e]=Math.max(Math.min(t[e],n[1]),n[0])}function Km(t,e){return t>=e[0]&&t<=e[1]}function $m(t,e){return e[1]===e[0]?.5:(t-e[0])/(e[1]-e[0])}function Jm(t,e){return t*(e[1]-e[0])+e[0]}var Qm=function(t){function e(e){var n=t.call(this,e)||this;n.type="ordinal";var i=n.getSetting("ordinalMeta");return i||(i=new Ym({})),F(i)&&(i=new Ym({categories:O(i,(function(t){return X(t)?t.value:t}))})),n._ordinalMeta=i,n._extent=n.getSetting("extent")||[0,i.categories.length-1],n}return n(e,t),e.prototype.parse=function(t){return"string"==typeof t?this._ordinalMeta.getOrdinal(t):Math.round(t)},e.prototype.contain=function(t){return Km(t=this.parse(t),this._extent)&&null!=this._ordinalMeta.categories[t]},e.prototype.normalize=function(t){return $m(t=this._getTickNumber(this.parse(t)),this._extent)},e.prototype.scale=function(t){return t=Math.round(Jm(t,this._extent)),this.getRawOrdinalNumber(t)},e.prototype.getTicks=function(){for(var t=[],e=this._extent,n=e[0];n<=e[1];)t.push({value:n}),n++;return t},e.prototype.getMinorTicks=function(t){},e.prototype.setSortInfo=function(t){if(null!=t){for(var e=t.ordinalNumbers,n=this._ordinalNumbersByTick=[],i=this._ticksByOrdinalNumber=[],r=0,o=this._ordinalMeta.categories.length,a=Math.min(o,e.length);r<a;++r){var s=e[r];n[r]=s,i[s]=r}for(var l=0;r<o;++r){for(;null!=i[l];)l++;n.push(l),i[l]=r}}else this._ordinalNumbersByTick=this._ticksByOrdinalNumber=null},e.prototype._getTickNumber=function(t){var e=this._ticksByOrdinalNumber;return e&&t>=0&&t<e.length?e[t]:t},e.prototype.getRawOrdinalNumber=function(t){var e=this._ordinalNumbersByTick;return e&&t>=0&&t<e.length?e[t]:t},e.prototype.getLabel=function(t){if(!this.isBlank()){var e=this.getRawOrdinalNumber(t.value),n=this._ordinalMeta.categories[e];return null==n?"":n+""}},e.prototype.count=function(){return this._extent[1]-this._extent[0]+1},e.prototype.unionExtentFromData=function(t,e){this.unionExtent(t.getApproximateExtent(e))},e.prototype.isInExtentRange=function(t){return t=this._getTickNumber(t),this._extent[0]<=t&&this._extent[1]>=t},e.prototype.getOrdinalMeta=function(){return this._ordinalMeta},e.prototype.niceTicks=function(){},e.prototype.niceExtent=function(){},e.type="ordinal",e}(Wm);Wm.registerClass(Qm);var t_=ji,e_=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="interval",e._interval=0,e._intervalPrecision=2,e}return n(e,t),e.prototype.parse=function(t){return t},e.prototype.contain=function(t){return Km(t,this._extent)},e.prototype.normalize=function(t){return $m(t,this._extent)},e.prototype.scale=function(t){return Jm(t,this._extent)},e.prototype.setExtent=function(t,e){var n=this._extent;isNaN(t)||(n[0]=parseFloat(t)),isNaN(e)||(n[1]=parseFloat(e))},e.prototype.unionExtent=function(t){var e=this._extent;t[0]<e[0]&&(e[0]=t[0]),t[1]>e[1]&&(e[1]=t[1]),this.setExtent(e[0],e[1])},e.prototype.getInterval=function(){return this._interval},e.prototype.setInterval=function(t){this._interval=t,this._niceExtent=this._extent.slice(),this._intervalPrecision=jm(t)},e.prototype.getTicks=function(t){var e=this._interval,n=this._extent,i=this._niceExtent,r=this._intervalPrecision,o=[];if(!e)return o;n[0]<i[0]&&(t?o.push({value:t_(i[0]-e,r)}):o.push({value:n[0]}));for(var a=i[0];a<=i[1]&&(o.push({value:a}),(a=t_(a+e,r))!==o[o.length-1].value);)if(o.length>1e4)return[];var s=o.length?o[o.length-1].value:i[1];return n[1]>s&&(t?o.push({value:t_(s+e,r)}):o.push({value:n[1]})),o},e.prototype.getMinorTicks=function(t){for(var e=this.getTicks(!0),n=[],i=this.getExtent(),r=1;r<e.length;r++){for(var o=e[r],a=e[r-1],s=0,l=[],u=(o.value-a.value)/t;s<t-1;){var h=t_(a.value+(s+1)*u);h>i[0]&&h<i[1]&&l.push(h),s++}n.push(l)}return n},e.prototype.getLabel=function(t,e){if(null==t)return"";var n=e&&e.precision;return null==n?n=$i(t.value)||0:"auto"===n&&(n=this._intervalPrecision),hc(t_(t.value,n,!0))},e.prototype.niceTicks=function(t,e,n){t=t||5;var i=this._extent,r=i[1]-i[0];if(isFinite(r)){r<0&&(r=-r,i.reverse());var o=Zm(i,t,e,n);this._intervalPrecision=o.intervalPrecision,this._interval=o.interval,this._niceExtent=o.niceTickExtent}},e.prototype.niceExtent=function(t){var e=this._extent;if(e[0]===e[1])if(0!==e[0]){var n=e[0];t.fixMax||(e[1]+=n/2),e[0]-=n/2}else e[1]=1;var i=e[1]-e[0];isFinite(i)||(e[0]=0,e[1]=1),this.niceTicks(t.splitNumber,t.minInterval,t.maxInterval);var r=this._interval;t.fixMin||(e[0]=t_(Math.floor(e[0]/r)*r)),t.fixMax||(e[1]=t_(Math.ceil(e[1]/r)*r))},e.type="interval",e}(Wm);Wm.registerClass(e_);var n_="__ec_stack_",i_="undefined"!=typeof Float32Array?Float32Array:Array;function r_(t){return t.get("stack")||n_+t.seriesIndex}function o_(t){return t.dim+t.index}function a_(t,e){var n=[];return e.eachSeriesByType(t,(function(t){p_(t)&&!d_(t)&&n.push(t)})),n}function s_(t){var e=function(t){var e={};P(t,(function(t){var n=t.coordinateSystem.getBaseAxis();if("time"===n.type||"value"===n.type)for(var i=t.getData(),r=n.dim+"_"+n.index,o=i.mapDimension(n.dim),a=0,s=i.count();a<s;++a){var l=i.get(o,a);e[r]?e[r].push(l):e[r]=[l]}}));var n={};for(var i in e)if(e.hasOwnProperty(i)){var r=e[i];if(r){r.sort((function(t,e){return t-e}));for(var o=null,a=1;a<r.length;++a){var s=r[a]-r[a-1];s>0&&(o=null===o?s:Math.min(o,s))}n[i]=o}}return n}(t),n=[];return P(t,(function(t){var i,r=t.coordinateSystem.getBaseAxis(),o=r.getExtent();if("category"===r.type)i=r.getBandWidth();else if("value"===r.type||"time"===r.type){var a=r.dim+"_"+r.index,s=e[a],l=Math.abs(o[1]-o[0]),u=r.scale.getExtent(),h=Math.abs(u[1]-u[0]);i=s?l/h*s:l}else{var c=t.getData();i=Math.abs(o[1]-o[0])/c.count()}var p=Zi(t.get("barWidth"),i),d=Zi(t.get("barMaxWidth"),i),f=Zi(t.get("barMinWidth")||1,i),g=t.get("barGap"),y=t.get("barCategoryGap");n.push({bandWidth:i,barWidth:p,barMaxWidth:d,barMinWidth:f,barGap:g,barCategoryGap:y,axisKey:o_(r),stackId:r_(t)})})),l_(n)}function l_(t){var e={};P(t,(function(t,n){var i=t.axisKey,r=t.bandWidth,o=e[i]||{bandWidth:r,remainedWidth:r,autoWidthCount:0,categoryGap:null,gap:"20%",stacks:{}},a=o.stacks;e[i]=o;var s=t.stackId;a[s]||o.autoWidthCount++,a[s]=a[s]||{width:0,maxWidth:0};var l=t.barWidth;l&&!a[s].width&&(a[s].width=l,l=Math.min(o.remainedWidth,l),o.remainedWidth-=l);var u=t.barMaxWidth;u&&(a[s].maxWidth=u);var h=t.barMinWidth;h&&(a[s].minWidth=h);var c=t.barGap;null!=c&&(o.gap=c);var p=t.barCategoryGap;null!=p&&(o.categoryGap=p)}));var n={};return P(e,(function(t,e){n[e]={};var i=t.stacks,r=t.bandWidth,o=t.categoryGap;if(null==o){var a=z(i).length;o=Math.max(35-4*a,15)+"%"}var s=Zi(o,r),l=Zi(t.gap,1),u=t.remainedWidth,h=t.autoWidthCount,c=(u-s)/(h+(h-1)*l);c=Math.max(c,0),P(i,(function(t){var e=t.maxWidth,n=t.minWidth;if(t.width){i=t.width;e&&(i=Math.min(i,e)),n&&(i=Math.max(i,n)),t.width=i,u-=i+l*i,h--}else{var i=c;e&&e<i&&(i=Math.min(e,u)),n&&n>i&&(i=n),i!==c&&(t.width=i,u-=i+l*i,h--)}})),c=(u-s)/(h+(h-1)*l),c=Math.max(c,0);var p,d=0;P(i,(function(t,e){t.width||(t.width=c),p=t,d+=t.width*(1+l)})),p&&(d-=p.width*l);var f=-d/2;P(i,(function(t,i){n[e][i]=n[e][i]||{bandWidth:r,offset:f,width:t.width},f+=t.width*(1+l)}))})),n}function u_(t,e,n){if(t&&e){var i=t[o_(e)];return null!=i&&null!=n?i[r_(n)]:i}}function h_(t,e){var n=a_(t,e),i=s_(n),r={};P(n,(function(t){var e=t.getData(),n=t.coordinateSystem,o=n.getBaseAxis(),a=r_(t),s=i[o_(o)][a],l=s.offset,u=s.width,h=n.getOtherAxis(o),c=t.get("barMinHeight")||0;r[a]=r[a]||[],e.setLayout({bandWidth:s.bandWidth,offset:l,size:u});for(var p=e.mapDimension(h.dim),d=e.mapDimension(o.dim),f=Fm(e,p),g=h.isHorizontal(),y=f_(o,h),v=0,m=e.count();v<m;v++){var _=e.get(p,v),x=e.get(d,v),b=_>=0?"p":"n",w=y;f&&(r[a][x]||(r[a][x]={p:y,n:y}),w=r[a][x][b]);var S,M=void 0,I=void 0,T=void 0,C=void 0;if(g)M=w,I=(S=n.dataToPoint([_,x]))[1]+l,T=S[0]-y,C=u,Math.abs(T)<c&&(T=(T<0?-1:1)*c),isNaN(T)||f&&(r[a][x][b]+=T);else M=(S=n.dataToPoint([x,_]))[0]+l,I=w,T=u,C=S[1]-y,Math.abs(C)<c&&(C=(C<=0?-1:1)*c),isNaN(C)||f&&(r[a][x][b]+=C);e.setItemLayout(v,{x:M,y:I,width:T,height:C})}}))}var c_={seriesType:"bar",plan:df(),reset:function(t){if(p_(t)&&d_(t)){var e=t.getData(),n=t.coordinateSystem,i=n.master.getRect(),r=n.getBaseAxis(),o=n.getOtherAxis(r),a=e.mapDimension(o.dim),s=e.mapDimension(r.dim),l=o.isHorizontal(),u=l?0:1,h=u_(s_([t]),r,t).width;return h>.5||(h=.5),{progress:function(t,e){for(var c,p=t.count,d=new i_(2*p),f=new i_(2*p),g=new i_(p),y=[],v=[],m=0,_=0;null!=(c=t.next());)v[u]=e.get(a,c),v[1-u]=e.get(s,c),y=n.dataToPoint(v,null,y),f[m]=l?i.x+i.width:y[0],d[m++]=y[0],f[m]=l?y[1]:i.y+i.height,d[m++]=y[1],g[_++]=c;e.setLayout({largePoints:d,largeDataIndices:g,largeBackgroundPoints:f,barWidth:h,valueAxisStart:f_(r,o),backgroundStart:l?i.x:i.y,valueAxisHorizontal:l})}}}}};function p_(t){return t.coordinateSystem&&"cartesian2d"===t.coordinateSystem.type}function d_(t){return t.pipelineContext&&t.pipelineContext.large}function f_(t,e,n){return e.toGlobalCoord(e.dataToCoord("log"===e.type?1:0))}var g_=function(t){function e(e){var n=t.call(this,e)||this;return n.type="time",n}return n(e,t),e.prototype.getLabel=function(t){var e=this.getSetting("useUTC");return Zh(t.value,Gh[function(t){switch(t){case"year":case"month":return"day";case"millisecond":return"millisecond";default:return"second"}}(Xh(this._minLevelUnit))]||Gh.second,e,this.getSetting("locale"))},e.prototype.getFormattedLabel=function(t,e,n){var i=this.getSetting("useUTC");return function(t,e,n,i,r){var o=null;if("string"==typeof n)o=n;else if("function"==typeof n)o=n(t.value,e,{level:t.level});else{var a=I({},Vh);if(t.level>0)for(var s=0;s<Hh.length;++s)a[Hh[s]]="{primary|"+a[Hh[s]]+"}";var l=n?!1===n.inherit?n:T(n,a):a,u=jh(t.value,r);if(l[u])o=l[u];else if(l.inherit){for(s=Wh.indexOf(u)-1;s>=0;--s)if(l[u]){o=l[u];break}o=o||a.none}if(F(o)){var h=null==t.level?0:t.level>=0?t.level:o.length+t.level;o=o[h=Math.min(h,o.length-1)]}}return Zh(new Date(t.value),o,r,i)}(t,e,n,this.getSetting("locale"),i)},e.prototype.getTicks=function(t){var e=this._interval,n=this._extent,i=[];if(!e)return i;i.push({value:n[0],level:0});var r=this.getSetting("useUTC"),o=function(t,e,n,i){var r=1e4,o=Wh,a=0;function s(t,e,n,r,o,a,s){for(var l=new Date(e),u=e,h=l[r]();u<n&&u<=i[1];)s.push({value:u}),h+=t,l[o](h),u=l.getTime();s.push({value:u,notAdd:!0})}function l(t,r,o){var a=[],l=!r.length;if(!function(t,e,n,i){var r=rr(e),o=rr(n),a=function(t){return qh(r,t,i)===qh(o,t,i)},s=function(){return a("year")},l=function(){return s()&&a("month")},u=function(){return l()&&a("day")},h=function(){return u()&&a("hour")},c=function(){return h()&&a("minute")},p=function(){return c()&&a("second")},d=function(){return p()&&a("millisecond")};switch(t){case"year":return s();case"month":return l();case"day":return u();case"hour":return h();case"minute":return c();case"second":return p();case"millisecond":return d()}}(Xh(t),i[0],i[1],n)){l&&(r=[{value:w_(new Date(i[0]),t,n)},{value:i[1]}]);for(var u=0;u<r.length-1;u++){var h=r[u].value,c=r[u+1].value;if(h!==c){var p=void 0,d=void 0,f=void 0,g=!1;switch(t){case"year":p=Math.max(1,Math.round(e/zh/365)),d=Kh(n),f=ic(n);break;case"half-year":case"quarter":case"month":p=m_(e),d=$h(n),f=rc(n);break;case"week":case"half-week":case"day":p=v_(e),d=Jh(n),f=oc(n),g=!0;break;case"half-day":case"quarter-day":case"hour":p=__(e),d=Qh(n),f=ac(n);break;case"minute":p=x_(e,!0),d=tc(n),f=sc(n);break;case"second":p=x_(e,!1),d=ec(n),f=lc(n);break;case"millisecond":p=b_(e),d=nc(n),f=uc(n)}s(p,h,c,d,f,g,a),"year"===t&&o.length>1&&0===u&&o.unshift({value:o[0].value-p})}}for(u=0;u<a.length;u++)o.push(a[u]);return a}}for(var u=[],h=[],c=0,p=0,d=0;d<o.length&&a++<r;++d){var f=Xh(o[d]);if(Uh(o[d]))if(l(o[d],u[u.length-1]||[],h),f!==(o[d+1]?Xh(o[d+1]):null)){if(h.length){p=c,h.sort((function(t,e){return t.value-e.value}));for(var g=[],y=0;y<h.length;++y){var v=h[y].value;0!==y&&h[y-1].value===v||(g.push(h[y]),v>=i[0]&&v<=i[1]&&c++)}var m=(i[1]-i[0])/e;if(c>1.5*m&&p>m/1.5)break;if(u.push(g),c>m||t===o[d])break}h=[]}}0;var _=N(O(u,(function(t){return N(t,(function(t){return t.value>=i[0]&&t.value<=i[1]&&!t.notAdd}))})),(function(t){return t.length>0})),x=[],b=_.length-1;for(d=0;d<_.length;++d)for(var w=_[d],S=0;S<w.length;++S)x.push({value:w[S].value,level:b-d});x.sort((function(t,e){return t.value-e.value}));var M=[];for(d=0;d<x.length;++d)0!==d&&x[d].value===x[d-1].value||M.push(x[d]);return M}(this._minLevelUnit,this._approxInterval,r,n);return(i=i.concat(o)).push({value:n[1],level:0}),i},e.prototype.niceExtent=function(t){var e=this._extent;if(e[0]===e[1]&&(e[0]-=zh,e[1]+=zh),e[1]===-1/0&&e[0]===1/0){var n=new Date;e[1]=+new Date(n.getFullYear(),n.getMonth(),n.getDate()),e[0]=e[1]-zh}this.niceTicks(t.splitNumber,t.minInterval,t.maxInterval)},e.prototype.niceTicks=function(t,e,n){t=t||10;var i=this._extent,r=i[1]-i[0];this._approxInterval=r/t,null!=e&&this._approxInterval<e&&(this._approxInterval=e),null!=n&&this._approxInterval>n&&(this._approxInterval=n);var o=y_.length,a=Math.min(function(t,e,n,i){for(;n<i;){var r=n+i>>>1;t[r][1]<e?n=r+1:i=r}return n}(y_,this._approxInterval,0,o),o-1);this._interval=y_[a][1],this._minLevelUnit=y_[Math.max(a-1,0)][0]},e.prototype.parse=function(t){return"number"==typeof t?t:+rr(t)},e.prototype.contain=function(t){return Km(this.parse(t),this._extent)},e.prototype.normalize=function(t){return $m(this.parse(t),this._extent)},e.prototype.scale=function(t){return Jm(t,this._extent)},e.type="time",e}(e_),y_=[["second",Rh],["minute",Nh],["hour",Eh],["quarter-day",216e5],["half-day",432e5],["day",10368e4],["half-week",3024e5],["week",6048e5],["month",26784e5],["quarter",8208e6],["half-year",Bh/2],["year",Bh]];function v_(t,e){return(t/=zh)>16?16:t>7.5?7:t>3.5?4:t>1.5?2:1}function m_(t){return(t/=2592e6)>6?6:t>3?3:t>2?2:1}function __(t){return(t/=Eh)>12?12:t>6?6:t>3.5?4:t>2?2:1}function x_(t,e){return(t/=e?Nh:Rh)>30?30:t>20?20:t>15?15:t>10?10:t>5?5:t>2?2:1}function b_(t){return sr(t,!0)}function w_(t,e,n){var i=new Date(t);switch(Xh(e)){case"year":case"month":i[rc(n)](0);case"day":i[oc(n)](1);case"hour":i[ac(n)](0);case"minute":i[sc(n)](0);case"second":i[lc(n)](0),i[uc(n)](0)}return i.getTime()}Wm.registerClass(g_);var S_=Wm.prototype,M_=e_.prototype,I_=$i,T_=ji,C_=Math.floor,A_=Math.ceil,D_=Math.pow,L_=Math.log,k_=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="log",e.base=10,e._originalScale=new e_,e._interval=0,e}return n(e,t),e.prototype.getTicks=function(t){var e=this._originalScale,n=this._extent,i=e.getExtent();return O(M_.getTicks.call(this,t),(function(t){var e=t.value,r=ji(D_(this.base,e));return r=e===n[0]&&this._fixMin?O_(r,i[0]):r,{value:r=e===n[1]&&this._fixMax?O_(r,i[1]):r}}),this)},e.prototype.setExtent=function(t,e){var n=this.base;t=L_(t)/L_(n),e=L_(e)/L_(n),M_.setExtent.call(this,t,e)},e.prototype.getExtent=function(){var t=this.base,e=S_.getExtent.call(this);e[0]=D_(t,e[0]),e[1]=D_(t,e[1]);var n=this._originalScale.getExtent();return this._fixMin&&(e[0]=O_(e[0],n[0])),this._fixMax&&(e[1]=O_(e[1],n[1])),e},e.prototype.unionExtent=function(t){this._originalScale.unionExtent(t);var e=this.base;t[0]=L_(t[0])/L_(e),t[1]=L_(t[1])/L_(e),S_.unionExtent.call(this,t)},e.prototype.unionExtentFromData=function(t,e){this.unionExtent(t.getApproximateExtent(e))},e.prototype.niceTicks=function(t){t=t||10;var e=this._extent,n=e[1]-e[0];if(!(n===1/0||n<=0)){var i=or(n);for(t/n*i<=.5&&(i*=10);!isNaN(i)&&Math.abs(i)<1&&Math.abs(i)>0;)i*=10;var r=[ji(A_(e[0]/i)*i),ji(C_(e[1]/i)*i)];this._interval=i,this._niceExtent=r}},e.prototype.niceExtent=function(t){M_.niceExtent.call(this,t),this._fixMin=t.fixMin,this._fixMax=t.fixMax},e.prototype.parse=function(t){return t},e.prototype.contain=function(t){return Km(t=L_(t)/L_(this.base),this._extent)},e.prototype.normalize=function(t){return $m(t=L_(t)/L_(this.base),this._extent)},e.prototype.scale=function(t){return t=Jm(t,this._extent),D_(this.base,t)},e.type="log",e}(Wm),P_=k_.prototype;function O_(t,e){return T_(t,I_(e))}P_.getMinorTicks=M_.getMinorTicks,P_.getLabel=M_.getLabel,Wm.registerClass(k_);var R_=function(){function t(t,e,n){this._prepareParams(t,e,n)}return t.prototype._prepareParams=function(t,e,n){n[1]<n[0]&&(n=[NaN,NaN]),this._dataMin=n[0],this._dataMax=n[1];var i=this._isOrdinal="ordinal"===t.type;this._needCrossZero=e.getNeedCrossZero&&e.getNeedCrossZero();var r=this._modelMinRaw=e.get("min",!0);G(r)?this._modelMinNum=B_(t,r({min:n[0],max:n[1]})):"dataMin"!==r&&(this._modelMinNum=B_(t,r));var o=this._modelMaxRaw=e.get("max",!0);if(G(o)?this._modelMaxNum=B_(t,o({min:n[0],max:n[1]})):"dataMax"!==o&&(this._modelMaxNum=B_(t,o)),i)this._axisDataLen=e.getCategories().length;else{var a=e.get("boundaryGap"),s=F(a)?a:[a||0,a||0];"boolean"==typeof s[0]||"boolean"==typeof s[1]?this._boundaryGapInner=[0,0]:this._boundaryGapInner=[Yn(s[0],1),Yn(s[1],1)]}},t.prototype.calculate=function(){var t=this._isOrdinal,e=this._dataMin,n=this._dataMax,i=this._axisDataLen,r=this._boundaryGapInner,o=t?null:n-e||Math.abs(e),a="dataMin"===this._modelMinRaw?e:this._modelMinNum,s="dataMax"===this._modelMaxRaw?n:this._modelMaxNum,l=null!=a,u=null!=s;null==a&&(a=t?i?0:NaN:e-r[0]*o),null==s&&(s=t?i?i-1:NaN:n+r[1]*o),(null==a||!isFinite(a))&&(a=NaN),(null==s||!isFinite(s))&&(s=NaN),a>s&&(a=NaN,s=NaN);var h=J(a)||J(s)||t&&!i;this._needCrossZero&&(a>0&&s>0&&!l&&(a=0),a<0&&s<0&&!u&&(s=0));var c=this._determinedMin,p=this._determinedMax;return null!=c&&(a=c,l=!0),null!=p&&(s=p,u=!0),{min:a,max:s,minFixed:l,maxFixed:u,isBlank:h}},t.prototype.modifyDataMinMax=function(t,e){this[E_[t]]=e},t.prototype.setDeterminedMinMax=function(t,e){var n=N_[t];this[n]=e},t.prototype.freeze=function(){this.frozen=!0},t}(),N_={min:"_determinedMin",max:"_determinedMax"},E_={min:"_dataMin",max:"_dataMax"};function z_(t,e,n){var i=t.rawExtentInfo;return i||(i=new R_(t,e,n),t.rawExtentInfo=i,i)}function B_(t,e){return null==e?null:J(e)?NaN:t.parse(e)}function V_(t,e){var n=t.type,i=z_(t,e,t.getExtent()).calculate();t.setBlank(i.isBlank);var r=i.min,o=i.max,a=e.ecModel;if(a&&"time"===n){var s=a_("bar",a),l=!1;if(P(s,(function(t){l=l||t.getBaseAxis()===e.axis})),l){var u=s_(s),h=function(t,e,n,i){var r=n.axis.getExtent(),o=r[1]-r[0],a=u_(i,n.axis);if(void 0===a)return{min:t,max:e};var s=1/0;P(a,(function(t){s=Math.min(t.offset,s)}));var l=-1/0;P(a,(function(t){l=Math.max(t.offset+t.width,l)})),s=Math.abs(s),l=Math.abs(l);var u=s+l,h=e-t,c=h/(1-(s+l)/o)-h;return{min:t-=c*(s/u),max:e+=c*(l/u)}}(r,o,e,u);r=h.min,o=h.max}}return{extent:[r,o],fixMin:i.minFixed,fixMax:i.maxFixed}}function F_(t,e){var n=V_(t,e),i=n.extent,r=e.get("splitNumber");t instanceof k_&&(t.base=e.get("logBase"));var o=t.type;t.setExtent(i[0],i[1]),t.niceExtent({splitNumber:r,fixMin:n.fixMin,fixMax:n.fixMax,minInterval:"interval"===o||"time"===o?e.get("minInterval"):null,maxInterval:"interval"===o||"time"===o?e.get("maxInterval"):null});var a=e.get("interval");null!=a&&t.setInterval&&t.setInterval(a)}function G_(t,e){if(e=e||t.get("type"))switch(e){case"category":return new Qm({ordinalMeta:t.getOrdinalMeta?t.getOrdinalMeta():t.getCategories(),extent:[1/0,-1/0]});case"time":return new g_({locale:t.ecModel.getLocaleModel(),useUTC:t.ecModel.get("useUTC")});default:return new(Wm.getClass(e)||e_)}}function H_(t){var e,n,i=t.getLabelModel().get("formatter"),r="category"===t.type?t.scale.getExtent()[0]:null;return"time"===t.scale.type?(n=i,function(e,i){return t.scale.getFormattedLabel(e,i,n)}):"string"==typeof i?function(e){return function(n){var i=t.scale.getLabel(n);return e.replace("{value}",null!=i?i:"")}}(i):"function"==typeof i?(e=i,function(n,i){return null!=r&&(i=n.value-r),e(W_(t,n),i,null!=n.level?{level:n.level}:null)}):function(e){return t.scale.getLabel(e)}}function W_(t,e){return"category"===t.type?t.scale.getLabel(e):e.value}function Y_(t,e){var n=e*Math.PI/180,i=t.width,r=t.height,o=i*Math.abs(Math.cos(n))+Math.abs(r*Math.sin(n)),a=i*Math.abs(Math.sin(n))+Math.abs(r*Math.cos(n));return new Rn(t.x,t.y,o,a)}function X_(t){var e=t.get("interval");return null==e?"auto":e}function U_(t){return"category"===t.type&&0===X_(t.getLabelModel())}function Z_(t,e){var n={};return P(t.mapDimensionsAll(e),(function(e){n[Gm(t,e)]=!0})),z(n)}var j_=function(){function t(){}return t.prototype.getNeedCrossZero=function(){return!this.option.scale},t.prototype.getCoordSysModel=function(){},t}();var q_={isDimensionStacked:Fm,enableDataStack:Vm,getStackedDimension:Gm};var K_=Object.freeze({__proto__:null,createList:function(t){return Hm(t.getSource(),t)},getLayoutRect:Ac,dataStack:q_,createScale:function(t,e){var n=e;e instanceof Sh||(n=new Sh(e));var i=G_(n);return i.setExtent(t[0],t[1]),F_(i,n),i},mixinAxisModelCommonMethods:function(t){L(t,j_)},getECData:ys,createTextStyle:function(t,e){return nh(t,null,null,"normal"!==(e=e||{}).state)},createDimensions:Nm,createSymbol:uy,enableHoverEmphasis:Js});function $_(t,e){return Math.abs(t-e)<1e-8}function J_(t,e,n){var i=0,r=t[0];if(!r)return!1;for(var o=1;o<t.length;o++){var a=t[o];i+=Na(r[0],r[1],a[0],a[1],e,n),r=a}var s=t[0];return $_(r[0],s[0])&&$_(r[1],s[1])||(i+=Na(r[0],r[1],s[0],s[1],e,n)),0!==i}var Q_=function(){function t(t,e,n){if(this.name=t,this.geometries=e,n)n=[n[0],n[1]];else{var i=this.getBoundingRect();n=[i.x+i.width/2,i.y+i.height/2]}this.center=n}return t.prototype.getBoundingRect=function(){var t=this._rect;if(t)return t;for(var e=Number.MAX_VALUE,n=[e,e],i=[-e,-e],r=[],o=[],a=this.geometries,s=0;s<a.length;s++){if("polygon"===a[s].type)ea(a[s].exterior,r,o),Nt(n,n,r),Et(i,i,o)}return 0===s&&(n[0]=n[1]=i[0]=i[1]=0),this._rect=new Rn(n[0],n[1],i[0]-n[0],i[1]-n[1])},t.prototype.contain=function(t){var e=this.getBoundingRect(),n=this.geometries;if(!e.contain(t[0],t[1]))return!1;t:for(var i=0,r=n.length;i<r;i++)if("polygon"===n[i].type){var o=n[i].exterior,a=n[i].interiors;if(J_(o,t[0],t[1])){for(var s=0;s<(a?a.length:0);s++)if(J_(a[s],t[0],t[1]))continue t;return!0}}return!1},t.prototype.transformTo=function(t,e,n,i){var r=this.getBoundingRect(),o=r.width/r.height;n?i||(i=n/o):n=o*i;for(var a=new Rn(t,e,n,i),s=r.calculateTransform(a),l=this.geometries,u=0;u<l.length;u++)if("polygon"===l[u].type){for(var h=l[u].exterior,c=l[u].interiors,p=0;p<h.length;p++)Rt(h[p],h[p],s);for(var d=0;d<(c?c.length:0);d++)for(p=0;p<c[d].length;p++)Rt(c[d][p],c[d][p],s)}(r=this._rect).copy(a),this.center=[r.x+r.width/2,r.y+r.height/2]},t.prototype.cloneShallow=function(e){null==e&&(e=this.name);var n=new t(e,this.geometries,this.center);return n._rect=this._rect,n.transformTo=null,n},t}();function tx(t,e,n){for(var i=[],r=e[0],o=e[1],a=0;a<t.length;a+=2){var s=t.charCodeAt(a)-64,l=t.charCodeAt(a+1)-64;s=s>>1^-(1&s),l=l>>1^-(1&l),r=s+=r,o=l+=o,i.push([s/n,l/n])}return i}function ex(t,e){return O(N((t=function(t){if(!t.UTF8Encoding)return t;var e=t,n=e.UTF8Scale;null==n&&(n=1024);for(var i=e.features,r=0;r<i.length;r++){var o=i[r].geometry;if("Polygon"===o.type)for(var a=o.coordinates,s=0;s<a.length;s++)a[s]=tx(a[s],o.encodeOffsets[s],n);else if("MultiPolygon"===o.type)for(a=o.coordinates,s=0;s<a.length;s++)for(var l=a[s],u=0;u<l.length;u++)l[u]=tx(l[u],o.encodeOffsets[s][u],n)}return e.UTF8Encoding=!1,e}(t)).features,(function(t){return t.geometry&&t.properties&&t.geometry.coordinates.length>0})),(function(t){var n=t.properties,i=t.geometry,r=[];if("Polygon"===i.type){var o=i.coordinates;r.push({type:"polygon",exterior:o[0],interiors:o.slice(1)})}"MultiPolygon"===i.type&&P(o=i.coordinates,(function(t){t[0]&&r.push({type:"polygon",exterior:t[0],interiors:t.slice(1)})}));var a=new Q_(n[e||"name"],r,n.cp);return a.properties=n,a}))}var nx=Object.freeze({__proto__:null,linearMap:Ui,round:ji,asc:qi,getPrecision:Ki,getPrecisionSafe:$i,getPixelPrecision:Ji,getPercentWithPrecision:Qi,MAX_SAFE_INTEGER:tr,remRadian:er,isRadianAroundZero:nr,parseDate:rr,quantity:or,quantityExponent:ar,nice:sr,quantile:lr,reformIntervals:ur,isNumeric:cr,numericToNumber:hr}),ix=Object.freeze({__proto__:null,parse:rr,format:Zh}),rx=Object.freeze({__proto__:null,extendShape:bu,extendPath:Su,makePath:Tu,makeImage:Cu,mergePath:Du,resizePath:Lu,createIcon:Uu,updateProps:Ou,initProps:Ru,getTransform:Vu,clipPointsByRect:Yu,clipRectByRect:Xu,registerShape:Mu,getShapeClass:Iu,Group:zi,Image:Ja,Text:ls,Circle:Tl,Ellipse:Al,Sector:Wl,Ring:Xl,Polygon:ql,Polyline:$l,Rect:os,Line:tu,BezierCurve:ru,Arc:au,IncrementalDisplayable:vu,CompoundPath:su,LinearGradient:uu,RadialGradient:hu,BoundingRect:Rn}),ox=Object.freeze({__proto__:null,addCommas:hc,toCamelCase:cc,normalizeCssArray:pc,encodeHTML:gc,formatTpl:_c,getTooltipMarker:xc,formatTime:function(t,e,n){"week"!==t&&"month"!==t&&"quarter"!==t&&"half-year"!==t&&"year"!==t||(t="MM-dd\nyyyy");var i=rr(e),r=n?"UTC":"",o=i["get"+r+"FullYear"](),a=i["get"+r+"Month"]()+1,s=i["get"+r+"Date"](),l=i["get"+r+"Hours"](),u=i["get"+r+"Minutes"](),h=i["get"+r+"Seconds"](),c=i["get"+r+"Milliseconds"]();return t=t.replace("MM",Yh(a,2)).replace("M",a).replace("yyyy",o).replace("yy",o%100+"").replace("dd",Yh(s,2)).replace("d",s).replace("hh",Yh(l,2)).replace("h",l).replace("mm",Yh(u,2)).replace("m",u).replace("ss",Yh(h,2)).replace("s",h).replace("SSS",Yh(c,3))},capitalFirst:function(t){return t?t.charAt(0).toUpperCase()+t.substr(1):t},truncateText:ro,getTextRect:function(t,e,n,i,r,o,a,s){return gr(),new ls({style:{text:t,font:e,align:n,verticalAlign:i,padding:r,rich:o,overflow:a?"truncate":null,lineHeight:s}}).getBoundingRect()}}),ax=Object.freeze({__proto__:null,map:O,each:P,indexOf:A,inherits:D,reduce:R,filter:N,bind:B,curry:V,isArray:F,isString:H,isObject:X,isFunction:G,extend:I,defaults:T,clone:w,merge:S}),sx=Lr();function lx(t){return"category"===t.type?function(t){var e=t.getLabelModel(),n=hx(t,e);return!e.get("show")||t.scale.isBlank()?{labels:[],labelCategoryInterval:n.labelCategoryInterval}:n}(t):function(t){var e=t.scale.getTicks(),n=H_(t);return{labels:O(e,(function(e,i){return{formattedLabel:n(e,i),rawLabel:t.scale.getLabel(e),tickValue:e.value}}))}}(t)}function ux(t,e){return"category"===t.type?function(t,e){var n,i,r=cx(t,"ticks"),o=X_(e),a=px(r,o);if(a)return a;e.get("show")&&!t.scale.isBlank()||(n=[]);if(G(o))n=gx(t,o,!0);else if("auto"===o){var s=hx(t,t.getLabelModel());i=s.labelCategoryInterval,n=O(s.labels,(function(t){return t.tickValue}))}else n=fx(t,i=o,!0);return dx(r,o,{ticks:n,tickCategoryInterval:i})}(t,e):{ticks:O(t.scale.getTicks(),(function(t){return t.value}))}}function hx(t,e){var n,i,r=cx(t,"labels"),o=X_(e),a=px(r,o);return a||(G(o)?n=gx(t,o):(i="auto"===o?function(t){var e=sx(t).autoInterval;return null!=e?e:sx(t).autoInterval=t.calculateCategoryInterval()}(t):o,n=fx(t,i)),dx(r,o,{labels:n,labelCategoryInterval:i}))}function cx(t,e){return sx(t)[e]||(sx(t)[e]=[])}function px(t,e){for(var n=0;n<t.length;n++)if(t[n].key===e)return t[n].value}function dx(t,e,n){return t.push({key:e,value:n}),n}function fx(t,e,n){var i=H_(t),r=t.scale,o=r.getExtent(),a=t.getLabelModel(),s=[],l=Math.max((e||0)+1,1),u=o[0],h=r.count();0!==u&&l>1&&h/l>2&&(u=Math.round(Math.ceil(u/l)*l));var c=U_(t),p=a.get("showMinLabel")||c,d=a.get("showMaxLabel")||c;p&&u!==o[0]&&g(o[0]);for(var f=u;f<=o[1];f+=l)g(f);function g(t){var e={value:t};s.push(n?t:{formattedLabel:i(e),rawLabel:r.getLabel(e),tickValue:t})}return d&&f-l!==o[1]&&g(o[1]),s}function gx(t,e,n){var i=t.scale,r=H_(t),o=[];return P(i.getTicks(),(function(t){var a=i.getLabel(t),s=t.value;e(t.value,a)&&o.push(n?s:{formattedLabel:r(t),rawLabel:a,tickValue:s})})),o}var yx=[0,1],vx=function(){function t(t,e,n){this.onBand=!1,this.inverse=!1,this.dim=t,this.scale=e,this._extent=n||[0,0]}return t.prototype.contain=function(t){var e=this._extent,n=Math.min(e[0],e[1]),i=Math.max(e[0],e[1]);return t>=n&&t<=i},t.prototype.containData=function(t){return this.scale.contain(t)},t.prototype.getExtent=function(){return this._extent.slice()},t.prototype.getPixelPrecision=function(t){return Ji(t||this.scale.getExtent(),this._extent)},t.prototype.setExtent=function(t,e){var n=this._extent;n[0]=t,n[1]=e},t.prototype.dataToCoord=function(t,e){var n=this._extent,i=this.scale;return t=i.normalize(t),this.onBand&&"ordinal"===i.type&&mx(n=n.slice(),i.count()),Ui(t,yx,n,e)},t.prototype.coordToData=function(t,e){var n=this._extent,i=this.scale;this.onBand&&"ordinal"===i.type&&mx(n=n.slice(),i.count());var r=Ui(t,n,yx,e);return this.scale.scale(r)},t.prototype.pointToData=function(t,e){},t.prototype.getTicksCoords=function(t){var e=(t=t||{}).tickModel||this.getTickModel(),n=O(ux(this,e).ticks,(function(t){return{coord:this.dataToCoord("ordinal"===this.scale.type?this.scale.getRawOrdinalNumber(t):t),tickValue:t}}),this);return function(t,e,n,i){var r=e.length;if(!t.onBand||n||!r)return;var o,a,s=t.getExtent();if(1===r)e[0].coord=s[0],o=e[1]={coord:s[0]};else{var l=e[r-1].tickValue-e[0].tickValue,u=(e[r-1].coord-e[0].coord)/l;P(e,(function(t){t.coord-=u/2})),a=1+t.scale.getExtent()[1]-e[r-1].tickValue,o={coord:e[r-1].coord+u*a},e.push(o)}var h=s[0]>s[1];c(e[0].coord,s[0])&&(i?e[0].coord=s[0]:e.shift());i&&c(s[0],e[0].coord)&&e.unshift({coord:s[0]});c(s[1],o.coord)&&(i?o.coord=s[1]:e.pop());i&&c(o.coord,s[1])&&e.push({coord:s[1]});function c(t,e){return t=ji(t),e=ji(e),h?t>e:t<e}}(this,n,e.get("alignWithLabel"),t.clamp),n},t.prototype.getMinorTicksCoords=function(){if("ordinal"===this.scale.type)return[];var t=this.model.getModel("minorTick").get("splitNumber");return t>0&&t<100||(t=5),O(this.scale.getMinorTicks(t),(function(t){return O(t,(function(t){return{coord:this.dataToCoord(t),tickValue:t}}),this)}),this)},t.prototype.getViewLabels=function(){return lx(this).labels},t.prototype.getLabelModel=function(){return this.model.getModel("axisLabel")},t.prototype.getTickModel=function(){return this.model.getModel("axisTick")},t.prototype.getBandWidth=function(){var t=this._extent,e=this.scale.getExtent(),n=e[1]-e[0]+(this.onBand?1:0);0===n&&(n=1);var i=Math.abs(t[1]-t[0]);return Math.abs(i)/n},t.prototype.calculateCategoryInterval=function(){return function(t){var e=function(t){var e=t.getLabelModel();return{axisRotate:t.getRotate?t.getRotate():t.isHorizontal&&!t.isHorizontal()?90:0,labelRotate:e.get("rotate")||0,font:e.getFont()}}(t),n=H_(t),i=(e.axisRotate-e.labelRotate)/180*Math.PI,r=t.scale,o=r.getExtent(),a=r.count();if(o[1]-o[0]<1)return 0;var s=1;a>40&&(s=Math.max(1,Math.floor(a/40)));for(var l=o[0],u=t.dataToCoord(l+1)-t.dataToCoord(l),h=Math.abs(u*Math.cos(i)),c=Math.abs(u*Math.sin(i)),p=0,d=0;l<=o[1];l+=s){var f,g,y=Fn(n({value:l}),e.font,"center","top");f=1.3*y.width,g=1.3*y.height,p=Math.max(p,f,7),d=Math.max(d,g,7)}var v=p/h,m=d/c;isNaN(v)&&(v=1/0),isNaN(m)&&(m=1/0);var _=Math.max(0,Math.floor(Math.min(v,m))),x=sx(t.model),b=t.getExtent(),w=x.lastAutoInterval,S=x.lastTickCount;return null!=w&&null!=S&&Math.abs(w-_)<=1&&Math.abs(S-a)<=1&&w>_&&x.axisExtent0===b[0]&&x.axisExtent1===b[1]?_=w:(x.lastTickCount=a,x.lastAutoInterval=_,x.axisExtent0=b[0],x.axisExtent1=b[1]),_}(this)},t}();function mx(t,e){var n=(t[1]-t[0])/e/2;t[0]+=n,t[1]-=n}function _x(t){return document.createElementNS("http://www.w3.org/2000/svg",t)}function xx(t,e,n,i,r){for(var o=e.length,a=n.length,s=t.newPos,l=s-i,u=0;s+1<o&&l+1<a&&r(e[s+1],n[l+1]);)s++,l++,u++;return u&&t.components.push({count:u,added:!1,removed:!1,indices:[]}),t.newPos=s,l}function bx(t,e,n){var i=t[t.length-1];i&&i.added===e&&i.removed===n?t[t.length-1]={count:i.count+1,added:e,removed:n,indices:[]}:t.push({count:1,added:e,removed:n,indices:[]})}function Sx(t){for(var e=0,n=t.length,i=0,r=0;e<n;e++){var o=t[e];if(o.removed){for(s=r;s<r+o.count;s++)o.indices.push(s);r+=o.count}else{for(var a=[],s=i;s<i+o.count;s++)a.push(s);o.indices=a,i+=o.count,o.added||(r+=o.count)}}return t}function Mx(t,e,n){return function(t,e,n){n||(n=function(t,e){return t===e}),t=t.slice();var i=(e=e.slice()).length,r=t.length,o=1,a=i+r,s=[{newPos:-1,components:[]}],l=xx(s[0],e,t,0,n);if(s[0].newPos+1>=i&&l+1>=r){for(var u=[],h=0;h<e.length;h++)u.push(h);return[{indices:u,count:e.length,added:!1,removed:!1}]}function c(){for(var a=-1*o;a<=o;a+=2){var l,u=s[a-1],h=s[a+1],c=(h?h.newPos:0)-a;u&&(s[a-1]=void 0);var p=u&&u.newPos+1<i,d=h&&0<=c&&c<r;if(p||d){if(!p||d&&u.newPos<h.newPos?bx((l={newPos:(f=h).newPos,components:f.components.slice(0)}).components,!1,!0):((l=u).newPos++,bx(l.components,!0,!1)),c=xx(l,e,t,a,n),l.newPos+1>=i&&c+1>=r)return Sx(l.components);s[a]=l}else s[a]=void 0}var f;o++}for(;o<=a;){var p=c();if(p)return p}}(t,e,n)}var Ix="none",Tx=Math.round,Cx=Math.sin,Ax=Math.cos,Dx=Math.PI,Lx=2*Math.PI,kx=180/Dx,Px=1e-4;function Ox(t){return Tx(1e3*t)/1e3}function Rx(t){return Tx(1e4*t)/1e4}function Nx(t){return t<Px&&t>-1e-4}function Ex(t,e){e&&zx(t,"transform","matrix("+Ox(e[0])+","+Ox(e[1])+","+Ox(e[2])+","+Ox(e[3])+","+Rx(e[4])+","+Rx(e[5])+")")}function zx(t,e,n){(!n||"linear"!==n.type&&"radial"!==n.type)&&t.setAttribute(e,n)}function Bx(t,e,n){var i=null==e.opacity?1:e.opacity;if(n instanceof Ja)t.style.opacity=i+"";else{if(function(t){var e=t.fill;return null!=e&&e!==Ix}(e)){var r=e.fill;zx(t,"fill",r="transparent"===r?Ix:r),zx(t,"fill-opacity",(null!=e.fillOpacity?e.fillOpacity*i:i)+"")}else zx(t,"fill",Ix);if(function(t){var e=t.stroke;return null!=e&&e!==Ix}(e)){var o=e.stroke;zx(t,"stroke",o="transparent"===o?Ix:o);var a=e.lineWidth,s=e.strokeNoScale?n.getLineScale():1;zx(t,"stroke-width",(s?a/s:0)+""),zx(t,"paint-order",e.strokeFirst?"stroke":"fill"),zx(t,"stroke-opacity",(null!=e.strokeOpacity?e.strokeOpacity*i:i)+"");var l=e.lineDash&&a>0&&py(e.lineDash,a);if(l){var u=e.lineDashOffset;s&&1!==s&&(l=O(l,(function(t){return t/s})),u&&(u=Tx(u/=s))),zx(t,"stroke-dasharray",l.join(",")),zx(t,"stroke-dashoffset",(u||0)+"")}else zx(t,"stroke-dasharray","");e.lineCap&&zx(t,"stroke-linecap",e.lineCap),e.lineJoin&&zx(t,"stroke-linejoin",e.lineJoin),e.miterLimit&&zx(t,"stroke-miterlimit",e.miterLimit+"")}else zx(t,"stroke",Ix)}}var Vx=function(){function t(){}return t.prototype.reset=function(){this._d=[],this._str=""},t.prototype.moveTo=function(t,e){this._add("M",t,e)},t.prototype.lineTo=function(t,e){this._add("L",t,e)},t.prototype.bezierCurveTo=function(t,e,n,i,r,o){this._add("C",t,e,n,i,r,o)},t.prototype.quadraticCurveTo=function(t,e,n,i){this._add("Q",t,e,n,i)},t.prototype.arc=function(t,e,n,i,r,o){this.ellipse(t,e,n,n,0,i,r,o)},t.prototype.ellipse=function(t,e,n,i,r,o,a,s){var l=0===this._d.length,u=a-o,h=!s,c=Math.abs(u),p=Nx(c-Lx)||(h?u>=Lx:-u>=Lx),d=u>0?u%Lx:u%Lx+Lx,f=!1;f=!!p||!Nx(c)&&d>=Dx==!!h;var g=Rx(t+n*Ax(o)),y=Rx(e+i*Cx(o));p&&(u=h?Lx-1e-4:1e-4-Lx,f=!0,l&&this._d.push("M",g,y));var v=Rx(t+n*Ax(o+u)),m=Rx(e+i*Cx(o+u));if(isNaN(g)||isNaN(y)||isNaN(n)||isNaN(i)||isNaN(r)||isNaN(kx)||isNaN(v)||isNaN(m))return"";this._d.push("A",Rx(n),Rx(i),Tx(r*kx),+f,+h,v,m)},t.prototype.rect=function(t,e,n,i){this._add("M",t,e),this._add("L",t+n,e),this._add("L",t+n,e+i),this._add("L",t,e+i),this._add("L",t,e)},t.prototype.closePath=function(){this._d.length>0&&this._add("Z")},t.prototype._add=function(t,e,n,i,r,o,a,s,l){this._d.push(t);for(var u=1;u<arguments.length;u++){var h=arguments[u];if(isNaN(h))return void(this._invalid=!0);this._d.push(Rx(h))}},t.prototype.generateStr=function(){this._str=this._invalid?"":this._d.join(" "),this._d=[]},t.prototype.getStr=function(){return this._str},t}(),Fx={brush:function(t){var e=t.style,n=t.__svgEl;n||(n=_x("path"),t.__svgEl=n),t.path||t.createPathProxy();var i=t.path;t.shapeChanged()&&(i.beginPath(),t.buildPath(i,t.shape),t.pathUpdated());var r=i.getVersion(),o=t,a=o.__svgPathBuilder;(o.__svgPathVersion!==r||!a||t.style.strokePercent<1)&&(a||(a=o.__svgPathBuilder=new Vx),a.reset(),i.rebuildPath(a,t.style.strokePercent),a.generateStr(),o.__svgPathVersion=r),zx(n,"d",a.getStr()),Bx(n,e,t),Ex(n,t.transform)}},Gx={brush:function(t){var e=t.style,n=e.image;if(n instanceof HTMLImageElement?n=n.src:n instanceof HTMLCanvasElement&&(n=n.toDataURL()),n){var i=e.x||0,r=e.y||0,o=e.width,a=e.height,s=t.__svgEl;s||(s=_x("image"),t.__svgEl=s),n!==t.__imageSrc&&(!function(t,e,n){t.setAttributeNS("http://www.w3.org/1999/xlink",e,n)}(s,"href",n),t.__imageSrc=n),zx(s,"width",o+""),zx(s,"height",a+""),zx(s,"x",i+""),zx(s,"y",r+""),Bx(s,e,t),Ex(s,t.transform)}}},Hx={left:"start",right:"end",center:"middle",middle:"middle"};var Wx={brush:function(t){var e=t.style,n=e.text;if(null!=n&&(n+=""),n&&!isNaN(e.x)&&!isNaN(e.y)){var i=t.__svgEl;i||(function(t,e,n){t.setAttributeNS("http://www.w3.org/XML/1998/namespace",e,n)}(i=_x("text"),"xml:space","preserve"),t.__svgEl=i);var r=e.font||En;i.style.font=r,i.textContent=n,Bx(i,e,t),Ex(i,t.transform);var o=e.x||0,a=function(t,e,n){return"top"===n?t+=e/2:"bottom"===n&&(t-=e/2),t}(e.y||0,Wn(r),e.textBaseline),s=Hx[e.textAlign]||e.textAlign;zx(i,"dominant-baseline","central"),zx(i,"text-anchor",s),zx(i,"x",o+""),zx(i,"y",a+"")}}},Yx=function(){function t(t,e,n,i,r){this.nextId=0,this._domName="_dom",this.createElement=_x,this._zrId=t,this._svgRoot=e,this._tagNames="string"==typeof n?[n]:n,this._markLabel=i,r&&(this._domName=r)}return t.prototype.getDefs=function(t){var e=this._svgRoot,n=this._svgRoot.getElementsByTagName("defs");if(0===n.length){if(t){var i=e.insertBefore(this.createElement("defs"),e.firstChild);return i.contains||(i.contains=function(t){var e=i.children;if(!e)return!1;for(var n=e.length-1;n>=0;--n)if(e[n]===t)return!0;return!1}),i}return null}return n[0]},t.prototype.doUpdate=function(t,e){if(t){var n=this.getDefs(!1);if(t[this._domName]&&n.contains(t[this._domName]))"function"==typeof e&&e(t);else{var i=this.add(t);i&&(t[this._domName]=i)}}},t.prototype.add=function(t){return null},t.prototype.addDom=function(t){var e=this.getDefs(!0);t.parentNode!==e&&e.appendChild(t)},t.prototype.removeDom=function(t){var e=this.getDefs(!1);e&&t[this._domName]&&(e.removeChild(t[this._domName]),t[this._domName]=null)},t.prototype.getDoms=function(){var t=this.getDefs(!1);if(!t)return[];var e=[];return P(this._tagNames,(function(n){for(var i=t.getElementsByTagName(n),r=0;r<i.length;r++)e.push(i[r])})),e},t.prototype.markAllUnused=function(){var t=this.getDoms(),e=this;P(t,(function(t){t[e._markLabel]="0"}))},t.prototype.markDomUsed=function(t){t&&(t[this._markLabel]="1")},t.prototype.markDomUnused=function(t){t&&(t[this._markLabel]="0")},t.prototype.isDomUnused=function(t){return t&&"1"!==t[this._markLabel]},t.prototype.removeUnused=function(){var t=this,e=this.getDefs(!1);e&&P(this.getDoms(),(function(n){t.isDomUnused(n)&&e.removeChild(n)}))},t.prototype.getSvgProxy=function(t){return t instanceof Za?Fx:t instanceof Ja?Gx:t instanceof qa?Wx:Fx},t.prototype.getSvgElement=function(t){return t.__svgEl},t}();function Xx(t){return"linear"===t.type}function Ux(t){return"radial"===t.type}function Zx(t){return t&&("linear"===t.type||"radial"===t.type)}var jx=function(t){function e(e,n){return t.call(this,e,n,["linearGradient","radialGradient"],"__gradient_in_use__")||this}return n(e,t),e.prototype.addWithoutUpdate=function(t,e){if(e&&e.style){var n=this;P(["fill","stroke"],(function(i){var r=e.style[i];if(Zx(r)){var o=r,a=n.getDefs(!0),s=void 0;o.__dom?(s=o.__dom,a.contains(o.__dom)||n.addDom(s)):s=n.add(o),n.markUsed(e);var l=s.getAttribute("id");t.setAttribute(i,"url(#"+l+")")}}))}},e.prototype.add=function(t){var e;if(Xx(t))e=this.createElement("linearGradient");else{if(!Ux(t))return b("Illegal gradient type."),null;e=this.createElement("radialGradient")}return t.id=t.id||this.nextId++,e.setAttribute("id","zr"+this._zrId+"-gradient-"+t.id),this.updateDom(t,e),this.addDom(e),e},e.prototype.update=function(t){if(Zx(t)){var e=this;this.doUpdate(t,(function(){var n=t.__dom;if(n){var i=n.tagName,r=t.type;"linear"===r&&"linearGradient"===i||"radial"===r&&"radialGradient"===i?e.updateDom(t,t.__dom):(e.removeDom(t),e.add(t))}}))}},e.prototype.updateDom=function(t,e){if(Xx(t))e.setAttribute("x1",t.x+""),e.setAttribute("y1",t.y+""),e.setAttribute("x2",t.x2+""),e.setAttribute("y2",t.y2+"");else{if(!Ux(t))return void b("Illegal gradient type.");e.setAttribute("cx",t.x+""),e.setAttribute("cy",t.y+""),e.setAttribute("r",t.r+"")}t.global?e.setAttribute("gradientUnits","userSpaceOnUse"):e.setAttribute("gradientUnits","objectBoundingBox"),e.innerHTML="";for(var n=t.colorStops,i=0,r=n.length;i<r;++i){var o=this.createElement("stop");o.setAttribute("offset",100*n[i].offset+"%");var a=n[i].color;if(a.indexOf("rgba")>-1){var s=qe(a)[3],l=Je(a);o.setAttribute("stop-color","#"+l),o.setAttribute("stop-opacity",s+"")}else o.setAttribute("stop-color",n[i].color);e.appendChild(o)}t.__dom=e},e.prototype.markUsed=function(e){if(e.style){var n=e.style.fill;n&&n.__dom&&t.prototype.markDomUsed.call(this,n.__dom),(n=e.style.stroke)&&n.__dom&&t.prototype.markDomUsed.call(this,n.__dom)}},e}(Yx);function qx(t){return t&&(!!t.image||!!t.svgElement)}var Kx=new ty,$x=function(t){function e(e,n){return t.call(this,e,n,["pattern"],"__pattern_in_use__")||this}return n(e,t),e.prototype.addWithoutUpdate=function(t,e){if(e&&e.style){var n=this;P(["fill","stroke"],(function(i){var r=e.style[i];if(qx(r)){var o=n.getDefs(!0),a=Kx.get(r);a?o.contains(a)||n.addDom(a):a=n.add(r),n.markUsed(e);var s=a.getAttribute("id");t.setAttribute(i,"url(#"+s+")")}}))}},e.prototype.add=function(t){if(qx(t)){var e=this.createElement("pattern");return t.id=null==t.id?this.nextId++:t.id,e.setAttribute("id","zr"+this._zrId+"-pattern-"+t.id),e.setAttribute("x","0"),e.setAttribute("y","0"),e.setAttribute("patternUnits","userSpaceOnUse"),this.updateDom(t,e),this.addDom(e),e}},e.prototype.update=function(t){if(qx(t)){var e=this;this.doUpdate(t,(function(){var n=Kx.get(t);e.updateDom(t,n)}))}},e.prototype.updateDom=function(t,e){var n=t.svgElement;if(n instanceof SVGElement)n.parentNode!==e&&(e.innerHTML="",e.appendChild(n),e.setAttribute("width",t.svgWidth+""),e.setAttribute("height",t.svgHeight+""));else{var i=void 0,r=e.getElementsByTagName("image");if(r.length){if(!t.image)return void e.removeChild(r[0]);i=r[0]}else t.image&&(i=this.createElement("image"));if(i){var o=void 0;if("string"==typeof t.image?o=t.image:t.image instanceof HTMLImageElement?o=t.image.src:t.image instanceof HTMLCanvasElement&&(o=t.image.toDataURL()),o){i.setAttribute("href",o),i.setAttribute("x","0"),i.setAttribute("y","0");var a=to(o,i,{dirty:function(){}},(function(t){e.setAttribute("width",t.width+""),e.setAttribute("height",t.height+"")}));a&&a.width&&a.height&&(e.setAttribute("width",a.width+""),e.setAttribute("height",a.height+"")),e.appendChild(i)}}}var s="translate("+(t.x||0)+", "+(t.y||0)+") rotate("+(t.rotation||0)/Math.PI*180+") scale("+(t.scaleX||1)+", "+(t.scaleY||1)+")";e.setAttribute("patternTransform",s),Kx.set(t,e)},e.prototype.markUsed=function(e){e.style&&(qx(e.style.fill)&&t.prototype.markDomUsed.call(this,Kx.get(e.style.fill)),qx(e.style.stroke)&&t.prototype.markDomUsed.call(this,Kx.get(e.style.stroke)))},e}(Yx);function Jx(t){var e=t.__clipPaths;return e&&e.length>0}var Qx=function(t){function e(e,n){var i=t.call(this,e,n,"clipPath","__clippath_in_use__")||this;return i._refGroups={},i._keyDuplicateCount={},i}return n(e,t),e.prototype.markAllUnused=function(){for(var e in t.prototype.markAllUnused.call(this),this._refGroups)this.markDomUnused(this._refGroups[e]);this._keyDuplicateCount={}},e.prototype._getClipPathGroup=function(t,e){if(Jx(t)){var n=t.__clipPaths,i=this._keyDuplicateCount,r=function(t){var e=[];if(t)for(var n=0;n<t.length;n++){var i=t[n];e.push(i.id)}return e.join(",")}(n);return cy(n,e&&e.__clipPaths)&&(i[r]=i[r]||0,i[r]&&(r+="-"+i[r]),i[r]++),this._refGroups[r]||(this._refGroups[r]=this.createElement("g"))}},e.prototype.update=function(t,e){var n=this._getClipPathGroup(t,e);return n&&(this.markDomUsed(n),this.updateDom(n,t.__clipPaths)),n},e.prototype.updateDom=function(t,e){if(e&&e.length>0){var n=this.getDefs(!0),i=e[0],r=void 0,o=void 0;i._dom?(o=i._dom.getAttribute("id"),r=i._dom,n.contains(r)||n.appendChild(r)):(o="zr"+this._zrId+"-clip-"+this.nextId,++this.nextId,(r=this.createElement("clipPath")).setAttribute("id",o),n.appendChild(r),i._dom=r),this.getSvgProxy(i).brush(i);var a=this.getSvgElement(i);r.innerHTML="",r.appendChild(a),t.setAttribute("clip-path","url(#"+o+")"),e.length>1&&this.updateDom(r,e.slice(1))}else t&&t.setAttribute("clip-path","none")},e.prototype.markUsed=function(e){var n=this;e.__clipPaths&&P(e.__clipPaths,(function(e){e._dom&&t.prototype.markDomUsed.call(n,e._dom)}))},e.prototype.removeUnused=function(){t.prototype.removeUnused.call(this);var e={};for(var n in this._refGroups){var i=this._refGroups[n];this.isDomUnused(i)?i.parentNode&&i.parentNode.removeChild(i):e[n]=i}this._refGroups=e},e}(Yx),tb=function(t){function e(e,n){var i=t.call(this,e,n,["filter"],"__filter_in_use__","_shadowDom")||this;return i._shadowDomMap={},i._shadowDomPool=[],i}return n(e,t),e.prototype._getFromPool=function(){var t=this._shadowDomPool.pop();if(!t){(t=this.createElement("filter")).setAttribute("id","zr"+this._zrId+"-shadow-"+this.nextId++);var e=this.createElement("feDropShadow");t.appendChild(e),this.addDom(t)}return t},e.prototype.update=function(t,e){if(function(t){return t&&(t.shadowBlur||t.shadowOffsetX||t.shadowOffsetY)}(e.style)){var n=function(t){var e=t.style,n=t.getGlobalScale();return[e.shadowColor,(e.shadowBlur||0).toFixed(2),(e.shadowOffsetX||0).toFixed(2),(e.shadowOffsetY||0).toFixed(2),n[0],n[1]].join(",")}(e),i=e._shadowDom=this._shadowDomMap[n];i||(i=this._getFromPool(),this._shadowDomMap[n]=i),this.updateDom(t,e,i)}else this.remove(t,e)},e.prototype.remove=function(t,e){null!=e._shadowDom&&(e._shadowDom=null,t.style.filter="")},e.prototype.updateDom=function(t,e,n){var i=n.children[0],r=e.style,o=e.getGlobalScale(),a=o[0],s=o[1];if(a&&s){var l=r.shadowOffsetX||0,u=r.shadowOffsetY||0,h=r.shadowBlur,c=r.shadowColor;i.setAttribute("dx",l/a+""),i.setAttribute("dy",u/s+""),i.setAttribute("flood-color",c);var p=h/2/a+" "+h/2/s;i.setAttribute("stdDeviation",p),n.setAttribute("x","-100%"),n.setAttribute("y","-100%"),n.setAttribute("width","300%"),n.setAttribute("height","300%"),e._shadowDom=n;var d=n.getAttribute("id");t.style.filter="url(#"+d+")"}},e.prototype.removeUnused=function(){if(this.getDefs(!1)){var t=this._shadowDomPool;for(var e in this._shadowDomMap){var n=this._shadowDomMap[e];t.push(n)}this._shadowDomMap={}}},e}(Yx);function eb(t){return parseInt(t,10)}function nb(t){return t instanceof Za?Fx:t instanceof Ja?Gx:t instanceof qa?Wx:Fx}function ib(t,e){return e&&t&&e.parentNode!==t}function rb(t,e,n){if(ib(t,e)&&n){var i=n.nextSibling;i?t.insertBefore(e,i):t.appendChild(e)}}function ob(t,e){if(ib(t,e)){var n=t.firstChild;n?t.insertBefore(e,n):t.appendChild(e)}}function ab(t,e){e&&t&&e.parentNode===t&&t.removeChild(e)}function sb(t){return t.__svgEl}var lb=function(){function t(t,e,n,i){this.type="svg",this.refreshHover=ub("refreshHover"),this.pathToImage=ub("pathToImage"),this.configLayer=ub("configLayer"),this.root=t,this.storage=e,this._opts=n=I({},n||{});var r=_x("svg");r.setAttributeNS("http://www.w3.org/2000/xmlns/","xmlns","http://www.w3.org/2000/svg"),r.setAttributeNS("http://www.w3.org/2000/xmlns/","xmlns:xlink","http://www.w3.org/1999/xlink"),r.setAttribute("version","1.1"),r.setAttribute("baseProfile","full"),r.style.cssText="user-select:none;position:absolute;left:0;top:0;";var o=_x("g");r.appendChild(o);var a=_x("g");r.appendChild(a),this._gradientManager=new jx(i,a),this._patternManager=new $x(i,a),this._clipPathManager=new Qx(i,a),this._shadowManager=new tb(i,a);var s=document.createElement("div");s.style.cssText="overflow:hidden;position:relative",this._svgDom=r,this._svgRoot=a,this._backgroundRoot=o,this._viewport=s,t.appendChild(s),s.appendChild(r),this.resize(n.width,n.height),this._visibleList=[]}return t.prototype.getType=function(){return"svg"},t.prototype.getViewportRoot=function(){return this._viewport},t.prototype.getSvgDom=function(){return this._svgDom},t.prototype.getSvgRoot=function(){return this._svgRoot},t.prototype.getViewportRootOffset=function(){var t=this.getViewportRoot();if(t)return{offsetLeft:t.offsetLeft||0,offsetTop:t.offsetTop||0}},t.prototype.refresh=function(){var t=this.storage.getDisplayList(!0);this._paintList(t)},t.prototype.setBackgroundColor=function(t){this._backgroundRoot&&this._backgroundNode&&this._backgroundRoot.removeChild(this._backgroundNode);var e=_x("rect");e.setAttribute("width",this.getWidth()),e.setAttribute("height",this.getHeight()),e.setAttribute("x",0),e.setAttribute("y",0),e.setAttribute("id",0),e.style.fill=t,this._backgroundRoot.appendChild(e),this._backgroundNode=e},t.prototype.createSVGElement=function(t){return _x(t)},t.prototype.paintOne=function(t){var e=nb(t);return e&&e.brush(t),sb(t)},t.prototype._paintList=function(t){var e=this._gradientManager,n=this._patternManager,i=this._clipPathManager,r=this._shadowManager;e.markAllUnused(),n.markAllUnused(),i.markAllUnused(),r.markAllUnused();for(var o=this._svgRoot,a=this._visibleList,s=t.length,l=[],u=0;u<s;u++){var h=nb(x=t[u]),c=sb(x);x.invisible||(!x.__dirty&&c||(h&&h.brush(x),(c=sb(x))&&x.style&&(e.update(x.style.fill),e.update(x.style.stroke),n.update(x.style.fill),n.update(x.style.stroke),r.update(c,x)),x.__dirty=0),c&&l.push(x))}var p,d,f,g,y,v=Mx(a,l);for(u=0;u<v.length;u++){if((_=v[u]).removed)for(var m=0;m<_.count;m++){c=sb(x=a[_.indices[m]]);Jx(x)?(f=c)&&f.parentNode&&f.parentNode.removeChild(f):ab(o,c)}}for(u=0;u<v.length;u++){var _;if(!(_=v[u]).removed)for(m=0;m<_.count;m++){var x=l[_.indices[m]],b=i.update(x,g);b!==y&&(p=d,b&&(p?rb(o,b,p):ob(o,b),d=b,p=null),y=b);c=sb(x);p?rb(y||o,c,p):ob(y||o,c),p=c||p,y||(d=p),e.markUsed(x),e.addWithoutUpdate(c,x),n.markUsed(x),n.addWithoutUpdate(c,x),i.markUsed(x),g=x}}e.removeUnused(),n.removeUnused(),i.removeUnused(),r.removeUnused(),this._visibleList=l},t.prototype._getDefs=function(t){var e=this._svgDom,n=e.getElementsByTagName("defs");if(0===n.length){if(t){var i=e.insertBefore(_x("defs"),e.firstChild);return i.contains||(i.contains=function(t){var e=i.children;if(!e)return!1;for(var n=e.length-1;n>=0;--n)if(e[n]===t)return!0;return!1}),i}return null}return n[0]},t.prototype.resize=function(t,e){var n=this._viewport;n.style.display="none";var i=this._opts;if(null!=t&&(i.width=t),null!=e&&(i.height=e),t=this._getSize(0),e=this._getSize(1),n.style.display="",this._width!==t||this._height!==e){this._width=t,this._height=e;var r=n.style;r.width=t+"px",r.height=e+"px";var o=this._svgDom;o.setAttribute("width",t+""),o.setAttribute("height",e+"")}this._backgroundNode&&(this._backgroundNode.setAttribute("width",t),this._backgroundNode.setAttribute("height",e))},t.prototype.getWidth=function(){return this._width},t.prototype.getHeight=function(){return this._height},t.prototype._getSize=function(t){var e=this._opts,n=["width","height"][t],i=["clientWidth","clientHeight"][t],r=["paddingLeft","paddingTop"][t],o=["paddingRight","paddingBottom"][t];if(null!=e[n]&&"auto"!==e[n])return parseFloat(e[n]);var a=this.root,s=document.defaultView.getComputedStyle(a);return(a[i]||eb(s[n])||eb(a.style[n]))-(eb(s[r])||0)-(eb(s[o])||0)|0},t.prototype.dispose=function(){this.root.innerHTML="",this._svgRoot=this._backgroundRoot=this._svgDom=this._backgroundNode=this._viewport=this.storage=null},t.prototype.clear=function(){var t=this._viewport;t&&t.parentNode&&t.parentNode.removeChild(t)},t.prototype.toDataURL=function(){this.refresh();var t=this._svgDom,e=t.outerHTML||(t.parentNode&&t.parentNode).innerHTML;return"data:image/svg+xml;charset=UTF-8,"+encodeURIComponent(e.replace(/></g,">\n\r<"))},t}();function ub(t){return function(){b('In SVG mode painter not support method "'+t+'"')}}function hb(){return!1}function cb(t,e,n){var i=C(),r=e.getWidth(),o=e.getHeight(),a=i.style;return a&&(a.position="absolute",a.left="0",a.top="0",a.width=r+"px",a.height=o+"px",i.setAttribute("data-zr-dom-id",t)),i.width=r*n,i.height=o*n,i}var pb=function(t){function e(e,n,i){var r,o=t.call(this)||this;o.motionBlur=!1,o.lastFrameAlpha=.7,o.dpr=1,o.virtual=!1,o.config={},o.incremental=!1,o.zlevel=0,o.maxRepaintRectCount=5,o.__dirty=!0,o.__firstTimePaint=!0,o.__used=!1,o.__drawIndex=0,o.__startIndex=0,o.__endIndex=0,o.__prevStartIndex=null,o.__prevEndIndex=null,i=i||Zn,"string"==typeof e?r=cb(e,n,i):X(e)&&(e=(r=e).id),o.id=e,o.dom=r;var a=r.style;return a&&(r.onselectstart=hb,a.webkitUserSelect="none",a.userSelect="none",a.webkitTapHighlightColor="rgba(0,0,0,0)",a["-webkit-touch-callout"]="none",a.padding="0",a.margin="0",a.borderWidth="0"),o.domBack=null,o.ctxBack=null,o.painter=n,o.config=null,o.dpr=i,o}return n(e,t),e.prototype.getElementCount=function(){return this.__endIndex-this.__startIndex},e.prototype.afterBrush=function(){this.__prevStartIndex=this.__startIndex,this.__prevEndIndex=this.__endIndex},e.prototype.initContext=function(){this.ctx=this.dom.getContext("2d"),this.ctx.dpr=this.dpr},e.prototype.setUnpainted=function(){this.__firstTimePaint=!0},e.prototype.createBackBuffer=function(){var t=this.dpr;this.domBack=cb("back-"+this.id,this.painter,t),this.ctxBack=this.domBack.getContext("2d"),1!==t&&this.ctxBack.scale(t,t)},e.prototype.createRepaintRects=function(t,e,n,i){if(this.__firstTimePaint)return this.__firstTimePaint=!1,null;var r,o=[],a=this.maxRepaintRectCount,s=!1,l=new Rn(0,0,0,0);function u(t){if(t.isFinite()&&!t.isZero())if(0===o.length){(e=new Rn(0,0,0,0)).copy(t),o.push(e)}else{for(var e,n=!1,i=1/0,r=0,u=0;u<o.length;++u){var h=o[u];if(h.intersect(t)){var c=new Rn(0,0,0,0);c.copy(h),c.union(t),o[u]=c,n=!0;break}if(s){l.copy(t),l.union(h);var p=t.width*t.height,d=h.width*h.height,f=l.width*l.height-p-d;f<i&&(i=f,r=u)}}if(s&&(o[r].union(t),n=!0),!n)(e=new Rn(0,0,0,0)).copy(t),o.push(e);s||(s=o.length>=a)}}for(var h=this.__startIndex;h<this.__endIndex;++h){if(d=t[h]){var c=d.shouldBePainted(n,i,!0,!0);(f=d.__isRendered&&(d.__dirty&ei.REDARAW_BIT||!c)?d.getPrevPaintRect():null)&&u(f);var p=c&&(d.__dirty&ei.REDARAW_BIT||!d.__isRendered)?d.getPaintRect():null;p&&u(p)}}for(h=this.__prevStartIndex;h<this.__prevEndIndex;++h){var d,f;c=(d=e[h]).shouldBePainted(n,i,!0,!0);if(d&&(!c||!d.__zr)&&d.__isRendered)(f=d.getPrevPaintRect())&&u(f)}do{r=!1;for(h=0;h<o.length;)if(o[h].isZero())o.splice(h,1);else{for(var g=h+1;g<o.length;)o[h].intersect(o[g])?(r=!0,o[h].union(o[g]),o.splice(g,1)):g++;h++}}while(r);return this._paintRects=o,o},e.prototype.debugGetPaintRects=function(){return(this._paintRects||[]).slice()},e.prototype.resize=function(t,e){var n=this.dpr,i=this.dom,r=i.style,o=this.domBack;r&&(r.width=t+"px",r.height=e+"px"),i.width=t*n,i.height=e*n,o&&(o.width=t*n,o.height=e*n,1!==n&&this.ctxBack.scale(n,n))},e.prototype.clear=function(t,e,n){var i=this.dom,r=this.ctx,o=i.width,a=i.height;e=e||this.clearColor;var s=this.motionBlur&&!t,l=this.lastFrameAlpha,u=this.dpr,h=this;s&&(this.domBack||this.createBackBuffer(),this.ctxBack.globalCompositeOperation="copy",this.ctxBack.drawImage(i,0,0,o/u,a/u));var c=this.domBack;function p(t,n,i,o){if(r.clearRect(t,n,i,o),e&&"transparent"!==e){var a=void 0;q(e)?(a=e.__canvasGradient||hy(r,e,{x:0,y:0,width:i,height:o}),e.__canvasGradient=a):K(e)&&(a=my(r,e,{dirty:function(){h.setUnpainted(),h.__painter.refresh()}})),r.save(),r.fillStyle=a||e,r.fillRect(t,n,i,o),r.restore()}s&&(r.save(),r.globalAlpha=l,r.drawImage(c,t,n,i,o),r.restore())}!n||s?p(0,0,o,a):n.length&&P(n,(function(t){p(t.x*u,t.y*u,t.width*u,t.height*u)}))},e}(Ft),db=1e5,fb=314159,gb=.01;function yb(t){return parseInt(t,10)}var vb=function(){function t(t,e,n,i){this.type="canvas",this._zlevelList=[],this._prevDisplayList=[],this._layers={},this._layerConfig={},this._needsManuallyCompositing=!1,this.type="canvas";var r=!t.nodeName||"CANVAS"===t.nodeName.toUpperCase();this._opts=n=I({},n||{}),this.dpr=n.devicePixelRatio||Zn,this._singleCanvas=r,this.root=t;var o=t.style;o&&(o.webkitTapHighlightColor="transparent",o.webkitUserSelect="none",o.userSelect="none",o["-webkit-touch-callout"]="none",t.innerHTML=""),this.storage=e;var a=this._zlevelList;this._prevDisplayList=[];var s=this._layers;if(r){var l=t,u=l.width,h=l.height;null!=n.width&&(u=n.width),null!=n.height&&(h=n.height),this.dpr=n.devicePixelRatio||1,l.width=u*this.dpr,l.height=h*this.dpr,this._width=u,this._height=h;var c=new pb(l,this,this.dpr);c.__builtin__=!0,c.initContext(),s[314159]=c,c.zlevel=fb,a.push(fb),this._domRoot=t}else{this._width=this._getSize(0),this._height=this._getSize(1);var p=this._domRoot=function(t,e){var n=document.createElement("div");return n.style.cssText=["position:relative","width:"+t+"px","height:"+e+"px","padding:0","margin:0","border-width:0"].join(";")+";",n}(this._width,this._height);t.appendChild(p)}}return t.prototype.getType=function(){return"canvas"},t.prototype.isSingleCanvas=function(){return this._singleCanvas},t.prototype.getViewportRoot=function(){return this._domRoot},t.prototype.getViewportRootOffset=function(){var t=this.getViewportRoot();if(t)return{offsetLeft:t.offsetLeft||0,offsetTop:t.offsetTop||0}},t.prototype.refresh=function(t){var e=this.storage.getDisplayList(!0),n=this._prevDisplayList,i=this._zlevelList;this._redrawId=Math.random(),this._paintList(e,n,t,this._redrawId);for(var r=0;r<i.length;r++){var o=i[r],a=this._layers[o];if(!a.__builtin__&&a.refresh){var s=0===r?this._backgroundColor:null;a.refresh(s)}}return this._opts.useDirtyRect&&(this._prevDisplayList=e.slice()),this},t.prototype.refreshHover=function(){this._paintHoverList(this.storage.getDisplayList(!1))},t.prototype._paintHoverList=function(t){var e=t.length,n=this._hoverlayer;if(n&&n.clear(),e){for(var i,r={inHover:!0,viewWidth:this._width,viewHeight:this._height},o=0;o<e;o++){var a=t[o];a.__inHover&&(n||(n=this._hoverlayer=this.getLayer(db)),i||(i=n.ctx).save(),Cy(i,a,r,o===e-1))}i&&i.restore()}},t.prototype.getHoverLayer=function(){return this.getLayer(db)},t.prototype.paintOne=function(t,e){Ty(t,e)},t.prototype._paintList=function(t,e,n,i){if(this._redrawId===i){n=n||!1,this._updateLayerStatus(t);var r=this._doPaintList(t,e,n),o=r.finished,a=r.needsRefreshHover;if(this._needsManuallyCompositing&&this._compositeManually(),a&&this._paintHoverList(t),o)this.eachLayer((function(t){t.afterBrush&&t.afterBrush()}));else{var s=this;mi((function(){s._paintList(t,e,n,i)}))}}},t.prototype._compositeManually=function(){var t=this.getLayer(fb).ctx,e=this._domRoot.width,n=this._domRoot.height;t.clearRect(0,0,e,n),this.eachBuiltinLayer((function(i){i.virtual&&t.drawImage(i.dom,0,0,e,n)}))},t.prototype._doPaintList=function(t,e,n){for(var i=this,r=[],o=this._opts.useDirtyRect,s=0;s<this._zlevelList.length;s++){var l=this._zlevelList[s],u=this._layers[l];u.__builtin__&&u!==this._hoverlayer&&(u.__dirty||n)&&r.push(u)}for(var h=!0,c=!1,p=function(a){var s=r[a],l=s.ctx,u=o&&s.createRepaintRects(t,e,d._width,d._height);l.save();var p,f=n?s.__startIndex:s.__drawIndex,g=!n&&s.incremental&&Date.now,y=g&&Date.now(),v=s.zlevel===d._zlevelList[0]?d._backgroundColor:null;if(s.__startIndex===s.__endIndex)s.clear(!1,v,u);else if(f===s.__startIndex){var m=t[f];m.incremental&&m.notClear&&!n||s.clear(!1,v,u)}-1===f&&(console.error("For some unknown reason. drawIndex is -1"),f=s.__startIndex);var _=function(e){var n={inHover:!1,allClipped:!1,prevEl:null,viewWidth:i._width,viewHeight:i._height};for(p=f;p<s.__endIndex;p++){var r=t[p];if(r.__inHover&&(c=!0),i._doPaintEl(r,s,o,e,n,p===s.__endIndex-1),g)if(Date.now()-y>15)break}n.prevElClipPaths&&l.restore()};if(u)if(0===u.length)p=s.__endIndex;else for(var x=d.dpr,b=0;b<u.length;++b){var w=u[b];l.save(),l.beginPath(),l.rect(w.x*x,w.y*x,w.width*x,w.height*x),l.clip(),_(w),l.restore()}else l.save(),_(),l.restore();s.__drawIndex=p,s.__drawIndex<s.__endIndex&&(h=!1)},d=this,f=0;f<r.length;f++)p(f);return a.wxa&&P(this._layers,(function(t){t&&t.ctx&&t.ctx.draw&&t.ctx.draw()})),{finished:h,needsRefreshHover:c}},t.prototype._doPaintEl=function(t,e,n,i,r,o){var a=e.ctx;if(n){var s=t.getPaintRect();(!i||s&&s.intersect(i))&&(Cy(a,t,r,o),t.setPrevPaintRect(s))}else Cy(a,t,r,o)},t.prototype.getLayer=function(t,e){this._singleCanvas&&!this._needsManuallyCompositing&&(t=fb);var n=this._layers[t];return n||((n=new pb("zr_"+t,this,this.dpr)).zlevel=t,n.__builtin__=!0,this._layerConfig[t]?S(n,this._layerConfig[t],!0):this._layerConfig[t-gb]&&S(n,this._layerConfig[t-gb],!0),e&&(n.virtual=e),this.insertLayer(t,n),n.initContext()),n},t.prototype.insertLayer=function(t,e){var n=this._layers,i=this._zlevelList,r=i.length,o=this._domRoot,a=null,s=-1;if(n[t])b("ZLevel "+t+" has been used already");else if(function(t){return!!t&&(!!t.__builtin__||"function"==typeof t.resize&&"function"==typeof t.refresh)}(e)){if(r>0&&t>i[0]){for(s=0;s<r-1&&!(i[s]<t&&i[s+1]>t);s++);a=n[i[s]]}if(i.splice(s+1,0,t),n[t]=e,!e.virtual)if(a){var l=a.dom;l.nextSibling?o.insertBefore(e.dom,l.nextSibling):o.appendChild(e.dom)}else o.firstChild?o.insertBefore(e.dom,o.firstChild):o.appendChild(e.dom);e.__painter=this}else b("Layer of zlevel "+t+" is not valid")},t.prototype.eachLayer=function(t,e){for(var n=this._zlevelList,i=0;i<n.length;i++){var r=n[i];t.call(e,this._layers[r],r)}},t.prototype.eachBuiltinLayer=function(t,e){for(var n=this._zlevelList,i=0;i<n.length;i++){var r=n[i],o=this._layers[r];o.__builtin__&&t.call(e,o,r)}},t.prototype.eachOtherLayer=function(t,e){for(var n=this._zlevelList,i=0;i<n.length;i++){var r=n[i],o=this._layers[r];o.__builtin__||t.call(e,o,r)}},t.prototype.getLayers=function(){return this._layers},t.prototype._updateLayerStatus=function(t){function e(t){o&&(o.__endIndex!==t&&(o.__dirty=!0),o.__endIndex=t)}if(this.eachBuiltinLayer((function(t,e){t.__dirty=t.__used=!1})),this._singleCanvas)for(var n=1;n<t.length;n++){if((s=t[n]).zlevel!==t[n-1].zlevel||s.incremental){this._needsManuallyCompositing=!0;break}}var i,r,o=null,a=0;for(r=0;r<t.length;r++){var s,l=(s=t[r]).zlevel,u=void 0;i!==l&&(i=l,a=0),s.incremental?((u=this.getLayer(l+.001,this._needsManuallyCompositing)).incremental=!0,a=1):u=this.getLayer(l+(a>0?gb:0),this._needsManuallyCompositing),u.__builtin__||b("ZLevel "+l+" has been used by unkown layer "+u.id),u!==o&&(u.__used=!0,u.__startIndex!==r&&(u.__dirty=!0),u.__startIndex=r,u.incremental?u.__drawIndex=-1:u.__drawIndex=r,e(r),o=u),s.__dirty&ei.REDARAW_BIT&&!s.__inHover&&(u.__dirty=!0,u.incremental&&u.__drawIndex<0&&(u.__drawIndex=r))}e(r),this.eachBuiltinLayer((function(t,e){!t.__used&&t.getElementCount()>0&&(t.__dirty=!0,t.__startIndex=t.__endIndex=t.__drawIndex=0),t.__dirty&&t.__drawIndex<0&&(t.__drawIndex=t.__startIndex)}))},t.prototype.clear=function(){return this.eachBuiltinLayer(this._clearLayer),this},t.prototype._clearLayer=function(t){t.clear()},t.prototype.setBackgroundColor=function(t){this._backgroundColor=t,P(this._layers,(function(t){t.setUnpainted()}))},t.prototype.configLayer=function(t,e){if(e){var n=this._layerConfig;n[t]?S(n[t],e,!0):n[t]=e;for(var i=0;i<this._zlevelList.length;i++){var r=this._zlevelList[i];if(r===t||r===t+gb)S(this._layers[r],n[t],!0)}}},t.prototype.delLayer=function(t){var e=this._layers,n=this._zlevelList,i=e[t];i&&(i.dom.parentNode.removeChild(i.dom),delete e[t],n.splice(A(n,t),1))},t.prototype.resize=function(t,e){if(this._domRoot.style){var n=this._domRoot;n.style.display="none";var i=this._opts;if(null!=t&&(i.width=t),null!=e&&(i.height=e),t=this._getSize(0),e=this._getSize(1),n.style.display="",this._width!==t||e!==this._height){for(var r in n.style.width=t+"px",n.style.height=e+"px",this._layers)this._layers.hasOwnProperty(r)&&this._layers[r].resize(t,e);this.refresh(!0)}this._width=t,this._height=e}else{if(null==t||null==e)return;this._width=t,this._height=e,this.getLayer(fb).resize(t,e)}return this},t.prototype.clearLayer=function(t){var e=this._layers[t];e&&e.clear()},t.prototype.dispose=function(){this.root.innerHTML="",this.root=this.storage=this._domRoot=this._layers=null},t.prototype.getRenderedCanvas=function(t){if(t=t||{},this._singleCanvas&&!this._compositeManually)return this._layers[314159].dom;var e=new pb("image",this,t.pixelRatio||this.dpr);e.initContext(),e.clear(!1,t.backgroundColor||this._backgroundColor);var n=e.ctx;if(t.pixelRatio<=this.dpr){this.refresh();var i=e.dom.width,r=e.dom.height;this.eachLayer((function(t){t.__builtin__?n.drawImage(t.dom,0,0,i,r):t.renderToCanvas&&(n.save(),t.renderToCanvas(n),n.restore())}))}else for(var o={inHover:!1,viewWidth:this._width,viewHeight:this._height},a=this.storage.getDisplayList(!0),s=0,l=a.length;s<l;s++){var u=a[s];Cy(n,u,o,s===l-1)}return e.dom},t.prototype.getWidth=function(){return this._width},t.prototype.getHeight=function(){return this._height},t.prototype._getSize=function(t){var e=this._opts,n=["width","height"][t],i=["clientWidth","clientHeight"][t],r=["paddingLeft","paddingTop"][t],o=["paddingRight","paddingBottom"][t];if(null!=e[n]&&"auto"!==e[n])return parseFloat(e[n]);var a=this.root,s=document.defaultView.getComputedStyle(a);return(a[i]||yb(s[n])||yb(a.style[n]))-(yb(s[r])||0)-(yb(s[o])||0)|0},t.prototype.pathToImage=function(t,e){e=e||this.dpr;var n=document.createElement("canvas"),i=n.getContext("2d"),r=t.getBoundingRect(),o=t.style,a=o.shadowBlur*e,s=o.shadowOffsetX*e,l=o.shadowOffsetY*e,u=t.hasStroke()?o.lineWidth:0,h=Math.max(u/2,-s+a),c=Math.max(u/2,s+a),p=Math.max(u/2,-l+a),d=Math.max(u/2,l+a),f=r.width+h+c,g=r.height+p+d;n.width=f*e,n.height=g*e,i.scale(e,e),i.clearRect(0,0,f,g),i.dpr=e;var y={x:t.x,y:t.y,scaleX:t.scaleX,scaleY:t.scaleY,rotation:t.rotation,originX:t.originX,originY:t.originY};t.x=h-r.x,t.y=p-r.y,t.rotation=0,t.scaleX=1,t.scaleY=1,t.updateTransform(),t&&Cy(i,t,{inHover:!1,viewWidth:this._width,viewHeight:this._height},!0);var v=new Ja({style:{x:0,y:0,image:n}});return I(t,y),v},t}();var mb=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.hasSymbolVisual=!0,n.legendSymbol="line",n}return n(e,t),e.prototype.getInitialData=function(t){return Hm(this.getSource(),this,{useEncodeDefaulter:!0})},e.type="series.line",e.dependencies=["grid","polar"],e.defaultOption={zlevel:0,z:3,coordinateSystem:"cartesian2d",legendHoverLink:!0,clip:!0,label:{position:"top"},endLabel:{show:!1,valueAnimation:!0,distance:8},lineStyle:{width:2,type:"solid"},emphasis:{scale:!0,lineStyle:{width:"bolder"}},step:!1,smooth:!1,smoothMonotone:null,symbol:"emptyCircle",symbolSize:4,symbolRotate:null,showSymbol:!0,showAllSymbol:"auto",connectNulls:!1,sampling:"none",animationEasing:"linear",progressive:0,hoverLayerThreshold:1/0},e}(rf);function _b(t,e){var n=t.mapDimensionsAll("defaultedLabel"),i=n.length;if(1===i){var r=fd(t,e,n[0]);return null!=r?r+"":null}if(i){for(var o=[],a=0;a<n.length;a++)o.push(fd(t,e,n[a]));return o.join(" ")}}function xb(t,e){var n=t.mapDimensionsAll("defaultedLabel");if(!F(e))return e+"";for(var i=[],r=0;r<n.length;r++){var o=t.getDimensionInfo(n[r]);o&&i.push(e[o.index])}return i.join(" ")}var bb=function(t){function e(e,n,i,r){var o=t.call(this)||this;return o.updateData(e,n,i,r),o}return n(e,t),e.prototype._createSymbol=function(t,e,n,i,r){this.removeAll();var o=uy(t,-1,-1,2,2,null,r);o.attr({z2:100,culling:!0,scaleX:i[0]/2,scaleY:i[1]/2}),o.drift=wb,this._symbolType=t,this.add(o)},e.prototype.stopSymbolAnimation=function(t){this.childAt(0).stopAnimation(null,t)},e.prototype.getSymbolPath=function(){return this.childAt(0)},e.prototype.highlight=function(){Hs(this.childAt(0))},e.prototype.downplay=function(){Ws(this.childAt(0))},e.prototype.setZ=function(t,e){var n=this.childAt(0);n.zlevel=t,n.z=e},e.prototype.setDraggable=function(t){var e=this.childAt(0);e.draggable=t,e.cursor=t?"move":e.cursor},e.prototype.updateData=function(t,n,i,r){this.silent=!1;var o=t.getItemVisual(n,"symbol")||"circle",a=t.hostModel,s=e.getSymbolSize(t,n),l=o!==this._symbolType,u=r&&r.disableAnimation;if(l){var h=t.getItemVisual(n,"symbolKeepAspect");this._createSymbol(o,t,n,s,h)}else{(p=this.childAt(0)).silent=!1;var c={scaleX:s[0]/2,scaleY:s[1]/2};u?p.attr(c):Ou(p,c,a,n)}if(this._updateCommon(t,n,s,i,r),l){var p=this.childAt(0);if(!u){c={scaleX:this._sizeX,scaleY:this._sizeY,style:{opacity:p.style.opacity}};p.scaleX=p.scaleY=0,p.style.opacity=0,Ru(p,c,a,n)}}u&&this.childAt(0).stopAnimation("remove"),this._seriesModel=a},e.prototype._updateCommon=function(t,e,n,i,r){var o,a,s,l,u,h,c,p,d,f=this.childAt(0),g=t.hostModel;if(i&&(o=i.emphasisItemStyle,a=i.blurItemStyle,s=i.selectItemStyle,l=i.focus,u=i.blurScope,h=i.symbolOffset,c=i.labelStatesModels,p=i.hoverScale,d=i.cursorStyle),!i||t.hasItemOption){var y=i&&i.itemModel?i.itemModel:t.getItemModel(e),v=y.getModel("emphasis");o=v.getModel("itemStyle").getItemStyle(),s=y.getModel(["select","itemStyle"]).getItemStyle(),a=y.getModel(["blur","itemStyle"]).getItemStyle(),l=v.get("focus"),u=v.get("blurScope"),h=y.getShallow("symbolOffset"),c=eh(y),p=v.getShallow("scale"),d=y.getShallow("cursor")}var m=t.getItemVisual(e,"symbolRotate");f.attr("rotation",(m||0)*Math.PI/180||0),h&&(f.x=Zi(h[0],n[0]),f.y=Zi(h[1],n[1])),d&&f.attr("cursor",d);var _=t.getItemVisual(e,"style"),x=_.fill;if(f instanceof Ja){var b=f.style;f.useStyle(I({image:b.image,x:b.x,y:b.y,width:b.width,height:b.height},_))}else f.__isEmptyBrush?f.useStyle(I({},_)):f.useStyle(_),f.style.decal=null,f.setColor(x,r&&r.symbolInnerColor),f.style.strokeNoScale=!0;var w=t.getItemVisual(e,"liftZ"),S=this._z2;null!=w?null==S&&(this._z2=f.z2,f.z2+=w):null!=S&&(f.z2=S,this._z2=null);var M=r&&r.useNameLabel;th(f,c,{labelFetcher:g,labelDataIndex:e,defaultText:function(e){return M?t.getName(e):_b(t,e)},inheritColor:x,defaultOpacity:_.opacity}),this._sizeX=n[0]/2,this._sizeY=n[1]/2;var T=f.ensureState("emphasis");if(T.style=o,f.ensureState("select").style=s,f.ensureState("blur").style=a,p){var C=Math.max(1.1,3/this._sizeY);T.scaleX=this._sizeX*C,T.scaleY=this._sizeY*C}this.setSymbolScale(1),Js(this,l,u)},e.prototype.setSymbolScale=function(t){this.scaleX=this.scaleY=t},e.prototype.fadeOut=function(t,e){var n=this.childAt(0),i=this._seriesModel,r=ys(this).dataIndex,o=e&&e.animation;if(this.silent=n.silent=!0,e&&e.fadeLabel){var a=n.getTextContent();a&&Nu(a,{style:{opacity:0}},i,{dataIndex:r,removeOpt:o,cb:function(){n.removeTextContent()}})}else n.removeTextContent();Nu(n,{style:{opacity:0},scaleX:0,scaleY:0},i,{dataIndex:r,cb:t,removeOpt:o})},e.getSymbolSize=function(t,e){var n=t.getItemVisual(e,"symbolSize");return n instanceof Array?n.slice():[+n,+n]},e}(zi);function wb(t,e){this.parent.drift(t,e)}function Sb(t,e,n,i){return e&&!isNaN(e[0])&&!isNaN(e[1])&&!(i.isIgnore&&i.isIgnore(n))&&!(i.clipShape&&!i.clipShape.contain(e[0],e[1]))&&"none"!==t.getItemVisual(n,"symbol")}function Mb(t){return null==t||X(t)||(t={isIgnore:t}),t||{}}function Ib(t){var e=t.hostModel,n=e.getModel("emphasis");return{emphasisItemStyle:n.getModel("itemStyle").getItemStyle(),blurItemStyle:e.getModel(["blur","itemStyle"]).getItemStyle(),selectItemStyle:e.getModel(["select","itemStyle"]).getItemStyle(),focus:n.get("focus"),blurScope:n.get("blurScope"),symbolRotate:e.get("symbolRotate"),symbolOffset:e.get("symbolOffset"),hoverScale:n.get("scale"),labelStatesModels:eh(e),cursorStyle:e.get("cursor")}}var Tb=function(){function t(t){this.group=new zi,this._SymbolCtor=t||bb}return t.prototype.updateData=function(t,e){e=Mb(e);var n=this.group,i=t.hostModel,r=this._data,o=this._SymbolCtor,a=e.disableAnimation,s=Ib(t),l={disableAnimation:a},u=e.getSymbolPoint||function(e){return t.getItemLayout(e)};r||n.removeAll(),t.diff(r).add((function(i){var r=u(i);if(Sb(t,r,i,e)){var a=new o(t,i,s,l);a.setPosition(r),t.setItemGraphicEl(i,a),n.add(a)}})).update((function(h,c){var p=r.getItemGraphicEl(c),d=u(h);if(Sb(t,d,h,e)){if(p){p.updateData(t,h,s,l);var f={x:d[0],y:d[1]};a?p.attr(f):Ou(p,f,i)}else(p=new o(t,h)).setPosition(d);n.add(p),t.setItemGraphicEl(h,p)}else n.remove(p)})).remove((function(t){var e=r.getItemGraphicEl(t);e&&e.fadeOut((function(){n.remove(e)}))})).execute(),this._getSymbolPoint=u,this._data=t},t.prototype.isPersistent=function(){return!0},t.prototype.updateLayout=function(){var t=this,e=this._data;e&&e.eachItemGraphicEl((function(e,n){var i=t._getSymbolPoint(n);e.setPosition(i),e.markRedraw()}))},t.prototype.incrementalPrepareUpdate=function(t){this._seriesScope=Ib(t),this._data=null,this.group.removeAll()},t.prototype.incrementalUpdate=function(t,e,n){function i(t){t.isGroup||(t.incremental=!0,t.ensureState("emphasis").hoverLayer=!0)}n=Mb(n);for(var r=t.start;r<t.end;r++){var o=e.getItemLayout(r);if(Sb(e,o,r,n)){var a=new this._SymbolCtor(e,r,this._seriesScope);a.traverse(i),a.setPosition(o),this.group.add(a),e.setItemGraphicEl(r,a)}}},t.prototype.remove=function(t){var e=this.group,n=this._data;n&&t?n.eachItemGraphicEl((function(t){t.fadeOut((function(){e.remove(t)}))})):e.removeAll()},t}();function Cb(t,e,n){var i=t.getBaseAxis(),r=t.getOtherAxis(i),o=function(t,e){var n=0,i=t.scale.getExtent();"start"===e?n=i[0]:"end"===e?n=i[1]:i[0]>0?n=i[0]:i[1]<0&&(n=i[1]);return n}(r,n),a=i.dim,s=r.dim,l=e.mapDimension(s),u=e.mapDimension(a),h="x"===s||"radius"===s?1:0,c=O(t.dimensions,(function(t){return e.mapDimension(t)})),p=!1,d=e.getCalculationInfo("stackResultDimension");return Fm(e,c[0])&&(p=!0,c[0]=d),Fm(e,c[1])&&(p=!0,c[1]=d),{dataDimsForPoint:c,valueStart:o,valueAxisDim:s,baseAxisDim:a,stacked:!!p,valueDim:l,baseDim:u,baseDataOffset:h,stackedOverDimension:e.getCalculationInfo("stackedOverDimension")}}function Ab(t,e,n,i){var r=NaN;t.stacked&&(r=n.get(n.getCalculationInfo("stackedOverDimension"),i)),isNaN(r)&&(r=t.valueStart);var o=t.baseDataOffset,a=[];return a[o]=n.get(t.baseDim,i),a[1-o]=r,e.dataToPoint(a)}var Db="undefined"!=typeof Float32Array,Lb=Db?Float32Array:Array;function kb(t){return F(t)?Db?new Float32Array(t):t:new Lb(t)}var Pb=Math.min,Ob=Math.max;function Rb(t,e){return isNaN(t)||isNaN(e)}function Nb(t,e,n,i,r,o,a,s,l){for(var u,h,c,p,d,f,g=n,y=0;y<i;y++){var v=e[2*g],m=e[2*g+1];if(g>=r||g<0)break;if(Rb(v,m)){if(l){g+=o;continue}break}if(g===n)t[o>0?"moveTo":"lineTo"](v,m),c=v,p=m;else{var _=v-u,x=m-h;if(_*_+x*x<.5){g+=o;continue}if(a>0){var b=g+o,w=e[2*b],S=e[2*b+1],M=y+1;if(l)for(;Rb(w,S)&&M<i;)M++,w=e[2*(b+=o)],S=e[2*b+1];var I=.5,T=0,C=0,A=void 0,D=void 0;if(M>=i||Rb(w,S))d=v,f=m;else{T=w-u,C=S-h;var L=v-u,k=w-v,P=m-h,O=S-m,R=void 0,N=void 0;"x"===s?(R=Math.abs(L),N=Math.abs(k),d=v-R*a,f=m,A=v+R*a,D=m):"y"===s?(R=Math.abs(P),N=Math.abs(O),d=v,f=m-R*a,A=v,D=m+R*a):(R=Math.sqrt(L*L+P*P),d=v-T*a*(1-(I=(N=Math.sqrt(k*k+O*O))/(N+R))),f=m-C*a*(1-I),D=m+C*a*I,A=Pb(A=v+T*a*I,Ob(w,v)),D=Pb(D,Ob(S,m)),A=Ob(A,Pb(w,v)),f=m-(C=(D=Ob(D,Pb(S,m)))-m)*R/N,d=Pb(d=v-(T=A-v)*R/N,Ob(u,v)),f=Pb(f,Ob(h,m)),A=v+(T=v-(d=Ob(d,Pb(u,v))))*N/R,D=m+(C=m-(f=Ob(f,Pb(h,m))))*N/R)}t.bezierCurveTo(c,p,d,f,v,m),c=A,p=D}else t.lineTo(v,m)}u=v,h=m,g+=o}return y}var Eb=function(){this.smooth=0,this.smoothConstraint=!0},zb=function(t){function e(e){var n=t.call(this,e)||this;return n.type="ec-polyline",n}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new Eb},e.prototype.buildPath=function(t,e){var n=e.points,i=0,r=n.length/2;if(e.connectNulls){for(;r>0&&Rb(n[2*r-2],n[2*r-1]);r--);for(;i<r&&Rb(n[2*i],n[2*i+1]);i++);}for(;i<r;)i+=Nb(t,n,i,r,r,1,e.smooth,e.smoothMonotone,e.connectNulls)+1},e.prototype.getPointOn=function(t,e){this.path||(this.createPathProxy(),this.buildPath(this.path,this.shape));for(var n,i,r=this.path.data,o=Ca.CMD,a="x"===e,s=[],l=0;l<r.length;){var u=void 0,h=void 0,c=void 0,p=void 0,d=void 0,f=void 0,g=void 0;switch(r[l++]){case o.M:n=r[l++],i=r[l++];break;case o.L:if(u=r[l++],h=r[l++],(g=a?(t-n)/(u-n):(t-i)/(h-i))<=1&&g>=0){var y=a?(h-i)*g+i:(u-n)*g+n;return a?[t,y]:[y,t]}n=u,i=h;break;case o.C:u=r[l++],h=r[l++],c=r[l++],p=r[l++],d=r[l++],f=r[l++];var v=a?Eo(n,u,c,d,t,s):Eo(i,h,p,f,t,s);if(v>0)for(var m=0;m<v;m++){var _=s[m];if(_<=1&&_>=0){y=a?Ro(i,h,p,f,_):Ro(n,u,c,d,_);return a?[t,y]:[y,t]}}n=d,i=f}}},e}(Za),Bb=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e}(Eb),Vb=function(t){function e(e){var n=t.call(this,e)||this;return n.type="ec-polygon",n}return n(e,t),e.prototype.getDefaultShape=function(){return new Bb},e.prototype.buildPath=function(t,e){var n=e.points,i=e.stackedOnPoints,r=0,o=n.length/2,a=e.smoothMonotone;if(e.connectNulls){for(;o>0&&Rb(n[2*o-2],n[2*o-1]);o--);for(;r<o&&Rb(n[2*r],n[2*r+1]);r++);}for(;r<o;){var s=Nb(t,n,r,o,o,1,e.smooth,a,e.connectNulls);Nb(t,i,r+s-1,s,o,-1,e.stackedOnSmooth,a,e.connectNulls),r+=s+1,t.closePath()}},e}(Za);function Fb(t,e,n,i,r){var o=t.getArea(),a=o.x,s=o.y,l=o.width,u=o.height,h=n.get(["lineStyle","width"])||2;a-=h/2,s-=h/2,l+=h,u+=h,a=Math.floor(a),l=Math.round(l);var c=new os({shape:{x:a,y:s,width:l,height:u}});if(e){var p=t.getBaseAxis(),d=p.isHorizontal(),f=p.inverse;d?(f&&(c.shape.x+=l),c.shape.width=0):(f||(c.shape.y+=u),c.shape.height=0),Ru(c,{shape:{width:l,height:u,x:a,y:s}},n,null,i,"function"==typeof r?function(t){r(t,c)}:null)}return c}function Gb(t,e,n){var i=t.getArea(),r=ji(i.r0,1),o=ji(i.r,1),a=new Wl({shape:{cx:ji(t.cx,1),cy:ji(t.cy,1),r0:r,r:o,startAngle:i.startAngle,endAngle:i.endAngle,clockwise:i.clockwise}});e&&("angle"===t.getBaseAxis().dim?a.shape.endAngle=i.startAngle:a.shape.r=r,Ru(a,{shape:{endAngle:i.endAngle,r:o}},n));return a}function Hb(t,e,n,i,r){return t?"polar"===t.type?Gb(t,e,n):"cartesian2d"===t.type?Fb(t,e,n,i,r):null:null}function Wb(t,e){return t.type===e}function Yb(t,e){if(t.length===e.length){for(var n=0;n<t.length;n++)if(t[n]!==e[n])return;return!0}}function Xb(t){for(var e=1/0,n=1/0,i=-1/0,r=-1/0,o=0;o<t.length;){var a=t[o++],s=t[o++];isNaN(a)||(e=Math.min(a,e),i=Math.max(a,i)),isNaN(s)||(n=Math.min(s,n),r=Math.max(s,r))}return[[e,n],[i,r]]}function Ub(t,e){var n=Xb(t),i=n[0],r=n[1],o=Xb(e),a=o[0],s=o[1];return Math.max(Math.abs(i[0]-a[0]),Math.abs(i[1]-a[1]),Math.abs(r[0]-s[0]),Math.abs(r[1]-s[1]))}function Zb(t){return"number"==typeof t?t:t?.5:0}function jb(t,e,n){for(var i=e.getBaseAxis(),r="x"===i.dim||"radius"===i.dim?0:1,o=[],a=0,s=[],l=[],u=[];a<t.length-2;a+=2)switch(u[0]=t[a+2],u[1]=t[a+3],l[0]=t[a],l[1]=t[a+1],o.push(l[0],l[1]),n){case"end":s[r]=u[r],s[1-r]=l[1-r],o.push(s[0],s[1]);break;case"middle":var h=(l[r]+u[r])/2,c=[];s[r]=c[r]=h,s[1-r]=l[1-r],c[1-r]=u[1-r],o.push(s[0],s[1]),o.push(c[0],c[1]);break;default:s[r]=l[r],s[1-r]=u[1-r],o.push(s[0],s[1])}return o.push(t[a++],t[a++]),o}function qb(t,e,n){var i=t.get("showAllSymbol"),r="auto"===i;if(!i||r){var o=n.getAxesByScale("ordinal")[0];if(o&&(!r||!function(t,e){var n=t.getExtent(),i=Math.abs(n[1]-n[0])/t.scale.count();isNaN(i)&&(i=0);for(var r=e.count(),o=Math.max(1,Math.round(r/5)),a=0;a<r;a+=o)if(1.5*bb.getSymbolSize(e,a)[t.isHorizontal()?1:0]>i)return!1;return!0}(o,e))){var a=e.mapDimension(o.dim),s={};return P(o.getViewLabels(),(function(t){var e=o.scale.getRawOrdinalNumber(t.tickValue);s[e]=1})),function(t){return!s.hasOwnProperty(e.get(a,t))}}}}function Kb(t,e){return[t[2*e],t[2*e+1]]}function $b(t,e,n,i){if(Wb(e,"cartesian2d")){var r=i.getModel("endLabel"),o=r.get("show"),a=r.get("valueAnimation"),s=i.getData(),l={lastFrameIndex:0},u=o?function(n,i){t._endLabelOnDuring(n,i,s,l,a,r,e)}:null,h=e.getBaseAxis().isHorizontal(),c=Fb(e,n,i,(function(){var e=t._endLabel;e&&n&&null!=l.originalX&&e.attr({x:l.originalX,y:l.originalY})}),u);if(!i.get("clip",!0)){var p=c.shape,d=Math.max(p.width,p.height);h?(p.y-=d,p.height+=2*d):(p.x-=d,p.width+=2*d)}return u&&u(1,c),c}return Gb(e,n,i)}var Jb=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.init=function(){var t=new zi,e=new Tb;this.group.add(e.group),this._symbolDraw=e,this._lineGroup=t},e.prototype.render=function(t,e,n){var i=this,r=t.coordinateSystem,o=this.group,a=t.getData(),s=t.getModel("lineStyle"),l=t.getModel("areaStyle"),u=a.getLayout("points")||[],h="polar"===r.type,c=this._coordSys,p=this._symbolDraw,d=this._polyline,f=this._polygon,g=this._lineGroup,y=t.get("animation"),v=!l.isEmpty(),m=l.get("origin"),_=Cb(r,a,m),x=v&&function(t,e,n){if(!n.valueDim)return[];for(var i=e.count(),r=kb(2*i),o=0;o<i;o++){var a=Ab(n,t,e,o);r[2*o]=a[0],r[2*o+1]=a[1]}return r}(r,a,_),b=t.get("showSymbol"),w=b&&!h&&qb(t,a,r),S=this._data;S&&S.eachItemGraphicEl((function(t,e){t.__temp&&(o.remove(t),S.setItemGraphicEl(e,null))})),b||p.remove(),o.add(g);var M,I=!h&&t.get("step");r&&r.getArea&&t.get("clip",!0)&&(null!=(M=r.getArea()).width?(M.x-=.1,M.y-=.1,M.width+=.2,M.height+=.2):M.r0&&(M.r0-=.5,M.r+=.5)),this._clipShapeForSymbol=M;var C=function(t,e){var n=t.getVisual("visualMeta");if(n&&n.length&&t.count()&&"cartesian2d"===e.type){for(var i,r,o=n.length-1;o>=0;o--){var a=n[o].dimension,s=t.dimensions[a],l=t.getDimensionInfo(s);if("x"===(i=l&&l.coordDim)||"y"===i){r=n[o];break}}if(r){var u=e.getAxis(i),h=O(r.stops,(function(t){return{offset:0,coord:u.toGlobalCoord(u.dataToCoord(t.value)),color:t.color}})),c=h.length,p=r.outerColors.slice();c&&h[0].coord>h[c-1].coord&&(h.reverse(),p.reverse());var d=h[0].coord-10,f=h[c-1].coord+10,g=f-d;if(g<.001)return"transparent";P(h,(function(t){t.offset=(t.coord-d)/g})),h.push({offset:c?h[c-1].offset:.5,color:p[1]||"transparent"}),h.unshift({offset:c?h[0].offset:.5,color:p[0]||"transparent"});var y=new uu(0,0,0,0,h,!0);return y[i]=d,y[i+"2"]=f,y}}}(a,r)||a.getVisual("style")[a.getVisual("drawType")];d&&c.type===r.type&&I===this._step?(v&&!f?f=this._newPolygon(u,x):f&&!v&&(g.remove(f),f=this._polygon=null),h||this._initOrUpdateEndLabel(t,r,bc(C)),g.setClipPath($b(this,r,!1,t)),b&&p.updateData(a,{isIgnore:w,clipShape:M,disableAnimation:!0,getSymbolPoint:function(t){return[u[2*t],u[2*t+1]]}}),Yb(this._stackedOnPoints,x)&&Yb(this._points,u)||(y?this._doUpdateAnimation(a,x,r,n,I,m):(I&&(u=jb(u,r,I),x&&(x=jb(x,r,I))),d.setShape({points:u}),f&&f.setShape({points:u,stackedOnPoints:x})))):(b&&p.updateData(a,{isIgnore:w,clipShape:M,disableAnimation:!0,getSymbolPoint:function(t){return[u[2*t],u[2*t+1]]}}),y&&this._initSymbolLabelAnimation(a,r,M),I&&(u=jb(u,r,I),x&&(x=jb(x,r,I))),d=this._newPolyline(u),v&&(f=this._newPolygon(u,x)),h||this._initOrUpdateEndLabel(t,r,bc(C)),g.setClipPath($b(this,r,!0,t)));var A=t.get(["emphasis","focus"]),D=t.get(["emphasis","blurScope"]);(d.useStyle(T(s.getLineStyle(),{fill:"none",stroke:C,lineJoin:"bevel"})),nl(d,t,"lineStyle"),d.style.lineWidth>0&&"bolder"===t.get(["emphasis","lineStyle","width"]))&&(d.getState("emphasis").style.lineWidth=d.style.lineWidth+1);ys(d).seriesIndex=t.seriesIndex,Js(d,A,D);var L=Zb(t.get("smooth")),k=t.get("smoothMonotone"),R=t.get("connectNulls");if(d.setShape({smooth:L,smoothMonotone:k,connectNulls:R}),f){var N=a.getCalculationInfo("stackedOnSeries"),E=0;f.useStyle(T(l.getAreaStyle(),{fill:C,opacity:.7,lineJoin:"bevel",decal:a.getVisual("style").decal})),N&&(E=Zb(N.get("smooth"))),f.setShape({smooth:L,stackedOnSmooth:E,smoothMonotone:k,connectNulls:R}),nl(f,t,"areaStyle"),ys(f).seriesIndex=t.seriesIndex,Js(f,A,D)}var z=function(t){i._changePolyState(t)};a.eachItemGraphicEl((function(t){t&&(t.onHoverStateChange=z)})),this._polyline.onHoverStateChange=z,this._data=a,this._coordSys=r,this._stackedOnPoints=x,this._points=u,this._step=I,this._valueOrigin=m},e.prototype.dispose=function(){},e.prototype.highlight=function(t,e,n,i){var r=t.getData(),o=Dr(r,i);if(this._changePolyState("emphasis"),!(o instanceof Array)&&null!=o&&o>=0){var a=r.getLayout("points"),s=r.getItemGraphicEl(o);if(!s){var l=a[2*o],u=a[2*o+1];if(isNaN(l)||isNaN(u))return;if(this._clipShapeForSymbol&&!this._clipShapeForSymbol.contain(l,u))return;(s=new bb(r,o)).x=l,s.y=u,s.setZ(t.get("zlevel"),t.get("z")),s.__temp=!0,r.setItemGraphicEl(o,s),s.stopSymbolAnimation(!0),this.group.add(s)}s.highlight()}else yf.prototype.highlight.call(this,t,e,n,i)},e.prototype.downplay=function(t,e,n,i){var r=t.getData(),o=Dr(r,i);if(this._changePolyState("normal"),null!=o&&o>=0){var a=r.getItemGraphicEl(o);a&&(a.__temp?(r.setItemGraphicEl(o,null),this.group.remove(a)):a.downplay())}else yf.prototype.downplay.call(this,t,e,n,i)},e.prototype._changePolyState=function(t){var e=this._polygon;Vs(this._polyline,t),e&&Vs(e,t)},e.prototype._newPolyline=function(t){var e=this._polyline;return e&&this._lineGroup.remove(e),e=new zb({shape:{points:t},segmentIgnoreThreshold:2,z2:10}),this._lineGroup.add(e),this._polyline=e,e},e.prototype._newPolygon=function(t,e){var n=this._polygon;return n&&this._lineGroup.remove(n),n=new Vb({shape:{points:t,stackedOnPoints:e},segmentIgnoreThreshold:2}),this._lineGroup.add(n),this._polygon=n,n},e.prototype._initSymbolLabelAnimation=function(t,e,n){var i,r,o=e.getBaseAxis(),a=o.inverse;"cartesian2d"===e.type?(i=o.isHorizontal(),r=!1):"polar"===e.type&&(i="angle"===o.dim,r=!0);var s=t.hostModel,l=s.get("animationDuration");"function"==typeof l&&(l=l(null));var u=s.get("animationDelay")||0,h="function"==typeof u?u(null):u;t.eachItemGraphicEl((function(t,o){var s=t;if(s){var c=[t.x,t.y],p=void 0,d=void 0,f=void 0;if(r){var g=n,y=e.pointToCoord(c);i?(p=g.startAngle,d=g.endAngle,f=-y[1]/180*Math.PI):(p=g.r0,d=g.r,f=y[0])}else{var v=n;i?(p=v.x,d=v.x+v.width,f=t.x):(p=v.y+v.height,d=v.y,f=t.y)}var m=d===p?0:(f-p)/(d-p);a&&(m=1-m);var _="function"==typeof u?u(o):l*m+h,x=s.getSymbolPath(),b=x.getTextContent();s.attr({scaleX:0,scaleY:0}),s.animateTo({scaleX:1,scaleY:1},{duration:200,delay:_}),b&&b.animateFrom({style:{opacity:0}},{duration:300,delay:_}),x.disableLabelAnimation=!0}}))},e.prototype._initOrUpdateEndLabel=function(t,e,n){var i=t.getModel("endLabel");if(i.get("show")){var r=t.getData(),o=this._polyline,a=this._endLabel;a||((a=this._endLabel=new ls({z2:200})).ignoreClip=!0,o.setTextContent(this._endLabel),o.disableLabelAnimation=!0);var s=function(t){for(var e,n,i=t.length/2;i>0&&(e=t[2*i-2],n=t[2*i-1],isNaN(e)||isNaN(n));i--);return i-1}(r.getLayout("points"));s>=0&&(th(o,eh(t,"endLabel"),{inheritColor:n,labelFetcher:t,labelDataIndex:s,defaultText:function(t,e,n){return null!=n?xb(r,n):_b(r,t)},enableTextSetter:!0},function(t,e){var n=e.getBaseAxis(),i=n.isHorizontal(),r=n.inverse,o=i?r?"right":"left":"center",a=i?"middle":r?"top":"bottom";return{normal:{align:t.get("align")||o,verticalAlign:t.get("verticalAlign")||a}}}(i,e)),o.textConfig.position=null)}else this._endLabel&&(this._polyline.removeTextContent(),this._endLabel=null)},e.prototype._endLabelOnDuring=function(t,e,n,i,r,o,a){var s=this._endLabel,l=this._polyline;if(s){t<1&&null==i.originalX&&(i.originalX=s.x,i.originalY=s.y);var u=n.getLayout("points"),h=n.hostModel,c=h.get("connectNulls"),p=o.get("precision"),d=o.get("distance")||0,f=a.getBaseAxis(),g=f.isHorizontal(),y=f.inverse,v=e.shape,m=y?g?v.x:v.y+v.height:g?v.x+v.width:v.y,_=(g?d:0)*(y?-1:1),x=(g?0:-d)*(y?-1:1),b=g?"x":"y",w=function(t,e,n){for(var i,r,o=t.length/2,a="x"===n?0:1,s=0,l=-1,u=0;u<o;u++)if(r=t[2*u+a],!isNaN(r)&&!isNaN(t[2*u+1-a]))if(0!==u){if(i<=e&&r>=e||i>=e&&r<=e){l=u;break}s=u,i=r}else i=r;return{range:[s,l],t:(e-i)/(r-i)}}(u,m,b),S=w.range,M=S[1]-S[0],I=void 0;if(M>=1){if(M>1&&!c){var T=Kb(u,S[0]);s.attr({x:T[0]+_,y:T[1]+x}),r&&(I=h.getRawValue(S[0]))}else{(T=l.getPointOn(m,b))&&s.attr({x:T[0]+_,y:T[1]+x});var C=h.getRawValue(S[0]),A=h.getRawValue(S[1]);r&&(I=Br(n,p,C,A,w.t))}i.lastFrameIndex=S[0]}else{var D=1===t||i.lastFrameIndex>0?S[0]:0;T=Kb(u,D);r&&(I=h.getRawValue(D)),s.attr({x:T[0]+_,y:T[1]+x})}r&&uh(s).setLabelText(I)}},e.prototype._doUpdateAnimation=function(t,e,n,i,r,o){var a=this._polyline,s=this._polygon,l=t.hostModel,u=function(t,e,n,i,r,o,a,s){for(var l=function(t,e){var n=[];return e.diff(t).add((function(t){n.push({cmd:"+",idx:t})})).update((function(t,e){n.push({cmd:"=",idx:e,idx1:t})})).remove((function(t){n.push({cmd:"-",idx:t})})).execute(),n}(t,e),u=[],h=[],c=[],p=[],d=[],f=[],g=[],y=Cb(r,e,a),v=Cb(o,t,s),m=t.getLayout("points")||[],_=e.getLayout("points")||[],x=0;x<l.length;x++){var b=l[x],w=!0,S=void 0,M=void 0;switch(b.cmd){case"=":S=2*b.idx,M=2*b.idx1;var I=m[S],T=m[S+1],C=_[M],A=_[M+1];(isNaN(I)||isNaN(T))&&(I=C,T=A),u.push(I,T),h.push(C,A),c.push(n[S],n[S+1]),p.push(i[M],i[M+1]),g.push(e.getRawIndex(b.idx1));break;case"+":var D=b.idx,L=y.dataDimsForPoint,k=r.dataToPoint([e.get(L[0],D),e.get(L[1],D)]);M=2*D,u.push(k[0],k[1]),h.push(_[M],_[M+1]);var P=Ab(y,r,e,D);c.push(P[0],P[1]),p.push(i[M],i[M+1]),g.push(e.getRawIndex(D));break;case"-":var O=b.idx,R=t.getRawIndex(O),N=v.dataDimsForPoint;if(S=2*O,R!==O){var E=o.dataToPoint([t.get(N[0],O),t.get(N[1],O)]),z=Ab(v,o,t,O);u.push(m[S],m[S+1]),h.push(E[0],E[1]),c.push(n[S],n[S+1]),p.push(z[0],z[1]),g.push(R)}else w=!1}w&&(d.push(b),f.push(f.length))}f.sort((function(t,e){return g[t]-g[e]}));var B=u.length,V=kb(B),F=kb(B),G=kb(B),H=kb(B),W=[];for(x=0;x<f.length;x++){var Y=f[x],X=2*x,U=2*Y;V[X]=u[U],V[X+1]=u[U+1],F[X]=h[U],F[X+1]=h[U+1],G[X]=c[U],G[X+1]=c[U+1],H[X]=p[U],H[X+1]=p[U+1],W[x]=d[Y]}return{current:V,next:F,stackedOnCurrent:G,stackedOnNext:H,status:W}}(this._data,t,this._stackedOnPoints,e,this._coordSys,n,this._valueOrigin,o),h=u.current,c=u.stackedOnCurrent,p=u.next,d=u.stackedOnNext;if(r&&(h=jb(u.current,n,r),c=jb(u.stackedOnCurrent,n,r),p=jb(u.next,n,r),d=jb(u.stackedOnNext,n,r)),Ub(h,p)>3e3||s&&Ub(c,d)>3e3)return a.setShape({points:p}),void(s&&s.setShape({points:p,stackedOnPoints:d}));a.shape.__points=u.current,a.shape.points=h;var f={shape:{points:p}};u.current!==h&&(f.shape.__points=u.next),a.stopAnimation(),Ou(a,f,l),s&&(s.setShape({points:h,stackedOnPoints:c}),s.stopAnimation(),Ou(s,{shape:{stackedOnPoints:d}},l),a.shape.points!==s.shape.points&&(s.shape.points=a.shape.points));for(var g=[],y=u.status,v=0;v<y.length;v++){if("="===y[v].cmd){var m=t.getItemGraphicEl(y[v].idx1);m&&g.push({el:m,ptIdx:v})}}a.animators&&a.animators.length&&a.animators[0].during((function(){s&&s.dirtyShape();for(var t=a.shape.__points,e=0;e<g.length;e++){var n=g[e].el,i=2*g[e].ptIdx;n.x=t[i],n.y=t[i+1],n.markRedraw()}}))},e.prototype.remove=function(t){var e=this.group,n=this._data;this._lineGroup.removeAll(),this._symbolDraw.remove(!0),n&&n.eachItemGraphicEl((function(t,i){t.__temp&&(e.remove(t),n.setItemGraphicEl(i,null))})),this._polyline=this._polygon=this._coordSys=this._points=this._stackedOnPoints=this._endLabel=this._data=null},e.type="line",e}(yf);function Qb(t,e){return{seriesType:t,plan:df(),reset:function(t){var n=t.getData(),i=t.coordinateSystem,r=t.pipelineContext,o=e||r.large;if(i){var a=O(i.dimensions,(function(t){return n.mapDimension(t)})).slice(0,2),s=a.length,l=n.getCalculationInfo("stackResultDimension");Fm(n,a[0])&&(a[0]=l),Fm(n,a[1])&&(a[1]=l);var u=n.getDimensionInfo(a[0]),h=n.getDimensionInfo(a[1]),c=u&&u.index,p=h&&h.index;return s&&{progress:function(t,e){for(var n=t.end-t.start,r=o&&kb(n*s),a=[],l=[],u=t.start,h=0;u<t.end;u++){var d=void 0;if(1===s){var f=e.getByDimIdx(c,u);d=i.dataToPoint(f,null,l)}else a[0]=e.getByDimIdx(c,u),a[1]=e.getByDimIdx(p,u),d=i.dataToPoint(a,null,l);o?(r[h++]=d[0],r[h++]=d[1]):e.setItemLayout(u,d.slice())}o&&e.setLayout("points",r)}}}}}}var tw={average:function(t){for(var e=0,n=0,i=0;i<t.length;i++)isNaN(t[i])||(e+=t[i],n++);return 0===n?NaN:e/n},sum:function(t){for(var e=0,n=0;n<t.length;n++)e+=t[n]||0;return e},max:function(t){for(var e=-1/0,n=0;n<t.length;n++)t[n]>e&&(e=t[n]);return isFinite(e)?e:NaN},min:function(t){for(var e=1/0,n=0;n<t.length;n++)t[n]<e&&(e=t[n]);return isFinite(e)?e:NaN},nearest:function(t){return t[0]}},ew=function(t){return Math.round(t.length/2)};function nw(t){return{seriesType:t,reset:function(t,e,n){var i=t.getData(),r=t.get("sampling"),o=t.coordinateSystem,a=i.count();if(a>10&&"cartesian2d"===o.type&&r){var s=o.getBaseAxis(),l=o.getOtherAxis(s),u=s.getExtent(),h=n.getDevicePixelRatio(),c=Math.abs(u[1]-u[0])*(h||1),p=Math.round(a/c);if(p>1){"lttb"===r&&t.setData(i.lttbDownSample(i.mapDimension(l.dim),1/p));var d=void 0;"string"==typeof r?d=tw[r]:"function"==typeof r&&(d=r),d&&t.setData(i.downSample(i.mapDimension(l.dim),1/p,d,ew))}}}}}var iw=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this,{useEncodeDefaulter:!0})},e.prototype.getMarkerPosition=function(t){var e=this.coordinateSystem;if(e){var n=e.dataToPoint(e.clampData(t)),i=this.getData(),r=i.getLayout("offset"),o=i.getLayout("size");return n[e.getBaseAxis().isHorizontal()?0:1]+=r+o/2,n}return[NaN,NaN]},e.type="series.__base_bar__",e.defaultOption={zlevel:0,z:2,coordinateSystem:"cartesian2d",legendHoverLink:!0,barMinHeight:0,barMinAngle:0,large:!1,largeThreshold:400,progressive:3e3,progressiveChunkMode:"mod"},e}(rf);rf.registerClass(iw);var rw=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.getInitialData=function(){return Hm(this.getSource(),this,{useEncodeDefaulter:!0,createInvertedIndices:!!this.get("realtimeSort",!0)||null})},e.prototype.getProgressive=function(){return!!this.get("large")&&this.get("progressive")},e.prototype.getProgressiveThreshold=function(){var t=this.get("progressiveThreshold"),e=this.get("largeThreshold");return e>t&&(t=e),t},e.prototype.brushSelector=function(t,e,n){return n.rect(e.getItemLayout(t))},e.type="series.bar",e.dependencies=["grid","polar"],e.defaultOption=Th(iw.defaultOption,{clip:!0,roundCap:!1,showBackground:!1,backgroundStyle:{color:"rgba(180, 180, 180, 0.2)",borderColor:null,borderWidth:0,borderType:"solid",borderRadius:0,shadowBlur:0,shadowColor:null,shadowOffsetX:0,shadowOffsetY:0,opacity:1},select:{itemStyle:{borderColor:"#212121"}},realtimeSort:!1}),e}(iw),ow=function(){this.cx=0,this.cy=0,this.r0=0,this.r=0,this.startAngle=0,this.endAngle=2*Math.PI,this.clockwise=!0},aw=function(t){function e(e){var n=t.call(this,e)||this;return n.type="sausage",n}return n(e,t),e.prototype.getDefaultShape=function(){return new ow},e.prototype.buildPath=function(t,e){var n=e.cx,i=e.cy,r=Math.max(e.r0||0,0),o=Math.max(e.r,0),a=.5*(o-r),s=r+a,l=e.startAngle,u=e.endAngle,h=e.clockwise,c=Math.cos(l),p=Math.sin(l),d=Math.cos(u),f=Math.sin(u);(h?u-l<2*Math.PI:l-u<2*Math.PI)&&(t.moveTo(c*r+n,p*r+i),t.arc(c*s+n,p*s+i,a,-Math.PI+l,l,!h)),t.arc(n,i,o,l,u,!h),t.moveTo(d*o+n,f*o+i),t.arc(d*s+n,f*s+i,a,u-2*Math.PI,u-Math.PI,!h),0!==r&&(t.arc(n,i,r,u,l,h),t.moveTo(c*r+n,f*r+i)),t.closePath()},e}(Za),sw=["itemStyle","borderWidth"],lw=["itemStyle","borderRadius"],uw=[0,0],hw=Math.max,cw=Math.min;var pw=function(t){function e(){var n=t.call(this)||this;return n.type=e.type,n._isFirstFrame=!0,n}return n(e,t),e.prototype.render=function(t,e,n,i){this._model=t,this._removeOnRenderedListener(n),this._updateDrawMode(t);var r=t.get("coordinateSystem");("cartesian2d"===r||"polar"===r)&&(this._isLargeDraw?this._renderLarge(t,e,n):this._renderNormal(t,e,n,i))},e.prototype.incrementalPrepareRender=function(t){this._clear(),this._updateDrawMode(t),this._updateLargeClip(t)},e.prototype.incrementalRender=function(t,e){this._incrementalRenderLarge(t,e)},e.prototype._updateDrawMode=function(t){var e=t.pipelineContext.large;null!=this._isLargeDraw&&e===this._isLargeDraw||(this._isLargeDraw=e,this._clear())},e.prototype._renderNormal=function(t,e,n,i){var r,o=this.group,a=t.getData(),s=this._data,l=t.coordinateSystem,u=l.getBaseAxis();"cartesian2d"===l.type?r=u.isHorizontal():"polar"===l.type&&(r="angle"===u.dim);var h=t.isAnimationEnabled()?t:null,c=function(t,e){var n=t.get("realtimeSort",!0),i=e.getBaseAxis();0;if(n&&"category"===i.type&&"cartesian2d"===e.type)return{baseAxis:i,otherAxis:e.getOtherAxis(i)}}(t,l);c&&this._enableRealtimeSort(c,a,n);var p=t.get("clip",!0)||c,d=function(t,e){var n=t.getArea&&t.getArea();if(Wb(t,"cartesian2d")){var i=t.getBaseAxis();if("category"!==i.type||!i.onBand){var r=e.getLayout("bandWidth");i.isHorizontal()?(n.x-=r,n.width+=2*r):(n.y-=r,n.height+=2*r)}}return n}(l,a);o.removeClipPath();var f=t.get("roundCap",!0),g=t.get("showBackground",!0),y=t.getModel("backgroundStyle"),v=y.get("borderRadius")||0,m=[],_=this._backgroundEls,x=i&&i.isInitSort,b=i&&"changeAxisOrder"===i.type;function w(t){var e=yw[l.type](a,t),n=function(t,e,n){return new("polar"===t.type?Wl:os)({shape:ww(e,n,t),silent:!0,z2:0})}(l,r,e);return n.useStyle(y.getItemStyle()),"cartesian2d"===l.type&&n.setShape("r",v),m[t]=n,n}a.diff(s).add((function(e){var n=a.getItemModel(e),i=yw[l.type](a,e,n);if(g&&w(e),a.hasValue(e)){var s=!1;p&&(s=dw[l.type](d,i));var y=fw[l.type](t,a,e,i,r,h,u.model,!1,f);vw(y,a,e,n,i,t,r,"polar"===l.type),x?y.attr({shape:i}):c?gw(c,h,y,i,e,r,!1,!1):Ru(y,{shape:i},t,e),a.setItemGraphicEl(e,y),o.add(y),y.ignore=s}})).update((function(e,n){var i=a.getItemModel(e),S=yw[l.type](a,e,i);if(g){var M=void 0;0===_.length?M=w(n):((M=_[n]).useStyle(y.getItemStyle()),"cartesian2d"===l.type&&M.setShape("r",v),m[e]=M);var I=yw[l.type](a,e);Ou(M,{shape:ww(r,I,l)},h,e)}var T=s.getItemGraphicEl(n);if(!a.hasValue(e))return o.remove(T),void(T=null);var C=!1;p&&(C=dw[l.type](d,S))&&o.remove(T),T||(T=fw[l.type](t,a,e,S,r,h,u.model,!!T,f)),b||vw(T,a,e,i,S,t,r,"polar"===l.type),x?T.attr({shape:S}):c?gw(c,h,T,S,e,r,!0,b):Ou(T,{shape:S},t,e,null),a.setItemGraphicEl(e,T),T.ignore=C,o.add(T)})).remove((function(e){var n=s.getItemGraphicEl(e);n&&zu(n,t,e)})).execute();var S=this._backgroundGroup||(this._backgroundGroup=new zi);S.removeAll();for(var M=0;M<m.length;++M)S.add(m[M]);o.add(S),this._backgroundEls=m,this._data=a},e.prototype._renderLarge=function(t,e,n){this._clear(),xw(t,this.group),this._updateLargeClip(t)},e.prototype._incrementalRenderLarge=function(t,e){this._removeBackground(),xw(e,this.group,!0)},e.prototype._updateLargeClip=function(t){var e=t.get("clip",!0)?Hb(t.coordinateSystem,!1,t):null;e?this.group.setClipPath(e):this.group.removeClipPath()},e.prototype._enableRealtimeSort=function(t,e,n){var i=this;if(e.count()){var r=t.baseAxis;if(this._isFirstFrame)this._dispatchInitSort(e,t,n),this._isFirstFrame=!1;else{var o=function(t){var n=e.getItemGraphicEl(t);if(n){var i=n.shape;return(r.isHorizontal()?Math.abs(i.height):Math.abs(i.width))||0}return 0};this._onRendered=function(){i._updateSortWithinSameData(e,o,r,n)},n.getZr().on("rendered",this._onRendered)}}},e.prototype._dataSort=function(t,e,n){var i=[];return t.each(t.mapDimension(e.dim),(function(t,e){var r=n(e);r=null==r?NaN:r,i.push({dataIndex:e,mappedValue:r,ordinalNumber:t})})),i.sort((function(t,e){return e.mappedValue-t.mappedValue})),{ordinalNumbers:O(i,(function(t){return t.ordinalNumber}))}},e.prototype._isOrderChangedWithinSameData=function(t,e,n){for(var i=n.scale,r=t.mapDimension(n.dim),o=Number.MAX_VALUE,a=0,s=i.getOrdinalMeta().categories.length;a<s;++a){var l=t.rawIndexOf(r,i.getRawOrdinalNumber(a)),u=l<0?Number.MIN_VALUE:e(t.indexOfRawIndex(l));if(u>o)return!0;o=u}return!1},e.prototype._isOrderDifferentInView=function(t,e){for(var n=e.scale,i=n.getExtent(),r=Math.max(0,i[0]),o=Math.min(i[1],n.getOrdinalMeta().categories.length-1);r<=o;++r)if(t.ordinalNumbers[r]!==n.getRawOrdinalNumber(r))return!0},e.prototype._updateSortWithinSameData=function(t,e,n,i){if(this._isOrderChangedWithinSameData(t,e,n)){var r=this._dataSort(t,n,e);this._isOrderDifferentInView(r,n)&&(this._removeOnRenderedListener(i),i.dispatchAction({type:"changeAxisOrder",componentType:n.dim+"Axis",axisId:n.index,sortInfo:r}))}},e.prototype._dispatchInitSort=function(t,e,n){var i=e.baseAxis,r=this._dataSort(t,i,(function(n){return t.get(t.mapDimension(e.otherAxis.dim),n)}));n.dispatchAction({type:"changeAxisOrder",componentType:i.dim+"Axis",isInitSort:!0,axisId:i.index,sortInfo:r,animation:{duration:0}})},e.prototype.remove=function(t,e){this._clear(this._model),this._removeOnRenderedListener(e)},e.prototype.dispose=function(t,e){this._removeOnRenderedListener(e)},e.prototype._removeOnRenderedListener=function(t){this._onRendered&&(t.getZr().off("rendered",this._onRendered),this._onRendered=null)},e.prototype._clear=function(t){var e=this.group,n=this._data;t&&t.isAnimationEnabled()&&n&&!this._isLargeDraw?(this._removeBackground(),this._backgroundEls=[],n.eachItemGraphicEl((function(e){zu(e,t,ys(e).dataIndex)}))):e.removeAll(),this._data=null,this._isFirstFrame=!0},e.prototype._removeBackground=function(){this.group.remove(this._backgroundGroup),this._backgroundGroup=null},e.type="bar",e}(yf),dw={cartesian2d:function(t,e){var n=e.width<0?-1:1,i=e.height<0?-1:1;n<0&&(e.x+=e.width,e.width=-e.width),i<0&&(e.y+=e.height,e.height=-e.height);var r=t.x+t.width,o=t.y+t.height,a=hw(e.x,t.x),s=cw(e.x+e.width,r),l=hw(e.y,t.y),u=cw(e.y+e.height,o),h=s<a,c=u<l;return e.x=h&&a>r?s:a,e.y=c&&l>o?u:l,e.width=h?0:s-a,e.height=c?0:u-l,n<0&&(e.x+=e.width,e.width=-e.width),i<0&&(e.y+=e.height,e.height=-e.height),h||c},polar:function(t,e){var n=e.r0<=e.r?1:-1;if(n<0){var i=e.r;e.r=e.r0,e.r0=i}var r=cw(e.r,t.r),o=hw(e.r0,t.r0);e.r=r,e.r0=o;var a=r-o<0;if(n<0){i=e.r;e.r=e.r0,e.r0=i}return a}},fw={cartesian2d:function(t,e,n,i,r,o,a,s,l){var u=new os({shape:I({},i),z2:1});(u.__dataIndex=n,u.name="item",o)&&(u.shape[r?"height":"width"]=0);return u},polar:function(t,e,n,i,r,o,a,s,l){var u=i.startAngle<i.endAngle,h=new(!r&&l?aw:Wl)({shape:T({clockwise:u},i),z2:1});if(h.name="item",o){var c=r?"r":"endAngle",p={};h.shape[c]=r?0:i.startAngle,p[c]=i[c],(s?Ou:Ru)(h,{shape:p},o)}return h}};function gw(t,e,n,i,r,o,a,s){var l,u;o?(u={x:i.x,width:i.width},l={y:i.y,height:i.height}):(u={y:i.y,height:i.height},l={x:i.x,width:i.width}),s||(a?Ou:Ru)(n,{shape:l},e,r,null),(a?Ou:Ru)(n,{shape:u},e?t.baseAxis.model:null,r)}var yw={cartesian2d:function(t,e,n){var i=t.getItemLayout(e),r=n?function(t,e){var n=t.get(sw)||0,i=isNaN(e.width)?Number.MAX_VALUE:Math.abs(e.width),r=isNaN(e.height)?Number.MAX_VALUE:Math.abs(e.height);return Math.min(n,i,r)}(n,i):0,o=i.width>0?1:-1,a=i.height>0?1:-1;return{x:i.x+o*r/2,y:i.y+a*r/2,width:i.width-o*r,height:i.height-a*r}},polar:function(t,e,n){var i=t.getItemLayout(e);return{cx:i.cx,cy:i.cy,r0:i.r0,r:i.r,startAngle:i.startAngle,endAngle:i.endAngle}}};function vw(t,e,n,i,r,o,a,s){var l=e.getItemVisual(n,"style");s||t.setShape("r",i.get(lw)||0),t.useStyle(l);var u=i.getShallow("cursor");if(u&&t.attr("cursor",u),!s){var h=a?r.height>0?"bottom":"top":r.width>0?"left":"right",c=eh(i);th(t,c,{labelFetcher:o,labelDataIndex:n,defaultText:_b(o.getData(),n),inheritColor:l.fill,defaultOpacity:l.opacity,defaultOutsidePosition:h}),hh(t.getTextContent(),c,o.getRawValue(n),(function(t){return xb(e,t)}))}var p=i.getModel(["emphasis"]);Js(t,p.get("focus"),p.get("blurScope")),nl(t,i),function(t){return null!=t.startAngle&&null!=t.endAngle&&t.startAngle===t.endAngle}(r)&&(t.style.fill="none",t.style.stroke="none",P(t.states,(function(t){t.style&&(t.style.fill=t.style.stroke="none")})))}var mw=function(){},_w=function(t){function e(e){var n=t.call(this,e)||this;return n.type="largeBar",n}return n(e,t),e.prototype.getDefaultShape=function(){return new mw},e.prototype.buildPath=function(t,e){for(var n=e.points,i=this.__startPoint,r=this.__baseDimIdx,o=0;o<n.length;o+=2)i[r]=n[o+r],t.moveTo(i[0],i[1]),t.lineTo(n[o],n[o+1])},e}(Za);function xw(t,e,n){var i=t.getData(),r=[],o=i.getLayout("valueAxisHorizontal")?1:0;r[1-o]=i.getLayout("valueAxisStart");var a=i.getLayout("largeDataIndices"),s=i.getLayout("barWidth"),l=t.getModel("backgroundStyle");if(t.get("showBackground",!0)){var u=i.getLayout("largeBackgroundPoints"),h=[];h[1-o]=i.getLayout("backgroundStart");var c=new _w({shape:{points:u},incremental:!!n,silent:!0,z2:0});c.__startPoint=h,c.__baseDimIdx=o,c.__largeDataIndices=a,c.__barWidth=s,function(t,e,n){var i=e.get("borderColor")||e.get("color"),r=e.getItemStyle();t.useStyle(r),t.style.fill=null,t.style.stroke=i,t.style.lineWidth=n.getLayout("barWidth")}(c,l,i),e.add(c)}var p=new _w({shape:{points:i.getLayout("largePoints")},incremental:!!n});p.__startPoint=r,p.__baseDimIdx=o,p.__largeDataIndices=a,p.__barWidth=s,e.add(p),function(t,e,n){var i=n.getVisual("style");t.useStyle(I({},i)),t.style.fill=null,t.style.stroke=i.fill,t.style.lineWidth=n.getLayout("barWidth")}(p,0,i),ys(p).seriesIndex=t.seriesIndex,t.get("silent")||(p.on("mousedown",bw),p.on("mousemove",bw))}var bw=If((function(t){var e=function(t,e,n){var i=t.__baseDimIdx,r=1-i,o=t.shape.points,a=t.__largeDataIndices,s=Math.abs(t.__barWidth/2),l=t.__startPoint[r];uw[0]=e,uw[1]=n;for(var u=uw[i],h=uw[1-i],c=u-s,p=u+s,d=0,f=o.length/2;d<f;d++){var g=2*d,y=o[g+i],v=o[g+r];if(y>=c&&y<=p&&(l<=v?h>=l&&h<=v:h>=v&&h<=l))return a[d]}return-1}(this,t.offsetX,t.offsetY);ys(this).dataIndex=e>=0?e:null}),30,!1);function ww(t,e,n){if(Wb(n,"cartesian2d")){var i=e,r=n.getArea();return{x:t?i.x:r.x,y:t?r.y:i.y,width:t?i.width:r.width,height:t?r.height:i.height}}var o=e;return{cx:(r=n.getArea()).cx,cy:r.cy,r0:t?r.r0:o.r0,r:t?r.r:o.r,startAngle:t?o.startAngle:0,endAngle:t?o.endAngle:2*Math.PI}}var Sw=2*Math.PI,Mw=Math.PI/180;function Iw(t,e,n){e.eachSeriesByType(t,(function(t){var e=t.getData(),i=e.mapDimension("value"),r=function(t,e){return Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()})}(t,n),o=t.get("center"),a=t.get("radius");F(a)||(a=[0,a]),F(o)||(o=[o,o]);var s=Zi(r.width,n.getWidth()),l=Zi(r.height,n.getHeight()),u=Math.min(s,l),h=Zi(o[0],s)+r.x,c=Zi(o[1],l)+r.y,p=Zi(a[0],u/2),d=Zi(a[1],u/2),f=-t.get("startAngle")*Mw,g=t.get("minAngle")*Mw,y=0;e.each(i,(function(t){!isNaN(t)&&y++}));var v=e.getSum(i),m=Math.PI/(v||y)*2,_=t.get("clockwise"),x=t.get("roseType"),b=t.get("stillShowZeroSum"),w=e.getDataExtent(i);w[0]=0;var S=Sw,M=0,I=f,T=_?1:-1;if(e.setLayout({viewRect:r,r:d}),e.each(i,(function(t,n){var i;if(isNaN(t))e.setItemLayout(n,{angle:NaN,startAngle:NaN,endAngle:NaN,clockwise:_,cx:h,cy:c,r0:p,r:x?NaN:d});else{(i="area"!==x?0===v&&b?m:t*m:Sw/y)<g?(i=g,S-=g):M+=t;var r=I+T*i;e.setItemLayout(n,{angle:i,startAngle:I,endAngle:r,clockwise:_,cx:h,cy:c,r0:p,r:x?Ui(t,w,[p,d]):d}),I=r}})),S<Sw&&y)if(S<=.001){var C=Sw/y;e.each(i,(function(t,n){if(!isNaN(t)){var i=e.getItemLayout(n);i.angle=C,i.startAngle=f+T*n*C,i.endAngle=f+T*(n+1)*C}}))}else m=S/M,I=f,e.each(i,(function(t,n){if(!isNaN(t)){var i=e.getItemLayout(n),r=i.angle===g?g:t*m;i.startAngle=I,i.endAngle=I+T*r,I+=T*r}}))}))}function Tw(t){return{seriesType:t,reset:function(t,e){var n=e.findComponents({mainType:"legend"});if(n&&n.length){var i=t.getData();i.filterSelf((function(t){for(var e=i.getName(t),r=0;r<n.length;r++)if(!n[r].isSelected(e))return!1;return!0}))}}}}var Cw=Math.PI/180;function Aw(t,e,n,i,r,o,a,s,l,u){if(!(t.length<2)){for(var h=t.length,c=0;c<h;c++)if("outer"===t[c].position&&"labelLine"===t[c].labelAlignTo){var p=t[c].label.x-u;t[c].linePoints[1][0]+=p,t[c].label.x=u}Fg(t,l,l+a)&&function(t){for(var o={list:[],maxY:0},a={list:[],maxY:0},s=0;s<t.length;s++)if("none"===t[s].labelAlignTo){var l=t[s],u=l.label.y>n?a:o,h=Math.abs(l.label.y-n);if(h>u.maxY){var c=l.label.x-e-l.len2*r,p=i+l.len,f=Math.abs(c)<p?Math.sqrt(h*h/(1-c*c/p/p)):p;u.rB=f,u.maxY=h}u.list.push(l)}d(o),d(a)}(t)}function d(t){for(var o=t.rB,a=o*o,s=0;s<t.list.length;s++){var l=t.list[s],u=Math.abs(l.label.y-n),h=i+l.len,c=h*h,p=Math.sqrt((1-Math.abs(u*u/a))*c);l.label.x=e+(p+l.len2)*r}}}function Dw(t){return"center"===t.position}function Lw(t){var e,n,i=t.getData(),r=[],o=!1,a=(t.get("minShowLabelAngle")||0)*Cw,s=i.getLayout("viewRect"),l=i.getLayout("r"),u=s.width,h=s.x,c=s.y,p=s.height;function d(t){t.ignore=!0}i.each((function(t){var s=i.getItemGraphicEl(t),c=s.shape,p=s.getTextContent(),f=s.getTextGuideLine(),g=i.getItemModel(t),y=g.getModel("label"),v=y.get("position")||g.get(["emphasis","label","position"]),m=y.get("distanceToLabelLine"),_=y.get("alignTo"),x=Zi(y.get("edgeDistance"),u),b=y.get("bleedMargin"),w=g.getModel("labelLine"),S=w.get("length");S=Zi(S,u);var M=w.get("length2");if(M=Zi(M,u),Math.abs(c.endAngle-c.startAngle)<a)return P(p.states,d),void(p.ignore=!0);if(function(t){if(!t.ignore)return!0;for(var e in t.states)if(!1===t.states[e].ignore)return!0;return!1}(p)){var I,T,C,A,D=(c.startAngle+c.endAngle)/2,L=Math.cos(D),k=Math.sin(D);e=c.cx,n=c.cy;var O,R="inside"===v||"inner"===v;if("center"===v)I=c.cx,T=c.cy,A="center";else{var N=(R?(c.r+c.r0)/2*L:c.r*L)+e,E=(R?(c.r+c.r0)/2*k:c.r*k)+n;if(I=N+3*L,T=E+3*k,!R){var z=N+L*(S+l-c.r),B=E+k*(S+l-c.r),V=z+(L<0?-1:1)*M;I="edge"===_?L<0?h+x:h+u-x:V+(L<0?-m:m),T=B,C=[[N,E],[z,B],[V,B]]}A=R?"center":"edge"===_?L>0?"right":"left":L>0?"left":"right"}var F=y.get("rotate");if(O="number"==typeof F?F*(Math.PI/180):F?L<0?-D+Math.PI:-D:0,o=!!O,p.x=I,p.y=T,p.rotation=O,p.setStyle({verticalAlign:"middle"}),R){p.setStyle({align:A});var G=p.states.select;G&&(G.x+=p.x,G.y+=p.y)}else{var H=p.getBoundingRect().clone();H.applyTransform(p.getComputedTransform());var W=(p.style.margin||0)+2.1;H.y-=W/2,H.height+=W,r.push({label:p,labelLine:f,position:v,len:S,len2:M,minTurnAngle:w.get("minTurnAngle"),maxSurfaceAngle:w.get("maxSurfaceAngle"),surfaceNormal:new In(L,k),linePoints:C,textAlign:A,labelDistance:m,labelAlignTo:_,edgeDistance:x,bleedMargin:b,rect:H})}s.setTextConfig({inside:R})}})),!o&&t.get("avoidLabelOverlap")&&function(t,e,n,i,r,o,a,s){for(var l=[],u=[],h=Number.MAX_VALUE,c=-Number.MAX_VALUE,p=0;p<t.length;p++){var d=t[p].label;Dw(t[p])||(d.x<e?(h=Math.min(h,d.x),l.push(t[p])):(c=Math.max(c,d.x),u.push(t[p])))}for(Aw(u,e,n,i,1,0,o,0,s,c),Aw(l,e,n,i,-1,0,o,0,s,h),p=0;p<t.length;p++){var f=t[p];if(d=f.label,!Dw(f)){var g=f.linePoints;if(g){var y="edge"===f.labelAlignTo,v=f.rect.width,m=void 0;(m=y?d.x<e?g[2][0]-f.labelDistance-a-f.edgeDistance:a+r-f.edgeDistance-g[2][0]-f.labelDistance:d.x<e?d.x-a-f.bleedMargin:a+r-d.x-f.bleedMargin)<f.rect.width&&(f.label.style.width=m,"edge"===f.labelAlignTo&&(v=m));var _=g[1][0]-g[2][0];y?d.x<e?g[2][0]=a+f.edgeDistance+v+f.labelDistance:g[2][0]=a+r-f.edgeDistance-v-f.labelDistance:(d.x<e?g[2][0]=d.x+f.labelDistance:g[2][0]=d.x-f.labelDistance,g[1][0]=g[2][0]+_),g[1][1]=g[2][1]=d.y}}}}(r,e,n,l,u,p,h,c);for(var f=0;f<r.length;f++){var g=r[f],y=g.label,v=g.labelLine,m=isNaN(y.x)||isNaN(y.y);if(y){y.setStyle({align:g.textAlign}),m&&(P(y.states,d),y.ignore=!0);var _=y.states.select;_&&(_.x+=y.x,_.y+=y.y)}if(v){var x=g.linePoints;m||!x?(P(v.states,d),v.ignore=!0):(Og(x,g.minTurnAngle),Rg(x,g.surfaceNormal,g.maxSurfaceAngle),v.setShape({points:x}),y.__hostTarget.textGuideLineConfig={anchor:new In(x[0][0],x[0][1])})}}}function kw(t,e){var n=t.get("borderRadius");return null==n?null:(F(n)||(n=[n,n]),{innerCornerRadius:Yn(n[0],e.r0),cornerRadius:Yn(n[1],e.r)})}var Pw=function(t){function e(e,n,i){var r=t.call(this)||this;r.z2=2;var o=new $l,a=new ls;return r.setTextGuideLine(o),r.setTextContent(a),r.updateData(e,n,i,!0),r}return n(e,t),e.prototype.updateData=function(t,e,n,r){var o=this,a=t.hostModel,s=t.getItemModel(e),l=s.getModel("emphasis"),u=t.getItemLayout(e),h=I(kw(s.getModel("itemStyle"),u)||{},u);r?(o.setShape(h),"scale"===a.getShallow("animationType")?(o.shape.r=u.r0,Ru(o,{shape:{r:u.r}},a,e)):null!=n?(o.setShape({startAngle:n,endAngle:n}),Ru(o,{shape:{startAngle:u.startAngle,endAngle:u.endAngle}},a,e)):(o.shape.endAngle=u.startAngle,Ou(o,{shape:{endAngle:u.endAngle}},a,e))):Ou(o,{shape:h},a,e);o.useStyle(t.getItemVisual(e,"style")),nl(o,s);var c=(u.startAngle+u.endAngle)/2,p=a.get("selectedOffset"),d=Math.cos(c)*p,f=Math.sin(c)*p,g=s.getShallow("cursor");g&&o.attr("cursor",g),this._updateLabel(a,t,e),o.ensureState("emphasis").shape=i({r:u.r+(l.get("scale")&&l.get("scaleSize")||0)},kw(l.getModel("itemStyle"),u)),I(o.ensureState("select"),{x:d,y:f,shape:kw(s.getModel(["select","itemStyle"]),u)}),I(o.ensureState("blur"),{shape:kw(s.getModel(["blur","itemStyle"]),u)});var y=o.getTextGuideLine(),v=o.getTextContent();y&&I(y.ensureState("select"),{x:d,y:f}),I(v.ensureState("select"),{x:d,y:f}),Js(this,l.get("focus"),l.get("blurScope"))},e.prototype._updateLabel=function(t,e,n){var i,r=this,o=e.getItemModel(n),a=o.getModel("labelLine"),s=e.getItemVisual(n,"style"),l=s&&s.fill,u=s&&s.opacity;th(r,eh(o),{labelFetcher:e.hostModel,labelDataIndex:n,inheritColor:l,defaultOpacity:u,defaultText:t.getFormattedLabel(n,"normal")||e.getName(n)});var h=r.getTextContent();r.setTextConfig({position:null,rotation:null}),h.attr({z2:10});var c=t.get(["label","position"]);"outside"===c||"outer"===c?zg(this,Bg(o),{stroke:l,opacity:et(a.get(["lineStyle","opacity"]),u,1)}):null===(i=r.getTextGuideLine())||void 0===i||i.hide()},e}(Wl),Ow=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.ignoreLabelLineUpdate=!0,e}return n(e,t),e.prototype.init=function(){var t=new zi;this._sectorGroup=t},e.prototype.render=function(t,e,n,i){var r,o=t.getData(),a=this._data,s=this.group;if(!a&&o.count()>0){for(var l=o.getItemLayout(0),u=1;isNaN(l&&l.startAngle)&&u<o.count();++u)l=o.getItemLayout(u);l&&(r=l.startAngle)}o.diff(a).add((function(t){var e=new Pw(o,t,r);o.setItemGraphicEl(t,e),s.add(e)})).update((function(t,e){var n=a.getItemGraphicEl(e);n.updateData(o,t,r),n.off("click"),s.add(n),o.setItemGraphicEl(t,n)})).remove((function(e){zu(a.getItemGraphicEl(e),t,e)})).execute(),Lw(t),"expansion"!==t.get("animationTypeUpdate")&&(this._data=o)},e.prototype.dispose=function(){},e.prototype.containPoint=function(t,e){var n=e.getData().getItemLayout(0);if(n){var i=t[0]-n.cx,r=t[1]-n.cy,o=Math.sqrt(i*i+r*r);return o<=n.r&&o>=n.r0}},e.type="pie",e}(yf);function Rw(t,e,n){e=F(e)&&{coordDimensions:e}||I({},e);var i=t.getSource(),r=Nm(i,e),o=new Pm(r,t);return o.initData(i,n),o}var Nw=function(){function t(t,e){this._getDataWithEncodedVisual=t,this._getRawData=e}return t.prototype.getAllNames=function(){var t=this._getRawData();return t.mapArray(t.getName)},t.prototype.containName=function(t){return this._getRawData().indexOfName(t)>=0},t.prototype.indexOfName=function(t){return this._getDataWithEncodedVisual().indexOfName(t)},t.prototype.getItemVisual=function(t,e){return this._getDataWithEncodedVisual().getItemVisual(t,e)},t}(),Ew=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.useColorPaletteOnData=!0,e}return n(e,t),e.prototype.init=function(e){t.prototype.init.apply(this,arguments),this.legendVisualProvider=new Nw(B(this.getData,this),B(this.getRawData,this)),this._defaultLabelLine(e)},e.prototype.mergeOption=function(){t.prototype.mergeOption.apply(this,arguments)},e.prototype.getInitialData=function(){return Rw(this,{coordDimensions:["value"],encodeDefaulter:V(Qc,this)})},e.prototype.getDataParams=function(e){var n=this.getData(),i=t.prototype.getDataParams.call(this,e),r=[];return n.each(n.mapDimension("value"),(function(t){r.push(t)})),i.percent=Qi(r,e,n.hostModel.get("percentPrecision")),i.$vars.push("percent"),i},e.prototype._defaultLabelLine=function(t){xr(t,"labelLine",["show"]);var e=t.labelLine,n=t.emphasis.labelLine;e.show=e.show&&t.label.show,n.show=n.show&&t.emphasis.label.show},e.type="series.pie",e.defaultOption={zlevel:0,z:2,legendHoverLink:!0,center:["50%","50%"],radius:[0,"75%"],clockwise:!0,startAngle:90,minAngle:0,minShowLabelAngle:0,selectedOffset:10,percentPrecision:2,stillShowZeroSum:!0,left:0,top:0,right:0,bottom:0,width:null,height:null,label:{rotate:0,show:!0,overflow:"truncate",position:"outer",alignTo:"none",edgeDistance:"25%",bleedMargin:10,distanceToLabelLine:5},labelLine:{show:!0,length:15,length2:15,smooth:!1,minTurnAngle:90,maxSurfaceAngle:90,lineStyle:{width:1,type:"solid"}},itemStyle:{borderWidth:1},labelLayout:{hideOverlap:!0},emphasis:{scale:!0,scaleSize:5},avoidLabelOverlap:!0,animationType:"expansion",animationDuration:1e3,animationTypeUpdate:"transition",animationEasingUpdate:"cubicInOut",animationDurationUpdate:500,animationEasing:"cubicInOut"},e}(rf);var zw=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.hasSymbolVisual=!0,n}return n(e,t),e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this,{useEncodeDefaulter:!0})},e.prototype.getProgressive=function(){var t=this.option.progressive;return null==t?this.option.large?5e3:this.get("progressive"):t},e.prototype.getProgressiveThreshold=function(){var t=this.option.progressiveThreshold;return null==t?this.option.large?1e4:this.get("progressiveThreshold"):t},e.prototype.brushSelector=function(t,e,n){return n.point(e.getItemLayout(t))},e.type="series.scatter",e.dependencies=["grid","polar","geo","singleAxis","calendar"],e.defaultOption={coordinateSystem:"cartesian2d",zlevel:0,z:2,legendHoverLink:!0,symbolSize:10,large:!1,largeThreshold:2e3,itemStyle:{opacity:.8},emphasis:{scale:!0},clip:!0,select:{itemStyle:{borderColor:"#212121"}}},e}(rf),Bw=function(){},Vw=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new Bw},e.prototype.buildPath=function(t,e){var n=e.points,i=e.size,r=this.symbolProxy,o=r.shape,a=t.getContext?t.getContext():t;if(a&&i[0]<4)this._ctx=a;else{this._ctx=null;for(var s=0;s<n.length;){var l=n[s++],u=n[s++];isNaN(l)||isNaN(u)||(this.softClipShape&&!this.softClipShape.contain(l,u)||(o.x=l-i[0]/2,o.y=u-i[1]/2,o.width=i[0],o.height=i[1],r.buildPath(t,o,!0)))}}},e.prototype.afterBrush=function(){var t=this.shape,e=t.points,n=t.size,i=this._ctx;if(i)for(var r=0;r<e.length;){var o=e[r++],a=e[r++];isNaN(o)||isNaN(a)||(this.softClipShape&&!this.softClipShape.contain(o,a)||i.fillRect(o-n[0]/2,a-n[1]/2,n[0],n[1]))}},e.prototype.findDataIndex=function(t,e){for(var n=this.shape,i=n.points,r=n.size,o=Math.max(r[0],4),a=Math.max(r[1],4),s=i.length/2-1;s>=0;s--){var l=2*s,u=i[l]-o/2,h=i[l+1]-a/2;if(t>=u&&e>=h&&t<=u+o&&e<=h+a)return s}return-1},e}(Za),Fw=function(){function t(){this.group=new zi}return t.prototype.isPersistent=function(){return!this._incremental},t.prototype.updateData=function(t,e){this.group.removeAll();var n=new Vw({rectHover:!0,cursor:"default"});n.setShape({points:t.getLayout("points")}),this._setCommon(n,t,!1,e),this.group.add(n),this._incremental=null},t.prototype.updateLayout=function(t){if(!this._incremental){var e=t.getLayout("points");this.group.eachChild((function(t){if(null!=t.startIndex){var n=2*(t.endIndex-t.startIndex),i=4*t.startIndex*2;e=new Float32Array(e.buffer,i,n)}t.setShape("points",e)}))}},t.prototype.incrementalPrepareUpdate=function(t){this.group.removeAll(),this._clearIncremental(),t.count()>2e6?(this._incremental||(this._incremental=new vu({silent:!0})),this.group.add(this._incremental)):this._incremental=null},t.prototype.incrementalUpdate=function(t,e,n){var i;this._incremental?(i=new Vw,this._incremental.addDisplayable(i,!0)):((i=new Vw({rectHover:!0,cursor:"default",startIndex:t.start,endIndex:t.end})).incremental=!0,this.group.add(i)),i.setShape({points:e.getLayout("points")}),this._setCommon(i,e,!!this._incremental,n)},t.prototype._setCommon=function(t,e,n,i){var r=e.hostModel;i=i||{};var o=e.getVisual("symbolSize");t.setShape("size",o instanceof Array?o:[o,o]),t.softClipShape=i.clipShape||null,t.symbolProxy=uy(e.getVisual("symbol"),0,0,0,0),t.setColor=t.symbolProxy.setColor;var a=t.shape.size[0]<4;t.useStyle(r.getModel("itemStyle").getItemStyle(a?["color","shadowBlur","shadowColor"]:["color"]));var s=e.getVisual("style"),l=s&&s.fill;if(l&&t.setColor(l),!n){var u=ys(t);u.seriesIndex=r.seriesIndex,t.on("mousemove",(function(e){u.dataIndex=null;var n=t.findDataIndex(e.offsetX,e.offsetY);n>=0&&(u.dataIndex=n+(t.startIndex||0))}))}},t.prototype.remove=function(){this._clearIncremental(),this._incremental=null,this.group.removeAll()},t.prototype._clearIncremental=function(){var t=this._incremental;t&&t.clearDisplaybles()},t}(),Gw=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.getData();this._updateSymbolDraw(i,t).updateData(i,{clipShape:this._getClipShape(t)}),this._finished=!0},e.prototype.incrementalPrepareRender=function(t,e,n){var i=t.getData();this._updateSymbolDraw(i,t).incrementalPrepareUpdate(i),this._finished=!1},e.prototype.incrementalRender=function(t,e,n){this._symbolDraw.incrementalUpdate(t,e.getData(),{clipShape:this._getClipShape(e)}),this._finished=t.end===e.getData().count()},e.prototype.updateTransform=function(t,e,n){var i=t.getData();if(this.group.dirty(),!this._finished||i.count()>1e4||!this._symbolDraw.isPersistent())return{update:!0};var r=Qb("").reset(t,e,n);r.progress&&r.progress({start:0,end:i.count(),count:i.count()},i),this._symbolDraw.updateLayout(i)},e.prototype._getClipShape=function(t){var e=t.coordinateSystem,n=e&&e.getArea&&e.getArea();return t.get("clip",!0)?n:null},e.prototype._updateSymbolDraw=function(t,e){var n=this._symbolDraw,i=e.pipelineContext.large;return n&&i===this._isLargeDraw||(n&&n.remove(),n=this._symbolDraw=i?new Fw:new Tb,this._isLargeDraw=i,this.group.removeAll()),this.group.add(n.group),n},e.prototype.remove=function(t,e){this._symbolDraw&&this._symbolDraw.remove(!0),this._symbolDraw=null},e.prototype.dispose=function(){},e.type="scatter",e}(yf),Hw=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.type="grid",e.dependencies=["xAxis","yAxis"],e.layoutMode="box",e.defaultOption={show:!1,zlevel:0,z:0,left:"10%",top:60,right:"10%",bottom:70,containLabel:!1,backgroundColor:"rgba(0,0,0,0)",borderWidth:1,borderColor:"#ccc"},e}(Nc),Ww=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.getCoordSysModel=function(){return this.getReferringComponents("grid",Or).models[0]},e.type="cartesian2dAxis",e}(Nc);L(Ww,j_);var Yw={show:!0,zlevel:0,z:0,inverse:!1,name:"",nameLocation:"end",nameRotate:null,nameTruncate:{maxWidth:null,ellipsis:"...",placeholder:"."},nameTextStyle:{},nameGap:15,silent:!1,triggerEvent:!1,tooltip:{show:!1},axisPointer:{},axisLine:{show:!0,onZero:!0,onZeroAxisIndex:null,lineStyle:{color:"#6E7079",width:1,type:"solid"},symbol:["none","none"],symbolSize:[10,15]},axisTick:{show:!0,inside:!1,length:5,lineStyle:{width:1}},axisLabel:{show:!0,inside:!1,rotate:0,showMinLabel:null,showMaxLabel:null,margin:8,fontSize:12},splitLine:{show:!0,lineStyle:{color:["#E0E6F1"],width:1,type:"solid"}},splitArea:{show:!1,areaStyle:{color:["rgba(250,250,250,0.2)","rgba(210,219,238,0.2)"]}}},Xw=S({boundaryGap:!0,deduplication:null,splitLine:{show:!1},axisTick:{alignWithLabel:!1,interval:"auto"},axisLabel:{interval:"auto"}},Yw),Uw=S({boundaryGap:[0,0],axisLine:{show:"auto"},axisTick:{show:"auto"},splitNumber:5,minorTick:{show:!1,splitNumber:5,length:3,lineStyle:{}},minorSplitLine:{show:!1,lineStyle:{color:"#F4F7FD",width:1}}},Yw),Zw={category:Xw,value:Uw,time:S({scale:!0,splitNumber:6,axisLabel:{showMinLabel:!1,showMaxLabel:!1,rich:{primary:{fontWeight:"bold"}}},splitLine:{show:!1}},Uw),log:T({scale:!0,logBase:10},Uw)},jw={value:1,category:1,time:1,log:1};function qw(t,e,i,r){P(jw,(function(o,a){var s=S(S({},Zw[a],!0),r,!0),l=function(t){function i(){for(var n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];var r=t.apply(this,n)||this;return r.type=e+"Axis."+a,r}return n(i,t),i.prototype.mergeDefaultAndTheme=function(t,e){var n=Lc(this),i=n?Pc(t):{};S(t,e.getTheme().get(a+"Axis")),S(t,this.getDefaultOption()),t.type=Kw(t),n&&kc(t,i,n)},i.prototype.optionUpdated=function(){"category"===this.option.type&&(this.__ordinalMeta=Ym.createByAxisModel(this))},i.prototype.getCategories=function(t){var e=this.option;if("category"===e.type)return t?e.data:this.__ordinalMeta.categories},i.prototype.getOrdinalMeta=function(){return this.__ordinalMeta},i.type=e+"Axis."+a,i.defaultOption=s,i}(i);t.registerComponentModel(l)})),t.registerSubTypeDefaulter(e+"Axis",Kw)}function Kw(t){return t.type||(t.data?"category":"value")}var $w=function(){function t(t){this.type="cartesian",this._dimList=[],this._axes={},this.name=t||""}return t.prototype.getAxis=function(t){return this._axes[t]},t.prototype.getAxes=function(){return O(this._dimList,(function(t){return this._axes[t]}),this)},t.prototype.getAxesByScale=function(t){return t=t.toLowerCase(),N(this.getAxes(),(function(e){return e.scale.type===t}))},t.prototype.addAxis=function(t){var e=t.dim;this._axes[e]=t,this._dimList.push(e)},t}(),Jw=["x","y"];function Qw(t){return"interval"===t.type||"time"===t.type}var tS=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="cartesian2d",e.dimensions=Jw,e}return n(e,t),e.prototype.calcAffineTransform=function(){this._transform=this._invTransform=null;var t=this.getAxis("x").scale,e=this.getAxis("y").scale;if(Qw(t)&&Qw(e)){var n=t.getExtent(),i=e.getExtent(),r=this.dataToPoint([n[0],i[0]]),o=this.dataToPoint([n[1],i[1]]),a=n[1]-n[0],s=i[1]-i[0];if(a&&s){var l=(o[0]-r[0])/a,u=(o[1]-r[1])/s,h=r[0]-n[0]*l,c=r[1]-i[0]*u,p=this._transform=[l,0,0,u,h,c];this._invTransform=be([],p)}}},e.prototype.getBaseAxis=function(){return this.getAxesByScale("ordinal")[0]||this.getAxesByScale("time")[0]||this.getAxis("x")},e.prototype.containPoint=function(t){var e=this.getAxis("x"),n=this.getAxis("y");return e.contain(e.toLocalCoord(t[0]))&&n.contain(n.toLocalCoord(t[1]))},e.prototype.containData=function(t){return this.getAxis("x").containData(t[0])&&this.getAxis("y").containData(t[1])},e.prototype.dataToPoint=function(t,e,n){n=n||[];var i=t[0],r=t[1];if(this._transform&&null!=i&&isFinite(i)&&null!=r&&isFinite(r))return Rt(n,t,this._transform);var o=this.getAxis("x"),a=this.getAxis("y");return n[0]=o.toGlobalCoord(o.dataToCoord(i)),n[1]=a.toGlobalCoord(a.dataToCoord(r)),n},e.prototype.clampData=function(t,e){var n=this.getAxis("x").scale,i=this.getAxis("y").scale,r=n.getExtent(),o=i.getExtent(),a=n.parse(t[0]),s=i.parse(t[1]);return(e=e||[])[0]=Math.min(Math.max(Math.min(r[0],r[1]),a),Math.max(r[0],r[1])),e[1]=Math.min(Math.max(Math.min(o[0],o[1]),s),Math.max(o[0],o[1])),e},e.prototype.pointToData=function(t,e){if(e=e||[],this._invTransform)return Rt(e,t,this._invTransform);var n=this.getAxis("x"),i=this.getAxis("y");return e[0]=n.coordToData(n.toLocalCoord(t[0])),e[1]=i.coordToData(i.toLocalCoord(t[1])),e},e.prototype.getOtherAxis=function(t){return this.getAxis("x"===t.dim?"y":"x")},e.prototype.getArea=function(){var t=this.getAxis("x").getGlobalExtent(),e=this.getAxis("y").getGlobalExtent(),n=Math.min(t[0],t[1]),i=Math.min(e[0],e[1]),r=Math.max(t[0],t[1])-n,o=Math.max(e[0],e[1])-i;return new Rn(n,i,r,o)},e}($w),eS=function(t){function e(e,n,i,r,o){var a=t.call(this,e,n,i)||this;return a.index=0,a.type=r||"value",a.position=o||"bottom",a}return n(e,t),e.prototype.isHorizontal=function(){var t=this.position;return"top"===t||"bottom"===t},e.prototype.getGlobalExtent=function(t){var e=this.getExtent();return e[0]=this.toGlobalCoord(e[0]),e[1]=this.toGlobalCoord(e[1]),t&&e[0]>e[1]&&e.reverse(),e},e.prototype.pointToData=function(t,e){return this.coordToData(this.toLocalCoord(t["x"===this.dim?0:1]),e)},e.prototype.setCategorySortInfo=function(t){if("category"!==this.type)return!1;this.model.option.categorySortInfo=t,this.scale.setSortInfo(t)},e}(vx);function nS(t,e,n){n=n||{};var i=t.coordinateSystem,r=e.axis,o={},a=r.getAxesOnZeroOf()[0],s=r.position,l=a?"onZero":s,u=r.dim,h=i.getRect(),c=[h.x,h.x+h.width,h.y,h.y+h.height],p={left:0,right:1,top:0,bottom:1,onZero:2},d=e.get("offset")||0,f="x"===u?[c[2]-d,c[3]+d]:[c[0]-d,c[1]+d];if(a){var g=a.toGlobalCoord(a.dataToCoord(0));f[p.onZero]=Math.max(Math.min(g,f[1]),f[0])}o.position=["y"===u?f[p[l]]:c[0],"x"===u?f[p[l]]:c[3]],o.rotation=Math.PI/2*("x"===u?0:1);o.labelDirection=o.tickDirection=o.nameDirection={top:-1,bottom:1,left:-1,right:1}[s],o.labelOffset=a?f[p[s]]-f[p.onZero]:0,e.get(["axisTick","inside"])&&(o.tickDirection=-o.tickDirection),Q(n.labelInside,e.get(["axisLabel","inside"]))&&(o.labelDirection=-o.labelDirection);var y=e.get(["axisLabel","rotate"]);return o.labelRotate="top"===l?-y:y,o.z2=1,o}function iS(t){return"cartesian2d"===t.get("coordinateSystem")}function rS(t){var e={xAxisModel:null,yAxisModel:null};return P(e,(function(n,i){var r=i.replace(/Model$/,""),o=t.getReferringComponents(r,Or).models[0];e[i]=o})),e}var oS=function(){function t(t,e,n){this.type="grid",this._coordsMap={},this._coordsList=[],this._axesMap={},this._axesList=[],this.axisPointerEnabled=!0,this.dimensions=Jw,this._initCartesian(t,e,n),this.model=t}return t.prototype.getRect=function(){return this._rect},t.prototype.update=function(t,e){var n=this._axesMap;this._updateScale(t,this.model),P(n.x,(function(t){F_(t.scale,t.model)})),P(n.y,(function(t){F_(t.scale,t.model)}));var i={};P(n.x,(function(t){sS(n,"y",t,i)})),P(n.y,(function(t){sS(n,"x",t,i)})),this.resize(this.model,e)},t.prototype.resize=function(t,e,n){var i=t.getBoxLayoutParams(),r=!n&&t.get("containLabel"),o=Ac(i,{width:e.getWidth(),height:e.getHeight()});this._rect=o;var a=this._axesList;function s(){P(a,(function(t){var e=t.isHorizontal(),n=e?[0,o.width]:[0,o.height],i=t.inverse?1:0;t.setExtent(n[i],n[1-i]),function(t,e){var n=t.getExtent(),i=n[0]+n[1];t.toGlobalCoord="x"===t.dim?function(t){return t+e}:function(t){return i-t+e},t.toLocalCoord="x"===t.dim?function(t){return t-e}:function(t){return i-t+e}}(t,e?o.x:o.y)}))}s(),r&&(P(a,(function(t){if(!t.model.get(["axisLabel","inside"])){var e=function(t){var e=t.model,n=t.scale;if(e.get(["axisLabel","show"])&&!n.isBlank()){var i,r,o=n.getExtent();r=n instanceof Qm?n.count():(i=n.getTicks()).length;var a,s=t.getLabelModel(),l=H_(t),u=1;r>40&&(u=Math.ceil(r/40));for(var h=0;h<r;h+=u){var c=l(i?i[h]:{value:o[0]+h},h),p=Y_(s.getTextRect(c),s.get("rotate")||0);a?a.union(p):a=p}return a}}(t);if(e){var n=t.isHorizontal()?"height":"width",i=t.model.get(["axisLabel","margin"]);o[n]-=e[n]+i,"top"===t.position?o.y+=e.height+i:"left"===t.position&&(o.x+=e.width+i)}}})),s()),P(this._coordsList,(function(t){t.calcAffineTransform()}))},t.prototype.getAxis=function(t,e){var n=this._axesMap[t];if(null!=n)return n[e||0]},t.prototype.getAxes=function(){return this._axesList.slice()},t.prototype.getCartesian=function(t,e){if(null!=t&&null!=e){var n="x"+t+"y"+e;return this._coordsMap[n]}X(t)&&(e=t.yAxisIndex,t=t.xAxisIndex);for(var i=0,r=this._coordsList;i<r.length;i++)if(r[i].getAxis("x").index===t||r[i].getAxis("y").index===e)return r[i]},t.prototype.getCartesians=function(){return this._coordsList.slice()},t.prototype.convertToPixel=function(t,e,n){var i=this._findConvertTarget(e);return i.cartesian?i.cartesian.dataToPoint(n):i.axis?i.axis.toGlobalCoord(i.axis.dataToCoord(n)):null},t.prototype.convertFromPixel=function(t,e,n){var i=this._findConvertTarget(e);return i.cartesian?i.cartesian.pointToData(n):i.axis?i.axis.coordToData(i.axis.toLocalCoord(n)):null},t.prototype._findConvertTarget=function(t){var e,n,i=t.seriesModel,r=t.xAxisModel||i&&i.getReferringComponents("xAxis",Or).models[0],o=t.yAxisModel||i&&i.getReferringComponents("yAxis",Or).models[0],a=t.gridModel,s=this._coordsList;if(i)A(s,e=i.coordinateSystem)<0&&(e=null);else if(r&&o)e=this.getCartesian(r.componentIndex,o.componentIndex);else if(r)n=this.getAxis("x",r.componentIndex);else if(o)n=this.getAxis("y",o.componentIndex);else if(a){a.coordinateSystem===this&&(e=this._coordsList[0])}return{cartesian:e,axis:n}},t.prototype.containPoint=function(t){var e=this._coordsList[0];if(e)return e.containPoint(t)},t.prototype._initCartesian=function(t,e,n){var i=this,r=this,o={left:!1,right:!1,top:!1,bottom:!1},a={x:{},y:{}},s={x:0,y:0};if(e.eachComponent("xAxis",l("x"),this),e.eachComponent("yAxis",l("y"),this),!s.x||!s.y)return this._axesMap={},void(this._axesList=[]);function l(e){return function(n,i){if(aS(n,t)){var l=n.get("position");"x"===e?"top"!==l&&"bottom"!==l&&(l=o.bottom?"top":"bottom"):"left"!==l&&"right"!==l&&(l=o.left?"right":"left"),o[l]=!0;var u=new eS(e,G_(n),[0,0],n.get("type"),l),h="category"===u.type;u.onBand=h&&n.get("boundaryGap"),u.inverse=n.get("inverse"),n.axis=u,u.model=n,u.grid=r,u.index=i,r._axesList.push(u),a[e][i]=u,s[e]++}}}this._axesMap=a,P(a.x,(function(e,n){P(a.y,(function(r,o){var a="x"+n+"y"+o,s=new tS(a);s.master=i,s.model=t,i._coordsMap[a]=s,i._coordsList.push(s),s.addAxis(e),s.addAxis(r)}))}))},t.prototype._updateScale=function(t,e){function n(t,e){P(Z_(t,e.dim),(function(n){e.scale.unionExtentFromData(t,n)}))}P(this._axesList,(function(t){if(t.scale.setExtent(1/0,-1/0),"category"===t.type){var e=t.model.get("categorySortInfo");t.scale.setSortInfo(e)}})),t.eachSeries((function(t){if(iS(t)){var i=rS(t),r=i.xAxisModel,o=i.yAxisModel;if(!aS(r,e)||!aS(o,e))return;var a=this.getCartesian(r.componentIndex,o.componentIndex),s=t.getData(),l=a.getAxis("x"),u=a.getAxis("y");"list"===s.type&&(n(s,l),n(s,u))}}),this)},t.prototype.getTooltipAxes=function(t){var e=[],n=[];return P(this.getCartesians(),(function(i){var r=null!=t&&"auto"!==t?i.getAxis(t):i.getBaseAxis(),o=i.getOtherAxis(r);A(e,r)<0&&e.push(r),A(n,o)<0&&n.push(o)})),{baseAxes:e,otherAxes:n}},t.create=function(e,n){var i=[];return e.eachComponent("grid",(function(r,o){var a=new t(r,e,n);a.name="grid_"+o,a.resize(r,n,!0),r.coordinateSystem=a,i.push(a)})),e.eachSeries((function(t){if(iS(t)){var e=rS(t),n=e.xAxisModel,i=e.yAxisModel,r=n.getCoordSysModel();0;var o=r.coordinateSystem;t.coordinateSystem=o.getCartesian(n.componentIndex,i.componentIndex)}})),i},t.dimensions=Jw,t}();function aS(t,e){return t.getCoordSysModel()===e}function sS(t,e,n,i){n.getAxesOnZeroOf=function(){return r?[r]:[]};var r,o=t[e],a=n.model,s=a.get(["axisLine","onZero"]),l=a.get(["axisLine","onZeroAxisIndex"]);if(s){if(null!=l)lS(o[l])&&(r=o[l]);else for(var u in o)if(o.hasOwnProperty(u)&&lS(o[u])&&!i[h(o[u])]){r=o[u];break}r&&(i[h(r)]=!0)}function h(t){return t.dim+"_"+t.index}}function lS(t){return t&&"category"!==t.type&&"time"!==t.type&&function(t){var e=t.scale.getExtent(),n=e[0],i=e[1];return!(n>0&&i>0||n<0&&i<0)}(t)}var uS=Math.PI,hS=function(){function t(t,e){this.group=new zi,this.opt=e,this.axisModel=t,T(e,{labelOffset:0,nameDirection:1,tickDirection:1,labelDirection:1,silent:!0,handleAutoShown:function(){return!0}});var n=new zi({x:e.position[0],y:e.position[1],rotation:e.rotation});n.updateTransform(),this._transformGroup=n}return t.prototype.hasBuilder=function(t){return!!cS[t]},t.prototype.add=function(t){cS[t](this.opt,this.axisModel,this.group,this._transformGroup)},t.prototype.getGroup=function(){return this.group},t.innerTextLayout=function(t,e,n){var i,r,o=er(e-t);return nr(o)?(r=n>0?"top":"bottom",i="center"):nr(o-uS)?(r=n>0?"bottom":"top",i="center"):(r="middle",i=o>0&&o<uS?n>0?"right":"left":n>0?"left":"right"),{rotation:o,textAlign:i,textVerticalAlign:r}},t.makeAxisEventDataBase=function(t){var e={componentType:t.mainType,componentIndex:t.componentIndex};return e[t.mainType+"Index"]=t.componentIndex,e},t.isLabelSilent=function(t){var e=t.get("tooltip");return t.get("silent")||!(t.get("triggerEvent")||e&&e.show)},t}(),cS={axisLine:function(t,e,n,i){var r=e.get(["axisLine","show"]);if("auto"===r&&t.handleAutoShown&&(r=t.handleAutoShown("axisLine")),r){var o=e.axis.getExtent(),a=i.transform,s=[o[0],0],l=[o[1],0];a&&(Rt(s,s,a),Rt(l,l,a));var u=I({lineCap:"round"},e.getModel(["axisLine","lineStyle"]).getLineStyle()),h=new tu({subPixelOptimize:!0,shape:{x1:s[0],y1:s[1],x2:l[0],y2:l[1]},style:u,strokeContainThreshold:t.strokeContainThreshold||5,silent:!0,z2:1});h.anid="line",n.add(h);var c=e.get(["axisLine","symbol"]),p=e.get(["axisLine","symbolSize"]),d=e.get(["axisLine","symbolOffset"])||0;if("number"==typeof d&&(d=[d,d]),null!=c){"string"==typeof c&&(c=[c,c]),"string"!=typeof p&&"number"!=typeof p||(p=[p,p]);var f=p[0],g=p[1];P([{rotate:t.rotation+Math.PI/2,offset:d[0],r:0},{rotate:t.rotation-Math.PI/2,offset:d[1],r:Math.sqrt((s[0]-l[0])*(s[0]-l[0])+(s[1]-l[1])*(s[1]-l[1]))}],(function(e,i){if("none"!==c[i]&&null!=c[i]){var r=uy(c[i],-f/2,-g/2,f,g,u.stroke,!0),o=e.r+e.offset;r.attr({rotation:e.rotate,x:s[0]+o*Math.cos(t.rotation),y:s[1]-o*Math.sin(t.rotation),silent:!0,z2:11}),n.add(r)}}))}}},axisTickLabel:function(t,e,n,i){var r=function(t,e,n,i){var r=n.axis,o=n.getModel("axisTick"),a=o.get("show");"auto"===a&&i.handleAutoShown&&(a=i.handleAutoShown("axisTick"));if(!a||r.scale.isBlank())return;for(var s=o.getModel("lineStyle"),l=i.tickDirection*o.get("length"),u=gS(r.getTicksCoords(),e.transform,l,T(s.getLineStyle(),{stroke:n.get(["axisLine","lineStyle","color"])}),"ticks"),h=0;h<u.length;h++)t.add(u[h]);return u}(n,i,e,t),o=function(t,e,n,i){var r=n.axis;if(!Q(i.axisLabelShow,n.get(["axisLabel","show"]))||r.scale.isBlank())return;var o=n.getModel("axisLabel"),a=o.get("margin"),s=r.getViewLabels(),l=(Q(i.labelRotate,o.get("rotate"))||0)*uS/180,u=hS.innerTextLayout(i.rotation,l,i.labelDirection),h=n.getCategories&&n.getCategories(!0),c=[],p=hS.isLabelSilent(n),d=n.get("triggerEvent");return P(s,(function(s,l){var f="ordinal"===r.scale.type?r.scale.getRawOrdinalNumber(s.tickValue):s.tickValue,g=s.formattedLabel,y=s.rawLabel,v=o;if(h&&h[f]){var m=h[f];X(m)&&m.textStyle&&(v=new Sh(m.textStyle,o,n.ecModel))}var _=v.getTextColor()||n.get(["axisLine","lineStyle","color"]),x=r.dataToCoord(f),b=new ls({x:x,y:i.labelOffset+i.labelDirection*a,rotation:u.rotation,silent:p,z2:10,style:nh(v,{text:g,align:v.getShallow("align",!0)||u.textAlign,verticalAlign:v.getShallow("verticalAlign",!0)||v.getShallow("baseline",!0)||u.textVerticalAlign,fill:"function"==typeof _?_("category"===r.type?y:"value"===r.type?f+"":f,l):_})});if(b.anid="label_"+f,d){var w=hS.makeAxisEventDataBase(n);w.targetType="axisLabel",w.value=y,ys(b).eventData=w}e.add(b),b.updateTransform(),c.push(b),t.add(b),b.decomposeTransform()})),c}(n,i,e,t);!function(t,e,n){if(U_(t.axis))return;var i=t.get(["axisLabel","showMinLabel"]),r=t.get(["axisLabel","showMaxLabel"]);n=n||[];var o=(e=e||[])[0],a=e[1],s=e[e.length-1],l=e[e.length-2],u=n[0],h=n[1],c=n[n.length-1],p=n[n.length-2];!1===i?(pS(o),pS(u)):dS(o,a)&&(i?(pS(a),pS(h)):(pS(o),pS(u)));!1===r?(pS(s),pS(c)):dS(l,s)&&(r?(pS(l),pS(p)):(pS(s),pS(c)))}(e,o,r),function(t,e,n,i){var r=n.axis,o=n.getModel("minorTick");if(!o.get("show")||r.scale.isBlank())return;var a=r.getMinorTicksCoords();if(!a.length)return;for(var s=o.getModel("lineStyle"),l=i*o.get("length"),u=T(s.getLineStyle(),T(n.getModel("axisTick").getLineStyle(),{stroke:n.get(["axisLine","lineStyle","color"])})),h=0;h<a.length;h++)for(var c=gS(a[h],e.transform,l,u,"minorticks_"+h),p=0;p<c.length;p++)t.add(c[p])}(n,i,e,t.tickDirection)},axisName:function(t,e,n,i){var r=Q(t.axisName,e.get("name"));if(r){var o,a,s=e.get("nameLocation"),l=t.nameDirection,u=e.getModel("nameTextStyle"),h=e.get("nameGap")||0,c=e.axis.getExtent(),p=c[0]>c[1]?-1:1,d=["start"===s?c[0]-p*h:"end"===s?c[1]+p*h:(c[0]+c[1])/2,fS(s)?t.labelOffset+l*h:0],f=e.get("nameRotate");null!=f&&(f=f*uS/180),fS(s)?o=hS.innerTextLayout(t.rotation,null!=f?f:t.rotation,l):(o=function(t,e,n,i){var r,o,a=er(n-t),s=i[0]>i[1],l="start"===e&&!s||"start"!==e&&s;nr(a-uS/2)?(o=l?"bottom":"top",r="center"):nr(a-1.5*uS)?(o=l?"top":"bottom",r="center"):(o="middle",r=a<1.5*uS&&a>uS/2?l?"left":"right":l?"right":"left");return{rotation:a,textAlign:r,textVerticalAlign:o}}(t.rotation,s,f||0,c),null!=(a=t.axisNameAvailableWidth)&&(a=Math.abs(a/Math.sin(o.rotation)),!isFinite(a)&&(a=null)));var g=u.getFont(),y=e.get("nameTruncate",!0)||{},v=y.ellipsis,m=Q(t.nameTruncateMaxWidth,y.maxWidth,a),_=e.get("tooltip",!0),x=e.mainType,b={componentType:x,name:r,$vars:["name"]};b[x+"Index"]=e.componentIndex;var w=new ls({x:d[0],y:d[1],rotation:o.rotation,silent:hS.isLabelSilent(e),style:nh(u,{text:r,font:g,overflow:"truncate",width:m,ellipsis:v,fill:u.getTextColor()||e.get(["axisLine","lineStyle","color"]),align:u.get("align")||o.textAlign,verticalAlign:u.get("verticalAlign")||o.textVerticalAlign}),z2:1});if(w.tooltip=_&&_.show?I({content:r,formatter:function(){return r},formatterParams:b},_):null,w.__fullText=r,w.anid="name",e.get("triggerEvent")){var S=hS.makeAxisEventDataBase(e);S.targetType="axisName",S.name=r,ys(w).eventData=S}i.add(w),w.updateTransform(),n.add(w),w.decomposeTransform()}}};function pS(t){t&&(t.ignore=!0)}function dS(t,e){var n=t&&t.getBoundingRect().clone(),i=e&&e.getBoundingRect().clone();if(n&&i){var r=ge([]);return _e(r,r,-t.rotation),n.applyTransform(ve([],r,t.getLocalTransform())),i.applyTransform(ve([],r,e.getLocalTransform())),n.intersect(i)}}function fS(t){return"middle"===t||"center"===t}function gS(t,e,n,i,r){for(var o=[],a=[],s=[],l=0;l<t.length;l++){var u=t[l].coord;a[0]=u,a[1]=0,s[0]=u,s[1]=n,e&&(Rt(a,a,e),Rt(s,s,e));var h=new tu({subPixelOptimize:!0,shape:{x1:a[0],y1:a[1],x2:s[0],y2:s[1]},style:i,z2:2,autoBatch:!0,silent:!0});h.anid=r+"_"+t[l].tickValue,o.push(h)}return o}function yS(t,e){var n={axesInfo:{},seriesInvolved:!1,coordSysAxesInfo:{},coordSysMap:{}};return function(t,e,n){var i=e.getComponent("tooltip"),r=e.getComponent("axisPointer"),o=r.get("link",!0)||[],a=[];P(n.getCoordinateSystems(),(function(n){if(n.axisPointerEnabled){var s=bS(n.model),l=t.coordSysAxesInfo[s]={};t.coordSysMap[s]=n;var u=n.model.getModel("tooltip",i);if(P(n.getAxes(),V(d,!1,null)),n.getTooltipAxes&&i&&u.get("show")){var h="axis"===u.get("trigger"),c="cross"===u.get(["axisPointer","type"]),p=n.getTooltipAxes(u.get(["axisPointer","axis"]));(h||c)&&P(p.baseAxes,V(d,!c||"cross",h)),c&&P(p.otherAxes,V(d,"cross",!1))}}function d(i,s,h){var c=h.model.getModel("axisPointer",r),p=c.get("show");if(p&&("auto"!==p||i||xS(c))){null==s&&(s=c.get("triggerTooltip"));var d=(c=i?function(t,e,n,i,r,o){var a=e.getModel("axisPointer"),s={};P(["type","snap","lineStyle","shadowStyle","label","animation","animationDurationUpdate","animationEasingUpdate","z"],(function(t){s[t]=w(a.get(t))})),s.snap="category"!==t.type&&!!o,"cross"===a.get("type")&&(s.type="line");var l=s.label||(s.label={});if(null==l.show&&(l.show=!1),"cross"===r){var u=a.get(["label","show"]);if(l.show=null==u||u,!o){var h=s.lineStyle=a.get("crossStyle");h&&T(l,h.textStyle)}}return t.model.getModel("axisPointer",new Sh(s,n,i))}(h,u,r,e,i,s):c).get("snap"),f=bS(h.model),g=s||d||"category"===h.type,y=t.axesInfo[f]={key:f,axis:h,coordSys:n,axisPointerModel:c,triggerTooltip:s,involveSeries:g,snap:d,useHandle:xS(c),seriesModels:[],linkGroup:null};l[f]=y,t.seriesInvolved=t.seriesInvolved||g;var v=function(t,e){for(var n=e.model,i=e.dim,r=0;r<t.length;r++){var o=t[r]||{};if(vS(o[i+"AxisId"],n.id)||vS(o[i+"AxisIndex"],n.componentIndex)||vS(o[i+"AxisName"],n.name))return r}}(o,h);if(null!=v){var m=a[v]||(a[v]={axesInfo:{}});m.axesInfo[f]=y,m.mapper=o[v].mapper,y.linkGroup=m}}}}))}(n,t,e),n.seriesInvolved&&function(t,e){e.eachSeries((function(e){var n=e.coordinateSystem,i=e.get(["tooltip","trigger"],!0),r=e.get(["tooltip","show"],!0);n&&"none"!==i&&!1!==i&&"item"!==i&&!1!==r&&!1!==e.get(["axisPointer","show"],!0)&&P(t.coordSysAxesInfo[bS(n.model)],(function(t){var i=t.axis;n.getAxis(i.dim)===i&&(t.seriesModels.push(e),null==t.seriesDataCount&&(t.seriesDataCount=0),t.seriesDataCount+=e.getData().count())}))}))}(n,t),n}function vS(t,e){return"all"===t||F(t)&&A(t,e)>=0||t===e}function mS(t){var e=_S(t);if(e){var n=e.axisPointerModel,i=e.axis.scale,r=n.option,o=n.get("status"),a=n.get("value");null!=a&&(a=i.parse(a));var s=xS(n);null==o&&(r.status=s?"show":"hide");var l=i.getExtent().slice();l[0]>l[1]&&l.reverse(),(null==a||a>l[1])&&(a=l[1]),a<l[0]&&(a=l[0]),r.value=a,s&&(r.status=e.axis.scale.isBlank()?"hide":"show")}}function _S(t){var e=(t.ecModel.getComponent("axisPointer")||{}).coordSysAxesInfo;return e&&e.axesInfo[bS(t)]}function xS(t){return!!t.get(["handle","show"])}function bS(t){return t.type+"||"+t.id}var wS={},SS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(e,n,i,r){this.axisPointerClass&&mS(e),t.prototype.render.apply(this,arguments),this._doUpdateAxisPointerClass(e,i,!0)},e.prototype.updateAxisPointer=function(t,e,n,i){this._doUpdateAxisPointerClass(t,n,!1)},e.prototype.remove=function(t,e){var n=this._axisPointer;n&&n.remove(e)},e.prototype.dispose=function(e,n){this._disposeAxisPointer(n),t.prototype.dispose.apply(this,arguments)},e.prototype._doUpdateAxisPointerClass=function(t,n,i){var r=e.getAxisPointerClass(this.axisPointerClass);if(r){var o=function(t){var e=_S(t);return e&&e.axisPointerModel}(t);o?(this._axisPointer||(this._axisPointer=new r)).render(t,o,n,i):this._disposeAxisPointer(n)}},e.prototype._disposeAxisPointer=function(t){this._axisPointer&&this._axisPointer.dispose(t),this._axisPointer=null},e.registerAxisPointerClass=function(t,e){wS[t]=e},e.getAxisPointerClass=function(t){return t&&wS[t]},e.type="axis",e}(pf),MS=Lr();function IS(t,e,n,i){var r=n.axis;if(!r.scale.isBlank()){var o=n.getModel("splitArea"),a=o.getModel("areaStyle"),s=a.get("color"),l=i.coordinateSystem.getRect(),u=r.getTicksCoords({tickModel:o,clamp:!0});if(u.length){var h=s.length,c=MS(t).splitAreaColors,p=ht(),d=0;if(c)for(var f=0;f<u.length;f++){var g=c.get(u[f].tickValue);if(null!=g){d=(g+(h-1)*f)%h;break}}var y=r.toGlobalCoord(u[0].coord),v=a.getAreaStyle();s=F(s)?s:[s];for(f=1;f<u.length;f++){var m=r.toGlobalCoord(u[f].coord),_=void 0,x=void 0,b=void 0,w=void 0;r.isHorizontal()?(_=y,x=l.y,b=m-_,w=l.height,y=_+b):(_=l.x,x=y,b=l.width,y=x+(w=m-x));var S=u[f-1].tickValue;null!=S&&p.set(S,d),e.add(new os({anid:null!=S?"area_"+S:null,shape:{x:_,y:x,width:b,height:w},style:T({fill:s[d]},v),autoBatch:!0,silent:!0})),d=(d+1)%h}MS(t).splitAreaColors=p}}}function TS(t){MS(t).splitAreaColors=null}var CS=["axisLine","axisTickLabel","axisName"],AS=["splitArea","splitLine","minorSplitLine"],DS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.axisPointerClass="CartesianAxisPointer",n}return n(e,t),e.prototype.render=function(e,n,i,r){this.group.removeAll();var o=this._axisGroup;if(this._axisGroup=new zi,this.group.add(this._axisGroup),e.get("show")){var a=e.getCoordSysModel(),s=nS(a,e),l=new hS(e,I({handleAutoShown:function(t){for(var n=a.coordinateSystem.getCartesians(),i=0;i<n.length;i++){var r=n[i].getOtherAxis(e.axis).type;if("value"===r||"log"===r)return!0}return!1}},s));P(CS,l.add,l),this._axisGroup.add(l.getGroup()),P(AS,(function(t){e.get([t,"show"])&&LS[t](this,this._axisGroup,e,a)}),this),Wu(o,this._axisGroup,e),t.prototype.render.call(this,e,n,i,r)}},e.prototype.remove=function(){TS(this)},e.type="cartesianAxis",e}(SS),LS={splitLine:function(t,e,n,i){var r=n.axis;if(!r.scale.isBlank()){var o=n.getModel("splitLine"),a=o.getModel("lineStyle"),s=a.get("color");s=F(s)?s:[s];for(var l=i.coordinateSystem.getRect(),u=r.isHorizontal(),h=0,c=r.getTicksCoords({tickModel:o}),p=[],d=[],f=a.getLineStyle(),g=0;g<c.length;g++){var y=r.toGlobalCoord(c[g].coord);u?(p[0]=y,p[1]=l.y,d[0]=y,d[1]=l.y+l.height):(p[0]=l.x,p[1]=y,d[0]=l.x+l.width,d[1]=y);var v=h++%s.length,m=c[g].tickValue;e.add(new tu({anid:null!=m?"line_"+c[g].tickValue:null,subPixelOptimize:!0,autoBatch:!0,shape:{x1:p[0],y1:p[1],x2:d[0],y2:d[1]},style:T({stroke:s[v]},f),silent:!0}))}}},minorSplitLine:function(t,e,n,i){var r=n.axis,o=n.getModel("minorSplitLine").getModel("lineStyle"),a=i.coordinateSystem.getRect(),s=r.isHorizontal(),l=r.getMinorTicksCoords();if(l.length)for(var u=[],h=[],c=o.getLineStyle(),p=0;p<l.length;p++)for(var d=0;d<l[p].length;d++){var f=r.toGlobalCoord(l[p][d].coord);s?(u[0]=f,u[1]=a.y,h[0]=f,h[1]=a.y+a.height):(u[0]=a.x,u[1]=f,h[0]=a.x+a.width,h[1]=f),e.add(new tu({anid:"minor_line_"+l[p][d].tickValue,subPixelOptimize:!0,autoBatch:!0,shape:{x1:u[0],y1:u[1],x2:h[0],y2:h[1]},style:c,silent:!0}))}},splitArea:function(t,e,n,i){IS(t,e,n,i)}},kS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="xAxis",e}(DS),PS=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type=kS.type,e}return n(e,t),e.type="yAxis",e}(DS),OS=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="grid",e}return n(e,t),e.prototype.render=function(t,e){this.group.removeAll(),t.get("show")&&this.group.add(new os({shape:t.coordinateSystem.getRect(),style:T({fill:t.get("backgroundColor")},t.getItemStyle()),silent:!0,z2:-1}))},e.type="grid",e}(pf),RS={offset:0};function NS(t){t.registerComponentView(OS),t.registerComponentModel(Hw),t.registerCoordinateSystem("cartesian2d",oS),qw(t,"x",Ww,RS),qw(t,"y",Ww,RS),t.registerComponentView(kS),t.registerComponentView(PS),t.registerPreprocessor((function(t){t.xAxis&&t.yAxis&&!t.grid&&(t.grid={})}))}function ES(t){t.eachSeriesByType("radar",(function(t){var e=t.getData(),n=[],i=t.coordinateSystem;if(i){var r=i.getIndicatorAxes();P(r,(function(t,o){e.each(e.mapDimension(r[o].dim),(function(t,e){n[e]=n[e]||[];var r=i.dataToPoint(t,o);n[e][o]=zS(r)?r:BS(i)}))})),e.each((function(t){var r=E(n[t],(function(t){return zS(t)}))||BS(i);n[t].push(r.slice()),e.setItemLayout(t,n[t])}))}}))}function zS(t){return!isNaN(t[0])&&!isNaN(t[1])}function BS(t){return[t.cx,t.cy]}function VS(t){var e=t.polar;if(e){F(e)||(e=[e]);var n=[];P(e,(function(e,i){e.indicator?(e.type&&!e.shape&&(e.shape=e.type),t.radar=t.radar||[],F(t.radar)||(t.radar=[t.radar]),t.radar.push(e)):n.push(e)})),t.polar=n}P(t.series,(function(t){t&&"radar"===t.type&&t.polarIndex&&(t.radarIndex=t.polarIndex)}))}var FS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.coordinateSystem,r=this.group,o=t.getData(),a=this._data;function s(t,e){var n=t.getItemVisual(e,"symbol")||"circle";if("none"!==n){var i=function(t){return F(t)||(t=[+t,+t]),t}(t.getItemVisual(e,"symbolSize")),r=uy(n,-1,-1,2,2),o=t.getItemVisual(e,"symbolRotate")||0;return r.attr({style:{strokeNoScale:!0},z2:100,scaleX:i[0]/2,scaleY:i[1]/2,rotation:o*Math.PI/180||0}),r}}function l(e,n,i,r,o,a){i.removeAll();for(var l=0;l<n.length-1;l++){var u=s(r,o);u&&(u.__dimIdx=l,e[l]?(u.setPosition(e[l]),Ku[a?"initProps":"updateProps"](u,{x:n[l][0],y:n[l][1]},t,o)):u.setPosition(n[l]),i.add(u))}}function u(t){return O(t,(function(t){return[i.cx,i.cy]}))}o.diff(a).add((function(e){var n=o.getItemLayout(e);if(n){var i=new ql,r=new $l,a={shape:{points:n}};i.shape.points=u(n),r.shape.points=u(n),Ru(i,a,t,e),Ru(r,a,t,e);var s=new zi,h=new zi;s.add(r),s.add(i),s.add(h),l(r.shape.points,n,h,o,e,!0),o.setItemGraphicEl(e,s)}})).update((function(e,n){var i=a.getItemGraphicEl(n),r=i.childAt(0),s=i.childAt(1),u=i.childAt(2),h={shape:{points:o.getItemLayout(e)}};h.shape.points&&(l(r.shape.points,h.shape.points,u,o,e,!1),Ou(r,h,t),Ou(s,h,t),o.setItemGraphicEl(e,i))})).remove((function(t){r.remove(a.getItemGraphicEl(t))})).execute(),o.eachItemGraphicEl((function(t,e){var n=o.getItemModel(e),i=t.childAt(0),a=t.childAt(1),s=t.childAt(2),l=o.getItemVisual(e,"style"),u=l.fill;r.add(t),i.useStyle(T(n.getModel("lineStyle").getLineStyle(),{fill:"none",stroke:u})),nl(i,n,"lineStyle"),nl(a,n,"areaStyle");var h=n.getModel("areaStyle"),c=h.isEmpty()&&h.parentModel.isEmpty();a.ignore=c,P(["emphasis","select","blur"],(function(t){var e=n.getModel([t,"areaStyle"]),i=e.isEmpty()&&e.parentModel.isEmpty();a.ensureState(t).ignore=i&&c})),a.useStyle(T(h.getAreaStyle(),{fill:u,opacity:.7,decal:l.decal}));var p=n.getModel("emphasis"),d=p.getModel("itemStyle").getItemStyle();s.eachChild((function(t){if(t instanceof Ja){var i=t.style;t.useStyle(I({image:i.image,x:i.x,y:i.y,width:i.width,height:i.height},l))}else t.useStyle(l),t.setColor(u);t.ensureState("emphasis").style=w(d);var r=o.get(o.dimensions[t.__dimIdx],e);(null==r||isNaN(r))&&(r=""),th(t,eh(n),{labelFetcher:o.hostModel,labelDataIndex:e,labelDimIndex:t.__dimIdx,defaultText:r,inheritColor:u,defaultOpacity:l.opacity})})),Js(t,p.get("focus"),p.get("blurScope"))})),this._data=o},e.prototype.remove=function(){this.group.removeAll(),this._data=null},e.type="radar",e}(yf),GS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.useColorPaletteOnData=!0,n.hasSymbolVisual=!0,n}return n(e,t),e.prototype.init=function(e){t.prototype.init.apply(this,arguments),this.legendVisualProvider=new Nw(B(this.getData,this),B(this.getRawData,this))},e.prototype.getInitialData=function(t,e){return Rw(this,{generateCoord:"indicator_",generateCoordCount:1/0})},e.prototype.formatTooltip=function(t,e,n){var i=this.getData(),r=this.coordinateSystem.getIndicatorAxes(),o=this.getData().getName(t),a=""===o?this.name:o,s=$d(this,t);return Yd("section",{header:a,sortBlocks:!0,blocks:O(r,(function(e){var n=i.get(i.mapDimension(e.dim),t);return Yd("nameValue",{markerType:"subItem",markerColor:s,name:e.name,value:n,sortParam:n})}))})},e.prototype.getTooltipPosition=function(t){if(null!=t)for(var e=this.getData(),n=this.coordinateSystem,i=e.getValues(O(n.dimensions,(function(t){return e.mapDimension(t)})),t),r=0,o=i.length;r<o;r++)if(!isNaN(i[r])){var a=n.getIndicatorAxes();return n.coordToPoint(a[r].dataToCoord(i[r]),r)}},e.type="series.radar",e.dependencies=["radar"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"radar",legendHoverLink:!0,radarIndex:0,lineStyle:{width:2,type:"solid"},label:{position:"top"},symbol:"emptyCircle",symbolSize:4},e}(rf),HS=Zw.value;function WS(t,e){return T({show:e},t)}var YS=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.optionUpdated=function(){var t=this.get("boundaryGap"),e=this.get("splitNumber"),n=this.get("scale"),i=this.get("axisLine"),r=this.get("axisTick"),o=this.get("axisLabel"),a=this.get("axisName"),s=this.get(["axisName","show"]),l=this.get(["axisName","formatter"]),u=this.get("axisNameGap"),h=this.get("triggerEvent"),c=O(this.get("indicator")||[],(function(c){null!=c.max&&c.max>0&&!c.min?c.min=0:null!=c.min&&c.min<0&&!c.max&&(c.max=0);var p=a;null!=c.color&&(p=T({color:c.color},a));var d=S(w(c),{boundaryGap:t,splitNumber:e,scale:n,axisLine:i,axisTick:r,axisLabel:o,name:c.text,nameLocation:"end",nameGap:u,nameTextStyle:p,triggerEvent:h},!1);if(s||(d.name=""),"string"==typeof l){var f=d.name;d.name=l.replace("{value}",null!=f?f:"")}else"function"==typeof l&&(d.name=l(d.name,d));var g=new Sh(d,null,this.ecModel);return L(g,j_.prototype),g.mainType="radar",g.componentIndex=this.componentIndex,g}),this);this._indicatorModels=c},e.prototype.getIndicatorModels=function(){return this._indicatorModels},e.type="radar",e.defaultOption={zlevel:0,z:0,center:["50%","50%"],radius:"75%",startAngle:90,axisName:{show:!0},boundaryGap:[0,0],splitNumber:5,axisNameGap:15,scale:!1,shape:"polygon",axisLine:S({lineStyle:{color:"#bbb"}},HS.axisLine),axisLabel:WS(HS.axisLabel,!1),axisTick:WS(HS.axisTick,!1),splitLine:WS(HS.splitLine,!0),splitArea:WS(HS.splitArea,!0),indicator:[]},e}(Nc),XS=["axisLine","axisTickLabel","axisName"],US=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){this.group.removeAll(),this._buildAxes(t),this._buildSplitLineAndArea(t)},e.prototype._buildAxes=function(t){var e=t.coordinateSystem;P(O(e.getIndicatorAxes(),(function(t){return new hS(t.model,{position:[e.cx,e.cy],rotation:t.angle,labelDirection:-1,tickDirection:-1,nameDirection:1})})),(function(t){P(XS,t.add,t),this.group.add(t.getGroup())}),this)},e.prototype._buildSplitLineAndArea=function(t){var e=t.coordinateSystem,n=e.getIndicatorAxes();if(n.length){var i=t.get("shape"),r=t.getModel("splitLine"),o=t.getModel("splitArea"),a=r.getModel("lineStyle"),s=o.getModel("areaStyle"),l=r.get("show"),u=o.get("show"),h=a.get("color"),c=s.get("color"),p=F(h)?h:[h],d=F(c)?c:[c],f=[],g=[];if("circle"===i)for(var y=n[0].getTicksCoords(),v=e.cx,m=e.cy,_=0;_<y.length;_++){if(l)f[A(f,p,_)].push(new Tl({shape:{cx:v,cy:m,r:y[_].coord}}));if(u&&_<y.length-1)g[A(g,d,_)].push(new Xl({shape:{cx:v,cy:m,r0:y[_].coord,r:y[_+1].coord}}))}else{var x,b=O(n,(function(t,n){var i=t.getTicksCoords();return x=null==x?i.length-1:Math.min(i.length-1,x),O(i,(function(t){return e.coordToPoint(t.coord,n)}))})),w=[];for(_=0;_<=x;_++){for(var S=[],M=0;M<n.length;M++)S.push(b[M][_]);if(S[0]&&S.push(S[0].slice()),l)f[A(f,p,_)].push(new $l({shape:{points:S}}));if(u&&w)g[A(g,d,_-1)].push(new ql({shape:{points:S.concat(w)}}));w=S.slice().reverse()}}var I=a.getLineStyle(),C=s.getAreaStyle();P(g,(function(t,e){this.group.add(Du(t,{style:T({stroke:"none",fill:d[e%d.length]},C),silent:!0}))}),this),P(f,(function(t,e){this.group.add(Du(t,{style:T({fill:"none",stroke:p[e%p.length]},I),silent:!0}))}),this)}function A(t,e,n){var i=n%e.length;return t[i]=t[i]||[],i}},e.type="radar",e}(pf),ZS=function(t){function e(e,n,i){var r=t.call(this,e,n,i)||this;return r.type="value",r.angle=0,r.name="",r}return n(e,t),e}(vx),jS=function(){function t(t,e,n){this.dimensions=[],this._model=t,this._indicatorAxes=O(t.getIndicatorModels(),(function(t,e){var n="indicator_"+e,i=new ZS(n,new e_);return i.name=t.get("name"),i.model=t,t.axis=i,this.dimensions.push(n),i}),this),this.resize(t,n)}return t.prototype.getIndicatorAxes=function(){return this._indicatorAxes},t.prototype.dataToPoint=function(t,e){var n=this._indicatorAxes[e];return this.coordToPoint(n.dataToCoord(t),e)},t.prototype.coordToPoint=function(t,e){var n=this._indicatorAxes[e].angle;return[this.cx+t*Math.cos(n),this.cy-t*Math.sin(n)]},t.prototype.pointToData=function(t){var e=t[0]-this.cx,n=t[1]-this.cy,i=Math.sqrt(e*e+n*n);e/=i,n/=i;for(var r,o=Math.atan2(-n,e),a=1/0,s=-1,l=0;l<this._indicatorAxes.length;l++){var u=this._indicatorAxes[l],h=Math.abs(o-u.angle);h<a&&(r=u,s=l,a=h)}return[s,+(r&&r.coordToData(i))]},t.prototype.resize=function(t,e){var n=t.get("center"),i=e.getWidth(),r=e.getHeight(),o=Math.min(i,r)/2;this.cx=Zi(n[0],i),this.cy=Zi(n[1],r),this.startAngle=t.get("startAngle")*Math.PI/180;var a=t.get("radius");"string"!=typeof a&&"number"!=typeof a||(a=[0,a]),this.r0=Zi(a[0],o),this.r=Zi(a[1],o),P(this._indicatorAxes,(function(t,e){t.setExtent(this.r0,this.r);var n=this.startAngle+e*Math.PI*2/this._indicatorAxes.length;n=Math.atan2(Math.sin(n),Math.cos(n)),t.angle=n}),this)},t.prototype.update=function(t,e){var n=this._indicatorAxes,i=this._model;P(n,(function(t){t.scale.setExtent(1/0,-1/0)})),t.eachSeriesByType("radar",(function(e,r){if("radar"===e.get("coordinateSystem")&&t.getComponent("radar",e.get("radarIndex"))===i){var o=e.getData();P(n,(function(t){t.scale.unionExtentFromData(o,o.mapDimension(t.dim))}))}}),this);var r=i.get("splitNumber");function o(t){var e=Math.pow(10,Math.floor(Math.log(t)/Math.LN10)),n=t/e;return 2===n?n=5:n*=2,n*e}P(n,(function(t,e){var n=V_(t.scale,t.model).extent;F_(t.scale,t.model);var i=t.model,a=t.scale,s=B_(a,i.get("min",!0)),l=B_(a,i.get("max",!0)),u=a.getInterval();if(null!=s&&null!=l)a.setExtent(+s,+l),a.setInterval((l-s)/r);else if(null!=s){var h=void 0;do{h=s+u*r,a.setExtent(+s,h),a.setInterval(u),u=o(u)}while(h<n[1]&&isFinite(h)&&isFinite(n[1]))}else if(null!=l){var c=void 0;do{c=l-u*r,a.setExtent(c,+l),a.setInterval(u),u=o(u)}while(c>n[0]&&isFinite(c)&&isFinite(n[0]))}else{a.getTicks().length-1>r&&(u=o(u));c=ji((h=Math.ceil(n[1]/u)*u)-u*r);a.setExtent(c,h),a.setInterval(u)}}))},t.prototype.convertToPixel=function(t,e,n){return console.warn("Not implemented."),null},t.prototype.convertFromPixel=function(t,e,n){return console.warn("Not implemented."),null},t.prototype.containPoint=function(t){return console.warn("Not implemented."),!1},t.create=function(e,n){var i=[];return e.eachComponent("radar",(function(r){var o=new t(r,e,n);i.push(o),r.coordinateSystem=o})),e.eachSeriesByType("radar",(function(t){"radar"===t.get("coordinateSystem")&&(t.coordinateSystem=i[t.get("radarIndex")||0])})),i},t.dimensions=[],t}();function qS(t){t.registerCoordinateSystem("radar",jS),t.registerComponentModel(YS),t.registerComponentView(US)}var KS="\0_ec_interaction_mutex";function $S(t,e){return!!JS(t)[e]}function JS(t){return t[KS]||(t[KS]={})}Yv({type:"takeGlobalCursor",event:"globalCursorTaken",update:"update"},(function(){}));var QS=function(t){function e(e){var n=t.call(this)||this;n._zr=e;var i=B(n._mousedownHandler,n),r=B(n._mousemoveHandler,n),o=B(n._mouseupHandler,n),a=B(n._mousewheelHandler,n),s=B(n._pinchHandler,n);return n.enable=function(t,n){this.disable(),this._opt=T(w(n)||{},{zoomOnMouseWheel:!0,moveOnMouseMove:!0,moveOnMouseWheel:!1,preventDefaultMouseMove:!0}),null==t&&(t=!0),!0!==t&&"move"!==t&&"pan"!==t||(e.on("mousedown",i),e.on("mousemove",r),e.on("mouseup",o)),!0!==t&&"scale"!==t&&"zoom"!==t||(e.on("mousewheel",a),e.on("pinch",s))},n.disable=function(){e.off("mousedown",i),e.off("mousemove",r),e.off("mouseup",o),e.off("mousewheel",a),e.off("pinch",s)},n}return n(e,t),e.prototype.isDragging=function(){return this._dragging},e.prototype.isPinching=function(){return this._pinching},e.prototype.setPointerChecker=function(t){this.pointerChecker=t},e.prototype.dispose=function(){this.disable()},e.prototype._mousedownHandler=function(t){if(!(ne(t)||t.target&&t.target.draggable)){var e=t.offsetX,n=t.offsetY;this.pointerChecker&&this.pointerChecker(t,e,n)&&(this._x=e,this._y=n,this._dragging=!0)}},e.prototype._mousemoveHandler=function(t){if(this._dragging&&nM("moveOnMouseMove",t,this._opt)&&"pinch"!==t.gestureEvent&&!$S(this._zr,"globalPan")){var e=t.offsetX,n=t.offsetY,i=this._x,r=this._y,o=e-i,a=n-r;this._x=e,this._y=n,this._opt.preventDefaultMouseMove&&ee(t.event),eM(this,"pan","moveOnMouseMove",t,{dx:o,dy:a,oldX:i,oldY:r,newX:e,newY:n,isAvailableBehavior:null})}},e.prototype._mouseupHandler=function(t){ne(t)||(this._dragging=!1)},e.prototype._mousewheelHandler=function(t){var e=nM("zoomOnMouseWheel",t,this._opt),n=nM("moveOnMouseWheel",t,this._opt),i=t.wheelDelta,r=Math.abs(i),o=t.offsetX,a=t.offsetY;if(0!==i&&(e||n)){if(e){var s=r>3?1.4:r>1?1.2:1.1;tM(this,"zoom","zoomOnMouseWheel",t,{scale:i>0?s:1/s,originX:o,originY:a,isAvailableBehavior:null})}if(n){var l=Math.abs(i);tM(this,"scrollMove","moveOnMouseWheel",t,{scrollDelta:(i>0?1:-1)*(l>3?.4:l>1?.15:.05),originX:o,originY:a,isAvailableBehavior:null})}}},e.prototype._pinchHandler=function(t){$S(this._zr,"globalPan")||tM(this,"zoom",null,t,{scale:t.pinchScale>1?1.1:1/1.1,originX:t.pinchX,originY:t.pinchY,isAvailableBehavior:null})},e}(Ft);function tM(t,e,n,i,r){t.pointerChecker&&t.pointerChecker(i,r.originX,r.originY)&&(ee(i.event),eM(t,e,n,i,r))}function eM(t,e,n,i,r){r.isAvailableBehavior=B(nM,null,n,i),t.trigger(e,r)}function nM(t,e,n){var i=n[t];return!t||i&&(!H(i)||e.event[i+"Key"])}function iM(t,e,n){var i=t.target;i.x+=e,i.y+=n,i.dirty()}function rM(t,e,n,i){var r=t.target,o=t.zoomLimit,a=t.zoom=t.zoom||1;if(a*=e,o){var s=o.min||0,l=o.max||1/0;a=Math.max(Math.min(l,a),s)}var u=a/t.zoom;t.zoom=a,r.x-=(n-r.x)*(u-1),r.y-=(i-r.y)*(u-1),r.scaleX*=u,r.scaleY*=u,r.dirty()}var oM={axisPointer:1,tooltip:1,brush:1};function aM(t,e,n){var i=e.getComponentByElement(t.topTarget),r=i&&i.coordinateSystem;return i&&i!==n&&!oM.hasOwnProperty(i.mainType)&&r&&r.model!==n}for(var sM=[126,25],lM=[[[0,3.5],[7,11.2],[15,11.9],[30,7],[42,.7],[52,.7],[56,7.7],[59,.7],[64,.7],[64,0],[5,0],[0,3.5]],[[13,16.1],[19,14.7],[16,21.7],[11,23.1],[13,16.1]],[[12,32.2],[14,38.5],[15,38.5],[13,32.2],[12,32.2]],[[16,47.6],[12,53.2],[13,53.2],[18,47.6],[16,47.6]],[[6,64.4],[8,70],[9,70],[8,64.4],[6,64.4]],[[23,82.6],[29,79.8],[30,79.8],[25,82.6],[23,82.6]],[[37,70.7],[43,62.3],[44,62.3],[39,70.7],[37,70.7]],[[48,51.1],[51,45.5],[53,45.5],[50,51.1],[48,51.1]],[[51,35],[51,28.7],[53,28.7],[53,35],[51,35]],[[52,22.4],[55,17.5],[56,17.5],[53,22.4],[52,22.4]],[[58,12.6],[62,7],[63,7],[60,12.6],[58,12.6]],[[0,3.5],[0,93.1],[64,93.1],[64,0],[63,0],[63,92.4],[1,92.4],[1,3.5],[0,3.5]]],uM=0;uM<lM.length;uM++)for(var hM=0;hM<lM[uM].length;hM++)lM[uM][hM][0]/=10.5,lM[uM][hM][1]/=-14,lM[uM][hM][0]+=sM[0],lM[uM][hM][1]+=sM[1];var cM={"南海诸岛":[32,80],"广东":[0,-10],"香港":[10,5],"澳门":[-10,10],"天津":[5,5]};var pM={Russia:[100,60],"United States":[-99,38],"United States of America":[-99,38]};var dM=[[[123.45165252685547,25.73527164402261],[123.49731445312499,25.73527164402261],[123.49731445312499,25.750734064600884],[123.45165252685547,25.750734064600884],[123.45165252685547,25.73527164402261]]];var fM=Lr(),gM={load:function(t,e,n){var i=fM(e).parsed;if(i)return i;var r,o=e.specialAreas||{},a=e.geoJSON;try{r=a?ex(a,n):[]}catch(t){throw new Error("Invalid geoJson format\n"+t.message)}return function(t,e){"china"===t&&e.push(new Q_("南海诸岛",O(lM,(function(t){return{type:"polygon",exterior:t}})),sM))}(t,r),P(r,(function(e){var n=e.name;!function(t,e){if("china"===t){var n=cM[e.name];if(n){var i=e.center;i[0]+=n[0]/10.5,i[1]+=-n[1]/14}}}(t,e),function(t,e){if("world"===t){var n=pM[e.name];if(n){var i=e.center;i[0]=n[0],i[1]=n[1]}}}(t,e),function(t,e){"china"===t&&"台湾"===e.name&&e.geometries.push({type:"polygon",exterior:dM[0]})}(t,e);var i=o[n];i&&e.transformTo(i.left,i.top,i.width,i.height)})),fM(e).parsed={regions:r,boundingRect:yM(r)}}};function yM(t){for(var e,n=0;n<t.length;n++){var i=t[n].getBoundingRect();(e=e||i.clone()).union(i)}return e}var vM,mM=/[\s,]+/,_M=function(){function t(){this._defs={},this._root=null,this._isDefine=!1,this._isText=!1}return t.prototype.parse=function(t,e){e=e||{};var n=og(t);if(!n)throw new Error("Illegal svg");var i=new zi;this._root=i;var r=n.getAttribute("viewBox")||"",o=parseFloat(n.getAttribute("width")||e.width),a=parseFloat(n.getAttribute("height")||e.height);isNaN(o)&&(o=null),isNaN(a)&&(a=null),MM(n,i,null,!0);for(var s,l,u=n.firstChild;u;)this._parseNode(u,i),u=u.nextSibling;if(r){var h=ot(r).split(mM);h.length>=4&&(s={x:parseFloat(h[0]||0),y:parseFloat(h[1]||0),width:parseFloat(h[2]),height:parseFloat(h[3])})}if(s&&null!=o&&null!=a&&(l=DM(s,o,a),!e.ignoreViewBox)){var c=i;(i=new zi).add(c),c.scaleX=c.scaleY=l.scale,c.x=l.x,c.y=l.y}return e.ignoreRootClip||null==o||null==a||i.setClipPath(new os({shape:{x:0,y:0,width:o,height:a}})),{root:i,width:o,height:a,viewBoxRect:s,viewBoxTransform:l}},t.prototype._parseNode=function(t,e){var n,i,r=t.nodeName.toLowerCase();if("defs"===r?this._isDefine=!0:"text"===r&&(this._isText=!0),this._isDefine){if(i=xM[r]){var o=i.call(this,t),a=t.getAttribute("id");a&&(this._defs[a]=o)}}else(i=vM[r])&&(n=i.call(this,t,e),e.add(n));if(n)for(var s=t.firstChild;s;)1===s.nodeType&&this._parseNode(s,n),3===s.nodeType&&this._isText&&this._parseText(s,n),s=s.nextSibling;"defs"===r?this._isDefine=!1:"text"===r&&(this._isText=!1)},t.prototype._parseText=function(t,e){if(1===t.nodeType){var n=t.getAttribute("dx")||0,i=t.getAttribute("dy")||0;this._textX+=parseFloat(n),this._textY+=parseFloat(i)}var r=new qa({style:{text:t.textContent},x:this._textX||0,y:this._textY||0});bM(e,r),MM(t,r,this._defs);var o=r.style,a=o.fontSize;a&&a<9&&(o.fontSize=9,r.scaleX*=a/9,r.scaleY*=a/9);var s=(o.fontSize||o.fontFamily)&&[o.fontStyle,o.fontWeight,(o.fontSize||12)+"px",o.fontFamily||"sans-serif"].join(" ");o.font=s;var l=r.getBoundingRect();return this._textX+=l.width,e.add(r),r},t.internalField=void(vM={g:function(t,e){var n=new zi;return bM(e,n),MM(t,n,this._defs),n},rect:function(t,e){var n=new os;return bM(e,n),MM(t,n,this._defs),n.setShape({x:parseFloat(t.getAttribute("x")||"0"),y:parseFloat(t.getAttribute("y")||"0"),width:parseFloat(t.getAttribute("width")||"0"),height:parseFloat(t.getAttribute("height")||"0")}),n},circle:function(t,e){var n=new Tl;return bM(e,n),MM(t,n,this._defs),n.setShape({cx:parseFloat(t.getAttribute("cx")||"0"),cy:parseFloat(t.getAttribute("cy")||"0"),r:parseFloat(t.getAttribute("r")||"0")}),n},line:function(t,e){var n=new tu;return bM(e,n),MM(t,n,this._defs),n.setShape({x1:parseFloat(t.getAttribute("x1")||"0"),y1:parseFloat(t.getAttribute("y1")||"0"),x2:parseFloat(t.getAttribute("x2")||"0"),y2:parseFloat(t.getAttribute("y2")||"0")}),n},ellipse:function(t,e){var n=new Al;return bM(e,n),MM(t,n,this._defs),n.setShape({cx:parseFloat(t.getAttribute("cx")||"0"),cy:parseFloat(t.getAttribute("cy")||"0"),rx:parseFloat(t.getAttribute("rx")||"0"),ry:parseFloat(t.getAttribute("ry")||"0")}),n},polygon:function(t,e){var n,i=t.getAttribute("points");i&&(n=wM(i));var r=new ql({shape:{points:n||[]}});return bM(e,r),MM(t,r,this._defs),r},polyline:function(t,e){var n=new Za;bM(e,n),MM(t,n,this._defs);var i,r=t.getAttribute("points");return r&&(i=wM(r)),new $l({shape:{points:i||[]}})},image:function(t,e){var n=new Ja;return bM(e,n),MM(t,n,this._defs),n.setStyle({image:t.getAttribute("xlink:href"),x:+t.getAttribute("x"),y:+t.getAttribute("y"),width:+t.getAttribute("width"),height:+t.getAttribute("height")}),n},text:function(t,e){var n=t.getAttribute("x")||"0",i=t.getAttribute("y")||"0",r=t.getAttribute("dx")||"0",o=t.getAttribute("dy")||"0";this._textX=parseFloat(n)+parseFloat(r),this._textY=parseFloat(i)+parseFloat(o);var a=new zi;return bM(e,a),MM(t,a,this._defs),a},tspan:function(t,e){var n=t.getAttribute("x"),i=t.getAttribute("y");null!=n&&(this._textX=parseFloat(n)),null!=i&&(this._textY=parseFloat(i));var r=t.getAttribute("dx")||0,o=t.getAttribute("dy")||0,a=new zi;return bM(e,a),MM(t,a,this._defs),this._textX+=r,this._textY+=o,a},path:function(t,e){var n=Ml(t.getAttribute("d")||"");return bM(e,n),MM(t,n,this._defs),n}}),t}(),xM={lineargradient:function(t){var e=parseInt(t.getAttribute("x1")||"0",10),n=parseInt(t.getAttribute("y1")||"0",10),i=parseInt(t.getAttribute("x2")||"10",10),r=parseInt(t.getAttribute("y2")||"0",10),o=new uu(e,n,i,r);return function(t,e){var n=t.firstChild;for(;n;){if(1===n.nodeType){var i=n.getAttribute("offset"),r=void 0;r=i.indexOf("%")>0?parseInt(i,10)/100:i?parseFloat(i):0;var o=n.getAttribute("stop-color")||"#000000";e.colorStops.push({offset:r,color:o})}n=n.nextSibling}}(t,o),o}};function bM(t,e){t&&t.__inheritedStyle&&(e.__inheritedStyle||(e.__inheritedStyle={}),T(e.__inheritedStyle,t.__inheritedStyle))}function wM(t){for(var e=ot(t).split(mM),n=[],i=0;i<e.length;i+=2){var r=parseFloat(e[i]),o=parseFloat(e[i+1]);n.push([r,o])}return n}var SM={fill:"fill",stroke:"stroke","stroke-width":"lineWidth",opacity:"opacity","fill-opacity":"fillOpacity","stroke-opacity":"strokeOpacity","stroke-dasharray":"lineDash","stroke-dashoffset":"lineDashOffset","stroke-linecap":"lineCap","stroke-linejoin":"lineJoin","stroke-miterlimit":"miterLimit","font-family":"fontFamily","font-size":"fontSize","font-style":"fontStyle","font-weight":"fontWeight","text-align":"textAlign","alignment-baseline":"textBaseline"};function MM(t,e,n,i){var r=e,o=r.__inheritedStyle||{};if(1===t.nodeType&&(function(t,e){var n=t.getAttribute("transform");if(n){n=n.replace(/,/g," ");var i=[],r=null;n.replace(CM,(function(t,e,n){return i.push(e,n),""}));for(var o=i.length-1;o>0;o-=2){var a=i[o],s=void 0;switch(r=r||[1,0,0,1,0,0],i[o-1]){case"translate":s=ot(a).split(mM),me(r,r,[parseFloat(s[0]),parseFloat(s[1]||"0")]);break;case"scale":s=ot(a).split(mM),xe(r,r,[parseFloat(s[0]),parseFloat(s[1]||s[0])]);break;case"rotate":s=ot(a).split(mM),_e(r,r,parseFloat(s[0]));break;case"skew":s=ot(a).split(mM),console.warn("Skew transform is not supported yet");break;case"matrix":s=ot(a).split(mM),r[0]=parseFloat(s[0]),r[1]=parseFloat(s[1]),r[2]=parseFloat(s[2]),r[3]=parseFloat(s[3]),r[4]=parseFloat(s[4]),r[5]=parseFloat(s[5])}}e.setLocalTransform(r)}}(t,e),I(o,function(t){var e=t.getAttribute("style"),n={};if(!e)return n;var i,r={};AM.lastIndex=0;for(;null!=(i=AM.exec(e));)r[i[1]]=i[2];for(var o in SM)SM.hasOwnProperty(o)&&null!=r[o]&&(n[SM[o]]=r[o]);return n}(t)),!i))for(var a in SM)if(SM.hasOwnProperty(a)){var s=t.getAttribute(a);null!=s&&(o[SM[a]]=s)}r.style=r.style||{},null!=o.fill&&(r.style.fill=TM(o.fill,n)),null!=o.stroke&&(r.style.stroke=TM(o.stroke,n)),P(["lineWidth","opacity","fillOpacity","strokeOpacity","miterLimit","fontSize"],(function(t){null!=o[t]&&(r.style[t]=parseFloat(o[t]))})),o.textBaseline&&"auto"!==o.textBaseline||(o.textBaseline="alphabetic"),"alphabetic"===o.textBaseline&&(o.textBaseline="bottom"),"start"===o.textAlign&&(o.textAlign="left"),"end"===o.textAlign&&(o.textAlign="right"),P(["lineDashOffset","lineCap","lineJoin","fontWeight","fontFamily","fontStyle","textAlign","textBaseline"],(function(t){null!=o[t]&&(r.style[t]=o[t])})),o.lineDash&&(r.style.lineDash=O(ot(o.lineDash).split(mM),(function(t){return parseFloat(t)}))),r.__inheritedStyle=o}var IM=/url\(\s*#(.*?)\)/;function TM(t,e){var n=e&&t&&t.match(IM);return n?e[ot(n[1])]:t}var CM=/(translate|scale|rotate|skewX|skewY|matrix)\(([\-\s0-9\.e,]*)\)/g;var AM=/([^\s:;]+)\s*:\s*([^:;]+)/g;function DM(t,e,n){var i=e/t.width,r=n/t.height,o=Math.min(i,r);return{scale:o,x:-(t.x+t.width/2)*o+e/2,y:-(t.y+t.height/2)*o+n/2}}var LM=Lr();function kM(t,e){var n,i,r,o,a=t.svgXML;try{rt(null!=(i=(n=a&&(r=a,o={ignoreViewBox:!0,ignoreRootClip:!0},(new _M).parse(r,o))||{}).root))}catch(t){throw new Error("Invalid svg format\n"+t.message)}var s=n.width,l=n.height,u=n.viewBoxRect;if(e||(e=null==s||null==l?i.getBoundingRect():new Rn(0,0,0,0),null!=s&&(e.width=s),null!=l&&(e.height=l)),u){var h=DM(u,e.width,e.height),c=i;(i=new zi).add(c),c.scaleX=c.scaleY=h.scale,c.x=h.x,c.y=h.y}return i.setClipPath(new os({shape:e.plain()})),{root:i,boundingRect:e}}var PM={geoJSON:gM,svg:{load:function(t,e){var n=LM(e).originRoot;if(n)return{root:n,boundingRect:LM(e).boundingRect};var i=kM(e);return LM(e).originRoot=i.root,LM(e).boundingRect=i.boundingRect,i},makeGraphic:function(t,e,n){var i=LM(e),r=i.rootMap||(i.rootMap=ht()),o=r.get(n);if(o)return o;var a=i.originRoot,s=i.boundingRect;return i.originRootHostKey?o=kM(e,s).root:(i.originRootHostKey=n,o=a),r.set(n,o)},removeGraphic:function(t,e,n){var i=LM(e),r=i.rootMap;r&&r.removeKey(n),n===i.originRootHostKey&&(i.originRootHostKey=null)}}},OM=function(t,e,n){var i,r=[],o=ht(),a=ht();return P(EM(t),(function(s){var l=PM[s.type].load(t,s,n);P(l.regions,(function(t){var n=t.name;e&&e.hasOwnProperty(n)&&(t=t.cloneShallow(n=e[n])),r.push(t),o.set(n,t),a.set(n,t.center)}));var u=l.boundingRect;u&&(i?i.union(u):i=u.clone())})),{regions:r,regionsMap:o,nameCoordMap:a,boundingRect:i||new Rn(0,0,0,0)}},RM=function(t,e){var n=EM(t),i=[];return P(n,(function(n){var r=PM[n.type].makeGraphic;r&&i.push(r(t,n,e))})),i},NM=function(t,e){P(EM(t),(function(n){var i=PM[n.type].makeGraphic;i&&i(t,n,e)}))};function EM(t){var e=lg(t)||[];return e}function zM(t){var e=t.getItemStyle(),n=t.get("areaColor");return null!=n&&(e.fill=n),e}var BM=function(){function t(t){var e=new zi;this.uid=Ih("ec_map_draw"),this._controller=new QS(t.getZr()),this._controllerHost={target:e},this.group=e,e.add(this._regionsGroup=new zi),e.add(this._backgroundGroup=new zi)}return t.prototype.draw=function(t,e,n,i,r){var o="geo"===t.mainType,a=t.getData&&t.getData();o&&e.eachComponent({mainType:"series",subType:"map"},(function(e){a||e.getHostGeoModel()!==t||(a=e.getData())}));var s=t.coordinateSystem;this._updateBackground(s);var l,u,h=this._regionsGroup,c=this.group,p=s.getTransformInfo(),d=!h.childAt(0)||r;if(d)c.transform=p.roamTransform,c.decomposeTransform(),c.dirty();else{var f=new ke;f.transform=p.roamTransform,f.decomposeTransform();var g={scaleX:f.scaleX,scaleY:f.scaleY,x:f.x,y:f.y};l=f.scaleX,u=f.scaleY,Ou(c,g,t)}h.removeAll();var y=ht(),v=a&&a.getVisual("visualMeta")&&a.getVisual("visualMeta").length>0;P(s.regions,(function(e){var i=y.get(e.name)||y.set(e.name,new zi),r=new su({segmentIgnoreThreshold:1,shape:{paths:[]}});i.add(r);var s,f=t.getRegionModel(e.name)||t,g=f.getModel("itemStyle"),m=f.getModel("emphasis"),_=m.getModel("itemStyle"),x=f.getModel(["blur","itemStyle"]),b=f.getModel(["select","itemStyle"]),w=zM(g),S=zM(_),M=zM(x),I=zM(b);if(a){s=a.indexOfName(e.name);var T=a.getItemVisual(s,"style"),C=a.getItemVisual(s,"decal");v&&T.fill&&(w.fill=T.fill),C&&(w.decal=ky(C,n))}var A=p.rawScaleX,D=p.rawScaleY,L=p.rawX,k=p.rawY,O=function(t){return[t[0]*A+L,t[1]*D+k]};P(e.geometries,(function(t){if("polygon"===t.type){for(var e=[],n=0;n<t.exterior.length;++n)e.push(O(t.exterior[n]));r.shape.paths.push(new ql({segmentIgnoreThreshold:1,shape:{points:e}}));for(n=0;n<(t.interiors?t.interiors.length:0);++n){for(var i=t.interiors[n],o=[],a=0;a<i.length;++a)o.push(O(i[a]));r.shape.paths.push(new ql({segmentIgnoreThreshold:1,shape:{points:o}}))}}})),r.setStyle(w),r.style.strokeNoScale=!0,r.culling=!0,r.ensureState("emphasis").style=S,r.ensureState("blur").style=M,r.ensureState("select").style=I;for(var R=!1,N=0;N<bs.length;N++){var E=bs[N];if(f.get("normal"===E?["label","show"]:[E,"label","show"])){R=!0;break}}var z=a&&isNaN(a.get(a.mapDimension("value"),s)),B=a&&a.getItemLayout(s);if(o||z&&R||B&&B.showLabel){var V=o?e.name:s,F=void 0;(!a||s>=0)&&(F=t);var G=O(e.center),H=new ls({x:G[0],y:G[1],scaleX:1/c.scaleX,scaleY:1/c.scaleY,z2:10,silent:!0});th(H,eh(f),{labelFetcher:F,labelDataIndex:V,defaultText:e.name},{normal:{align:"center",verticalAlign:"middle"}}),r.setTextContent(H),r.setTextConfig({local:!0}),r.disableLabelAnimation=!0,d||Ou(H,{scaleX:1/l,scaleY:1/u},t)}if(a)a.setItemGraphicEl(s,i);else{var W=t.getRegionModel(e.name);ys(r).eventData={componentType:"geo",componentIndex:t.componentIndex,geoIndex:t.componentIndex,name:e.name,region:W&&W.option||{}}}(i.__regions||(i.__regions=[])).push(e),i.highDownSilentOnTouch=!!t.get("selectedMode"),Js(i,m.get("focus"),m.get("blurScope")),h.add(i)})),this._updateController(t,e,n),this._updateMapSelectHandler(t,h,n,i)},t.prototype.remove=function(){this._regionsGroup.removeAll(),this._backgroundGroup.removeAll(),this._controller.dispose(),this._mapName&&NM(this._mapName,this.uid),this._mapName=null,this._controllerHost=null},t.prototype._updateBackground=function(t){var e=t.map;this._mapName!==e&&P(RM(e,this.uid),(function(t){this._backgroundGroup.add(t)}),this),this._mapName=e},t.prototype._updateController=function(t,e,n){var i=t.coordinateSystem,r=this._controller,o=this._controllerHost;o.zoomLimit=t.get("scaleLimit"),o.zoom=i.getZoom(),r.enable(t.get("roam")||!1);var a=t.mainType;function s(){var e={type:"geoRoam",componentType:a};return e[a+"Id"]=t.id,e}r.off("pan").on("pan",(function(t){this._mouseDownFlag=!1,iM(o,t.dx,t.dy),n.dispatchAction(I(s(),{dx:t.dx,dy:t.dy}))}),this),r.off("zoom").on("zoom",(function(t){this._mouseDownFlag=!1,rM(o,t.scale,t.originX,t.originY),n.dispatchAction(I(s(),{zoom:t.scale,originX:t.originX,originY:t.originY}));var e=this.group;this._regionsGroup.traverse((function(t){var n=t.getTextContent();n&&(n.scaleX=1/e.scaleX,n.scaleY=1/e.scaleY,n.markRedraw())}))}),this),r.setPointerChecker((function(e,r,o){return i.getViewRectAfterRoam().contain(r,o)&&!aM(e,n,t)}))},t.prototype._updateMapSelectHandler=function(t,e,n,i){var r=this;e.off("mousedown"),t.get("selectedMode")&&(e.on("mousedown",(function(){r._mouseDownFlag=!0})),e.on("click",(function(t){r._mouseDownFlag&&(r._mouseDownFlag=!1)})))},t}(),VM=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n,i){if(!i||"mapToggleSelect"!==i.type||i.from!==this.uid){var r=this.group;if(r.removeAll(),!t.getHostGeoModel()){if(i&&"geoRoam"===i.type&&"series"===i.componentType&&i.seriesId===t.id)(o=this._mapDraw)&&r.add(o.group);else if(t.needsDrawMap){var o=this._mapDraw||new BM(n);r.add(o.group),o.draw(t,e,n,this,i),this._mapDraw=o}else this._mapDraw&&this._mapDraw.remove(),this._mapDraw=null;t.get("showLegendSymbol")&&e.getComponent("legend")&&this._renderSymbols(t,e,n)}}},e.prototype.remove=function(){this._mapDraw&&this._mapDraw.remove(),this._mapDraw=null,this.group.removeAll()},e.prototype.dispose=function(){this._mapDraw&&this._mapDraw.remove(),this._mapDraw=null},e.prototype._renderSymbols=function(t,e,n){var i=t.originalData,r=this.group;i.each(i.mapDimension("value"),(function(e,n){if(!isNaN(e)){var o=i.getItemLayout(n);if(o&&o.point){var a=o.point,s=o.offset,l=new Tl({style:{fill:t.getData().getVisual("style").fill},shape:{cx:a[0]+9*s,cy:a[1],r:3},silent:!0,z2:8+(s?0:11)});if(!s){var u=t.mainSeries.getData(),h=i.getName(n),c=u.indexOfName(h),p=i.getItemModel(n),d=p.getModel("label"),f=u.getItemGraphicEl(c);th(l,eh(p),{labelFetcher:{getFormattedLabel:function(e,n){return t.getFormattedLabel(c,n)}}}),l.disableLabelAnimation=!0,d.get("position")||l.setTextConfig({position:"bottom"}),f.onHoverStateChange=function(t){l.useState(t)}}r.add(l)}}}))},e.type="map",e}(yf),FM=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.needsDrawMap=!1,n.seriesGroup=[],n.getTooltipPosition=function(t){if(null!=t){var e=this.getData().getName(t),n=this.coordinateSystem,i=n.getRegion(e);return i&&n.dataToPoint(i.center)}},n}return n(e,t),e.prototype.getInitialData=function(t){for(var e=Rw(this,{coordDimensions:["value"],encodeDefaulter:V(Qc,this)}),n=ht(),i=[],r=0,o=e.count();r<o;r++){var a=e.getName(r);n.set(a,!0)}return P(OM(this.getMapType(),this.option.nameMap,this.option.nameProperty).regions,(function(t){var e=t.name;n.get(e)||i.push(e)})),e.appendValues([],i),e},e.prototype.getHostGeoModel=function(){var t=this.option.geoIndex;return null!=t?this.ecModel.getComponent("geo",t):null},e.prototype.getMapType=function(){return(this.getHostGeoModel()||this).option.map},e.prototype.getRawValue=function(t){var e=this.getData();return e.get(e.mapDimension("value"),t)},e.prototype.getRegionModel=function(t){var e=this.getData();return e.getItemModel(e.indexOfName(t))},e.prototype.formatTooltip=function(t,e,n){for(var i=this.getData(),r=this.getRawValue(t),o=i.getName(t),a=this.seriesGroup,s=[],l=0;l<a.length;l++){var u=a[l].originalData.indexOfName(o),h=i.mapDimension("value");isNaN(a[l].originalData.get(h,u))||s.push(a[l].name)}return Yd("section",{header:s.join(", "),noHeader:!s.length,blocks:[Yd("nameValue",{name:o,value:r})]})},e.prototype.setZoom=function(t){this.option.zoom=t},e.prototype.setCenter=function(t){this.option.center=t},e.type="series.map",e.dependencies=["geo"],e.layoutMode="box",e.defaultOption={zlevel:0,z:2,coordinateSystem:"geo",map:"",left:"center",top:"center",aspectScale:.75,showLegendSymbol:!0,boundingCoords:null,center:null,zoom:1,scaleLimit:null,selectedMode:!0,label:{show:!1,color:"#000"},itemStyle:{borderWidth:.5,borderColor:"#444",areaColor:"#eee"},emphasis:{label:{show:!0,color:"rgb(100,0,0)"},itemStyle:{areaColor:"rgba(255,215,0,0.8)"}},select:{label:{show:!0,color:"rgb(100,0,0)"},itemStyle:{color:"rgba(255,215,0,0.8)"}},nameProperty:"name"},e}(rf);function GM(t){var e={};t.eachSeriesByType("map",(function(t){var n=t.getHostGeoModel(),i=n?"o"+n.id:"i"+t.getMapType();(e[i]=e[i]||[]).push(t)})),P(e,(function(t,e){for(var n,i,r,o=(n=O(t,(function(t){return t.getData()})),i=t[0].get("mapValueCalculation"),r={},P(n,(function(t){t.each(t.mapDimension("value"),(function(e,n){var i="ec-"+t.getName(n);r[i]=r[i]||[],isNaN(e)||r[i].push(e)}))})),n[0].map(n[0].mapDimension("value"),(function(t,e){for(var o="ec-"+n[0].getName(e),a=0,s=1/0,l=-1/0,u=r[o].length,h=0;h<u;h++)s=Math.min(s,r[o][h]),l=Math.max(l,r[o][h]),a+=r[o][h];return 0===u?NaN:"min"===i?s:"max"===i?l:"average"===i?a/u:a}))),a=0;a<t.length;a++)t[a].originalData=t[a].getData();for(a=0;a<t.length;a++)t[a].seriesGroup=t,t[a].needsDrawMap=0===a&&!t[a].getHostGeoModel(),t[a].setData(o.cloneShallow()),t[a].mainSeries=t[0]}))}function HM(t){var e={};t.eachSeriesByType("map",(function(n){var i=n.getMapType();if(!n.getHostGeoModel()&&!e[i]){var r={};P(n.seriesGroup,(function(e){var n=e.coordinateSystem,i=e.originalData;e.get("showLegendSymbol")&&t.getComponent("legend")&&i.each(i.mapDimension("value"),(function(t,e){var o=i.getName(e),a=n.getRegion(o);if(a&&!isNaN(t)){var s=r[o]||0,l=n.dataToPoint(a.center);r[o]=s+1,i.setItemLayout(e,{point:l,offset:s})}}))}));var o=n.getData();o.each((function(t){var e=o.getName(t),n=o.getItemLayout(t)||{};n.showLabel=!r[e],o.setItemLayout(t,n)})),e[i]=!0}}))}var WM=Rt,YM=function(t){function e(e){var n=t.call(this)||this;return n.type="view",n.dimensions=["x","y"],n._roamTransformable=new ke,n._rawTransformable=new ke,n.name=e,n}return n(e,t),e.prototype.setBoundingRect=function(t,e,n,i){return this._rect=new Rn(t,e,n,i),this._rect},e.prototype.getBoundingRect=function(){return this._rect},e.prototype.setViewRect=function(t,e,n,i){this.transformTo(t,e,n,i),this._viewRect=new Rn(t,e,n,i)},e.prototype.transformTo=function(t,e,n,i){var r=this.getBoundingRect(),o=this._rawTransformable;o.transform=r.calculateTransform(new Rn(t,e,n,i)),o.decomposeTransform(),this._updateTransform()},e.prototype.setCenter=function(t){t&&(this._center=t,this._updateCenterAndZoom())},e.prototype.setZoom=function(t){t=t||1;var e=this.zoomLimit;e&&(null!=e.max&&(t=Math.min(e.max,t)),null!=e.min&&(t=Math.max(e.min,t))),this._zoom=t,this._updateCenterAndZoom()},e.prototype.getDefaultCenter=function(){var t=this.getBoundingRect();return[t.x+t.width/2,t.y+t.height/2]},e.prototype.getCenter=function(){return this._center||this.getDefaultCenter()},e.prototype.getZoom=function(){return this._zoom||1},e.prototype.getRoamTransform=function(){return this._roamTransformable.getLocalTransform()},e.prototype._updateCenterAndZoom=function(){var t=this._rawTransformable.getLocalTransform(),e=this._roamTransformable,n=this.getDefaultCenter(),i=this.getCenter(),r=this.getZoom();i=Rt([],i,t),n=Rt([],n,t),e.originX=i[0],e.originY=i[1],e.x=n[0]-i[0],e.y=n[1]-i[1],e.scaleX=e.scaleY=r,this._updateTransform()},e.prototype._updateTransform=function(){var t=this._roamTransformable,e=this._rawTransformable;e.parent=t,t.updateTransform(),e.updateTransform(),ye(this.transform||(this.transform=[]),e.transform||[1,0,0,1,0,0]),this._rawTransform=e.getLocalTransform(),this.invTransform=this.invTransform||[],be(this.invTransform,this.transform),this.decomposeTransform()},e.prototype.getTransformInfo=function(){var t=this._roamTransformable.transform,e=this._rawTransformable;return{roamTransform:t?nt(t):[1,0,0,1,0,0],rawScaleX:e.scaleX,rawScaleY:e.scaleY,rawX:e.x,rawY:e.y}},e.prototype.getViewRect=function(){return this._viewRect},e.prototype.getViewRectAfterRoam=function(){var t=this.getBoundingRect().clone();return t.applyTransform(this.transform),t},e.prototype.dataToPoint=function(t,e,n){var i=e?this._rawTransform:this.transform;return n=n||[],i?WM(n,t,i):vt(n,t)},e.prototype.pointToData=function(t){var e=this.invTransform;return e?WM([],t,e):[t[0],t[1]]},e.prototype.convertToPixel=function(t,e,n){var i=XM(e);return i===this?i.dataToPoint(n):null},e.prototype.convertFromPixel=function(t,e,n){var i=XM(e);return i===this?i.pointToData(n):null},e.prototype.containPoint=function(t){return this.getViewRectAfterRoam().contain(t[0],t[1])},e.dimensions=["x","y"],e}(ke);function XM(t){var e=t.seriesModel;return e?e.coordinateSystem:null}var UM=function(t){function e(e,n,i,r){var o=t.call(this,e)||this;o.dimensions=["lng","lat"],o.type="geo",o.map=n;var a=OM(n,i);return o._nameCoordMap=a.nameCoordMap,o._regionsMap=a.regionsMap,o._invertLongitute=null==r||r,o.regions=a.regions,o._rect=a.boundingRect,o}return n(e,t),e.prototype.containCoord=function(t){for(var e=this.regions,n=0;n<e.length;n++)if(e[n].contain(t))return!0;return!1},e.prototype.transformTo=function(t,e,n,i){var r=this.getBoundingRect(),o=this._invertLongitute;r=r.clone(),o&&(r.y=-r.y-r.height);var a=this._rawTransformable;a.transform=r.calculateTransform(new Rn(t,e,n,i)),a.decomposeTransform(),o&&(a.scaleY=-a.scaleY),a.updateTransform(),this._updateTransform()},e.prototype.getRegion=function(t){return this._regionsMap.get(t)},e.prototype.getRegionByCoord=function(t){for(var e=this.regions,n=0;n<e.length;n++)if(e[n].contain(t))return e[n]},e.prototype.addGeoCoord=function(t,e){this._nameCoordMap.set(t,e)},e.prototype.getGeoCoord=function(t){return this._nameCoordMap.get(t)},e.prototype.getBoundingRect=function(){return this._rect},e.prototype.dataToPoint=function(t,e,n){if("string"==typeof t&&(t=this.getGeoCoord(t)),t)return YM.prototype.dataToPoint.call(this,t,e,n)},e.prototype.convertToPixel=function(t,e,n){var i=ZM(e);return i===this?i.dataToPoint(n):null},e.prototype.convertFromPixel=function(t,e,n){var i=ZM(e);return i===this?i.pointToData(n):null},e}(YM);function ZM(t){var e=t.geoModel,n=t.seriesModel;return e?e.coordinateSystem:n?n.coordinateSystem||(n.getReferringComponents("geo",Or).models[0]||{}).coordinateSystem:null}function jM(t,e){var n=t.get("boundingCoords");if(null!=n){var i=n[0],r=n[1];isNaN(i[0])||isNaN(i[1])||isNaN(r[0])||isNaN(r[1])||this.setBoundingRect(i[0],i[1],r[0]-i[0],r[1]-i[1])}var o,a,s,l=this.getBoundingRect(),u=t.get("layoutCenter"),h=t.get("layoutSize"),c=e.getWidth(),p=e.getHeight(),d=l.width/l.height*this.aspectScale,f=!1;if(u&&h&&(o=[Zi(u[0],c),Zi(u[1],p)],a=Zi(h,Math.min(c,p)),isNaN(o[0])||isNaN(o[1])||isNaN(a)||(f=!0)),f)s={},d>1?(s.width=a,s.height=a/d):(s.height=a,s.width=a*d),s.y=o[1]-s.height/2,s.x=o[0]-s.width/2;else{var g=t.getBoxLayoutParams();g.aspect=d,s=Ac(g,{width:c,height:p})}this.setViewRect(s.x,s.y,s.width,s.height),this.setCenter(t.get("center")),this.setZoom(t.get("zoom"))}L(UM,YM);var qM=new(function(){function t(){this.dimensions=UM.prototype.dimensions}return t.prototype.create=function(t,e){var n=[];t.eachComponent("geo",(function(t,i){var r=t.get("map"),o=t.get("aspectScale"),a=!0,s=lg(r);s&&s[0]&&"svg"===s[0].type?(null==o&&(o=1),a=!1):null==o&&(o=.75);var l=new UM(r+i,r,t.get("nameMap"),a);l.aspectScale=o,l.zoomLimit=t.get("scaleLimit"),n.push(l),t.coordinateSystem=l,l.model=t,l.resize=jM,l.resize(t,e)})),t.eachSeries((function(t){if("geo"===t.get("coordinateSystem")){var e=t.get("geoIndex")||0;t.coordinateSystem=n[e]}}));var i={};return t.eachSeriesByType("map",(function(t){if(!t.getHostGeoModel()){var e=t.getMapType();i[e]=i[e]||[],i[e].push(t)}})),P(i,(function(t,i){var r=O(t,(function(t){return t.get("nameMap")})),o=new UM(i,i,M(r));o.zoomLimit=Q.apply(null,O(t,(function(t){return t.get("scaleLimit")}))),n.push(o),o.resize=jM,o.aspectScale=t[0].get("aspectScale"),o.resize(t[0],e),P(t,(function(t){t.coordinateSystem=o,function(t,e){P(e.get("geoCoord"),(function(e,n){t.addGeoCoord(n,e)}))}(o,t)}))})),n},t.prototype.getFilledRegions=function(t,e,n){for(var i=(t||[]).slice(),r=ht(),o=0;o<i.length;o++)r.set(i[o].name,i[o]);return P(OM(e,n).regions,(function(t){var e=t.name;!r.get(e)&&i.push({name:e})})),i},t}()),KM=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(e,n,i){t.prototype.init.call(this,e,n,i),xr(e,"label",["show"])},e.prototype.optionUpdated=function(){var t=this.option,e=this;t.regions=qM.getFilledRegions(t.regions,t.map,t.nameMap);var n={};this._optionModelMap=R(t.regions||[],(function(t,i){var r=i.name;return r&&(t.set(r,new Sh(i,e)),i.selected&&(n[r]=!0)),t}),ht()),t.selectedMap||(t.selectedMap=n)},e.prototype.getRegionModel=function(t){return this._optionModelMap.get(t)||new Sh(null,this,this.ecModel)},e.prototype.getFormattedLabel=function(t,e){var n=this.getRegionModel(t),i="normal"===e?n.get(["label","formatter"]):n.get(["emphasis","label","formatter"]),r={name:t};return"function"==typeof i?(r.status=e,i(r)):"string"==typeof i?i.replace("{a}",null!=t?t:""):void 0},e.prototype.setZoom=function(t){this.option.zoom=t},e.prototype.setCenter=function(t){this.option.center=t},e.prototype.select=function(t){var e=this.option,n=e.selectedMode;n&&("multiple"!==n&&(e.selectedMap=null),(e.selectedMap||(e.selectedMap={}))[t]=!0)},e.prototype.unSelect=function(t){var e=this.option.selectedMap;e&&(e[t]=!1)},e.prototype.toggleSelected=function(t){this[this.isSelected(t)?"unSelect":"select"](t)},e.prototype.isSelected=function(t){var e=this.option.selectedMap;return!(!e||!e[t])},e.prototype._initSelectedMapFromData=function(){},e.type="geo",e.layoutMode="box",e.defaultOption={zlevel:0,z:0,show:!0,left:"center",top:"center",aspectScale:null,silent:!1,map:"",boundingCoords:null,center:null,zoom:1,scaleLimit:null,label:{show:!1,color:"#000"},itemStyle:{borderWidth:.5,borderColor:"#444",color:"#eee"},emphasis:{label:{show:!0,color:"rgb(100,0,0)"},itemStyle:{color:"rgba(255,215,0,0.8)"}},select:{label:{show:!0,color:"rgb(100,0,0)"},itemStyle:{color:"rgba(255,215,0,0.8)"}},regions:[]},e}(Nc);function $M(t,e,n){var i=t.getZoom(),r=t.getCenter(),o=e.zoom,a=t.dataToPoint(r);if(null!=e.dx&&null!=e.dy&&(a[0]-=e.dx,a[1]-=e.dy,t.setCenter(t.pointToData(a))),null!=o){if(n){var s=n.min||0,l=n.max||1/0;o=Math.max(Math.min(i*o,l),s)/i}t.scaleX*=o,t.scaleY*=o;var u=(e.originX-t.x)*(o-1),h=(e.originY-t.y)*(o-1);t.x-=u,t.y-=h,t.updateTransform(),t.setCenter(t.pointToData(a)),t.setZoom(o*i)}return{center:t.getCenter(),zoom:t.getZoom()}}var JM=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(t,e){var n=new BM(e);this._mapDraw=n,this.group.add(n.group),this._api=e},e.prototype.render=function(t,e,n,i){var r=this._mapDraw;t.get("show")?r.draw(t,e,n,this,i):this._mapDraw.group.removeAll(),r.group.on("click",this._handleRegionClick,this),r.group.silent=t.get("silent"),this._model=t,this.updateSelectStatus(t,e,n)},e.prototype._handleRegionClick=function(t){for(var e,n=t.target;n&&null==(e=ys(n).eventData);)n=n.__hostTarget||n.parent;e&&this._api.dispatchAction({type:"geoToggleSelect",geoId:this._model.id,name:e.name})},e.prototype.updateSelectStatus=function(t,e,n){var i=this;this._mapDraw.group.traverse((function(t){var e=ys(t).eventData;if(e)return i._model.isSelected(e.name)?n.enterSelect(t):n.leaveSelect(t),!0}))},e.prototype.dispose=function(){this._mapDraw&&this._mapDraw.remove()},e.type="geo",e}(pf);function QM(t){function e(e,n){n.update="geo:updateSelectStatus",t.registerAction(n,(function(t,n){var i={};return n.eachComponent({mainType:"geo",query:t},(function(n){n[e](t.name),P(n.coordinateSystem.regions,(function(t){i[t.name]=n.isSelected(t.name)||!1}))})),{selected:i,name:t.name}}))}t.registerCoordinateSystem("geo",qM),t.registerComponentModel(KM),t.registerComponentView(JM),e("toggleSelected",{type:"geoToggleSelect",event:"geoselectchanged"}),e("select",{type:"geoSelect",event:"geoselected"}),e("unSelect",{type:"geoUnSelect",event:"geounselected"}),t.registerAction({type:"geoRoam",event:"geoRoam",update:"updateTransform"},(function(t,e){var n=t.componentType||"series";e.eachComponent({mainType:n,query:t},(function(e){var i=e.coordinateSystem;if("geo"===i.type){var r=$M(i,t,e.get("scaleLimit"));e.setCenter&&e.setCenter(r.center),e.setZoom&&e.setZoom(r.zoom),"series"===n&&P(e.seriesGroup,(function(t){t.setCenter(r.center),t.setZoom(r.zoom)}))}}))}))}function tI(t,e){var n=t.isExpand?t.children:[],i=t.parentNode.children,r=t.hierNode.i?i[t.hierNode.i-1]:null;if(n.length){!function(t){var e=t.children,n=e.length,i=0,r=0;for(;--n>=0;){var o=e[n];o.hierNode.prelim+=i,o.hierNode.modifier+=i,r+=o.hierNode.change,i+=o.hierNode.shift+r}}(t);var o=(n[0].hierNode.prelim+n[n.length-1].hierNode.prelim)/2;r?(t.hierNode.prelim=r.hierNode.prelim+e(t,r),t.hierNode.modifier=t.hierNode.prelim-o):t.hierNode.prelim=o}else r&&(t.hierNode.prelim=r.hierNode.prelim+e(t,r));t.parentNode.hierNode.defaultAncestor=function(t,e,n,i){if(e){for(var r=t,o=t,a=o.parentNode.children[0],s=e,l=r.hierNode.modifier,u=o.hierNode.modifier,h=a.hierNode.modifier,c=s.hierNode.modifier;s=rI(s),o=oI(o),s&&o;){r=rI(r),a=oI(a),r.hierNode.ancestor=t;var p=s.hierNode.prelim+c-o.hierNode.prelim-u+i(s,o);p>0&&(sI(aI(s,t,n),t,p),u+=p,l+=p),c+=s.hierNode.modifier,u+=o.hierNode.modifier,l+=r.hierNode.modifier,h+=a.hierNode.modifier}s&&!rI(r)&&(r.hierNode.thread=s,r.hierNode.modifier+=c-l),o&&!oI(a)&&(a.hierNode.thread=o,a.hierNode.modifier+=u-h,n=t)}return n}(t,r,t.parentNode.hierNode.defaultAncestor||i[0],e)}function eI(t){var e=t.hierNode.prelim+t.parentNode.hierNode.modifier;t.setLayout({x:e},!0),t.hierNode.modifier+=t.parentNode.hierNode.modifier}function nI(t){return arguments.length?t:lI}function iI(t,e){return t-=Math.PI/2,{x:e*Math.cos(t),y:e*Math.sin(t)}}function rI(t){var e=t.children;return e.length&&t.isExpand?e[e.length-1]:t.hierNode.thread}function oI(t){var e=t.children;return e.length&&t.isExpand?e[0]:t.hierNode.thread}function aI(t,e,n){return t.hierNode.ancestor.parentNode===e.parentNode?t.hierNode.ancestor:n}function sI(t,e,n){var i=n/(e.hierNode.i-t.hierNode.i);e.hierNode.change-=i,e.hierNode.shift+=n,e.hierNode.modifier+=n,e.hierNode.prelim+=n,t.hierNode.change+=i}function lI(t,e){return t.parentNode===e.parentNode?1:2}var uI=function(){this.parentPoint=[],this.childPoints=[]},hI=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new uI},e.prototype.buildPath=function(t,e){var n=e.childPoints,i=n.length,r=e.parentPoint,o=n[0],a=n[i-1];if(1===i)return t.moveTo(r[0],r[1]),void t.lineTo(o[0],o[1]);var s=e.orient,l="TB"===s||"BT"===s?0:1,u=1-l,h=Zi(e.forkPosition,1),c=[];c[l]=r[l],c[u]=r[u]+(a[u]-r[u])*h,t.moveTo(r[0],r[1]),t.lineTo(c[0],c[1]),t.moveTo(o[0],o[1]),c[l]=o[l],t.lineTo(c[0],c[1]),c[l]=a[l],t.lineTo(c[0],c[1]),t.lineTo(a[0],a[1]);for(var p=1;p<i-1;p++){var d=n[p];t.moveTo(d[0],d[1]),c[l]=d[l],t.lineTo(c[0],c[1])}},e}(Za),cI=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._mainGroup=new zi,n}return n(e,t),e.prototype.init=function(t,e){this._controller=new QS(e.getZr()),this._controllerHost={target:this.group},this.group.add(this._mainGroup)},e.prototype.render=function(t,e,n){var i=t.getData(),r=t.layoutInfo,o=this._mainGroup;"radial"===t.get("layout")?(o.x=r.x+r.width/2,o.y=r.y+r.height/2):(o.x=r.x,o.y=r.y),this._updateViewCoordSys(t),this._updateController(t,e,n);var a=this._data;i.diff(a).add((function(e){pI(i,e)&&dI(i,e,null,o,t)})).update((function(e,n){var r=a.getItemGraphicEl(n);pI(i,e)?dI(i,e,r,o,t):r&&fI(a,n,r,o,t)})).remove((function(e){var n=a.getItemGraphicEl(e);n&&fI(a,e,n,o,t)})).execute(),this._nodeScaleRatio=t.get("nodeScaleRatio"),this._updateNodeAndLinkScale(t),!0===t.get("expandAndCollapse")&&i.eachItemGraphicEl((function(e,i){e.off("click").on("click",(function(){n.dispatchAction({type:"treeExpandAndCollapse",seriesId:t.id,dataIndex:i})}))})),this._data=i},e.prototype._updateViewCoordSys=function(t){var e=t.getData(),n=[];e.each((function(t){var i=e.getItemLayout(t);!i||isNaN(i.x)||isNaN(i.y)||n.push([+i.x,+i.y])}));var i=[],r=[];ea(n,i,r);var o=this._min,a=this._max;r[0]-i[0]==0&&(i[0]=o?o[0]:i[0]-1,r[0]=a?a[0]:r[0]+1),r[1]-i[1]==0&&(i[1]=o?o[1]:i[1]-1,r[1]=a?a[1]:r[1]+1);var s=t.coordinateSystem=new YM;s.zoomLimit=t.get("scaleLimit"),s.setBoundingRect(i[0],i[1],r[0]-i[0],r[1]-i[1]),s.setCenter(t.get("center")),s.setZoom(t.get("zoom")),this.group.attr({x:s.x,y:s.y,scaleX:s.scaleX,scaleY:s.scaleY}),this._min=i,this._max=r},e.prototype._updateController=function(t,e,n){var i=this,r=this._controller,o=this._controllerHost,a=this.group;r.setPointerChecker((function(e,i,r){var o=a.getBoundingRect();return o.applyTransform(a.transform),o.contain(i,r)&&!aM(e,n,t)})),r.enable(t.get("roam")),o.zoomLimit=t.get("scaleLimit"),o.zoom=t.coordinateSystem.getZoom(),r.off("pan").off("zoom").on("pan",(function(e){iM(o,e.dx,e.dy),n.dispatchAction({seriesId:t.id,type:"treeRoam",dx:e.dx,dy:e.dy})})).on("zoom",(function(e){rM(o,e.scale,e.originX,e.originY),n.dispatchAction({seriesId:t.id,type:"treeRoam",zoom:e.scale,originX:e.originX,originY:e.originY}),i._updateNodeAndLinkScale(t),n.updateLabelLayout()}))},e.prototype._updateNodeAndLinkScale=function(t){var e=t.getData(),n=this._getNodeGlobalScale(t);e.eachItemGraphicEl((function(t,e){t.setSymbolScale(n)}))},e.prototype._getNodeGlobalScale=function(t){var e=t.coordinateSystem;if("view"!==e.type)return 1;var n=this._nodeScaleRatio,i=e.scaleX||1;return((e.getZoom()-1)*n+1)/i},e.prototype.dispose=function(){this._controller&&this._controller.dispose(),this._controllerHost=null},e.prototype.remove=function(){this._mainGroup.removeAll(),this._data=null},e.type="tree",e}(yf);function pI(t,e){var n=t.getItemLayout(e);return n&&!isNaN(n.x)&&!isNaN(n.y)}function dI(t,e,n,i,r){var o=!n,a=t.tree.getNodeByDataIndex(e),s=a.getModel(),l=a.getVisual("style").fill,u=!1===a.isExpand&&0!==a.children.length?l:"#fff",h=t.tree.root,c=a.parentNode===h?a:a.parentNode||a,p=t.getItemGraphicEl(c.dataIndex),d=c.getLayout(),f=p?{x:p.__oldX,y:p.__oldY,rawX:p.__radialOldRawX,rawY:p.__radialOldRawY}:d,g=a.getLayout();o?((n=new bb(t,e,null,{symbolInnerColor:u,useNameLabel:!0})).x=f.x,n.y=f.y):n.updateData(t,e,null,{symbolInnerColor:u,useNameLabel:!0}),n.__radialOldRawX=n.__radialRawX,n.__radialOldRawY=n.__radialRawY,n.__radialRawX=g.rawX,n.__radialRawY=g.rawY,i.add(n),t.setItemGraphicEl(e,n),n.__oldX=n.x,n.__oldY=n.y,Ou(n,{x:g.x,y:g.y},r);var y=n.getSymbolPath();if("radial"===r.get("layout")){var v=h.children[0],m=v.getLayout(),_=v.children.length,x=void 0,b=void 0;if(g.x===m.x&&!0===a.isExpand){var w={x:(v.children[0].getLayout().x+v.children[_-1].getLayout().x)/2,y:(v.children[0].getLayout().y+v.children[_-1].getLayout().y)/2};(x=Math.atan2(w.y-m.y,w.x-m.x))<0&&(x=2*Math.PI+x),(b=w.x<m.x)&&(x-=Math.PI)}else(x=Math.atan2(g.y-m.y,g.x-m.x))<0&&(x=2*Math.PI+x),0===a.children.length||0!==a.children.length&&!1===a.isExpand?(b=g.x<m.x)&&(x-=Math.PI):(b=g.x>m.x)||(x-=Math.PI);var S=b?"left":"right",M=s.getModel("label"),I=M.get("rotate"),C=I*(Math.PI/180),A=y.getTextContent();A&&(y.setTextConfig({position:M.get("position")||S,rotation:null==I?-x:C,origin:"center"}),A.setStyle("verticalAlign","middle"))}var D=s.get(["emphasis","focus"]),L="ancestor"===D?a.getAncestorsIndices():"descendant"===D?a.getDescendantIndices():null;L&&(ys(n).focus=L),function(t,e,n,i,r,o,a,s){var l=e.getModel(),u=t.get("edgeShape"),h=t.get("layout"),c=t.getOrient(),p=t.get(["lineStyle","curveness"]),d=t.get("edgeForkPosition"),f=l.getModel("lineStyle").getLineStyle(),g=i.__edge;if("curve"===u)e.parentNode&&e.parentNode!==n&&(g||(g=i.__edge=new ru({shape:gI(h,c,p,r,r)})),Ou(g,{shape:gI(h,c,p,o,a)},t));else if("polyline"===u)if("orthogonal"===h){if(e!==n&&e.children&&0!==e.children.length&&!0===e.isExpand){for(var y=e.children,v=[],m=0;m<y.length;m++){var _=y[m].getLayout();v.push([_.x,_.y])}g||(g=i.__edge=new hI({shape:{parentPoint:[a.x,a.y],childPoints:[[a.x,a.y]],orient:c,forkPosition:d}})),Ou(g,{shape:{parentPoint:[a.x,a.y],childPoints:v}},t)}}else 0;g&&(g.useStyle(T({strokeNoScale:!0,fill:null},f)),nl(g,l,"lineStyle"),Gs(g),s.add(g))}(r,a,h,n,f,d,g,i),n.__edge&&(n.onHoverStateChange=function(e){if("blur"!==e){var i=a.parentNode&&t.getItemGraphicEl(a.parentNode.dataIndex);i&&1===i.hoverState||Vs(n.__edge,e)}})}function fI(t,e,n,i,r){for(var o,a=t.tree.getNodeByDataIndex(e),s=t.tree.root,l=a.parentNode===s?a:a.parentNode||a;null==(o=l.getLayout());)l=l.parentNode===s?l:l.parentNode||l;var u={duration:r.get("animationDurationUpdate"),easing:r.get("animationEasingUpdate")};Nu(n,{x:o.x+1,y:o.y+1},r,{cb:function(){i.remove(n),t.setItemGraphicEl(e,null)},removeOpt:u}),n.fadeOut(null,{fadeLabel:!0,animation:u});var h=t.getItemGraphicEl(l.dataIndex).__edge,c=n.__edge||(!1===l.isExpand||1===l.children.length?h:void 0),p=r.get("edgeShape"),d=r.get("layout"),f=r.get("orient"),g=r.get(["lineStyle","curveness"]);c&&("curve"===p?Nu(c,{shape:gI(d,f,g,o,o),style:{opacity:0}},r,{cb:function(){i.remove(c)},removeOpt:u}):"polyline"===p&&"orthogonal"===r.get("layout")&&Nu(c,{shape:{parentPoint:[o.x,o.y],childPoints:[[o.x,o.y]]},style:{opacity:0}},r,{cb:function(){i.remove(c)},removeOpt:u}))}function gI(t,e,n,i,r){var o,a,s,l,u,h,c,p;if("radial"===t){u=i.rawX,c=i.rawY,h=r.rawX,p=r.rawY;var d=iI(u,c),f=iI(u,c+(p-c)*n),g=iI(h,p+(c-p)*n),y=iI(h,p);return{x1:d.x||0,y1:d.y||0,x2:y.x||0,y2:y.y||0,cpx1:f.x||0,cpy1:f.y||0,cpx2:g.x||0,cpy2:g.y||0}}return u=i.x,c=i.y,h=r.x,p=r.y,"LR"!==e&&"RL"!==e||(o=u+(h-u)*n,a=c,s=h+(u-h)*n,l=p),"TB"!==e&&"BT"!==e||(o=u,a=c+(p-c)*n,s=h,l=p+(c-p)*n),{x1:u,y1:c,x2:h,y2:p,cpx1:o,cpy1:a,cpx2:s,cpy2:l}}var yI=Lr();function vI(t){var e=t.mainData,n=t.datas;n||(n={main:e},t.datasAttr={main:"data"}),t.datas=t.mainData=null,SI(e,n,t),P(n,(function(n){P(e.TRANSFERABLE_METHODS,(function(e){n.wrapMethod(e,V(mI,t))}))})),e.wrapMethod("cloneShallow",V(xI,t)),P(e.CHANGABLE_METHODS,(function(n){e.wrapMethod(n,V(_I,t))})),rt(n[e.dataType]===e)}function mI(t,e){if(yI(i=this).mainData===i){var n=I({},yI(this).datas);n[this.dataType]=e,SI(e,n,t)}else MI(e,this.dataType,yI(this).mainData,t);var i;return e}function _I(t,e){return t.struct&&t.struct.update(),e}function xI(t,e){return P(yI(e).datas,(function(n,i){n!==e&&MI(n.cloneShallow(),i,e,t)})),e}function bI(t){var e=yI(this).mainData;return null==t||null==e?e:yI(e).datas[t]}function wI(){var t=yI(this).mainData;return null==t?[{data:t}]:O(z(yI(t).datas),(function(e){return{type:e,data:yI(t).datas[e]}}))}function SI(t,e,n){yI(t).datas={},P(e,(function(e,i){MI(e,i,t,n)}))}function MI(t,e,n,i){yI(n).datas[e]=t,yI(t).mainData=n,t.dataType=e,i.struct&&(t[i.structAttr]=i.struct,i.struct[i.datasAttr[e]]=t),t.getLinkedData=bI,t.getLinkedDataAll=wI}var II=function(){function t(t,e){this.depth=0,this.height=0,this.dataIndex=-1,this.children=[],this.viewChildren=[],this.isExpand=!1,this.name=t||"",this.hostTree=e}return t.prototype.isRemoved=function(){return this.dataIndex<0},t.prototype.eachNode=function(t,e,n){"function"==typeof t&&(n=e,e=t,t=null),H(t=t||{})&&(t={order:t});var i,r=t.order||"preorder",o=this[t.attr||"children"];"preorder"===r&&(i=e.call(n,this));for(var a=0;!i&&a<o.length;a++)o[a].eachNode(t,e,n);"postorder"===r&&e.call(n,this)},t.prototype.updateDepthAndHeight=function(t){var e=0;this.depth=t;for(var n=0;n<this.children.length;n++){var i=this.children[n];i.updateDepthAndHeight(t+1),i.height>e&&(e=i.height)}this.height=e+1},t.prototype.getNodeById=function(t){if(this.getId()===t)return this;for(var e=0,n=this.children,i=n.length;e<i;e++){var r=n[e].getNodeById(t);if(r)return r}},t.prototype.contains=function(t){if(t===this)return!0;for(var e=0,n=this.children,i=n.length;e<i;e++){var r=n[e].contains(t);if(r)return r}},t.prototype.getAncestors=function(t){for(var e=[],n=t?this:this.parentNode;n;)e.push(n),n=n.parentNode;return e.reverse(),e},t.prototype.getAncestorsIndices=function(){for(var t=[],e=this;e;)t.push(e.dataIndex),e=e.parentNode;return t.reverse(),t},t.prototype.getDescendantIndices=function(){var t=[];return this.eachNode((function(e){t.push(e.dataIndex)})),t},t.prototype.getValue=function(t){var e=this.hostTree.data;return e.get(e.getDimension(t||"value"),this.dataIndex)},t.prototype.setLayout=function(t,e){this.dataIndex>=0&&this.hostTree.data.setItemLayout(this.dataIndex,t,e)},t.prototype.getLayout=function(){return this.hostTree.data.getItemLayout(this.dataIndex)},t.prototype.getModel=function(t){if(!(this.dataIndex<0))return this.hostTree.data.getItemModel(this.dataIndex).getModel(t)},t.prototype.getLevelModel=function(){return(this.hostTree.levelModels||[])[this.depth]},t.prototype.setVisual=function(t,e){this.dataIndex>=0&&this.hostTree.data.setItemVisual(this.dataIndex,t,e)},t.prototype.getVisual=function(t){return this.hostTree.data.getItemVisual(this.dataIndex,t)},t.prototype.getRawIndex=function(){return this.hostTree.data.getRawIndex(this.dataIndex)},t.prototype.getId=function(){return this.hostTree.data.getId(this.dataIndex)},t.prototype.isAncestorOf=function(t){for(var e=t.parentNode;e;){if(e===this)return!0;e=e.parentNode}return!1},t.prototype.isDescendantOf=function(t){return t!==this&&t.isAncestorOf(this)},t}(),TI=function(){function t(t){this.type="tree",this._nodes=[],this.hostModel=t}return t.prototype.eachNode=function(t,e,n){this.root.eachNode(t,e,n)},t.prototype.getNodeByDataIndex=function(t){var e=this.data.getRawIndex(t);return this._nodes[e]},t.prototype.getNodeById=function(t){return this.root.getNodeById(t)},t.prototype.update=function(){for(var t=this.data,e=this._nodes,n=0,i=e.length;n<i;n++)e[n].dataIndex=-1;for(n=0,i=t.count();n<i;n++)e[t.getRawIndex(n)].dataIndex=n},t.prototype.clearLayouts=function(){this.data.clearItemLayouts()},t.createTree=function(e,n,i){var r=new t(n),o=[],a=1;!function t(e,n){var i=e.value;a=Math.max(a,F(i)?i.length:1),o.push(e);var s=new II(Tr(e.name,""),r);n?function(t,e){var n=e.children;if(t.parentNode===e)return;n.push(t),t.parentNode=e}(s,n):r.root=s,r._nodes.push(s);var l=e.children;if(l)for(var u=0;u<l.length;u++)t(l[u],s)}(e),r.root.updateDepthAndHeight(0);var s=Nm(o,{coordDimensions:["value"],dimensionsCount:a}),l=new Pm(s,n);return l.initData(o),i&&i(l),vI({mainData:l,struct:r,structAttr:"tree"}),r.update(),r},t}();var CI=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.hasSymbolVisual=!0,e.ignoreStyleOnData=!0,e}return n(e,t),e.prototype.getInitialData=function(t){var e={name:t.name,children:t.data},n=t.leaves||{},i=new Sh(n,this,this.ecModel),r=TI.createTree(e,this,(function(t){t.wrapMethod("getItemModel",(function(t,e){var n=r.getNodeByDataIndex(e);return n.children.length&&n.isExpand||(t.parentModel=i),t}))}));var o=0;r.eachNode("preorder",(function(t){t.depth>o&&(o=t.depth)}));var a=t.expandAndCollapse&&t.initialTreeDepth>=0?t.initialTreeDepth:o;return r.root.eachNode("preorder",(function(t){var e=t.hostTree.data.getRawDataItem(t.dataIndex);t.isExpand=e&&null!=e.collapsed?!e.collapsed:t.depth<=a})),r.data},e.prototype.getOrient=function(){var t=this.get("orient");return"horizontal"===t?t="LR":"vertical"===t&&(t="TB"),t},e.prototype.setZoom=function(t){this.option.zoom=t},e.prototype.setCenter=function(t){this.option.center=t},e.prototype.formatTooltip=function(t,e,n){for(var i=this.getData().tree,r=i.root.children[0],o=i.getNodeByDataIndex(t),a=o.getValue(),s=o.name;o&&o!==r;)s=o.parentNode.name+"."+s,o=o.parentNode;return Yd("nameValue",{name:s,value:a,noValue:isNaN(a)||null==a})},e.type="series.tree",e.layoutMode="box",e.defaultOption={zlevel:0,z:2,coordinateSystem:"view",left:"12%",top:"12%",right:"12%",bottom:"12%",layout:"orthogonal",edgeShape:"curve",edgeForkPosition:"50%",roam:!1,nodeScaleRatio:.4,center:null,zoom:1,orient:"LR",symbol:"emptyCircle",symbolSize:7,expandAndCollapse:!0,initialTreeDepth:2,lineStyle:{color:"#ccc",width:1.5,curveness:.5},itemStyle:{color:"lightsteelblue",borderColor:"#c23531",borderWidth:1.5},label:{show:!0},animationEasing:"linear",animationDuration:700,animationDurationUpdate:500},e}(rf);function AI(t,e){for(var n,i=[t];n=i.pop();)if(e(n),n.isExpand){var r=n.children;if(r.length)for(var o=r.length-1;o>=0;o--)i.push(r[o])}}function DI(t,e){t.eachSeriesByType("tree",(function(t){!function(t,e){var n=function(t,e){return Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()})}(t,e);t.layoutInfo=n;var i=t.get("layout"),r=0,o=0,a=null;"radial"===i?(r=2*Math.PI,o=Math.min(n.height,n.width)/2,a=nI((function(t,e){return(t.parentNode===e.parentNode?1:2)/t.depth}))):(r=n.width,o=n.height,a=nI());var s=t.getData().tree.root,l=s.children[0];if(l){!function(t){var e=t;e.hierNode={defaultAncestor:null,ancestor:e,prelim:0,modifier:0,change:0,shift:0,i:0,thread:null};for(var n,i,r=[e];n=r.pop();)if(i=n.children,n.isExpand&&i.length)for(var o=i.length-1;o>=0;o--){var a=i[o];a.hierNode={defaultAncestor:null,ancestor:a,prelim:0,modifier:0,change:0,shift:0,i:o,thread:null},r.push(a)}}(s),function(t,e,n){for(var i,r=[t],o=[];i=r.pop();)if(o.push(i),i.isExpand){var a=i.children;if(a.length)for(var s=0;s<a.length;s++)r.push(a[s])}for(;i=o.pop();)e(i,n)}(l,tI,a),s.hierNode.modifier=-l.hierNode.prelim,AI(l,eI);var u=l,h=l,c=l;AI(l,(function(t){var e=t.getLayout().x;e<u.getLayout().x&&(u=t),e>h.getLayout().x&&(h=t),t.depth>c.depth&&(c=t)}));var p=u===h?1:a(u,h)/2,d=p-u.getLayout().x,f=0,g=0,y=0,v=0;if("radial"===i)f=r/(h.getLayout().x+p+d),g=o/(c.depth-1||1),AI(l,(function(t){y=(t.getLayout().x+d)*f,v=(t.depth-1)*g;var e=iI(y,v);t.setLayout({x:e.x,y:e.y,rawX:y,rawY:v},!0)}));else{var m=t.getOrient();"RL"===m||"LR"===m?(g=o/(h.getLayout().x+p+d),f=r/(c.depth-1||1),AI(l,(function(t){v=(t.getLayout().x+d)*g,y="LR"===m?(t.depth-1)*f:r-(t.depth-1)*f,t.setLayout({x:y,y:v},!0)}))):"TB"!==m&&"BT"!==m||(f=r/(h.getLayout().x+p+d),g=o/(c.depth-1||1),AI(l,(function(t){y=(t.getLayout().x+d)*f,v="TB"===m?(t.depth-1)*g:o-(t.depth-1)*g,t.setLayout({x:y,y:v},!0)})))}}}(t,e)}))}function LI(t){t.eachSeriesByType("tree",(function(t){var e=t.getData();e.tree.eachNode((function(t){var n=t.getModel().getModel("itemStyle").getItemStyle();I(e.ensureUniqueItemVisual(t.dataIndex,"style"),n)}))}))}function kI(t,e,n){if(t&&A(e,t.type)>=0){var i=n.getData().tree.root,r=t.targetNode;if("string"==typeof r&&(r=i.getNodeById(r)),r&&i.contains(r))return{node:r};var o=t.targetNodeId;if(null!=o&&(r=i.getNodeById(o)))return{node:r}}}function PI(t){for(var e=[];t;)(t=t.parentNode)&&e.push(t);return e.reverse()}function OI(t,e){return A(PI(t),e)>=0}function RI(t,e){for(var n=[];t;){var i=t.dataIndex;n.push({name:t.name,dataIndex:i,value:e.getRawValue(i)}),t=t.parentNode}return n.reverse(),n}var NI=function(){},EI=["treemapZoomToNode","treemapRender","treemapMove"];function zI(t){var e=t.getData().tree,n={};e.eachNode((function(e){for(var i=e;i&&i.depth>1;)i=i.parentNode;var r=hp(t.ecModel,i.name||i.dataIndex+"",n);e.setVisual("decal",r)}))}var BI=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.preventUsingHoverLayer=!0,n}return n(e,t),e.prototype.getInitialData=function(t,e){var n={name:t.name,children:t.data};VI(n);var i=t.levels||[],r=this.designatedVisualItemStyle={},o=new Sh({itemStyle:r},this,e),a=O((i=t.levels=function(t,e){var n,i,r=_r(e.get("color")),o=_r(e.get(["aria","decal","decals"]));if(!r)return;P(t=t||[],(function(t){var e=new Sh(t),r=e.get("color"),o=e.get("decal");(e.get(["itemStyle","color"])||r&&"none"!==r)&&(n=!0),(e.get(["itemStyle","decal"])||o&&"none"!==o)&&(i=!0)}));var a=t[0]||(t[0]={});n||(a.color=r.slice());!i&&o&&(a.decal=o.slice());return t}(i,e))||[],(function(t){return new Sh(t,o,e)}),this),s=TI.createTree(n,this,(function(t){t.wrapMethod("getItemModel",(function(t,e){var n=s.getNodeByDataIndex(e),i=a[n.depth];return t.parentModel=i||o,t}))}));return s.data},e.prototype.optionUpdated=function(){this.resetViewRoot()},e.prototype.formatTooltip=function(t,e,n){var i=this.getData(),r=this.getRawValue(t);return Yd("nameValue",{name:i.getName(t),value:r})},e.prototype.getDataParams=function(e){var n=t.prototype.getDataParams.apply(this,arguments),i=this.getData().tree.getNodeByDataIndex(e);return n.treePathInfo=RI(i,this),n},e.prototype.setLayoutInfo=function(t){this.layoutInfo=this.layoutInfo||{},I(this.layoutInfo,t)},e.prototype.mapIdToIndex=function(t){var e=this._idIndexMap;e||(e=this._idIndexMap=ht(),this._idIndexMapCount=0);var n=e.get(t);return null==n&&e.set(t,n=this._idIndexMapCount++),n},e.prototype.getViewRoot=function(){return this._viewRoot},e.prototype.resetViewRoot=function(t){t?this._viewRoot=t:t=this._viewRoot;var e=this.getRawData().tree.root;t&&(t===e||e.contains(t))||(this._viewRoot=e)},e.prototype.enableAriaDecal=function(){zI(this)},e.type="series.treemap",e.layoutMode="box",e.defaultOption={progressive:0,left:"center",top:"middle",width:"80%",height:"80%",sort:!0,clipWindow:"origin",squareRatio:.5*(1+Math.sqrt(5)),leafDepth:null,drillDownIcon:"▶",zoomToNodeRatio:.1024,roam:!0,nodeClick:"zoomToNode",animation:!0,animationDurationUpdate:900,animationEasing:"quinticInOut",breadcrumb:{show:!0,height:22,left:"center",top:"bottom",emptyItemWidth:25,itemStyle:{color:"rgba(0,0,0,0.7)",textStyle:{color:"#fff"}}},label:{show:!0,distance:0,padding:5,position:"inside",color:"#fff",overflow:"truncate"},upperLabel:{show:!1,position:[0,"50%"],height:20,overflow:"truncate",verticalAlign:"middle"},itemStyle:{color:null,colorAlpha:null,colorSaturation:null,borderWidth:0,gapWidth:0,borderColor:"#fff",borderColorSaturation:null},emphasis:{upperLabel:{show:!0,position:[0,"50%"],ellipsis:!0,verticalAlign:"middle"}},visualDimension:0,visualMin:null,visualMax:null,color:[],colorAlpha:null,colorSaturation:null,colorMappingBy:"index",visibleMin:10,childrenVisibleMin:null,levels:[]},e}(rf);function VI(t){var e=0;P(t.children,(function(t){VI(t);var n=t.value;F(n)&&(n=n[0]),e+=n}));var n=t.value;F(n)&&(n=n[0]),(null==n||isNaN(n))&&(n=e),n<0&&(n=0),F(t.value)?t.value[0]=n:t.value=n}var FI=function(){function t(t){this.group=new zi,t.add(this.group)}return t.prototype.render=function(t,e,n,i){var r=t.getModel("breadcrumb"),o=this.group;if(o.removeAll(),r.get("show")&&n){var a=r.getModel("itemStyle"),s=a.getModel("textStyle"),l={pos:{left:r.get("left"),right:r.get("right"),top:r.get("top"),bottom:r.get("bottom")},box:{width:e.getWidth(),height:e.getHeight()},emptyItemWidth:r.get("emptyItemWidth"),totalWidth:0,renderList:[]};this._prepare(n,l,s),this._renderContent(t,l,a,s,i),Dc(o,l.pos,l.box)}},t.prototype._prepare=function(t,e,n){for(var i=t;i;i=i.parentNode){var r=Tr(i.getModel().get("name"),""),o=n.getTextRect(r),a=Math.max(o.width+16,e.emptyItemWidth);e.totalWidth+=a+8,e.renderList.push({node:i,text:r,width:a})}},t.prototype._renderContent=function(t,e,n,i,r){for(var o,a,s,l,u,h,c,p,d,f=0,g=e.emptyItemWidth,y=t.get(["breadcrumb","height"]),v=(o=e.pos,a=e.box,l=a.width,u=a.height,h=Zi(o.left,l),c=Zi(o.top,u),p=Zi(o.right,l),d=Zi(o.bottom,u),(isNaN(h)||isNaN(parseFloat(o.left)))&&(h=0),(isNaN(p)||isNaN(parseFloat(o.right)))&&(p=l),(isNaN(c)||isNaN(parseFloat(o.top)))&&(c=0),(isNaN(d)||isNaN(parseFloat(o.bottom)))&&(d=u),s=pc(s||0),{width:Math.max(p-h-s[1]-s[3],0),height:Math.max(d-c-s[0]-s[2],0)}),m=e.totalWidth,_=e.renderList,x=_.length-1;x>=0;x--){var b=_[x],w=b.node,S=b.width,M=b.text;m>v.width&&(m-=S-g,S=g,M=null);var I=new ql({shape:{points:GI(f,0,S,y,x===_.length-1,0===x)},style:T(n.getItemStyle(),{lineJoin:"bevel"}),textContent:new ls({style:{text:M,fill:i.getTextColor(),font:i.getFont()}}),textConfig:{position:"inside"},z:10,onclick:V(r,w)});I.disableLabelAnimation=!0,this.group.add(I),HI(I,t,w),f+=S+8}},t.prototype.remove=function(){this.group.removeAll()},t}();function GI(t,e,n,i,r,o){var a=[[r?t:t-5,e],[t+n,e],[t+n,e+i],[r?t:t-5,e+i]];return!o&&a.splice(2,0,[t+n+5,e+i/2]),!r&&a.push([t,e+i/2]),a}function HI(t,e,n){ys(t).eventData={componentType:"series",componentSubType:"treemap",componentIndex:e.componentIndex,seriesIndex:e.componentIndex,seriesName:e.name,seriesType:"treemap",selfType:"breadcrumb",nodeData:{dataIndex:n&&n.dataIndex,name:n&&n.name},treePathInfo:n&&RI(n,e)}}var WI=function(){function t(){this._storage=[],this._elExistsMap={}}return t.prototype.add=function(t,e,n,i,r){return!this._elExistsMap[t.id]&&(this._elExistsMap[t.id]=!0,this._storage.push({el:t,target:e,duration:n,delay:i,easing:r}),!0)},t.prototype.finished=function(t){return this._finishedCallback=t,this},t.prototype.start=function(){for(var t=this,e=this._storage.length,n=function(){--e<=0&&(t._storage.length=0,t._elExistsMap={},t._finishedCallback&&t._finishedCallback())},i=0,r=this._storage.length;i<r;i++){var o=this._storage[i];o.el.animateTo(o.target,{duration:o.duration,delay:o.delay,easing:o.easing,setToFinal:!0,done:n,aborted:n})}return this},t}();var YI=zi,XI=os,UI="label",ZI="upperLabel",jI=qr([["fill","color"],["stroke","strokeColor"],["lineWidth","strokeWidth"],["shadowBlur"],["shadowOffsetX"],["shadowOffsetY"],["shadowColor"]]),qI=function(t){var e=jI(t);return e.stroke=e.fill=e.lineWidth=null,e},KI=Lr(),$I=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._state="ready",n._storage={nodeGroup:[],background:[],content:[]},n}return n(e,t),e.prototype.render=function(t,e,n,i){if(!(A(e.findComponents({mainType:"series",subType:"treemap",query:i}),t)<0)){this.seriesModel=t,this.api=n,this.ecModel=e;var r=kI(i,["treemapZoomToNode","treemapRootToNode"],t),o=i&&i.type,a=t.layoutInfo,s=!this._oldTree,l=this._storage,u="treemapRootToNode"===o&&r&&l?{rootNodeGroup:l.nodeGroup[r.node.getRawIndex()],direction:i.direction}:null,h=this._giveContainerGroup(a),c=this._doRender(h,t,u);s||o&&"treemapZoomToNode"!==o&&"treemapRootToNode"!==o?c.renderFinally():this._doAnimation(h,c,t,u),this._resetController(n),this._renderBreadcrumb(t,n,r)}},e.prototype._giveContainerGroup=function(t){var e=this._containerGroup;return e||(e=this._containerGroup=new YI,this._initEvents(e),this.group.add(e)),e.x=t.x,e.y=t.y,e},e.prototype._doRender=function(t,e,n){var i=e.getData().tree,r=this._oldTree,o={nodeGroup:[],background:[],content:[]},a={nodeGroup:[],background:[],content:[]},s=this._storage,l=[];function u(t,i,r,u){return function(t,e,n,i,r,o,a,s,l,u){if(!a)return;var h=a.getLayout(),c=t.getData(),p=a.getModel();if(c.setItemGraphicEl(a.dataIndex,null),!h||!h.isInView)return;var d=h.width,f=h.height,g=h.borderWidth,y=h.invisible,v=a.getRawIndex(),m=s&&s.getRawIndex(),_=a.viewChildren,x=h.upperHeight,b=_&&_.length,w=p.getModel("itemStyle"),S=p.getModel(["emphasis","itemStyle"]),M=p.getModel(["blur","itemStyle"]),T=p.getModel(["select","itemStyle"]),C=w.get("borderRadius")||0,A=V("nodeGroup",YI);if(!A)return;if(l.add(A),A.x=h.x||0,A.y=h.y||0,A.markRedraw(),KI(A).nodeWidth=d,KI(A).nodeHeight=f,h.isAboveViewRoot)return A;var D=V("background",XI,u,1);D&&R(A,D,b&&h.upperLabelHeight);var L=p.get(["emphasis","focus"]),k=p.get(["emphasis","blurScope"]),P="ancestor"===L?a.getAncestorsIndices():"descendant"===L?a.getDescendantIndices():null;if(b)rl(A)&&il(A,!1),D&&(il(D,!0),c.setItemGraphicEl(a.dataIndex,D),Qs(D,P||L,k));else{var O=V("content",XI,u,2);O&&N(A,O),D&&rl(D)&&il(D,!1),il(A,!0),c.setItemGraphicEl(a.dataIndex,A),Qs(A,P||L,k)}return A;function R(e,n,i){var r=ys(n);if(r.dataIndex=a.dataIndex,r.seriesIndex=t.seriesIndex,n.setShape({x:0,y:0,width:d,height:f,r:C}),y)E(n);else{n.invisible=!1;var o=a.getVisual("style"),s=o.stroke,l=qI(w);l.fill=s;var u=jI(S);u.fill=S.get("borderColor");var h=jI(M);h.fill=M.get("borderColor");var c=jI(T);if(c.fill=T.get("borderColor"),i){var p=d-2*g;z(n,s,p,x,o.opacity,{x:g,y:0,width:p,height:x})}else n.removeTextContent();n.setStyle(l),n.ensureState("emphasis").style=u,n.ensureState("blur").style=h,n.ensureState("select").style=c,Gs(n)}e.add(n)}function N(e,n){var i=ys(n);i.dataIndex=a.dataIndex,i.seriesIndex=t.seriesIndex;var r=Math.max(d-2*g,0),o=Math.max(f-2*g,0);if(n.culling=!0,n.setShape({x:g,y:g,width:r,height:o,r:C}),y)E(n);else{n.invisible=!1;var s=a.getVisual("style"),l=s.fill,u=qI(w);u.fill=l,u.decal=s.decal;var h=jI(S),c=jI(M),p=jI(T);z(n,l,r,s.opacity),n.setStyle(u),n.ensureState("emphasis").style=h,n.ensureState("blur").style=c,n.ensureState("select").style=p,Gs(n)}e.add(n)}function E(t){!t.invisible&&o.push(t)}function z(e,n,i,r,o,s){var l=p.getModel(s?ZI:UI),u=Q(t.getFormattedLabel(a.dataIndex,"normal",null,null,l.get("formatter")),Tr(p.get("name"),null));if(!s&&h.isLeafRoot){var c=t.get("drillDownIcon",!0);u=c?c+" "+u:u}var d=l.getShallow("show");th(e,eh(p,s?ZI:UI),{defaultText:d?u:null,inheritColor:n,defaultOpacity:i,labelFetcher:t,labelDataIndex:a.dataIndex});var f=e.getTextContent(),g=f.style,y=it(g.padding||0);s&&(e.setTextConfig({layoutRect:s}),f.disableLabelLayout=!0),f.beforeUpdate=function(){var t=Math.max((s?s.width:e.shape.width)-y[1]-y[3],0),n=Math.max((s?s.height:e.shape.height)-y[0]-y[2],0);g.width===t&&g.height===n||f.setStyle({width:t,height:n})},g.truncateMinChar=2,g.lineOverflow="truncate",B(g,s,h);var v=f.getState("emphasis");B(v?v.style:null,s,h)}function B(e,n,i){var r=e?e.text:null;if(!n&&i.isLeafRoot&&null!=r){var o=t.get("drillDownIcon",!0);e.text=o?o+" "+r:r}}function V(t,i,o,a){var s=null!=m&&n[t][m],l=r[t];return s?(n[t][m]=null,F(l,s)):y||((s=new i)instanceof xo&&(s.z=function(t,e){var n=10*t+e;return(n-1)/n}(o,a)),G(l,s)),e[t][v]=s}function F(t,e){var n=t[v]={};e instanceof YI?(n.oldX=e.x,n.oldY=e.y):n.oldShape=I({},e.shape)}function G(t,e){var n=t[v]={},o=a.parentNode,s=e instanceof zi;if(o&&(!i||"drillDown"===i.direction)){var l=0,u=0,h=r.background[o.getRawIndex()];!i&&h&&h.oldShape&&(l=h.oldShape.width,u=h.oldShape.height),s?(n.oldX=0,n.oldY=u):n.oldShape={x:l,y:u,width:0,height:0}}n.fadein=!s}}(e,a,s,n,o,l,t,i,r,u)}!function t(e,n,i,r,o){r?(n=e,P(e,(function(t,e){!t.isRemoved()&&s(e,e)}))):new rm(n,e,a,a).add(s).update(s).remove(V(s,null)).execute();function a(t){return t.getId()}function s(a,s){var l=null!=a?e[a]:null,h=null!=s?n[s]:null,c=u(l,h,i,o);c&&t(l&&l.viewChildren||[],h&&h.viewChildren||[],c,r,o+1)}}(i.root?[i.root]:[],r&&r.root?[r.root]:[],t,i===r||!r,0);var h=function(t){var e={nodeGroup:[],background:[],content:[]};return t&&P(t,(function(t,n){var i=e[n];P(t,(function(t){t&&(i.push(t),KI(t).willDelete=!0)}))})),e}(s);return this._oldTree=i,this._storage=a,{lastsForAnimation:o,willDeleteEls:h,renderFinally:function(){P(h,(function(t){P(t,(function(t){t.parent&&t.parent.remove(t)}))})),P(l,(function(t){t.invisible=!0,t.dirty()}))}}},e.prototype._doAnimation=function(t,e,n,i){if(n.get("animation")){var r=n.get("animationDurationUpdate"),o=n.get("animationEasing"),a=(G(r)?0:r)||0,s=(G(o)?null:o)||"cubicOut",l=new WI;P(e.willDeleteEls,(function(t,e){P(t,(function(t,n){if(!t.invisible){var r,o=t.parent,u=KI(o);if(i&&"drillDown"===i.direction)r=o===i.rootNodeGroup?{shape:{x:0,y:0,width:u.nodeWidth,height:u.nodeHeight},style:{opacity:0}}:{style:{opacity:0}};else{var h=0,c=0;u.willDelete||(h=u.nodeWidth/2,c=u.nodeHeight/2),r="nodeGroup"===e?{x:h,y:c,style:{opacity:0}}:{shape:{x:h,y:c,width:0,height:0},style:{opacity:0}}}r&&l.add(t,r,a,0,s)}}))})),P(this._storage,(function(t,n){P(t,(function(t,i){var r=e.lastsForAnimation[n][i],o={};r&&(t instanceof zi?null!=r.oldX&&(o.x=t.x,o.y=t.y,t.x=r.oldX,t.y=r.oldY):(r.oldShape&&(o.shape=I({},t.shape),t.setShape(r.oldShape)),r.fadein?(t.setStyle("opacity",0),o.style={opacity:1}):1!==t.style.opacity&&(o.style={opacity:1})),l.add(t,o,a,0,s))}))}),this),this._state="animating",l.finished(B((function(){this._state="ready",e.renderFinally()}),this)).start()}},e.prototype._resetController=function(t){var e=this._controller;e||((e=this._controller=new QS(t.getZr())).enable(this.seriesModel.get("roam")),e.on("pan",B(this._onPan,this)),e.on("zoom",B(this._onZoom,this)));var n=new Rn(0,0,t.getWidth(),t.getHeight());e.setPointerChecker((function(t,e,i){return n.contain(e,i)}))},e.prototype._clearController=function(){var t=this._controller;t&&(t.dispose(),t=null)},e.prototype._onPan=function(t){if("animating"!==this._state&&(Math.abs(t.dx)>3||Math.abs(t.dy)>3)){var e=this.seriesModel.getData().tree.root;if(!e)return;var n=e.getLayout();if(!n)return;this.api.dispatchAction({type:"treemapMove",from:this.uid,seriesId:this.seriesModel.id,rootRect:{x:n.x+t.dx,y:n.y+t.dy,width:n.width,height:n.height}})}},e.prototype._onZoom=function(t){var e=t.originX,n=t.originY;if("animating"!==this._state){var i=this.seriesModel.getData().tree.root;if(!i)return;var r=i.getLayout();if(!r)return;var o=new Rn(r.x,r.y,r.width,r.height),a=this.seriesModel.layoutInfo,s=[1,0,0,1,0,0];me(s,s,[-(e-=a.x),-(n-=a.y)]),xe(s,s,[t.scale,t.scale]),me(s,s,[e,n]),o.applyTransform(s),this.api.dispatchAction({type:"treemapRender",from:this.uid,seriesId:this.seriesModel.id,rootRect:{x:o.x,y:o.y,width:o.width,height:o.height}})}},e.prototype._initEvents=function(t){var e=this;t.on("click",(function(t){if("ready"===e._state){var n=e.seriesModel.get("nodeClick",!0);if(n){var i=e.findTarget(t.offsetX,t.offsetY);if(i){var r=i.node;if(r.getLayout().isLeafRoot)e._rootToNode(i);else if("zoomToNode"===n)e._zoomToNode(i);else if("link"===n){var o=r.hostTree.data.getItemModel(r.dataIndex),a=o.get("link",!0),s=o.get("target",!0)||"blank";a&&wc(a,s)}}}}}),this)},e.prototype._renderBreadcrumb=function(t,e,n){var i=this;n||(n=null!=t.get("leafDepth",!0)?{node:t.getViewRoot()}:this.findTarget(e.getWidth()/2,e.getHeight()/2))||(n={node:t.getData().tree.root}),(this._breadcrumb||(this._breadcrumb=new FI(this.group))).render(t,e,n.node,(function(e){"animating"!==i._state&&(OI(t.getViewRoot(),e)?i._rootToNode({node:e}):i._zoomToNode({node:e}))}))},e.prototype.remove=function(){this._clearController(),this._containerGroup&&this._containerGroup.removeAll(),this._storage={nodeGroup:[],background:[],content:[]},this._state="ready",this._breadcrumb&&this._breadcrumb.remove()},e.prototype.dispose=function(){this._clearController()},e.prototype._zoomToNode=function(t){this.api.dispatchAction({type:"treemapZoomToNode",from:this.uid,seriesId:this.seriesModel.id,targetNode:t.node})},e.prototype._rootToNode=function(t){this.api.dispatchAction({type:"treemapRootToNode",from:this.uid,seriesId:this.seriesModel.id,targetNode:t.node})},e.prototype.findTarget=function(t,e){var n;return this.seriesModel.getViewRoot().eachNode({attr:"viewChildren",order:"preorder"},(function(i){var r=this._storage.background[i.getRawIndex()];if(r){var o=r.transformCoordToLocal(t,e),a=r.shape;if(!(a.x<=o[0]&&o[0]<=a.x+a.width&&a.y<=o[1]&&o[1]<=a.y+a.height))return!1;n={node:i,offsetX:o[0],offsetY:o[1]}}}),this),n},e.type="treemap",e}(yf);var JI=P,QI=X,tT=-1,eT=function(){function t(e){var n=e.mappingMethod,i=e.type,r=this.option=w(e);this.type=i,this.mappingMethod=n,this._normalizeData=cT[n];var o=t.visualHandlers[i];this.applyVisual=o.applyVisual,this.getColorMapper=o.getColorMapper,this._normalizedToVisual=o._normalizedToVisual[n],"piecewise"===n?(nT(r),function(t){var e=t.pieceList;t.hasSpecialVisual=!1,P(e,(function(e,n){e.originIndex=n,null!=e.visual&&(t.hasSpecialVisual=!0)}))}(r)):"category"===n?r.categories?function(t){var e=t.categories,n=t.categoryMap={},i=t.visual;if(JI(e,(function(t,e){n[t]=e})),!F(i)){var r=[];X(i)?JI(i,(function(t,e){var i=n[e];r[null!=i?i:tT]=t})):r[-1]=i,i=hT(t,r)}for(var o=e.length-1;o>=0;o--)null==i[o]&&(delete n[e[o]],e.pop())}(r):nT(r,!0):(rt("linear"!==n||r.dataExtent),nT(r))}return t.prototype.mapValueToVisual=function(t){var e=this._normalizeData(t);return this._normalizedToVisual(e,t)},t.prototype.getNormalizer=function(){return B(this._normalizeData,this)},t.listVisualTypes=function(){return z(t.visualHandlers)},t.isValidType=function(e){return t.visualHandlers.hasOwnProperty(e)},t.eachVisual=function(t,e,n){X(t)?P(t,e,n):e.call(n,t)},t.mapVisual=function(e,n,i){var r,o=F(e)?[]:X(e)?{}:(r=!0,null);return t.eachVisual(e,(function(t,e){var a=n.call(i,t,e);r?o=a:o[e]=a})),o},t.retrieveVisuals=function(e){var n,i={};return e&&JI(t.visualHandlers,(function(t,r){e.hasOwnProperty(r)&&(i[r]=e[r],n=!0)})),n?i:null},t.prepareVisualTypes=function(t){if(F(t))t=t.slice();else{if(!QI(t))return[];var e=[];JI(t,(function(t,n){e.push(n)})),t=e}return t.sort((function(t,e){return"color"===e&&"color"!==t&&0===t.indexOf("color")?1:-1})),t},t.dependsOn=function(t,e){return"color"===e?!(!t||0!==t.indexOf(e)):t===e},t.findPieceIndex=function(t,e,n){for(var i,r=1/0,o=0,a=e.length;o<a;o++){var s=e[o].value;if(null!=s){if(s===t||"string"==typeof s&&s===t+"")return o;n&&c(s,o)}}for(o=0,a=e.length;o<a;o++){var l=e[o],u=l.interval,h=l.close;if(u){if(u[0]===-1/0){if(pT(h[1],t,u[1]))return o}else if(u[1]===1/0){if(pT(h[0],u[0],t))return o}else if(pT(h[0],u[0],t)&&pT(h[1],t,u[1]))return o;n&&c(u[0],o),n&&c(u[1],o)}}if(n)return t===1/0?e.length-1:t===-1/0?0:i;function c(e,n){var o=Math.abs(e-t);o<r&&(r=o,i=n)}},t.visualHandlers={color:{applyVisual:oT("color"),getColorMapper:function(){var t=this.option;return B("category"===t.mappingMethod?function(t,e){return!e&&(t=this._normalizeData(t)),aT.call(this,t)}:function(e,n,i){var r=!!i;return!n&&(e=this._normalizeData(e)),i=Qe(e,t.parsedVisual,i),r?i:an(i,"rgba")},this)},_normalizedToVisual:{linear:function(t){return an(Qe(t,this.option.parsedVisual),"rgba")},category:aT,piecewise:function(t,e){var n=uT.call(this,e);return null==n&&(n=an(Qe(t,this.option.parsedVisual),"rgba")),n},fixed:sT}},colorHue:iT((function(t,e){return rn(t,e)})),colorSaturation:iT((function(t,e){return rn(t,null,e)})),colorLightness:iT((function(t,e){return rn(t,null,null,e)})),colorAlpha:iT((function(t,e){return on(t,e)})),decal:{applyVisual:oT("decal"),_normalizedToVisual:{linear:null,category:aT,piecewise:null,fixed:null}},opacity:{applyVisual:oT("opacity"),_normalizedToVisual:lT([0,1])},liftZ:{applyVisual:oT("liftZ"),_normalizedToVisual:{linear:sT,category:sT,piecewise:sT,fixed:sT}},symbol:{applyVisual:function(t,e,n){n("symbol",this.mapValueToVisual(t))},_normalizedToVisual:{linear:rT,category:aT,piecewise:function(t,e){var n=uT.call(this,e);return null==n&&(n=rT.call(this,t)),n},fixed:sT}},symbolSize:{applyVisual:oT("symbolSize"),_normalizedToVisual:lT([0,1])}},t}();function nT(t,e){var n=t.visual,i=[];X(n)?JI(n,(function(t){i.push(t)})):null!=n&&i.push(n);e||1!==i.length||{color:1,symbol:1}.hasOwnProperty(t.type)||(i[1]=i[0]),hT(t,i)}function iT(t){return{applyVisual:function(e,n,i){var r=this.mapValueToVisual(e);i("color",t(n("color"),r))},_normalizedToVisual:lT([0,1])}}function rT(t){var e=this.option.visual;return e[Math.round(Ui(t,[0,1],[0,e.length-1],!0))]||{}}function oT(t){return function(e,n,i){i(t,this.mapValueToVisual(e))}}function aT(t){var e=this.option.visual;return e[this.option.loop&&t!==tT?t%e.length:t]}function sT(){return this.option.visual[0]}function lT(t){return{linear:function(e){return Ui(e,t,this.option.visual,!0)},category:aT,piecewise:function(e,n){var i=uT.call(this,n);return null==i&&(i=Ui(e,t,this.option.visual,!0)),i},fixed:sT}}function uT(t){var e=this.option,n=e.pieceList;if(e.hasSpecialVisual){var i=n[eT.findPieceIndex(t,n)];if(i&&i.visual)return i.visual[this.type]}}function hT(t,e){return t.visual=e,"color"===t.type&&(t.parsedVisual=O(e,(function(t){return qe(t)}))),e}var cT={linear:function(t){return Ui(t,this.option.dataExtent,[0,1],!0)},piecewise:function(t){var e=this.option.pieceList,n=eT.findPieceIndex(t,e,!0);if(null!=n)return Ui(n,[0,e.length-1],[0,1],!0)},category:function(t){var e=this.option.categories?this.option.categoryMap[t]:t;return null==e?tT:e},fixed:ft};function pT(t,e,n){return t?e<=n:e<n}var dT=Lr(),fT={seriesType:"treemap",reset:function(t){var e=t.getData().tree.root;e.isRemoved()||gT(e,{},t.getViewRoot().getAncestors(),t)}};function gT(t,e,n,i){var r=t.getModel(),o=t.getLayout(),a=t.hostTree.data;if(o&&!o.invisible&&o.isInView){var s,l=r.getModel("itemStyle"),u=function(t,e,n){var i=I({},e),r=n.designatedVisualItemStyle;return P(["color","colorAlpha","colorSaturation"],(function(n){r[n]=e[n];var o=t.get(n);r[n]=null,null!=o&&(i[n]=o)})),i}(l,e,i),h=a.ensureUniqueItemVisual(t.dataIndex,"style"),c=l.get("borderColor"),p=l.get("borderColorSaturation");null!=p&&(c=function(t,e){return null!=e?rn(e,null,null,t):null}(p,s=yT(u))),h.stroke=c;var d=t.viewChildren;if(d&&d.length){var f=function(t,e,n,i,r,o){if(!o||!o.length)return;var a=mT(e,"color")||null!=r.color&&"none"!==r.color&&(mT(e,"colorAlpha")||mT(e,"colorSaturation"));if(!a)return;var s=e.get("visualMin"),l=e.get("visualMax"),u=n.dataExtent.slice();null!=s&&s<u[0]&&(u[0]=s),null!=l&&l>u[1]&&(u[1]=l);var h=e.get("colorMappingBy"),c={type:a.name,dataExtent:u,visual:a.range};"color"!==c.type||"index"!==h&&"id"!==h?c.mappingMethod="linear":(c.mappingMethod="category",c.loop=!0);var p=new eT(c);return dT(p).drColorMappingBy=h,p}(0,r,o,0,u,d);P(d,(function(t,e){if(t.depth>=n.length||t===n[t.depth]){var o=function(t,e,n,i,r,o){var a=I({},e);if(r){var s=r.type,l="color"===s&&dT(r).drColorMappingBy,u="index"===l?i:"id"===l?o.mapIdToIndex(n.getId()):n.getValue(t.get("visualDimension"));a[s]=r.mapValueToVisual(u)}return a}(r,u,t,e,f,i);gT(t,o,n,i)}}))}else s=yT(u),h.fill=s}}function yT(t){var e=vT(t,"color");if(e){var n=vT(t,"colorAlpha"),i=vT(t,"colorSaturation");return i&&(e=rn(e,null,null,i)),n&&(e=on(e,n)),e}}function vT(t,e){var n=t[e];if(null!=n&&"none"!==n)return n}function mT(t,e){var n=t.get(e);return F(n)&&n.length?{name:e,range:n}:null}var _T=Math.max,xT=Math.min,bT=Q,wT=P,ST=["itemStyle","borderWidth"],MT=["itemStyle","gapWidth"],IT=["upperLabel","show"],TT=["upperLabel","height"],CT={seriesType:"treemap",reset:function(t,e,n,i){var r=n.getWidth(),o=n.getHeight(),a=t.option,s=Ac(t.getBoxLayoutParams(),{width:n.getWidth(),height:n.getHeight()}),l=a.size||[],u=Zi(bT(s.width,l[0]),r),h=Zi(bT(s.height,l[1]),o),c=i&&i.type,p=kI(i,["treemapZoomToNode","treemapRootToNode"],t),d="treemapRender"===c||"treemapMove"===c?i.rootRect:null,f=t.getViewRoot(),g=PI(f);if("treemapMove"!==c){var y="treemapZoomToNode"===c?function(t,e,n,i,r){var o,a=(e||{}).node,s=[i,r];if(!a||a===n)return s;var l=i*r,u=l*t.option.zoomToNodeRatio;for(;o=a.parentNode;){for(var h=0,c=o.children,p=0,d=c.length;p<d;p++)h+=c[p].getValue();var f=a.getValue();if(0===f)return s;u*=h/f;var g=o.getModel(),y=g.get(ST);(u+=4*y*y+(3*y+Math.max(y,PT(g)))*Math.pow(u,.5))>tr&&(u=tr),a=o}u<l&&(u=l);var v=Math.pow(u/l,.5);return[i*v,r*v]}(t,p,f,u,h):d?[d.width,d.height]:[u,h],v=a.sort;v&&"asc"!==v&&"desc"!==v&&(v="desc");var m={squareRatio:a.squareRatio,sort:v,leafDepth:a.leafDepth};f.hostTree.clearLayouts();var _={x:0,y:0,width:y[0],height:y[1],area:y[0]*y[1]};f.setLayout(_),AT(f,m,!1,0),_=f.getLayout(),wT(g,(function(t,e){var n=(g[e+1]||f).getValue();t.setLayout(I({dataExtent:[n,n],borderWidth:0,upperHeight:0},_))}))}var x=t.getData().tree.root;x.setLayout(function(t,e,n){if(e)return{x:e.x,y:e.y};var i={x:0,y:0};if(!n)return i;var r=n.node,o=r.getLayout();if(!o)return i;var a=[o.width/2,o.height/2],s=r;for(;s;){var l=s.getLayout();a[0]+=l.x,a[1]+=l.y,s=s.parentNode}return{x:t.width/2-a[0],y:t.height/2-a[1]}}(s,d,p),!0),t.setLayoutInfo(s),kT(x,new Rn(-s.x,-s.y,r,o),g,f,0)}};function AT(t,e,n,i){var r,o;if(!t.isRemoved()){var a=t.getLayout();r=a.width,o=a.height;var s=t.getModel(),l=s.get(ST),u=s.get(MT)/2,h=PT(s),c=Math.max(l,h),p=l-u,d=c-u;t.setLayout({borderWidth:l,upperHeight:c,upperLabelHeight:h},!0);var f=(r=_T(r-2*p,0))*(o=_T(o-p-d,0)),g=function(t,e,n,i,r,o){var a=t.children||[],s=i.sort;"asc"!==s&&"desc"!==s&&(s=null);var l=null!=i.leafDepth&&i.leafDepth<=o;if(r&&!l)return t.viewChildren=[];!function(t,e){e&&t.sort((function(t,n){var i="asc"===e?t.getValue()-n.getValue():n.getValue()-t.getValue();return 0===i?"asc"===e?t.dataIndex-n.dataIndex:n.dataIndex-t.dataIndex:i}))}(a=N(a,(function(t){return!t.isRemoved()})),s);var u=function(t,e,n){for(var i=0,r=0,o=e.length;r<o;r++)i+=e[r].getValue();var a,s=t.get("visualDimension");e&&e.length?"value"===s&&n?(a=[e[e.length-1].getValue(),e[0].getValue()],"asc"===n&&a.reverse()):(a=[1/0,-1/0],wT(e,(function(t){var e=t.getValue(s);e<a[0]&&(a[0]=e),e>a[1]&&(a[1]=e)}))):a=[NaN,NaN];return{sum:i,dataExtent:a}}(e,a,s);if(0===u.sum)return t.viewChildren=[];if(u.sum=function(t,e,n,i,r){if(!i)return n;for(var o=t.get("visibleMin"),a=r.length,s=a,l=a-1;l>=0;l--){var u=r["asc"===i?a-l-1:l].getValue();u/n*e<o&&(s=l,n-=u)}return"asc"===i?r.splice(0,a-s):r.splice(s,a-s),n}(e,n,u.sum,s,a),0===u.sum)return t.viewChildren=[];for(var h=0,c=a.length;h<c;h++){var p=a[h].getValue()/u.sum*n;a[h].setLayout({area:p})}l&&(a.length&&t.setLayout({isLeafRoot:!0},!0),a.length=0);return t.viewChildren=a,t.setLayout({dataExtent:u.dataExtent},!0),a}(t,s,f,e,n,i);if(g.length){var y={x:p,y:d,width:r,height:o},v=xT(r,o),m=1/0,_=[];_.area=0;for(var x=0,b=g.length;x<b;){var w=g[x];_.push(w),_.area+=w.getLayout().area;var S=DT(_,v,e.squareRatio);S<=m?(x++,m=S):(_.area-=_.pop().getLayout().area,LT(_,v,y,u,!1),v=xT(y.width,y.height),_.length=_.area=0,m=1/0)}if(_.length&&LT(_,v,y,u,!0),!n){var M=s.get("childrenVisibleMin");null!=M&&f<M&&(n=!0)}for(x=0,b=g.length;x<b;x++)AT(g[x],e,n,i+1)}}}function DT(t,e,n){for(var i=0,r=1/0,o=0,a=void 0,s=t.length;o<s;o++)(a=t[o].getLayout().area)&&(a<r&&(r=a),a>i&&(i=a));var l=t.area*t.area,u=e*e*n;return l?_T(u*i/l,l/(u*r)):1/0}function LT(t,e,n,i,r){var o=e===n.width?0:1,a=1-o,s=["x","y"],l=["width","height"],u=n[s[o]],h=e?t.area/e:0;(r||h>n[l[a]])&&(h=n[l[a]]);for(var c=0,p=t.length;c<p;c++){var d=t[c],f={},g=h?d.getLayout().area/h:0,y=f[l[a]]=_T(h-2*i,0),v=n[s[o]]+n[l[o]]-u,m=c===p-1||v<g?v:g,_=f[l[o]]=_T(m-2*i,0);f[s[a]]=n[s[a]]+xT(i,y/2),f[s[o]]=u+xT(i,_/2),u+=m,d.setLayout(f,!0)}n[s[a]]+=h,n[l[a]]-=h}function kT(t,e,n,i,r){var o=t.getLayout(),a=n[r],s=a&&a===t;if(!(a&&!s||r===n.length&&t!==i)){t.setLayout({isInView:!0,invisible:!s&&!e.intersect(o),isAboveViewRoot:s},!0);var l=new Rn(e.x-o.x,e.y-o.y,e.width,e.height);wT(t.viewChildren||[],(function(t){kT(t,l,n,i,r+1)}))}}function PT(t){return t.get(IT)?t.get(TT):0}function OT(t){var e=t.findComponents({mainType:"legend"});e&&e.length&&t.eachSeriesByType("graph",(function(t){var n=t.getCategoriesData(),i=t.getGraph().data,r=n.mapArray(n.getName);i.filterSelf((function(t){var n=i.getItemModel(t).getShallow("category");if(null!=n){"number"==typeof n&&(n=r[n]);for(var o=0;o<e.length;o++)if(!e[o].isSelected(n))return!1}return!0}))}))}function RT(t){var e={};t.eachSeriesByType("graph",(function(t){var n=t.getCategoriesData(),i=t.getData(),r={};n.each((function(i){var o=n.getName(i);r["ec-"+o]=i;var a=n.getItemModel(i),s=a.getModel("itemStyle").getItemStyle();s.fill||(s.fill=t.getColorFromPalette(o,e)),n.setItemVisual(i,"style",s);for(var l=["symbol","symbolSize","symbolKeepAspect"],u=0;u<l.length;u++){var h=a.getShallow(l[u],!0);null!=h&&n.setItemVisual(i,l[u],h)}})),n.count()&&i.each((function(t){var e=i.getItemModel(t).getShallow("category");if(null!=e){"string"==typeof e&&(e=r["ec-"+e]);var o=n.getItemVisual(e,"style");I(i.ensureUniqueItemVisual(t,"style"),o);for(var a=["symbol","symbolSize","symbolKeepAspect"],s=0;s<a.length;s++)i.setItemVisual(t,a[s],n.getItemVisual(e,a[s]))}}))}))}function NT(t){return t instanceof Array||(t=[t,t]),t}function ET(t){t.eachSeriesByType("graph",(function(t){var e=t.getGraph(),n=t.getEdgeData(),i=NT(t.get("edgeSymbol")),r=NT(t.get("edgeSymbolSize"));n.setVisual("fromSymbol",i&&i[0]),n.setVisual("toSymbol",i&&i[1]),n.setVisual("fromSymbolSize",r&&r[0]),n.setVisual("toSymbolSize",r&&r[1]),n.setVisual("style",t.getModel("lineStyle").getLineStyle()),n.each((function(t){var i=n.getItemModel(t),r=e.getEdgeByIndex(t),o=NT(i.getShallow("symbol",!0)),a=NT(i.getShallow("symbolSize",!0)),s=i.getModel("lineStyle").getLineStyle(),l=n.ensureUniqueItemVisual(t,"style");switch(I(l,s),l.stroke){case"source":var u=r.node1.getVisual("style");l.stroke=u&&u.fill;break;case"target":u=r.node2.getVisual("style");l.stroke=u&&u.fill}o[0]&&r.setVisual("fromSymbol",o[0]),o[1]&&r.setVisual("toSymbol",o[1]),a[0]&&r.setVisual("fromSymbolSize",a[0]),a[1]&&r.setVisual("toSymbolSize",a[1])}))}))}var zT="--\x3e",BT=function(t){return t.get("autoCurveness")||null},VT=function(t,e){var n=BT(t),i=20,r=[];if("number"==typeof n)i=n;else if(F(n))return void(t.__curvenessList=n);e>i&&(i=e);var o=i%2?i+2:i+3;r=[];for(var a=0;a<o;a++)r.push((a%2?a+1:a)/10*(a%2?-1:1));t.__curvenessList=r},FT=function(t,e,n){var i=[t.id,t.dataIndex].join("."),r=[e.id,e.dataIndex].join(".");return[n.uid,i,r].join(zT)},GT=function(t){var e=t.split(zT);return[e[0],e[2],e[1]].join(zT)},HT=function(t,e){var n=e.__edgeMap;return n[t]?n[t].length:0};function WT(t,e,n,i){var r=BT(e),o=F(r);if(!r)return null;var a=function(t,e){var n=FT(t.node1,t.node2,e);return e.__edgeMap[n]}(t,e);if(!a)return null;for(var s=-1,l=0;l<a.length;l++)if(a[l]===n){s=l;break}var u=function(t,e){return HT(FT(t.node1,t.node2,e),e)+HT(FT(t.node2,t.node1,e),e)}(t,e);VT(e,u),t.lineStyle=t.lineStyle||{};var h=FT(t.node1,t.node2,e),c=e.__curvenessList,p=o||u%2?0:1;if(a.isForward)return c[p+s];var d=GT(h),f=HT(d,e),g=c[s+f+p];return i?o?r&&0===r[0]?(f+p)%2?g:-g:((f%2?0:1)+p)%2?g:-g:(f+p)%2?g:-g:c[s+f+p]}function YT(t){var e=t.coordinateSystem;if(!e||"view"===e.type){var n=t.getGraph();n.eachNode((function(t){var e=t.getModel();t.setLayout([+e.get("x"),+e.get("y")])})),XT(n,t)}}function XT(t,e){t.eachEdge((function(t,n){var i=et(t.getModel().get(["lineStyle","curveness"]),-WT(t,e,n,!0),0),r=mt(t.node1.getLayout()),o=mt(t.node2.getLayout()),a=[r,o];+i&&a.push([(r[0]+o[0])/2-(r[1]-o[1])*i,(r[1]+o[1])/2-(o[0]-r[0])*i]),t.setLayout(a)}))}function UT(t,e){t.eachSeriesByType("graph",(function(t){var e=t.get("layout"),n=t.coordinateSystem;if(n&&"view"!==n.type){var i=t.getData(),r=[];P(n.dimensions,(function(t){r=r.concat(i.mapDimensionsAll(t))}));for(var o=0;o<i.count();o++){for(var a=[],s=!1,l=0;l<r.length;l++){var u=i.get(r[l],o);isNaN(u)||(s=!0),a.push(u)}s?i.setItemLayout(o,n.dataToPoint(a)):i.setItemLayout(o,[NaN,NaN])}XT(i.graph,t)}else e&&"none"!==e||YT(t)}))}function ZT(t){var e=t.coordinateSystem;if("view"!==e.type)return 1;var n=t.option.nodeScaleRatio,i=e.scaleX;return((e.getZoom()-1)*n+1)/i}function jT(t){var e=t.getVisual("symbolSize");return e instanceof Array&&(e=(e[0]+e[1])/2),+e}var qT=Math.PI,KT=[];function $T(t,e){var n=t.coordinateSystem;if(!n||"view"===n.type){var i=n.getBoundingRect(),r=t.getData(),o=r.graph,a=i.width/2+i.x,s=i.height/2+i.y,l=Math.min(i.width,i.height)/2,u=r.count();r.setLayout({cx:a,cy:s}),u&&(JT[e](t,o,r,l,a,s,u),o.eachEdge((function(e,n){var i,r=et(e.getModel().get(["lineStyle","curveness"]),WT(e,t,n),0),o=mt(e.node1.getLayout()),l=mt(e.node2.getLayout()),u=(o[0]+l[0])/2,h=(o[1]+l[1])/2;+r&&(i=[a*(r*=3)+u*(1-r),s*r+h*(1-r)]),e.setLayout([o,l,i])})))}}var JT={value:function(t,e,n,i,r,o,a){var s=0,l=n.getSum("value"),u=2*Math.PI/(l||a);e.eachNode((function(t){var e=t.getValue("value"),n=u*(l?e:1)/2;s+=n,t.setLayout([i*Math.cos(s)+r,i*Math.sin(s)+o]),s+=n}))},symbolSize:function(t,e,n,i,r,o,a){var s=0;KT.length=a;var l=ZT(t);e.eachNode((function(t){var e=jT(t);isNaN(e)&&(e=2),e<0&&(e=0),e*=l;var n=Math.asin(e/2/i);isNaN(n)&&(n=qT/2),KT[t.dataIndex]=n,s+=2*n}));var u=(2*qT-s)/a/2,h=0;e.eachNode((function(t){var e=u+KT[t.dataIndex];h+=e,t.setLayout([i*Math.cos(h)+r,i*Math.sin(h)+o]),h+=e}))}};function QT(t){t.eachSeriesByType("graph",(function(t){"circular"===t.get("layout")&&$T(t,"symbolSize")}))}var tC=bt;function eC(t){t.eachSeriesByType("graph",(function(t){var e=t.coordinateSystem;if(!e||"view"===e.type)if("force"===t.get("layout")){var n=t.preservedPoints||{},i=t.getGraph(),r=i.data,o=i.edgeData,a=t.getModel("force"),s=a.get("initLayout");t.preservedPoints?r.each((function(t){var e=r.getId(t);r.setItemLayout(t,n[e]||[NaN,NaN])})):s&&"none"!==s?"circular"===s&&$T(t,"value"):YT(t);var l=r.getDataExtent("value"),u=o.getDataExtent("value"),h=a.get("repulsion"),c=a.get("edgeLength"),p=F(h)?h:[h,h],d=F(c)?c:[c,c];d=[d[1],d[0]];var f=r.mapArray("value",(function(t,e){var n=r.getItemLayout(e),i=Ui(t,l,p);return isNaN(i)&&(i=(p[0]+p[1])/2),{w:i,rep:i,fixed:r.getItemModel(e).get("fixed"),p:!n||isNaN(n[0])||isNaN(n[1])?null:n}})),g=o.mapArray("value",(function(e,n){var r=i.getEdgeByIndex(n),o=Ui(e,u,d);isNaN(o)&&(o=(d[0]+d[1])/2);var a=r.getModel(),s=et(r.getModel().get(["lineStyle","curveness"]),-WT(r,t,n,!0),0);return{n1:f[r.node1.dataIndex],n2:f[r.node2.dataIndex],d:o,curveness:s,ignoreForceLayout:a.get("ignoreForceLayout")}})),y=e.getBoundingRect(),v=function(t,e,n){for(var i=t,r=e,o=n.rect,a=o.width,s=o.height,l=[o.x+a/2,o.y+s/2],u=null==n.gravity?.1:n.gravity,h=0;h<i.length;h++){var c=i[h];c.p||(c.p=yt(a*(Math.random()-.5)+l[0],s*(Math.random()-.5)+l[1])),c.pp=mt(c.p),c.edges=null}var p,d,f=null==n.friction?.6:n.friction,g=f;return{warmUp:function(){g=.8*f},setFixed:function(t){i[t].fixed=!0},setUnfixed:function(t){i[t].fixed=!1},beforeStep:function(t){p=t},afterStep:function(t){d=t},step:function(t){p&&p(i,r);for(var e=[],n=i.length,o=0;o<r.length;o++){var a=r[o];if(!a.ignoreForceLayout){var s=a.n1;wt(e,(y=a.n2).p,s.p);var h=St(e)-a.d,c=y.w/(s.w+y.w);isNaN(c)&&(c=0),At(e,e),!s.fixed&&tC(s.p,s.p,e,c*h*g),!y.fixed&&tC(y.p,y.p,e,-(1-c)*h*g)}}for(o=0;o<n;o++)(_=i[o]).fixed||(wt(e,l,_.p),tC(_.p,_.p,e,u*g));for(o=0;o<n;o++){s=i[o];for(var f=o+1;f<n;f++){var y;wt(e,(y=i[f]).p,s.p),0===(h=St(e))&&(_t(e,Math.random()-.5,Math.random()-.5),h=1);var v=(s.rep+y.rep)/h/h;!s.fixed&&tC(s.pp,s.pp,e,v),!y.fixed&&tC(y.pp,y.pp,e,-v)}}var m=[];for(o=0;o<n;o++){var _;(_=i[o]).fixed||(wt(m,_.p,_.pp),tC(_.p,_.p,m,g),vt(_.pp,_.p))}var x=(g*=.992)<.01;d&&d(i,r,x),t&&t(x)}}}(f,g,{rect:y,gravity:a.get("gravity"),friction:a.get("friction")});v.beforeStep((function(t,e){for(var n=0,r=t.length;n<r;n++)t[n].fixed&&vt(t[n].p,i.getNodeByIndex(n).getLayout())})),v.afterStep((function(t,e,o){for(var a=0,s=t.length;a<s;a++)t[a].fixed||i.getNodeByIndex(a).setLayout(t[a].p),n[r.getId(a)]=t[a].p;for(a=0,s=e.length;a<s;a++){var l=e[a],u=i.getEdgeByIndex(a),h=l.n1.p,c=l.n2.p,p=u.getLayout();(p=p?p.slice():[])[0]=p[0]||[],p[1]=p[1]||[],vt(p[0],h),vt(p[1],c),+l.curveness&&(p[2]=[(h[0]+c[0])/2-(h[1]-c[1])*l.curveness,(h[1]+c[1])/2-(c[0]-h[0])*l.curveness]),u.setLayout(p)}})),t.forceLayout=v,t.preservedPoints=n,v.step()}else t.forceLayout=null}))}function nC(t,e){var n=[];return t.eachSeriesByType("graph",(function(t){var i=t.get("coordinateSystem");if(!i||"view"===i){var r=t.getData(),o=[],a=[];ea(r.mapArray((function(t){var e=r.getItemModel(t);return[+e.get("x"),+e.get("y")]})),o,a),a[0]-o[0]==0&&(a[0]+=1,o[0]-=1),a[1]-o[1]==0&&(a[1]+=1,o[1]-=1);var s=(a[0]-o[0])/(a[1]-o[1]),l=function(t,e,n){return Ac(I(t.getBoxLayoutParams(),{aspect:n}),{width:e.getWidth(),height:e.getHeight()})}(t,e,s);isNaN(s)&&(o=[l.x,l.y],a=[l.x+l.width,l.y+l.height]);var u=a[0]-o[0],h=a[1]-o[1],c=l.width,p=l.height,d=t.coordinateSystem=new YM;d.zoomLimit=t.get("scaleLimit"),d.setBoundingRect(o[0],o[1],u,h),d.setViewRect(l.x,l.y,c,p),d.setCenter(t.get("center")),d.setZoom(t.get("zoom")),n.push(d)}})),n}var iC=tu.prototype,rC=ru.prototype,oC=function(){this.x1=0,this.y1=0,this.x2=0,this.y2=0,this.percent=1};!function(t){function e(){return null!==t&&t.apply(this,arguments)||this}n(e,t)}(oC);function aC(t){return isNaN(+t.cpx1)||isNaN(+t.cpy1)}var sC=function(t){function e(e){var n=t.call(this,e)||this;return n.type="ec-line",n}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new oC},e.prototype.buildPath=function(t,e){aC(e)?iC.buildPath.call(this,t,e):rC.buildPath.call(this,t,e)},e.prototype.pointAt=function(t){return aC(this.shape)?iC.pointAt.call(this,t):rC.pointAt.call(this,t)},e.prototype.tangentAt=function(t){var e=this.shape,n=aC(e)?[e.x2-e.x1,e.y2-e.y1]:rC.tangentAt.call(this,t);return At(n,n)},e}(Za),lC=["fromSymbol","toSymbol"];function uC(t){return"_"+t+"Type"}function hC(t,e,n){var i=e.getItemVisual(n,t);if(i&&"none"!==i){var r=e.getItemVisual(n,t+"Size"),o=e.getItemVisual(n,t+"Rotate"),a=F(r)?r:[r,r],s=uy(i,-a[0]/2,-a[1]/2,a[0],a[1]);return s.__specifiedRotation=null==o||isNaN(o)?void 0:+o*Math.PI/180||0,s.name=t,s}}function cC(t,e){t.x1=e[0][0],t.y1=e[0][1],t.x2=e[1][0],t.y2=e[1][1],t.percent=1;var n=e[2];n?(t.cpx1=n[0],t.cpy1=n[1]):(t.cpx1=NaN,t.cpy1=NaN)}var pC=function(t){function e(e,n,i){var r=t.call(this)||this;return r._createLine(e,n,i),r}return n(e,t),e.prototype._createLine=function(t,e,n){var i=t.hostModel,r=function(t){var e=new sC({name:"line",subPixelOptimize:!0});return cC(e.shape,t),e}(t.getItemLayout(e));r.shape.percent=0,Ru(r,{shape:{percent:1}},i,e),this.add(r),P(lC,(function(n){var i=hC(n,t,e);this.add(i),this[uC(n)]=t.getItemVisual(e,n)}),this),this._updateCommonStl(t,e,n)},e.prototype.updateData=function(t,e,n){var i=t.hostModel,r=this.childOfName("line"),o=t.getItemLayout(e),a={shape:{}};cC(a.shape,o),Ou(r,a,i,e),P(lC,(function(n){var i=t.getItemVisual(e,n),r=uC(n);if(this[r]!==i){this.remove(this.childOfName(n));var o=hC(n,t,e);this.add(o)}this[r]=i}),this),this._updateCommonStl(t,e,n)},e.prototype.getLinePath=function(){return this.childAt(0)},e.prototype._updateCommonStl=function(t,e,n){var i=t.hostModel,r=this.childOfName("line"),o=n&&n.emphasisLineStyle,a=n&&n.blurLineStyle,s=n&&n.selectLineStyle,l=n&&n.labelStatesModels;if(!n||t.hasItemOption){var u=t.getItemModel(e);o=u.getModel(["emphasis","lineStyle"]).getLineStyle(),a=u.getModel(["blur","lineStyle"]).getLineStyle(),s=u.getModel(["select","lineStyle"]).getLineStyle(),l=eh(u)}var h=t.getItemVisual(e,"style"),c=h.stroke;r.useStyle(h),r.style.fill=null,r.style.strokeNoScale=!0,r.ensureState("emphasis").style=o,r.ensureState("blur").style=a,r.ensureState("select").style=s,P(lC,(function(t){var e=this.childOfName(t);if(e){e.setColor(c),e.style.opacity=h.opacity;for(var n=0;n<xs.length;n++){var i=xs[n],o=r.getState(i);if(o){var a=o.style||{},s=e.ensureState(i),l=s.style||(s.style={});null!=a.stroke&&(l[e.__isEmptyBrush?"stroke":"fill"]=a.stroke),null!=a.opacity&&(l.opacity=a.opacity)}}e.markRedraw()}}),this);var p=i.getRawValue(e);th(this,l,{labelDataIndex:e,labelFetcher:{getFormattedLabel:function(e,n){return i.getFormattedLabel(e,n,t.dataType)}},inheritColor:c||"#000",defaultOpacity:h.opacity,defaultText:(null==p?t.getName(e):isFinite(p)?ji(p):p)+""});var d=this.getTextContent();if(d){var f=l.normal;d.__align=d.style.align,d.__verticalAlign=d.style.verticalAlign,d.__position=f.get("position")||"middle";var g=f.get("distance");F(g)||(g=[g,g]),d.__labelDistance=g}this.setTextConfig({position:null,local:!0,inside:!1}),Js(this)},e.prototype.highlight=function(){Hs(this)},e.prototype.downplay=function(){Ws(this)},e.prototype.updateLayout=function(t,e){this.setLinePoints(t.getItemLayout(e))},e.prototype.setLinePoints=function(t){var e=this.childOfName("line");cC(e.shape,t),e.dirty()},e.prototype.beforeUpdate=function(){var t=this,e=t.childOfName("fromSymbol"),n=t.childOfName("toSymbol"),i=t.getTextContent();if(e||n||i&&!i.ignore){for(var r=1,o=this.parent;o;)o.scaleX&&(r/=o.scaleX),o=o.parent;var a=t.childOfName("line");if(this.__dirty||a.__dirty){var s=a.shape.percent,l=a.pointAt(0),u=a.pointAt(s),h=wt([],u,l);if(At(h,h),e&&(e.setPosition(l),S(e,0),e.scaleX=e.scaleY=r*s,e.markRedraw()),n&&(n.setPosition(u),S(n,1),n.scaleX=n.scaleY=r*s,n.markRedraw()),i&&!i.ignore){i.x=i.y=0,i.originX=i.originY=0;var c=void 0,p=void 0,d=i.__labelDistance,f=d[0]*r,g=d[1]*r,y=s/2,v=a.tangentAt(y),m=[v[1],-v[0]],_=a.pointAt(y);m[1]>0&&(m[0]=-m[0],m[1]=-m[1]);var x=v[0]<0?-1:1;if("start"!==i.__position&&"end"!==i.__position){var b=-Math.atan2(v[1],v[0]);u[0]<l[0]&&(b=Math.PI+b),i.rotation=b}var w=void 0;switch(i.__position){case"insideStartTop":case"insideMiddleTop":case"insideEndTop":case"middle":w=-g,p="bottom";break;case"insideStartBottom":case"insideMiddleBottom":case"insideEndBottom":w=g,p="top";break;default:w=0,p="middle"}switch(i.__position){case"end":i.x=h[0]*f+u[0],i.y=h[1]*g+u[1],c=h[0]>.8?"left":h[0]<-.8?"right":"center",p=h[1]>.8?"top":h[1]<-.8?"bottom":"middle";break;case"start":i.x=-h[0]*f+l[0],i.y=-h[1]*g+l[1],c=h[0]>.8?"right":h[0]<-.8?"left":"center",p=h[1]>.8?"bottom":h[1]<-.8?"top":"middle";break;case"insideStartTop":case"insideStart":case"insideStartBottom":i.x=f*x+l[0],i.y=l[1]+w,c=v[0]<0?"right":"left",i.originX=-f*x,i.originY=-w;break;case"insideMiddleTop":case"insideMiddle":case"insideMiddleBottom":case"middle":i.x=_[0],i.y=_[1]+w,c="center",i.originY=-w;break;case"insideEndTop":case"insideEnd":case"insideEndBottom":i.x=-f*x+u[0],i.y=u[1]+w,c=v[0]>=0?"right":"left",i.originX=f*x,i.originY=-w}i.scaleX=i.scaleY=r,i.setStyle({verticalAlign:i.__verticalAlign||p,align:i.__align||c})}}}function S(t,e){var n=t.__specifiedRotation;if(null==n){var i=a.tangentAt(e);t.attr("rotation",(1===e?-1:1)*Math.PI/2-Math.atan2(i[1],i[0]))}else t.attr("rotation",n)}},e}(zi),dC=function(){function t(t){this.group=new zi,this._LineCtor=t||pC}return t.prototype.isPersistent=function(){return!0},t.prototype.updateData=function(t){var e=this,n=this,i=n.group,r=n._lineData;n._lineData=t,r||i.removeAll();var o=fC(t);t.diff(r).add((function(n){e._doAdd(t,n,o)})).update((function(n,i){e._doUpdate(r,t,i,n,o)})).remove((function(t){i.remove(r.getItemGraphicEl(t))})).execute()},t.prototype.updateLayout=function(){var t=this._lineData;t&&t.eachItemGraphicEl((function(e,n){e.updateLayout(t,n)}),this)},t.prototype.incrementalPrepareUpdate=function(t){this._seriesScope=fC(t),this._lineData=null,this.group.removeAll()},t.prototype.incrementalUpdate=function(t,e){function n(t){t.isGroup||function(t){return t.animators&&t.animators.length>0}(t)||(t.incremental=!0,t.ensureState("emphasis").hoverLayer=!0)}for(var i=t.start;i<t.end;i++){if(yC(e.getItemLayout(i))){var r=new this._LineCtor(e,i,this._seriesScope);r.traverse(n),this.group.add(r),e.setItemGraphicEl(i,r)}}},t.prototype.remove=function(){this.group.removeAll()},t.prototype._doAdd=function(t,e,n){if(yC(t.getItemLayout(e))){var i=new this._LineCtor(t,e,n);t.setItemGraphicEl(e,i),this.group.add(i)}},t.prototype._doUpdate=function(t,e,n,i,r){var o=t.getItemGraphicEl(n);yC(e.getItemLayout(i))?(o?o.updateData(e,i,r):o=new this._LineCtor(e,i,r),e.setItemGraphicEl(i,o),this.group.add(o)):this.group.remove(o)},t}();function fC(t){var e=t.hostModel;return{lineStyle:e.getModel("lineStyle").getLineStyle(),emphasisLineStyle:e.getModel(["emphasis","lineStyle"]).getLineStyle(),blurLineStyle:e.getModel(["blur","lineStyle"]).getLineStyle(),selectLineStyle:e.getModel(["select","lineStyle"]).getLineStyle(),labelStatesModels:eh(e)}}function gC(t){return isNaN(t[0])||isNaN(t[1])}function yC(t){return!gC(t[0])&&!gC(t[1])}var vC=[],mC=[],_C=[],xC=Go,bC=Pt,wC=Math.abs;function SC(t,e,n){for(var i,r=t[0],o=t[1],a=t[2],s=1/0,l=n*n,u=.1,h=.1;h<=.9;h+=.1){vC[0]=xC(r[0],o[0],a[0],h),vC[1]=xC(r[1],o[1],a[1],h),(d=wC(bC(vC,e)-l))<s&&(s=d,i=h)}for(var c=0;c<32;c++){var p=i+u;mC[0]=xC(r[0],o[0],a[0],i),mC[1]=xC(r[1],o[1],a[1],i),_C[0]=xC(r[0],o[0],a[0],p),_C[1]=xC(r[1],o[1],a[1],p);var d=bC(mC,e)-l;if(wC(d)<.01)break;var f=bC(_C,e)-l;u/=2,d<0?f>=0?i+=u:i-=u:f>=0?i-=u:i+=u}return i}function MC(t,e){var n=[],i=Yo,r=[[],[],[]],o=[[],[]],a=[];e/=2,t.eachEdge((function(t,s){var l=t.getLayout(),u=t.getVisual("fromSymbol"),h=t.getVisual("toSymbol");l.__original||(l.__original=[mt(l[0]),mt(l[1])],l[2]&&l.__original.push(mt(l[2])));var c=l.__original;if(null!=l[2]){if(vt(r[0],c[0]),vt(r[1],c[2]),vt(r[2],c[1]),u&&"none"!==u){var p=jT(t.node1),d=SC(r,c[0],p*e);i(r[0][0],r[1][0],r[2][0],d,n),r[0][0]=n[3],r[1][0]=n[4],i(r[0][1],r[1][1],r[2][1],d,n),r[0][1]=n[3],r[1][1]=n[4]}if(h&&"none"!==h){p=jT(t.node2),d=SC(r,c[1],p*e);i(r[0][0],r[1][0],r[2][0],d,n),r[1][0]=n[1],r[2][0]=n[2],i(r[0][1],r[1][1],r[2][1],d,n),r[1][1]=n[1],r[2][1]=n[2]}vt(l[0],r[0]),vt(l[1],r[2]),vt(l[2],r[1])}else{if(vt(o[0],c[0]),vt(o[1],c[1]),wt(a,o[1],o[0]),At(a,a),u&&"none"!==u){p=jT(t.node1);bt(o[0],o[0],a,p*e)}if(h&&"none"!==h){p=jT(t.node2);bt(o[1],o[1],a,-p*e)}vt(l[0],o[0]),vt(l[1],o[1])}}))}function IC(t){return"view"===t.type}var TC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(t,e){var n=new Tb,i=new dC,r=this.group;this._controller=new QS(e.getZr()),this._controllerHost={target:r},r.add(n.group),r.add(i.group),this._symbolDraw=n,this._lineDraw=i,this._firstRender=!0},e.prototype.render=function(t,e,n){var i=this,r=t.coordinateSystem;this._model=t;var o=this._symbolDraw,a=this._lineDraw,s=this.group;if(IC(r)){var l={x:r.x,y:r.y,scaleX:r.scaleX,scaleY:r.scaleY};this._firstRender?s.attr(l):Ou(s,l,t)}MC(t.getGraph(),ZT(t));var u=t.getData();o.updateData(u);var h=t.getEdgeData();a.updateData(h),this._updateNodeAndLinkScale(),this._updateController(t,e,n),clearTimeout(this._layoutTimeout);var c=t.forceLayout,p=t.get(["force","layoutAnimation"]);c&&this._startForceLayoutIteration(c,p),u.graph.eachNode((function(t){var e=t.dataIndex,n=t.getGraphicEl(),r=t.getModel();n.off("drag").off("dragend");var o=r.get("draggable");o&&n.on("drag",(function(){c&&(c.warmUp(),!i._layouting&&i._startForceLayoutIteration(c,p),c.setFixed(e),u.setItemLayout(e,[n.x,n.y]))})).on("dragend",(function(){c&&c.setUnfixed(e)})),n.setDraggable(o&&!!c),"adjacency"===r.get(["emphasis","focus"])&&(ys(n).focus=t.getAdjacentDataIndices())})),u.graph.eachEdge((function(t){var e=t.getGraphicEl();"adjacency"===t.getModel().get(["emphasis","focus"])&&(ys(e).focus={edge:[t.dataIndex],node:[t.node1.dataIndex,t.node2.dataIndex]})}));var d="circular"===t.get("layout")&&t.get(["circular","rotateLabel"]),f=u.getLayout("cx"),g=u.getLayout("cy");u.eachItemGraphicEl((function(t,e){var n=u.getItemModel(e).get(["label","rotate"])||0,i=t.getSymbolPath();if(d){var r=u.getItemLayout(e),o=Math.atan2(r[1]-g,r[0]-f);o<0&&(o=2*Math.PI+o);var a=r[0]<f;a&&(o-=Math.PI);var s=a?"left":"right";i.setTextConfig({rotation:-o,position:s,origin:"center"});var l=i.ensureState("emphasis");I(l.textConfig||(l.textConfig={}),{position:s})}else i.setTextConfig({rotation:n*=Math.PI/180})})),this._firstRender=!1},e.prototype.dispose=function(){this._controller&&this._controller.dispose(),this._controllerHost=null},e.prototype._startForceLayoutIteration=function(t,e){var n=this;!function i(){t.step((function(t){n.updateLayout(n._model),(n._layouting=!t)&&(e?n._layoutTimeout=setTimeout(i,16):i())}))}()},e.prototype._updateController=function(t,e,n){var i=this,r=this._controller,o=this._controllerHost,a=this.group;r.setPointerChecker((function(e,i,r){var o=a.getBoundingRect();return o.applyTransform(a.transform),o.contain(i,r)&&!aM(e,n,t)})),IC(t.coordinateSystem)?(r.enable(t.get("roam")),o.zoomLimit=t.get("scaleLimit"),o.zoom=t.coordinateSystem.getZoom(),r.off("pan").off("zoom").on("pan",(function(e){iM(o,e.dx,e.dy),n.dispatchAction({seriesId:t.id,type:"graphRoam",dx:e.dx,dy:e.dy})})).on("zoom",(function(e){rM(o,e.scale,e.originX,e.originY),n.dispatchAction({seriesId:t.id,type:"graphRoam",zoom:e.scale,originX:e.originX,originY:e.originY}),i._updateNodeAndLinkScale(),MC(t.getGraph(),ZT(t)),i._lineDraw.updateLayout(),n.updateLabelLayout()}))):r.disable()},e.prototype._updateNodeAndLinkScale=function(){var t=this._model,e=t.getData(),n=ZT(t);e.eachItemGraphicEl((function(t,e){t.setSymbolScale(n)}))},e.prototype.updateLayout=function(t){MC(t.getGraph(),ZT(t)),this._symbolDraw.updateLayout(),this._lineDraw.updateLayout()},e.prototype.remove=function(t,e){this._symbolDraw&&this._symbolDraw.remove(),this._lineDraw&&this._lineDraw.remove()},e.type="graph",e}(yf);function CC(t){return"_EC_"+t}var AC=function(){function t(t){this.type="graph",this.nodes=[],this.edges=[],this._nodesMap={},this._edgesMap={},this._directed=t||!1}return t.prototype.isDirected=function(){return this._directed},t.prototype.addNode=function(t,e){t=null==t?""+e:""+t;var n=this._nodesMap;if(!n[CC(t)]){var i=new DC(t,e);return i.hostGraph=this,this.nodes.push(i),n[CC(t)]=i,i}},t.prototype.getNodeByIndex=function(t){var e=this.data.getRawIndex(t);return this.nodes[e]},t.prototype.getNodeById=function(t){return this._nodesMap[CC(t)]},t.prototype.addEdge=function(t,e,n){var i=this._nodesMap,r=this._edgesMap;if("number"==typeof t&&(t=this.nodes[t]),"number"==typeof e&&(e=this.nodes[e]),t instanceof DC||(t=i[CC(t)]),e instanceof DC||(e=i[CC(e)]),t&&e){var o=t.id+"-"+e.id,a=new LC(t,e,n);return a.hostGraph=this,this._directed&&(t.outEdges.push(a),e.inEdges.push(a)),t.edges.push(a),t!==e&&e.edges.push(a),this.edges.push(a),r[o]=a,a}},t.prototype.getEdgeByIndex=function(t){var e=this.edgeData.getRawIndex(t);return this.edges[e]},t.prototype.getEdge=function(t,e){t instanceof DC&&(t=t.id),e instanceof DC&&(e=e.id);var n=this._edgesMap;return this._directed?n[t+"-"+e]:n[t+"-"+e]||n[e+"-"+t]},t.prototype.eachNode=function(t,e){for(var n=this.nodes,i=n.length,r=0;r<i;r++)n[r].dataIndex>=0&&t.call(e,n[r],r)},t.prototype.eachEdge=function(t,e){for(var n=this.edges,i=n.length,r=0;r<i;r++)n[r].dataIndex>=0&&n[r].node1.dataIndex>=0&&n[r].node2.dataIndex>=0&&t.call(e,n[r],r)},t.prototype.breadthFirstTraverse=function(t,e,n,i){if(e instanceof DC||(e=this._nodesMap[CC(e)]),e){for(var r="out"===n?"outEdges":"in"===n?"inEdges":"edges",o=0;o<this.nodes.length;o++)this.nodes[o].__visited=!1;if(!t.call(i,e,null))for(var a=[e];a.length;){var s=a.shift(),l=s[r];for(o=0;o<l.length;o++){var u=l[o],h=u.node1===s?u.node2:u.node1;if(!h.__visited){if(t.call(i,h,s))return;a.push(h),h.__visited=!0}}}}},t.prototype.update=function(){for(var t=this.data,e=this.edgeData,n=this.nodes,i=this.edges,r=0,o=n.length;r<o;r++)n[r].dataIndex=-1;for(r=0,o=t.count();r<o;r++)n[t.getRawIndex(r)].dataIndex=r;e.filterSelf((function(t){var n=i[e.getRawIndex(t)];return n.node1.dataIndex>=0&&n.node2.dataIndex>=0}));for(r=0,o=i.length;r<o;r++)i[r].dataIndex=-1;for(r=0,o=e.count();r<o;r++)i[e.getRawIndex(r)].dataIndex=r},t.prototype.clone=function(){for(var e=new t(this._directed),n=this.nodes,i=this.edges,r=0;r<n.length;r++)e.addNode(n[r].id,n[r].dataIndex);for(r=0;r<i.length;r++){var o=i[r];e.addEdge(o.node1.id,o.node2.id,o.dataIndex)}return e},t}(),DC=function(){function t(t,e){this.inEdges=[],this.outEdges=[],this.edges=[],this.dataIndex=-1,this.id=null==t?"":t,this.dataIndex=null==e?-1:e}return t.prototype.degree=function(){return this.edges.length},t.prototype.inDegree=function(){return this.inEdges.length},t.prototype.outDegree=function(){return this.outEdges.length},t.prototype.getModel=function(t){if(!(this.dataIndex<0))return this.hostGraph.data.getItemModel(this.dataIndex).getModel(t)},t.prototype.getAdjacentDataIndices=function(){for(var t={edge:[],node:[]},e=0;e<this.edges.length;e++){var n=this.edges[e];n.dataIndex<0||(t.edge.push(n.dataIndex),t.node.push(n.node1.dataIndex,n.node2.dataIndex))}return t},t}(),LC=function(){function t(t,e,n){this.dataIndex=-1,this.node1=t,this.node2=e,this.dataIndex=null==n?-1:n}return t.prototype.getModel=function(t){if(!(this.dataIndex<0))return this.hostGraph.edgeData.getItemModel(this.dataIndex).getModel(t)},t.prototype.getAdjacentDataIndices=function(){return{edge:[this.dataIndex],node:[this.node1.dataIndex,this.node2.dataIndex]}},t}();function kC(t,e){return{getValue:function(n){var i=this[t][e];return i.get(i.getDimension(n||"value"),this.dataIndex)},setVisual:function(n,i){this.dataIndex>=0&&this[t][e].setItemVisual(this.dataIndex,n,i)},getVisual:function(n){return this[t][e].getItemVisual(this.dataIndex,n)},setLayout:function(n,i){this.dataIndex>=0&&this[t][e].setItemLayout(this.dataIndex,n,i)},getLayout:function(){return this[t][e].getItemLayout(this.dataIndex)},getGraphicEl:function(){return this[t][e].getItemGraphicEl(this.dataIndex)},getRawIndex:function(){return this[t][e].getRawIndex(this.dataIndex)}}}function PC(t,e,n,i,r){for(var o=new AC(i),a=0;a<t.length;a++)o.addNode(Q(t[a].id,t[a].name,a),a);var s=[],l=[],u=0;for(a=0;a<e.length;a++){var h=e[a],c=h.source,p=h.target;o.addEdge(c,p,u)&&(l.push(h),s.push(Q(Tr(h.id,null),c+" > "+p)),u++)}var d,f=n.get("coordinateSystem");if("cartesian2d"===f||"polar"===f)d=Hm(t,n);else{var g=_p.get(f),y=g&&g.dimensions||[];A(y,"value")<0&&y.concat(["value"]);var v=Nm(t,{coordDimensions:y});(d=new Pm(v,n)).initData(t)}var m=new Pm(["value"],n);return m.initData(l,s),r&&r(d,m),vI({mainData:d,struct:o,structAttr:"graph",datas:{node:d,edge:m},datasAttr:{node:"data",edge:"edgeData"}}),o.update(),o}L(DC,kC("hostGraph","data")),L(LC,kC("hostGraph","edgeData"));var OC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.hasSymbolVisual=!0,n}return n(e,t),e.prototype.init=function(e){t.prototype.init.apply(this,arguments);var n=this;function i(){return n._categoriesData}this.legendVisualProvider=new Nw(i,i),this.fillDataTextStyle(e.edges||e.links),this._updateCategoriesData()},e.prototype.mergeOption=function(e){t.prototype.mergeOption.apply(this,arguments),this.fillDataTextStyle(e.edges||e.links),this._updateCategoriesData()},e.prototype.mergeDefaultAndTheme=function(e){t.prototype.mergeDefaultAndTheme.apply(this,arguments),xr(e,"edgeLabel",["show"])},e.prototype.getInitialData=function(t,e){var n,i=t.edges||t.links||[],r=t.data||t.nodes||[],o=this;if(r&&i){BT(n=this)&&(n.__curvenessList=[],n.__edgeMap={},VT(n));var a=PC(r,i,this,!0,(function(t,e){t.wrapMethod("getItemModel",(function(t){var e=o._categoriesModels[t.getShallow("category")];return e&&(e.parentModel=t.parentModel,t.parentModel=e),t}));var n=Sh.prototype.getModel;function i(t,e){var i=n.call(this,t,e);return i.resolveParentPath=r,i}function r(t){if(t&&("label"===t[0]||"label"===t[1])){var e=t.slice();return"label"===t[0]?e[0]="edgeLabel":"label"===t[1]&&(e[1]="edgeLabel"),e}return t}e.wrapMethod("getItemModel",(function(t){return t.resolveParentPath=r,t.getModel=i,t}))}));return P(a.edges,(function(t){!function(t,e,n,i){if(BT(n)){var r=FT(t,e,n),o=n.__edgeMap,a=o[GT(r)];o[r]&&!a?o[r].isForward=!0:a&&o[r]&&(a.isForward=!0,o[r].isForward=!1),o[r]=o[r]||[],o[r].push(i)}}(t.node1,t.node2,this,t.dataIndex)}),this),a.data}},e.prototype.getGraph=function(){return this.getData().graph},e.prototype.getEdgeData=function(){return this.getGraph().edgeData},e.prototype.getCategoriesData=function(){return this._categoriesData},e.prototype.formatTooltip=function(t,e,n){if("edge"===n){var i=this.getData(),r=this.getDataParams(t,n),o=i.graph.getEdgeByIndex(t),a=i.getName(o.node1.dataIndex),s=i.getName(o.node2.dataIndex),l=[];return null!=a&&l.push(a),null!=s&&l.push(s),Yd("nameValue",{name:l.join(" > "),value:r.value,noValue:null==r.value})}return tf({series:this,dataIndex:t,multipleSeries:e})},e.prototype._updateCategoriesData=function(){var t=O(this.option.categories||[],(function(t){return null!=t.value?t:I({value:0},t)})),e=new Pm(["value"],this);e.initData(t),this._categoriesData=e,this._categoriesModels=e.mapArray((function(t){return e.getItemModel(t)}))},e.prototype.setZoom=function(t){this.option.zoom=t},e.prototype.setCenter=function(t){this.option.center=t},e.prototype.isAnimationEnabled=function(){return t.prototype.isAnimationEnabled.call(this)&&!("force"===this.get("layout")&&this.get(["force","layoutAnimation"]))},e.type="series.graph",e.dependencies=["grid","polar","geo","singleAxis","calendar"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"view",legendHoverLink:!0,layout:null,circular:{rotateLabel:!1},force:{initLayout:null,repulsion:[0,50],gravity:.1,friction:.6,edgeLength:30,layoutAnimation:!0},left:"center",top:"center",symbol:"circle",symbolSize:10,edgeSymbol:["none","none"],edgeSymbolSize:10,edgeLabel:{position:"middle",distance:5},draggable:!1,roam:!1,center:null,zoom:1,nodeScaleRatio:.6,label:{show:!1,formatter:"{b}"},itemStyle:{},lineStyle:{color:"#aaa",width:1,opacity:.5},emphasis:{scale:!0,label:{show:!0}},select:{itemStyle:{borderColor:"#212121"}}},e}(rf),RC={type:"graphRoam",event:"graphRoam",update:"none"};var NC=function(){this.angle=0,this.width=10,this.r=10,this.x=0,this.y=0},EC=function(t){function e(e){var n=t.call(this,e)||this;return n.type="pointer",n}return n(e,t),e.prototype.getDefaultShape=function(){return new NC},e.prototype.buildPath=function(t,e){var n=Math.cos,i=Math.sin,r=e.r,o=e.width,a=e.angle,s=e.x-n(a)*o*(o>=r/3?1:2),l=e.y-i(a)*o*(o>=r/3?1:2);a=e.angle-Math.PI/2,t.moveTo(s,l),t.lineTo(e.x+n(a)*o,e.y+i(a)*o),t.lineTo(e.x+n(e.angle)*r,e.y+i(e.angle)*r),t.lineTo(e.x-n(a)*o,e.y-i(a)*o),t.lineTo(s,l)},e}(Za);function zC(t,e){var n=null==t?"":t+"";return e&&("string"==typeof e?n=e.replace("{value}",n):"function"==typeof e&&(n=e(t))),n}var BC=2*Math.PI,VC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){this.group.removeAll();var i=t.get(["axisLine","lineStyle","color"]),r=function(t,e){var n=t.get("center"),i=e.getWidth(),r=e.getHeight(),o=Math.min(i,r);return{cx:Zi(n[0],e.getWidth()),cy:Zi(n[1],e.getHeight()),r:Zi(t.get("radius"),o/2)}}(t,n);this._renderMain(t,e,n,i,r),this._data=t.getData()},e.prototype.dispose=function(){},e.prototype._renderMain=function(t,e,n,i,r){for(var o=this.group,a=t.get("clockwise"),s=-t.get("startAngle")/180*Math.PI,l=-t.get("endAngle")/180*Math.PI,u=t.getModel("axisLine"),h=u.get("roundCap")?aw:Wl,c=u.get("show"),p=u.getModel("lineStyle"),d=p.get("width"),f=(l-s)%BC||l===s?(l-s)%BC:BC,g=s,y=0;c&&y<i.length;y++){var v=new h({shape:{startAngle:g,endAngle:l=s+f*Math.min(Math.max(i[y][0],0),1),cx:r.cx,cy:r.cy,clockwise:a,r0:r.r-d,r:r.r},silent:!0});v.setStyle({fill:i[y][1]}),v.setStyle(p.getLineStyle(["color","width"])),o.add(v),g=l}var m=function(t){if(t<=0)return i[0][1];var e;for(e=0;e<i.length;e++)if(i[e][0]>=t&&(0===e?0:i[e-1][0])<t)return i[e][1];return i[e-1][1]};if(!a){var _=s;s=l,l=_}this._renderTicks(t,e,n,m,r,s,l,a,d),this._renderTitleAndDetail(t,e,n,m,r),this._renderAnchor(t,r),this._renderPointer(t,e,n,m,r,s,l,a,d)},e.prototype._renderTicks=function(t,e,n,i,r,o,a,s,l){for(var u,h,c=this.group,p=r.cx,d=r.cy,f=r.r,g=+t.get("min"),y=+t.get("max"),v=t.getModel("splitLine"),m=t.getModel("axisTick"),_=t.getModel("axisLabel"),x=t.get("splitNumber"),b=m.get("splitNumber"),w=Zi(v.get("length"),f),S=Zi(m.get("length"),f),M=o,I=(a-o)/x,T=I/b,C=v.getModel("lineStyle").getLineStyle(),A=m.getModel("lineStyle").getLineStyle(),D=v.get("distance"),L=0;L<=x;L++){if(u=Math.cos(M),h=Math.sin(M),v.get("show")){var k=new tu({shape:{x1:u*(f-(P=D?D+l:l))+p,y1:h*(f-P)+d,x2:u*(f-w-P)+p,y2:h*(f-w-P)+d},style:C,silent:!0});"auto"===C.stroke&&k.setStyle({stroke:i(L/x)}),c.add(k)}if(_.get("show")){var P=_.get("distance")+D,O=zC(ji(L/x*(y-g)+g),_.get("formatter")),R=i(L/x);c.add(new ls({style:nh(_,{text:O,x:u*(f-w-P)+p,y:h*(f-w-P)+d,verticalAlign:h<-.8?"top":h>.8?"bottom":"middle",align:u<-.4?"left":u>.4?"right":"center"},{inheritColor:R}),silent:!0}))}if(m.get("show")&&L!==x){P=(P=m.get("distance"))?P+l:l;for(var N=0;N<=b;N++){u=Math.cos(M),h=Math.sin(M);var E=new tu({shape:{x1:u*(f-P)+p,y1:h*(f-P)+d,x2:u*(f-S-P)+p,y2:h*(f-S-P)+d},silent:!0,style:A});"auto"===A.stroke&&E.setStyle({stroke:i((L+N/b)/x)}),c.add(E),M+=T}M-=T}else M+=I}},e.prototype._renderPointer=function(t,e,n,i,r,o,a,s,l){var u=this.group,h=this._data,c=this._progressEls,p=[],d=t.get(["pointer","show"]),f=t.getModel("progress"),g=f.get("show"),y=t.getData(),v=y.mapDimension("value"),m=+t.get("min"),_=+t.get("max"),x=[m,_],b=[o,a];function w(e,n){var i,o=y.getItemModel(e).getModel("pointer"),a=Zi(o.get("width"),r.r),s=Zi(o.get("length"),r.r),l=t.get(["pointer","icon"]),u=o.get("offsetCenter"),h=Zi(u[0],r.r),c=Zi(u[1],r.r),p=o.get("keepAspect");return(i=l?uy(l,h-a/2,c-s,a,s,null,p):new EC({shape:{angle:-Math.PI/2,width:a,r:s,x:h,y:c}})).rotation=-(n+Math.PI/2),i.x=r.cx,i.y=r.cy,i}function S(t,e){var n=f.get("roundCap")?aw:Wl,i=f.get("overlap"),a=i?f.get("width"):l/y.count(),u=i?r.r-a:r.r-(t+1)*a,h=i?r.r:r.r-t*a,c=new n({shape:{startAngle:o,endAngle:e,cx:r.cx,cy:r.cy,clockwise:s,r0:u,r:h}});return i&&(c.z2=_-y.get(v,t)%_),c}(g||d)&&(y.diff(h).add((function(e){if(d){var n=w(e,o);Ru(n,{rotation:-(Ui(y.get(v,e),x,b,!0)+Math.PI/2)},t),u.add(n),y.setItemGraphicEl(e,n)}if(g){var i=S(e,o),r=f.get("clip");Ru(i,{shape:{endAngle:Ui(y.get(v,e),x,b,r)}},t),u.add(i),p[e]=i}})).update((function(e,n){if(d){var i=h.getItemGraphicEl(n),r=i?i.rotation:o,a=w(e,r);a.rotation=r,Ou(a,{rotation:-(Ui(y.get(v,e),x,b,!0)+Math.PI/2)},t),u.add(a),y.setItemGraphicEl(e,a)}if(g){var s=c[n],l=S(e,s?s.shape.endAngle:o),m=f.get("clip");Ou(l,{shape:{endAngle:Ui(y.get(v,e),x,b,m)}},t),u.add(l),p[e]=l}})).execute(),y.each((function(t){var e=y.getItemModel(t),n=e.getModel("emphasis");if(d){var r=y.getItemGraphicEl(t);r.useStyle(y.getItemVisual(t,"style")),r.setStyle(e.getModel(["pointer","itemStyle"]).getItemStyle()),"auto"===r.style.fill&&r.setStyle("fill",i(Ui(y.get(v,t),x,[0,1],!0))),r.z2EmphasisLift=0,nl(r,e),Js(r,n.get("focus"),n.get("blurScope"))}if(g){var o=p[t];o.useStyle(y.getItemVisual(t,"style")),o.setStyle(e.getModel(["progress","itemStyle"]).getItemStyle()),o.z2EmphasisLift=0,nl(o,e),Js(o,n.get("focus"),n.get("blurScope"))}})),this._progressEls=p)},e.prototype._renderAnchor=function(t,e){var n=t.getModel("anchor");if(n.get("show")){var i=n.get("size"),r=n.get("icon"),o=n.get("offsetCenter"),a=n.get("keepAspect"),s=uy(r,e.cx-i/2+Zi(o[0],e.r),e.cy-i/2+Zi(o[1],e.r),i,i,null,a);s.z2=n.get("showAbove")?1:0,s.setStyle(n.getModel("itemStyle").getItemStyle()),this.group.add(s)}},e.prototype._renderTitleAndDetail=function(t,e,n,i,r){var o=this,a=t.getData(),s=a.mapDimension("value"),l=+t.get("min"),u=+t.get("max"),h=new zi,c=[],p=[],d=t.isAnimationEnabled();a.diff(this._data).add((function(t){c[t]=new ls({silent:!0}),p[t]=new ls({silent:!0})})).update((function(t,e){c[t]=o._titleEls[e],p[t]=o._detailEls[e]})).execute(),a.each((function(e){var n=a.getItemModel(e),o=a.get(s,e),f=new zi,g=i(Ui(o,[l,u],[0,1],!0)),y=n.getModel("title");if(y.get("show")){var v=y.get("offsetCenter"),m=r.cx+Zi(v[0],r.r),_=r.cy+Zi(v[1],r.r);(C=c[e]).attr({style:nh(y,{x:m,y:_,text:a.getName(e),align:"center",verticalAlign:"middle"},{inheritColor:g})}),f.add(C)}var x=n.getModel("detail");if(x.get("show")){var b=x.get("offsetCenter"),w=r.cx+Zi(b[0],r.r),S=r.cy+Zi(b[1],r.r),M=Zi(x.get("width"),r.r),I=Zi(x.get("height"),r.r),T=t.get(["progress","show"])?a.getItemVisual(e,"style").fill:g,C=p[e],A=x.get("formatter");C.attr({style:nh(x,{x:w,y:S,text:zC(o,A),width:isNaN(M)?null:M,height:isNaN(I)?null:I,align:"center",verticalAlign:"middle"},{inheritColor:T})}),hh(C,{normal:x},o,(function(t){return zC(t,A)})),d&&ch(C,e,a,t,{getFormattedLabel:function(t,e,n,i,r,a){return zC(a?a.interpolatedValue:o,A)}}),f.add(C)}h.add(f)})),this.group.add(h),this._titleEls=c,this._detailEls=p},e.type="gauge",e}(yf),FC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.visualStyleAccessPath="itemStyle",n.useColorPaletteOnData=!0,n}return n(e,t),e.prototype.getInitialData=function(t,e){return Rw(this,["value"])},e.type="series.gauge",e.defaultOption={zlevel:0,z:2,center:["50%","50%"],legendHoverLink:!0,radius:"75%",startAngle:225,endAngle:-45,clockwise:!0,min:0,max:100,splitNumber:10,axisLine:{show:!0,roundCap:!1,lineStyle:{color:[[1,"#E6EBF8"]],width:10}},progress:{show:!1,overlap:!0,width:10,roundCap:!1,clip:!0},splitLine:{show:!0,length:10,distance:10,lineStyle:{color:"#63677A",width:3,type:"solid"}},axisTick:{show:!0,splitNumber:5,length:6,distance:10,lineStyle:{color:"#63677A",width:1,type:"solid"}},axisLabel:{show:!0,distance:15,color:"#464646",fontSize:12},pointer:{icon:null,offsetCenter:[0,0],show:!0,length:"60%",width:6,keepAspect:!1},anchor:{show:!1,showAbove:!1,size:6,icon:"circle",offsetCenter:[0,0],keepAspect:!1,itemStyle:{color:"#fff",borderWidth:0,borderColor:"#5470c6"}},title:{show:!0,offsetCenter:[0,"20%"],color:"#464646",fontSize:16,valueAnimation:!1},detail:{show:!0,backgroundColor:"rgba(0,0,0,0)",borderWidth:0,borderColor:"#ccc",width:100,height:null,padding:[5,10],offsetCenter:[0,"40%"],color:"#464646",fontSize:30,fontWeight:"bold",lineHeight:30,valueAnimation:!1}},e}(rf);var GC=["itemStyle","opacity"],HC=function(t){function e(e,n){var i=t.call(this)||this,r=i,o=new $l,a=new ls;return r.setTextContent(a),i.setTextGuideLine(o),i.updateData(e,n,!0),i}return n(e,t),e.prototype.updateData=function(t,e,n){var i=this,r=t.hostModel,o=t.getItemModel(e),a=t.getItemLayout(e),s=o.getModel("emphasis"),l=o.get(GC);l=null==l?1:l,i.useStyle(t.getItemVisual(e,"style")),i.style.lineJoin="round",n?(i.setShape({points:a.points}),i.style.opacity=0,Ru(i,{style:{opacity:l}},r,e)):Ou(i,{style:{opacity:l},shape:{points:a.points}},r,e),nl(i,o),this._updateLabel(t,e),Js(this,s.get("focus"),s.get("blurScope"))},e.prototype._updateLabel=function(t,e){var n=this,i=this.getTextGuideLine(),r=n.getTextContent(),o=t.hostModel,a=t.getItemModel(e),s=t.getItemLayout(e).label,l=t.getItemVisual(e,"style"),u=l.fill;th(r,eh(a),{labelFetcher:t.hostModel,labelDataIndex:e,defaultOpacity:l.opacity,defaultText:t.getName(e)},{normal:{align:s.textAlign,verticalAlign:s.verticalAlign}}),n.setTextConfig({local:!0,inside:!!s.inside,insideStroke:u,outsideFill:u});var h=s.linePoints;i.setShape({points:h}),n.textGuideLineConfig={anchor:h?new In(h[0][0],h[0][1]):null},Ou(r,{style:{x:s.x,y:s.y}},o,e),r.attr({rotation:s.rotation,originX:s.x,originY:s.y,z2:10}),zg(n,Bg(a),{stroke:u})},e}(ql),WC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.ignoreLabelLineUpdate=!0,n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.getData(),r=this._data,o=this.group;i.diff(r).add((function(t){var e=new HC(i,t);i.setItemGraphicEl(t,e),o.add(e)})).update((function(t,e){var n=r.getItemGraphicEl(e);n.updateData(i,t),o.add(n),i.setItemGraphicEl(t,n)})).remove((function(e){zu(r.getItemGraphicEl(e),t,e)})).execute(),this._data=i},e.prototype.remove=function(){this.group.removeAll(),this._data=null},e.prototype.dispose=function(){},e.type="funnel",e}(yf),YC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.useColorPaletteOnData=!0,n}return n(e,t),e.prototype.init=function(e){t.prototype.init.apply(this,arguments),this.legendVisualProvider=new Nw(B(this.getData,this),B(this.getRawData,this)),this._defaultLabelLine(e)},e.prototype.getInitialData=function(t,e){return Rw(this,{coordDimensions:["value"],encodeDefaulter:V(Qc,this)})},e.prototype._defaultLabelLine=function(t){xr(t,"labelLine",["show"]);var e=t.labelLine,n=t.emphasis.labelLine;e.show=e.show&&t.label.show,n.show=n.show&&t.emphasis.label.show},e.prototype.getDataParams=function(e){var n=this.getData(),i=t.prototype.getDataParams.call(this,e),r=n.mapDimension("value"),o=n.getSum(r);return i.percent=o?+(n.get(r,e)/o*100).toFixed(2):0,i.$vars.push("percent"),i},e.type="series.funnel",e.defaultOption={zlevel:0,z:2,legendHoverLink:!0,left:80,top:60,right:80,bottom:60,minSize:"0%",maxSize:"100%",sort:"descending",orient:"vertical",gap:0,funnelAlign:"center",label:{show:!0,position:"outer"},labelLine:{show:!0,length:20,lineStyle:{width:1}},itemStyle:{borderColor:"#fff",borderWidth:1},emphasis:{label:{show:!0}},select:{itemStyle:{borderColor:"#212121"}}},e}(rf);function XC(t,e){t.eachSeriesByType("funnel",(function(t){var n=t.getData(),i=n.mapDimension("value"),r=t.get("sort"),o=function(t,e){return Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()})}(t,e),a=t.get("orient"),s=o.width,l=o.height,u=function(t,e){for(var n=t.mapDimension("value"),i=t.mapArray(n,(function(t){return t})),r=[],o="ascending"===e,a=0,s=t.count();a<s;a++)r[a]=a;return"function"==typeof e?r.sort(e):"none"!==e&&r.sort((function(t,e){return o?i[t]-i[e]:i[e]-i[t]})),r}(n,r),h=o.x,c=o.y,p="horizontal"===a?[Zi(t.get("minSize"),l),Zi(t.get("maxSize"),l)]:[Zi(t.get("minSize"),s),Zi(t.get("maxSize"),s)],d=n.getDataExtent(i),f=t.get("min"),g=t.get("max");null==f&&(f=Math.min(d[0],0)),null==g&&(g=d[1]);var y=t.get("funnelAlign"),v=t.get("gap"),m=(("horizontal"===a?s:l)-v*(n.count()-1))/n.count(),_=function(t,e){if("horizontal"===a){var r=Ui(n.get(i,t)||0,[f,g],p,!0),o=void 0;switch(y){case"top":o=c;break;case"center":o=c+(l-r)/2;break;case"bottom":o=c+(l-r)}return[[e,o],[e,o+r]]}var u,d=Ui(n.get(i,t)||0,[f,g],p,!0);switch(y){case"left":u=h;break;case"center":u=h+(s-d)/2;break;case"right":u=h+s-d}return[[u,e],[u+d,e]]};"ascending"===r&&(m=-m,v=-v,"horizontal"===a?h+=s:c+=l,u=u.reverse());for(var x=0;x<u.length;x++){var b=u[x],w=u[x+1],S=n.getItemModel(b);if("horizontal"===a){var M=S.get(["itemStyle","width"]);null==M?M=m:(M=Zi(M,s),"ascending"===r&&(M=-M));var I=_(b,h),T=_(w,h+M);h+=M+v,n.setItemLayout(b,{points:I.concat(T.slice().reverse())})}else{var C=S.get(["itemStyle","height"]);null==C?C=m:(C=Zi(C,l),"ascending"===r&&(C=-C));I=_(b,c),T=_(w,c+C);c+=C+v,n.setItemLayout(b,{points:I.concat(T.slice().reverse())})}}!function(t){var e=t.hostModel.get("orient");t.each((function(n){var i,r,o,a,s=t.getItemModel(n),l=s.getModel("label").get("position"),u=s.getModel("labelLine"),h=t.getItemLayout(n),c=h.points,p="inner"===l||"inside"===l||"center"===l||"insideLeft"===l||"insideRight"===l;if(p)"insideLeft"===l?(r=(c[0][0]+c[3][0])/2+5,o=(c[0][1]+c[3][1])/2,i="left"):"insideRight"===l?(r=(c[1][0]+c[2][0])/2-5,o=(c[1][1]+c[2][1])/2,i="right"):(r=(c[0][0]+c[1][0]+c[2][0]+c[3][0])/4,o=(c[0][1]+c[1][1]+c[2][1]+c[3][1])/4,i="center"),a=[[r,o],[r,o]];else{var d=void 0,f=void 0,g=void 0,y=void 0,v=u.get("length");"left"===l?(d=(c[3][0]+c[0][0])/2,f=(c[3][1]+c[0][1])/2,r=(g=d-v)-5,i="right"):"right"===l?(d=(c[1][0]+c[2][0])/2,f=(c[1][1]+c[2][1])/2,r=(g=d+v)+5,i="left"):"top"===l?(d=(c[3][0]+c[0][0])/2,o=(y=(f=(c[3][1]+c[0][1])/2)-v)-5,i="center"):"bottom"===l?(d=(c[1][0]+c[2][0])/2,o=(y=(f=(c[1][1]+c[2][1])/2)+v)+5,i="center"):"rightTop"===l?(d="horizontal"===e?c[3][0]:c[1][0],f="horizontal"===e?c[3][1]:c[1][1],"horizontal"===e?(o=(y=f-v)-5,i="center"):(r=(g=d+v)+5,i="top")):"rightBottom"===l?(d=c[2][0],f=c[2][1],"horizontal"===e?(o=(y=f+v)+5,i="center"):(r=(g=d+v)+5,i="bottom")):"leftTop"===l?(d=c[0][0],f="horizontal"===e?c[0][1]:c[1][1],"horizontal"===e?(o=(y=f-v)-5,i="center"):(r=(g=d-v)-5,i="right")):"leftBottom"===l?(d="horizontal"===e?c[1][0]:c[3][0],f="horizontal"===e?c[1][1]:c[2][1],"horizontal"===e?(o=(y=f+v)+5,i="center"):(r=(g=d-v)-5,i="right")):(d=(c[1][0]+c[2][0])/2,f=(c[1][1]+c[2][1])/2,"horizontal"===e?(o=(y=f+v)+5,i="center"):(r=(g=d+v)+5,i="left")),"horizontal"===e?r=g=d:o=y=f,a=[[d,f],[g,y]]}h.label={linePoints:a,x:r,y:o,verticalAlign:"middle",textAlign:i,inside:p}}))}(n)}))}var UC=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._dataGroup=new zi,n._initialized=!1,n}return n(e,t),e.prototype.init=function(){this.group.add(this._dataGroup)},e.prototype.render=function(t,e,n,i){var r=this._dataGroup,o=t.getData(),a=this._data,s=t.coordinateSystem,l=s.dimensions,u=qC(t);if(o.diff(a).add((function(t){KC(jC(o,r,t,l,s),o,t,u)})).update((function(e,n){var i=a.getItemGraphicEl(n),r=ZC(o,e,l,s);o.setItemGraphicEl(e,i),Ou(i,{shape:{points:r}},t,e),KC(i,o,e,u)})).remove((function(t){var e=a.getItemGraphicEl(t);r.remove(e)})).execute(),!this._initialized){this._initialized=!0;var h=function(t,e,n){var i=t.model,r=t.getRect(),o=new os({shape:{x:r.x,y:r.y,width:r.width,height:r.height}}),a="horizontal"===i.get("layout")?"width":"height";return o.setShape(a,0),Ru(o,{shape:{width:r.width,height:r.height}},e,n),o}(s,t,(function(){setTimeout((function(){r.removeClipPath()}))}));r.setClipPath(h)}this._data=o},e.prototype.incrementalPrepareRender=function(t,e,n){this._initialized=!0,this._data=null,this._dataGroup.removeAll()},e.prototype.incrementalRender=function(t,e,n){for(var i=e.getData(),r=e.coordinateSystem,o=r.dimensions,a=qC(e),s=t.start;s<t.end;s++){var l=jC(i,this._dataGroup,s,o,r);l.incremental=!0,KC(l,i,s,a)}},e.prototype.remove=function(){this._dataGroup&&this._dataGroup.removeAll(),this._data=null},e.type="parallel",e}(yf);function ZC(t,e,n,i){for(var r,o=[],a=0;a<n.length;a++){var s=n[a],l=t.get(t.mapDimension(s),e);r=l,("category"===i.getAxis(s).type?null==r:null==r||isNaN(r))||o.push(i.dataToPoint(l,s))}return o}function jC(t,e,n,i,r){var o=ZC(t,n,i,r),a=new $l({shape:{points:o},z2:10});return e.add(a),t.setItemGraphicEl(n,a),a}function qC(t){var e=t.get("smooth",!0);return!0===e&&(e=.3),J(e=hr(e))&&(e=0),{smooth:e}}function KC(t,e,n,i){t.useStyle(e.getItemVisual(n,"style")),t.style.fill=null,t.setShape("smooth",i.smooth);var r=e.getItemModel(n),o=r.getModel("emphasis");nl(t,r,"lineStyle"),Js(t,o.get("focus"),o.get("blurScope"))}var $C=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.visualStyleAccessPath="lineStyle",n.visualDrawType="stroke",n}return n(e,t),e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this,{useEncodeDefaulter:B(JC,null,this)})},e.prototype.getRawIndicesByActiveState=function(t){var e=this.coordinateSystem,n=this.getData(),i=[];return e.eachActiveState(n,(function(e,r){t===e&&i.push(n.getRawIndex(r))})),i},e.type="series.parallel",e.dependencies=["parallel"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"parallel",parallelIndex:0,label:{show:!1},inactiveOpacity:.05,activeOpacity:1,lineStyle:{width:1,opacity:.45,type:"solid"},emphasis:{label:{show:!1}},progressive:500,smooth:!1,animationEasing:"linear"},e}(rf);function JC(t){var e=t.ecModel.getComponent("parallel",t.get("parallelIndex"));if(e){var n={};return P(e.dimensions,(function(t){var e=+t.replace("dim","");n[t]=e})),n}}var QC=["lineStyle","opacity"],tA={seriesType:"parallel",reset:function(t,e){var n=t.coordinateSystem,i={normal:t.get(["lineStyle","opacity"]),active:t.get("activeOpacity"),inactive:t.get("inactiveOpacity")};return{progress:function(t,e){n.eachActiveState(e,(function(t,n){var r=i[t];if("normal"===t&&e.hasItemOption){var o=e.getItemModel(n).get(QC,!0);null!=o&&(r=o)}e.ensureUniqueItemVisual(n,"style").opacity=r}),t.start,t.end)}}}};function eA(t){!function(t){if(t.parallel)return;var e=!1;P(t.series,(function(t){t&&"parallel"===t.type&&(e=!0)})),e&&(t.parallel=[{}])}(t),function(t){P(_r(t.parallelAxis),(function(e){if(X(e)){var n=e.parallelIndex||0,i=_r(t.parallel)[n];i&&i.parallelAxisDefault&&S(e,i.parallelAxisDefault,!1)}}))}(t)}var nA=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){this._model=t,this._api=n,this._handlers||(this._handlers={},P(iA,(function(t,e){n.getZr().on(e,this._handlers[e]=B(t,this))}),this)),Tf(this,"_throttledDispatchExpand",t.get("axisExpandRate"),"fixRate")},e.prototype.dispose=function(t,e){P(this._handlers,(function(t,n){e.getZr().off(n,t)})),this._handlers=null},e.prototype._throttledDispatchExpand=function(t){this._dispatchExpand(t)},e.prototype._dispatchExpand=function(t){t&&this._api.dispatchAction(I({type:"parallelAxisExpand"},t))},e.type="parallel",e}(pf),iA={mousedown:function(t){rA(this,"click")&&(this._mouseDownPoint=[t.offsetX,t.offsetY])},mouseup:function(t){var e=this._mouseDownPoint;if(rA(this,"click")&&e){var n=[t.offsetX,t.offsetY];if(Math.pow(e[0]-n[0],2)+Math.pow(e[1]-n[1],2)>5)return;var i=this._model.coordinateSystem.getSlidedAxisExpandWindow([t.offsetX,t.offsetY]);"none"!==i.behavior&&this._dispatchExpand({axisExpandWindow:i.axisExpandWindow})}this._mouseDownPoint=null},mousemove:function(t){if(!this._mouseDownPoint&&rA(this,"mousemove")){var e=this._model,n=e.coordinateSystem.getSlidedAxisExpandWindow([t.offsetX,t.offsetY]),i=n.behavior;"jump"===i&&this._throttledDispatchExpand.debounceNextCall(e.get("axisExpandDebounce")),this._throttledDispatchExpand("none"===i?null:{axisExpandWindow:n.axisExpandWindow,animation:"jump"===i?null:{duration:0}})}}};function rA(t,e){var n=t._model;return n.get("axisExpandable")&&n.get("axisExpandTriggerOn")===e}var oA=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(){t.prototype.init.apply(this,arguments),this.mergeOption({})},e.prototype.mergeOption=function(t){var e=this.option;t&&S(e,t,!0),this._initDimensions()},e.prototype.contains=function(t,e){var n=t.get("parallelIndex");return null!=n&&e.getComponent("parallel",n)===this},e.prototype.setAxisExpand=function(t){P(["axisExpandable","axisExpandCenter","axisExpandCount","axisExpandWidth","axisExpandWindow"],(function(e){t.hasOwnProperty(e)&&(this.option[e]=t[e])}),this)},e.prototype._initDimensions=function(){var t=this.dimensions=[],e=this.parallelAxisIndex=[];P(N(this.ecModel.queryComponents({mainType:"parallelAxis"}),(function(t){return(t.get("parallelIndex")||0)===this.componentIndex}),this),(function(n){t.push("dim"+n.get("dim")),e.push(n.componentIndex)}))},e.type="parallel",e.dependencies=["parallelAxis"],e.layoutMode="box",e.defaultOption={zlevel:0,z:0,left:80,top:60,right:80,bottom:60,layout:"horizontal",axisExpandable:!1,axisExpandCenter:null,axisExpandCount:0,axisExpandWidth:50,axisExpandRate:17,axisExpandDebounce:50,axisExpandSlideTriggerArea:[-.15,.05,.4],axisExpandTriggerOn:"click",parallelAxisDefault:null},e}(Nc),aA=function(t){function e(e,n,i,r,o){var a=t.call(this,e,n,i)||this;return a.type=r||"value",a.axisIndex=o,a}return n(e,t),e.prototype.isHorizontal=function(){return"horizontal"!==this.coordinateSystem.getModel().get("layout")},e}(vx);function sA(t,e,n,i,r,o){t=t||0;var a=n[1]-n[0];if(null!=r&&(r=uA(r,[0,a])),null!=o&&(o=Math.max(o,null!=r?r:0)),"all"===i){var s=Math.abs(e[1]-e[0]);s=uA(s,[0,a]),r=o=uA(s,[r,o]),i=0}e[0]=uA(e[0],n),e[1]=uA(e[1],n);var l=lA(e,i);e[i]+=t;var u,h=r||0,c=n.slice();return l.sign<0?c[0]+=h:c[1]-=h,e[i]=uA(e[i],c),u=lA(e,i),null!=r&&(u.sign!==l.sign||u.span<r)&&(e[1-i]=e[i]+l.sign*r),u=lA(e,i),null!=o&&u.span>o&&(e[1-i]=e[i]+u.sign*o),e}function lA(t,e){var n=t[e]-t[1-e];return{span:Math.abs(n),sign:n>0?-1:n<0?1:e?-1:1}}function uA(t,e){return Math.min(null!=e[1]?e[1]:1/0,Math.max(null!=e[0]?e[0]:-1/0,t))}var hA=P,cA=Math.min,pA=Math.max,dA=Math.floor,fA=Math.ceil,gA=ji,yA=Math.PI,vA=function(){function t(t,e,n){this.type="parallel",this._axesMap=ht(),this._axesLayout={},this.dimensions=t.dimensions,this._model=t,this._init(t,e,n)}return t.prototype._init=function(t,e,n){var i=t.dimensions,r=t.parallelAxisIndex;hA(i,(function(t,n){var i=r[n],o=e.getComponent("parallelAxis",i),a=this._axesMap.set(t,new aA(t,G_(o),[0,0],o.get("type"),i)),s="category"===a.type;a.onBand=s&&o.get("boundaryGap"),a.inverse=o.get("inverse"),o.axis=a,a.model=o,a.coordinateSystem=o.coordinateSystem=this}),this)},t.prototype.update=function(t,e){this._updateAxesFromSeries(this._model,t)},t.prototype.containPoint=function(t){var e=this._makeLayoutInfo(),n=e.axisBase,i=e.layoutBase,r=e.pixelDimIndex,o=t[1-r],a=t[r];return o>=n&&o<=n+e.axisLength&&a>=i&&a<=i+e.layoutLength},t.prototype.getModel=function(){return this._model},t.prototype._updateAxesFromSeries=function(t,e){e.eachSeries((function(n){if(t.contains(n,e)){var i=n.getData();hA(this.dimensions,(function(t){var e=this._axesMap.get(t);e.scale.unionExtentFromData(i,i.mapDimension(t)),F_(e.scale,e.model)}),this)}}),this)},t.prototype.resize=function(t,e){this._rect=Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()}),this._layoutAxes()},t.prototype.getRect=function(){return this._rect},t.prototype._makeLayoutInfo=function(){var t,e=this._model,n=this._rect,i=["x","y"],r=["width","height"],o=e.get("layout"),a="horizontal"===o?0:1,s=n[r[a]],l=[0,s],u=this.dimensions.length,h=mA(e.get("axisExpandWidth"),l),c=mA(e.get("axisExpandCount")||0,[0,u]),p=e.get("axisExpandable")&&u>3&&u>c&&c>1&&h>0&&s>0,d=e.get("axisExpandWindow");d?(t=mA(d[1]-d[0],l),d[1]=d[0]+t):(t=mA(h*(c-1),l),(d=[h*(e.get("axisExpandCenter")||dA(u/2))-t/2])[1]=d[0]+t);var f=(s-t)/(u-c);f<3&&(f=0);var g=[dA(gA(d[0]/h,1))+1,fA(gA(d[1]/h,1))-1],y=f/h*d[0];return{layout:o,pixelDimIndex:a,layoutBase:n[i[a]],layoutLength:s,axisBase:n[i[1-a]],axisLength:n[r[1-a]],axisExpandable:p,axisExpandWidth:h,axisCollapseWidth:f,axisExpandWindow:d,axisCount:u,winInnerIndices:g,axisExpandWindow0Pos:y}},t.prototype._layoutAxes=function(){var t=this._rect,e=this._axesMap,n=this.dimensions,i=this._makeLayoutInfo(),r=i.layout;e.each((function(t){var e=[0,i.axisLength],n=t.inverse?1:0;t.setExtent(e[n],e[1-n])})),hA(n,(function(e,n){var o=(i.axisExpandable?xA:_A)(n,i),a={horizontal:{x:o.position,y:i.axisLength},vertical:{x:0,y:o.position}},s={horizontal:yA/2,vertical:0},l=[a[r].x+t.x,a[r].y+t.y],u=s[r],h=[1,0,0,1,0,0];_e(h,h,u),me(h,h,l),this._axesLayout[e]={position:l,rotation:u,transform:h,axisNameAvailableWidth:o.axisNameAvailableWidth,axisLabelShow:o.axisLabelShow,nameTruncateMaxWidth:o.nameTruncateMaxWidth,tickDirection:1,labelDirection:1}}),this)},t.prototype.getAxis=function(t){return this._axesMap.get(t)},t.prototype.dataToPoint=function(t,e){return this.axisCoordToPoint(this._axesMap.get(e).dataToCoord(t),e)},t.prototype.eachActiveState=function(t,e,n,i){null==n&&(n=0),null==i&&(i=t.count());var r=this._axesMap,o=this.dimensions,a=[],s=[];P(o,(function(e){a.push(t.mapDimension(e)),s.push(r.get(e).model)}));for(var l=this.hasAxisBrushed(),u=n;u<i;u++){var h=void 0;if(l){h="active";for(var c=t.getValues(a,u),p=0,d=o.length;p<d;p++){if("inactive"===s[p].getActiveState(c[p])){h="inactive";break}}}else h="normal";e(h,u)}},t.prototype.hasAxisBrushed=function(){for(var t=this.dimensions,e=this._axesMap,n=!1,i=0,r=t.length;i<r;i++)"normal"!==e.get(t[i]).model.getActiveState()&&(n=!0);return n},t.prototype.axisCoordToPoint=function(t,e){return Fu([t,0],this._axesLayout[e].transform)},t.prototype.getAxisLayout=function(t){return w(this._axesLayout[t])},t.prototype.getSlidedAxisExpandWindow=function(t){var e=this._makeLayoutInfo(),n=e.pixelDimIndex,i=e.axisExpandWindow.slice(),r=i[1]-i[0],o=[0,e.axisExpandWidth*(e.axisCount-1)];if(!this.containPoint(t))return{behavior:"none",axisExpandWindow:i};var a,s=t[n]-e.layoutBase-e.axisExpandWindow0Pos,l="slide",u=e.axisCollapseWidth,h=this._model.get("axisExpandSlideTriggerArea"),c=null!=h[0];if(u)c&&u&&s<r*h[0]?(l="jump",a=s-r*h[2]):c&&u&&s>r*(1-h[0])?(l="jump",a=s-r*(1-h[2])):(a=s-r*h[1])>=0&&(a=s-r*(1-h[1]))<=0&&(a=0),(a*=e.axisExpandWidth/u)?sA(a,i,o,"all"):l="none";else{var p=i[1]-i[0];(i=[pA(0,o[1]*s/p-p/2)])[1]=cA(o[1],i[0]+p),i[0]=i[1]-p}return{axisExpandWindow:i,behavior:l}},t}();function mA(t,e){return cA(pA(t,e[0]),e[1])}function _A(t,e){var n=e.layoutLength/(e.axisCount-1);return{position:n*t,axisNameAvailableWidth:n,axisLabelShow:!0}}function xA(t,e){var n,i,r=e.layoutLength,o=e.axisExpandWidth,a=e.axisCount,s=e.axisCollapseWidth,l=e.winInnerIndices,u=s,h=!1;return t<l[0]?(n=t*s,i=s):t<=l[1]?(n=e.axisExpandWindow0Pos+t*o-e.axisExpandWindow[0],u=o,h=!0):(n=r-(a-1-t)*s,i=s),{position:n,axisNameAvailableWidth:u,axisLabelShow:h,nameTruncateMaxWidth:i}}var bA={create:function(t,e){var n=[];return t.eachComponent("parallel",(function(i,r){var o=new vA(i,t,e);o.name="parallel_"+r,o.resize(i,e),i.coordinateSystem=o,o.model=i,n.push(o)})),t.eachSeries((function(t){if("parallel"===t.get("coordinateSystem")){var e=t.getReferringComponents("parallel",Or).models[0];t.coordinateSystem=e.coordinateSystem}})),n}},wA=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.activeIntervals=[],n}return n(e,t),e.prototype.getAreaSelectStyle=function(){return qr([["fill","color"],["lineWidth","borderWidth"],["stroke","borderColor"],["width","width"],["opacity","opacity"]])(this.getModel("areaSelectStyle"))},e.prototype.setActiveIntervals=function(t){var e=this.activeIntervals=w(t);if(e)for(var n=e.length-1;n>=0;n--)qi(e[n])},e.prototype.getActiveState=function(t){var e=this.activeIntervals;if(!e.length)return"normal";if(null==t||isNaN(+t))return"inactive";if(1===e.length){var n=e[0];if(n[0]<=t&&t<=n[1])return"active"}else for(var i=0,r=e.length;i<r;i++)if(e[i][0]<=t&&t<=e[i][1])return"active";return"inactive"},e}(Nc);L(wA,j_);var SA=!0,MA=Math.min,IA=Math.max,TA=Math.pow,CA="globalPan",AA={w:[0,0],e:[0,1],n:[1,0],s:[1,1]},DA={w:"ew",e:"ew",n:"ns",s:"ns",ne:"nesw",sw:"nesw",nw:"nwse",se:"nwse"},LA={brushStyle:{lineWidth:2,stroke:"rgba(210,219,238,0.3)",fill:"#D2DBEE"},transformable:!0,brushMode:"single",removeOnClick:!1},kA=0,PA=function(t){function e(e){var n=t.call(this)||this;return n._track=[],n._covers=[],n._handlers={},n._zr=e,n.group=new zi,n._uid="brushController_"+kA++,P(oD,(function(t,e){this._handlers[e]=B(t,this)}),n),n}return n(e,t),e.prototype.enableBrush=function(t){return this._brushType&&this._doDisableBrush(),t.brushType&&this._doEnableBrush(t),this},e.prototype._doEnableBrush=function(t){var e=this._zr;this._enableGlobalPan||function(t,e,n){JS(t)[e]=n}(e,CA,this._uid),P(this._handlers,(function(t,n){e.on(n,t)})),this._brushType=t.brushType,this._brushOption=S(w(LA),t,!0)},e.prototype._doDisableBrush=function(){var t=this._zr;!function(t,e,n){var i=JS(t);i[e]===n&&(i[e]=null)}(t,CA,this._uid),P(this._handlers,(function(e,n){t.off(n,e)})),this._brushType=this._brushOption=null},e.prototype.setPanels=function(t){if(t&&t.length){var e=this._panels={};P(t,(function(t){e[t.panelId]=w(t)}))}else this._panels=null;return this},e.prototype.mount=function(t){t=t||{},this._enableGlobalPan=t.enableGlobalPan;var e=this.group;return this._zr.add(e),e.attr({x:t.x||0,y:t.y||0,rotation:t.rotation||0,scaleX:t.scaleX||1,scaleY:t.scaleY||1}),this._transform=e.getLocalTransform(),this},e.prototype.updateCovers=function(t){t=O(t,(function(t){return S(w(LA),t,!0)}));var e=this._covers,n=this._covers=[],i=this,r=this._creatingCover;return new rm(e,t,(function(t,e){return o(t.__brushOption,e)}),o).add(a).update(a).remove((function(t){e[t]!==r&&i.group.remove(e[t])})).execute(),this;function o(t,e){return(null!=t.id?t.id:"\0-brush-index-"+e)+"-"+t.brushType}function a(o,a){var s=t[o];if(null!=a&&e[a]===r)n[o]=e[a];else{var l=n[o]=null!=a?(e[a].__brushOption=s,e[a]):RA(i,OA(i,s));zA(i,l)}}},e.prototype.unmount=function(){return this.enableBrush(!1),GA(this),this._zr.remove(this.group),this},e.prototype.dispose=function(){this.unmount(),this.off()},e}(Ft);function OA(t,e){var n=sD[e.brushType].createCover(t,e);return n.__brushOption=e,EA(n,e),t.group.add(n),n}function RA(t,e){var n=BA(e);return n.endCreating&&(n.endCreating(t,e),EA(e,e.__brushOption)),e}function NA(t,e){var n=e.__brushOption;BA(e).updateCoverShape(t,e,n.range,n)}function EA(t,e){var n=e.z;null==n&&(n=1e4),t.traverse((function(t){t.z=n,t.z2=n}))}function zA(t,e){BA(e).updateCommon(t,e),NA(t,e)}function BA(t){return sD[t.__brushOption.brushType]}function VA(t,e,n){var i,r=t._panels;if(!r)return SA;var o=t._transform;return P(r,(function(t){t.isTargetByCursor(e,n,o)&&(i=t)})),i}function FA(t,e){var n=t._panels;if(!n)return SA;var i=e.__brushOption.panelId;return null!=i?n[i]:SA}function GA(t){var e=t._covers,n=e.length;return P(e,(function(e){t.group.remove(e)}),t),e.length=0,!!n}function HA(t,e){var n=O(t._covers,(function(t){var e=t.__brushOption,n=w(e.range);return{brushType:e.brushType,panelId:e.panelId,range:n}}));t.trigger("brush",{areas:n,isEnd:!!e.isEnd,removeOnClick:!!e.removeOnClick})}function WA(t){var e=t.length-1;return e<0&&(e=0),[t[0],t[e]]}function YA(t,e,n,i){var r=new zi;return r.add(new os({name:"main",style:jA(n),silent:!0,draggable:!0,cursor:"move",drift:V($A,t,e,r,["n","s","w","e"]),ondragend:V(HA,e,{isEnd:!0})})),P(i,(function(n){r.add(new os({name:n.join(""),style:{opacity:0},draggable:!0,silent:!0,invisible:!0,drift:V($A,t,e,r,n),ondragend:V(HA,e,{isEnd:!0})}))})),r}function XA(t,e,n,i){var r=i.brushStyle.lineWidth||0,o=IA(r,6),a=n[0][0],s=n[1][0],l=a-r/2,u=s-r/2,h=n[0][1],c=n[1][1],p=h-o+r/2,d=c-o+r/2,f=h-a,g=c-s,y=f+r,v=g+r;ZA(t,e,"main",a,s,f,g),i.transformable&&(ZA(t,e,"w",l,u,o,v),ZA(t,e,"e",p,u,o,v),ZA(t,e,"n",l,u,y,o),ZA(t,e,"s",l,d,y,o),ZA(t,e,"nw",l,u,o,o),ZA(t,e,"ne",p,u,o,o),ZA(t,e,"sw",l,d,o,o),ZA(t,e,"se",p,d,o,o))}function UA(t,e){var n=e.__brushOption,i=n.transformable,r=e.childAt(0);r.useStyle(jA(n)),r.attr({silent:!i,cursor:i?"move":"default"}),P([["w"],["e"],["n"],["s"],["s","e"],["s","w"],["n","e"],["n","w"]],(function(n){var r=e.childOfName(n.join("")),o=1===n.length?KA(t,n[0]):function(t,e){var n=[KA(t,e[0]),KA(t,e[1])];return("e"===n[0]||"w"===n[0])&&n.reverse(),n.join("")}(t,n);r&&r.attr({silent:!i,invisible:!i,cursor:i?DA[o]+"-resize":null})}))}function ZA(t,e,n,i,r,o,a){var s=e.childOfName(n);s&&s.setShape(function(t){var e=MA(t[0][0],t[1][0]),n=MA(t[0][1],t[1][1]),i=IA(t[0][0],t[1][0]),r=IA(t[0][1],t[1][1]);return{x:e,y:n,width:i-e,height:r-n}}(tD(t,e,[[i,r],[i+o,r+a]])))}function jA(t){return T({strokeNoScale:!0},t.brushStyle)}function qA(t,e,n,i){var r=[MA(t,n),MA(e,i)],o=[IA(t,n),IA(e,i)];return[[r[0],o[0]],[r[1],o[1]]]}function KA(t,e){return{left:"w",right:"e",top:"n",bottom:"s"}[Gu({w:"left",e:"right",n:"top",s:"bottom"}[e],function(t){return Vu(t.group)}(t))]}function $A(t,e,n,i,r,o){var a=n.__brushOption,s=t.toRectRange(a.range),l=QA(e,r,o);P(i,(function(t){var e=AA[t];s[e[0]][e[1]]+=l[e[0]]})),a.range=t.fromRectRange(qA(s[0][0],s[1][0],s[0][1],s[1][1])),zA(e,n),HA(e,{isEnd:!1})}function JA(t,e,n,i){var r=e.__brushOption.range,o=QA(t,n,i);P(r,(function(t){t[0]+=o[0],t[1]+=o[1]})),zA(t,e),HA(t,{isEnd:!1})}function QA(t,e,n){var i=t.group,r=i.transformCoordToLocal(e,n),o=i.transformCoordToLocal(0,0);return[r[0]-o[0],r[1]-o[1]]}function tD(t,e,n){var i=FA(t,e);return i&&i!==SA?i.clipPath(n,t._transform):w(n)}function eD(t){var e=t.event;e.preventDefault&&e.preventDefault()}function nD(t,e,n){return t.childOfName("main").contain(e,n)}function iD(t,e,n,i){var r,o=t._creatingCover,a=t._creatingPanel,s=t._brushOption;if(t._track.push(n.slice()),function(t){var e=t._track;if(!e.length)return!1;var n=e[e.length-1],i=e[0],r=n[0]-i[0],o=n[1]-i[1];return TA(r*r+o*o,.5)>6}(t)||o){if(a&&!o){"single"===s.brushMode&&GA(t);var l=w(s);l.brushType=rD(l.brushType,a),l.panelId=a===SA?null:a.panelId,o=t._creatingCover=OA(t,l),t._covers.push(o)}if(o){var u=sD[rD(t._brushType,a)];o.__brushOption.range=u.getCreatingRange(tD(t,o,t._track)),i&&(RA(t,o),u.updateCommon(t,o)),NA(t,o),r={isEnd:i}}}else i&&"single"===s.brushMode&&s.removeOnClick&&VA(t,e,n)&&GA(t)&&(r={isEnd:i,removeOnClick:!0});return r}function rD(t,e){return"auto"===t?e.defaultBrushType:t}var oD={mousedown:function(t){if(this._dragging)aD(this,t);else if(!t.target||!t.target.draggable){eD(t);var e=this.group.transformCoordToLocal(t.offsetX,t.offsetY);this._creatingCover=null,(this._creatingPanel=VA(this,t,e))&&(this._dragging=!0,this._track=[e.slice()])}},mousemove:function(t){var e=t.offsetX,n=t.offsetY,i=this.group.transformCoordToLocal(e,n);if(function(t,e,n){if(t._brushType&&!function(t,e,n){var i=t._zr;return e<0||e>i.getWidth()||n<0||n>i.getHeight()}(t,e.offsetX,e.offsetY)){var i=t._zr,r=t._covers,o=VA(t,e,n);if(!t._dragging)for(var a=0;a<r.length;a++){var s=r[a].__brushOption;if(o&&(o===SA||s.panelId===o.panelId)&&sD[s.brushType].contain(r[a],n[0],n[1]))return}o&&i.setCursorStyle("crosshair")}}(this,t,i),this._dragging){eD(t);var r=iD(this,t,i,!1);r&&HA(this,r)}},mouseup:function(t){aD(this,t)}};function aD(t,e){if(t._dragging){eD(e);var n=e.offsetX,i=e.offsetY,r=t.group.transformCoordToLocal(n,i),o=iD(t,e,r,!0);t._dragging=!1,t._track=[],t._creatingCover=null,o&&HA(t,o)}}var sD={lineX:lD(0),lineY:lD(1),rect:{createCover:function(t,e){function n(t){return t}return YA({toRectRange:n,fromRectRange:n},t,e,[["w"],["e"],["n"],["s"],["s","e"],["s","w"],["n","e"],["n","w"]])},getCreatingRange:function(t){var e=WA(t);return qA(e[1][0],e[1][1],e[0][0],e[0][1])},updateCoverShape:function(t,e,n,i){XA(t,e,n,i)},updateCommon:UA,contain:nD},polygon:{createCover:function(t,e){var n=new zi;return n.add(new $l({name:"main",style:jA(e),silent:!0})),n},getCreatingRange:function(t){return t},endCreating:function(t,e){e.remove(e.childAt(0)),e.add(new ql({name:"main",draggable:!0,drift:V(JA,t,e),ondragend:V(HA,t,{isEnd:!0})}))},updateCoverShape:function(t,e,n,i){e.childAt(0).setShape({points:tD(t,e,n)})},updateCommon:UA,contain:nD}};function lD(t){return{createCover:function(e,n){return YA({toRectRange:function(e){var n=[e,[0,100]];return t&&n.reverse(),n},fromRectRange:function(e){return e[t]}},e,n,[[["w"],["e"]],[["n"],["s"]]][t])},getCreatingRange:function(e){var n=WA(e);return[MA(n[0][t],n[1][t]),IA(n[0][t],n[1][t])]},updateCoverShape:function(e,n,i,r){var o,a=FA(e,n);if(a!==SA&&a.getLinearBrushOtherExtent)o=a.getLinearBrushOtherExtent(t);else{var s=e._zr;o=[0,[s.getWidth(),s.getHeight()][1-t]]}var l=[i,o];t&&l.reverse(),XA(e,n,l,r)},updateCommon:UA,contain:nD}}function uD(t){return t=pD(t),function(e){return Yu(e,t)}}function hD(t,e){return t=pD(t),function(n){var i=null!=e?e:n,r=i?t.width:t.height,o=i?t.x:t.y;return[o,o+(r||0)]}}function cD(t,e,n){var i=pD(t);return function(t,r){return i.contain(r[0],r[1])&&!aM(t,e,n)}}function pD(t){return Rn.create(t)}var dD=["axisLine","axisTickLabel","axisName"],fD=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(e,n){t.prototype.init.apply(this,arguments),(this._brushController=new PA(n.getZr())).on("brush",B(this._onBrush,this))},e.prototype.render=function(t,e,n,i){if(!function(t,e,n){return n&&"axisAreaSelect"===n.type&&e.findComponents({mainType:"parallelAxis",query:n})[0]===t}(t,e,i)){this.axisModel=t,this.api=n,this.group.removeAll();var r=this._axisGroup;if(this._axisGroup=new zi,this.group.add(this._axisGroup),t.get("show")){var o=function(t,e){return e.getComponent("parallel",t.get("parallelIndex"))}(t,e),a=o.coordinateSystem,s=t.getAreaSelectStyle(),l=s.width,u=t.axis.dim,h=I({strokeContainThreshold:l},a.getAxisLayout(u)),c=new hS(t,h);P(dD,c.add,c),this._axisGroup.add(c.getGroup()),this._refreshBrushController(h,s,t,o,l,n),Wu(r,this._axisGroup,t)}}},e.prototype._refreshBrushController=function(t,e,n,i,r,o){var a=n.axis.getExtent(),s=a[1]-a[0],l=Math.min(30,.1*Math.abs(s)),u=Rn.create({x:a[0],y:-r/2,width:s,height:r});u.x-=l,u.width+=2*l,this._brushController.mount({enableGlobalPan:!0,rotation:t.rotation,x:t.position[0],y:t.position[1]}).setPanels([{panelId:"pl",clipPath:uD(u),isTargetByCursor:cD(u,o,i),getLinearBrushOtherExtent:hD(u,0)}]).enableBrush({brushType:"lineX",brushStyle:e,removeOnClick:!0}).updateCovers(function(t){var e=t.axis;return O(t.activeIntervals,(function(t){return{brushType:"lineX",panelId:"pl",range:[e.dataToCoord(t[0],!0),e.dataToCoord(t[1],!0)]}}))}(n))},e.prototype._onBrush=function(t){var e=t.areas,n=this.axisModel,i=n.axis,r=O(e,(function(t){return[i.coordToData(t.range[0],!0),i.coordToData(t.range[1],!0)]}));(!n.option.realtime===t.isEnd||t.removeOnClick)&&this.api.dispatchAction({type:"axisAreaSelect",parallelAxisId:n.id,intervals:r})},e.prototype.dispose=function(){this._brushController.dispose()},e.type="parallelAxis",e}(pf);var gD={type:"axisAreaSelect",event:"axisAreaSelected"};var yD={type:"value",areaSelectStyle:{width:20,borderWidth:1,borderColor:"rgba(160,197,232)",color:"rgba(160,197,232)",opacity:.3},realtime:!0,z:10};function vD(t){t.registerComponentView(nA),t.registerComponentModel(oA),t.registerCoordinateSystem("parallel",bA),t.registerPreprocessor(eA),t.registerComponentModel(wA),t.registerComponentView(fD),qw(t,"parallel",wA,yD),function(t){t.registerAction(gD,(function(t,e){e.eachComponent({mainType:"parallelAxis",query:t},(function(e){e.axis.model.setActiveIntervals(t.intervals)}))})),t.registerAction("parallelAxisExpand",(function(t,e){e.eachComponent({mainType:"parallel",query:t},(function(e){e.setAxisExpand(t)}))}))}(t)}var mD=function(){this.x1=0,this.y1=0,this.x2=0,this.y2=0,this.cpx1=0,this.cpy1=0,this.cpx2=0,this.cpy2=0,this.extent=0},_D=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultShape=function(){return new mD},e.prototype.buildPath=function(t,e){var n=e.extent;t.moveTo(e.x1,e.y1),t.bezierCurveTo(e.cpx1,e.cpy1,e.cpx2,e.cpy2,e.x2,e.y2),"vertical"===e.orient?(t.lineTo(e.x2+n,e.y2),t.bezierCurveTo(e.cpx2+n,e.cpy2,e.cpx1+n,e.cpy1,e.x1+n,e.y1)):(t.lineTo(e.x2,e.y2+n),t.bezierCurveTo(e.cpx2,e.cpy2+n,e.cpx1,e.cpy1+n,e.x1,e.y1+n)),t.closePath()},e.prototype.highlight=function(){Hs(this)},e.prototype.downplay=function(){Ws(this)},e}(Za),xD=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._focusAdjacencyDisabled=!1,n}return n(e,t),e.prototype.render=function(t,e,n){var i=this,r=t.getGraph(),o=this.group,a=t.layoutInfo,s=a.width,l=a.height,u=t.getData(),h=t.getData("edge"),c=t.get("orient");this._model=t,o.removeAll(),o.x=a.x,o.y=a.y,r.eachEdge((function(e){var n=new _D,i=ys(n);i.dataIndex=e.dataIndex,i.seriesIndex=t.seriesIndex,i.dataType="edge";var r,a,u,p,d,f,g,y,v=e.getModel(),m=v.getModel("lineStyle"),_=m.get("curveness"),x=e.node1.getLayout(),b=e.node1.getModel(),w=b.get("localX"),S=b.get("localY"),M=e.node2.getLayout(),I=e.node2.getModel(),T=I.get("localX"),C=I.get("localY"),A=e.getLayout();switch(n.shape.extent=Math.max(1,A.dy),n.shape.orient=c,"vertical"===c?(r=(null!=w?w*s:x.x)+A.sy,a=(null!=S?S*l:x.y)+x.dy,u=(null!=T?T*s:M.x)+A.ty,d=r,f=a*(1-_)+(p=null!=C?C*l:M.y)*_,g=u,y=a*_+p*(1-_)):(r=(null!=w?w*s:x.x)+x.dx,a=(null!=S?S*l:x.y)+A.sy,d=r*(1-_)+(u=null!=T?T*s:M.x)*_,f=a,g=r*_+u*(1-_),y=p=(null!=C?C*l:M.y)+A.ty),n.setShape({x1:r,y1:a,x2:u,y2:p,cpx1:d,cpy1:f,cpx2:g,cpy2:y}),n.useStyle(m.getItemStyle()),n.style.fill){case"source":n.style.fill=e.node1.getVisual("color"),n.style.decal=e.node1.getVisual("style").decal;break;case"target":n.style.fill=e.node2.getVisual("color"),n.style.decal=e.node2.getVisual("style").decal;break;case"gradient":var D=e.node1.getVisual("color"),L=e.node2.getVisual("color");"string"==typeof D&&"string"==typeof L&&(n.style.fill=new uu(0,0,1,0,[{color:D,offset:0},{color:L,offset:1}]))}var k=v.getModel("emphasis");nl(n,v,"lineStyle",(function(t){return t.getItemStyle()})),o.add(n),h.setItemGraphicEl(e.dataIndex,n);var P=k.get("focus");Js(n,"adjacency"===P?e.getAdjacentDataIndices():P,k.get("blurScope")),ys(n).dataType="edge"})),r.eachNode((function(e){var n=e.getLayout(),i=e.getModel(),r=i.get("localX"),a=i.get("localY"),h=i.getModel("emphasis"),c=new os({shape:{x:null!=r?r*s:n.x,y:null!=a?a*l:n.y,width:n.dx,height:n.dy},style:i.getModel("itemStyle").getItemStyle()});th(c,eh(i),{labelFetcher:t,labelDataIndex:e.dataIndex,defaultText:e.id}),c.disableLabelAnimation=!0,c.setStyle("fill",e.getVisual("color")),c.setStyle("decal",e.getVisual("style").decal),nl(c,i),o.add(c),u.setItemGraphicEl(e.dataIndex,c),ys(c).dataType="node";var p=h.get("focus");Js(c,"adjacency"===p?e.getAdjacentDataIndices():p,h.get("blurScope"))})),u.eachItemGraphicEl((function(e,r){u.getItemModel(r).get("draggable")&&(e.drift=function(e,o){i._focusAdjacencyDisabled=!0,this.shape.x+=e,this.shape.y+=o,this.dirty(),n.dispatchAction({type:"dragNode",seriesId:t.id,dataIndex:u.getRawIndex(r),localX:this.shape.x/s,localY:this.shape.y/l})},e.ondragend=function(){i._focusAdjacencyDisabled=!1},e.draggable=!0,e.cursor="move")})),!this._data&&t.isAnimationEnabled()&&o.setClipPath(function(t,e,n){var i=new os({shape:{x:t.x-10,y:t.y-10,width:0,height:t.height+20}});return Ru(i,{shape:{width:t.width+20}},e,n),i}(o.getBoundingRect(),t,(function(){o.removeClipPath()}))),this._data=t.getData()},e.prototype.dispose=function(){},e.type="sankey",e}(yf);var bD=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.getInitialData=function(t,e){var n=t.edges||t.links,i=t.data||t.nodes,r=t.levels;this.levelModels=[];for(var o=this.levelModels,a=0;a<r.length;a++)null!=r[a].depth&&r[a].depth>=0&&(o[r[a].depth]=new Sh(r[a],this,e));if(i&&n)return PC(i,n,this,!0,(function(t,e){t.wrapMethod("getItemModel",(function(t,e){var n=t.parentModel,i=n.getData().getItemLayout(e);if(i){var r=i.depth,o=n.levelModels[r];o&&(t.parentModel=o)}return t})),e.wrapMethod("getItemModel",(function(t,e){var n=t.parentModel,i=n.getGraph().getEdgeByIndex(e).node1.getLayout();if(i){var r=i.depth,o=n.levelModels[r];o&&(t.parentModel=o)}return t}))})).data},e.prototype.setNodePosition=function(t,e){var n=this.option.data[t];n.localX=e[0],n.localY=e[1]},e.prototype.getGraph=function(){return this.getData().graph},e.prototype.getEdgeData=function(){return this.getGraph().edgeData},e.prototype.formatTooltip=function(t,e,n){function i(t){return isNaN(t)||null==t}if("edge"===n){var r=this.getDataParams(t,n),o=r.data,a=r.value;return Yd("nameValue",{name:o.source+" -- "+o.target,value:a,noValue:i(a)})}var s=this.getGraph().getNodeByIndex(t).getLayout().value,l=this.getDataParams(t,n).data.name;return Yd("nameValue",{name:null!=l?l+"":null,value:s,noValue:i(s)})},e.prototype.optionUpdated=function(){this.option},e.prototype.getDataParams=function(e,n){var i=t.prototype.getDataParams.call(this,e,n);if(null==i.value&&"node"===n){var r=this.getGraph().getNodeByIndex(e).getLayout().value;i.value=r}return i},e.type="series.sankey",e.defaultOption={zlevel:0,z:2,coordinateSystem:"view",left:"5%",top:"5%",right:"20%",bottom:"5%",orient:"horizontal",nodeWidth:20,nodeGap:8,draggable:!0,layoutIterations:32,label:{show:!0,position:"right",fontSize:12},levels:[],nodeAlign:"justify",lineStyle:{color:"#314656",opacity:.2,curveness:.5},emphasis:{label:{show:!0},lineStyle:{opacity:.5}},select:{itemStyle:{borderColor:"#212121"}},animationEasing:"linear",animationDuration:1e3},e}(rf);function wD(t,e){t.eachSeriesByType("sankey",(function(t){var n=t.get("nodeWidth"),i=t.get("nodeGap"),r=function(t,e){return Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()})}(t,e);t.layoutInfo=r;var o=r.width,a=r.height,s=t.getGraph(),l=s.nodes,u=s.edges;!function(t){P(t,(function(t){var e=PD(t.outEdges,kD),n=PD(t.inEdges,kD),i=t.getValue()||0,r=Math.max(e,n,i);t.setLayout({value:r},!0)}))}(l),function(t,e,n,i,r,o,a,s,l){(function(t,e,n,i,r,o,a){for(var s=[],l=[],u=[],h=[],c=0,p=0;p<e.length;p++)s[p]=1;for(p=0;p<t.length;p++)l[p]=t[p].inEdges.length,0===l[p]&&u.push(t[p]);var d=-1;for(;u.length;){for(var f=0;f<u.length;f++){var g=u[f],y=g.hostGraph.data.getRawDataItem(g.dataIndex),v=null!=y.depth&&y.depth>=0;v&&y.depth>d&&(d=y.depth),g.setLayout({depth:v?y.depth:c},!0),"vertical"===o?g.setLayout({dy:n},!0):g.setLayout({dx:n},!0);for(var m=0;m<g.outEdges.length;m++){var _=g.outEdges[m];s[e.indexOf(_)]=0;var x=_.node2;0==--l[t.indexOf(x)]&&h.indexOf(x)<0&&h.push(x)}}++c,u=h,h=[]}for(p=0;p<s.length;p++)if(1===s[p])throw new Error("Sankey is a DAG, the original data has cycle!");var b=d>c-1?d:c-1;a&&"left"!==a&&function(t,e,n,i){if("right"===e){for(var r=[],o=t,a=0;o.length;){for(var s=0;s<o.length;s++){var l=o[s];l.setLayout({skNodeHeight:a},!0);for(var u=0;u<l.inEdges.length;u++){var h=l.inEdges[u];r.indexOf(h.node1)<0&&r.push(h.node1)}}o=r,r=[],++a}P(t,(function(t){SD(t)||t.setLayout({depth:Math.max(0,i-t.getLayout().skNodeHeight)},!0)}))}else"justify"===e&&function(t,e){P(t,(function(t){SD(t)||t.outEdges.length||t.setLayout({depth:e},!0)}))}(t,i)}(t,a,0,b);!function(t,e,n){P(t,(function(t){var i=t.getLayout().depth*e;"vertical"===n?t.setLayout({y:i},!0):t.setLayout({x:i},!0)}))}(t,"vertical"===o?(r-n)/b:(i-n)/b,o)})(t,e,n,r,o,s,l),function(t,e,n,i,r,o,a){var s=function(t,e){var n=[],i="vertical"===e?"y":"x",r=zr(t,(function(t){return t.getLayout()[i]}));return r.keys.sort((function(t,e){return t-e})),P(r.keys,(function(t){n.push(r.buckets.get(t))})),n}(t,a);(function(t,e,n,i,r,o){var a=1/0;P(t,(function(t){var e=t.length,s=0;P(t,(function(t){s+=t.getLayout().value}));var l="vertical"===o?(i-(e-1)*r)/s:(n-(e-1)*r)/s;l<a&&(a=l)})),P(t,(function(t){P(t,(function(t,e){var n=t.getLayout().value*a;"vertical"===o?(t.setLayout({x:e},!0),t.setLayout({dx:n},!0)):(t.setLayout({y:e},!0),t.setLayout({dy:n},!0))}))})),P(e,(function(t){var e=+t.getValue()*a;t.setLayout({dy:e},!0)}))})(s,e,n,i,r,a),MD(s,r,n,i,a);for(var l=1;o>0;o--)ID(s,l*=.99,a),MD(s,r,n,i,a),OD(s,l,a),MD(s,r,n,i,a)}(t,e,o,r,i,a,s),function(t,e){var n="vertical"===e?"x":"y";P(t,(function(t){t.outEdges.sort((function(t,e){return t.node2.getLayout()[n]-e.node2.getLayout()[n]})),t.inEdges.sort((function(t,e){return t.node1.getLayout()[n]-e.node1.getLayout()[n]}))})),P(t,(function(t){var e=0,n=0;P(t.outEdges,(function(t){t.setLayout({sy:e},!0),e+=t.getLayout().dy})),P(t.inEdges,(function(t){t.setLayout({ty:n},!0),n+=t.getLayout().dy}))}))}(t,s)}(l,u,n,i,o,a,0!==N(l,(function(t){return 0===t.getLayout().value})).length?0:t.get("layoutIterations"),t.get("orient"),t.get("nodeAlign"))}))}function SD(t){var e=t.hostGraph.data.getRawDataItem(t.dataIndex);return null!=e.depth&&e.depth>=0}function MD(t,e,n,i,r){var o="vertical"===r?"x":"y";P(t,(function(t){var a,s,l;t.sort((function(t,e){return t.getLayout()[o]-e.getLayout()[o]}));for(var u=0,h=t.length,c="vertical"===r?"dx":"dy",p=0;p<h;p++)(l=u-(s=t[p]).getLayout()[o])>0&&(a=s.getLayout()[o]+l,"vertical"===r?s.setLayout({x:a},!0):s.setLayout({y:a},!0)),u=s.getLayout()[o]+s.getLayout()[c]+e;if((l=u-e-("vertical"===r?i:n))>0){a=s.getLayout()[o]-l,"vertical"===r?s.setLayout({x:a},!0):s.setLayout({y:a},!0),u=a;for(p=h-2;p>=0;--p)(l=(s=t[p]).getLayout()[o]+s.getLayout()[c]+e-u)>0&&(a=s.getLayout()[o]-l,"vertical"===r?s.setLayout({x:a},!0):s.setLayout({y:a},!0)),u=s.getLayout()[o]}}))}function ID(t,e,n){P(t.slice().reverse(),(function(t){P(t,(function(t){if(t.outEdges.length){var i=PD(t.outEdges,TD,n)/PD(t.outEdges,kD);if(isNaN(i)){var r=t.outEdges.length;i=r?PD(t.outEdges,CD,n)/r:0}if("vertical"===n){var o=t.getLayout().x+(i-LD(t,n))*e;t.setLayout({x:o},!0)}else{var a=t.getLayout().y+(i-LD(t,n))*e;t.setLayout({y:a},!0)}}}))}))}function TD(t,e){return LD(t.node2,e)*t.getValue()}function CD(t,e){return LD(t.node2,e)}function AD(t,e){return LD(t.node1,e)*t.getValue()}function DD(t,e){return LD(t.node1,e)}function LD(t,e){return"vertical"===e?t.getLayout().x+t.getLayout().dx/2:t.getLayout().y+t.getLayout().dy/2}function kD(t){return t.getValue()}function PD(t,e,n){for(var i=0,r=t.length,o=-1;++o<r;){var a=+e(t[o],n);isNaN(a)||(i+=a)}return i}function OD(t,e,n){P(t,(function(t){P(t,(function(t){if(t.inEdges.length){var i=PD(t.inEdges,AD,n)/PD(t.inEdges,kD);if(isNaN(i)){var r=t.inEdges.length;i=r?PD(t.inEdges,DD,n)/r:0}if("vertical"===n){var o=t.getLayout().x+(i-LD(t,n))*e;t.setLayout({x:o},!0)}else{var a=t.getLayout().y+(i-LD(t,n))*e;t.setLayout({y:a},!0)}}}))}))}function RD(t){t.eachSeriesByType("sankey",(function(t){var e=t.getGraph().nodes;if(e.length){var n=1/0,i=-1/0;P(e,(function(t){var e=t.getLayout().value;e<n&&(n=e),e>i&&(i=e)})),P(e,(function(e){var r=new eT({type:"color",mappingMethod:"linear",dataExtent:[n,i],visual:t.get("color")}).mapValueToVisual(e.getLayout().value),o=e.getModel().get(["itemStyle","color"]);null!=o?(e.setVisual("color",o),e.setVisual("style",{fill:o})):(e.setVisual("color",r),e.setVisual("style",{fill:r}))}))}}))}var ND=function(){function t(){}return t.prototype.getInitialData=function(t,e){var n,i,r=e.getComponent("xAxis",this.get("xAxisIndex")),o=e.getComponent("yAxis",this.get("yAxisIndex")),a=r.get("type"),s=o.get("type");"category"===a?(t.layout="horizontal",n=r.getOrdinalMeta(),i=!0):"category"===s?(t.layout="vertical",n=o.getOrdinalMeta(),i=!0):t.layout=t.layout||"horizontal";var l=["x","y"],u="horizontal"===t.layout?0:1,h=this._baseAxisDim=l[u],c=l[1-u],p=[r,o],d=p[u].get("type"),f=p[1-u].get("type"),g=t.data;if(g&&i){var y=[];P(g,(function(t,e){var n;F(t)?(n=t.slice(),t.unshift(e)):F(t.value)?(n=t.value.slice(),t.value.unshift(e)):n=t,y.push(n)})),t.data=y}var v=this.defaultValueDimensions,m=[{name:h,type:am(d),ordinalMeta:n,otherDims:{tooltip:!1,itemName:0},dimsDef:["base"]},{name:c,type:am(f),dimsDef:v.slice()}];return Rw(this,{coordDimensions:m,dimensionsCount:v.length+1,encodeDefaulter:V(Jc,m,this)})},t.prototype.getBaseAxis=function(){var t=this._baseAxisDim;return this.ecModel.getComponent(t+"Axis",this.get(t+"AxisIndex")).axis},t}(),ED=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.defaultValueDimensions=[{name:"min",defaultTooltip:!0},{name:"Q1",defaultTooltip:!0},{name:"median",defaultTooltip:!0},{name:"Q3",defaultTooltip:!0},{name:"max",defaultTooltip:!0}],n.visualDrawType="stroke",n}return n(e,t),e.type="series.boxplot",e.dependencies=["xAxis","yAxis","grid"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"cartesian2d",legendHoverLink:!0,layout:null,boxWidth:[7,50],itemStyle:{color:"#fff",borderWidth:1},emphasis:{scale:!0,itemStyle:{borderWidth:2,shadowBlur:5,shadowOffsetX:1,shadowOffsetY:1,shadowColor:"rgba(0,0,0,0.2)"}},animationDuration:800},e}(rf);L(ED,ND,!0);var zD=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.getData(),r=this.group,o=this._data;this._data||r.removeAll();var a="horizontal"===t.get("layout")?1:0;i.diff(o).add((function(t){if(i.hasValue(t)){var e=FD(i.getItemLayout(t),i,t,a,!0);i.setItemGraphicEl(t,e),r.add(e)}})).update((function(t,e){var n=o.getItemGraphicEl(e);if(i.hasValue(t)){var s=i.getItemLayout(t);n?GD(s,n,i,t):n=FD(s,i,t,a),r.add(n),i.setItemGraphicEl(t,n)}else r.remove(n)})).remove((function(t){var e=o.getItemGraphicEl(t);e&&r.remove(e)})).execute(),this._data=i},e.prototype.remove=function(t){var e=this.group,n=this._data;this._data=null,n&&n.eachItemGraphicEl((function(t){t&&e.remove(t)}))},e.type="boxplot",e}(yf),BD=function(){},VD=function(t){function e(e){var n=t.call(this,e)||this;return n.type="boxplotBoxPath",n}return n(e,t),e.prototype.getDefaultShape=function(){return new BD},e.prototype.buildPath=function(t,e){var n=e.points,i=0;for(t.moveTo(n[i][0],n[i][1]),i++;i<4;i++)t.lineTo(n[i][0],n[i][1]);for(t.closePath();i<n.length;i++)t.moveTo(n[i][0],n[i][1]),i++,t.lineTo(n[i][0],n[i][1])},e}(Za);function FD(t,e,n,i,r){var o=t.ends,a=new VD({shape:{points:r?HD(o,i,t):o}});return GD(t,a,e,n,r),a}function GD(t,e,n,i,r){var o=n.hostModel;(0,Ku[r?"initProps":"updateProps"])(e,{shape:{points:t.ends}},o,i),e.useStyle(n.getItemVisual(i,"style")),e.style.strokeNoScale=!0,e.z2=100;var a=n.getItemModel(i);nl(e,a),Js(e,a.get(["emphasis","focus"]),a.get(["emphasis","blurScope"]))}function HD(t,e,n){return O(t,(function(t){return(t=t.slice())[e]=n.initBaseline,t}))}function WD(t,e){t.eachRawSeriesByType("boxplot",(function(t){t.getData().setVisual("legendSymbol","roundRect")}))}var YD=P;function XD(t){var e=function(t){var e=[],n=[];return t.eachSeriesByType("boxplot",(function(t){var i=t.getBaseAxis(),r=A(n,i);r<0&&(r=n.length,n[r]=i,e[r]={axis:i,seriesModels:[]}),e[r].seriesModels.push(t)})),e}(t);YD(e,(function(t){var e=t.seriesModels;e.length&&(!function(t){var e,n,i=t.axis,r=t.seriesModels,o=r.length,a=t.boxWidthList=[],s=t.boxOffsetList=[],l=[];if("category"===i.type)n=i.getBandWidth();else{var u=0;YD(r,(function(t){u=Math.max(u,t.getData().count())})),e=i.getExtent(),Math.abs(e[1]-e[0])}YD(r,(function(t){var e=t.get("boxWidth");F(e)||(e=[e,e]),l.push([Zi(e[0],n)||0,Zi(e[1],n)||0])}));var h=.8*n-2,c=h/o*.3,p=(h-c*(o-1))/o,d=p/2-h/2;YD(r,(function(t,e){s.push(d),d+=c+p,a.push(Math.min(Math.max(p,l[e][0]),l[e][1]))}))}(t),YD(e,(function(e,n){!function(t,e,n){var i=t.coordinateSystem,r=t.getData(),o=n/2,a="horizontal"===t.get("layout")?0:1,s=1-a,l=["x","y"],u=r.mapDimension(l[a]),h=r.mapDimensionsAll(l[s]);if(null==u||h.length<5)return;for(var c=0;c<r.count();c++){var p=r.get(u,c),d=_(p,h[2],c),f=_(p,h[0],c),g=_(p,h[1],c),y=_(p,h[3],c),v=_(p,h[4],c),m=[];x(m,g,!1),x(m,y,!0),m.push(f,g,v,y),b(m,f),b(m,v),b(m,d),r.setItemLayout(c,{initBaseline:d[s],ends:m})}function _(t,n,o){var l,u=r.get(n,o),h=[];return h[a]=t,h[s]=u,isNaN(t)||isNaN(u)?l=[NaN,NaN]:(l=i.dataToPoint(h))[a]+=e,l}function x(t,e,n){var i=e.slice(),r=e.slice();i[a]+=o,r[a]-=o,n?t.push(i,r):t.push(r,i)}function b(t,e){var n=e.slice(),i=e.slice();n[a]-=o,i[a]+=o,t.push(n,i)}}(e,t.boxOffsetList[n],t.boxWidthList[n])})))}))}var UD={type:"echarts:boxplot",transform:function(t){var e=t.upstream;if(e.sourceFormat!==Gc){var n="";0,yr(n)}var i=function(t,e){for(var n=[],i=[],r=(e=e||{}).boundIQR,o="none"===r||0===r,a=0;a<t.length;a++){var s=qi(t[a].slice()),l=lr(s,.25),u=lr(s,.5),h=lr(s,.75),c=s[0],p=s[s.length-1],d=(null==r?1.5:r)*(h-l),f=o?c:Math.max(c,l-d),g=o?p:Math.min(p,h+d),y=e.itemNameFormatter,v=G(y)?y({value:a}):H(y)?y.replace("{value}",a+""):a+"";n.push([v,f,l,u,h,g]);for(var m=0;m<s.length;m++){var _=s[m];if(_<f||_>g){var x=[v,_];i.push(x)}}}return{boxData:n,outliers:i}}(e.getRawData(),t.config);return[{dimensions:["ItemName","Low","Q1","Q2","Q3","High"],data:i.boxData},{data:i.outliers}]}};var ZD=["color","borderColor"],jD=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){this.group.removeClipPath(),this._updateDrawMode(t),this._isLargeDraw?this._renderLarge(t):this._renderNormal(t)},e.prototype.incrementalPrepareRender=function(t,e,n){this._clear(),this._updateDrawMode(t)},e.prototype.incrementalRender=function(t,e,n,i){this._isLargeDraw?this._incrementalRenderLarge(t,e):this._incrementalRenderNormal(t,e)},e.prototype._updateDrawMode=function(t){var e=t.pipelineContext.large;null!=this._isLargeDraw&&e===this._isLargeDraw||(this._isLargeDraw=e,this._clear())},e.prototype._renderNormal=function(t){var e=t.getData(),n=this._data,i=this.group,r=e.getLayout("isSimpleBox"),o=t.get("clip",!0),a=t.coordinateSystem,s=a.getArea&&a.getArea();this._data||i.removeAll(),e.diff(n).add((function(n){if(e.hasValue(n)){var a=e.getItemLayout(n);if(o&&JD(s,a))return;var l=$D(a,n,!0);Ru(l,{shape:{points:a.ends}},t,n),QD(l,e,n,r),i.add(l),e.setItemGraphicEl(n,l)}})).update((function(a,l){var u=n.getItemGraphicEl(l);if(e.hasValue(a)){var h=e.getItemLayout(a);o&&JD(s,h)?i.remove(u):(u?Ou(u,{shape:{points:h.ends}},t,a):u=$D(h),QD(u,e,a,r),i.add(u),e.setItemGraphicEl(a,u))}else i.remove(u)})).remove((function(t){var e=n.getItemGraphicEl(t);e&&i.remove(e)})).execute(),this._data=e},e.prototype._renderLarge=function(t){this._clear(),iL(t,this.group);var e=t.get("clip",!0)?Hb(t.coordinateSystem,!1,t):null;e?this.group.setClipPath(e):this.group.removeClipPath()},e.prototype._incrementalRenderNormal=function(t,e){for(var n,i=e.getData(),r=i.getLayout("isSimpleBox");null!=(n=t.next());){var o=$D(i.getItemLayout(n));QD(o,i,n,r),o.incremental=!0,this.group.add(o)}},e.prototype._incrementalRenderLarge=function(t,e){iL(e,this.group,!0)},e.prototype.remove=function(t){this._clear()},e.prototype._clear=function(){this.group.removeAll(),this._data=null},e.type="candlestick",e}(yf),qD=function(){},KD=function(t){function e(e){var n=t.call(this,e)||this;return n.type="normalCandlestickBox",n}return n(e,t),e.prototype.getDefaultShape=function(){return new qD},e.prototype.buildPath=function(t,e){var n=e.points;this.__simpleBox?(t.moveTo(n[4][0],n[4][1]),t.lineTo(n[6][0],n[6][1])):(t.moveTo(n[0][0],n[0][1]),t.lineTo(n[1][0],n[1][1]),t.lineTo(n[2][0],n[2][1]),t.lineTo(n[3][0],n[3][1]),t.closePath(),t.moveTo(n[4][0],n[4][1]),t.lineTo(n[5][0],n[5][1]),t.moveTo(n[6][0],n[6][1]),t.lineTo(n[7][0],n[7][1]))},e}(Za);function $D(t,e,n){var i=t.ends;return new KD({shape:{points:n?tL(i,t):i},z2:100})}function JD(t,e){for(var n=!0,i=0;i<e.ends.length;i++)if(t.contain(e.ends[i][0],e.ends[i][1])){n=!1;break}return n}function QD(t,e,n,i){var r=e.getItemModel(n);t.useStyle(e.getItemVisual(n,"style")),t.style.strokeNoScale=!0,t.__simpleBox=i,nl(t,r)}function tL(t,e){return O(t,(function(t){return(t=t.slice())[1]=e.initBaseline,t}))}var eL=function(){},nL=function(t){function e(e){var n=t.call(this,e)||this;return n.type="largeCandlestickBox",n}return n(e,t),e.prototype.getDefaultShape=function(){return new eL},e.prototype.buildPath=function(t,e){for(var n=e.points,i=0;i<n.length;)if(this.__sign===n[i++]){var r=n[i++];t.moveTo(r,n[i++]),t.lineTo(r,n[i++])}else i+=3},e}(Za);function iL(t,e,n){var i=t.getData().getLayout("largePoints"),r=new nL({shape:{points:i},__sign:1});e.add(r);var o=new nL({shape:{points:i},__sign:-1});e.add(o),rL(1,r,t),rL(-1,o,t),n&&(r.incremental=!0,o.incremental=!0)}function rL(t,e,n,i){var r=n.get(["itemStyle",t>0?"borderColor":"borderColor0"])||n.get(["itemStyle",t>0?"color":"color0"]),o=n.getModel("itemStyle").getItemStyle(ZD);e.useStyle(o),e.style.fill=null,e.style.stroke=r}var oL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.defaultValueDimensions=[{name:"open",defaultTooltip:!0},{name:"close",defaultTooltip:!0},{name:"lowest",defaultTooltip:!0},{name:"highest",defaultTooltip:!0}],n}return n(e,t),e.prototype.getShadowDim=function(){return"open"},e.prototype.brushSelector=function(t,e,n){var i=e.getItemLayout(t);return i&&n.rect(i.brushRect)},e.type="series.candlestick",e.dependencies=["xAxis","yAxis","grid"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"cartesian2d",legendHoverLink:!0,layout:null,clip:!0,itemStyle:{color:"#eb5454",color0:"#47b262",borderColor:"#eb5454",borderColor0:"#47b262",borderWidth:1},emphasis:{scale:!0,itemStyle:{borderWidth:2}},barMaxWidth:null,barMinWidth:null,barWidth:null,large:!0,largeThreshold:600,progressive:3e3,progressiveThreshold:1e4,progressiveChunkMode:"mod",animationEasing:"linear",animationDuration:300},e}(rf);function aL(t){t&&F(t.series)&&P(t.series,(function(t){X(t)&&"k"===t.type&&(t.type="candlestick")}))}L(oL,ND,!0);var sL=["itemStyle","borderColor"],lL=["itemStyle","borderColor0"],uL=["itemStyle","color"],hL=["itemStyle","color0"],cL={seriesType:"candlestick",plan:df(),performRawSeries:!0,reset:function(t,e){function n(t,e){return e.get(t>0?uL:hL)}function i(t,e){return e.get(t>0?sL:lL)}if(t.getData().setVisual("legendSymbol","roundRect"),!e.isSeriesFiltered(t))return!t.pipelineContext.large&&{progress:function(t,e){for(var r;null!=(r=t.next());){var o=e.getItemModel(r),a=e.getItemLayout(r).sign,s=o.getItemStyle();s.fill=n(a,o),s.stroke=i(a,o)||s.fill,I(e.ensureUniqueItemVisual(r,"style"),s)}}}}},pL="undefined"!=typeof Float32Array?Float32Array:Array,dL={seriesType:"candlestick",plan:df(),reset:function(t){var e=t.coordinateSystem,n=t.getData(),i=function(t,e){var n,i=t.getBaseAxis(),r="category"===i.type?i.getBandWidth():(n=i.getExtent(),Math.abs(n[1]-n[0])/e.count()),o=Zi(tt(t.get("barMaxWidth"),r),r),a=Zi(tt(t.get("barMinWidth"),1),r),s=t.get("barWidth");return null!=s?Zi(s,r):Math.max(Math.min(r/2,o),a)}(t,n),r=["x","y"],o=n.mapDimension(r[0]),a=n.mapDimensionsAll(r[1]),s=a[0],l=a[1],u=a[2],h=a[3];if(n.setLayout({candleWidth:i,isSimpleBox:i<=1.3}),!(null==o||a.length<4))return{progress:t.pipelineContext.large?function(t,n){var i,r,a=new pL(4*t.count),c=0,p=[],d=[];for(;null!=(r=t.next());){var f=n.get(o,r),g=n.get(s,r),y=n.get(l,r),v=n.get(u,r),m=n.get(h,r);isNaN(f)||isNaN(v)||isNaN(m)?(a[c++]=NaN,c+=3):(a[c++]=fL(n,r,g,y,l),p[0]=f,p[1]=v,i=e.dataToPoint(p,null,d),a[c++]=i?i[0]:NaN,a[c++]=i?i[1]:NaN,p[1]=m,i=e.dataToPoint(p,null,d),a[c++]=i?i[1]:NaN)}n.setLayout("largePoints",a)}:function(t,n){var r;for(;null!=(r=t.next());){var a=n.get(o,r),c=n.get(s,r),p=n.get(l,r),d=n.get(u,r),f=n.get(h,r),g=Math.min(c,p),y=Math.max(c,p),v=w(g,a),m=w(y,a),_=w(d,a),x=w(f,a),b=[];S(b,m,0),S(b,v,1),b.push(I(x),I(m),I(_),I(v)),n.setItemLayout(r,{sign:fL(n,r,c,p,l),initBaseline:c>p?m[1]:v[1],ends:b,brushRect:M(d,f,a)})}function w(t,n){var i=[];return i[0]=n,i[1]=t,isNaN(n)||isNaN(t)?[NaN,NaN]:e.dataToPoint(i)}function S(t,e,n){var r=e.slice(),o=e.slice();r[0]=ku(r[0]+i/2,1,!1),o[0]=ku(o[0]-i/2,1,!0),n?t.push(r,o):t.push(o,r)}function M(t,e,n){var r=w(t,n),o=w(e,n);return r[0]-=i/2,o[0]-=i/2,{x:r[0],y:r[1],width:i,height:o[1]-r[1]}}function I(t){return t[0]=ku(t[0],1),t}}}}};function fL(t,e,n,i,r){return n>i?-1:n<i?1:e>0?t.get(r,e-1)<=i?1:-1:1}function gL(t,e){var n=e.rippleEffectColor||e.color;t.eachChild((function(t){t.attr({z:e.z,zlevel:e.zlevel,style:{stroke:"stroke"===e.brushType?n:null,fill:"fill"===e.brushType?n:null}})}))}var yL=function(t){function e(e,n){var i=t.call(this)||this,r=new bb(e,n),o=new zi;return i.add(r),i.add(o),i.updateData(e,n),i}return n(e,t),e.prototype.stopEffectAnimation=function(){this.childAt(1).removeAll()},e.prototype.startEffectAnimation=function(t){for(var e=t.symbolType,n=t.color,i=this.childAt(1),r=0;r<3;r++){var o=uy(e,-1,-1,2,2,n);o.attr({style:{strokeNoScale:!0},z2:99,silent:!0,scaleX:.5,scaleY:.5});var a=-r/3*t.period+t.effectOffset;o.animate("",!0).when(t.period,{scale:[t.rippleScale/2,t.rippleScale/2]}).delay(a).start(),o.animateStyle(!0).when(t.period,{opacity:0}).delay(a).start(),i.add(o)}gL(i,t)},e.prototype.updateEffectAnimation=function(t){for(var e=this._effectCfg,n=this.childAt(1),i=["symbolType","period","rippleScale"],r=0;r<i.length;r++){var o=i[r];if(e[o]!==t[o])return this.stopEffectAnimation(),void this.startEffectAnimation(t)}gL(n,t)},e.prototype.highlight=function(){Hs(this)},e.prototype.downplay=function(){Ws(this)},e.prototype.updateData=function(t,e){var n=this,i=t.hostModel;this.childAt(0).updateData(t,e);var r=this.childAt(1),o=t.getItemModel(e),a=t.getItemVisual(e,"symbol"),s=function(t){return F(t)||(t=[+t,+t]),t}(t.getItemVisual(e,"symbolSize")),l=t.getItemVisual(e,"style"),u=l&&l.fill;r.setScale(s),r.traverse((function(t){t.setStyle("fill",u)}));var h=o.getShallow("symbolOffset");h&&(r.x=Zi(h[0],s[0]),r.y=Zi(h[1],s[1]));var c=t.getItemVisual(e,"symbolRotate");r.rotation=(c||0)*Math.PI/180||0;var p={};p.showEffectOn=i.get("showEffectOn"),p.rippleScale=o.get(["rippleEffect","scale"]),p.brushType=o.get(["rippleEffect","brushType"]),p.period=1e3*o.get(["rippleEffect","period"]),p.effectOffset=e/t.count(),p.z=i.getShallow("z")||0,p.zlevel=i.getShallow("zlevel")||0,p.symbolType=a,p.color=u,p.rippleEffectColor=o.get(["rippleEffect","color"]),this.off("mouseover").off("mouseout").off("emphasis").off("normal"),"render"===p.showEffectOn?(this._effectCfg?this.updateEffectAnimation(p):this.startEffectAnimation(p),this._effectCfg=p):(this._effectCfg=null,this.stopEffectAnimation(),this.onHoverStateChange=function(t){"emphasis"===t?"render"!==p.showEffectOn&&n.startEffectAnimation(p):"normal"===t&&"render"!==p.showEffectOn&&n.stopEffectAnimation()}),this._effectCfg=p,Js(this)},e.prototype.fadeOut=function(t){this.off("mouseover").off("mouseout"),t&&t()},e}(zi);D(yL,zi);var vL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(){this._symbolDraw=new Tb(yL)},e.prototype.render=function(t,e,n){var i=t.getData(),r=this._symbolDraw;r.updateData(i),this.group.add(r.group)},e.prototype.updateTransform=function(t,e,n){var i=t.getData();this.group.dirty();var r=Qb("").reset(t,e,n);r.progress&&r.progress({start:0,end:i.count(),count:i.count()},i),this._symbolDraw.updateLayout()},e.prototype._updateGroupTransform=function(t){var e=t.coordinateSystem;e&&e.getRoamTransform&&(this.group.transform=we(e.getRoamTransform()),this.group.decomposeTransform())},e.prototype.remove=function(t,e){this._symbolDraw&&this._symbolDraw.remove(!0)},e.type="effectScatter",e}(yf),mL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.hasSymbolVisual=!0,n}return n(e,t),e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this,{useEncodeDefaulter:!0})},e.prototype.brushSelector=function(t,e,n){return n.point(e.getItemLayout(t))},e.type="series.effectScatter",e.dependencies=["grid","polar"],e.defaultOption={coordinateSystem:"cartesian2d",zlevel:0,z:2,legendHoverLink:!0,effectType:"ripple",progressive:0,showEffectOn:"render",rippleEffect:{period:4,scale:2.5,brushType:"fill"},symbolSize:10},e}(rf);var _L=function(t){function e(e,n,i){var r=t.call(this)||this;return r.add(r.createLine(e,n,i)),r._updateEffectSymbol(e,n),r}return n(e,t),e.prototype.createLine=function(t,e,n){return new pC(t,e,n)},e.prototype._updateEffectSymbol=function(t,e){var n=t.getItemModel(e).getModel("effect"),i=n.get("symbolSize"),r=n.get("symbol");F(i)||(i=[i,i]);var o=t.getItemVisual(e,"style"),a=n.get("color")||o&&o.stroke,s=this.childAt(1);this._symbolType!==r&&(this.remove(s),(s=uy(r,-.5,-.5,1,1,a)).z2=100,s.culling=!0,this.add(s)),s&&(s.setStyle("shadowColor",a),s.setStyle(n.getItemStyle(["color"])),s.scaleX=i[0],s.scaleY=i[1],s.setColor(a),this._symbolType=r,this._symbolScale=i,this._updateEffectAnimation(t,n,e))},e.prototype._updateEffectAnimation=function(t,e,n){var i=this.childAt(1);if(i){var r=this,o=t.getItemLayout(n),a=1e3*e.get("period"),s=e.get("loop"),l=e.get("constantSpeed"),u=Q(e.get("delay"),(function(e){return e/t.count()*a/3}));if(i.ignore=!0,this._updateAnimationPoints(i,o),l>0&&(a=this._getLineLength(i)/l*1e3),(a!==this._period||s!==this._loop)&&(i.stopAnimation(),a>0)){var h=void 0;h="function"==typeof u?u(n):u,i.__t>0&&(h=-a*i.__t),i.__t=0;var c=i.animate("",s).when(a,{__t:1}).delay(h).during((function(){r._updateSymbolPosition(i)}));s||c.done((function(){r.remove(i)})),c.start()}this._period=a,this._loop=s}},e.prototype._getLineLength=function(t){return Lt(t.__p1,t.__cp1)+Lt(t.__cp1,t.__p2)},e.prototype._updateAnimationPoints=function(t,e){t.__p1=e[0],t.__p2=e[1],t.__cp1=e[2]||[(e[0][0]+e[1][0])/2,(e[0][1]+e[1][1])/2]},e.prototype.updateData=function(t,e,n){this.childAt(0).updateData(t,e,n),this._updateEffectSymbol(t,e)},e.prototype._updateSymbolPosition=function(t){var e=t.__p1,n=t.__p2,i=t.__cp1,r=t.__t,o=[t.x,t.y],a=o.slice(),s=Go,l=Ho;o[0]=s(e[0],i[0],n[0],r),o[1]=s(e[1],i[1],n[1],r);var u=l(e[0],i[0],n[0],r),h=l(e[1],i[1],n[1],r);t.rotation=-Math.atan2(h,u)-Math.PI/2,"line"!==this._symbolType&&"rect"!==this._symbolType&&"roundRect"!==this._symbolType||(void 0!==t.__lastT&&t.__lastT<t.__t?(t.scaleY=1.05*Lt(a,o),1===r&&(o[0]=a[0]+(o[0]-a[0])/2,o[1]=a[1]+(o[1]-a[1])/2)):1===t.__lastT?t.scaleY=2*Lt(e,o):t.scaleY=this._symbolScale[1]),t.__lastT=t.__t,t.ignore=!1,t.x=o[0],t.y=o[1]},e.prototype.updateLayout=function(t,e){this.childAt(0).updateLayout(t,e);var n=t.getItemModel(e).getModel("effect");this._updateEffectAnimation(t,n,e)},e}(zi),xL=function(t){function e(e,n,i){var r=t.call(this)||this;return r._createPolyline(e,n,i),r}return n(e,t),e.prototype._createPolyline=function(t,e,n){var i=t.getItemLayout(e),r=new $l({shape:{points:i}});this.add(r),this._updateCommonStl(t,e,n)},e.prototype.updateData=function(t,e,n){var i=t.hostModel;Ou(this.childAt(0),{shape:{points:t.getItemLayout(e)}},i,e),this._updateCommonStl(t,e,n)},e.prototype._updateCommonStl=function(t,e,n){var i=this.childAt(0),r=t.getItemModel(e),o=n&&n.emphasisLineStyle;n&&!t.hasItemOption||(o=r.getModel(["emphasis","lineStyle"]).getLineStyle()),i.useStyle(t.getItemVisual(e,"style")),i.style.fill=null,i.style.strokeNoScale=!0,i.ensureState("emphasis").style=o,Js(this)},e.prototype.updateLayout=function(t,e){this.childAt(0).setShape("points",t.getItemLayout(e))},e}(zi),bL=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._lastFrame=0,e._lastFramePercent=0,e}return n(e,t),e.prototype.createLine=function(t,e,n){return new xL(t,e,n)},e.prototype._updateAnimationPoints=function(t,e){this._points=e;for(var n=[0],i=0,r=1;r<e.length;r++){var o=e[r-1],a=e[r];i+=Lt(o,a),n.push(i)}if(0!==i){for(r=0;r<n.length;r++)n[r]/=i;this._offsets=n,this._length=i}else this._length=0},e.prototype._getLineLength=function(){return this._length},e.prototype._updateSymbolPosition=function(t){var e=t.__t,n=this._points,i=this._offsets,r=n.length;if(i){var o,a=this._lastFrame;if(e<this._lastFramePercent){for(o=Math.min(a+1,r-1);o>=0&&!(i[o]<=e);o--);o=Math.min(o,r-2)}else{for(o=a;o<r&&!(i[o]>e);o++);o=Math.min(o-1,r-2)}var s=(e-i[o])/(i[o+1]-i[o]),l=n[o],u=n[o+1];t.x=l[0]*(1-s)+s*u[0],t.y=l[1]*(1-s)+s*u[1];var h=u[0]-l[0],c=u[1]-l[1];t.rotation=-Math.atan2(c,h)-Math.PI/2,this._lastFrame=o,this._lastFramePercent=e,t.ignore=!1}},e}(_L),wL=function(){this.polyline=!1,this.curveness=0,this.segs=[]},SL=function(t){function e(e){return t.call(this,e)||this}return n(e,t),e.prototype.getDefaultStyle=function(){return{stroke:"#000",fill:null}},e.prototype.getDefaultShape=function(){return new wL},e.prototype.buildPath=function(t,e){var n=e.segs,i=e.curveness;if(e.polyline)for(var r=0;r<n.length;){var o=n[r++];if(o>0){t.moveTo(n[r++],n[r++]);for(var a=1;a<o;a++)t.lineTo(n[r++],n[r++])}}else for(r=0;r<n.length;){var s=n[r++],l=n[r++],u=n[r++],h=n[r++];if(t.moveTo(s,l),i>0){var c=(s+u)/2-(l-h)*i,p=(l+h)/2-(u-s)*i;t.quadraticCurveTo(c,p,u,h)}else t.lineTo(u,h)}},e.prototype.findDataIndex=function(t,e){var n=this.shape,i=n.segs,r=n.curveness,o=this.style.lineWidth;if(n.polyline)for(var a=0,s=0;s<i.length;){var l=i[s++];if(l>0)for(var u=i[s++],h=i[s++],c=1;c<l;c++){if(Aa(u,h,p=i[s++],d=i[s++],o,t,e))return a}a++}else for(a=0,s=0;s<i.length;){u=i[s++],h=i[s++];var p=i[s++],d=i[s++];if(r>0){if(La(u,h,(u+p)/2-(h-d)*r,(h+d)/2-(p-u)*r,p,d,o,t,e))return a}else if(Aa(u,h,p,d,o,t,e))return a;a++}return-1},e}(Za),ML=function(){function t(){this.group=new zi}return t.prototype.isPersistent=function(){return!this._incremental},t.prototype.updateData=function(t){this.group.removeAll();var e=new SL({rectHover:!0,cursor:"default"});e.setShape({segs:t.getLayout("linesPoints")}),this._setCommon(e,t),this.group.add(e),this._incremental=null},t.prototype.incrementalPrepareUpdate=function(t){this.group.removeAll(),this._clearIncremental(),t.count()>5e5?(this._incremental||(this._incremental=new vu({silent:!0})),this.group.add(this._incremental)):this._incremental=null},t.prototype.incrementalUpdate=function(t,e){var n=new SL;n.setShape({segs:e.getLayout("linesPoints")}),this._setCommon(n,e,!!this._incremental),this._incremental?this._incremental.addDisplayable(n,!0):(n.rectHover=!0,n.cursor="default",n.__startIndex=t.start,this.group.add(n))},t.prototype.remove=function(){this._clearIncremental(),this._incremental=null,this.group.removeAll()},t.prototype._setCommon=function(t,e,n){var i=e.hostModel;t.setShape({polyline:i.get("polyline"),curveness:i.get(["lineStyle","curveness"])}),t.useStyle(i.getModel("lineStyle").getLineStyle()),t.style.strokeNoScale=!0;var r=e.getVisual("style");if(r&&r.stroke&&t.setStyle("stroke",r.stroke),t.setStyle("fill",null),!n){var o=ys(t);o.seriesIndex=i.seriesIndex,t.on("mousemove",(function(e){o.dataIndex=null;var n=t.findDataIndex(e.offsetX,e.offsetY);n>0&&(o.dataIndex=n+t.__startIndex)}))}},t.prototype._clearIncremental=function(){var t=this._incremental;t&&t.clearDisplaybles()},t}(),IL={seriesType:"lines",plan:df(),reset:function(t){var e=t.coordinateSystem,n=t.get("polyline"),i=t.pipelineContext.large;return{progress:function(r,o){var a=[];if(i){var s=void 0,l=r.end-r.start;if(n){for(var u=0,h=r.start;h<r.end;h++)u+=t.getLineCoordsCount(h);s=new Float32Array(l+2*u)}else s=new Float32Array(4*l);var c=0,p=[];for(h=r.start;h<r.end;h++){var d=t.getLineCoords(h,a);n&&(s[c++]=d);for(var f=0;f<d;f++)p=e.dataToPoint(a[f],!1,p),s[c++]=p[0],s[c++]=p[1]}o.setLayout("linesPoints",s)}else for(h=r.start;h<r.end;h++){var g=o.getItemModel(h),y=(d=t.getLineCoords(h,a),[]);if(n)for(var v=0;v<d;v++)y.push(e.dataToPoint(a[v]));else{y[0]=e.dataToPoint(a[0]),y[1]=e.dataToPoint(a[1]);var m=g.get(["lineStyle","curveness"]);+m&&(y[2]=[(y[0][0]+y[1][0])/2-(y[0][1]-y[1][1])*m,(y[0][1]+y[1][1])/2-(y[1][0]-y[0][0])*m])}o.setItemLayout(h,y)}}}}},TL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.getData(),r=this._updateLineDraw(i,t),o=t.get("zlevel"),a=t.get(["effect","trailLength"]),s=n.getZr(),l="svg"===s.painter.getType();(l||s.painter.getLayer(o).clear(!0),null==this._lastZlevel||l||s.configLayer(this._lastZlevel,{motionBlur:!1}),this._showEffect(t)&&a)&&(l||s.configLayer(o,{motionBlur:!0,lastFrameAlpha:Math.max(Math.min(a/10+.9,1),0)}));r.updateData(i);var u=t.get("clip",!0)&&Hb(t.coordinateSystem,!1,t);u?this.group.setClipPath(u):this.group.removeClipPath(),this._lastZlevel=o,this._finished=!0},e.prototype.incrementalPrepareRender=function(t,e,n){var i=t.getData();this._updateLineDraw(i,t).incrementalPrepareUpdate(i),this._clearLayer(n),this._finished=!1},e.prototype.incrementalRender=function(t,e,n){this._lineDraw.incrementalUpdate(t,e.getData()),this._finished=t.end===e.getData().count()},e.prototype.updateTransform=function(t,e,n){var i=t.getData(),r=t.pipelineContext;if(!this._finished||r.large||r.progressiveRender)return{update:!0};var o=IL.reset(t,e,n);o.progress&&o.progress({start:0,end:i.count(),count:i.count()},i),this._lineDraw.updateLayout(),this._clearLayer(n)},e.prototype._updateLineDraw=function(t,e){var n=this._lineDraw,i=this._showEffect(e),r=!!e.get("polyline"),o=e.pipelineContext.large;return n&&i===this._hasEffet&&r===this._isPolyline&&o===this._isLargeDraw||(n&&n.remove(),n=this._lineDraw=o?new ML:new dC(r?i?bL:xL:i?_L:pC),this._hasEffet=i,this._isPolyline=r,this._isLargeDraw=o,this.group.removeAll()),this.group.add(n.group),n},e.prototype._showEffect=function(t){return!!t.get(["effect","show"])},e.prototype._clearLayer=function(t){var e=t.getZr();"svg"===e.painter.getType()||null==this._lastZlevel||e.painter.getLayer(this._lastZlevel).clear(!0)},e.prototype.remove=function(t,e){this._lineDraw&&this._lineDraw.remove(),this._lineDraw=null,this._clearLayer(e)},e.type="lines",e}(yf),CL="undefined"==typeof Uint32Array?Array:Uint32Array,AL="undefined"==typeof Float64Array?Array:Float64Array;function DL(t){var e=t.data;e&&e[0]&&e[0][0]&&e[0][0].coord&&(t.data=O(e,(function(t){var e={coords:[t[0].coord,t[1].coord]};return t[0].name&&(e.fromName=t[0].name),t[1].name&&(e.toName=t[1].name),M([e,t[0],t[1]])})))}var LL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.visualStyleAccessPath="lineStyle",n.visualDrawType="stroke",n}return n(e,t),e.prototype.init=function(e){e.data=e.data||[],DL(e);var n=this._processFlatCoordsArray(e.data);this._flatCoords=n.flatCoords,this._flatCoordsOffset=n.flatCoordsOffset,n.flatCoords&&(e.data=new Float32Array(n.count)),t.prototype.init.apply(this,arguments)},e.prototype.mergeOption=function(e){if(DL(e),e.data){var n=this._processFlatCoordsArray(e.data);this._flatCoords=n.flatCoords,this._flatCoordsOffset=n.flatCoordsOffset,n.flatCoords&&(e.data=new Float32Array(n.count))}t.prototype.mergeOption.apply(this,arguments)},e.prototype.appendData=function(t){var e=this._processFlatCoordsArray(t.data);e.flatCoords&&(this._flatCoords?(this._flatCoords=ct(this._flatCoords,e.flatCoords),this._flatCoordsOffset=ct(this._flatCoordsOffset,e.flatCoordsOffset)):(this._flatCoords=e.flatCoords,this._flatCoordsOffset=e.flatCoordsOffset),t.data=new Float32Array(e.count)),this.getRawData().appendData(t.data)},e.prototype._getCoordsFromItemModel=function(t){var e=this.getData().getItemModel(t),n=e.option instanceof Array?e.option:e.getShallow("coords");return n},e.prototype.getLineCoordsCount=function(t){return this._flatCoordsOffset?this._flatCoordsOffset[2*t+1]:this._getCoordsFromItemModel(t).length},e.prototype.getLineCoords=function(t,e){if(this._flatCoordsOffset){for(var n=this._flatCoordsOffset[2*t],i=this._flatCoordsOffset[2*t+1],r=0;r<i;r++)e[r]=e[r]||[],e[r][0]=this._flatCoords[n+2*r],e[r][1]=this._flatCoords[n+2*r+1];return i}var o=this._getCoordsFromItemModel(t);for(r=0;r<o.length;r++)e[r]=e[r]||[],e[r][0]=o[r][0],e[r][1]=o[r][1];return o.length},e.prototype._processFlatCoordsArray=function(t){var e=0;if(this._flatCoords&&(e=this._flatCoords.length),"number"==typeof t[0]){for(var n=t.length,i=new CL(n),r=new AL(n),o=0,a=0,s=0,l=0;l<n;){s++;var u=t[l++];i[a++]=o+e,i[a++]=u;for(var h=0;h<u;h++){var c=t[l++],p=t[l++];r[o++]=c,r[o++]=p}}return{flatCoordsOffset:new Uint32Array(i.buffer,0,a),flatCoords:r,count:s}}return{flatCoordsOffset:null,flatCoords:null,count:t.length}},e.prototype.getInitialData=function(t,e){var n=new Pm(["value"],this);return n.hasItemOption=!1,n.initData(t.data,[],(function(t,e,i,r){if(t instanceof Array)return NaN;n.hasItemOption=!0;var o=t.value;return null!=o?o instanceof Array?o[r]:o:void 0})),n},e.prototype.formatTooltip=function(t,e,n){var i=this.getData().getItemModel(t),r=i.get("name");if(r)return r;var o=i.get("fromName"),a=i.get("toName"),s=[];return null!=o&&s.push(o),null!=a&&s.push(a),Yd("nameValue",{name:s.join(" > ")})},e.prototype.preventIncremental=function(){return!!this.get(["effect","show"])},e.prototype.getProgressive=function(){var t=this.option.progressive;return null==t?this.option.large?1e4:this.get("progressive"):t},e.prototype.getProgressiveThreshold=function(){var t=this.option.progressiveThreshold;return null==t?this.option.large?2e4:this.get("progressiveThreshold"):t},e.type="series.lines",e.dependencies=["grid","polar","geo","calendar"],e.defaultOption={coordinateSystem:"geo",zlevel:0,z:2,legendHoverLink:!0,xAxisIndex:0,yAxisIndex:0,symbol:["none","none"],symbolSize:[10,10],geoIndex:0,effect:{show:!1,period:4,constantSpeed:0,symbol:"circle",symbolSize:3,loop:!0,trailLength:.2},large:!1,largeThreshold:2e3,polyline:!1,clip:!0,label:{show:!1,position:"end"},lineStyle:{opacity:.5}},e}(rf);function kL(t){return t instanceof Array||(t=[t,t]),t}var PL={seriesType:"lines",reset:function(t){var e=kL(t.get("symbol")),n=kL(t.get("symbolSize")),i=t.getData();return i.setVisual("fromSymbol",e&&e[0]),i.setVisual("toSymbol",e&&e[1]),i.setVisual("fromSymbolSize",n&&n[0]),i.setVisual("toSymbolSize",n&&n[1]),{dataEach:i.hasItemOption?function(t,e){var n=t.getItemModel(e),i=kL(n.getShallow("symbol",!0)),r=kL(n.getShallow("symbolSize",!0));i[0]&&t.setItemVisual(e,"fromSymbol",i[0]),i[1]&&t.setItemVisual(e,"toSymbol",i[1]),r[0]&&t.setItemVisual(e,"fromSymbolSize",r[0]),r[1]&&t.setItemVisual(e,"toSymbolSize",r[1])}:null}}};var OL=function(){function t(){this.blurSize=30,this.pointSize=20,this.maxOpacity=1,this.minOpacity=0,this._gradientPixels={inRange:null,outOfRange:null};var t=C();this.canvas=t}return t.prototype.update=function(t,e,n,i,r,o){var a=this._getBrush(),s=this._getGradient(r,"inRange"),l=this._getGradient(r,"outOfRange"),u=this.pointSize+this.blurSize,h=this.canvas,c=h.getContext("2d"),p=t.length;h.width=e,h.height=n;for(var d=0;d<p;++d){var f=t[d],g=f[0],y=f[1],v=i(f[2]);c.globalAlpha=v,c.drawImage(a,g-u,y-u)}if(!h.width||!h.height)return h;for(var m=c.getImageData(0,0,h.width,h.height),_=m.data,x=0,b=_.length,w=this.minOpacity,S=this.maxOpacity-w;x<b;){v=_[x+3]/256;var M=4*Math.floor(255*v);if(v>0){var I=o(v)?s:l;v>0&&(v=v*S+w),_[x++]=I[M],_[x++]=I[M+1],_[x++]=I[M+2],_[x++]=I[M+3]*v*256}else x+=4}return c.putImageData(m,0,0),h},t.prototype._getBrush=function(){var t=this._brushCanvas||(this._brushCanvas=C()),e=this.pointSize+this.blurSize,n=2*e;t.width=n,t.height=n;var i=t.getContext("2d");return i.clearRect(0,0,n,n),i.shadowOffsetX=n,i.shadowBlur=this.blurSize,i.shadowColor="#000",i.beginPath(),i.arc(-e,e,this.pointSize,0,2*Math.PI,!0),i.closePath(),i.fill(),t},t.prototype._getGradient=function(t,e){for(var n=this._gradientPixels,i=n[e]||(n[e]=new Uint8ClampedArray(1024)),r=[0,0,0,0],o=0,a=0;a<256;a++)t[e](a/255,!0,r),i[o++]=r[0],i[o++]=r[1],i[o++]=r[2],i[o++]=r[3];return i},t}();function RL(t){var e=t.dimensions;return"lng"===e[0]&&"lat"===e[1]}var NL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i;e.eachComponent("visualMap",(function(e){e.eachTargetSeries((function(n){n===t&&(i=e)}))})),this.group.removeAll(),this._incrementalDisplayable=null;var r=t.coordinateSystem;"cartesian2d"===r.type||"calendar"===r.type?this._renderOnCartesianAndCalendar(t,n,0,t.getData().count()):RL(r)&&this._renderOnGeo(r,t,i,n)},e.prototype.incrementalPrepareRender=function(t,e,n){this.group.removeAll()},e.prototype.incrementalRender=function(t,e,n,i){var r=e.coordinateSystem;r&&(RL(r)?this.render(e,n,i):this._renderOnCartesianAndCalendar(e,i,t.start,t.end,!0))},e.prototype._renderOnCartesianAndCalendar=function(t,e,n,i,r){var o,a,s,l,u=t.coordinateSystem;if(Wb(u,"cartesian2d")){var h=u.getAxis("x"),c=u.getAxis("y");0,o=h.getBandWidth(),a=c.getBandWidth(),s=h.scale.getExtent(),l=c.scale.getExtent()}for(var p=this.group,d=t.getData(),f=t.getModel(["emphasis","itemStyle"]).getItemStyle(),g=t.getModel(["blur","itemStyle"]).getItemStyle(),y=t.getModel(["select","itemStyle"]).getItemStyle(),v=eh(t),m=t.get(["emphasis","focus"]),_=t.get(["emphasis","blurScope"]),x=Wb(u,"cartesian2d")?[d.mapDimension("x"),d.mapDimension("y"),d.mapDimension("value")]:[d.mapDimension("time"),d.mapDimension("value")],b=n;b<i;b++){var w=void 0,S=d.getItemVisual(b,"style");if(Wb(u,"cartesian2d")){var M=d.get(x[0],b),I=d.get(x[1],b);if(isNaN(d.get(x[2],b))||M<s[0]||M>s[1]||I<l[0]||I>l[1])continue;var T=u.dataToPoint([M,I]);w=new os({shape:{x:Math.floor(Math.round(T[0])-o/2),y:Math.floor(Math.round(T[1])-a/2),width:Math.ceil(o),height:Math.ceil(a)},style:S})}else{if(isNaN(d.get(x[1],b)))continue;w=new os({z2:1,shape:u.dataToRect([d.get(x[0],b)]).contentShape,style:S})}var C=d.getItemModel(b);if(d.hasItemOption){var A=C.getModel("emphasis");f=A.getModel("itemStyle").getItemStyle(),g=C.getModel(["blur","itemStyle"]).getItemStyle(),y=C.getModel(["select","itemStyle"]).getItemStyle(),m=A.get("focus"),_=A.get("blurScope"),v=eh(C)}var D=t.getRawValue(b),L="-";D&&null!=D[2]&&(L=D[2]+""),th(w,v,{labelFetcher:t,labelDataIndex:b,defaultOpacity:S.opacity,defaultText:L}),w.ensureState("emphasis").style=f,w.ensureState("blur").style=g,w.ensureState("select").style=y,Js(w,m,_),w.incremental=r,r&&(w.states.emphasis.hoverLayer=!0),p.add(w),d.setItemGraphicEl(b,w)}},e.prototype._renderOnGeo=function(t,e,n,i){var r=n.targetVisuals.inRange,o=n.targetVisuals.outOfRange,a=e.getData(),s=this._hmLayer||this._hmLayer||new OL;s.blurSize=e.get("blurSize"),s.pointSize=e.get("pointSize"),s.minOpacity=e.get("minOpacity"),s.maxOpacity=e.get("maxOpacity");var l=t.getViewRect().clone(),u=t.getRoamTransform();l.applyTransform(u);var h=Math.max(l.x,0),c=Math.max(l.y,0),p=Math.min(l.width+l.x,i.getWidth()),d=Math.min(l.height+l.y,i.getHeight()),f=p-h,g=d-c,y=[a.mapDimension("lng"),a.mapDimension("lat"),a.mapDimension("value")],v=a.mapArray(y,(function(e,n,i){var r=t.dataToPoint([e,n]);return r[0]-=h,r[1]-=c,r.push(i),r})),m=n.getExtent(),_="visualMap.continuous"===n.type?function(t,e){var n=t[1]-t[0];return e=[(e[0]-t[0])/n,(e[1]-t[0])/n],function(t){return t>=e[0]&&t<=e[1]}}(m,n.option.range):function(t,e,n){var i=t[1]-t[0],r=(e=O(e,(function(e){return{interval:[(e.interval[0]-t[0])/i,(e.interval[1]-t[0])/i]}}))).length,o=0;return function(t){var i;for(i=o;i<r;i++)if((a=e[i].interval)[0]<=t&&t<=a[1]){o=i;break}if(i===r)for(i=o-1;i>=0;i--){var a;if((a=e[i].interval)[0]<=t&&t<=a[1]){o=i;break}}return i>=0&&i<r&&n[i]}}(m,n.getPieceList(),n.option.selected);s.update(v,f,g,r.color.getNormalizer(),{inRange:r.color.getColorMapper(),outOfRange:o.color.getColorMapper()},_);var x=new Ja({style:{width:f,height:g,x:h,y:c,image:s.canvas},silent:!0});this.group.add(x)},e.type="heatmap",e}(yf),EL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this,{generateCoord:"value"})},e.prototype.preventIncremental=function(){var t=_p.get(this.get("coordinateSystem"));if(t&&t.dimensions)return"lng"===t.dimensions[0]&&"lat"===t.dimensions[1]},e.type="series.heatmap",e.dependencies=["grid","geo","calendar"],e.defaultOption={coordinateSystem:"cartesian2d",zlevel:0,z:2,geoIndex:0,blurSize:30,pointSize:20,maxOpacity:1,minOpacity:0,select:{itemStyle:{borderColor:"#212121"}}},e}(rf);var zL=["itemStyle","borderWidth"],BL=[{xy:"x",wh:"width",index:0,posDesc:["left","right"]},{xy:"y",wh:"height",index:1,posDesc:["top","bottom"]}],VL=new Tl,FL=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=this.group,r=t.getData(),o=this._data,a=t.coordinateSystem,s=a.getBaseAxis().isHorizontal(),l=a.master.getRect(),u={ecSize:{width:n.getWidth(),height:n.getHeight()},seriesModel:t,coordSys:a,coordSysExtent:[[l.x,l.x+l.width],[l.y,l.y+l.height]],isHorizontal:s,valueDim:BL[+s],categoryDim:BL[1-+s]};return r.diff(o).add((function(t){if(r.hasValue(t)){var e=jL(r,t),n=GL(r,t,e,u),o=$L(r,u,n);r.setItemGraphicEl(t,o),i.add(o),nk(o,u,n)}})).update((function(t,e){var n=o.getItemGraphicEl(e);if(r.hasValue(t)){var a=jL(r,t),s=GL(r,t,a,u),l=QL(r,s);n&&l!==n.__pictorialShapeStr&&(i.remove(n),r.setItemGraphicEl(t,null),n=null),n?function(t,e,n){var i=n.animationModel,r=n.dataIndex;Ou(t.__pictorialBundle,{x:n.bundlePosition[0],y:n.bundlePosition[1]},i,r),n.symbolRepeat?YL(t,e,n,!0):XL(t,e,n,!0);UL(t,n,!0),ZL(t,e,n,!0)}(n,u,s):n=$L(r,u,s,!0),r.setItemGraphicEl(t,n),n.__pictorialSymbolMeta=s,i.add(n),nk(n,u,s)}else i.remove(n)})).remove((function(t){var e=o.getItemGraphicEl(t);e&&JL(o,t,e.__pictorialSymbolMeta.animationModel,e)})).execute(),this._data=r,this.group},e.prototype.remove=function(t,e){var n=this.group,i=this._data;t.get("animation")?i&&i.eachItemGraphicEl((function(e){JL(i,ys(e).dataIndex,t,e)})):n.removeAll()},e.type="pictorialBar",e}(yf);function GL(t,e,n,i){var r=t.getItemLayout(e),o=n.get("symbolRepeat"),a=n.get("symbolClip"),s=n.get("symbolPosition")||"start",l=(n.get("symbolRotate")||0)*Math.PI/180||0,u=n.get("symbolPatternSize")||2,h=n.isAnimationEnabled(),c={dataIndex:e,layout:r,itemModel:n,symbolType:t.getItemVisual(e,"symbol")||"circle",style:t.getItemVisual(e,"style"),symbolClip:a,symbolRepeat:o,symbolRepeatDirection:n.get("symbolRepeatDirection"),symbolPatternSize:u,rotation:l,animationModel:h?n:null,hoverScale:h&&n.get(["emphasis","scale"]),z2:n.getShallow("z",!0)||0};!function(t,e,n,i,r){var o,a=i.valueDim,s=t.get("symbolBoundingData"),l=i.coordSys.getOtherAxis(i.coordSys.getBaseAxis()),u=l.toGlobalCoord(l.dataToCoord(0)),h=1-+(n[a.wh]<=0);if(F(s)){var c=[HL(l,s[0])-u,HL(l,s[1])-u];c[1]<c[0]&&c.reverse(),o=c[h]}else o=null!=s?HL(l,s)-u:e?i.coordSysExtent[a.index][h]-u:n[a.wh];r.boundingLength=o,e&&(r.repeatCutLength=n[a.wh]);r.pxSign=o>0?1:o<0?-1:0}(n,o,r,i,c),function(t,e,n,i,r,o,a,s,l,u){var h,c=l.valueDim,p=l.categoryDim,d=Math.abs(n[p.wh]),f=t.getItemVisual(e,"symbolSize");h=F(f)?f.slice():null==f?["100%","100%"]:[f,f];h[p.index]=Zi(h[p.index],d),h[c.index]=Zi(h[c.index],i?d:Math.abs(o)),u.symbolSize=h,(u.symbolScale=[h[0]/s,h[1]/s])[c.index]*=(l.isHorizontal?-1:1)*a}(t,e,r,o,0,c.boundingLength,c.pxSign,u,i,c),function(t,e,n,i,r){var o=t.get(zL)||0;o&&(VL.attr({scaleX:e[0],scaleY:e[1],rotation:n}),VL.updateTransform(),o/=VL.getLineScale(),o*=e[i.valueDim.index]);r.valueLineWidth=o}(n,c.symbolScale,l,i,c);var p=c.symbolSize,d=n.get("symbolOffset");return F(d)&&(d=[Zi(d[0],p[0]),Zi(d[1],p[1])]),function(t,e,n,i,r,o,a,s,l,u,h,c){var p=h.categoryDim,d=h.valueDim,f=c.pxSign,g=Math.max(e[d.index]+s,0),y=g;if(i){var v=Math.abs(l),m=Q(t.get("symbolMargin"),"15%")+"",_=!1;m.lastIndexOf("!")===m.length-1&&(_=!0,m=m.slice(0,m.length-1));var x=Zi(m,e[d.index]),b=Math.max(g+2*x,0),w=_?0:2*x,S=cr(i),M=S?i:ik((v+w)/b);b=g+2*(x=(v-M*g)/2/(_?M:M-1)),w=_?0:2*x,S||"fixed"===i||(M=u?ik((Math.abs(u)+w)/b):0),y=M*b-w,c.repeatTimes=M,c.symbolMargin=x}var T=f*(y/2),C=c.pathPosition=[];C[p.index]=n[p.wh]/2,C[d.index]="start"===a?T:"end"===a?l-T:l/2,o&&(C[0]+=o[0],C[1]+=o[1]);var A=c.bundlePosition=[];A[p.index]=n[p.xy],A[d.index]=n[d.xy];var D=c.barRectShape=I({},n);D[d.wh]=f*Math.max(Math.abs(n[d.wh]),Math.abs(C[d.index]+T)),D[p.wh]=n[p.wh];var L=c.clipShape={};L[p.xy]=-n[p.xy],L[p.wh]=h.ecSize[p.wh],L[d.xy]=0,L[d.wh]=n[d.wh]}(n,p,r,o,0,d,s,c.valueLineWidth,c.boundingLength,c.repeatCutLength,i,c),c}function HL(t,e){return t.toGlobalCoord(t.dataToCoord(t.scale.parse(e)))}function WL(t){var e=t.symbolPatternSize,n=uy(t.symbolType,-e/2,-e/2,e,e);return n.attr({culling:!0}),"image"!==n.type&&n.setStyle({strokeNoScale:!0}),n}function YL(t,e,n,i){var r=t.__pictorialBundle,o=n.symbolSize,a=n.valueLineWidth,s=n.pathPosition,l=e.valueDim,u=n.repeatTimes||0,h=0,c=o[e.valueDim.index]+a+2*n.symbolMargin;for(tk(t,(function(t){t.__pictorialAnimationIndex=h,t.__pictorialRepeatTimes=u,h<u?ek(t,null,f(h),n,i):ek(t,null,{scaleX:0,scaleY:0},n,i,(function(){r.remove(t)})),h++}));h<u;h++){var p=WL(n);p.__pictorialAnimationIndex=h,p.__pictorialRepeatTimes=u,r.add(p);var d=f(h);ek(p,{x:d.x,y:d.y,scaleX:0,scaleY:0},{scaleX:d.scaleX,scaleY:d.scaleY,rotation:d.rotation},n,i)}function f(t){var e=s.slice(),i=n.pxSign,r=t;return("start"===n.symbolRepeatDirection?i>0:i<0)&&(r=u-1-t),e[l.index]=c*(r-u/2+.5)+s[l.index],{x:e[0],y:e[1],scaleX:n.symbolScale[0],scaleY:n.symbolScale[1],rotation:n.rotation}}}function XL(t,e,n,i){var r=t.__pictorialBundle,o=t.__pictorialMainPath;o?ek(o,null,{x:n.pathPosition[0],y:n.pathPosition[1],scaleX:n.symbolScale[0],scaleY:n.symbolScale[1],rotation:n.rotation},n,i):(o=t.__pictorialMainPath=WL(n),r.add(o),ek(o,{x:n.pathPosition[0],y:n.pathPosition[1],scaleX:0,scaleY:0,rotation:n.rotation},{scaleX:n.symbolScale[0],scaleY:n.symbolScale[1]},n,i))}function UL(t,e,n){var i=I({},e.barRectShape),r=t.__pictorialBarRect;r?ek(r,null,{shape:i},e,n):(r=t.__pictorialBarRect=new os({z2:2,shape:i,silent:!0,style:{stroke:"transparent",fill:"transparent",lineWidth:0}}),t.add(r))}function ZL(t,e,n,i){if(n.symbolClip){var r=t.__pictorialClipPath,o=I({},n.clipShape),a=e.valueDim,s=n.animationModel,l=n.dataIndex;if(r)Ou(r,{shape:o},s,l);else{o[a.wh]=0,r=new os({shape:o}),t.__pictorialBundle.setClipPath(r),t.__pictorialClipPath=r;var u={};u[a.wh]=n.clipShape[a.wh],Ku[i?"updateProps":"initProps"](r,{shape:u},s,l)}}}function jL(t,e){var n=t.getItemModel(e);return n.getAnimationDelayParams=qL,n.isAnimationEnabled=KL,n}function qL(t){return{index:t.__pictorialAnimationIndex,count:t.__pictorialRepeatTimes}}function KL(){return this.parentModel.isAnimationEnabled()&&!!this.getShallow("animation")}function $L(t,e,n,i){var r=new zi,o=new zi;return r.add(o),r.__pictorialBundle=o,o.x=n.bundlePosition[0],o.y=n.bundlePosition[1],n.symbolRepeat?YL(r,e,n):XL(r,0,n),UL(r,n,i),ZL(r,e,n,i),r.__pictorialShapeStr=QL(t,n),r.__pictorialSymbolMeta=n,r}function JL(t,e,n,i){var r=i.__pictorialBarRect;r&&r.removeTextContent();var o=[];tk(i,(function(t){o.push(t)})),i.__pictorialMainPath&&o.push(i.__pictorialMainPath),i.__pictorialClipPath&&(n=null),P(o,(function(t){Nu(t,{scaleX:0,scaleY:0},n,e,(function(){i.parent&&i.parent.remove(i)}))})),t.setItemGraphicEl(e,null)}function QL(t,e){return[t.getItemVisual(e.dataIndex,"symbol")||"none",!!e.symbolRepeat,!!e.symbolClip].join(":")}function tk(t,e,n){P(t.__pictorialBundle.children(),(function(i){i!==t.__pictorialBarRect&&e.call(n,i)}))}function ek(t,e,n,i,r,o){e&&t.attr(e),i.symbolClip&&!r?n&&t.attr(n):n&&Ku[r?"updateProps":"initProps"](t,n,i.animationModel,i.dataIndex,o)}function nk(t,e,n){var i=n.dataIndex,r=n.itemModel,o=r.getModel("emphasis"),a=o.getModel("itemStyle").getItemStyle(),s=r.getModel(["blur","itemStyle"]).getItemStyle(),l=r.getModel(["select","itemStyle"]).getItemStyle(),u=r.getShallow("cursor"),h=o.get("focus"),c=o.get("blurScope"),p=o.get("scale");tk(t,(function(t){if(t instanceof Ja){var e=t.style;t.useStyle(I({image:e.image,x:e.x,y:e.y,width:e.width,height:e.height},n.style))}else t.useStyle(n.style);var i=t.ensureState("emphasis");i.style=a,p&&(i.scaleX=1.1*t.scaleX,i.scaleY=1.1*t.scaleY),t.ensureState("blur").style=s,t.ensureState("select").style=l,u&&(t.cursor=u),t.z2=n.z2}));var d=e.valueDim.posDesc[+(n.boundingLength>0)];th(t.__pictorialBarRect,eh(r),{labelFetcher:e.seriesModel,labelDataIndex:i,defaultText:_b(e.seriesModel.getData(),i),inheritColor:n.style.fill,defaultOpacity:n.style.opacity,defaultOutsidePosition:d}),Js(t,h,c)}function ik(t){var e=Math.round(t);return Math.abs(t-e)<1e-4?e:Math.ceil(t)}var rk=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.hasSymbolVisual=!0,n.defaultSymbol="roundRect",n}return n(e,t),e.prototype.getInitialData=function(e){return e.stack=null,t.prototype.getInitialData.apply(this,arguments)},e.type="series.pictorialBar",e.dependencies=["grid"],e.defaultOption=Th(iw.defaultOption,{symbol:"circle",symbolSize:null,symbolRotate:null,symbolPosition:null,symbolOffset:null,symbolMargin:null,symbolRepeat:!1,symbolRepeatDirection:"end",symbolClip:!1,symbolBoundingData:null,symbolPatternSize:400,barGap:"-100%",progressive:0,emphasis:{scale:!1},select:{itemStyle:{borderColor:"#212121"}}}),e}(iw);var ok=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._layers=[],n}return n(e,t),e.prototype.render=function(t,e,n){var i=t.getData(),r=this,o=this.group,a=t.getLayerSeries(),s=i.getLayout("layoutInfo"),l=s.rect,u=s.boundaryGap;function h(t){return t.name}o.x=0,o.y=l.y+u[0];var c=new rm(this._layersSeries||[],a,h,h),p=[];function d(e,n,s){var l=r._layers;if("remove"!==e){for(var u,h,c=[],d=[],f=a[n].indices,g=0;g<f.length;g++){var y=i.getItemLayout(f[g]),v=y.x,m=y.y0,_=y.y;c.push(v,m),d.push(v,m+_),u=i.getItemVisual(f[g],"style")}var x=i.getItemLayout(f[0]),b=t.getModel("label").get("margin"),w=t.getModel("emphasis");if("add"===e){var S=p[n]=new zi;h=new Vb({shape:{points:c,stackedOnPoints:d,smooth:.4,stackedOnSmooth:.4,smoothConstraint:!1},z2:0}),S.add(h),o.add(S),t.isAnimationEnabled()&&h.setClipPath(function(t,e,n){var i=new os({shape:{x:t.x-10,y:t.y-10,width:0,height:t.height+20}});return Ru(i,{shape:{x:t.x-50,width:t.width+100,height:t.height+20}},e,n),i}(h.getBoundingRect(),t,(function(){h.removeClipPath()})))}else{S=l[s];h=S.childAt(0),o.add(S),p[n]=S,Ou(h,{shape:{points:c,stackedOnPoints:d}},t)}th(h,eh(t),{labelDataIndex:f[g-1],defaultText:i.getName(f[g-1]),inheritColor:u.fill},{normal:{verticalAlign:"middle"}}),h.setTextConfig({position:null,local:!0});var M=h.getTextContent();M&&(M.x=x.x-b,M.y=x.y0+x.y/2),h.useStyle(u),i.setItemGraphicEl(n,h),nl(h,t),Js(h,w.get("focus"),w.get("blurScope"))}else o.remove(l[n])}c.add(B(d,this,"add")).update(B(d,this,"update")).remove(B(d,this,"remove")).execute(),this._layersSeries=a,this._layers=p},e.type="themeRiver",e}(yf);var ak=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.useColorPaletteOnData=!0,n}return n(e,t),e.prototype.init=function(e){t.prototype.init.apply(this,arguments),this.legendVisualProvider=new Nw(B(this.getData,this),B(this.getRawData,this))},e.prototype.fixData=function(t){var e=t.length,n={},i=zr(t,(function(t){return n.hasOwnProperty(t[0]+"")||(n[t[0]+""]=-1),t[2]})),r=[];i.buckets.each((function(t,e){r.push({name:e,dataList:t})}));for(var o=r.length,a=0;a<o;++a){for(var s=r[a].name,l=0;l<r[a].dataList.length;++l){var u=r[a].dataList[l][0]+"";n[u]=a}for(var u in n)n.hasOwnProperty(u)&&n[u]!==a&&(n[u]=a,t[e]=[u,0,s],e++)}return t},e.prototype.getInitialData=function(t,e){for(var n=this.getReferringComponents("singleAxis",Or).models[0].get("type"),i=N(t.data,(function(t){return void 0!==t[2]})),r=this.fixData(i||[]),o=[],a=this.nameMap=ht(),s=0,l=0;l<r.length;++l)o.push(r[l][2]),a.get(r[l][2])||(a.set(r[l][2],s),s++);var u=Nm(r,{coordDimensions:["single"],dimensionsDefine:[{name:"time",type:am(n)},{name:"value",type:"float"},{name:"name",type:"ordinal"}],encodeDefine:{single:0,value:1,itemName:2}}),h=new Pm(u,this);return h.initData(r),h},e.prototype.getLayerSeries=function(){for(var t=this.getData(),e=t.count(),n=[],i=0;i<e;++i)n[i]=i;var r=t.mapDimension("single"),o=zr(n,(function(e){return t.get("name",e)})),a=[];return o.buckets.each((function(e,n){e.sort((function(e,n){return t.get(r,e)-t.get(r,n)})),a.push({name:n,indices:e})})),a},e.prototype.getAxisTooltipData=function(t,e,n){F(t)||(t=t?[t]:[]);for(var i,r=this.getData(),o=this.getLayerSeries(),a=[],s=o.length,l=0;l<s;++l){for(var u=Number.MAX_VALUE,h=-1,c=o[l].indices.length,p=0;p<c;++p){var d=r.get(t[0],o[l].indices[p]),f=Math.abs(d-e);f<=u&&(i=d,u=f,h=o[l].indices[p])}a.push(h)}return{dataIndices:a,nestestValue:i}},e.prototype.formatTooltip=function(t,e,n){var i=this.getData();return Yd("nameValue",{name:i.getName(t),value:i.get(i.mapDimension("value"),t)})},e.type="series.themeRiver",e.dependencies=["singleAxis"],e.defaultOption={zlevel:0,z:2,coordinateSystem:"singleAxis",boundaryGap:["10%","10%"],singleAxisIndex:0,animationEasing:"linear",label:{margin:4,show:!0,position:"left",fontSize:11},emphasis:{label:{show:!0}}},e}(rf);function sk(t,e){t.eachSeriesByType("themeRiver",(function(t){var e=t.getData(),n=t.coordinateSystem,i={},r=n.getRect();i.rect=r;var o=t.get("boundaryGap"),a=n.getAxis();(i.boundaryGap=o,"horizontal"===a.orient)?(o[0]=Zi(o[0],r.height),o[1]=Zi(o[1],r.height),lk(e,t,r.height-o[0]-o[1])):(o[0]=Zi(o[0],r.width),o[1]=Zi(o[1],r.width),lk(e,t,r.width-o[0]-o[1]));e.setLayout("layoutInfo",i)}))}function lk(t,e,n){if(t.count())for(var i,r=e.coordinateSystem,o=e.getLayerSeries(),a=t.mapDimension("single"),s=t.mapDimension("value"),l=O(o,(function(e){return O(e.indices,(function(e){var n=r.dataToPoint(t.get(a,e));return n[1]=t.get(s,e),n}))})),u=function(t){for(var e=t.length,n=t[0].length,i=[],r=[],o=0,a=0;a<n;++a){for(var s=0,l=0;l<e;++l)s+=t[l][a][1];s>o&&(o=s),i.push(s)}for(var u=0;u<n;++u)r[u]=(o-i[u])/2;o=0;for(var h=0;h<n;++h){var c=i[h]+r[h];c>o&&(o=c)}return{y0:r,max:o}}(l),h=u.y0,c=n/u.max,p=o.length,d=o[0].indices.length,f=0;f<d;++f){i=h[f]*c,t.setItemLayout(o[0].indices[f],{layerIndex:0,x:l[0][f][0],y0:i,y:l[0][f][1]*c});for(var g=1;g<p;++g)i+=l[g-1][f][1]*c,t.setItemLayout(o[g].indices[f],{layerIndex:g,x:l[g][f][0],y0:i,y:l[g][f][1]*c})}}var uk=function(t){function e(e,n,i,r){var o=t.call(this)||this;o.z2=2,o.textConfig={inside:!0},ys(o).seriesIndex=n.seriesIndex;var a=new ls({z2:4,silent:e.getModel().get(["label","silent"])});return o.setTextContent(a),o.updateData(!0,e,n,i,r),o}return n(e,t),e.prototype.updateData=function(t,e,n,i,r){this.node=e,e.piece=this,n=n||this._seriesModel,i=i||this._ecModel;var o=this;ys(o).dataIndex=e.dataIndex;var a=e.getModel(),s=a.getModel("emphasis"),l=e.getLayout(),u=I({},l);u.label=null;var h=e.getVisual("style");h.lineJoin="bevel";var c=e.getVisual("decal");c&&(h.decal=ky(c,r));var p=kw(a.getModel("itemStyle"),u);I(u,p),P(xs,(function(t){var e=o.ensureState(t),n=a.getModel([t,"itemStyle"]);e.style=n.getItemStyle();var i=kw(n,u);i&&(e.shape=i)})),t?(o.setShape(u),o.shape.r=l.r0,Ou(o,{shape:{r:l.r}},n,e.dataIndex)):Ou(o,{shape:u},n),o.useStyle(h),this._updateLabel(n);var d=a.getShallow("cursor");d&&o.attr("cursor",d),this._seriesModel=n||this._seriesModel,this._ecModel=i||this._ecModel;var f=s.get("focus");Js(this,("ancestor"===f?e.getAncestorsIndices():"descendant"===f?e.getDescendantIndices():null)||f,s.get("blurScope"))},e.prototype._updateLabel=function(t){var e=this,n=this.node.getModel(),i=n.getModel("label"),r=this.node.getLayout(),o=r.endAngle-r.startAngle,a=(r.startAngle+r.endAngle)/2,s=Math.cos(a),l=Math.sin(a),u=this,h=u.getTextContent(),c=this.node.dataIndex,p=i.get("minAngle")/180*Math.PI,d=i.get("show")&&!(null!=p&&Math.abs(o)<p);function f(t,e){var n=t.get(e);return null==n?i.get(e):n}h.ignore=!d,P(bs,(function(i){var o="normal"===i?n.getModel("label"):n.getModel([i,"label"]),p="normal"===i,d=p?h:h.ensureState(i),g=t.getFormattedLabel(c,i);p&&(g=g||e.node.name),d.style=nh(o,{},null,"normal"!==i,!0),g&&(d.style.text=g);var y=o.get("show");null==y||p||(d.ignore=!y);var v,m=f(o,"position"),_=p?u:u.states[i],x=_.style.fill;_.textConfig={outsideFill:"inherit"===o.get("color")?x:null,inside:"outside"!==m};var b=f(o,"distance")||0,w=f(o,"align");"outside"===m?(v=r.r+b,w=a>Math.PI/2?"right":"left"):w&&"center"!==w?"left"===w?(v=r.r0+b,a>Math.PI/2&&(w="right")):"right"===w&&(v=r.r-b,a>Math.PI/2&&(w="left")):(v=(r.r+r.r0)/2,w="center"),d.style.align=w,d.style.verticalAlign=f(o,"verticalAlign")||"middle",d.x=v*s+r.cx,d.y=v*l+r.cy;var S=f(o,"rotate"),M=0;"radial"===S?(M=-a)<-Math.PI/2&&(M+=Math.PI):"tangential"===S?(M=Math.PI/2-a)>Math.PI/2?M-=Math.PI:M<-Math.PI/2&&(M+=Math.PI):"number"==typeof S&&(M=S*Math.PI/180),d.rotation=M})),h.dirtyStyle()},e}(Wl),hk="sunburstRootToNode",ck="sunburstHighlight";var pk=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n,i){var r=this;this.seriesModel=t,this.api=n,this.ecModel=e;var o=t.getData(),a=o.tree.root,s=t.getViewRoot(),l=this.group,u=t.get("renderLabelForZeroData"),h=[];s.eachNode((function(t){h.push(t)}));var c=this._oldChildren||[];!function(i,r){if(0===i.length&&0===r.length)return;function s(t){return t.getId()}function h(s,h){!function(i,r){u||!i||i.getValue()||(i=null);if(i!==a&&r!==a)if(r&&r.piece)i?(r.piece.updateData(!1,i,t,e,n),o.setItemGraphicEl(i.dataIndex,r.piece)):function(t){if(!t)return;t.piece&&(l.remove(t.piece),t.piece=null)}(r);else if(i){var s=new uk(i,t,e,n);l.add(s),o.setItemGraphicEl(i.dataIndex,s)}}(null==s?null:i[s],null==h?null:r[h])}new rm(r,i,s,s).add(h).update(h).remove(V(h,null)).execute()}(h,c),function(i,o){o.depth>0?(r.virtualPiece?r.virtualPiece.updateData(!1,i,t,e,n):(r.virtualPiece=new uk(i,t,e,n),l.add(r.virtualPiece)),o.piece.off("click"),r.virtualPiece.on("click",(function(t){r._rootToNode(o.parentNode)}))):r.virtualPiece&&(l.remove(r.virtualPiece),r.virtualPiece=null)}(a,s),this._initEvents(),this._oldChildren=h},e.prototype._initEvents=function(){var t=this;this.group.off("click"),this.group.on("click",(function(e){var n=!1;t.seriesModel.getViewRoot().eachNode((function(i){if(!n&&i.piece&&i.piece===e.target){var r=i.getModel().get("nodeClick");if("rootToNode"===r)t._rootToNode(i);else if("link"===r){var o=i.getModel(),a=o.get("link");if(a)wc(a,o.get("target",!0)||"_blank")}n=!0}}))}))},e.prototype._rootToNode=function(t){t!==this.seriesModel.getViewRoot()&&this.api.dispatchAction({type:hk,from:this.uid,seriesId:this.seriesModel.id,targetNode:t})},e.prototype.containPoint=function(t,e){var n=e.getData().getItemLayout(0);if(n){var i=t[0]-n.cx,r=t[1]-n.cy,o=Math.sqrt(i*i+r*r);return o<=n.r&&o>=n.r0}},e.type="sunburst",e}(yf),dk=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.ignoreStyleOnData=!0,n}return n(e,t),e.prototype.getInitialData=function(t,e){var n={name:t.name,children:t.data};fk(n);var i=O(t.levels||[],(function(t){return new Sh(t,this,e)}),this),r=TI.createTree(n,this,(function(t){t.wrapMethod("getItemModel",(function(t,e){var n=r.getNodeByDataIndex(e),o=i[n.depth];return o&&(t.parentModel=o),t}))}));return r.data},e.prototype.optionUpdated=function(){this.resetViewRoot()},e.prototype.getDataParams=function(e){var n=t.prototype.getDataParams.apply(this,arguments),i=this.getData().tree.getNodeByDataIndex(e);return n.treePathInfo=RI(i,this),n},e.prototype.getViewRoot=function(){return this._viewRoot},e.prototype.resetViewRoot=function(t){t?this._viewRoot=t:t=this._viewRoot;var e=this.getRawData().tree.root;t&&(t===e||e.contains(t))||(this._viewRoot=e)},e.prototype.enableAriaDecal=function(){zI(this)},e.type="series.sunburst",e.defaultOption={zlevel:0,z:2,center:["50%","50%"],radius:[0,"75%"],clockwise:!0,startAngle:90,minAngle:0,stillShowZeroSum:!0,nodeClick:"rootToNode",renderLabelForZeroData:!1,label:{rotate:"radial",show:!0,opacity:1,align:"center",position:"inside",distance:5,silent:!0},itemStyle:{borderWidth:1,borderColor:"white",borderType:"solid",shadowBlur:0,shadowColor:"rgba(0, 0, 0, 0.2)",shadowOffsetX:0,shadowOffsetY:0,opacity:1},emphasis:{focus:"descendant"},blur:{itemStyle:{opacity:.2},label:{opacity:.1}},animationType:"expansion",animationDuration:1e3,animationDurationUpdate:500,data:[],levels:[],sort:"desc"},e}(rf);function fk(t){var e=0;P(t.children,(function(t){fk(t);var n=t.value;F(n)&&(n=n[0]),e+=n}));var n=t.value;F(n)&&(n=n[0]),(null==n||isNaN(n))&&(n=e),n<0&&(n=0),F(t.value)?t.value[0]=n:t.value=n}var gk=Math.PI/180;function yk(t,e,n){e.eachSeriesByType(t,(function(t){var e=t.get("center"),i=t.get("radius");F(i)||(i=[0,i]),F(e)||(e=[e,e]);var r=n.getWidth(),o=n.getHeight(),a=Math.min(r,o),s=Zi(e[0],r),l=Zi(e[1],o),u=Zi(i[0],a/2),h=Zi(i[1],a/2),c=-t.get("startAngle")*gk,p=t.get("minAngle")*gk,d=t.getData().tree.root,f=t.getViewRoot(),g=f.depth,y=t.get("sort");null!=y&&vk(f,y);var v=0;P(f.children,(function(t){!isNaN(t.getValue())&&v++}));var m=f.getValue(),_=Math.PI/(m||v)*2,x=f.depth>0,b=f.height-(x?-1:1),w=(h-u)/(b||1),S=t.get("clockwise"),M=t.get("stillShowZeroSum"),I=S?1:-1,T=function(t,e){if(t){var n=e;if(t!==d){var i=t.getValue(),r=0===m&&M?_:i*_;r<p&&(r=p),n=e+I*r;var o=t.depth-g-(x?-1:1),h=u+w*o,c=u+w*(o+1),f=t.getModel();null!=f.get("r0")&&(h=Zi(f.get("r0"),a/2)),null!=f.get("r")&&(c=Zi(f.get("r"),a/2)),t.setLayout({angle:r,startAngle:e,endAngle:n,clockwise:S,cx:s,cy:l,r0:h,r:c})}if(t.children&&t.children.length){var y=0;P(t.children,(function(t){y+=T(t,e+y)}))}return n-e}};if(x){var C=u,A=u+w,D=2*Math.PI;d.setLayout({angle:D,startAngle:c,endAngle:c+D,clockwise:S,cx:s,cy:l,r0:C,r:A})}T(f,c)}))}function vk(t,e){var n=t.children||[];t.children=function(t,e){if("function"==typeof e){var n=O(t,(function(t,e){var n=t.getValue();return{params:{depth:t.depth,height:t.height,dataIndex:t.dataIndex,getValue:function(){return n}},index:e}}));return n.sort((function(t,n){return e(t.params,n.params)})),O(n,(function(e){return t[e.index]}))}var i="asc"===e;return t.sort((function(t,e){var n=(t.getValue()-e.getValue())*(i?1:-1);return 0===n?(t.dataIndex-e.dataIndex)*(i?-1:1):n}))}(n,e),n.length&&P(t.children,(function(t){vk(t,e)}))}function mk(t){var e={};t.eachSeriesByType("sunburst",(function(t){var n=t.getData(),i=n.tree;i.eachNode((function(r){var o=r.getModel().getModel("itemStyle").getItemStyle();o.fill||(o.fill=function(t,n,i){for(var r=t;r&&r.depth>1;)r=r.parentNode;var o=n.getColorFromPalette(r.name||r.dataIndex+"",e);return t.depth>1&&"string"==typeof o&&(o=$e(o,(t.depth-1)/(i-1)*.5)),o}(r,t,i.root.height)),I(n.ensureUniqueItemVisual(r.dataIndex,"style"),o)}))}))}function _k(t,e){return e=e||[0,0],O(["x","y"],(function(n,i){var r=this.getAxis(n),o=e[i],a=t[i]/2;return"category"===r.type?r.getBandWidth():Math.abs(r.dataToCoord(o-a)-r.dataToCoord(o+a))}),this)}function xk(t,e){return e=e||[0,0],O([0,1],(function(n){var i=e[n],r=t[n]/2,o=[],a=[];return o[n]=i-r,a[n]=i+r,o[1-n]=a[1-n]=e[1-n],Math.abs(this.dataToPoint(o)[n]-this.dataToPoint(a)[n])}),this)}function bk(t,e){var n=this.getAxis(),i=e instanceof Array?e[0]:e,r=(t instanceof Array?t[0]:t)/2;return"category"===n.type?n.getBandWidth():Math.abs(n.dataToCoord(i-r)-n.dataToCoord(i+r))}function wk(t,e){return e=e||[0,0],O(["Radius","Angle"],(function(n,i){var r=this["get"+n+"Axis"](),o=e[i],a=t[i]/2,s="category"===r.type?r.getBandWidth():Math.abs(r.dataToCoord(o-a)-r.dataToCoord(o+a));return"Angle"===n&&(s=s*Math.PI/180),s}),this)}function Sk(t,e,n,i){return t&&(t.legacy||!1!==t.legacy&&!n&&!i&&"tspan"!==e&&("text"===e||dt(t,"text")))}function Mk(t,e,n){var i,r,o,a=t;if("text"===e)o=a;else{o={},dt(a,"text")&&(o.text=a.text),dt(a,"rich")&&(o.rich=a.rich),dt(a,"textFill")&&(o.fill=a.textFill),dt(a,"textStroke")&&(o.stroke=a.textStroke),r={type:"text",style:o,silent:!0},i={};var s=dt(a,"textPosition");n?i.position=s?a.textPosition:"inside":s&&(i.position=a.textPosition),dt(a,"textPosition")&&(i.position=a.textPosition),dt(a,"textOffset")&&(i.offset=a.textOffset),dt(a,"textRotation")&&(i.rotation=a.textRotation),dt(a,"textDistance")&&(i.distance=a.textDistance)}return Ik(o,t),P(o.rich,(function(t){Ik(t,t)})),{textConfig:i,textContent:r}}function Ik(t,e){e&&(e.font=e.textFont||e.font,dt(e,"textStrokeWidth")&&(t.lineWidth=e.textStrokeWidth),dt(e,"textAlign")&&(t.align=e.textAlign),dt(e,"textVerticalAlign")&&(t.verticalAlign=e.textVerticalAlign),dt(e,"textLineHeight")&&(t.lineHeight=e.textLineHeight),dt(e,"textWidth")&&(t.width=e.textWidth),dt(e,"textHeight")&&(t.height=e.textHeight),dt(e,"textBackgroundColor")&&(t.backgroundColor=e.textBackgroundColor),dt(e,"textPadding")&&(t.padding=e.textPadding),dt(e,"textBorderColor")&&(t.borderColor=e.textBorderColor),dt(e,"textBorderWidth")&&(t.borderWidth=e.textBorderWidth),dt(e,"textBorderRadius")&&(t.borderRadius=e.textBorderRadius),dt(e,"textBoxShadowColor")&&(t.shadowColor=e.textBoxShadowColor),dt(e,"textBoxShadowBlur")&&(t.shadowBlur=e.textBoxShadowBlur),dt(e,"textBoxShadowOffsetX")&&(t.shadowOffsetX=e.textBoxShadowOffsetX),dt(e,"textBoxShadowOffsetY")&&(t.shadowOffsetY=e.textBoxShadowOffsetY))}function Tk(t,e,n){var i=t;i.textPosition=i.textPosition||n.position||"inside",null!=n.offset&&(i.textOffset=n.offset),null!=n.rotation&&(i.textRotation=n.rotation),null!=n.distance&&(i.textDistance=n.distance);var r=i.textPosition.indexOf("inside")>=0,o=t.fill||"#000";Ck(i,e);var a=null==i.textFill;return r?a&&(i.textFill=n.insideFill||"#fff",!i.textStroke&&n.insideStroke&&(i.textStroke=n.insideStroke),!i.textStroke&&(i.textStroke=o),null==i.textStrokeWidth&&(i.textStrokeWidth=2)):(a&&(i.textFill=n.outsideFill||o),!i.textStroke&&n.outsideStroke&&(i.textStroke=n.outsideStroke)),i.text=e.text,i.rich=e.rich,P(e.rich,(function(t){Ck(t,t)})),i}function Ck(t,e){e&&(dt(e,"fill")&&(t.textFill=e.fill),dt(e,"stroke")&&(t.textStroke=e.fill),dt(e,"lineWidth")&&(t.textStrokeWidth=e.lineWidth),dt(e,"font")&&(t.font=e.font),dt(e,"fontStyle")&&(t.fontStyle=e.fontStyle),dt(e,"fontWeight")&&(t.fontWeight=e.fontWeight),dt(e,"fontSize")&&(t.fontSize=e.fontSize),dt(e,"fontFamily")&&(t.fontFamily=e.fontFamily),dt(e,"align")&&(t.textAlign=e.align),dt(e,"verticalAlign")&&(t.textVerticalAlign=e.verticalAlign),dt(e,"lineHeight")&&(t.textLineHeight=e.lineHeight),dt(e,"width")&&(t.textWidth=e.width),dt(e,"height")&&(t.textHeight=e.height),dt(e,"backgroundColor")&&(t.textBackgroundColor=e.backgroundColor),dt(e,"padding")&&(t.textPadding=e.padding),dt(e,"borderColor")&&(t.textBorderColor=e.borderColor),dt(e,"borderWidth")&&(t.textBorderWidth=e.borderWidth),dt(e,"borderRadius")&&(t.textBorderRadius=e.borderRadius),dt(e,"shadowColor")&&(t.textBoxShadowColor=e.shadowColor),dt(e,"shadowBlur")&&(t.textBoxShadowBlur=e.shadowBlur),dt(e,"shadowOffsetX")&&(t.textBoxShadowOffsetX=e.shadowOffsetX),dt(e,"shadowOffsetY")&&(t.textBoxShadowOffsetY=e.shadowOffsetY),dt(e,"textShadowColor")&&(t.textShadowColor=e.textShadowColor),dt(e,"textShadowBlur")&&(t.textShadowBlur=e.textShadowBlur),dt(e,"textShadowOffsetX")&&(t.textShadowOffsetX=e.textShadowOffsetX),dt(e,"textShadowOffsetY")&&(t.textShadowOffsetY=e.textShadowOffsetY))}var Ak=Ca.CMD,Dk=2*Math.PI,Lk=["x","y"],kk=["width","height"],Pk=[];function Ok(t,e){return Math.abs(t-e)<1e-5}function Rk(t){var e,n,i,r,o,a=t.data,s=t.len(),l=[],u=0,h=0,c=0,p=0;function d(t,n){e&&e.length>2&&l.push(e),e=[t,n]}function f(t,n,i,r){Ok(t,i)&&Ok(n,r)||e.push(t,n,i,r,i,r)}function g(t,n,i,r,o,a){var s=Math.abs(n-t),l=4*Math.tan(s/4)/3,u=n<t?-1:1,h=Math.cos(t),c=Math.sin(t),p=Math.cos(n),d=Math.sin(n),f=h*o+i,g=c*a+r,y=p*o+i,v=d*a+r,m=o*l*u,_=a*l*u;e.push(f-m*c,g+_*h,y+m*d,v-_*p,y,v)}for(var y=0;y<s;){var v=a[y++],m=1===y;switch(m&&(c=u=a[y],p=h=a[y+1],v!==Ak.L&&v!==Ak.C&&v!==Ak.Q||(e=[c,p])),v){case Ak.M:u=c=a[y++],h=p=a[y++],d(c,p);break;case Ak.L:f(u,h,n=a[y++],i=a[y++]),u=n,h=i;break;case Ak.C:e.push(a[y++],a[y++],a[y++],a[y++],u=a[y++],h=a[y++]);break;case Ak.Q:n=a[y++],i=a[y++],r=a[y++],o=a[y++],e.push(u+2/3*(n-u),h+2/3*(i-h),r+2/3*(n-r),o+2/3*(i-o),r,o),u=r,h=o;break;case Ak.A:var _=a[y++],x=a[y++],b=a[y++],w=a[y++],S=a[y++],M=a[y++]+S;y+=1;var I=!a[y++];n=Math.cos(S)*b+_,i=Math.sin(S)*w+x,m?d(c=n,p=i):f(u,h,n,i),u=Math.cos(M)*b+_,h=Math.sin(M)*w+x;for(var T=(I?-1:1)*Math.PI/2,C=S;I?C>M:C<M;C+=T){g(C,I?Math.max(C+T,M):Math.min(C+T,M),_,x,b,w)}break;case Ak.R:c=u=a[y++],p=h=a[y++],n=c+a[y++],i=p+a[y++],d(n,p),f(n,p,n,i),f(n,i,c,i),f(c,i,c,p),f(c,p,n,p);break;case Ak.Z:e&&f(u,h,c,p),u=c,h=p}}return e&&e.length>2&&l.push(e),l}function Nk(t,e){var n=t.length,i=e.length;if(n===i)return[t,e];for(var r=n<i?t:e,o=Math.min(n,i),a=Math.abs(i-n)/6,s=(o-2)/6,l=Math.ceil(a/s)+1,u=[r[0],r[1]],h=a,c=[],p=[],d=2;d<o;){var f=r[d-2],g=r[d-1],y=r[d++],v=r[d++],m=r[d++],_=r[d++],x=r[d++],b=r[d++];if(h<=0)u.push(y,v,m,_,x,b);else{for(var w=Math.min(h,l-1)+1,S=1;S<=w;S++){var M=S/w;Bo(f,y,m,x,M,c),Bo(g,v,_,b,M,p),f=c[3],g=p[3],u.push(c[1],p[1],c[2],p[2],f,g),y=c[5],v=p[5],m=c[6],_=p[6]}h-=w-1}}return r===t?[u,e]:[t,u]}function Ek(t,e){for(var n=t.length,i=t[n-2],r=t[n-1],o=[],a=0;a<e.length;)o[a++]=i,o[a++]=r;return o}function zk(t){for(var e=0,n=0,i=0,r=t.length,o=0,a=r-2;o<r;a=o,o+=2){var s=t[a],l=t[a+1],u=t[o],h=t[o+1],c=s*h-u*l;e+=c,n+=(s+u)*c,i+=(l+h)*c}return 0===e?[t[0]||0,t[1]||0]:[n/e/3,i/e/3,e]}function Bk(t,e,n,i){for(var r=(t.length-2)/6,o=1/0,a=0,s=t.length,l=s-2,u=0;u<r;u++){for(var h=6*u,c=0,p=0;p<s;p+=2){var d=0===p?h:(h+p-2)%l+2,f=t[d]-n[0],g=t[d+1]-n[1],y=e[p]-i[0]-f,v=e[p+1]-i[1]-g;c+=y*y+v*v}c<o&&(o=c,a=u)}return a}function Vk(t){for(var e=[],n=t.length,i=0;i<n;i+=2)e[i]=t[n-i-2],e[i+1]=t[n-i-1];return e}function Fk(t,e,n){var i,r;if(!t||!e)return e;!t.path&&t.createPathProxy(),(i=t.path).beginPath(),t.buildPath(i,t.shape),!e.path&&e.createPathProxy(),(r=e.path)===i&&(r=new Ca(!1)),r.beginPath(),Wk(e)?e.__oldBuildPath(r,e.shape):e.buildPath(r,e.shape);var o=function(t,e){for(var n,i,r,o=[],a=[],s=0;s<Math.max(t.length,e.length);s++){var l=t[s],u=e[s],h=void 0,c=void 0;l?u?(i=h=(n=Nk(l,u))[0],r=c=n[1]):(c=Ek(r||l,l),h=l):(h=Ek(i||u,u),c=u),o.push(h),a.push(c)}return[o,a]}(Rk(i),Rk(r)),a=function(t,e,n,i){for(var r,o=[],a=0;a<t.length;a++){var s=t[a],l=e[a],u=zk(s),h=zk(l);null==r&&(r=u[2]<0!=h[2]<0);var c=[],p=[],d=0,f=1/0,g=[],y=s.length;r&&(s=Vk(s));for(var v=6*Bk(s,l,u,h),m=y-2,_=0;_<m;_+=2){var x=(v+_)%m+2;c[_+2]=s[x]-u[0],c[_+3]=s[x+1]-u[1]}if(c[0]=s[v]-u[0],c[1]=s[v+1]-u[1],n>0)for(var b=i/n,w=-i/2;w<=i/2;w+=b){var S=Math.sin(w),M=Math.cos(w),I=0;for(_=0;_<s.length;_+=2){var T=c[_],C=c[_+1],A=l[_]-h[0],D=l[_+1]-h[1],L=A*M-D*S,k=A*S+D*M;g[_]=L,g[_+1]=k;var P=L-T,O=k-C;I+=P*P+O*O}if(I<f){f=I,d=w;for(var R=0;R<g.length;R++)p[R]=g[R]}}else for(var N=0;N<y;N+=2)p[N]=l[N]-h[0],p[N+1]=l[N+1]-h[1];o.push({from:c,to:p,fromCp:u,toCp:h,rotation:-d})}return o}(o[0],o[1],10,Math.PI);!function(t,e,n){if(Wk(t))return void Hk(t,e,n);var i=t;i.__oldBuildPath=i.buildPath,i.buildPath=Gk,Hk(i,e,n)}(e,a,0);var s=n&&n.done,l=n&&n.aborted,u=n&&n.during;return e.animateTo({__morphT:1},T({during:function(t){e.dirtyShape(),u&&u(t)},done:function(){var t;Wk(t=e)&&(t.buildPath=t.__oldBuildPath,t.__oldBuildPath=t.__morphingData=null),e.createPathProxy(),e.dirtyShape(),s&&s()},aborted:function(){l&&l()}},n)),e}function Gk(t){for(var e=this.__morphingData,n=this.__morphT,i=1-n,r=[],o=0;o<e.length;o++){var a=e[o],s=a.from,l=a.to,u=a.rotation*n,h=a.fromCp,c=a.toCp,p=Math.sin(u),d=Math.cos(u);Ot(r,h,c,n);for(var f=0;f<s.length;f+=2){var g=s[f],y=s[f+1],v=g*i+l[f]*n,m=y*i+l[f+1]*n;Pk[f]=v*d-m*p+r[0],Pk[f+1]=v*p+m*d+r[1]}for(f=0;f<s.length;)0===f&&t.moveTo(Pk[f++],Pk[f++]),t.bezierCurveTo(Pk[f++],Pk[f++],Pk[f++],Pk[f++],Pk[f++],Pk[f++])}}function Hk(t,e,n){t.__morphingData=e,t.__morphT=n}function Wk(t){return null!=t.__oldBuildPath}function Yk(t){return!!t.__combiningSubList}function Xk(t,e,n,i){for(var r=[],o=0,a=0;a<t.length;a++){var s=t[a];if(Yk(s)){for(var l=s.__combiningSubList,u=0;u<l.length;u++)r.push(l[u]);o+=l.length}else r.push(s),o++}if(o){var h=n?n.dividingMethod:null,c=$k(e,o,h);rt(c.length===o);var p=n&&n.done,d=n&&n.aborted,f=n&&n.during,g=0,y=!1,v=T({during:function(t){f&&f(t)},done:function(){++g===c.length&&(!function(t){if(!Yk(t))return;var e=t;Uk(e,null),e.addSelfToZr=e.__oldAddSelfToZr,e.removeSelfFromZr=e.__oldRemoveSelfFromZr,e.buildPath=e.__oldBuildPath,e.childrenRef=e.__combiningSubList=e.__oldAddSelfToZr=e.__oldRemoveSelfFromZr=e.__oldBuildPath=null}(e),p&&p())},aborted:function(){y||(y=!0,d&&d())}},n);for(a=0;a<o;a++){var m=r[a],_=c[a];i&&i(e,_,!0),Fk(m,_,v)}return function(t,e){if(Yk(t))return void Uk(t,e);var n=t;Uk(n,e),n.__oldAddSelfToZr=t.addSelfToZr,n.__oldRemoveSelfFromZr=t.removeSelfFromZr,n.addSelfToZr=Zk,n.removeSelfFromZr=qk,n.__oldBuildPath=n.buildPath,n.buildPath=ft,n.childrenRef=Kk}(e,c),{fromIndividuals:r,toIndividuals:c,count:o}}}function Uk(t,e){if(t.__combiningSubList!==e){if(jk(t,"removeSelfFromZr"),t.__combiningSubList=e,e)for(var n=0;n<e.length;n++)e[n].parent=t;jk(t,"addSelfToZr")}}function Zk(t){this.__oldAddSelfToZr(t),jk(this,"addSelfToZr")}function jk(t,e){var n=t.__combiningSubList,i=t.__zr;if(n&&i)for(var r=0;r<n.length;r++){n[r][e](i)}}function qk(t){this.__oldRemoveSelfFromZr(t);for(var e=this.__combiningSubList,n=0;n<e.length;n++){e[n].removeSelfFromZr(t)}}function Kk(){return this.__combiningSubList}function $k(t,e,n){return"duplicate"===n?Jk(t,e):function(t,e){var n=[];if(e<=0)return n;if(1===e)return Jk(t,e);if(t instanceof os)for(var i=(c=t.shape).height>c.width?1:0,r=kk[i],o=Lk[i],a=c[r]/e,s=c[o],l=0;l<e;l++,s+=a){var u={x:c.x,y:c.y,width:c.width,height:c.height};u[o]=s,u[r]=l<e-1?a:c[o]+c[r]-s;var h=new os({shape:u});n.push(h)}else{if(!(t instanceof Wl))return Jk(t,e);var c,p=(c=t.shape).clockwise,d=c.startAngle,f=c.endAngle,g=(function(t,e,n){return e+Dk*Math[n?"ceil":"floor"]((t-e)/Dk)}(d,c.endAngle,p)-d)/e,y=d;for(l=0;l<e;l++,y+=g){h=new Wl({shape:{cx:c.cx,cy:c.cy,r:c.r,r0:c.r0,clockwise:p,startAngle:y,endAngle:l===e-1?f:y+g}});n.push(h)}}return n}(t,e)}function Jk(t,e){var n=[];if(e<=0)return n;for(var i=t.constructor,r=0;r<e;r++){var o=new i({shape:w(t.shape)});n.push(o)}return n}var Qk=Lr(),tP={x:1,y:1,scaleX:1,scaleY:1,originX:1,originY:1,rotation:1},eP=(z(tP).join(", "),{color:"fill",borderColor:"stroke"}),nP={symbol:1,symbolSize:1,symbolKeepAspect:1,legendSymbol:1,visualMeta:1,liftZ:1,decal:1},iP="emphasis",rP="normal",oP="blur",aP="select",sP=[rP,iP,oP,aP],lP={normal:["itemStyle"],emphasis:[iP,"itemStyle"],blur:[oP,"itemStyle"],select:[aP,"itemStyle"]},uP={normal:["label"],emphasis:[iP,"label"],blur:[oP,"label"],select:[aP,"label"]},hP={normal:{},emphasis:{},blur:{},select:{}},cP={position:["x","y"],scale:["scaleX","scaleY"],origin:["originX","originY"]},pP=new ke,dP={cartesian2d:function(t){var e=t.master.getRect();return{coordSys:{type:"cartesian2d",x:e.x,y:e.y,width:e.width,height:e.height},api:{coord:function(e){return t.dataToPoint(e)},size:B(_k,t)}}},geo:function(t){var e=t.getBoundingRect();return{coordSys:{type:"geo",x:e.x,y:e.y,width:e.width,height:e.height,zoom:t.getZoom()},api:{coord:function(e){return t.dataToPoint(e)},size:B(xk,t)}}},singleAxis:function(t){var e=t.getRect();return{coordSys:{type:"singleAxis",x:e.x,y:e.y,width:e.width,height:e.height},api:{coord:function(e){return t.dataToPoint(e)},size:B(bk,t)}}},polar:function(t){var e=t.getRadiusAxis(),n=t.getAngleAxis(),i=e.getExtent();return i[0]>i[1]&&i.reverse(),{coordSys:{type:"polar",cx:t.cx,cy:t.cy,r:i[1],r0:i[0]},api:{coord:function(i){var r=e.dataToRadius(i[0]),o=n.dataToAngle(i[1]),a=t.coordToPoint([r,o]);return a.push(r,o*Math.PI/180),a},size:B(wk,t)}}},calendar:function(t){var e=t.getRect(),n=t.getRangeInfo();return{coordSys:{type:"calendar",x:e.x,y:e.y,width:e.width,height:e.height,cellWidth:t.getCellWidth(),cellHeight:t.getCellHeight(),rangeInfo:{start:n.start,end:n.end,weeks:n.weeks,dayCount:n.allDay}},api:{coord:function(e,n){return t.dataToPoint(e,n)}}}}},fP=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.optionUpdated=function(){this.currentZLevel=this.get("zlevel",!0),this.currentZ=this.get("z",!0)},e.prototype.getInitialData=function(t,e){return Hm(this.getSource(),this)},e.prototype.getDataParams=function(e,n,i){var r=t.prototype.getDataParams.call(this,e,n);return i&&(r.info=Qk(i).info),r},e.type="series.custom",e.dependencies=["grid","polar","geo","singleAxis","calendar"],e.defaultOption={coordinateSystem:"cartesian2d",zlevel:0,z:2,legendHoverLink:!0,clip:!1},e}(rf),gP=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n,i){var r=this._data,o=t.getData(),a=this.group,s=NP(t,o,e,n),l=t.__transientTransitionOpt;if(!l||null!=l.from&&null!=l.to){var u=new KP(t,l),h=l?"multiple":"oneToOne";new rm(r?r.getIndices():[],o.getIndices(),yP(r,h,l&&l.from),yP(o,h,l&&l.to),null,h).add((function(e){zP(n,null,e,s(e,i),t,a,o,null)})).remove((function(e){UP(r.getItemGraphicEl(e),t,a)})).update((function(e,l){u.reset("oneToOne");var h=r.getItemGraphicEl(l);u.findAndAddFrom(h),u.hasFrom()&&(qP(h,a),h=null),zP(n,h,e,s(e,i),t,a,o,u),u.applyMorphing()})).updateManyToOne((function(e,l){u.reset("manyToOne");for(var h=0;h<l.length;h++){var c=r.getItemGraphicEl(l[h]);u.findAndAddFrom(c),qP(c,a)}zP(n,null,e,s(e,i),t,a,o,u),u.applyMorphing()})).updateOneToMany((function(e,l){u.reset("oneToMany");var h=e.length,c=r.getItemGraphicEl(l);u.findAndAddFrom(c),qP(c,a);for(var p=0;p<h;p++)zP(n,null,e[p],s(e[p],i),t,a,o,u);u.applyMorphing()})).execute()}else r&&r.each((function(e){UP(r.getItemGraphicEl(e),t,a)})),o.each((function(e){zP(n,null,e,s(e,i),t,a,o,null)}));var c=t.get("clip",!0)?Hb(t.coordinateSystem,!1,t):null;c?a.setClipPath(c):a.removeClipPath(),this._data=o},e.prototype.incrementalPrepareRender=function(t,e,n){this.group.removeAll(),this._data=null},e.prototype.incrementalRender=function(t,e,n,i,r){var o=e.getData(),a=NP(e,o,n,i);function s(t){t.isGroup||(t.incremental=!0,t.ensureState("emphasis").hoverLayer=!0)}for(var l=t.start;l<t.end;l++){zP(null,null,l,a(l,r),e,this.group,o,null).traverse(s)}},e.prototype.filterForExposedEvent=function(t,e,n,i){var r=e.element;if(null==r||n.name===r)return!0;for(;(n=n.__hostTarget||n.parent)&&n!==this.group;)if(n.name===r)return!0;return!1},e.type="custom",e}(yf);function yP(t,e,n){if(t){if("oneToOne"===e)return function(e,n){return t.getId(n)};var i=t.getDimension(n),r=t.getDimensionInfo(i);if(!r){var o="";0,yr(o)}var a=r.ordinalMeta;return function(e,n){var r=t.get(i,n);return a&&(r=a.categories[r]),null==r||J(r)?e+"":"_ec_"+r}}}function vP(t){var e,n=t.type;if("path"===n){var i=t.shape,r=null!=i.width&&null!=i.height?{x:i.x||0,y:i.y||0,width:i.width,height:i.height}:null,o=ZP(i);e=Tu(o,null,r,i.layout||"center"),Qk(e).customPathData=o}else if("image"===n)e=new Ja({}),Qk(e).customImagePath=t.style.image;else if("text"===n)e=new ls({});else if("group"===n)e=new zi;else{if("compoundPath"===n)throw new Error('"compoundPath" is not supported yet.');var a=Iu(n);if(!a){var s="";0,yr(s)}e=new a}return Qk(e).customGraphicType=n,e.name=t.name,e.z2EmphasisLift=1,e.z2SelectLift=1,e}function mP(t,e,n,i,r,o,a,s,l,u){var h={},c={},p=e.isGroup?null:e;!n&&bP("shape",e,null,r,h,l),wP("shape",r,c),!n&&bP("extra",e,null,r,h,l),wP("extra",r,c),!n&&SP(e,null,r,h,l),function(t,e){PP(t,e,"position"),PP(t,e,"scale"),PP(t,e,"origin"),OP(t,e,"x"),OP(t,e,"y"),OP(t,e,"scaleX"),OP(t,e,"scaleY"),OP(t,e,"originX"),OP(t,e,"originY"),OP(t,e,"rotation")}(r,c);var d=a&&a.normal.cfg;if(d&&e.setTextConfig(d),"text"===e.type&&o){var f=o;dt(f,"textFill")&&(f.fill=f.textFill),dt(f,"textStroke")&&(f.stroke=f.textStroke)}if(o){var g=void 0,y=jP(e)?o.decal:null;t&&y&&(y.dirty=!0,g=ky(y,t)),o.__decalPattern=g}return!n&&MP(e,null,r,o,h,l),p&&dt(r,"invisible")&&(p.invisible=r.invisible),n||(_P(e,c,o),xP(e,i,r,s,h,l)),dt(r,"silent")&&(e.silent=r.silent),dt(r,"ignore")&&(e.ignore=r.ignore),u||dt(r,"info")&&(Qk(e).info=r.info),o?e.dirty():e.markRedraw(),n?c:null}function _P(t,e,n){var i=t.isGroup?null:t;if(i&&n){var r=n.__decalPattern,o=void 0;r&&(o=n.decal,n.decal=r),i.useStyle(n),r&&(n.decal=o);for(var a=i.animators,s=0;s<a.length;s++){var l=a[s];"style"===l.targetName&&l.changeTarget(i.style)}}e&&t.attr(e)}function xP(t,e,n,i,r,o){if(r){var a=n.during;Qk(t).userDuring=a;var s={dataIndex:e,isFrom:!0,during:a?B(DP,{el:t,userDuring:a}):null};o?Ru(t,r,i,s):Ou(t,r,i,s)}}function bP(t,e,n,i,r,o){var a=i[t];if(a){var s,l=e[t],u=a.enterFrom;if(o&&u){!s&&(s=r[t]={});for(var h=z(u),c=0;c<h.length;c++){s[_=h[c]]=u[_]}}if(!o&&l&&(null==n||"shape"!==t))if(a.transition){!s&&(s=r[t]={});var p=_r(a.transition);for(c=0;c<p.length;c++){var d=l[_=p[c]];0,s[_]=d}}else if(A(i.transition,t)>=0){!s&&(s=r[t]={});var f=z(l);for(c=0;c<f.length;c++){d=l[_=f[c]];IP(a[_],d)&&(s[_]=d)}}var g=a.leaveTo;if(g){var y=TP(e),v=y[t]||(y[t]={}),m=z(g);for(c=0;c<m.length;c++){var _;v[_=m[c]]=g[_]}}}}function wP(t,e,n){var i=e[t];if(i)for(var r=n[t]={},o=z(i),a=0;a<o.length;a++){var s=o[a];r[s]=mn(i[s])}}function SP(t,e,n,i,r){var o=n.enterFrom;if(r&&o)for(var a=z(o),s=0;s<a.length;s++){0,i[f=a[s]]=o[f]}if(!r)if(e){var l=function(t,e){if(!t||t===e||t.parent===e.parent)return t;var n=pP.transform||(pP.transform=ge([])),i=t.getComputedTransform();i?ye(n,i):ge(n);var r=e.parent;r&&r.getComputedTransform();return pP.originX=t.originX,pP.originY=t.originY,pP.parent=r,pP.decomposeTransform(),pP}(e,t);RP(i,"x",l),RP(i,"y",l),RP(i,"scaleX",l),RP(i,"scaleY",l),RP(i,"originX",l),RP(i,"originY",l),RP(i,"rotation",l)}else if(n.transition){var u=_r(n.transition);for(s=0;s<u.length;s++){if("style"!==(f=u[s])&&"shape"!==f&&"extra"!==f){var h=t[f];0,i[f]=h}}}else RP(i,"x",t),RP(i,"y",t);var c=n.leaveTo;if(c){var p=TP(t),d=z(c);for(s=0;s<d.length;s++){var f;0,p[f=d[s]]=c[f]}}}function MP(t,e,n,i,r,o){if(i){var a,s=(e||t).style,l=i.enterFrom;if(o&&l){var u=z(l);!a&&(a=r.style={});for(var h=0;h<u.length;h++){a[x=u[h]]=l[x]}}if(!o&&s)if(i.transition){var c=_r(i.transition);!a&&(a=r.style={});for(h=0;h<c.length;h++){var p=s[x=c[h]];a[x]=p}}else if(t.getAnimationStyleProps&&A(n.transition,"style")>=0){var d=t.getAnimationStyleProps(),f=d?d.style:null;if(f){!a&&(a=r.style={});var g=z(i);for(h=0;h<g.length;h++){if(f[x=g[h]]){p=s[x];a[x]=p}}}}var y=i.leaveTo;if(y){var v=z(y),m=TP(t),_=m.style||(m.style={});for(h=0;h<v.length;h++){var x;_[x=v[h]]=y[x]}}}}function IP(t,e){return k(t)?t!==e:null!=t&&isFinite(t)}function TP(t){var e=Qk(t);return e.leaveToProps||(e.leaveToProps={})}var CP={},AP={setTransform:function(t,e){return CP.el[t]=e,this},getTransform:function(t){return CP.el[t]},setShape:function(t,e){return(CP.el.shape||(CP.el.shape={}))[t]=e,CP.isShapeDirty=!0,this},getShape:function(t){var e=CP.el.shape;if(e)return e[t]},setStyle:function(t,e){var n=CP.el.style;return n&&(n[t]=e,CP.isStyleDirty=!0),this},getStyle:function(t){var e=CP.el.style;if(e)return e[t]},setExtra:function(t,e){return(CP.el.extra||(CP.el.extra={}))[t]=e,this},getExtra:function(t){var e=CP.el.extra;if(e)return e[t]}};function DP(){var t=this,e=t.el;if(e){var n=Qk(e).userDuring,i=t.userDuring;n===i?(CP.el=e,CP.isShapeDirty=!1,CP.isStyleDirty=!1,i(AP),CP.isShapeDirty&&e.dirtyShape&&e.dirtyShape(),CP.isStyleDirty&&e.dirtyStyle&&e.dirtyStyle()):t.el=t.userDuring=null}}function LP(t,e,n,i,r,o,a){var s=e.isGroup?null:e,l=r&&r[t].cfg;if(s){var u=s.ensureState(t);if(!1===i){var h=s.getState(t);h&&(h.style=null)}else u.style=i||null;l&&(u.textConfig=l),Gs(s)}}function kP(t,e,n){var i=n===rP,r=i?e:GP(e,n),o=r?r.z2:null;null!=o&&((i?t:t.ensureState(n)).z2=o||0)}function PP(t,e,n,i){var r=t[n],o=cP[n];r&&(i?(e[o[0]]=i[o[0]],e[o[1]]=i[o[1]]):(e[o[0]]=r[0],e[o[1]]=r[1]))}function OP(t,e,n,i){null!=t[n]&&(e[n]=i?i[n]:t[n])}function RP(t,e,n){n&&(t[e]=n[e])}function NP(t,e,n,i){var r=t.get("renderItem"),o=t.coordinateSystem,a={};o&&(a=o.prepareCustoms?o.prepareCustoms(o):dP[o.type](o));for(var s,l,u=T({getWidth:i.getWidth,getHeight:i.getHeight,getZr:i.getZr,getDevicePixelRatio:i.getDevicePixelRatio,value:function(t,n){return null==n&&(n=s),e.get(e.getDimension(t||0),n)},style:function(n,i){0;null==i&&(i=s);var r=e.getItemVisual(i,"style"),o=r&&r.fill,a=r&&r.opacity,l=m(i,rP).getItemStyle();null!=o&&(l.fill=o),null!=a&&(l.opacity=a);var u={inheritColor:H(o)?o:"#000"},h=_(i,rP),c=nh(h,null,u,!1,!0);c.text=h.getShallow("show")?tt(t.getFormattedLabel(i,rP),_b(e,i)):null;var p=ih(h,u,!1);return b(n,l),l=Tk(l,c,p),n&&x(l,n),l.legacy=!0,l},ordinalRawValue:function(t,n){null==n&&(n=s);var i=e.getDimensionInfo(t||0);if(!i)return;var r=e.get(i.name,n),o=i&&i.ordinalMeta;return o?o.categories[r]:r},styleEmphasis:function(n,i){0;null==i&&(i=s);var r=m(i,iP).getItemStyle(),o=_(i,iP),a=nh(o,null,null,!0,!0);a.text=o.getShallow("show")?et(t.getFormattedLabel(i,iP),t.getFormattedLabel(i,rP),_b(e,i)):null;var l=ih(o,null,!0);return b(n,r),r=Tk(r,a,l),n&&x(r,n),r.legacy=!0,r},visual:function(t,n){if(null==n&&(n=s),dt(eP,t)){var i=e.getItemVisual(n,"style");return i?i[eP[t]]:null}if(dt(nP,t))return e.getItemVisual(n,t)},barLayout:function(t){if("cartesian2d"===o.type){return function(t){var e=[],n=t.axis,i="axis0";if("category"===n.type){for(var r=n.getBandWidth(),o=0;o<t.count;o++)e.push(T({bandWidth:r,axisKey:i,stackId:n_+o},t));var a=l_(e),s=[];for(o=0;o<t.count;o++){var l=a.axis0[n_+o];l.offsetCenter=l.offset+l.width/2,s.push(l)}return s}}(T({axis:o.getBaseAxis()},t))}},currentSeriesIndices:function(){return n.getCurrentSeriesIndices()},font:function(t){return lh(t,n)}},a.api||{}),h={context:{},seriesId:t.id,seriesName:t.name,seriesIndex:t.seriesIndex,coordSys:a.coordSys,dataInsideLength:e.count(),encode:EP(t.getData())},c={},p={},d={},f={},g=0;g<sP.length;g++){var y=sP[g];d[y]=t.getModel(lP[y]),f[y]=t.getModel(uP[y])}function v(t){return t===s?l||(l=e.getItemModel(t)):e.getItemModel(t)}function m(t,n){return e.hasItemOption?t===s?c[n]||(c[n]=v(t).getModel(lP[n])):v(t).getModel(lP[n]):d[n]}function _(t,n){return e.hasItemOption?t===s?p[n]||(p[n]=v(t).getModel(uP[n])):v(t).getModel(uP[n]):f[n]}return function(t,n){return s=t,l=null,c={},p={},r&&r(T({dataIndexInside:t,dataIndex:e.getRawIndex(t),actionType:n?n.type:null},h),u)};function x(t,e){for(var n in e)dt(e,n)&&(t[n]=e[n])}function b(t,e){t&&(t.textFill&&(e.textFill=t.textFill),t.textPosition&&(e.textPosition=t.textPosition))}}function EP(t){var e={};return P(t.dimensions,(function(n,i){var r=t.getDimensionInfo(n);if(!r.isExtraCoord){var o=r.coordDim;(e[o]=e[o]||[])[r.coordDimIndex]=i}})),e}function zP(t,e,n,i,r,o,a,s){if(i)return(e=BP(t,e,n,i,r,o,!0,s))&&a.setItemGraphicEl(n,e),Js(e,i.focus,i.blurScope),e;qP(e,o)}function BP(t,e,n,i,r,o,a,s){var l=-1;e&&VP(e,i)&&(l=o.childrenRef().indexOf(e),e=null);var u=!e;e?e.clearStates():e=vP(i);var h=(Qk(e).canMorph=i.morph&&jP(e))&&s&&s.hasFrom(),c=u&&!h;hP.normal.cfg=hP.normal.conOpt=hP.emphasis.cfg=hP.emphasis.conOpt=hP.blur.cfg=hP.blur.conOpt=hP.select.cfg=hP.select.conOpt=null,hP.isLegacy=!1,function(t,e,n,i,r,o){if(t.isGroup)return;FP(n,null,o),FP(n,iP,o);var a=o.normal.conOpt,s=o.emphasis.conOpt,l=o.blur.conOpt,u=o.select.conOpt;if(null!=a||null!=s||null!=u||null!=l){var h=t.getTextContent();if(!1===a)h&&t.removeTextContent();else{a=o.normal.conOpt=a||{type:"text"},h?h.clearStates():(h=vP(a),t.setTextContent(h));var c=a&&a.style;mP(null,h,null,e,a,c,null,i,r,!0);for(var p=0;p<sP.length;p++){var d=sP[p];if(d!==rP){var f=o[d].conOpt;LP(d,h,0,HP(a,f,d),null)}}c?h.dirty():h.markRedraw()}}}(e,n,i,r,c,hP),function(t,e,n,i,r){var o=n.clipPath;if(!1===o)t&&t.getClipPath()&&t.removeClipPath();else if(o){var a=t.getClipPath();a&&VP(a,o)&&(a=null),a||(a=vP(o),t.setClipPath(a)),mP(null,a,null,e,o,null,null,i,r,!1)}}(e,n,i,r,c);var p=mP(t,e,h,n,i,i.style,hP,r,c,!1);h&&s.addTo(e,i,n,p);for(var d=0;d<sP.length;d++){var f=sP[d];if(f!==rP){var g=GP(i,f);LP(f,e,0,HP(i,g,f),hP)}}return function(t,e,n,i){if(!t.isGroup){var r=t,o=n.currentZ,a=n.currentZLevel;r.z=o,r.zlevel=a;var s=e.z2;null!=s&&(r.z2=s||0);for(var l=0;l<sP.length;l++)kP(r,e,sP[l])}}(e,i,r),"group"===i.type&&function(t,e,n,i,r,o){var a=i.children,s=a?a.length:0,l=i.$mergeChildren,u="byName"===l||i.diffChildrenByName,h=!1===l;if(!s&&!u&&!h)return;if(u)return c={api:t,oldChildren:e.children()||[],newChildren:a||[],dataIndex:n,seriesModel:r,group:e,morphPreparation:o},void new rm(c.oldChildren,c.newChildren,WP,WP,c).add(YP).update(YP).remove(XP).execute();var c;h&&e.removeAll();for(var p=0;p<s;p++)a[p]&&BP(t,e.childAt(p),n,a[p],r,e,!1,o);for(var d=e.childCount()-1;d>=p;d--)UP(e.childAt(d),r,e)}(t,e,n,i,r,s),l>=0?o.replaceAt(e,l):o.add(e),e}function VP(t,e){var n,i=Qk(t),r=e.type,o=e.shape,a=e.style;return null!=r&&r!==i.customGraphicType||"path"===r&&((n=o)&&(dt(n,"pathData")||dt(n,"d")))&&ZP(o)!==i.customPathData||"image"===r&&dt(a,"image")&&a.image!==i.customImagePath}function FP(t,e,n){var i=e?GP(t,e):t,r=e?HP(t,i,iP):t.style,o=t.type,a=i?i.textConfig:null,s=t.textContent,l=s?e?GP(s,e):s:null;if(r&&(n.isLegacy||Sk(r,o,!!a,!!l))){n.isLegacy=!0;var u=Mk(r,o,!e);!a&&u.textConfig&&(a=u.textConfig),!l&&u.textContent&&(l=u.textContent)}if(!e&&l){var h=l;!h.type&&(h.type="text")}var c=e?n[e]:n.normal;c.cfg=a,c.conOpt=l}function GP(t,e){return e?t?t[e]:null:t}function HP(t,e,n){var i=e&&e.style;return null==i&&n===iP&&t&&(i=t.styleEmphasis),i}function WP(t,e){var n=t&&t.name;return null!=n?n:"e\0\0"+e}function YP(t,e){var n=this.context,i=null!=t?n.newChildren[t]:null,r=null!=e?n.oldChildren[e]:null;BP(n.api,r,n.dataIndex,i,n.seriesModel,n.group,0,n.morphPreparation)}function XP(t){var e=this.context;UP(e.oldChildren[t],e.seriesModel,e.group)}function UP(t,e,n){if(t){var i=Qk(t).leaveToProps;i?Ou(t,i,e,{cb:function(){n.remove(t)}}):n.remove(t)}}function ZP(t){return t&&(t.pathData||t.d)}function jP(t){return t&&t instanceof Za}function qP(t,e){t&&e.remove(t)}var KP=function(){function t(t,e){this._fromList=[],this._toList=[],this._toElOptionList=[],this._allPropsFinalList=[],this._toDataIndices=[],this._morphConfigList=[],this._seriesModel=t,this._transOpt=e}return t.prototype.hasFrom=function(){return!!this._fromList.length},t.prototype.findAndAddFrom=function(t){if(t&&(Qk(t).canMorph&&this._fromList.push(t),t.isGroup))for(var e=t.childrenRef(),n=0;n<e.length;n++)this.findAndAddFrom(e[n])},t.prototype.addTo=function(t,e,n,i){t&&(this._toList.push(t),this._toElOptionList.push(e),this._toDataIndices.push(n),this._allPropsFinalList.push(i))},t.prototype.applyMorphing=function(){var t=this._type,e=this._fromList,n=this._toList.length,i=e.length;if(i&&n)if("oneToOne"===t)for(var r=0;r<n;r++)this._oneToOneForSingleTo(r,r);else if("manyToOne"===t)for(var o=Math.max(1,Math.floor(i/n)),a=(r=0,0);r<n;r++,a+=o){var s=r+1>=n?i-a:o;this._manyToOneForSingleTo(r,a>=i?null:a,s)}else if("oneToMany"===t)for(var l=Math.max(1,Math.floor(n/i)),u=0,h=0;u<n;u+=l,h++){var c=u+l>=n?n-u:l;this._oneToManyForSingleFrom(u,c,h>=i?null:h)}},t.prototype._oneToOneForSingleTo=function(t,e){var n,i=this._toList[t],r=this._toElOptionList[t],o=this._toDataIndices[t],a=this._allPropsFinalList[t],s=this._fromList[e],l=this._getOrCreateMorphConfig(o),u=l.duration;if(s&&Yk(s)){if(_P(i,a,r.style),u){var h=Xk([s],i,l,$P);this._processResultIndividuals(h,t,null)}}else{var c=u&&s&&(s!==i||(Wk(n=s)||Yk(n)))?s:null,p={};bP("shape",i,c,r,p,!1),bP("extra",i,c,r,p,!1),SP(i,c,r,p,!1),MP(i,c,r,r.style,p,!1),_P(i,a,r.style),c&&Fk(c,i,l),xP(i,o,r,this._seriesModel,p,!1)}},t.prototype._manyToOneForSingleTo=function(t,e,n){var i=this._toList[t],r=this._toElOptionList[t];_P(i,this._allPropsFinalList[t],r.style);var o=this._getOrCreateMorphConfig(this._toDataIndices[t]);if(o.duration&&null!=e){for(var a=[],s=e;s<n;s++)a.push(this._fromList[s]);var l=Xk(a,i,o,$P);this._processResultIndividuals(l,t,null)}},t.prototype._oneToManyForSingleFrom=function(t,e,n){for(var i=null==n?null:this._fromList[n],r=this._toList,o=[],a=t;a<e;a++){var s=r[a];_P(s,this._allPropsFinalList[a],this._toElOptionList[a].style),o.push(s)}var l=this._getOrCreateMorphConfig(this._toDataIndices[t]);if(l.duration&&i){var u=function(t,e,n,i){var r,o=e.length,a=n?n.dividingMethod:null,s=!1;if(Yk(t)){var l=t.__combiningSubList;l.length===o?r=l:(r=$k(t,o,a),s=!0)}else r=$k(t,o,a),s=!0;rt(r.length===o);for(var u=0;u<o;u++)s&&i&&i(t,r[u],!1),Fk(r[u],e[u],n);return{fromIndividuals:r,toIndividuals:e,count:o}}(i,o,l,$P);this._processResultIndividuals(u,t,e)}},t.prototype._processResultIndividuals=function(t,e,n){for(var i=null!=n,r=0;r<t.count;r++){var o=t.fromIndividuals[r],a=t.toIndividuals[r],s=e+(i?r:0),l=this._toElOptionList[s],u=this._toDataIndices[s],h={};SP(a,o,l,h,!1),MP(a,o,l,l.style,h,!1),xP(a,u,l,this._seriesModel,h,!1)}},t.prototype._getOrCreateMorphConfig=function(t){var e,n,i,r=this._morphConfigList,o=r[t];if(o)return o;var a=this._seriesModel,s=this._transOpt;if(a.isAnimationEnabled()){var l=void 0;if(a&&a.ecModel){var u=a.ecModel.getUpdatePayload();l=u&&u.animation}if(l)e=l.duration||0,n=l.easing||"cubicOut",i=l.delay||0;else{n=a.get("animationEasingUpdate");var h=a.get("animationDelayUpdate");i=G(h)?h(t):h;var c=a.get("animationDurationUpdate");e=G(c)?c(t):c}}return o={duration:e||0,delay:i,easing:n,dividingMethod:s?s.dividingMethod:null},r[t]=o,o},t.prototype.reset=function(t){this._type=t,this._fromList.length=this._toList.length=this._toElOptionList.length=this._allPropsFinalList.length=this._toDataIndices.length=0},t}();function $P(t,e,n){e.style=n?w(t.style):t.style,e.zlevel=t.zlevel,e.z=t.z,e.z2=t.z2}var JP=Lr(),QP=w,tO=B,eO=function(){function t(){this._dragging=!1,this.animationThreshold=15}return t.prototype.render=function(t,e,n,i){var r=e.get("value"),o=e.get("status");if(this._axisModel=t,this._axisPointerModel=e,this._api=n,i||this._lastValue!==r||this._lastStatus!==o){this._lastValue=r,this._lastStatus=o;var a=this._group,s=this._handle;if(!o||"hide"===o)return a&&a.hide(),void(s&&s.hide());a&&a.show(),s&&s.show();var l={};this.makeElOption(l,r,t,e,n);var u=l.graphicKey;u!==this._lastGraphicKey&&this.clear(n),this._lastGraphicKey=u;var h=this._moveAnimation=this.determineAnimation(t,e);if(a){var c=V(nO,e,h);this.updatePointerEl(a,l,c),this.updateLabelEl(a,l,c,e)}else a=this._group=new zi,this.createPointerEl(a,l,t,e),this.createLabelEl(a,l,t,e),n.getZr().add(a);aO(a,e,!0),this._renderHandle(r)}},t.prototype.remove=function(t){this.clear(t)},t.prototype.dispose=function(t){this.clear(t)},t.prototype.determineAnimation=function(t,e){var n=e.get("animation"),i=t.axis,r="category"===i.type,o=e.get("snap");if(!o&&!r)return!1;if("auto"===n||null==n){var a=this.animationThreshold;if(r&&i.getBandWidth()>a)return!0;if(o){var s=_S(t).seriesDataCount,l=i.getExtent();return Math.abs(l[0]-l[1])/s>a}return!1}return!0===n},t.prototype.makeElOption=function(t,e,n,i,r){},t.prototype.createPointerEl=function(t,e,n,i){var r=e.pointer;if(r){var o=JP(t).pointerEl=new Ku[r.type](QP(e.pointer));t.add(o)}},t.prototype.createLabelEl=function(t,e,n,i){if(e.label){var r=JP(t).labelEl=new ls(QP(e.label));t.add(r),rO(r,i)}},t.prototype.updatePointerEl=function(t,e,n){var i=JP(t).pointerEl;i&&e.pointer&&(i.setStyle(e.pointer.style),n(i,{shape:e.pointer.shape}))},t.prototype.updateLabelEl=function(t,e,n,i){var r=JP(t).labelEl;r&&(r.setStyle(e.label.style),n(r,{x:e.label.x,y:e.label.y}),rO(r,i))},t.prototype._renderHandle=function(t){if(!this._dragging&&this.updateHandleTransform){var e,n=this._axisPointerModel,i=this._api.getZr(),r=this._handle,o=n.getModel("handle"),a=n.get("status");if(!o.get("show")||!a||"hide"===a)return r&&i.remove(r),void(this._handle=null);this._handle||(e=!0,r=this._handle=Uu(o.get("icon"),{cursor:"move",draggable:!0,onmousemove:function(t){ee(t.event)},onmousedown:tO(this._onHandleDragMove,this,0,0),drift:tO(this._onHandleDragMove,this),ondragend:tO(this._onHandleDragEnd,this)}),i.add(r)),aO(r,n,!1),r.setStyle(o.getItemStyle(null,["color","borderColor","borderWidth","opacity","shadowColor","shadowBlur","shadowOffsetX","shadowOffsetY"]));var s=o.get("size");F(s)||(s=[s,s]),r.scaleX=s[0]/2,r.scaleY=s[1]/2,Tf(this,"_doDispatchAxisPointer",o.get("throttle")||0,"fixRate"),this._moveHandleToValue(t,e)}},t.prototype._moveHandleToValue=function(t,e){nO(this._axisPointerModel,!e&&this._moveAnimation,this._handle,oO(this.getHandleTransform(t,this._axisModel,this._axisPointerModel)))},t.prototype._onHandleDragMove=function(t,e){var n=this._handle;if(n){this._dragging=!0;var i=this.updateHandleTransform(oO(n),[t,e],this._axisModel,this._axisPointerModel);this._payloadInfo=i,n.stopAnimation(),n.attr(oO(i)),JP(n).lastProp=null,this._doDispatchAxisPointer()}},t.prototype._doDispatchAxisPointer=function(){if(this._handle){var t=this._payloadInfo,e=this._axisModel;this._api.dispatchAction({type:"updateAxisPointer",x:t.cursorPoint[0],y:t.cursorPoint[1],tooltipOption:t.tooltipOption,axesInfo:[{axisDim:e.axis.dim,axisIndex:e.componentIndex}]})}},t.prototype._onHandleDragEnd=function(){if(this._dragging=!1,this._handle){var t=this._axisPointerModel.get("value");this._moveHandleToValue(t),this._api.dispatchAction({type:"hideTip"})}},t.prototype.clear=function(t){this._lastValue=null,this._lastStatus=null;var e=t.getZr(),n=this._group,i=this._handle;e&&n&&(this._lastGraphicKey=null,n&&e.remove(n),i&&e.remove(i),this._group=null,this._handle=null,this._payloadInfo=null)},t.prototype.doClear=function(){},t.prototype.buildLabel=function(t,e,n){return{x:t[n=n||0],y:t[1-n],width:e[n],height:e[1-n]}},t}();function nO(t,e,n,i){iO(JP(n).lastProp,i)||(JP(n).lastProp=i,e?Ou(n,i,t):(n.stopAnimation(),n.attr(i)))}function iO(t,e){if(X(t)&&X(e)){var n=!0;return P(e,(function(e,i){n=n&&iO(t[i],e)})),!!n}return t===e}function rO(t,e){t[e.get(["label","show"])?"show":"hide"]()}function oO(t){return{x:t.x||0,y:t.y||0,rotation:t.rotation||0}}function aO(t,e,n){var i=e.get("z"),r=e.get("zlevel");t&&t.traverse((function(t){"group"!==t.type&&(null!=i&&(t.z=i),null!=r&&(t.zlevel=r),t.silent=n)}))}function sO(t){var e,n=t.get("type"),i=t.getModel(n+"Style");return"line"===n?(e=i.getLineStyle()).fill=null:"shadow"===n&&((e=i.getAreaStyle()).stroke=null),e}function lO(t,e,n,i,r){var o=uO(n.get("value"),e.axis,e.ecModel,n.get("seriesDataIndices"),{precision:n.get(["label","precision"]),formatter:n.get(["label","formatter"])}),a=n.getModel("label"),s=pc(a.get("padding")||0),l=a.getFont(),u=Fn(o,l),h=r.position,c=u.width+s[1]+s[3],p=u.height+s[0]+s[2],d=r.align;"right"===d&&(h[0]-=c),"center"===d&&(h[0]-=c/2);var f=r.verticalAlign;"bottom"===f&&(h[1]-=p),"middle"===f&&(h[1]-=p/2),function(t,e,n,i){var r=i.getWidth(),o=i.getHeight();t[0]=Math.min(t[0]+e,r)-e,t[1]=Math.min(t[1]+n,o)-n,t[0]=Math.max(t[0],0),t[1]=Math.max(t[1],0)}(h,c,p,i);var g=a.get("backgroundColor");g&&"auto"!==g||(g=e.get(["axisLine","lineStyle","color"])),t.label={x:h[0],y:h[1],style:nh(a,{text:o,font:l,fill:a.getTextColor(),padding:s,backgroundColor:g}),z2:10}}function uO(t,e,n,i,r){t=e.scale.parse(t);var o=e.scale.getLabel({value:t},{precision:r.precision}),a=r.formatter;if(a){var s={value:W_(e,{value:t}),axisDimension:e.dim,axisIndex:e.index,seriesData:[]};P(i,(function(t){var e=n.getSeriesByIndex(t.seriesIndex),i=t.dataIndexInside,r=e&&e.getDataParams(i);r&&s.seriesData.push(r)})),H(a)?o=a.replace("{value}",o):G(a)&&(o=a(s))}return o}function hO(t,e,n){var i=[1,0,0,1,0,0];return _e(i,i,n.rotation),me(i,i,n.position),Fu([t.dataToCoord(e),(n.labelOffset||0)+(n.labelDirection||1)*(n.labelMargin||0)],i)}function cO(t,e,n,i,r,o){var a=hS.innerTextLayout(n.rotation,0,n.labelDirection);n.labelMargin=r.get(["label","margin"]),lO(e,i,r,o,{position:hO(i.axis,t,n),align:a.textAlign,verticalAlign:a.textVerticalAlign})}function pO(t,e,n){return{x1:t[n=n||0],y1:t[1-n],x2:e[n],y2:e[1-n]}}function dO(t,e,n){return{x:t[n=n||0],y:t[1-n],width:e[n],height:e[1-n]}}function fO(t,e,n,i,r,o){return{cx:t,cy:e,r0:n,r:i,startAngle:r,endAngle:o,clockwise:!0}}var gO=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.makeElOption=function(t,e,n,i,r){var o=n.axis,a=o.grid,s=i.get("type"),l=yO(a,o).getOtherAxis(o).getGlobalExtent(),u=o.toGlobalCoord(o.dataToCoord(e,!0));if(s&&"none"!==s){var h=sO(i),c=vO[s](o,u,l);c.style=h,t.graphicKey=c.type,t.pointer=c}cO(e,t,nS(a.model,n),n,i,r)},e.prototype.getHandleTransform=function(t,e,n){var i=nS(e.axis.grid.model,e,{labelInside:!1});i.labelMargin=n.get(["handle","margin"]);var r=hO(e.axis,t,i);return{x:r[0],y:r[1],rotation:i.rotation+(i.labelDirection<0?Math.PI:0)}},e.prototype.updateHandleTransform=function(t,e,n,i){var r=n.axis,o=r.grid,a=r.getGlobalExtent(!0),s=yO(o,r).getOtherAxis(r).getGlobalExtent(),l="x"===r.dim?0:1,u=[t.x,t.y];u[l]+=e[l],u[l]=Math.min(a[1],u[l]),u[l]=Math.max(a[0],u[l]);var h=(s[1]+s[0])/2,c=[h,h];c[l]=u[l];return{x:u[0],y:u[1],rotation:t.rotation,cursorPoint:c,tooltipOption:[{verticalAlign:"middle"},{align:"center"}][l]}},e}(eO);function yO(t,e){var n={};return n[e.dim+"AxisIndex"]=e.index,t.getCartesian(n)}var vO={line:function(t,e,n){return{type:"Line",subPixelOptimize:!0,shape:pO([e,n[0]],[e,n[1]],mO(t))}},shadow:function(t,e,n){var i=Math.max(1,t.getBandWidth()),r=n[1]-n[0];return{type:"Rect",shape:dO([e-i/2,n[0]],[i,r],mO(t))}}};function mO(t){return"x"===t.dim?0:1}var _O=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="axisPointer",e.defaultOption={show:"auto",zlevel:0,z:50,type:"line",snap:!1,triggerTooltip:!0,value:null,status:null,link:[],animation:null,animationDurationUpdate:200,lineStyle:{color:"#B9BEC9",width:1,type:"dashed"},shadowStyle:{color:"rgba(210,219,238,0.2)"},label:{show:!0,formatter:null,precision:"auto",margin:3,color:"#fff",padding:[5,7,5,7],backgroundColor:"auto",borderColor:null,borderWidth:0,borderRadius:3},handle:{show:!1,icon:"M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z",size:45,margin:50,color:"#333",shadowBlur:3,shadowColor:"#aaa",shadowOffsetX:0,shadowOffsetY:2,throttle:40}},e}(Nc),xO=Lr(),bO=P;function wO(t,e,n){if(!a.node){var i=e.getZr();xO(i).records||(xO(i).records={}),function(t,e){if(xO(t).initialized)return;function n(n,i){t.on(n,(function(n){var r=function(t){var e={showTip:[],hideTip:[]},n=function(i){var r=e[i.type];r?r.push(i):(i.dispatchAction=n,t.dispatchAction(i))};return{dispatchAction:n,pendings:e}}(e);bO(xO(t).records,(function(t){t&&i(t,n,r.dispatchAction)})),function(t,e){var n,i=t.showTip.length,r=t.hideTip.length;i?n=t.showTip[i-1]:r&&(n=t.hideTip[r-1]);n&&(n.dispatchAction=null,e.dispatchAction(n))}(r.pendings,e)}))}xO(t).initialized=!0,n("click",V(MO,"click")),n("mousemove",V(MO,"mousemove")),n("globalout",SO)}(i,e),(xO(i).records[t]||(xO(i).records[t]={})).handler=n}}function SO(t,e,n){t.handler("leave",null,n)}function MO(t,e,n,i){e.handler(t,n,i)}function IO(t,e){if(!a.node){var n=e.getZr();(xO(n).records||{})[t]&&(xO(n).records[t]=null)}}var TO=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=e.getComponent("tooltip"),r=t.get("triggerOn")||i&&i.get("triggerOn")||"mousemove|click";wO("axisPointer",n,(function(t,e,n){"none"!==r&&("leave"===t||r.indexOf(t)>=0)&&n({type:"updateAxisPointer",currTrigger:t,x:e&&e.offsetX,y:e&&e.offsetY})}))},e.prototype.remove=function(t,e){IO("axisPointer",e)},e.prototype.dispose=function(t,e){IO("axisPointer",e)},e.type="axisPointer",e}(pf);function CO(t,e){var n,i=[],r=t.seriesIndex;if(null==r||!(n=e.getSeriesByIndex(r)))return{point:[]};var o=n.getData(),a=Dr(o,t);if(null==a||a<0||F(a))return{point:[]};var s=o.getItemGraphicEl(a),l=n.coordinateSystem;if(n.getTooltipPosition)i=n.getTooltipPosition(a)||[];else if(l&&l.dataToPoint)if(t.isStacked){var u=l.getBaseAxis(),h=l.getOtherAxis(u).dim,c=u.dim,p="x"===h||"radius"===h?1:0,d=o.mapDimension(c),f=[];f[p]=o.get(d,a),f[1-p]=o.get(o.getCalculationInfo("stackResultDimension"),a),i=l.dataToPoint(f)||[]}else i=l.dataToPoint(o.getValues(O(l.dimensions,(function(t){return o.mapDimension(t)})),a))||[];else if(s){var g=s.getBoundingRect().clone();g.applyTransform(s.transform),i=[g.x+g.width/2,g.y+g.height/2]}return{point:i,el:s}}var AO=Lr();function DO(t,e,n){var i=t.currTrigger,r=[t.x,t.y],o=t,a=t.dispatchAction||B(n.dispatchAction,n),s=e.getComponent("axisPointer").coordSysAxesInfo;if(s){RO(r)&&(r=CO({seriesIndex:o.seriesIndex,dataIndex:o.dataIndex},e).point);var l=RO(r),u=o.axesInfo,h=s.axesInfo,c="leave"===i||RO(r),p={},d={},f={list:[],map:{}},g={showPointer:V(kO,d),showTooltip:V(PO,f)};P(s.coordSysMap,(function(t,e){var n=l||t.containPoint(r);P(s.coordSysAxesInfo[e],(function(t,e){var i=t.axis,o=function(t,e){for(var n=0;n<(t||[]).length;n++){var i=t[n];if(e.axis.dim===i.axisDim&&e.axis.model.componentIndex===i.axisIndex)return i}}(u,t);if(!c&&n&&(!u||o)){var a=o&&o.value;null!=a||l||(a=i.pointToData(r)),null!=a&&LO(t,a,g,!1,p)}}))}));var y={};return P(h,(function(t,e){var n=t.linkGroup;n&&!d[e]&&P(n.axesInfo,(function(e,i){var r=d[i];if(e!==t&&r){var o=r.value;n.mapper&&(o=t.axis.scale.parse(n.mapper(o,OO(e),OO(t)))),y[t.key]=o}}))})),P(y,(function(t,e){LO(h[e],t,g,!0,p)})),function(t,e,n){var i=n.axesInfo=[];P(e,(function(e,n){var r=e.axisPointerModel.option,o=t[n];o?(!e.useHandle&&(r.status="show"),r.value=o.value,r.seriesDataIndices=(o.payloadBatch||[]).slice()):!e.useHandle&&(r.status="hide"),"show"===r.status&&i.push({axisDim:e.axis.dim,axisIndex:e.axis.model.componentIndex,value:r.value})}))}(d,h,p),function(t,e,n,i){if(RO(e)||!t.list.length)return void i({type:"hideTip"});var r=((t.list[0].dataByAxis[0]||{}).seriesDataIndices||[])[0]||{};i({type:"showTip",escapeConnect:!0,x:e[0],y:e[1],tooltipOption:n.tooltipOption,position:n.position,dataIndexInside:r.dataIndexInside,dataIndex:r.dataIndex,seriesIndex:r.seriesIndex,dataByCoordSys:t.list})}(f,r,t,a),function(t,e,n){var i=n.getZr(),r="axisPointerLastHighlights",o=AO(i)[r]||{},a=AO(i)[r]={};P(t,(function(t,e){var n=t.axisPointerModel.option;"show"===n.status&&P(n.seriesDataIndices,(function(t){var e=t.seriesIndex+" | "+t.dataIndex;a[e]=t}))}));var s=[],l=[];P(o,(function(t,e){!a[e]&&l.push(t)})),P(a,(function(t,e){!o[e]&&s.push(t)})),l.length&&n.dispatchAction({type:"downplay",escapeConnect:!0,notBlur:!0,batch:l}),s.length&&n.dispatchAction({type:"highlight",escapeConnect:!0,notBlur:!0,batch:s})}(h,0,n),p}}function LO(t,e,n,i,r){var o=t.axis;if(!o.scale.isBlank()&&o.containData(e))if(t.involveSeries){var a=function(t,e){var n=e.axis,i=n.dim,r=t,o=[],a=Number.MAX_VALUE,s=-1;return P(e.seriesModels,(function(e,l){var u,h,c=e.getData().mapDimensionsAll(i);if(e.getAxisTooltipData){var p=e.getAxisTooltipData(c,t,n);h=p.dataIndices,u=p.nestestValue}else{if(!(h=e.getData().indicesOfNearest(c[0],t,"category"===n.type?.5:null)).length)return;u=e.getData().get(c[0],h[0])}if(null!=u&&isFinite(u)){var d=t-u,f=Math.abs(d);f<=a&&((f<a||d>=0&&s<0)&&(a=f,s=d,r=u,o.length=0),P(h,(function(t){o.push({seriesIndex:e.seriesIndex,dataIndexInside:t,dataIndex:e.getData().getRawIndex(t)})})))}})),{payloadBatch:o,snapToValue:r}}(e,t),s=a.payloadBatch,l=a.snapToValue;s[0]&&null==r.seriesIndex&&I(r,s[0]),!i&&t.snap&&o.containData(l)&&null!=l&&(e=l),n.showPointer(t,e,s),n.showTooltip(t,a,l)}else n.showPointer(t,e)}function kO(t,e,n,i){t[e.key]={value:n,payloadBatch:i}}function PO(t,e,n,i){var r=n.payloadBatch,o=e.axis,a=o.model,s=e.axisPointerModel;if(e.triggerTooltip&&r.length){var l=e.coordSys.model,u=bS(l),h=t.map[u];h||(h=t.map[u]={coordSysId:l.id,coordSysIndex:l.componentIndex,coordSysType:l.type,coordSysMainType:l.mainType,dataByAxis:[]},t.list.push(h)),h.dataByAxis.push({axisDim:o.dim,axisIndex:a.componentIndex,axisType:a.type,axisId:a.id,value:i,valueLabelOpt:{precision:s.get(["label","precision"]),formatter:s.get(["label","formatter"])},seriesDataIndices:r.slice()})}}function OO(t){var e=t.axis.model,n={},i=n.axisDim=t.axis.dim;return n.axisIndex=n[i+"AxisIndex"]=e.componentIndex,n.axisName=n[i+"AxisName"]=e.name,n.axisId=n[i+"AxisId"]=e.id,n}function RO(t){return!t||null==t[0]||isNaN(t[0])||null==t[1]||isNaN(t[1])}function NO(t){SS.registerAxisPointerClass("CartesianAxisPointer",gO),t.registerComponentModel(_O),t.registerComponentView(TO),t.registerPreprocessor((function(t){if(t){(!t.axisPointer||0===t.axisPointer.length)&&(t.axisPointer={});var e=t.axisPointer.link;e&&!F(e)&&(t.axisPointer.link=[e])}})),t.registerProcessor(t.PRIORITY.PROCESSOR.STATISTIC,(function(t,e){t.getComponent("axisPointer").coordSysAxesInfo=yS(t,e)})),t.registerAction({type:"updateAxisPointer",event:"updateAxisPointer",update:":updateAxisPointer"},DO)}var EO=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.makeElOption=function(t,e,n,i,r){var o=n.axis;"angle"===o.dim&&(this.animationThreshold=Math.PI/18);var a=o.polar,s=a.getOtherAxis(o).getExtent(),l=o.dataToCoord(e),u=i.get("type");if(u&&"none"!==u){var h=sO(i),c=zO[u](o,a,l,s);c.style=h,t.graphicKey=c.type,t.pointer=c}var p=function(t,e,n,i,r){var o=e.axis,a=o.dataToCoord(t),s=i.getAngleAxis().getExtent()[0];s=s/180*Math.PI;var l,u,h,c=i.getRadiusAxis().getExtent();if("radius"===o.dim){var p=[1,0,0,1,0,0];_e(p,p,s),me(p,p,[i.cx,i.cy]),l=Fu([a,-r],p);var d=e.getModel("axisLabel").get("rotate")||0,f=hS.innerTextLayout(s,d*Math.PI/180,-1);u=f.textAlign,h=f.textVerticalAlign}else{var g=c[1];l=i.coordToPoint([g+r,a]);var y=i.cx,v=i.cy;u=Math.abs(l[0]-y)/g<.3?"center":l[0]>y?"left":"right",h=Math.abs(l[1]-v)/g<.3?"middle":l[1]>v?"top":"bottom"}return{position:l,align:u,verticalAlign:h}}(e,n,0,a,i.get(["label","margin"]));lO(t,n,i,r,p)},e}(eO);var zO={line:function(t,e,n,i){return"angle"===t.dim?{type:"Line",shape:pO(e.coordToPoint([i[0],n]),e.coordToPoint([i[1],n]))}:{type:"Circle",shape:{cx:e.cx,cy:e.cy,r:n}}},shadow:function(t,e,n,i){var r=Math.max(1,t.getBandWidth()),o=Math.PI/180;return"angle"===t.dim?{type:"Sector",shape:fO(e.cx,e.cy,i[0],i[1],(-n-r/2)*o,(r/2-n)*o)}:{type:"Sector",shape:fO(e.cx,e.cy,n-r/2,n+r/2,0,2*Math.PI)}}},BO=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.findAxisModel=function(t){var e;return this.ecModel.eachComponent(t,(function(t){t.getCoordSysModel()===this&&(e=t)}),this),e},e.type="polar",e.dependencies=["radiusAxis","angleAxis"],e.defaultOption={zlevel:0,z:0,center:["50%","50%"],radius:"80%"},e}(Nc),VO=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.getCoordSysModel=function(){return this.getReferringComponents("polar",Or).models[0]},e.type="polarAxis",e}(Nc);L(VO,j_);var FO=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="angleAxis",e}(VO),GO=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="radiusAxis",e}(VO),HO=function(t){function e(e,n){return t.call(this,"radius",e,n)||this}return n(e,t),e.prototype.pointToData=function(t,e){return this.polar.pointToData(t,e)["radius"===this.dim?0:1]},e}(vx);HO.prototype.dataToRadius=vx.prototype.dataToCoord,HO.prototype.radiusToData=vx.prototype.coordToData;var WO=Lr(),YO=function(t){function e(e,n){return t.call(this,"angle",e,n||[0,360])||this}return n(e,t),e.prototype.pointToData=function(t,e){return this.polar.pointToData(t,e)["radius"===this.dim?0:1]},e.prototype.calculateCategoryInterval=function(){var t=this,e=t.getLabelModel(),n=t.scale,i=n.getExtent(),r=n.count();if(i[1]-i[0]<1)return 0;var o=i[0],a=t.dataToCoord(o+1)-t.dataToCoord(o),s=Math.abs(a),l=Fn(null==o?"":o+"",e.getFont(),"center","top"),u=Math.max(l.height,7)/s;isNaN(u)&&(u=1/0);var h=Math.max(0,Math.floor(u)),c=WO(t.model),p=c.lastAutoInterval,d=c.lastTickCount;return null!=p&&null!=d&&Math.abs(p-h)<=1&&Math.abs(d-r)<=1&&p>h?h=p:(c.lastTickCount=r,c.lastAutoInterval=h),h},e}(vx);YO.prototype.dataToAngle=vx.prototype.dataToCoord,YO.prototype.angleToData=vx.prototype.coordToData;var XO=function(){function t(t){this.dimensions=["radius","angle"],this.type="polar",this.cx=0,this.cy=0,this._radiusAxis=new HO,this._angleAxis=new YO,this.axisPointerEnabled=!0,this.name=t||"",this._radiusAxis.polar=this._angleAxis.polar=this}return t.prototype.containPoint=function(t){var e=this.pointToCoord(t);return this._radiusAxis.contain(e[0])&&this._angleAxis.contain(e[1])},t.prototype.containData=function(t){return this._radiusAxis.containData(t[0])&&this._angleAxis.containData(t[1])},t.prototype.getAxis=function(t){return this["_"+t+"Axis"]},t.prototype.getAxes=function(){return[this._radiusAxis,this._angleAxis]},t.prototype.getAxesByScale=function(t){var e=[],n=this._angleAxis,i=this._radiusAxis;return n.scale.type===t&&e.push(n),i.scale.type===t&&e.push(i),e},t.prototype.getAngleAxis=function(){return this._angleAxis},t.prototype.getRadiusAxis=function(){return this._radiusAxis},t.prototype.getOtherAxis=function(t){var e=this._angleAxis;return t===e?this._radiusAxis:e},t.prototype.getBaseAxis=function(){return this.getAxesByScale("ordinal")[0]||this.getAxesByScale("time")[0]||this.getAngleAxis()},t.prototype.getTooltipAxes=function(t){var e=null!=t&&"auto"!==t?this.getAxis(t):this.getBaseAxis();return{baseAxes:[e],otherAxes:[this.getOtherAxis(e)]}},t.prototype.dataToPoint=function(t,e){return this.coordToPoint([this._radiusAxis.dataToRadius(t[0],e),this._angleAxis.dataToAngle(t[1],e)])},t.prototype.pointToData=function(t,e){var n=this.pointToCoord(t);return[this._radiusAxis.radiusToData(n[0],e),this._angleAxis.angleToData(n[1],e)]},t.prototype.pointToCoord=function(t){var e=t[0]-this.cx,n=t[1]-this.cy,i=this.getAngleAxis(),r=i.getExtent(),o=Math.min(r[0],r[1]),a=Math.max(r[0],r[1]);i.inverse?o=a-360:a=o+360;var s=Math.sqrt(e*e+n*n);e/=s,n/=s;for(var l=Math.atan2(-n,e)/Math.PI*180,u=l<o?1:-1;l<o||l>a;)l+=360*u;return[s,l]},t.prototype.coordToPoint=function(t){var e=t[0],n=t[1]/180*Math.PI;return[Math.cos(n)*e+this.cx,-Math.sin(n)*e+this.cy]},t.prototype.getArea=function(){var t=this.getAngleAxis(),e=this.getRadiusAxis().getExtent().slice();e[0]>e[1]&&e.reverse();var n=t.getExtent(),i=Math.PI/180;return{cx:this.cx,cy:this.cy,r0:e[0],r:e[1],startAngle:-n[0]*i,endAngle:-n[1]*i,clockwise:t.inverse,contain:function(t,e){var n=t-this.cx,i=e-this.cy,r=n*n+i*i,o=this.r,a=this.r0;return r<=o*o&&r>=a*a}}},t.prototype.convertToPixel=function(t,e,n){return UO(e)===this?this.dataToPoint(n):null},t.prototype.convertFromPixel=function(t,e,n){return UO(e)===this?this.pointToData(n):null},t}();function UO(t){var e=t.seriesModel,n=t.polarModel;return n&&n.coordinateSystem||e&&e.coordinateSystem}function ZO(t,e){var n=this,i=n.getAngleAxis(),r=n.getRadiusAxis();if(i.scale.setExtent(1/0,-1/0),r.scale.setExtent(1/0,-1/0),t.eachSeries((function(t){if(t.coordinateSystem===n){var e=t.getData();P(Z_(e,"radius"),(function(t){r.scale.unionExtentFromData(e,t)})),P(Z_(e,"angle"),(function(t){i.scale.unionExtentFromData(e,t)}))}})),F_(i.scale,i.model),F_(r.scale,r.model),"category"===i.type&&!i.onBand){var o=i.getExtent(),a=360/i.scale.count();i.inverse?o[1]+=a:o[1]-=a,i.setExtent(o[0],o[1])}}function jO(t,e){if(t.type=e.get("type"),t.scale=G_(e),t.onBand=e.get("boundaryGap")&&"category"===t.type,t.inverse=e.get("inverse"),function(t){return"angleAxis"===t.mainType}(e)){t.inverse=t.inverse!==e.get("clockwise");var n=e.get("startAngle");t.setExtent(n,n+(t.inverse?-360:360))}e.axis=t,t.model=e}var qO={dimensions:XO.prototype.dimensions,create:function(t,e){var n=[];return t.eachComponent("polar",(function(t,i){var r=new XO(i+"");r.update=ZO;var o=r.getRadiusAxis(),a=r.getAngleAxis(),s=t.findAxisModel("radiusAxis"),l=t.findAxisModel("angleAxis");jO(o,s),jO(a,l),function(t,e,n){var i=e.get("center"),r=n.getWidth(),o=n.getHeight();t.cx=Zi(i[0],r),t.cy=Zi(i[1],o);var a=t.getRadiusAxis(),s=Math.min(r,o)/2,l=e.get("radius");null==l?l=[0,"100%"]:F(l)||(l=[0,l]);var u=[Zi(l[0],s),Zi(l[1],s)];a.inverse?a.setExtent(u[1],u[0]):a.setExtent(u[0],u[1])}(r,t,e),n.push(r),t.coordinateSystem=r,r.model=t})),t.eachSeries((function(t){if("polar"===t.get("coordinateSystem")){var e=t.getReferringComponents("polar",Or).models[0];0,t.coordinateSystem=e.coordinateSystem}})),n}},KO=["axisLine","axisLabel","axisTick","minorTick","splitLine","minorSplitLine","splitArea"];function $O(t,e,n){e[1]>e[0]&&(e=e.slice().reverse());var i=t.coordToPoint([e[0],n]),r=t.coordToPoint([e[1],n]);return{x1:i[0],y1:i[1],x2:r[0],y2:r[1]}}function JO(t){return t.getRadiusAxis().inverse?0:1}function QO(t){var e=t[0],n=t[t.length-1];e&&n&&Math.abs(Math.abs(e.coord-n.coord)-360)<1e-4&&t.pop()}var tR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.axisPointerClass="PolarAxisPointer",n}return n(e,t),e.prototype.render=function(t,e){if(this.group.removeAll(),t.get("show")){var n=t.axis,i=n.polar,r=i.getRadiusAxis().getExtent(),o=n.getTicksCoords(),a=n.getMinorTicksCoords(),s=O(n.getViewLabels(),(function(t){t=w(t);var e=n.scale,i="ordinal"===e.type?e.getRawOrdinalNumber(t.tickValue):t.tickValue;return t.coord=n.dataToCoord(i),t}));QO(s),QO(o),P(KO,(function(e){!t.get([e,"show"])||n.scale.isBlank()&&"axisLine"!==e||eR[e](this.group,t,i,o,a,r,s)}),this)}},e.type="angleAxis",e}(SS),eR={axisLine:function(t,e,n,i,r,o){var a,s=e.getModel(["axisLine","lineStyle"]),l=JO(n),u=l?0:1;(a=0===o[u]?new Tl({shape:{cx:n.cx,cy:n.cy,r:o[l]},style:s.getLineStyle(),z2:1,silent:!0}):new Xl({shape:{cx:n.cx,cy:n.cy,r:o[l],r0:o[u]},style:s.getLineStyle(),z2:1,silent:!0})).style.fill=null,t.add(a)},axisTick:function(t,e,n,i,r,o){var a=e.getModel("axisTick"),s=(a.get("inside")?-1:1)*a.get("length"),l=o[JO(n)],u=O(i,(function(t){return new tu({shape:$O(n,[l,l+s],t.coord)})}));t.add(Du(u,{style:T(a.getModel("lineStyle").getLineStyle(),{stroke:e.get(["axisLine","lineStyle","color"])})}))},minorTick:function(t,e,n,i,r,o){if(r.length){for(var a=e.getModel("axisTick"),s=e.getModel("minorTick"),l=(a.get("inside")?-1:1)*s.get("length"),u=o[JO(n)],h=[],c=0;c<r.length;c++)for(var p=0;p<r[c].length;p++)h.push(new tu({shape:$O(n,[u,u+l],r[c][p].coord)}));t.add(Du(h,{style:T(s.getModel("lineStyle").getLineStyle(),T(a.getLineStyle(),{stroke:e.get(["axisLine","lineStyle","color"])}))}))}},axisLabel:function(t,e,n,i,r,o,a){var s=e.getCategories(!0),l=e.getModel("axisLabel"),u=l.get("margin"),h=e.get("triggerEvent");P(a,(function(i,r){var a=l,c=i.tickValue,p=o[JO(n)],d=n.coordToPoint([p+u,i.coord]),f=n.cx,g=n.cy,y=Math.abs(d[0]-f)/p<.3?"center":d[0]>f?"left":"right",v=Math.abs(d[1]-g)/p<.3?"middle":d[1]>g?"top":"bottom";if(s&&s[c]){var m=s[c];X(m)&&m.textStyle&&(a=new Sh(m.textStyle,l,l.ecModel))}var _=new ls({silent:hS.isLabelSilent(e),style:nh(a,{x:d[0],y:d[1],fill:a.getTextColor()||e.get(["axisLine","lineStyle","color"]),text:i.formattedLabel,align:y,verticalAlign:v})});if(t.add(_),h){var x=hS.makeAxisEventDataBase(e);x.targetType="axisLabel",x.value=i.rawLabel,ys(_).eventData=x}}),this)},splitLine:function(t,e,n,i,r,o){var a=e.getModel("splitLine").getModel("lineStyle"),s=a.get("color"),l=0;s=s instanceof Array?s:[s];for(var u=[],h=0;h<i.length;h++){var c=l++%s.length;u[c]=u[c]||[],u[c].push(new tu({shape:$O(n,o,i[h].coord)}))}for(h=0;h<u.length;h++)t.add(Du(u[h],{style:T({stroke:s[h%s.length]},a.getLineStyle()),silent:!0,z:e.get("z")}))},minorSplitLine:function(t,e,n,i,r,o){if(r.length){for(var a=e.getModel("minorSplitLine").getModel("lineStyle"),s=[],l=0;l<r.length;l++)for(var u=0;u<r[l].length;u++)s.push(new tu({shape:$O(n,o,r[l][u].coord)}));t.add(Du(s,{style:a.getLineStyle(),silent:!0,z:e.get("z")}))}},splitArea:function(t,e,n,i,r,o){if(i.length){var a=e.getModel("splitArea").getModel("areaStyle"),s=a.get("color"),l=0;s=s instanceof Array?s:[s];for(var u=[],h=Math.PI/180,c=-i[0].coord*h,p=Math.min(o[0],o[1]),d=Math.max(o[0],o[1]),f=e.get("clockwise"),g=1,y=i.length;g<=y;g++){var v=g===y?i[0].coord:i[g].coord,m=l++%s.length;u[m]=u[m]||[],u[m].push(new Wl({shape:{cx:n.cx,cy:n.cy,r0:p,r:d,startAngle:c,endAngle:-v*h,clockwise:f},silent:!0})),c=-v*h}for(g=0;g<u.length;g++)t.add(Du(u[g],{style:T({fill:s[g%s.length]},a.getAreaStyle()),silent:!0}))}}},nR=["axisLine","axisTickLabel","axisName"],iR=["splitLine","splitArea","minorSplitLine"],rR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.axisPointerClass="PolarAxisPointer",n}return n(e,t),e.prototype.render=function(t,e){if(this.group.removeAll(),t.get("show")){var n=this._axisGroup,i=this._axisGroup=new zi;this.group.add(i);var r=t.axis,o=r.polar,a=o.getAngleAxis(),s=r.getTicksCoords(),l=r.getMinorTicksCoords(),u=a.getExtent()[0],h=r.getExtent(),c=function(t,e,n){return{position:[t.cx,t.cy],rotation:n/180*Math.PI,labelDirection:-1,tickDirection:-1,nameDirection:1,labelRotate:e.getModel("axisLabel").get("rotate"),z2:1}}(o,t,u),p=new hS(t,c);P(nR,p.add,p),i.add(p.getGroup()),Wu(n,i,t),P(iR,(function(e){t.get([e,"show"])&&!r.scale.isBlank()&&oR[e](this.group,t,o,u,h,s,l)}),this)}},e.type="radiusAxis",e}(SS),oR={splitLine:function(t,e,n,i,r,o){var a=e.getModel("splitLine").getModel("lineStyle"),s=a.get("color"),l=0;s=s instanceof Array?s:[s];for(var u=[],h=0;h<o.length;h++){var c=l++%s.length;u[c]=u[c]||[],u[c].push(new Tl({shape:{cx:n.cx,cy:n.cy,r:o[h].coord}}))}for(h=0;h<u.length;h++)t.add(Du(u[h],{style:T({stroke:s[h%s.length],fill:null},a.getLineStyle()),silent:!0}))},minorSplitLine:function(t,e,n,i,r,o,a){if(a.length){for(var s=e.getModel("minorSplitLine").getModel("lineStyle"),l=[],u=0;u<a.length;u++)for(var h=0;h<a[u].length;h++)l.push(new Tl({shape:{cx:n.cx,cy:n.cy,r:a[u][h].coord}}));t.add(Du(l,{style:T({fill:null},s.getLineStyle()),silent:!0}))}},splitArea:function(t,e,n,i,r,o){if(o.length){var a=e.getModel("splitArea").getModel("areaStyle"),s=a.get("color"),l=0;s=s instanceof Array?s:[s];for(var u=[],h=o[0].coord,c=1;c<o.length;c++){var p=l++%s.length;u[p]=u[p]||[],u[p].push(new Wl({shape:{cx:n.cx,cy:n.cy,r0:h,r:o[c].coord,startAngle:0,endAngle:2*Math.PI},silent:!0})),h=o[c].coord}for(c=0;c<u.length;c++)t.add(Du(u[c],{style:T({fill:s[c%s.length]},a.getAreaStyle()),silent:!0}))}}};function aR(t){return t.get("stack")||"__ec_stack_"+t.seriesIndex}function sR(t,e){return e.dim+t.model.componentIndex}function lR(t,e,n){var i={},r=function(t){var e={};P(t,(function(t,n){var i=t.getData(),r=t.coordinateSystem,o=r.getBaseAxis(),a=sR(r,o),s=o.getExtent(),l="category"===o.type?o.getBandWidth():Math.abs(s[1]-s[0])/i.count(),u=e[a]||{bandWidth:l,remainedWidth:l,autoWidthCount:0,categoryGap:"20%",gap:"30%",stacks:{}},h=u.stacks;e[a]=u;var c=aR(t);h[c]||u.autoWidthCount++,h[c]=h[c]||{width:0,maxWidth:0};var p=Zi(t.get("barWidth"),l),d=Zi(t.get("barMaxWidth"),l),f=t.get("barGap"),g=t.get("barCategoryGap");p&&!h[c].width&&(p=Math.min(u.remainedWidth,p),h[c].width=p,u.remainedWidth-=p),d&&(h[c].maxWidth=d),null!=f&&(u.gap=f),null!=g&&(u.categoryGap=g)}));var n={};return P(e,(function(t,e){n[e]={};var i=t.stacks,r=t.bandWidth,o=Zi(t.categoryGap,r),a=Zi(t.gap,1),s=t.remainedWidth,l=t.autoWidthCount,u=(s-o)/(l+(l-1)*a);u=Math.max(u,0),P(i,(function(t,e){var n=t.maxWidth;n&&n<u&&(n=Math.min(n,s),t.width&&(n=Math.min(n,t.width)),s-=n,t.width=n,l--)})),u=(s-o)/(l+(l-1)*a),u=Math.max(u,0);var h,c=0;P(i,(function(t,e){t.width||(t.width=u),h=t,c+=t.width*(1+a)})),h&&(c-=h.width*a);var p=-c/2;P(i,(function(t,i){n[e][i]=n[e][i]||{offset:p,width:t.width},p+=t.width*(1+a)}))})),n}(N(e.getSeriesByType(t),(function(t){return!e.isSeriesFiltered(t)&&t.coordinateSystem&&"polar"===t.coordinateSystem.type})));e.eachSeriesByType(t,(function(t){if("polar"===t.coordinateSystem.type){var e=t.getData(),n=t.coordinateSystem,o=n.getBaseAxis(),a=sR(n,o),s=aR(t),l=r[a][s],u=l.offset,h=l.width,c=n.getOtherAxis(o),p=t.coordinateSystem.cx,d=t.coordinateSystem.cy,f=t.get("barMinHeight")||0,g=t.get("barMinAngle")||0;i[s]=i[s]||[];for(var y=e.mapDimension(c.dim),v=e.mapDimension(o.dim),m=Fm(e,y),_="radius"!==o.dim||!t.get("roundCap",!0),x=c.dataToCoord(0),b=0,w=e.count();b<w;b++){var S=e.get(y,b),M=e.get(v,b),I=S>=0?"p":"n",T=x;m&&(i[s][M]||(i[s][M]={p:x,n:x}),T=i[s][M][I]);var C=void 0,A=void 0,D=void 0,L=void 0;if("radius"===c.dim){var k=c.dataToCoord(S)-x,P=o.dataToCoord(M);Math.abs(k)<f&&(k=(k<0?-1:1)*f),C=T,A=T+k,L=(D=P-u)-h,m&&(i[s][M][I]=A)}else{var O=c.dataToCoord(S,_)-x,R=o.dataToCoord(M);Math.abs(O)<g&&(O=(O<0?-1:1)*g),A=(C=R+u)+h,D=T,L=T+O,m&&(i[s][M][I]=L)}e.setItemLayout(b,{cx:p,cy:d,r0:C,r:A,startAngle:-D*Math.PI/180,endAngle:-L*Math.PI/180})}}}))}var uR={startAngle:90,clockwise:!0,splitNumber:12,axisLabel:{rotate:0}},hR={splitNumber:5},cR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="polar",e}(pf);function pR(t,e){e=e||{};var n=t.coordinateSystem,i=t.axis,r={},o=i.position,a=i.orient,s=n.getRect(),l=[s.x,s.x+s.width,s.y,s.y+s.height],u={horizontal:{top:l[2],bottom:l[3]},vertical:{left:l[0],right:l[1]}};r.position=["vertical"===a?u.vertical[o]:l[0],"horizontal"===a?u.horizontal[o]:l[3]];r.rotation=Math.PI/2*{horizontal:0,vertical:1}[a];r.labelDirection=r.tickDirection=r.nameDirection={top:-1,bottom:1,right:1,left:-1}[o],t.get(["axisTick","inside"])&&(r.tickDirection=-r.tickDirection),Q(e.labelInside,t.get(["axisLabel","inside"]))&&(r.labelDirection=-r.labelDirection);var h=e.rotate;return null==h&&(h=t.get(["axisLabel","rotate"])),r.labelRotation="top"===o?-h:h,r.z2=1,r}var dR=["axisLine","axisTickLabel","axisName"],fR=["splitArea","splitLine"],gR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.axisPointerClass="SingleAxisPointer",n}return n(e,t),e.prototype.render=function(e,n,i,r){var o=this.group;o.removeAll();var a=this._axisGroup;this._axisGroup=new zi;var s=pR(e),l=new hS(e,s);P(dR,l.add,l),o.add(this._axisGroup),o.add(l.getGroup()),P(fR,(function(t){e.get([t,"show"])&&yR[t](this,this.group,this._axisGroup,e)}),this),Wu(a,this._axisGroup,e),t.prototype.render.call(this,e,n,i,r)},e.prototype.remove=function(){TS(this)},e.type="singleAxis",e}(SS),yR={splitLine:function(t,e,n,i){var r=i.axis;if(!r.scale.isBlank()){var o=i.getModel("splitLine"),a=o.getModel("lineStyle"),s=a.get("color");s=s instanceof Array?s:[s];for(var l=i.coordinateSystem.getRect(),u=r.isHorizontal(),h=[],c=0,p=r.getTicksCoords({tickModel:o}),d=[],f=[],g=0;g<p.length;++g){var y=r.toGlobalCoord(p[g].coord);u?(d[0]=y,d[1]=l.y,f[0]=y,f[1]=l.y+l.height):(d[0]=l.x,d[1]=y,f[0]=l.x+l.width,f[1]=y);var v=c++%s.length;h[v]=h[v]||[],h[v].push(new tu({subPixelOptimize:!0,shape:{x1:d[0],y1:d[1],x2:f[0],y2:f[1]},silent:!0}))}var m=a.getLineStyle(["color"]);for(g=0;g<h.length;++g)e.add(Du(h[g],{style:T({stroke:s[g%s.length]},m),silent:!0}))}},splitArea:function(t,e,n,i){IS(t,n,i,i)}},vR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.getCoordSysModel=function(){return this},e.type="singleAxis",e.layoutMode="box",e.defaultOption={left:"5%",top:"5%",right:"5%",bottom:"5%",type:"value",position:"bottom",orient:"horizontal",axisLine:{show:!0,lineStyle:{width:1,type:"solid"}},tooltip:{show:!0},axisTick:{show:!0,length:6,lineStyle:{width:1}},axisLabel:{show:!0,interval:"auto"},splitLine:{show:!0,lineStyle:{type:"dashed",opacity:.2}}},e}(Nc);L(vR,j_.prototype);var mR=function(t){function e(e,n,i,r,o){var a=t.call(this,e,n,i)||this;return a.type=r||"value",a.position=o||"bottom",a}return n(e,t),e.prototype.isHorizontal=function(){var t=this.position;return"top"===t||"bottom"===t},e.prototype.pointToData=function(t,e){return this.coordinateSystem.pointToData(t)[0]},e}(vx),_R=function(){function t(t,e,n){this.type="single",this.dimension="single",this.dimensions=["single"],this.axisPointerEnabled=!0,this.model=t,this._init(t,e,n)}return t.prototype._init=function(t,e,n){var i=this.dimension,r=new mR(i,G_(t),[0,0],t.get("type"),t.get("position")),o="category"===r.type;r.onBand=o&&t.get("boundaryGap"),r.inverse=t.get("inverse"),r.orient=t.get("orient"),t.axis=r,r.model=t,r.coordinateSystem=this,this._axis=r},t.prototype.update=function(t,e){t.eachSeries((function(t){if(t.coordinateSystem===this){var e=t.getData();P(e.mapDimensionsAll(this.dimension),(function(t){this._axis.scale.unionExtentFromData(e,t)}),this),F_(this._axis.scale,this._axis.model)}}),this)},t.prototype.resize=function(t,e){this._rect=Ac({left:t.get("left"),top:t.get("top"),right:t.get("right"),bottom:t.get("bottom"),width:t.get("width"),height:t.get("height")},{width:e.getWidth(),height:e.getHeight()}),this._adjustAxis()},t.prototype.getRect=function(){return this._rect},t.prototype._adjustAxis=function(){var t=this._rect,e=this._axis,n=e.isHorizontal(),i=n?[0,t.width]:[0,t.height],r=e.reverse?1:0;e.setExtent(i[r],i[1-r]),this._updateAxisTransform(e,n?t.x:t.y)},t.prototype._updateAxisTransform=function(t,e){var n=t.getExtent(),i=n[0]+n[1],r=t.isHorizontal();t.toGlobalCoord=r?function(t){return t+e}:function(t){return i-t+e},t.toLocalCoord=r?function(t){return t-e}:function(t){return i-t+e}},t.prototype.getAxis=function(){return this._axis},t.prototype.getBaseAxis=function(){return this._axis},t.prototype.getAxes=function(){return[this._axis]},t.prototype.getTooltipAxes=function(){return{baseAxes:[this.getAxis()],otherAxes:[]}},t.prototype.containPoint=function(t){var e=this.getRect(),n=this.getAxis();return"horizontal"===n.orient?n.contain(n.toLocalCoord(t[0]))&&t[1]>=e.y&&t[1]<=e.y+e.height:n.contain(n.toLocalCoord(t[1]))&&t[0]>=e.y&&t[0]<=e.y+e.height},t.prototype.pointToData=function(t){var e=this.getAxis();return[e.coordToData(e.toLocalCoord(t["horizontal"===e.orient?0:1]))]},t.prototype.dataToPoint=function(t){var e=this.getAxis(),n=this.getRect(),i=[],r="horizontal"===e.orient?0:1;return t instanceof Array&&(t=t[0]),i[r]=e.toGlobalCoord(e.dataToCoord(+t)),i[1-r]=0===r?n.y+n.height/2:n.x+n.width/2,i},t.prototype.convertToPixel=function(t,e,n){return xR(e)===this?this.dataToPoint(n):null},t.prototype.convertFromPixel=function(t,e,n){return xR(e)===this?this.pointToData(n):null},t}();function xR(t){var e=t.seriesModel,n=t.singleAxisModel;return n&&n.coordinateSystem||e&&e.coordinateSystem}var bR={create:function(t,e){var n=[];return t.eachComponent("singleAxis",(function(i,r){var o=new _R(i,t,e);o.name="single_"+r,o.resize(i,e),i.coordinateSystem=o,n.push(o)})),t.eachSeries((function(t){if("singleAxis"===t.get("coordinateSystem")){var e=t.getReferringComponents("singleAxis",Or).models[0];t.coordinateSystem=e&&e.coordinateSystem}})),n},dimensions:_R.prototype.dimensions},wR=["x","y"],SR=["width","height"],MR=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.makeElOption=function(t,e,n,i,r){var o=n.axis,a=o.coordinateSystem,s=CR(a,1-TR(o)),l=a.dataToPoint(e)[0],u=i.get("type");if(u&&"none"!==u){var h=sO(i),c=IR[u](o,l,s);c.style=h,t.graphicKey=c.type,t.pointer=c}cO(e,t,pR(n),n,i,r)},e.prototype.getHandleTransform=function(t,e,n){var i=pR(e,{labelInside:!1});i.labelMargin=n.get(["handle","margin"]);var r=hO(e.axis,t,i);return{x:r[0],y:r[1],rotation:i.rotation+(i.labelDirection<0?Math.PI:0)}},e.prototype.updateHandleTransform=function(t,e,n,i){var r=n.axis,o=r.coordinateSystem,a=TR(r),s=CR(o,a),l=[t.x,t.y];l[a]+=e[a],l[a]=Math.min(s[1],l[a]),l[a]=Math.max(s[0],l[a]);var u=CR(o,1-a),h=(u[1]+u[0])/2,c=[h,h];return c[a]=l[a],{x:l[0],y:l[1],rotation:t.rotation,cursorPoint:c,tooltipOption:{verticalAlign:"middle"}}},e}(eO),IR={line:function(t,e,n){return{type:"Line",subPixelOptimize:!0,shape:pO([e,n[0]],[e,n[1]],TR(t))}},shadow:function(t,e,n){var i=t.getBandWidth(),r=n[1]-n[0];return{type:"Rect",shape:dO([e-i/2,n[0]],[i,r],TR(t))}}};function TR(t){return t.isHorizontal()?0:1}function CR(t,e){var n=t.getRect();return[n[wR[e]],n[wR[e]]+n[SR[e]]]}var AR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="single",e}(pf);var DR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(e,n,i){var r=Pc(e);t.prototype.init.apply(this,arguments),LR(e,r)},e.prototype.mergeOption=function(e){t.prototype.mergeOption.apply(this,arguments),LR(this.option,e)},e.prototype.getCellSize=function(){return this.option.cellSize},e.type="calendar",e.defaultOption={zlevel:0,z:2,left:80,top:60,cellSize:20,orient:"horizontal",splitLine:{show:!0,lineStyle:{color:"#000",width:1,type:"solid"}},itemStyle:{color:"#fff",borderWidth:1,borderColor:"#ccc"},dayLabel:{show:!0,firstDay:0,position:"start",margin:"50%",nameMap:"en",color:"#000"},monthLabel:{show:!0,position:"start",margin:5,align:"center",nameMap:"en",formatter:null,color:"#000"},yearLabel:{show:!0,position:null,margin:30,formatter:null,color:"#ccc",fontFamily:"sans-serif",fontWeight:"bolder",fontSize:20}},e}(Nc);function LR(t,e){var n,i=t.cellSize;1===(n=F(i)?i:t.cellSize=[i,i]).length&&(n[1]=n[0]);var r=O([0,1],(function(t){return function(t,e){return null!=t[Ic[e][0]]||null!=t[Ic[e][1]]&&null!=t[Ic[e][2]]}(e,t)&&(n[t]="auto"),null!=n[t]&&"auto"!==n[t]}));kc(t,e,{type:"box",ignoreSize:r})}var kR={EN:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],CN:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"]},PR={EN:["S","M","T","W","T","F","S"],CN:["日","一","二","三","四","五","六"]},OR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){var i=this.group;i.removeAll();var r=t.coordinateSystem,o=r.getRangeInfo(),a=r.getOrient();this._renderDayRect(t,o,i),this._renderLines(t,o,a,i),this._renderYearText(t,o,a,i),this._renderMonthText(t,a,i),this._renderWeekText(t,o,a,i)},e.prototype._renderDayRect=function(t,e,n){for(var i=t.coordinateSystem,r=t.getModel("itemStyle").getItemStyle(),o=i.getCellWidth(),a=i.getCellHeight(),s=e.start.time;s<=e.end.time;s=i.getNextNDay(s,1).time){var l=i.dataToRect([s],!1).tl,u=new os({shape:{x:l[0],y:l[1],width:o,height:a},cursor:"default",style:r});n.add(u)}},e.prototype._renderLines=function(t,e,n,i){var r=this,o=t.coordinateSystem,a=t.getModel(["splitLine","lineStyle"]).getLineStyle(),s=t.get(["splitLine","show"]),l=a.lineWidth;this._tlpoints=[],this._blpoints=[],this._firstDayOfMonth=[],this._firstDayPoints=[];for(var u=e.start,h=0;u.time<=e.end.time;h++){p(u.formatedDate),0===h&&(u=o.getDateInfo(e.start.y+"-"+e.start.m));var c=u.date;c.setMonth(c.getMonth()+1),u=o.getDateInfo(c)}function p(e){r._firstDayOfMonth.push(o.getDateInfo(e)),r._firstDayPoints.push(o.dataToRect([e],!1).tl);var l=r._getLinePointsOfOneWeek(t,e,n);r._tlpoints.push(l[0]),r._blpoints.push(l[l.length-1]),s&&r._drawSplitline(l,a,i)}p(o.getNextNDay(e.end.time,1).formatedDate),s&&this._drawSplitline(r._getEdgesPoints(r._tlpoints,l,n),a,i),s&&this._drawSplitline(r._getEdgesPoints(r._blpoints,l,n),a,i)},e.prototype._getEdgesPoints=function(t,e,n){var i=[t[0].slice(),t[t.length-1].slice()],r="horizontal"===n?0:1;return i[0][r]=i[0][r]-e/2,i[1][r]=i[1][r]+e/2,i},e.prototype._drawSplitline=function(t,e,n){var i=new $l({z2:20,shape:{points:t},style:e});n.add(i)},e.prototype._getLinePointsOfOneWeek=function(t,e,n){for(var i=t.coordinateSystem,r=i.getDateInfo(e),o=[],a=0;a<7;a++){var s=i.getNextNDay(r.time,a),l=i.dataToRect([s.time],!1);o[2*s.day]=l.tl,o[2*s.day+1]=l["horizontal"===n?"bl":"tr"]}return o},e.prototype._formatterLabel=function(t,e){return"string"==typeof t&&t?(n=t,P(e,(function(t,e){n=n.replace("{"+e+"}",i?gc(t):t)})),n):"function"==typeof t?t(e):e.nameMap;var n,i},e.prototype._yearTextPositionControl=function(t,e,n,i,r){var o=e[0],a=e[1],s=["center","bottom"];"bottom"===i?(a+=r,s=["center","top"]):"left"===i?o-=r:"right"===i?(o+=r,s=["center","top"]):a-=r;var l=0;return"left"!==i&&"right"!==i||(l=Math.PI/2),{rotation:l,x:o,y:a,style:{align:s[0],verticalAlign:s[1]}}},e.prototype._renderYearText=function(t,e,n,i){var r=t.getModel("yearLabel");if(r.get("show")){var o=r.get("margin"),a=r.get("position");a||(a="horizontal"!==n?"top":"left");var s=[this._tlpoints[this._tlpoints.length-1],this._blpoints[0]],l=(s[0][0]+s[1][0])/2,u=(s[0][1]+s[1][1])/2,h="horizontal"===n?0:1,c={top:[l,s[h][1]],bottom:[l,s[1-h][1]],left:[s[1-h][0],u],right:[s[h][0],u]},p=e.start.y;+e.end.y>+e.start.y&&(p=p+"-"+e.end.y);var d=r.get("formatter"),f={start:e.start.y,end:e.end.y,nameMap:p},g=this._formatterLabel(d,f),y=new ls({z2:30,style:nh(r,{text:g})});y.attr(this._yearTextPositionControl(y,c[a],n,a,o)),i.add(y)}},e.prototype._monthTextPositionControl=function(t,e,n,i,r){var o="left",a="top",s=t[0],l=t[1];return"horizontal"===n?(l+=r,e&&(o="center"),"start"===i&&(a="bottom")):(s+=r,e&&(a="middle"),"start"===i&&(o="right")),{x:s,y:l,align:o,verticalAlign:a}},e.prototype._renderMonthText=function(t,e,n){var i=t.getModel("monthLabel");if(i.get("show")){var r=i.get("nameMap"),o=i.get("margin"),a=i.get("position"),s=i.get("align"),l=[this._tlpoints,this._blpoints];H(r)&&(r=kR[r.toUpperCase()]||[]);var u="start"===a?0:1,h="horizontal"===e?0:1;o="start"===a?-o:o;for(var c="center"===s,p=0;p<l[u].length-1;p++){var d=l[u][p].slice(),f=this._firstDayOfMonth[p];if(c){var g=this._firstDayPoints[p];d[h]=(g[h]+l[0][p+1][h])/2}var y=i.get("formatter"),v=r[+f.m-1],m={yyyy:f.y,yy:(f.y+"").slice(2),MM:f.m,M:+f.m,nameMap:v},_=this._formatterLabel(y,m),x=new ls({z2:30,style:I(nh(i,{text:_}),this._monthTextPositionControl(d,c,e,a,o))});n.add(x)}}},e.prototype._weekTextPositionControl=function(t,e,n,i,r){var o="center",a="middle",s=t[0],l=t[1],u="start"===n;return"horizontal"===e?(s=s+i+(u?1:-1)*r[0]/2,o=u?"right":"left"):(l=l+i+(u?1:-1)*r[1]/2,a=u?"bottom":"top"),{x:s,y:l,align:o,verticalAlign:a}},e.prototype._renderWeekText=function(t,e,n,i){var r=t.getModel("dayLabel");if(r.get("show")){var o=t.coordinateSystem,a=r.get("position"),s=r.get("nameMap"),l=r.get("margin"),u=o.getFirstDayOfWeek();H(s)&&(s=PR[s.toUpperCase()]||[]);var h=o.getNextNDay(e.end.time,7-e.lweek).time,c=[o.getCellWidth(),o.getCellHeight()];l=Zi(l,c["horizontal"===n?0:1]),"start"===a&&(h=o.getNextNDay(e.start.time,-(7+e.fweek)).time,l=-l);for(var p=0;p<7;p++){var d,f=o.getNextNDay(h,p),g=o.dataToRect([f.time],!1).center;d=Math.abs((p+u)%7);var y=new ls({z2:30,style:I(nh(r,{text:s[d]}),this._weekTextPositionControl(g,n,a,l,c))});i.add(y)}}},e.type="calendar",e}(pf),RR=864e5,NR=function(){function t(e,n,i){this.type="calendar",this.dimensions=t.dimensions,this.getDimensionsInfo=t.getDimensionsInfo,this._model=e}return t.getDimensionsInfo=function(){return[{name:"time",type:"time"},"value"]},t.prototype.getRangeInfo=function(){return this._rangeInfo},t.prototype.getModel=function(){return this._model},t.prototype.getRect=function(){return this._rect},t.prototype.getCellWidth=function(){return this._sw},t.prototype.getCellHeight=function(){return this._sh},t.prototype.getOrient=function(){return this._orient},t.prototype.getFirstDayOfWeek=function(){return this._firstDayOfWeek},t.prototype.getDateInfo=function(t){var e=(t=rr(t)).getFullYear(),n=t.getMonth()+1,i=n<10?"0"+n:""+n,r=t.getDate(),o=r<10?"0"+r:""+r,a=t.getDay();return{y:e+"",m:i,d:o,day:a=Math.abs((a+7-this.getFirstDayOfWeek())%7),time:t.getTime(),formatedDate:e+"-"+i+"-"+o,date:t}},t.prototype.getNextNDay=function(t,e){return 0===(e=e||0)||(t=new Date(this.getDateInfo(t).time)).setDate(t.getDate()+e),this.getDateInfo(t)},t.prototype.update=function(t,e){this._firstDayOfWeek=+this._model.getModel("dayLabel").get("firstDay"),this._orient=this._model.get("orient"),this._lineWidth=this._model.getModel("itemStyle").getItemStyle().lineWidth||0,this._rangeInfo=this._getRangeInfo(this._initRangeOption());var n=this._rangeInfo.weeks||1,i=["width","height"],r=this._model.getCellSize().slice(),o=this._model.getBoxLayoutParams(),a="horizontal"===this._orient?[n,7]:[7,n];P([0,1],(function(t){u(r,t)&&(o[i[t]]=r[t]*a[t])}));var s={width:e.getWidth(),height:e.getHeight()},l=this._rect=Ac(o,s);function u(t,e){return null!=t[e]&&"auto"!==t[e]}P([0,1],(function(t){u(r,t)||(r[t]=l[i[t]]/a[t])})),this._sw=r[0],this._sh=r[1]},t.prototype.dataToPoint=function(t,e){F(t)&&(t=t[0]),null==e&&(e=!0);var n=this.getDateInfo(t),i=this._rangeInfo,r=n.formatedDate;if(e&&!(n.time>=i.start.time&&n.time<i.end.time+RR))return[NaN,NaN];var o=n.day,a=this._getRangeInfo([i.start.time,r]).nthWeek;return"vertical"===this._orient?[this._rect.x+o*this._sw+this._sw/2,this._rect.y+a*this._sh+this._sh/2]:[this._rect.x+a*this._sw+this._sw/2,this._rect.y+o*this._sh+this._sh/2]},t.prototype.pointToData=function(t){var e=this.pointToDate(t);return e&&e.time},t.prototype.dataToRect=function(t,e){var n=this.dataToPoint(t,e);return{contentShape:{x:n[0]-(this._sw-this._lineWidth)/2,y:n[1]-(this._sh-this._lineWidth)/2,width:this._sw-this._lineWidth,height:this._sh-this._lineWidth},center:n,tl:[n[0]-this._sw/2,n[1]-this._sh/2],tr:[n[0]+this._sw/2,n[1]-this._sh/2],br:[n[0]+this._sw/2,n[1]+this._sh/2],bl:[n[0]-this._sw/2,n[1]+this._sh/2]}},t.prototype.pointToDate=function(t){var e=Math.floor((t[0]-this._rect.x)/this._sw)+1,n=Math.floor((t[1]-this._rect.y)/this._sh)+1,i=this._rangeInfo.range;return"vertical"===this._orient?this._getDateByWeeksAndDay(n,e-1,i):this._getDateByWeeksAndDay(e,n-1,i)},t.prototype.convertToPixel=function(t,e,n){var i=ER(e);return i===this?i.dataToPoint(n):null},t.prototype.convertFromPixel=function(t,e,n){var i=ER(e);return i===this?i.pointToData(n):null},t.prototype.containPoint=function(t){return console.warn("Not implemented."),!1},t.prototype._initRangeOption=function(){var t,e=this._model.get("range");if(F(e)&&1===e.length&&(e=e[0]),F(e))t=e;else{var n=e.toString();if(/^\d{4}$/.test(n)&&(t=[n+"-01-01",n+"-12-31"]),/^\d{4}[\/|-]\d{1,2}$/.test(n)){var i=this.getDateInfo(n),r=i.date;r.setMonth(r.getMonth()+1);var o=this.getNextNDay(r,-1);t=[i.formatedDate,o.formatedDate]}/^\d{4}[\/|-]\d{1,2}[\/|-]\d{1,2}$/.test(n)&&(t=[n,n])}if(!t)return e;var a=this._getRangeInfo(t);return a.start.time>a.end.time&&t.reverse(),t},t.prototype._getRangeInfo=function(t){var e,n=[this.getDateInfo(t[0]),this.getDateInfo(t[1])];n[0].time>n[1].time&&(e=!0,n.reverse());var i=Math.floor(n[1].time/RR)-Math.floor(n[0].time/RR)+1,r=new Date(n[0].time),o=r.getDate(),a=n[1].date.getDate();r.setDate(o+i-1);var s=r.getDate();if(s!==a)for(var l=r.getTime()-n[1].time>0?1:-1;(s=r.getDate())!==a&&(r.getTime()-n[1].time)*l>0;)i-=l,r.setDate(s-l);var u=Math.floor((i+n[0].day+6)/7),h=e?1-u:u-1;return e&&n.reverse(),{range:[n[0].formatedDate,n[1].formatedDate],start:n[0],end:n[1],allDay:i,weeks:u,nthWeek:h,fweek:n[0].day,lweek:n[1].day}},t.prototype._getDateByWeeksAndDay=function(t,e,n){var i=this._getRangeInfo(n);if(t>i.weeks||0===t&&e<i.fweek||t===i.weeks&&e>i.lweek)return null;var r=7*(t-1)-i.fweek+e,o=new Date(i.start.time);return o.setDate(+i.start.d+r),this.getDateInfo(o)},t.create=function(e,n){var i=[];return e.eachComponent("calendar",(function(r){var o=new t(r,e,n);i.push(o),r.coordinateSystem=o})),e.eachSeries((function(t){"calendar"===t.get("coordinateSystem")&&(t.coordinateSystem=i[t.get("calendarIndex")||0])})),i},t.dimensions=["time","value"],t}();function ER(t){var e=t.calendarModel,n=t.seriesModel;return e?e.coordinateSystem:n?n.coordinateSystem:null}var zR=Lr(),BR={path:null,compoundPath:null,group:zi,image:Ja,text:ls},VR=function(t){var e=t.graphic;F(e)?e[0]&&e[0].elements?t.graphic=[t.graphic[0]]:t.graphic=[{elements:e}]:e&&!e.elements&&(t.graphic=[{elements:[e]}])},FR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.mergeOption=function(e,n){var i=this.option.elements;this.option.elements=null,t.prototype.mergeOption.call(this,e,n),this.option.elements=i},e.prototype.optionUpdated=function(t,e){var n=this.option,i=(e?n:t).elements,r=n.elements=e?[]:n.elements,o=[];this._flatten(i,o,null);var a=Sr(r,o,"normalMerge"),s=this._elOptionsToUpdate=[];P(a,(function(t,e){var n=t.newOption;n&&(s.push(n),function(t,e){var n=t.existing;if(e.id=t.keyInfo.id,!e.type&&n&&(e.type=n.type),null==e.parentId){var i=e.parentOption;i?e.parentId=i.id:n&&(e.parentId=n.parentId)}e.parentOption=null}(t,n),function(t,e,n){var i=I({},n),r=t[e],o=n.$action||"merge";if("merge"===o){if(r)S(r,i,!0),kc(r,i,{ignoreSize:!0}),Oc(n,r);else t[e]=i}else"replace"===o?t[e]=i:"remove"===o&&r&&(t[e]=null)}(r,e,n),function(t,e){if(!t)return;if(t.hv=e.hv=[YR(e,["left","right"]),YR(e,["top","bottom"])],"group"===t.type){var n=t,i=e;null==n.width&&(n.width=i.width=0),null==n.height&&(n.height=i.height=0)}}(r[e],n))}),this);for(var l=r.length-1;l>=0;l--)null==r[l]?r.splice(l,1):delete r[l].$action},e.prototype._flatten=function(t,e,n){P(t,(function(t){if(t){n&&(t.parentOption=n),e.push(t);var i=t.children;"group"===t.type&&i&&this._flatten(i,e,t),delete t.children}}),this)},e.prototype.useElOptionsToUpdate=function(){var t=this._elOptionsToUpdate;return this._elOptionsToUpdate=null,t},e.type="graphic",e.defaultOption={elements:[]},e}(Nc),GR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(){this._elMap=ht()},e.prototype.render=function(t,e,n){t!==this._lastGraphicModel&&this._clear(),this._lastGraphicModel=t,this._updateElements(t),this._relocate(t,n)},e.prototype._updateElements=function(t){var e=t.useElOptionsToUpdate();if(e){var n=this._elMap,i=this.group;P(e,(function(e){var r=Tr(e.id,null),o=null!=r?n.get(r):null,a=Tr(e.parentId,null),s=null!=a?n.get(a):i,l=e.type,u=e.style;"text"===l&&u&&e.hv&&e.hv[1]&&(u.textVerticalAlign=u.textBaseline=u.verticalAlign=u.align=null);var h=e.textContent,c=e.textConfig;if(u&&Sk(u,l,!!c,!!h)){var p=Mk(u,l,!0);!c&&p.textConfig&&(c=e.textConfig=p.textConfig),!h&&p.textContent&&(h=p.textContent)}var d=function(t){return t=I({},t),P(["id","parentId","$action","hv","bounding","textContent"].concat(Mc),(function(e){delete t[e]})),t}(e);var f=e.$action||"merge";"merge"===f?o?o.attr(d):HR(r,s,d,n):"replace"===f?(WR(o,n),HR(r,s,d,n)):"remove"===f&&WR(o,n);var g=n.get(r);if(g&&h)if("merge"===f){var y=g.getTextContent();y?y.attr(h):g.setTextContent(new ls(h))}else"replace"===f&&g.setTextContent(new ls(h));if(g){var v=zR(g);v.__ecGraphicWidthOption=e.width,v.__ecGraphicHeightOption=e.height,function(t,e,n){var i=ys(t).eventData;t.silent||t.ignore||i||(i=ys(t).eventData={componentType:"graphic",componentIndex:e.componentIndex,name:t.name});i&&(i.info=n.info)}(g,t,e)}}))}},e.prototype._relocate=function(t,e){for(var n=t.option.elements,i=this.group,r=this._elMap,o=e.getWidth(),a=e.getHeight(),s=0;s<n.length;s++){if((d=null!=(p=Tr((c=n[s]).id,null))?r.get(p):null)&&d.isGroup){var l=(f=d.parent)===i,u=zR(d),h=zR(f);u.__ecGraphicWidth=Zi(u.__ecGraphicWidthOption,l?o:h.__ecGraphicWidth)||0,u.__ecGraphicHeight=Zi(u.__ecGraphicHeightOption,l?a:h.__ecGraphicHeight)||0}}for(s=n.length-1;s>=0;s--){var c,p,d;if(d=null!=(p=Tr((c=n[s]).id,null))?r.get(p):null){var f=d.parent;h=zR(f);Dc(d,c,f===i?{width:o,height:a}:{width:h.__ecGraphicWidth,height:h.__ecGraphicHeight},null,{hv:c.hv,boundingMode:c.bounding})}}},e.prototype._clear=function(){var t=this._elMap;t.each((function(e){WR(e,t)})),this._elMap=ht()},e.prototype.dispose=function(){this._clear()},e.type="graphic",e}(pf);function HR(t,e,n,i){var r=n.type;var o=dt(BR,r)?BR[r]:Iu(r);var a=new o(n);e.add(a),i.set(t,a),zR(a).__ecGraphicId=t}function WR(t,e){var n=t&&t.parent;n&&("group"===t.type&&t.traverse((function(t){WR(t,e)})),e.removeKey(zR(t).__ecGraphicId),n.remove(t))}function YR(t,e){var n;return P(e,(function(e){null!=t[e]&&"auto"!==t[e]&&(n=!0)})),n}var XR=["x","y","radius","angle","single"],UR=["cartesian2d","polar","singleAxis"];function ZR(t){return t+"Axis"}function jR(t,e){var n,i=ht(),r=[],o=ht();t.eachComponent({mainType:"dataZoom",query:e},(function(t){o.get(t.uid)||s(t)}));do{n=!1,t.eachComponent("dataZoom",a)}while(n);function a(t){!o.get(t.uid)&&function(t){var e=!1;return t.eachTargetAxis((function(t,n){var r=i.get(t);r&&r[n]&&(e=!0)})),e}(t)&&(s(t),n=!0)}function s(t){o.set(t.uid,!0),r.push(t),t.eachTargetAxis((function(t,e){(i.get(t)||i.set(t,[]))[e]=!0}))}return r}function qR(t){var e=t.ecModel,n={infoList:[],infoMap:ht()};return t.eachTargetAxis((function(t,i){var r=e.getComponent(ZR(t),i);if(r){var o=r.getCoordSysModel();if(o){var a=o.uid,s=n.infoMap.get(a);s||(s={model:o,axisModels:[]},n.infoList.push(s),n.infoMap.set(a,s)),s.axisModels.push(r)}}})),n}var KR=function(){function t(){this.indexList=[],this.indexMap=[]}return t.prototype.add=function(t){this.indexMap[t]||(this.indexList.push(t),this.indexMap[t]=!0)},t}(),$R=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._autoThrottle=!0,n._noTarget=!0,n._rangePropMode=["percent","percent"],n}return n(e,t),e.prototype.init=function(t,e,n){var i=JR(t);this.settledOption=i,this.mergeDefaultAndTheme(t,n),this._doInit(i)},e.prototype.mergeOption=function(t){var e=JR(t);S(this.option,t,!0),S(this.settledOption,e,!0),this._doInit(e)},e.prototype._doInit=function(t){var e=this.option;this._setDefaultThrottle(t),this._updateRangeUse(t);var n=this.settledOption;P([["start","startValue"],["end","endValue"]],(function(t,i){"value"===this._rangePropMode[i]&&(e[t[0]]=n[t[0]]=null)}),this),this._resetTarget()},e.prototype._resetTarget=function(){var t=this.get("orient",!0),e=this._targetAxisInfoMap=ht();this._fillSpecifiedTargetAxis(e)?this._orient=t||this._makeAutoOrientByTargetAxis():(this._orient=t||"horizontal",this._fillAutoTargetAxisByOrient(e,this._orient)),this._noTarget=!0,e.each((function(t){t.indexList.length&&(this._noTarget=!1)}),this)},e.prototype._fillSpecifiedTargetAxis=function(t){var e=!1;return P(XR,(function(n){var i=this.getReferringComponents(ZR(n),Rr);if(i.specified){e=!0;var r=new KR;P(i.models,(function(t){r.add(t.componentIndex)})),t.set(n,r)}}),this),e},e.prototype._fillAutoTargetAxisByOrient=function(t,e){var n=this.ecModel,i=!0;if(i){var r="vertical"===e?"y":"x";o(n.findComponents({mainType:r+"Axis"}),r)}i&&o(n.findComponents({mainType:"singleAxis",filter:function(t){return t.get("orient",!0)===e}}),"single");function o(e,n){var r=e[0];if(r){var o=new KR;if(o.add(r.componentIndex),t.set(n,o),i=!1,"x"===n||"y"===n){var a=r.getReferringComponents("grid",Or).models[0];a&&P(e,(function(t){r.componentIndex!==t.componentIndex&&a===t.getReferringComponents("grid",Or).models[0]&&o.add(t.componentIndex)}))}}}i&&P(XR,(function(e){if(i){var r=n.findComponents({mainType:ZR(e),filter:function(t){return"category"===t.get("type",!0)}});if(r[0]){var o=new KR;o.add(r[0].componentIndex),t.set(e,o),i=!1}}}),this)},e.prototype._makeAutoOrientByTargetAxis=function(){var t;return this.eachTargetAxis((function(e){!t&&(t=e)}),this),"y"===t?"vertical":"horizontal"},e.prototype._setDefaultThrottle=function(t){if(t.hasOwnProperty("throttle")&&(this._autoThrottle=!1),this._autoThrottle){var e=this.ecModel.option;this.option.throttle=e.animation&&e.animationDurationUpdate>0?100:20}},e.prototype._updateRangeUse=function(t){var e=this._rangePropMode,n=this.get("rangeMode");P([["start","startValue"],["end","endValue"]],(function(i,r){var o=null!=t[i[0]],a=null!=t[i[1]];o&&!a?e[r]="percent":!o&&a?e[r]="value":n?e[r]=n[r]:o&&(e[r]="percent")}))},e.prototype.noTarget=function(){return this._noTarget},e.prototype.getFirstTargetAxisModel=function(){var t;return this.eachTargetAxis((function(e,n){null==t&&(t=this.ecModel.getComponent(ZR(e),n))}),this),t},e.prototype.eachTargetAxis=function(t,e){this._targetAxisInfoMap.each((function(n,i){P(n.indexList,(function(n){t.call(e,i,n)}))}))},e.prototype.getAxisProxy=function(t,e){var n=this.getAxisModel(t,e);if(n)return n.__dzAxisProxy},e.prototype.getAxisModel=function(t,e){var n=this._targetAxisInfoMap.get(t);if(n&&n.indexMap[e])return this.ecModel.getComponent(ZR(t),e)},e.prototype.setRawRange=function(t){var e=this.option,n=this.settledOption;P([["start","startValue"],["end","endValue"]],(function(i){null==t[i[0]]&&null==t[i[1]]||(e[i[0]]=n[i[0]]=t[i[0]],e[i[1]]=n[i[1]]=t[i[1]])}),this),this._updateRangeUse(t)},e.prototype.setCalculatedRange=function(t){var e=this.option;P(["start","startValue","end","endValue"],(function(n){e[n]=t[n]}))},e.prototype.getPercentRange=function(){var t=this.findRepresentativeAxisProxy();if(t)return t.getDataPercentWindow()},e.prototype.getValueRange=function(t,e){if(null!=t||null!=e)return this.getAxisProxy(t,e).getDataValueWindow();var n=this.findRepresentativeAxisProxy();return n?n.getDataValueWindow():void 0},e.prototype.findRepresentativeAxisProxy=function(t){if(t)return t.__dzAxisProxy;for(var e,n=this._targetAxisInfoMap.keys(),i=0;i<n.length;i++)for(var r=n[i],o=this._targetAxisInfoMap.get(r),a=0;a<o.indexList.length;a++){var s=this.getAxisProxy(r,o.indexList[a]);if(s.hostedBy(this))return s;e||(e=s)}return e},e.prototype.getRangePropMode=function(){return this._rangePropMode.slice()},e.prototype.getOrient=function(){return this._orient},e.type="dataZoom",e.dependencies=["xAxis","yAxis","radiusAxis","angleAxis","singleAxis","series","toolbox"],e.defaultOption={zlevel:0,z:4,filterMode:"filter",start:0,end:100},e}(Nc);function JR(t){var e={};return P(["start","end","startValue","endValue","throttle"],(function(n){t.hasOwnProperty(n)&&(e[n]=t[n])})),e}var QR=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="dataZoom.select",e}($R),tN=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n,i){this.dataZoomModel=t,this.ecModel=e,this.api=n},e.type="dataZoom",e}(pf),eN=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="dataZoom.select",e}(tN),nN=P,iN=qi,rN=function(){function t(t,e,n,i){this._dimName=t,this._axisIndex=e,this.ecModel=i,this._dataZoomModel=n}return t.prototype.hostedBy=function(t){return this._dataZoomModel===t},t.prototype.getDataValueWindow=function(){return this._valueWindow.slice()},t.prototype.getDataPercentWindow=function(){return this._percentWindow.slice()},t.prototype.getTargetSeriesModels=function(){var t=[];return this.ecModel.eachSeries((function(e){if(function(t){var e=t.get("coordinateSystem");return A(UR,e)>=0}(e)){var n=ZR(this._dimName),i=e.getReferringComponents(n,Or).models[0];i&&this._axisIndex===i.componentIndex&&t.push(e)}}),this),t},t.prototype.getAxisModel=function(){return this.ecModel.getComponent(this._dimName+"Axis",this._axisIndex)},t.prototype.getMinMaxSpan=function(){return w(this._minMaxSpan)},t.prototype.calculateDataWindow=function(t){var e,n=this._dataExtent,i=this.getAxisModel().axis.scale,r=this._dataZoomModel.getRangePropMode(),o=[0,100],a=[],s=[];nN(["start","end"],(function(l,u){var h=t[l],c=t[l+"Value"];"percent"===r[u]?(null==h&&(h=o[u]),c=i.parse(Ui(h,o,n))):(e=!0,h=Ui(c=null==c?n[u]:i.parse(c),n,o)),s[u]=c,a[u]=h})),iN(s),iN(a);var l=this._minMaxSpan;function u(t,e,n,r,o){var a=o?"Span":"ValueSpan";sA(0,t,n,"all",l["min"+a],l["max"+a]);for(var s=0;s<2;s++)e[s]=Ui(t[s],n,r,!0),o&&(e[s]=i.parse(e[s]))}return e?u(s,a,n,o,!1):u(a,s,o,n,!0),{valueWindow:s,percentWindow:a}},t.prototype.reset=function(t){if(t===this._dataZoomModel){var e=this.getTargetSeriesModels();this._dataExtent=function(t,e,n){var i=[1/0,-1/0];nN(n,(function(t){!function(t,e,n){e&&P(Z_(e,n),(function(n){var i=e.getApproximateExtent(n);i[0]<t[0]&&(t[0]=i[0]),i[1]>t[1]&&(t[1]=i[1])}))}(i,t.getData(),e)}));var r=t.getAxisModel(),o=z_(r.axis.scale,r,i).calculate();return[o.min,o.max]}(this,this._dimName,e),this._updateMinMaxSpan();var n=this.calculateDataWindow(t.settledOption);this._valueWindow=n.valueWindow,this._percentWindow=n.percentWindow,this._setAxisModel()}},t.prototype.filterData=function(t,e){if(t===this._dataZoomModel){var n=this._dimName,i=this.getTargetSeriesModels(),r=t.get("filterMode"),o=this._valueWindow;"none"!==r&&nN(i,(function(t){var e=t.getData(),i=e.mapDimensionsAll(n);i.length&&("weakFilter"===r?e.filterSelf((function(t){for(var n,r,a,s=0;s<i.length;s++){var l=e.get(i[s],t),u=!isNaN(l),h=l<o[0],c=l>o[1];if(u&&!h&&!c)return!0;u&&(a=!0),h&&(n=!0),c&&(r=!0)}return a&&n&&r})):nN(i,(function(n){if("empty"===r)t.setData(e=e.map(n,(function(t){return function(t){return t>=o[0]&&t<=o[1]}(t)?t:NaN})));else{var i={};i[n]=o,e.selectRange(i)}})),nN(i,(function(t){e.setApproximateExtent(o,t)})))}))}},t.prototype._updateMinMaxSpan=function(){var t=this._minMaxSpan={},e=this._dataZoomModel,n=this._dataExtent;nN(["min","max"],(function(i){var r=e.get(i+"Span"),o=e.get(i+"ValueSpan");null!=o&&(o=this.getAxisModel().axis.scale.parse(o)),null!=o?r=Ui(n[0]+o,n,[0,100],!0):null!=r&&(o=Ui(r,[0,100],n,!0)-n[0]),t[i+"Span"]=r,t[i+"ValueSpan"]=o}),this)},t.prototype._setAxisModel=function(){var t=this.getAxisModel(),e=this._percentWindow,n=this._valueWindow;if(e){var i=Ji(n,[0,500]);i=Math.min(i,20);var r=t.axis.scale.rawExtentInfo;0!==e[0]&&r.setDeterminedMinMax("min",+n[0].toFixed(i)),100!==e[1]&&r.setDeterminedMinMax("max",+n[1].toFixed(i)),r.freeze()}},t}();var oN={getTargetSeries:function(t){function e(e){t.eachComponent("dataZoom",(function(n){n.eachTargetAxis((function(i,r){var o=t.getComponent(ZR(i),r);e(i,r,o,n)}))}))}e((function(t,e,n,i){n.__dzAxisProxy=null}));var n=[];e((function(e,i,r,o){r.__dzAxisProxy||(r.__dzAxisProxy=new rN(e,i,o,t),n.push(r.__dzAxisProxy))}));var i=ht();return P(n,(function(t){P(t.getTargetSeriesModels(),(function(t){i.set(t.uid,t)}))})),i},overallReset:function(t,e){t.eachComponent("dataZoom",(function(t){t.eachTargetAxis((function(e,n){t.getAxisProxy(e,n).reset(t)})),t.eachTargetAxis((function(n,i){t.getAxisProxy(n,i).filterData(t,e)}))})),t.eachComponent("dataZoom",(function(t){var e=t.findRepresentativeAxisProxy();if(e){var n=e.getDataPercentWindow(),i=e.getDataValueWindow();t.setCalculatedRange({start:n[0],end:n[1],startValue:i[0],endValue:i[1]})}}))}};var aN=!1;function sN(t){aN||(aN=!0,t.registerProcessor(t.PRIORITY.PROCESSOR.FILTER,oN),function(t){t.registerAction("dataZoom",(function(t,e){P(jR(e,t),(function(e){e.setRawRange({start:t.start,end:t.end,startValue:t.startValue,endValue:t.endValue})}))}))}(t),t.registerSubTypeDefaulter("dataZoom",(function(){return"slider"})))}function lN(t){t.registerComponentModel(QR),t.registerComponentView(eN),sN(t)}var uN=function(){},hN={};function cN(t,e){hN[t]=e}function pN(t){return hN[t]}var dN=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.optionUpdated=function(){t.prototype.optionUpdated.apply(this,arguments);var e=this.ecModel;P(this.option.feature,(function(t,n){var i=pN(n);i&&(i.getDefaultOption&&(i.defaultOption=i.getDefaultOption(e)),S(t,i.defaultOption))}))},e.type="toolbox",e.layoutMode={type:"box",ignoreSize:!0},e.defaultOption={show:!0,z:6,zlevel:0,orient:"horizontal",left:"right",top:"top",backgroundColor:"transparent",borderColor:"#ccc",borderRadius:0,borderWidth:0,padding:5,itemSize:15,itemGap:8,showTitle:!0,iconStyle:{borderColor:"#666",color:"none"},emphasis:{iconStyle:{borderColor:"#3E98C5"}},tooltip:{show:!1}},e}(Nc);function fN(t,e){var n=pc(e.get("padding")),i=e.getItemStyle(["color","opacity"]);return i.fill=e.get("backgroundColor"),t=new os({shape:{x:t.x-n[3],y:t.y-n[0],width:t.width+n[1]+n[3],height:t.height+n[0]+n[2],r:e.get("borderRadius")},style:i,silent:!0,z2:-1})}var gN=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.render=function(t,e,n,i){var r=this.group;if(r.removeAll(),t.get("show")){var o=+t.get("itemSize"),a=t.get("feature")||{},s=this._features||(this._features={}),l=[];P(a,(function(t,e){l.push(e)})),new rm(this._featureNames||[],l).add(u).update(u).remove(V(u,null)).execute(),this._featureNames=l,function(t,e,n){var i=e.getBoxLayoutParams(),r=e.get("padding"),o={width:n.getWidth(),height:n.getHeight()},a=Ac(i,o,r);Cc(e.get("orient"),t,e.get("itemGap"),a.width,a.height),Dc(t,i,o,r)}(r,t,n),r.add(fN(r.getBoundingRect(),t)),r.eachChild((function(t){var e=t.__title,i=t.ensureState("emphasis"),a=i.textConfig||(i.textConfig={}),s=t.getTextContent(),l=s&&s.states.emphasis;if(l&&!G(l)&&e){var u=l.style||(l.style={}),h=Fn(e,ls.makeFont(u)),c=t.x+r.x,p=!1;t.y+r.y+o+h.height>n.getHeight()&&(a.position="top",p=!0);var d=p?-5-h.height:o+8;c+h.width/2>n.getWidth()?(a.position=["100%",d],u.align="right"):c-h.width/2<0&&(a.position=[0,d],u.align="left")}}))}function u(u,h){var c,p=l[u],d=l[h],f=a[p],g=new Sh(f,t,t.ecModel);if(i&&null!=i.newTitle&&i.featureName===p&&(f.title=i.newTitle),p&&!d){if(function(t){return 0===t.indexOf("my")}(p))c={onclick:g.option.onclick,featureName:p};else{var y=pN(p);if(!y)return;c=new y}s[p]=c}else if(!(c=s[d]))return;if(c.uid=Ih("toolbox-feature"),c.model=g,c.ecModel=e,c.api=n,c instanceof uN){if(!p&&d)return void(c.dispose&&c.dispose(e,n));if(!g.get("show")||c.unusable)return void(c.remove&&c.remove(e,n))}!function(i,a,s){var l,u,h=i.getModel("iconStyle"),c=i.getModel(["emphasis","iconStyle"]),p=a instanceof uN&&a.getIcons?a.getIcons():i.get("icon"),d=i.get("title")||{};"string"==typeof p?(l={})[s]=p:l=p;"string"==typeof d?(u={})[s]=d:u=d;var f=i.iconPaths={};P(l,(function(s,l){var p=Uu(s,{},{x:-o/2,y:-o/2,width:o,height:o});p.setStyle(h.getItemStyle()),p.ensureState("emphasis").style=c.getItemStyle();var d=new ls({style:{text:u[l],align:c.get("textAlign"),borderRadius:c.get("textBorderRadius"),padding:c.get("textPadding"),fill:null},ignore:!0});p.setTextContent(d);var g=t.getModel("tooltip");g&&g.get("show")&&(p.tooltip=I({content:u[l],formatter:g.get("formatter",!0)||function(){return u[l]},formatterParams:{componentType:"toolbox",name:l,title:u[l],$vars:["name","title"]},position:g.get("position",!0)||"bottom"},g.option)),p.__title=u[l],p.on("mouseover",(function(){var e=c.getItemStyle(),n="vertical"===t.get("orient")?null==t.get("right")?"right":"left":null==t.get("bottom")?"bottom":"top";d.setStyle({fill:c.get("textFill")||e.fill||e.stroke||"#000",backgroundColor:c.get("textBackgroundColor")}),p.setTextConfig({position:c.get("textPosition")||n}),d.ignore=!t.get("showTitle"),Hs(this)})).on("mouseout",(function(){"emphasis"!==i.get(["iconStatus",l])&&Ws(this),d.hide()})),("emphasis"===i.get(["iconStatus",l])?Hs:Ws)(p),r.add(p),p.on("click",B(a.onclick,a,e,n,l)),f[l]=p}))}(g,c,p),g.setIconStatus=function(t,e){var n=this.option,i=this.iconPaths;n.iconStatus=n.iconStatus||{},n.iconStatus[t]=e,i[t]&&("emphasis"===e?Hs:Ws)(i[t])},c instanceof uN&&c.render&&c.render(g,e,n,i)}},e.prototype.updateView=function(t,e,n,i){P(this._features,(function(t){t instanceof uN&&t.updateView&&t.updateView(t.model,e,n,i)}))},e.prototype.remove=function(t,e){P(this._features,(function(n){n instanceof uN&&n.remove&&n.remove(t,e)})),this.group.removeAll()},e.prototype.dispose=function(t,e){P(this._features,(function(n){n instanceof uN&&n.dispose&&n.dispose(t,e)}))},e.type="toolbox",e}(pf);var yN=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.onclick=function(t,e){var n=this.model,i=n.get("name")||t.get("title.0.text")||"echarts",r="svg"===e.getZr().painter.getType(),o=r?"svg":n.get("type",!0)||"png",s=e.getConnectedDataURL({type:o,backgroundColor:n.get("backgroundColor",!0)||t.get("backgroundColor")||"#fff",connectedBackgroundColor:n.get("connectedBackgroundColor"),excludeComponents:n.get("excludeComponents"),pixelRatio:n.get("pixelRatio")});if("function"!=typeof MouseEvent||!a.browser.newEdge&&(a.browser.ie||a.browser.edge))if(window.navigator.msSaveOrOpenBlob||r){var l=s.split(","),u=l[0].indexOf("base64")>-1,h=r?decodeURIComponent(l[1]):l[1];u&&(h=atob(h));var c=i+"."+o;if(window.navigator.msSaveOrOpenBlob){for(var p=h.length,d=new Uint8Array(p);p--;)d[p]=h.charCodeAt(p);var f=new Blob([d]);window.navigator.msSaveOrOpenBlob(f,c)}else{var g=document.createElement("iframe");document.body.appendChild(g);var y=g.contentWindow,v=y.document;v.open("image/svg+xml","replace"),v.write(h),v.close(),y.focus(),v.execCommand("SaveAs",!0,c),document.body.removeChild(g)}}else{var m=n.get("lang"),_='<body style="margin:0;"><img src="'+s+'" style="max-width:100%;" title="'+(m&&m[0]||"")+'" /></body>',x=window.open();x.document.write(_),x.document.title=i}else{var b=document.createElement("a");b.download=i+"."+o,b.target="_blank",b.href=s;var w=new MouseEvent("click",{view:document.defaultView,bubbles:!0,cancelable:!1});b.dispatchEvent(w)}},e.getDefaultOption=function(t){return{show:!0,icon:"M4.7,22.9L29.3,45.5L54.7,23.4M4.6,43.6L4.6,58L53.8,58L53.8,43.6M29.2,45.1L29.2,0",title:t.getLocale(["toolbox","saveAsImage","title"]),type:"png",connectedBackgroundColor:"#fff",name:"",excludeComponents:["toolbox"],lang:t.getLocale(["toolbox","saveAsImage","lang"])}},e}(uN);yN.prototype.unusable=!a.canvasSupported;var vN="__ec_magicType_stack__",mN=[["line","bar"],["stack"]],_N=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.getIcons=function(){var t=this.model,e=t.get("icon"),n={};return P(t.get("type"),(function(t){e[t]&&(n[t]=e[t])})),n},e.getDefaultOption=function(t){return{show:!0,type:[],icon:{line:"M4.1,28.9h7.1l9.3-22l7.4,38l9.7-19.7l3,12.8h14.9M4.1,58h51.4",bar:"M6.7,22.9h10V48h-10V22.9zM24.9,13h10v35h-10V13zM43.2,2h10v46h-10V2zM3.1,58h53.7",stack:"M8.2,38.4l-8.4,4.1l30.6,15.3L60,42.5l-8.1-4.1l-21.5,11L8.2,38.4z M51.9,30l-8.1,4.2l-13.4,6.9l-13.9-6.9L8.2,30l-8.4,4.2l8.4,4.2l22.2,11l21.5-11l8.1-4.2L51.9,30z M51.9,21.7l-8.1,4.2L35.7,30l-5.3,2.8L24.9,30l-8.4-4.1l-8.3-4.2l-8.4,4.2L8.2,30l8.3,4.2l13.9,6.9l13.4-6.9l8.1-4.2l8.1-4.1L51.9,21.7zM30.4,2.2L-0.2,17.5l8.4,4.1l8.3,4.2l8.4,4.2l5.5,2.7l5.3-2.7l8.1-4.2l8.1-4.2l8.1-4.1L30.4,2.2z"},title:t.getLocale(["toolbox","magicType","title"]),option:{},seriesIndex:{}}},e.prototype.onclick=function(t,e,n){var i=this.model,r=i.get(["seriesIndex",n]);if(xN[n]){var o,a={series:[]};P(mN,(function(t){A(t,n)>=0&&P(t,(function(t){i.setIconStatus(t,"normal")}))})),i.setIconStatus(n,"emphasis"),t.eachComponent({mainType:"series",query:null==r?null:{seriesIndex:r}},(function(t){var e=t.subType,r=t.id,o=xN[n](e,r,t,i);o&&(T(o,t.option),a.series.push(o));var s=t.coordinateSystem;if(s&&"cartesian2d"===s.type&&("line"===n||"bar"===n)){var l=s.getAxesByScale("ordinal")[0];if(l){var u=l.dim+"Axis",h=t.getReferringComponents(u,Or).models[0].componentIndex;a[u]=a[u]||[];for(var c=0;c<=h;c++)a[u][h]=a[u][h]||{};a[u][h].boundaryGap="bar"===n}}})),"stack"===n&&(o=S({stack:i.option.title.tiled,tiled:i.option.title.stack},i.option.title)),e.dispatchAction({type:"changeMagicType",currentType:n,newOption:a,newTitle:o,featureName:"magicType"})}},e}(uN),xN={line:function(t,e,n,i){if("bar"===t)return S({id:e,type:"line",data:n.get("data"),stack:n.get("stack"),markPoint:n.get("markPoint"),markLine:n.get("markLine")},i.get(["option","line"])||{},!0)},bar:function(t,e,n,i){if("line"===t)return S({id:e,type:"bar",data:n.get("data"),stack:n.get("stack"),markPoint:n.get("markPoint"),markLine:n.get("markLine")},i.get(["option","bar"])||{},!0)},stack:function(t,e,n,i){var r=n.get("stack")===vN;if("line"===t||"bar"===t)return i.setIconStatus("stack",r?"normal":"emphasis"),S({id:e,stack:r?"":vN},i.get(["option","stack"])||{},!0)}};Yv({type:"changeMagicType",event:"magicTypeChanged",update:"prepareAndUpdate"},(function(t,e){e.mergeOption(t.newOption)}));var bN=new Array(60).join("-"),wN="\t";function SN(t){return t.replace(/^\s\s*/,"").replace(/\s\s*$/,"")}var MN=new RegExp("[\t]+","g");function IN(t,e){var n=t.split(new RegExp("\n*"+bN+"\n*","g")),i={series:[]};return P(n,(function(t,n){if(function(t){if(t.slice(0,t.indexOf("\n")).indexOf(wN)>=0)return!0}(t)){var r=function(t){for(var e=t.split(/\n+/g),n=[],i=O(SN(e.shift()).split(MN),(function(t){return{name:t,data:[]}})),r=0;r<e.length;r++){var o=SN(e[r]).split(MN);n.push(o.shift());for(var a=0;a<o.length;a++)i[a]&&(i[a].data[r]=o[a])}return{series:i,categories:n}}(t),o=e[n],a=o.axisDim+"Axis";o&&(i[a]=i[a]||[],i[a][o.axisIndex]={data:r.categories},i.series=i.series.concat(r.series))}else{r=function(t){for(var e=t.split(/\n+/g),n=SN(e.shift()),i=[],r=0;r<e.length;r++){var o=SN(e[r]);if(o){var a=o.split(MN),s="",l=void 0,u=!1;isNaN(a[0])?(u=!0,s=a[0],a=a.slice(1),i[r]={name:s,value:[]},l=i[r].value):l=i[r]=[];for(var h=0;h<a.length;h++)l.push(+a[h]);1===l.length&&(u?i[r].value=l[0]:i[r]=l[0])}}return{name:n,data:i}}(t);i.series.push(r)}})),i}var TN=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.onclick=function(t,e){var n=e.getDom(),i=this.model;this._dom&&n.removeChild(this._dom);var r=document.createElement("div");r.style.cssText="position:absolute;left:5px;top:5px;bottom:5px;right:5px;",r.style.backgroundColor=i.get("backgroundColor")||"#fff";var o=document.createElement("h4"),a=i.get("lang")||[];o.innerHTML=a[0]||i.get("title"),o.style.cssText="margin: 10px 20px;",o.style.color=i.get("textColor");var s=document.createElement("div"),l=document.createElement("textarea");s.style.cssText="display:block;width:100%;overflow:auto;";var u=i.get("optionToContent"),h=i.get("contentToOption"),c=function(t){var e,n,i,r=function(t){var e={},n=[],i=[];return t.eachRawSeries((function(t){var r=t.coordinateSystem;if(!r||"cartesian2d"!==r.type&&"polar"!==r.type)n.push(t);else{var o=r.getBaseAxis();if("category"===o.type){var a=o.dim+"_"+o.index;e[a]||(e[a]={categoryAxis:o,valueAxis:r.getOtherAxis(o),series:[]},i.push({axisDim:o.dim,axisIndex:o.index})),e[a].series.push(t)}else n.push(t)}})),{seriesGroupByCategoryAxis:e,other:n,meta:i}}(t);return{value:N([(n=r.seriesGroupByCategoryAxis,i=[],P(n,(function(t,e){var n=t.categoryAxis,r=t.valueAxis.dim,o=[" "].concat(O(t.series,(function(t){return t.name}))),a=[n.model.getCategories()];P(t.series,(function(t){var e=t.getRawData();a.push(t.getRawData().mapArray(e.mapDimension(r),(function(t){return t})))}));for(var s=[o.join(wN)],l=0;l<a[0].length;l++){for(var u=[],h=0;h<a.length;h++)u.push(a[h][l]);s.push(u.join(wN))}i.push(s.join("\n"))})),i.join("\n\n"+bN+"\n\n")),(e=r.other,O(e,(function(t){var e=t.getRawData(),n=[t.name],i=[];return e.each(e.dimensions,(function(){for(var t=arguments.length,r=arguments[t-1],o=e.getName(r),a=0;a<t-1;a++)i[a]=arguments[a];n.push((o?o+wN:"")+i.join(wN))})),n.join("\n")})).join("\n\n"+bN+"\n\n"))],(function(t){return!!t.replace(/[\n\t\s]/g,"")})).join("\n\n"+bN+"\n\n"),meta:r.meta}}(t);if("function"==typeof u){var p=u(e.getOption());"string"==typeof p?s.innerHTML=p:j(p)&&s.appendChild(p)}else s.appendChild(l),l.readOnly=i.get("readOnly"),l.style.cssText="width:100%;height:100%;font-family:monospace;font-size:14px;line-height:1.6rem;",l.style.color=i.get("textColor"),l.style.borderColor=i.get("textareaBorderColor"),l.style.backgroundColor=i.get("textareaColor"),l.value=c.value;var d=c.meta,f=document.createElement("div");f.style.cssText="position:absolute;bottom:0;left:0;right:0;";var g="float:right;margin-right:20px;border:none;cursor:pointer;padding:2px 5px;font-size:12px;border-radius:3px",y=document.createElement("div"),v=document.createElement("div");g+=";background-color:"+i.get("buttonColor"),g+=";color:"+i.get("buttonTextColor");var m=this;function _(){n.removeChild(r),m._dom=null}te(y,"click",_),te(v,"click",(function(){if(null==h&&null!=u||null!=h&&null==u)_();else{var t;try{t="function"==typeof h?h(s,e.getOption()):IN(l.value,d)}catch(t){throw _(),new Error("Data view format error "+t)}t&&e.dispatchAction({type:"changeDataView",newOption:t}),_()}})),y.innerHTML=a[1],v.innerHTML=a[2],v.style.cssText=g,y.style.cssText=g,!i.get("readOnly")&&f.appendChild(v),f.appendChild(y),r.appendChild(o),r.appendChild(s),r.appendChild(f),s.style.height=n.clientHeight-80+"px",n.appendChild(r),this._dom=r},e.prototype.remove=function(t,e){this._dom&&e.getDom().removeChild(this._dom)},e.prototype.dispose=function(t,e){this.remove(t,e)},e.getDefaultOption=function(t){return{show:!0,readOnly:!1,optionToContent:null,contentToOption:null,icon:"M17.5,17.3H33 M17.5,17.3H33 M45.4,29.5h-28 M11.5,2v56H51V14.8L38.4,2H11.5z M38.4,2.2v12.7H51 M45.4,41.7h-28",title:t.getLocale(["toolbox","dataView","title"]),lang:t.getLocale(["toolbox","dataView","lang"]),backgroundColor:"#fff",textColor:"#000",textareaColor:"#fff",textareaBorderColor:"#333",buttonColor:"#c23531",buttonTextColor:"#fff"}},e}(uN);function CN(t,e){return O(t,(function(t,n){var i=e&&e[n];if(X(i)&&!F(i)){X(t)&&!F(t)||(t={value:t});var r=null!=i.name&&null==t.name;return t=T(t,i),r&&delete t.name,t}return t}))}Yv({type:"changeDataView",event:"dataViewChanged",update:"prepareAndUpdate"},(function(t,e){var n=[];P(t.newOption.series,(function(t){var i=e.getSeriesByName(t.name)[0];if(i){var r=i.get("data");n.push({name:t.name,data:CN(t.data,r)})}else n.push(I({type:"scatter"},t))})),e.mergeOption(T({series:n},t.newOption))}));var AN=P,DN=Lr();function LN(t){var e=DN(t);return e.snapshots||(e.snapshots=[{}]),e.snapshots}var kN=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.onclick=function(t,e){!function(t){DN(t).snapshots=null}(t),e.dispatchAction({type:"restore",from:this.uid})},e.getDefaultOption=function(t){return{show:!0,icon:"M3.8,33.4 M47,18.9h9.8V8.7 M56.3,20.1 C52.1,9,40.5,0.6,26.8,2.1C12.6,3.7,1.6,16.2,2.1,30.6 M13,41.1H3.1v10.2 M3.7,39.9c4.2,11.1,15.8,19.5,29.5,18 c14.2-1.6,25.2-14.1,24.7-28.5",title:t.getLocale(["toolbox","restore","title"])}},e}(uN);Yv({type:"restore",event:"restore",update:"prepareAndUpdate"},(function(t,e){e.resetOption("recreate")}));var PN=["dataToPoint","pointToData"],ON=["grid","xAxis","yAxis","geo","graph","polar","radiusAxis","angleAxis","bmap"],RN=function(){function t(t,e,n){var i=this;this._targetInfoList=[];var r=EN(e,t);P(zN,(function(t,e){(!n||!n.include||A(n.include,e)>=0)&&t(r,i._targetInfoList)}))}return t.prototype.setOutputRanges=function(t,e){return this.matchOutputRanges(t,e,(function(t,e,n){if((t.coordRanges||(t.coordRanges=[])).push(e),!t.coordRange){t.coordRange=e;var i=FN[t.brushType](0,n,e);t.__rangeOffset={offset:HN[t.brushType](i.values,t.range,[1,1]),xyMinMax:i.xyMinMax}}})),t},t.prototype.matchOutputRanges=function(t,e,n){P(t,(function(t){var i=this.findTargetInfo(t,e);i&&!0!==i&&P(i.coordSyses,(function(i){var r=FN[t.brushType](1,i,t.range);n(t,r.values,i,e)}))}),this)},t.prototype.setInputRanges=function(t,e){P(t,(function(t){var n,i,r,o,a,s=this.findTargetInfo(t,e);if(t.range=t.range||[],s&&!0!==s){t.panelId=s.panelId;var l=FN[t.brushType](0,s.coordSys,t.coordRange),u=t.__rangeOffset;t.range=u?HN[t.brushType](l.values,u.offset,(n=l.xyMinMax,i=u.xyMinMax,r=YN(n),o=YN(i),a=[r[0]/o[0],r[1]/o[1]],isNaN(a[0])&&(a[0]=1),isNaN(a[1])&&(a[1]=1),a)):l.values}}),this)},t.prototype.makePanelOpts=function(t,e){return O(this._targetInfoList,(function(n){var i=n.getPanelRect();return{panelId:n.panelId,defaultBrushType:e?e(n):null,clipPath:uD(i),isTargetByCursor:cD(i,t,n.coordSysModel),getLinearBrushOtherExtent:hD(i)}}))},t.prototype.controlSeries=function(t,e,n){var i=this.findTargetInfo(t,n);return!0===i||i&&A(i.coordSyses,e.coordinateSystem)>=0},t.prototype.findTargetInfo=function(t,e){for(var n=this._targetInfoList,i=EN(e,t),r=0;r<n.length;r++){var o=n[r],a=t.panelId;if(a){if(o.panelId===a)return o}else for(var s=0;s<BN.length;s++)if(BN[s](i,o))return o}return!0},t}();function NN(t){return t[0]>t[1]&&t.reverse(),t}function EN(t,e){return Pr(t,e,{includeMainTypes:ON})}var zN={grid:function(t,e){var n=t.xAxisModels,i=t.yAxisModels,r=t.gridModels,o=ht(),a={},s={};(n||i||r)&&(P(n,(function(t){var e=t.axis.grid.model;o.set(e.id,e),a[e.id]=!0})),P(i,(function(t){var e=t.axis.grid.model;o.set(e.id,e),s[e.id]=!0})),P(r,(function(t){o.set(t.id,t),a[t.id]=!0,s[t.id]=!0})),o.each((function(t){var r=t.coordinateSystem,o=[];P(r.getCartesians(),(function(t,e){(A(n,t.getAxis("x").model)>=0||A(i,t.getAxis("y").model)>=0)&&o.push(t)})),e.push({panelId:"grid--"+t.id,gridModel:t,coordSysModel:t,coordSys:o[0],coordSyses:o,getPanelRect:VN.grid,xAxisDeclared:a[t.id],yAxisDeclared:s[t.id]})})))},geo:function(t,e){P(t.geoModels,(function(t){var n=t.coordinateSystem;e.push({panelId:"geo--"+t.id,geoModel:t,coordSysModel:t,coordSys:n,coordSyses:[n],getPanelRect:VN.geo})}))}},BN=[function(t,e){var n=t.xAxisModel,i=t.yAxisModel,r=t.gridModel;return!r&&n&&(r=n.axis.grid.model),!r&&i&&(r=i.axis.grid.model),r&&r===e.gridModel},function(t,e){var n=t.geoModel;return n&&n===e.geoModel}],VN={grid:function(){return this.coordSys.master.getRect().clone()},geo:function(){var t=this.coordSys,e=t.getBoundingRect().clone();return e.applyTransform(Vu(t)),e}},FN={lineX:V(GN,0),lineY:V(GN,1),rect:function(t,e,n){var i=e[PN[t]]([n[0][0],n[1][0]]),r=e[PN[t]]([n[0][1],n[1][1]]),o=[NN([i[0],r[0]]),NN([i[1],r[1]])];return{values:o,xyMinMax:o}},polygon:function(t,e,n){var i=[[1/0,-1/0],[1/0,-1/0]];return{values:O(n,(function(n){var r=e[PN[t]](n);return i[0][0]=Math.min(i[0][0],r[0]),i[1][0]=Math.min(i[1][0],r[1]),i[0][1]=Math.max(i[0][1],r[0]),i[1][1]=Math.max(i[1][1],r[1]),r})),xyMinMax:i}}};function GN(t,e,n,i){var r=n.getAxis(["x","y"][t]),o=NN(O([0,1],(function(t){return e?r.coordToData(r.toLocalCoord(i[t])):r.toGlobalCoord(r.dataToCoord(i[t]))}))),a=[];return a[t]=o,a[1-t]=[NaN,NaN],{values:o,xyMinMax:a}}var HN={lineX:V(WN,0),lineY:V(WN,1),rect:function(t,e,n){return[[t[0][0]-n[0]*e[0][0],t[0][1]-n[0]*e[0][1]],[t[1][0]-n[1]*e[1][0],t[1][1]-n[1]*e[1][1]]]},polygon:function(t,e,n){return O(t,(function(t,i){return[t[0]-n[0]*e[i][0],t[1]-n[1]*e[i][1]]}))}};function WN(t,e,n,i){return[e[0]-i[t]*n[0],e[1]-i[t]*n[1]]}function YN(t){return t?[t[0][1]-t[0][0],t[1][1]-t[1][0]]:[NaN,NaN]}var XN,UN,ZN=P,jN=mr+"toolbox-dataZoom_",qN=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.render=function(t,e,n,i){this._brushController||(this._brushController=new PA(n.getZr()),this._brushController.on("brush",B(this._onBrush,this)).mount()),function(t,e,n,i,r){var o=n._isZoomActive;i&&"takeGlobalCursor"===i.type&&(o="dataZoomSelect"===i.key&&i.dataZoomSelectActive);n._isZoomActive=o,t.setIconStatus("zoom",o?"emphasis":"normal");var a=new RN($N(t),e,{include:["grid"]}).makePanelOpts(r,(function(t){return t.xAxisDeclared&&!t.yAxisDeclared?"lineX":!t.xAxisDeclared&&t.yAxisDeclared?"lineY":"rect"}));n._brushController.setPanels(a).enableBrush(!(!o||!a.length)&&{brushType:"auto",brushStyle:t.getModel("brushStyle").getItemStyle()})}(t,e,this,i,n),function(t,e){t.setIconStatus("back",function(t){return LN(t).length}(e)>1?"emphasis":"normal")}(t,e)},e.prototype.onclick=function(t,e,n){KN[n].call(this)},e.prototype.remove=function(t,e){this._brushController&&this._brushController.unmount()},e.prototype.dispose=function(t,e){this._brushController&&this._brushController.dispose()},e.prototype._onBrush=function(t){var e=t.areas;if(t.isEnd&&e.length){var n={},i=this.ecModel;this._brushController.updateCovers([]),new RN($N(this.model),i,{include:["grid"]}).matchOutputRanges(e,i,(function(t,e,n){if("cartesian2d"===n.type){var i=t.brushType;"rect"===i?(r("x",n,e[0]),r("y",n,e[1])):r({lineX:"x",lineY:"y"}[i],n,e)}})),function(t,e){var n=LN(t);AN(e,(function(e,i){for(var r=n.length-1;r>=0&&!n[r][i];r--);if(r<0){var o=t.queryComponents({mainType:"dataZoom",subType:"select",id:i})[0];if(o){var a=o.getPercentRange();n[0][i]={dataZoomId:i,start:a[0],end:a[1]}}}})),n.push(e)}(i,n),this._dispatchZoomAction(n)}function r(t,e,r){var o=e.getAxis(t),a=o.model,s=function(t,e,n){var i;return n.eachComponent({mainType:"dataZoom",subType:"select"},(function(n){n.getAxisModel(t,e.componentIndex)&&(i=n)})),i}(t,a,i),l=s.findRepresentativeAxisProxy(a).getMinMaxSpan();null==l.minValueSpan&&null==l.maxValueSpan||(r=sA(0,r.slice(),o.scale.getExtent(),0,l.minValueSpan,l.maxValueSpan)),s&&(n[s.id]={dataZoomId:s.id,startValue:r[0],endValue:r[1]})}},e.prototype._dispatchZoomAction=function(t){var e=[];ZN(t,(function(t,n){e.push(w(t))})),e.length&&this.api.dispatchAction({type:"dataZoom",from:this.uid,batch:e})},e.getDefaultOption=function(t){return{show:!0,filterMode:"filter",icon:{zoom:"M0,13.5h26.9 M13.5,26.9V0 M32.1,13.5H58V58H13.5 V32.1",back:"M22,1.4L9.9,13.5l12.3,12.3 M10.3,13.5H54.9v44.6 H10.3v-26"},title:t.getLocale(["toolbox","dataZoom","title"]),brushStyle:{borderWidth:0,color:"rgba(210,219,238,0.2)"}}},e}(uN),KN={zoom:function(){var t=!this._isZoomActive;this.api.dispatchAction({type:"takeGlobalCursor",key:"dataZoomSelect",dataZoomSelectActive:t})},back:function(){this._dispatchZoomAction(function(t){var e=LN(t),n=e[e.length-1];e.length>1&&e.pop();var i={};return AN(n,(function(t,n){for(var r=e.length-1;r>=0;r--)if(t=e[r][n]){i[n]=t;break}})),i}(this.ecModel))}};function $N(t){var e={xAxisIndex:t.get("xAxisIndex",!0),yAxisIndex:t.get("yAxisIndex",!0),xAxisId:t.get("xAxisId",!0),yAxisId:t.get("yAxisId",!0)};return null==e.xAxisIndex&&null==e.xAxisId&&(e.xAxisIndex="all"),null==e.yAxisIndex&&null==e.yAxisId&&(e.yAxisIndex="all"),e}XN="dataZoom",UN=function(t){var e=t.getComponent("toolbox",0);if(e){var n=e.getModel(["feature","dataZoom"]),i=[],r=Pr(t,$N(n));return ZN(r.xAxisModels,(function(t){return o(t,"xAxis","xAxisIndex")})),ZN(r.yAxisModels,(function(t){return o(t,"yAxis","yAxisIndex")})),i}function o(t,e,r){var o=t.componentIndex,a={type:"select",$fromToolbox:!0,filterMode:n.get("filterMode",!0)||"filter",id:jN+e+o};a[r]=o,i.push(a)}},rt(null==ip.get(XN)&&UN),ip.set(XN,UN);var JN=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="tooltip",e.dependencies=["axisPointer"],e.defaultOption={zlevel:0,z:60,show:!0,showContent:!0,trigger:"item",triggerOn:"mousemove|click",alwaysShowContent:!1,displayMode:"single",renderMode:"auto",confine:null,showDelay:0,hideDelay:100,transitionDuration:.4,enterable:!1,backgroundColor:"#fff",shadowBlur:10,shadowColor:"rgba(0, 0, 0, .2)",shadowOffsetX:1,shadowOffsetY:2,borderRadius:4,borderWidth:1,padding:null,extraCssText:"",axisPointer:{type:"line",axis:"auto",animation:"auto",animationDurationUpdate:200,animationEasingUpdate:"exponentialOut",crossStyle:{color:"#999",width:1,type:"dashed",textStyle:{}}},textStyle:{color:"#666",fontSize:14}},e}(Nc);function QN(t){var e=t.get("confine");return null!=e?!!e:"richText"===t.get("renderMode")}var tE=["-ms-","-moz-","-o-","-webkit-",""];function eE(t,e,n){var i=[],r=t.get("transitionDuration"),o=t.get("backgroundColor"),s=t.get("shadowBlur"),l=t.get("shadowColor"),u=t.get("shadowOffsetX"),h=t.get("shadowOffsetY"),c=t.getModel("textStyle"),p=Jd(t,"html"),d=u+"px "+h+"px "+s+"px "+l;return i.push("box-shadow:"+d),e&&r&&i.push(function(t,e){var n="cubic-bezier(0.23, 1, 0.32, 1)",i="opacity "+t/2+"s "+n+",visibility "+t/2+"s "+n;return e||(i+=",left "+t+"s "+n+",top "+t+"s "+n),O(tE,(function(t){return t+"transition:"+i})).join(";")}(r,n)),o&&(a.canvasSupported?i.push("background-Color:"+o):(i.push("background-Color:#"+Je(o)),i.push("filter:alpha(opacity=70)"))),P(["width","color","radius"],(function(e){var n="border-"+e,r=cc(n),o=t.get(r);null!=o&&i.push(n+":"+o+("color"===e?"":"px"))})),i.push(function(t){var e=[],n=t.get("fontSize"),i=t.getTextColor();i&&e.push("color:"+i),e.push("font:"+t.getFont()),n&&e.push("line-height:"+Math.round(3*n/2)+"px");var r=t.get("textShadowColor"),o=t.get("textShadowBlur")||0,a=t.get("textShadowOffsetX")||0,s=t.get("textShadowOffsetY")||0;return r&&o&&e.push("text-shadow:"+a+"px "+s+"px "+o+"px "+r),P(["decoration","align"],(function(n){var i=t.get(n);i&&e.push("text-"+n+":"+i)})),e.join(";")}(c)),null!=p&&i.push("padding:"+pc(p).join("px ")+"px"),i.join(";")+";"}function nE(t,e,n,i,r){var o=e&&e.painter;if(n){var a=o&&o.getViewportRoot();a&&function(t,e,n,i,r){Xt(Yt,e,i,r,!0)&&Xt(t,n,Yt[0],Yt[1])}(t,a,document.body,i,r)}else{t[0]=i,t[1]=r;var s=o&&o.getViewportRootOffset();s&&(t[0]+=s.offsetLeft,t[1]+=s.offsetTop)}t[2]=t[0]/e.getWidth(),t[3]=t[1]/e.getHeight()}var iE=function(){function t(t,e,n){if(this._show=!1,this._styleCoord=[0,0,0,0],this._enterable=!0,this._firstShow=!0,this._longHide=!0,a.wxa)return null;var i=document.createElement("div");i.domBelongToZr=!0,this.el=i;var r=this._zr=e.getZr(),o=this._appendToBody=n&&n.appendToBody;nE(this._styleCoord,r,o,e.getWidth()/2,e.getHeight()/2),o?document.body.appendChild(i):t.appendChild(i),this._container=t;var s=this;i.onmouseenter=function(){s._enterable&&(clearTimeout(s._hideTimeout),s._show=!0),s._inContent=!0},i.onmousemove=function(t){if(t=t||window.event,!s._enterable){var e=r.handler;Qt(r.painter.getViewportRoot(),t,!0),e.dispatch("mousemove",t)}},i.onmouseleave=function(){s._inContent=!1,s._enterable&&s._show&&s.hideLater(s._hideDelay)}}return t.prototype.update=function(t){var e=this._container,n=e.currentStyle||document.defaultView.getComputedStyle(e),i=e.style;"absolute"!==i.position&&"absolute"!==n.position&&(i.position="relative"),t.get("alwaysShowContent")&&this._moveIfResized(),this.el.className=t.get("className")||""},t.prototype.show=function(t,e){clearTimeout(this._hideTimeout),clearTimeout(this._longHideTimeout);var n=this.el,i=this._styleCoord,r=n.offsetHeight/2;e=bc(e),n.style.cssText="position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;"+eE(t,!this._firstShow,this._longHide)+";left:"+i[0]+"px;top:"+(i[1]-r)+"px;border-color: "+e+";"+(t.get("extraCssText")||""),n.style.display=n.innerHTML?"block":"none",n.style.pointerEvents=this._enterable?"auto":"none",this._show=!0,this._firstShow=!1,this._longHide=!1},t.prototype.setContent=function(t,e,n,i,r){if(null!=t){var o=this.el;if(H(r)&&"item"===n.get("trigger")&&!QN(n)&&(t+=function(t,e,n){if(!H(n)||"inside"===n)return"";e=bc(e);var i,r="left"===(i=n)?"right":"right"===i?"left":"top"===i?"bottom":"top",o="",a="";return A(["left","right"],r)>-1?(o=r+":-6px;top:50%;",a="translateY(-50%) rotate("+("left"===r?-225:-45)+"deg)"):(o=r+":-6px;left:50%;",a="translateX(-50%) rotate("+("top"===r?225:45)+"deg)"),'<div style="'+["position:absolute;width:10px;height:10px;",""+o+(a=O(tE,(function(t){return t+"transform:"+a})).join(";"))+";","border-bottom: "+e+" solid 1px;","border-right: "+e+" solid 1px;","background-color: "+t+";","box-shadow: 8px 8px 16px -3px #000;"].join("")+'"></div>'}(n.get("backgroundColor"),i,r)),H(t))o.innerHTML=t;else if(t){o.innerHTML="",F(t)||(t=[t]);for(var a=0;a<t.length;a++)j(t[a])&&t[a].parentNode!==o&&o.appendChild(t[a])}}},t.prototype.setEnterable=function(t){this._enterable=t},t.prototype.getSize=function(){var t=this.el;return[t.clientWidth,t.clientHeight]},t.prototype.moveTo=function(t,e){var n=this._styleCoord;if(nE(n,this._zr,this._appendToBody,t,e),null!=n[0]&&null!=n[1]){var i=this.el.style;i.left=n[0].toFixed(0)+"px",i.top=n[1].toFixed(0)+"px"}},t.prototype._moveIfResized=function(){var t=this._styleCoord[2],e=this._styleCoord[3];this.moveTo(t*this._zr.getWidth(),e*this._zr.getHeight())},t.prototype.hide=function(){var t=this;this.el.style.visibility="hidden",this.el.style.opacity="0",this._show=!1,this._longHideTimeout=setTimeout((function(){return t._longHide=!0}),500)},t.prototype.hideLater=function(t){!this._show||this._inContent&&this._enterable||(t?(this._hideDelay=t,this._show=!1,this._hideTimeout=setTimeout(B(this.hide,this),t)):this.hide())},t.prototype.isShow=function(){return this._show},t.prototype.dispose=function(){this.el.parentNode.removeChild(this.el)},t.prototype.getOuterSize=function(){var t=this.el.clientWidth,e=this.el.clientHeight;if(document.defaultView&&document.defaultView.getComputedStyle){var n=document.defaultView.getComputedStyle(this.el);n&&(t+=parseInt(n.borderLeftWidth,10)+parseInt(n.borderRightWidth,10),e+=parseInt(n.borderTopWidth,10)+parseInt(n.borderBottomWidth,10))}return{width:t,height:e}},t}(),rE=function(){function t(t){this._show=!1,this._styleCoord=[0,0,0,0],this._enterable=!0,this._zr=t.getZr(),sE(this._styleCoord,this._zr,t.getWidth()/2,t.getHeight()/2)}return t.prototype.update=function(t){t.get("alwaysShowContent")&&this._moveIfResized()},t.prototype.show=function(){this._hideTimeout&&clearTimeout(this._hideTimeout),this.el.show(),this._show=!0},t.prototype.setContent=function(t,e,n,i,r){X(t)&&yr(""),this.el&&this._zr.remove(this.el);var o=n.getModel("textStyle");this.el=new ls({style:{rich:e.richTextStyles,text:t,lineHeight:22,backgroundColor:n.get("backgroundColor"),borderRadius:n.get("borderRadius"),borderWidth:1,borderColor:i,shadowColor:n.get("shadowColor"),shadowBlur:n.get("shadowBlur"),shadowOffsetX:n.get("shadowOffsetX"),shadowOffsetY:n.get("shadowOffsetY"),textShadowColor:o.get("textShadowColor"),textShadowBlur:o.get("textShadowBlur")||0,textShadowOffsetX:o.get("textShadowOffsetX")||0,textShadowOffsetY:o.get("textShadowOffsetY")||0,fill:n.get(["textStyle","color"]),padding:Jd(n,"richText"),verticalAlign:"top",align:"left"},z:n.get("z")}),this._zr.add(this.el);var a=this;this.el.on("mouseover",(function(){a._enterable&&(clearTimeout(a._hideTimeout),a._show=!0),a._inContent=!0})),this.el.on("mouseout",(function(){a._enterable&&a._show&&a.hideLater(a._hideDelay),a._inContent=!1}))},t.prototype.setEnterable=function(t){this._enterable=t},t.prototype.getSize=function(){var t=this.el,e=this.el.getBoundingRect(),n=aE(t.style);return[e.width+n.left+n.right,e.height+n.top+n.bottom]},t.prototype.moveTo=function(t,e){var n=this.el;if(n){var i=this._styleCoord;sE(i,this._zr,t,e),t=i[0],e=i[1];var r=n.style,o=oE(r.borderWidth||0),a=aE(r);n.x=t+o+a.left,n.y=e+o+a.top,n.markRedraw()}},t.prototype._moveIfResized=function(){var t=this._styleCoord[2],e=this._styleCoord[3];this.moveTo(t*this._zr.getWidth(),e*this._zr.getHeight())},t.prototype.hide=function(){this.el&&this.el.hide(),this._show=!1},t.prototype.hideLater=function(t){!this._show||this._inContent&&this._enterable||(t?(this._hideDelay=t,this._show=!1,this._hideTimeout=setTimeout(B(this.hide,this),t)):this.hide())},t.prototype.isShow=function(){return this._show},t.prototype.getOuterSize=function(){var t=this.getSize();return{width:t[0],height:t[1]}},t.prototype.dispose=function(){this._zr.remove(this.el)},t}();function oE(t){return Math.max(0,t)}function aE(t){var e=oE(t.shadowBlur||0),n=oE(t.shadowOffsetX||0),i=oE(t.shadowOffsetY||0);return{left:oE(e-n),right:oE(e+n),top:oE(e-i),bottom:oE(e+i)}}function sE(t,e,n,i){t[0]=n,t[1]=i,t[2]=t[0]/e.getWidth(),t[3]=t[1]/e.getHeight()}var lE=B,uE=P,hE=Zi,cE=new os({shape:{x:-1,y:-1,width:2,height:2}}),pE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(t,e){if(!a.node){var n,i=t.getComponent("tooltip"),r=i.get("renderMode");this._renderMode="auto"===(n=r)?a.domSupported?"html":"richText":n||"html",this._tooltipContent="richText"===this._renderMode?new rE(e):new iE(e.getDom(),e,{appendToBody:i.get("appendToBody",!0)})}},e.prototype.render=function(t,e,n){if(!a.node){this.group.removeAll(),this._tooltipModel=t,this._ecModel=e,this._api=n,this._alwaysShowContent=t.get("alwaysShowContent");var i=this._tooltipContent;i.update(t),i.setEnterable(t.get("enterable")),this._initGlobalListener(),this._keepShow()}},e.prototype._initGlobalListener=function(){var t=this._tooltipModel.get("triggerOn");wO("itemTooltip",this._api,lE((function(e,n,i){"none"!==t&&(t.indexOf(e)>=0?this._tryShow(n,i):"leave"===e&&this._hide(i))}),this))},e.prototype._keepShow=function(){var t=this._tooltipModel,e=this._ecModel,n=this._api;if(null!=this._lastX&&null!=this._lastY&&"none"!==t.get("triggerOn")){var i=this;clearTimeout(this._refreshUpdateTimeout),this._refreshUpdateTimeout=setTimeout((function(){!n.isDisposed()&&i.manuallyShowTip(t,e,n,{x:i._lastX,y:i._lastY,dataByCoordSys:i._lastDataByCoordSys})}))}},e.prototype.manuallyShowTip=function(t,e,n,i){if(i.from!==this.uid&&!a.node){var r=fE(i,n);this._ticket="";var o=i.dataByCoordSys;if(i.tooltip&&null!=i.x&&null!=i.y){var s=cE;s.x=i.x,s.y=i.y,s.update(),s.tooltip=i.tooltip,this._tryShow({offsetX:i.x,offsetY:i.y,target:s},r)}else if(o)this._tryShow({offsetX:i.x,offsetY:i.y,position:i.position,dataByCoordSys:o,tooltipOption:i.tooltipOption},r);else if(null!=i.seriesIndex){if(this._manuallyAxisShowTip(t,e,n,i))return;var l=CO(i,e),u=l.point[0],h=l.point[1];null!=u&&null!=h&&this._tryShow({offsetX:u,offsetY:h,position:i.position,target:l.el},r)}else null!=i.x&&null!=i.y&&(n.dispatchAction({type:"updateAxisPointer",x:i.x,y:i.y}),this._tryShow({offsetX:i.x,offsetY:i.y,position:i.position,target:n.getZr().findHover(i.x,i.y).target},r))}},e.prototype.manuallyHideTip=function(t,e,n,i){var r=this._tooltipContent;!this._alwaysShowContent&&this._tooltipModel&&r.hideLater(this._tooltipModel.get("hideDelay")),this._lastX=this._lastY=this._lastDataByCoordSys=null,i.from!==this.uid&&this._hide(fE(i,n))},e.prototype._manuallyAxisShowTip=function(t,e,n,i){var r=i.seriesIndex,o=i.dataIndex,a=e.getComponent("axisPointer").coordSysAxesInfo;if(null!=r&&null!=o&&null!=a){var s=e.getSeriesByIndex(r);if(s)if("axis"===dE([s.getData().getItemModel(o),s,(s.coordinateSystem||{}).model,t]).get("trigger"))return n.dispatchAction({type:"updateAxisPointer",seriesIndex:r,dataIndex:o,position:i.position}),!0}},e.prototype._tryShow=function(t,e){var n=t.target;if(this._tooltipModel){this._lastX=t.offsetX,this._lastY=t.offsetY;var i=t.dataByCoordSys;i&&i.length?this._showAxisTooltip(i,t):n&&Jg(n,(function(t){return null!=ys(t).dataIndex}),!0)?(this._lastDataByCoordSys=null,this._showSeriesItemTooltip(t,n,e)):n&&n.tooltip?(this._lastDataByCoordSys=null,this._showComponentItemTooltip(t,n,e)):(this._lastDataByCoordSys=null,this._hide(e))}},e.prototype._showOrMove=function(t,e){var n=t.get("showDelay");e=B(e,this),clearTimeout(this._showTimout),n>0?this._showTimout=setTimeout(e,n):e()},e.prototype._showAxisTooltip=function(t,e){var n=this._ecModel,i=this._tooltipModel,r=[e.offsetX,e.offsetY],o=dE([e.tooltipOption,i]),a=this._renderMode,s=[],l=Yd("section",{blocks:[],noHeader:!0}),u=[],h=new Qd;uE(t,(function(t){uE(t.dataByAxis,(function(t){var e=n.getComponent(t.axisDim+"Axis",t.axisIndex),i=t.value;if(e&&null!=i){var r=uO(i,e.axis,n,t.seriesDataIndices,t.valueLabelOpt),o=Yd("section",{header:r,noHeader:!ot(r),sortBlocks:!0,blocks:[]});l.blocks.push(o),P(t.seriesDataIndices,(function(l){var c=n.getSeriesByIndex(l.seriesIndex),p=l.dataIndexInside,d=c.getDataParams(p);d.axisDim=t.axisDim,d.axisIndex=t.axisIndex,d.axisType=t.axisType,d.axisId=t.axisId,d.axisValue=W_(e.axis,{value:i}),d.axisValueLabel=r,d.marker=h.makeTooltipMarker("item",bc(d.color),a);var f=vd(c.formatTooltip(p,!0,null));f.markupFragment&&o.blocks.push(f.markupFragment),f.markupText&&u.push(f.markupText),s.push(d)}))}}))})),l.blocks.reverse(),u.reverse();var c=e.position,p=o.get("order"),d=Zd(l,h,a,p,n.get("useUTC"),o.get("textStyle"));d&&u.unshift(d);var f="richText"===a?"\n\n":"<br/>",g=u.join(f);this._showOrMove(o,(function(){this._updateContentNotChangedOnAxis(t)?this._updatePosition(o,c,r[0],r[1],this._tooltipContent,s):this._showTooltipContent(o,g,s,Math.random()+"",r[0],r[1],c,null,h)}))},e.prototype._showSeriesItemTooltip=function(t,e,n){var i=Jg(e,(function(t){return null!=ys(t).dataIndex}),!0),r=this._ecModel,o=ys(i),a=o.seriesIndex,s=r.getSeriesByIndex(a),l=o.dataModel||s,u=o.dataIndex,h=o.dataType,c=l.getData(h),p=this._renderMode,d=dE([c.getItemModel(u),l,s&&(s.coordinateSystem||{}).model,this._tooltipModel]),f=d.get("trigger");if(null==f||"item"===f){var g=l.getDataParams(u,h),y=new Qd;g.marker=y.makeTooltipMarker("item",bc(g.color),p);var v=vd(l.formatTooltip(u,!1,h)),m=d.get("order"),_=v.markupFragment?Zd(v.markupFragment,y,p,m,r.get("useUTC"),d.get("textStyle")):v.markupText,x="item_"+l.name+"_"+u;this._showOrMove(d,(function(){this._showTooltipContent(d,_,g,x,t.offsetX,t.offsetY,t.position,t.target,y)})),n({type:"showTip",dataIndexInside:u,dataIndex:c.getRawIndex(u),seriesIndex:a,from:this.uid})}},e.prototype._showComponentItemTooltip=function(t,e,n){var i=e.tooltip;if(H(i)){i={content:i,formatter:i}}var r=new Sh(i,this._tooltipModel,this._ecModel),o=r.get("content"),a=Math.random()+"",s=new Qd;this._showOrMove(r,(function(){this._showTooltipContent(r,o,r.get("formatterParams")||{},a,t.offsetX,t.offsetY,t.position,e,s)})),n({type:"showTip",from:this.uid})},e.prototype._showTooltipContent=function(t,e,n,i,r,o,a,s,l){if(this._ticket="",t.get("showContent")&&t.get("show")){var u=this._tooltipContent,h=t.get("formatter");a=a||t.get("position");var c=e,p=this._getNearestPoint([r,o],n,t.get("trigger"),t.get("borderColor"));if(h&&H(h)){var d=t.ecModel.get("useUTC"),f=F(n)?n[0]:n;c=h,f&&f.axisType&&f.axisType.indexOf("time")>=0&&(c=Zh(f.axisValue,c,d)),c=_c(c,n,!0)}else if(G(h)){var g=lE((function(e,i){e===this._ticket&&(u.setContent(i,l,t,p.color,a),this._updatePosition(t,a,r,o,u,n,s))}),this);this._ticket=i,c=h(n,i,g)}u.setContent(c,l,t,p.color,a),u.show(t,p.color),this._updatePosition(t,a,r,o,u,n,s)}},e.prototype._getNearestPoint=function(t,e,n,i){return"axis"===n||F(e)?{color:i||("html"===this._renderMode?"#fff":"none")}:F(e)?void 0:{color:i||e.color||e.borderColor}},e.prototype._updatePosition=function(t,e,n,i,r,o,a){var s=this._api.getWidth(),l=this._api.getHeight();e=e||t.get("position");var u=r.getSize(),h=t.get("align"),c=t.get("verticalAlign"),p=a&&a.getBoundingRect().clone();if(a&&p.applyTransform(a.transform),G(e)&&(e=e([n,i],o,r.el,p,{viewSize:[s,l],contentSize:u.slice()})),F(e))n=hE(e[0],s),i=hE(e[1],l);else if(X(e)){var d=e;d.width=u[0],d.height=u[1];var f=Ac(d,{width:s,height:l});n=f.x,i=f.y,h=null,c=null}else if(H(e)&&a){var g=function(t,e,n){var i=n[0],r=n[1],o=10,a=5,s=0,l=0,u=e.width,h=e.height;switch(t){case"inside":s=e.x+u/2-i/2,l=e.y+h/2-r/2;break;case"top":s=e.x+u/2-i/2,l=e.y-r-o;break;case"bottom":s=e.x+u/2-i/2,l=e.y+h+o;break;case"left":s=e.x-i-o-a,l=e.y+h/2-r/2;break;case"right":s=e.x+u+o+a,l=e.y+h/2-r/2}return[s,l]}(e,p,u);n=g[0],i=g[1]}else{g=function(t,e,n,i,r,o,a){var s=n.getOuterSize(),l=s.width,u=s.height;null!=o&&(t+l+o+2>i?t-=l+o:t+=o);null!=a&&(e+u+a>r?e-=u+a:e+=a);return[t,e]}(n,i,r,s,l,h?null:20,c?null:20);n=g[0],i=g[1]}if(h&&(n-=gE(h)?u[0]/2:"right"===h?u[0]:0),c&&(i-=gE(c)?u[1]/2:"bottom"===c?u[1]:0),QN(t)){g=function(t,e,n,i,r){var o=n.getOuterSize(),a=o.width,s=o.height;return t=Math.min(t+a,i)-a,e=Math.min(e+s,r)-s,t=Math.max(t,0),e=Math.max(e,0),[t,e]}(n,i,r,s,l);n=g[0],i=g[1]}r.moveTo(n,i)},e.prototype._updateContentNotChangedOnAxis=function(t){var e=this._lastDataByCoordSys,n=!!e&&e.length===t.length;return n&&uE(e,(function(e,i){var r=e.dataByAxis||[],o=(t[i]||{}).dataByAxis||[];(n=n&&r.length===o.length)&&uE(r,(function(t,e){var i=o[e]||{},r=t.seriesDataIndices||[],a=i.seriesDataIndices||[];(n=n&&t.value===i.value&&t.axisType===i.axisType&&t.axisId===i.axisId&&r.length===a.length)&&uE(r,(function(t,e){var i=a[e];n=n&&t.seriesIndex===i.seriesIndex&&t.dataIndex===i.dataIndex}))}))})),this._lastDataByCoordSys=t,!!n},e.prototype._hide=function(t){this._lastDataByCoordSys=null,t({type:"hideTip",from:this.uid})},e.prototype.dispose=function(t,e){a.node||(this._tooltipContent.dispose(),IO("itemTooltip",e))},e.type="tooltip",e}(pf);function dE(t){for(var e=t.pop();t.length;){var n=t.pop();n&&(n instanceof Sh&&(n=n.get("tooltip",!0)),H(n)&&(n={formatter:n}),e=new Sh(n,e,e.ecModel))}return e}function fE(t,e){return t.dispatchAction||B(e.dispatchAction,e)}function gE(t){return"center"===t||"middle"===t}var yE=["rect","polygon","keep","clear"];function vE(t,e){var n=_r(t?t.brush:[]);if(n.length){var i=[];P(n,(function(t){var e=t.hasOwnProperty("toolbox")?t.toolbox:[];e instanceof Array&&(i=i.concat(e))}));var r=t&&t.toolbox;F(r)&&(r=r[0]),r||(r={feature:{}},t.toolbox=[r]);var o=r.feature||(r.feature={}),a=o.brush||(o.brush={}),s=a.type||(a.type=[]);s.push.apply(s,i),function(t){var e={};P(t,(function(t){e[t]=1})),t.length=0,P(e,(function(e,n){t.push(n)}))}(s),e&&!s.length&&s.push.apply(s,yE)}}var mE=P;function _E(t){if(t)for(var e in t)if(t.hasOwnProperty(e))return!0}function xE(t,e,n){var i={};return mE(e,(function(e){var r,o=i[e]=((r=function(){}).prototype.__hidden=r.prototype,new r);mE(t[e],(function(t,i){if(eT.isValidType(i)){var r={type:i,visual:t};n&&n(r,e),o[i]=new eT(r),"opacity"===i&&((r=w(r)).type="colorAlpha",o.__hidden.__alphaForOpacity=new eT(r))}}))})),i}function bE(t,e,n){var i;P(n,(function(t){e.hasOwnProperty(t)&&_E(e[t])&&(i=!0)})),i&&P(n,(function(n){e.hasOwnProperty(n)&&_E(e[n])?t[n]=w(e[n]):delete t[n]}))}var wE={lineX:SE(0),lineY:SE(1),rect:{point:function(t,e,n){return t&&n.boundingRect.contain(t[0],t[1])},rect:function(t,e,n){return t&&n.boundingRect.intersect(t)}},polygon:{point:function(t,e,n){return t&&n.boundingRect.contain(t[0],t[1])&&J_(n.range,t[0],t[1])},rect:function(t,e,n){var i=n.range;if(!t||i.length<=1)return!1;var r=t.x,o=t.y,a=t.width,s=t.height,l=i[0];return!!(J_(i,r,o)||J_(i,r+a,o)||J_(i,r,o+s)||J_(i,r+a,o+s)||Rn.create(t).contain(l[0],l[1])||Zu(r,o,r+a,o,i)||Zu(r,o,r,o+s,i)||Zu(r+a,o,r+a,o+s,i)||Zu(r,o+s,r+a,o+s,i))||void 0}}};function SE(t){var e=["x","y"],n=["width","height"];return{point:function(e,n,i){if(e){var r=i.range;return ME(e[t],r)}},rect:function(i,r,o){if(i){var a=o.range,s=[i[e[t]],i[e[t]]+i[n[t]]];return s[1]<s[0]&&s.reverse(),ME(s[0],a)||ME(s[1],a)||ME(a[0],s)||ME(a[1],s)}}}}function ME(t,e){return e[0]<=t&&t<=e[1]}var IE=["inBrush","outOfBrush"],TE="__ecBrushSelect",CE="__ecInBrushSelectEvent";function AE(t){t.eachComponent({mainType:"brush"},(function(e){(e.brushTargetManager=new RN(e.option,t)).setInputRanges(e.areas,t)}))}function DE(t,e,n){var i,r,o=[];t.eachComponent({mainType:"brush"},(function(t){n&&"takeGlobalCursor"===n.type&&t.setBrushOption("brush"===n.key?n.brushOption:{brushType:!1})})),AE(t),t.eachComponent({mainType:"brush"},(function(e,n){var a={brushId:e.id,brushIndex:n,brushName:e.name,areas:w(e.areas),selected:[]};o.push(a);var s=e.option,l=s.brushLink,u=[],h=[],c=[],p=!1;n||(i=s.throttleType,r=s.throttleDelay);var d=O(e.areas,(function(t){var e=PE[t.brushType],n=T({boundingRect:e?e(t):void 0},t);return n.selectors=function(t){var e=t.brushType,n={point:function(i){return wE[e].point(i,n,t)},rect:function(i){return wE[e].rect(i,n,t)}};return n}(n),n})),f=xE(e.option,IE,(function(t){t.mappingMethod="fixed"}));function g(t){return"all"===l||!!u[t]}function y(t){return!!t.length}F(l)&&P(l,(function(t){u[t]=1})),t.eachSeries((function(n,i){var r=c[i]=[];"parallel"===n.subType?function(t,e){var n=t.coordinateSystem;p=p||n.hasAxisBrushed(),g(e)&&n.eachActiveState(t.getData(),(function(t,e){"active"===t&&(h[e]=1)}))}(n,i):function(n,i,r){if(!n.brushSelector||function(t,e){var n=t.option.seriesIndex;return null!=n&&"all"!==n&&(F(n)?A(n,e)<0:e!==n)}(e,i))return;if(P(d,(function(i){e.brushTargetManager.controlSeries(i,n,t)&&r.push(i),p=p||y(r)})),g(i)&&y(r)){var o=n.getData();o.each((function(t){kE(n,r,o,t)&&(h[t]=1)}))}}(n,i,r)})),t.eachSeries((function(t,e){var n={seriesId:t.id,seriesIndex:e,seriesName:t.name,dataIndex:[]};a.selected.push(n);var i=c[e],r=t.getData(),o=g(e)?function(t){return h[t]?(n.dataIndex.push(r.getRawIndex(t)),"inBrush"):"outOfBrush"}:function(e){return kE(t,i,r,e)?(n.dataIndex.push(r.getRawIndex(e)),"inBrush"):"outOfBrush"};(g(e)?p:y(i))&&function(t,e,n,i,r,o){var a,s={};function l(t){return pg(n,a,t)}function u(t,e){fg(n,a,t,e)}function h(t,h){a=null==o?t:h;var c=n.getRawDataItem(a);if(!c||!1!==c.visualMap)for(var p=i.call(r,t),d=e[p],f=s[p],g=0,y=f.length;g<y;g++){var v=f[g];d[v]&&d[v].applyVisual(t,l,u)}}P(t,(function(t){var n=eT.prepareVisualTypes(e[t]);s[t]=n})),null==o?n.each(h):n.each([o],h)}(IE,f,r,o)}))})),function(t,e,n,i,r){if(!r)return;var o=t.getZr();if(o[CE])return;o.__ecBrushSelect||(o.__ecBrushSelect=LE);Tf(o,TE,n,e)(t,i)}(e,i,r,o,n)}function LE(t,e){if(!t.isDisposed()){var n=t.getZr();n[CE]=!0,t.dispatchAction({type:"brushSelect",batch:e}),n[CE]=!1}}function kE(t,e,n,i){for(var r=0,o=e.length;r<o;r++){var a=e[r];if(t.brushSelector(i,n,a.selectors,a))return!0}}var PE={rect:function(t){return OE(t.range)},polygon:function(t){for(var e,n=t.range,i=0,r=n.length;i<r;i++){e=e||[[1/0,-1/0],[1/0,-1/0]];var o=n[i];o[0]<e[0][0]&&(e[0][0]=o[0]),o[0]>e[0][1]&&(e[0][1]=o[0]),o[1]<e[1][0]&&(e[1][0]=o[1]),o[1]>e[1][1]&&(e[1][1]=o[1])}return e&&OE(e)}};function OE(t){return new Rn(t[0][0],t[1][0],t[0][1]-t[0][0],t[1][1]-t[1][0])}var RE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(t,e){this.ecModel=t,this.api=e,this.model,(this._brushController=new PA(e.getZr())).on("brush",B(this._onBrush,this)).mount()},e.prototype.render=function(t,e,n,i){this.model=t,this._updateController(t,e,n,i)},e.prototype.updateTransform=function(t,e,n,i){AE(e),this._updateController(t,e,n,i)},e.prototype.updateVisual=function(t,e,n,i){this.updateTransform(t,e,n,i)},e.prototype.updateView=function(t,e,n,i){this._updateController(t,e,n,i)},e.prototype._updateController=function(t,e,n,i){(!i||i.$from!==t.id)&&this._brushController.setPanels(t.brushTargetManager.makePanelOpts(n)).enableBrush(t.brushOption).updateCovers(t.areas.slice())},e.prototype.dispose=function(){this._brushController.dispose()},e.prototype._onBrush=function(t){var e=this.model.id,n=this.model.brushTargetManager.setOutputRanges(t.areas,this.ecModel);(!t.isEnd||t.removeOnClick)&&this.api.dispatchAction({type:"brush",brushId:e,areas:w(n),$from:e}),t.isEnd&&this.api.dispatchAction({type:"brushEnd",brushId:e,areas:w(n),$from:e})},e.type="brush",e}(pf),NE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.areas=[],n.brushOption={},n}return n(e,t),e.prototype.optionUpdated=function(t,e){var n=this.option;!e&&bE(n,t,["inBrush","outOfBrush"]);var i=n.inBrush=n.inBrush||{};n.outOfBrush=n.outOfBrush||{color:"#ddd"},i.hasOwnProperty("liftZ")||(i.liftZ=5)},e.prototype.setAreas=function(t){t&&(this.areas=O(t,(function(t){return EE(this.option,t)}),this))},e.prototype.setBrushOption=function(t){this.brushOption=EE(this.option,t),this.brushType=this.brushOption.brushType},e.type="brush",e.dependencies=["geo","grid","xAxis","yAxis","parallel","series"],e.defaultOption={seriesIndex:"all",brushType:"rect",brushMode:"single",transformable:!0,brushStyle:{borderWidth:1,color:"rgba(210,219,238,0.3)",borderColor:"#D2DBEE"},throttleType:"fixRate",throttleDelay:0,removeOnClick:!0,z:1e4},e}(Nc);function EE(t,e){return S({brushType:t.brushType,brushMode:t.brushMode,transformable:t.transformable,brushStyle:new Sh(t.brushStyle).getItemStyle(),removeOnClick:t.removeOnClick,z:t.z},e,!0)}var zE=["rect","polygon","lineX","lineY","keep","clear"],BE=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.render=function(t,e,n){var i,r,o;e.eachComponent({mainType:"brush"},(function(t){i=t.brushType,r=t.brushOption.brushMode||"single",o=o||!!t.areas.length})),this._brushType=i,this._brushMode=r,P(t.get("type",!0),(function(e){t.setIconStatus(e,("keep"===e?"multiple"===r:"clear"===e?o:e===i)?"emphasis":"normal")}))},e.prototype.updateView=function(t,e,n){this.render(t,e,n)},e.prototype.getIcons=function(){var t=this.model,e=t.get("icon",!0),n={};return P(t.get("type",!0),(function(t){e[t]&&(n[t]=e[t])})),n},e.prototype.onclick=function(t,e,n){var i=this._brushType,r=this._brushMode;"clear"===n?(e.dispatchAction({type:"axisAreaSelect",intervals:[]}),e.dispatchAction({type:"brush",command:"clear",areas:[]})):e.dispatchAction({type:"takeGlobalCursor",key:"brush",brushOption:{brushType:"keep"===n?i:i!==n&&n,brushMode:"keep"===n?"multiple"===r?"single":"multiple":r}})},e.getDefaultOption=function(t){return{show:!0,type:zE.slice(),icon:{rect:"M7.3,34.7 M0.4,10V-0.2h9.8 M89.6,10V-0.2h-9.8 M0.4,60v10.2h9.8 M89.6,60v10.2h-9.8 M12.3,22.4V10.5h13.1 M33.6,10.5h7.8 M49.1,10.5h7.8 M77.5,22.4V10.5h-13 M12.3,31.1v8.2 M77.7,31.1v8.2 M12.3,47.6v11.9h13.1 M33.6,59.5h7.6 M49.1,59.5 h7.7 M77.5,47.6v11.9h-13",polygon:"M55.2,34.9c1.7,0,3.1,1.4,3.1,3.1s-1.4,3.1-3.1,3.1 s-3.1-1.4-3.1-3.1S53.5,34.9,55.2,34.9z M50.4,51c1.7,0,3.1,1.4,3.1,3.1c0,1.7-1.4,3.1-3.1,3.1c-1.7,0-3.1-1.4-3.1-3.1 C47.3,52.4,48.7,51,50.4,51z M55.6,37.1l1.5-7.8 M60.1,13.5l1.6-8.7l-7.8,4 M59,19l-1,5.3 M24,16.1l6.4,4.9l6.4-3.3 M48.5,11.6 l-5.9,3.1 M19.1,12.8L9.7,5.1l1.1,7.7 M13.4,29.8l1,7.3l6.6,1.6 M11.6,18.4l1,6.1 M32.8,41.9 M26.6,40.4 M27.3,40.2l6.1,1.6 M49.9,52.1l-5.6-7.6l-4.9-1.2",lineX:"M15.2,30 M19.7,15.6V1.9H29 M34.8,1.9H40.4 M55.3,15.6V1.9H45.9 M19.7,44.4V58.1H29 M34.8,58.1H40.4 M55.3,44.4 V58.1H45.9 M12.5,20.3l-9.4,9.6l9.6,9.8 M3.1,29.9h16.5 M62.5,20.3l9.4,9.6L62.3,39.7 M71.9,29.9H55.4",lineY:"M38.8,7.7 M52.7,12h13.2v9 M65.9,26.6V32 M52.7,46.3h13.2v-9 M24.9,12H11.8v9 M11.8,26.6V32 M24.9,46.3H11.8v-9 M48.2,5.1l-9.3-9l-9.4,9.2 M38.9-3.9V12 M48.2,53.3l-9.3,9l-9.4-9.2 M38.9,62.3V46.4",keep:"M4,10.5V1h10.3 M20.7,1h6.1 M33,1h6.1 M55.4,10.5V1H45.2 M4,17.3v6.6 M55.6,17.3v6.6 M4,30.5V40h10.3 M20.7,40 h6.1 M33,40h6.1 M55.4,30.5V40H45.2 M21,18.9h62.9v48.6H21V18.9z",clear:"M22,14.7l30.9,31 M52.9,14.7L22,45.7 M4.7,16.8V4.2h13.1 M26,4.2h7.8 M41.6,4.2h7.8 M70.3,16.8V4.2H57.2 M4.7,25.9v8.6 M70.3,25.9v8.6 M4.7,43.2v12.6h13.1 M26,55.8h7.8 M41.6,55.8h7.8 M70.3,43.2v12.6H57.2"},title:t.getLocale(["toolbox","brush","title"])}},e}(uN);var VE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.layoutMode={type:"box",ignoreSize:!0},n}return n(e,t),e.type="title",e.defaultOption={zlevel:0,z:6,show:!0,text:"",target:"blank",subtext:"",subtarget:"blank",left:0,top:0,backgroundColor:"rgba(0,0,0,0)",borderColor:"#ccc",borderWidth:0,padding:5,itemGap:10,textStyle:{fontSize:18,fontWeight:"bold",color:"#464646"},subtextStyle:{fontSize:12,color:"#6E7079"}},e}(Nc),FE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.render=function(t,e,n){if(this.group.removeAll(),t.get("show")){var i=this.group,r=t.getModel("textStyle"),o=t.getModel("subtextStyle"),a=t.get("textAlign"),s=tt(t.get("textBaseline"),t.get("textVerticalAlign")),l=new ls({style:nh(r,{text:t.get("text"),fill:r.getTextColor()},{disableBox:!0}),z2:10}),u=l.getBoundingRect(),h=t.get("subtext"),c=new ls({style:nh(o,{text:h,fill:o.getTextColor(),y:u.height+t.get("itemGap"),verticalAlign:"top"},{disableBox:!0}),z2:10}),p=t.get("link"),d=t.get("sublink"),f=t.get("triggerEvent",!0);l.silent=!p&&!f,c.silent=!d&&!f,p&&l.on("click",(function(){wc(p,"_"+t.get("target"))})),d&&c.on("click",(function(){wc(d,"_"+t.get("subtarget"))})),ys(l).eventData=ys(c).eventData=f?{componentType:"title",componentIndex:t.componentIndex}:null,i.add(l),h&&i.add(c);var g=i.getBoundingRect(),y=t.getBoxLayoutParams();y.width=g.width,y.height=g.height;var v=Ac(y,{width:n.getWidth(),height:n.getHeight()},t.get("padding"));a||("middle"===(a=t.get("left")||t.get("right"))&&(a="center"),"right"===a?v.x+=v.width:"center"===a&&(v.x+=v.width/2)),s||("center"===(s=t.get("top")||t.get("bottom"))&&(s="middle"),"bottom"===s?v.y+=v.height:"middle"===s&&(v.y+=v.height/2),s=s||"top"),i.x=v.x,i.y=v.y,i.markRedraw();var m={align:a,verticalAlign:s};l.setStyle(m),c.setStyle(m),g=i.getBoundingRect();var _=v.margin,x=t.getItemStyle(["color","opacity"]);x.fill=t.get("backgroundColor");var b=new os({shape:{x:g.x-_[3],y:g.y-_[0],width:g.width+_[1]+_[3],height:g.height+_[0]+_[2],r:t.get("borderRadius")},style:x,subPixelOptimize:!0,silent:!0});i.add(b)}},e.type="title",e}(pf);var GE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.layoutMode="box",n}return n(e,t),e.prototype.init=function(t,e,n){this.mergeDefaultAndTheme(t,n),this._initData()},e.prototype.mergeOption=function(e){t.prototype.mergeOption.apply(this,arguments),this._initData()},e.prototype.setCurrentIndex=function(t){null==t&&(t=this.option.currentIndex);var e=this._data.count();this.option.loop?t=(t%e+e)%e:(t>=e&&(t=e-1),t<0&&(t=0)),this.option.currentIndex=t},e.prototype.getCurrentIndex=function(){return this.option.currentIndex},e.prototype.isIndexMax=function(){return this.getCurrentIndex()>=this._data.count()-1},e.prototype.setPlayState=function(t){this.option.autoPlay=!!t},e.prototype.getPlayState=function(){return!!this.option.autoPlay},e.prototype._initData=function(){var t,e=this.option,n=e.data||[],i=e.axisType,r=this._names=[];"category"===i?(t=[],P(n,(function(e,n){var i,o=Tr(wr(e),"");X(e)?(i=w(e)).value=n:i=n,t.push(i),r.push(o)}))):t=n;var o={category:"ordinal",time:"time",value:"number"}[i]||"number";(this._data=new Pm([{name:"value",type:o}],this)).initData(t,r)},e.prototype.getData=function(){return this._data},e.prototype.getCategories=function(){if("category"===this.get("axisType"))return this._names.slice()},e.type="timeline",e.defaultOption={zlevel:0,z:4,show:!0,axisType:"time",realtime:!0,left:"20%",top:null,right:"20%",bottom:0,width:null,height:40,padding:5,controlPosition:"left",autoPlay:!1,rewind:!1,loop:!0,playInterval:2e3,currentIndex:0,itemStyle:{},label:{color:"#000"},data:[]},e}(Nc),HE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="timeline.slider",e.defaultOption=Th(GE.defaultOption,{backgroundColor:"rgba(0,0,0,0)",borderColor:"#ccc",borderWidth:0,orient:"horizontal",inverse:!1,tooltip:{trigger:"item"},symbol:"circle",symbolSize:12,lineStyle:{show:!0,width:2,color:"#DAE1F5"},label:{position:"auto",show:!0,interval:"auto",rotate:0,color:"#A4B1D7"},itemStyle:{color:"#A4B1D7",borderWidth:1},checkpointStyle:{symbol:"circle",symbolSize:15,color:"#316bf3",borderColor:"#fff",borderWidth:2,shadowBlur:2,shadowOffsetX:1,shadowOffsetY:1,shadowColor:"rgba(0, 0, 0, 0.3)",animation:!0,animationDuration:300,animationEasing:"quinticInOut"},controlStyle:{show:!0,showPlayBtn:!0,showPrevBtn:!0,showNextBtn:!0,itemSize:24,itemGap:12,position:"left",playIcon:"path://M31.6,53C17.5,53,6,41.5,6,27.4S17.5,1.8,31.6,1.8C45.7,1.8,57.2,13.3,57.2,27.4S45.7,53,31.6,53z M31.6,3.3 C18.4,3.3,7.5,14.1,7.5,27.4c0,13.3,10.8,24.1,24.1,24.1C44.9,51.5,55.7,40.7,55.7,27.4C55.7,14.1,44.9,3.3,31.6,3.3z M24.9,21.3 c0-2.2,1.6-3.1,3.5-2l10.5,6.1c1.899,1.1,1.899,2.9,0,4l-10.5,6.1c-1.9,1.1-3.5,0.2-3.5-2V21.3z",stopIcon:"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",nextIcon:"M2,18.5A1.52,1.52,0,0,1,.92,18a1.49,1.49,0,0,1,0-2.12L7.81,9.36,1,3.11A1.5,1.5,0,1,1,3,.89l8,7.34a1.48,1.48,0,0,1,.49,1.09,1.51,1.51,0,0,1-.46,1.1L3,18.08A1.5,1.5,0,0,1,2,18.5Z",prevIcon:"M10,.5A1.52,1.52,0,0,1,11.08,1a1.49,1.49,0,0,1,0,2.12L4.19,9.64,11,15.89a1.5,1.5,0,1,1-2,2.22L1,10.77A1.48,1.48,0,0,1,.5,9.68,1.51,1.51,0,0,1,1,8.58L9,.92A1.5,1.5,0,0,1,10,.5Z",prevBtnSize:18,nextBtnSize:18,color:"#A4B1D7",borderColor:"#A4B1D7",borderWidth:1},emphasis:{label:{show:!0,color:"#6f778d"},itemStyle:{color:"#316BF3"},controlStyle:{color:"#316BF3",borderColor:"#316BF3",borderWidth:2}},progress:{lineStyle:{color:"#316BF3"},itemStyle:{color:"#316BF3"},label:{color:"#6f778d"}},data:[]}),e}(GE);L(HE,yd.prototype);var WE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="timeline",e}(pf),YE=function(t){function e(e,n,i,r){var o=t.call(this,e,n,i)||this;return o.type=r||"value",o}return n(e,t),e.prototype.getLabelModel=function(){return this.model.getModel("label")},e.prototype.isHorizontal=function(){return"horizontal"===this.model.get("orient")},e}(vx),XE=Math.PI,UE=Lr(),ZE=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(t,e){this.api=e},e.prototype.render=function(t,e,n){if(this.model=t,this.api=n,this.ecModel=e,this.group.removeAll(),t.get("show",!0)){var i=this._layout(t,n),r=this._createGroup("_mainGroup"),o=this._createGroup("_labelGroup"),a=this._axis=this._createAxis(i,t);t.formatTooltip=function(t){return Yd("nameValue",{noName:!0,value:a.scale.getLabel({value:t})})},P(["AxisLine","AxisTick","Control","CurrentPointer"],(function(e){this["_render"+e](i,r,a,t)}),this),this._renderAxisLabel(i,o,a,t),this._position(i,t)}this._doPlayStop(),this._updateTicksStatus()},e.prototype.remove=function(){this._clearTimer(),this.group.removeAll()},e.prototype.dispose=function(){this._clearTimer()},e.prototype._layout=function(t,e){var n,i,r,o,a=t.get(["label","position"]),s=t.get("orient"),l=function(t,e){return Ac(t.getBoxLayoutParams(),{width:e.getWidth(),height:e.getHeight()},t.get("padding"))}(t,e),u={horizontal:"center",vertical:(n=null==a||"auto"===a?"horizontal"===s?l.y+l.height/2<e.getHeight()/2?"-":"+":l.x+l.width/2<e.getWidth()/2?"+":"-":H(a)?{horizontal:{top:"-",bottom:"+"},vertical:{left:"-",right:"+"}}[s][a]:a)>=0||"+"===n?"left":"right"},h={horizontal:n>=0||"+"===n?"top":"bottom",vertical:"middle"},c={horizontal:0,vertical:XE/2},p="vertical"===s?l.height:l.width,d=t.getModel("controlStyle"),f=d.get("show",!0),g=f?d.get("itemSize"):0,y=f?d.get("itemGap"):0,v=g+y,m=t.get(["label","rotate"])||0;m=m*XE/180;var _=d.get("position",!0),x=f&&d.get("showPlayBtn",!0),b=f&&d.get("showPrevBtn",!0),w=f&&d.get("showNextBtn",!0),S=0,M=p;"left"===_||"bottom"===_?(x&&(i=[0,0],S+=v),b&&(r=[S,0],S+=v),w&&(o=[M-g,0],M-=v)):(x&&(i=[M-g,0],M-=v),b&&(r=[0,0],S+=v),w&&(o=[M-g,0],M-=v));var I=[S,M];return t.get("inverse")&&I.reverse(),{viewRect:l,mainLength:p,orient:s,rotation:c[s],labelRotation:m,labelPosOpt:n,labelAlign:t.get(["label","align"])||u[s],labelBaseline:t.get(["label","verticalAlign"])||t.get(["label","baseline"])||h[s],playPosition:i,prevBtnPosition:r,nextBtnPosition:o,axisExtent:I,controlSize:g,controlGap:y}},e.prototype._position=function(t,e){var n=this._mainGroup,i=this._labelGroup,r=t.viewRect;if("vertical"===t.orient){var o=[1,0,0,1,0,0],a=r.x,s=r.y+r.height;me(o,o,[-a,-s]),_e(o,o,-XE/2),me(o,o,[a,s]),(r=r.clone()).applyTransform(o)}var l=y(r),u=y(n.getBoundingRect()),h=y(i.getBoundingRect()),c=[n.x,n.y],p=[i.x,i.y];p[0]=c[0]=l[0][0];var d,f=t.labelPosOpt;null==f||H(f)?(v(c,u,l,1,d="+"===f?0:1),v(p,h,l,1,1-d)):(v(c,u,l,1,d=f>=0?0:1),p[1]=c[1]+f);function g(t){t.originX=l[0][0]-t.x,t.originY=l[1][0]-t.y}function y(t){return[[t.x,t.x+t.width],[t.y,t.y+t.height]]}function v(t,e,n,i,r){t[i]+=n[i][r]-e[i][r]}n.setPosition(c),i.setPosition(p),n.rotation=i.rotation=t.rotation,g(n),g(i)},e.prototype._createAxis=function(t,e){var n=e.getData(),i=e.get("axisType"),r=function(t,e){if(e=e||t.get("type"))switch(e){case"category":return new Qm({ordinalMeta:t.getCategories(),extent:[1/0,-1/0]});case"time":return new g_({locale:t.ecModel.getLocaleModel(),useUTC:t.ecModel.get("useUTC")});default:return new e_}}(e,i);r.getTicks=function(){return n.mapArray(["value"],(function(t){return{value:t}}))};var o=n.getDataExtent("value");r.setExtent(o[0],o[1]),r.niceTicks();var a=new YE("value",r,t.axisExtent,i);return a.model=e,a},e.prototype._createGroup=function(t){var e=this[t]=new zi;return this.group.add(e),e},e.prototype._renderAxisLine=function(t,e,n,i){var r=n.getExtent();if(i.get(["lineStyle","show"])){var o=new tu({shape:{x1:r[0],y1:0,x2:r[1],y2:0},style:I({lineCap:"round"},i.getModel("lineStyle").getLineStyle()),silent:!0,z2:1});e.add(o);var a=this._progressLine=new tu({shape:{x1:r[0],x2:this._currentPointer?this._currentPointer.x:r[0],y1:0,y2:0},style:T({lineCap:"round",lineWidth:o.style.lineWidth},i.getModel(["progress","lineStyle"]).getLineStyle()),silent:!0,z2:1});e.add(a)}},e.prototype._renderAxisTick=function(t,e,n,i){var r=this,o=i.getData(),a=n.scale.getTicks();this._tickSymbols=[],P(a,(function(t){var a=n.dataToCoord(t.value),s=o.getItemModel(t.value),l=s.getModel("itemStyle"),u=s.getModel(["emphasis","itemStyle"]),h=s.getModel(["progress","itemStyle"]),c={x:a,y:0,onclick:B(r._changeTimeline,r,t.value)},p=jE(s,l,e,c);p.ensureState("emphasis").style=u.getItemStyle(),p.ensureState("progress").style=h.getItemStyle(),Js(p);var d=ys(p);s.get("tooltip")?(d.dataIndex=t.value,d.dataModel=i):d.dataIndex=d.dataModel=null,r._tickSymbols.push(p)}))},e.prototype._renderAxisLabel=function(t,e,n,i){var r=this;if(n.getLabelModel().get("show")){var o=i.getData(),a=n.getViewLabels();this._tickLabels=[],P(a,(function(i){var a=i.tickValue,s=o.getItemModel(a),l=s.getModel("label"),u=s.getModel(["emphasis","label"]),h=s.getModel(["progress","label"]),c=n.dataToCoord(i.tickValue),p=new ls({x:c,y:0,rotation:t.labelRotation-t.rotation,onclick:B(r._changeTimeline,r,a),silent:!1,style:nh(l,{text:i.formattedLabel,align:t.labelAlign,verticalAlign:t.labelBaseline})});p.ensureState("emphasis").style=nh(u),p.ensureState("progress").style=nh(h),e.add(p),Js(p),UE(p).dataIndex=a,r._tickLabels.push(p)}))}},e.prototype._renderControl=function(t,e,n,i){var r=t.controlSize,o=t.rotation,a=i.getModel("controlStyle").getItemStyle(),s=i.getModel(["emphasis","controlStyle"]).getItemStyle(),l=i.getPlayState(),u=i.get("inverse",!0);function h(t,n,l,u){if(t){var h=Yn(tt(i.get(["controlStyle",n+"BtnSize"]),r),r),c=function(t,e,n,i){var r=i.style,o=Uu(t.get(["controlStyle",e]),i||{},new Rn(n[0],n[1],n[2],n[3]));r&&o.setStyle(r);return o}(i,n+"Icon",[0,-h/2,h,h],{position:t,origin:[r/2,0],rotation:u?-o:0,rectHover:!0,style:a,onclick:l});c.ensureState("emphasis").style=s,e.add(c),Js(c)}}h(t.nextBtnPosition,"next",B(this._changeTimeline,this,u?"-":"+")),h(t.prevBtnPosition,"prev",B(this._changeTimeline,this,u?"+":"-")),h(t.playPosition,l?"stop":"play",B(this._handlePlayClick,this,!l),!0)},e.prototype._renderCurrentPointer=function(t,e,n,i){var r=i.getData(),o=i.getCurrentIndex(),a=r.getItemModel(o).getModel("checkpointStyle"),s=this,l={onCreate:function(t){t.draggable=!0,t.drift=B(s._handlePointerDrag,s),t.ondragend=B(s._handlePointerDragend,s),qE(t,s._progressLine,o,n,i,!0)},onUpdate:function(t){qE(t,s._progressLine,o,n,i)}};this._currentPointer=jE(a,a,this._mainGroup,{},this._currentPointer,l)},e.prototype._handlePlayClick=function(t){this._clearTimer(),this.api.dispatchAction({type:"timelinePlayChange",playState:t,from:this.uid})},e.prototype._handlePointerDrag=function(t,e,n){this._clearTimer(),this._pointerChangeTimeline([n.offsetX,n.offsetY])},e.prototype._handlePointerDragend=function(t){this._pointerChangeTimeline([t.offsetX,t.offsetY],!0)},e.prototype._pointerChangeTimeline=function(t,e){var n=this._toAxisCoord(t)[0],i=qi(this._axis.getExtent().slice());n>i[1]&&(n=i[1]),n<i[0]&&(n=i[0]),this._currentPointer.x=n,this._currentPointer.markRedraw(),this._progressLine.shape.x2=n,this._progressLine.dirty();var r=this._findNearestTick(n),o=this.model;(e||r!==o.getCurrentIndex()&&o.get("realtime"))&&this._changeTimeline(r)},e.prototype._doPlayStop=function(){var t=this;this._clearTimer(),this.model.getPlayState()&&(this._timer=setTimeout((function(){var e=t.model;t._changeTimeline(e.getCurrentIndex()+(e.get("rewind",!0)?-1:1))}),this.model.get("playInterval")))},e.prototype._toAxisCoord=function(t){return Fu(t,this._mainGroup.getLocalTransform(),!0)},e.prototype._findNearestTick=function(t){var e,n=this.model.getData(),i=1/0,r=this._axis;return n.each(["value"],(function(n,o){var a=r.dataToCoord(n),s=Math.abs(a-t);s<i&&(i=s,e=o)})),e},e.prototype._clearTimer=function(){this._timer&&(clearTimeout(this._timer),this._timer=null)},e.prototype._changeTimeline=function(t){var e=this.model.getCurrentIndex();"+"===t?t=e+1:"-"===t&&(t=e-1),this.api.dispatchAction({type:"timelineChange",currentIndex:t,from:this.uid})},e.prototype._updateTicksStatus=function(){var t=this.model.getCurrentIndex(),e=this._tickSymbols,n=this._tickLabels;if(e)for(var i=0;i<e.length;i++)e&&e[i]&&e[i].toggleState("progress",i<t);if(n)for(i=0;i<n.length;i++)n&&n[i]&&n[i].toggleState("progress",UE(n[i]).dataIndex<=t)},e.type="timeline.slider",e}(WE);function jE(t,e,n,i,r,o){var a=e.get("color");r?(r.setColor(a),n.add(r),o&&o.onUpdate(r)):((r=uy(t.get("symbol"),-1,-1,2,2,a)).setStyle("strokeNoScale",!0),n.add(r),o&&o.onCreate(r));var s=e.getItemStyle(["color"]);r.setStyle(s),i=S({rectHover:!0,z2:100},i,!0);var l=t.get("symbolSize");l=l instanceof Array?l.slice():[+l,+l],i.scaleX=l[0]/2,i.scaleY=l[1]/2;var u=t.get("symbolOffset");u&&(i.x=i.x||0,i.y=i.y||0,i.x+=Zi(u[0],l[0]),i.y+=Zi(u[1],l[1]));var h=t.get("symbolRotate");return i.rotation=(h||0)*Math.PI/180||0,r.attr(i),r.updateTransform(),r}function qE(t,e,n,i,r,o){if(!t.dragging){var a=r.getModel("checkpointStyle"),s=i.dataToCoord(r.getData().get("value",n));if(o||!a.get("animation",!0))t.attr({x:s,y:0}),e&&e.attr({shape:{x2:s}});else{var l={duration:a.get("animationDuration",!0),easing:a.get("animationEasing",!0)};t.stopAnimation(null,!0),t.animateTo({x:s,y:0},l),e&&e.animateTo({shape:{x2:s}},l)}}}function KE(t){var e=t&&t.timeline;F(e)||(e=e?[e]:[]),P(e,(function(t){t&&function(t){var e=t.type,n={number:"value",time:"time"};n[e]&&(t.axisType=n[e],delete t.type);if($E(t),JE(t,"controlPosition")){var i=t.controlStyle||(t.controlStyle={});JE(i,"position")||(i.position=t.controlPosition),"none"!==i.position||JE(i,"show")||(i.show=!1,delete i.position),delete t.controlPosition}P(t.data||[],(function(t){X(t)&&!F(t)&&(!JE(t,"value")&&JE(t,"name")&&(t.value=t.name),$E(t))}))}(t)}))}function $E(t){var e=t.itemStyle||(t.itemStyle={}),n=e.emphasis||(e.emphasis={}),i=t.label||t.label||{},r=i.normal||(i.normal={}),o={normal:1,emphasis:1};P(i,(function(t,e){o[e]||JE(r,e)||(r[e]=t)})),n.label&&!JE(i,"emphasis")&&(i.emphasis=n.label,delete n.label)}function JE(t,e){return t.hasOwnProperty(e)}function QE(t){xr(t,"label",["show"])}var tz=Lr(),ez=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.createdBySelf=!1,n}return n(e,t),e.prototype.init=function(t,e,n){this.mergeDefaultAndTheme(t,n),this._mergeOption(t,n,!1,!0)},e.prototype.isAnimationEnabled=function(){if(a.node)return!1;var t=this.__hostSeries;return this.getShallow("animation")&&t&&t.isAnimationEnabled()},e.prototype.mergeOption=function(t,e){this._mergeOption(t,e,!1,!1)},e.prototype._mergeOption=function(t,e,n,i){var r=this.mainType;n||e.eachSeries((function(t){var n=t.get(this.mainType,!0),o=tz(t)[r];n&&n.data?(o?o._mergeOption(n,e,!0):(i&&QE(n),P(n.data,(function(t){t instanceof Array?(QE(t[0]),QE(t[1])):QE(t)})),I(o=this.createMarkerModelFromSeries(n,this,e),{mainType:this.mainType,seriesIndex:t.seriesIndex,name:t.name,createdBySelf:!0}),o.__hostSeries=t),tz(t)[r]=o):tz(t)[r]=null}),this)},e.prototype.formatTooltip=function(t,e,n){var i=this.getData(),r=this.getRawValue(t),o=i.getName(t);return Yd("section",{header:this.name,blocks:[Yd("nameValue",{name:o,value:r,noName:!o,noValue:null==r})]})},e.prototype.getData=function(){return this._data},e.prototype.setData=function(t){this._data=t},e.getMarkerModelFromSeries=function(t,e){return tz(t)[e]},e.type="marker",e.dependencies=["series","grid","polar","geo"],e}(Nc);L(ez,yd.prototype);var nz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.createMarkerModelFromSeries=function(t,n,i){return new e(t,n,i)},e.type="markPoint",e.defaultOption={zlevel:0,z:5,symbol:"pin",symbolSize:50,tooltip:{trigger:"item"},label:{show:!0,position:"inside"},itemStyle:{borderWidth:2},emphasis:{label:{show:!0}}},e}(ez);function iz(t,e,n,i,r,o){var a=[],s=Fm(e,i)?e.getCalculationInfo("stackResultDimension"):i,l=uz(e,s,t),u=e.indicesOfNearest(s,l)[0];a[r]=e.get(n,u),a[o]=e.get(s,u);var h=e.get(i,u),c=Ki(e.get(i,u));return(c=Math.min(c,20))>=0&&(a[o]=+a[o].toFixed(c)),[a,h]}var rz={min:V(iz,"min"),max:V(iz,"max"),average:V(iz,"average"),median:V(iz,"median")};function oz(t,e){var n=t.getData(),i=t.coordinateSystem;if(e&&!function(t){return!isNaN(parseFloat(t.x))&&!isNaN(parseFloat(t.y))}(e)&&!F(e.coord)&&i){var r=i.dimensions,o=az(e,n,i,t);if((e=w(e)).type&&rz[e.type]&&o.baseAxis&&o.valueAxis){var a=A(r,o.baseAxis.dim),s=A(r,o.valueAxis.dim),l=rz[e.type](n,o.baseDataDim,o.valueDataDim,a,s);e.coord=l[0],e.value=l[1]}else{for(var u=[null!=e.xAxis?e.xAxis:e.radiusAxis,null!=e.yAxis?e.yAxis:e.angleAxis],h=0;h<2;h++)rz[u[h]]&&(u[h]=uz(n,n.mapDimension(r[h]),u[h]));e.coord=u}}return e}function az(t,e,n,i){var r={};return null!=t.valueIndex||null!=t.valueDim?(r.valueDataDim=null!=t.valueIndex?e.getDimension(t.valueIndex):t.valueDim,r.valueAxis=n.getAxis(function(t,e){var n=t.getData(),i=n.dimensions;e=n.getDimension(e);for(var r=0;r<i.length;r++){var o=n.getDimensionInfo(i[r]);if(o.name===e)return o.coordDim}}(i,r.valueDataDim)),r.baseAxis=n.getOtherAxis(r.valueAxis),r.baseDataDim=e.mapDimension(r.baseAxis.dim)):(r.baseAxis=i.getBaseAxis(),r.valueAxis=n.getOtherAxis(r.baseAxis),r.baseDataDim=e.mapDimension(r.baseAxis.dim),r.valueDataDim=e.mapDimension(r.valueAxis.dim)),r}function sz(t,e){return!(t&&t.containData&&e.coord&&!function(t){return!(isNaN(parseFloat(t.x))&&isNaN(parseFloat(t.y)))}(e))||t.containData(e.coord)}function lz(t,e,n,i){return i<2?t.coord&&t.coord[i]:t.value}function uz(t,e,n){if("average"===n){var i=0,r=0;return t.each(e,(function(t,e){isNaN(t)||(i+=t,r++)})),i/r}return"median"===n?t.getMedian(e):t.getDataExtent(e)["max"===n?1:0]}var hz=Lr(),cz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.init=function(){this.markerGroupMap=ht()},e.prototype.render=function(t,e,n){var i=this,r=this.markerGroupMap;r.each((function(t){hz(t).keep=!1})),e.eachSeries((function(t){var r=ez.getMarkerModelFromSeries(t,i.type);r&&i.renderSeries(t,r,e,n)})),r.each((function(t){!hz(t).keep&&i.group.remove(t.group)}))},e.prototype.markKeep=function(t){hz(t).keep=!0},e.prototype.blurSeries=function(t){var e=this;P(t,(function(t){var n=ez.getMarkerModelFromSeries(t,e.type);n&&n.getData().eachItemGraphicEl((function(t){t&&Ys(t)}))}))},e.type="marker",e}(pf);function pz(t,e,n){var i=e.coordinateSystem;t.each((function(r){var o,a=t.getItemModel(r),s=Zi(a.get("x"),n.getWidth()),l=Zi(a.get("y"),n.getHeight());if(isNaN(s)||isNaN(l)){if(e.getMarkerPosition)o=e.getMarkerPosition(t.getValues(t.dimensions,r));else if(i){var u=t.get(i.dimensions[0],r),h=t.get(i.dimensions[1],r);o=i.dataToPoint([u,h])}}else o=[s,l];isNaN(s)||(o[0]=s),isNaN(l)||(o[1]=l),t.setItemLayout(r,o)}))}var dz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.updateTransform=function(t,e,n){e.eachSeries((function(t){var e=ez.getMarkerModelFromSeries(t,"markPoint");e&&(pz(e.getData(),t,n),this.markerGroupMap.get(t.id).updateLayout())}),this)},e.prototype.renderSeries=function(t,e,n,i){var r=t.coordinateSystem,o=t.id,a=t.getData(),s=this.markerGroupMap,l=s.get(o)||s.set(o,new Tb),u=function(t,e,n){var i;i=t?O(t&&t.dimensions,(function(t){return T({name:t},e.getData().getDimensionInfo(e.getData().mapDimension(t))||{})})):[{name:"value",type:"float"}];var r=new Pm(i,n),o=O(n.get("data"),V(oz,e));t&&(o=N(o,V(sz,t)));return r.initData(o,null,t?lz:function(t){return t.value}),r}(r,t,e);e.setData(u),pz(e.getData(),t,i),u.each((function(t){var n=u.getItemModel(t),i=n.getShallow("symbol"),r=n.getShallow("symbolSize"),o=n.getShallow("symbolRotate");if(G(i)||G(r)||G(o)){var s=e.getRawValue(t),l=e.getDataParams(t);G(i)&&(i=i(s,l)),G(r)&&(r=r(s,l)),G(o)&&(o=o(s,l))}var h=n.getModel("itemStyle").getItemStyle(),c=dg(a,"color");h.fill||(h.fill=c),u.setItemVisual(t,{symbol:i,symbolSize:r,symbolRotate:o,style:h})})),l.updateData(u),this.group.add(l.group),u.eachItemGraphicEl((function(t){t.traverse((function(t){ys(t).dataModel=e}))})),this.markKeep(l),l.group.silent=e.get("silent")||t.get("silent")},e.type="markPoint",e}(cz);var fz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.createMarkerModelFromSeries=function(t,n,i){return new e(t,n,i)},e.type="markLine",e.defaultOption={zlevel:0,z:5,symbol:["circle","arrow"],symbolSize:[8,16],precision:2,tooltip:{trigger:"item"},label:{show:!0,position:"end",distance:5},lineStyle:{type:"dashed"},emphasis:{label:{show:!0},lineStyle:{width:3}},animationEasing:"linear"},e}(ez),gz=Lr(),yz=function(t,e,n,i){var r,o=t.getData();if(F(i))r=i;else{var a=i.type;if("min"===a||"max"===a||"average"===a||"median"===a||null!=i.xAxis||null!=i.yAxis){var s=void 0,l=void 0;if(null!=i.yAxis||null!=i.xAxis)s=e.getAxis(null!=i.yAxis?"y":"x"),l=Q(i.yAxis,i.xAxis);else{var u=az(i,o,e,t);s=u.valueAxis,l=uz(o,Gm(o,u.valueDataDim),a)}var h="x"===s.dim?0:1,c=1-h,p=w(i),d={coord:[]};p.type=null,p.coord=[],p.coord[c]=-1/0,d.coord[c]=1/0;var f=n.get("precision");f>=0&&"number"==typeof l&&(l=+l.toFixed(Math.min(f,20))),p.coord[h]=d.coord[h]=l,r=[p,d,{type:a,valueIndex:i.valueIndex,value:l}]}else r=[]}var g=[oz(t,r[0]),oz(t,r[1]),I({},r[2])];return g[2].type=g[2].type||null,S(g[2],g[0]),S(g[2],g[1]),g};function vz(t){return!isNaN(t)&&!isFinite(t)}function mz(t,e,n,i){var r=1-t,o=i.dimensions[t];return vz(e[r])&&vz(n[r])&&e[t]===n[t]&&i.getAxis(o).containData(e[t])}function _z(t,e){if("cartesian2d"===t.type){var n=e[0].coord,i=e[1].coord;if(n&&i&&(mz(1,n,i,t)||mz(0,n,i,t)))return!0}return sz(t,e[0])&&sz(t,e[1])}function xz(t,e,n,i,r){var o,a=i.coordinateSystem,s=t.getItemModel(e),l=Zi(s.get("x"),r.getWidth()),u=Zi(s.get("y"),r.getHeight());if(isNaN(l)||isNaN(u)){if(i.getMarkerPosition)o=i.getMarkerPosition(t.getValues(t.dimensions,e));else{var h=a.dimensions,c=t.get(h[0],e),p=t.get(h[1],e);o=a.dataToPoint([c,p])}if(Wb(a,"cartesian2d")){var d=a.getAxis("x"),f=a.getAxis("y");h=a.dimensions;vz(t.get(h[0],e))?o[0]=d.toGlobalCoord(d.getExtent()[n?0:1]):vz(t.get(h[1],e))&&(o[1]=f.toGlobalCoord(f.getExtent()[n?0:1]))}isNaN(l)||(o[0]=l),isNaN(u)||(o[1]=u)}else o=[l,u];t.setItemLayout(e,o)}var bz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.updateTransform=function(t,e,n){e.eachSeries((function(t){var e=ez.getMarkerModelFromSeries(t,"markLine");if(e){var i=e.getData(),r=gz(e).from,o=gz(e).to;r.each((function(e){xz(r,e,!0,t,n),xz(o,e,!1,t,n)})),i.each((function(t){i.setItemLayout(t,[r.getItemLayout(t),o.getItemLayout(t)])})),this.markerGroupMap.get(t.id).updateLayout()}}),this)},e.prototype.renderSeries=function(t,e,n,i){var r=t.coordinateSystem,o=t.id,a=t.getData(),s=this.markerGroupMap,l=s.get(o)||s.set(o,new dC);this.group.add(l.group);var u=function(t,e,n){var i;i=t?O(t&&t.dimensions,(function(t){return T({name:t},e.getData().getDimensionInfo(e.getData().mapDimension(t))||{})})):[{name:"value",type:"float"}];var r=new Pm(i,n),o=new Pm(i,n),a=new Pm([],n),s=O(n.get("data"),V(yz,e,t,n));t&&(s=N(s,V(_z,t)));var l=t?lz:function(t){return t.value};return r.initData(O(s,(function(t){return t[0]})),null,l),o.initData(O(s,(function(t){return t[1]})),null,l),a.initData(O(s,(function(t){return t[2]}))),a.hasItemOption=!0,{from:r,to:o,line:a}}(r,t,e),h=u.from,c=u.to,p=u.line;gz(e).from=h,gz(e).to=c,e.setData(p);var d=e.get("symbol"),f=e.get("symbolSize");function g(e,n,r){var o=e.getItemModel(n);xz(e,n,r,t,i);var s=o.getModel("itemStyle").getItemStyle();null==s.fill&&(s.fill=dg(a,"color")),e.setItemVisual(n,{symbolRotate:o.get("symbolRotate"),symbolSize:o.get("symbolSize")||f[r?0:1],symbol:o.get("symbol",!0)||d[r?0:1],style:s})}F(d)||(d=[d,d]),F(f)||(f=[f,f]),u.from.each((function(t){g(h,t,!0),g(c,t,!1)})),p.each((function(t){var e=p.getItemModel(t).getModel("lineStyle").getLineStyle();p.setItemLayout(t,[h.getItemLayout(t),c.getItemLayout(t)]),null==e.stroke&&(e.stroke=h.getItemVisual(t,"style").fill),p.setItemVisual(t,{fromSymbolRotate:h.getItemVisual(t,"symbolRotate"),fromSymbolSize:h.getItemVisual(t,"symbolSize"),fromSymbol:h.getItemVisual(t,"symbol"),toSymbolRotate:c.getItemVisual(t,"symbolRotate"),toSymbolSize:c.getItemVisual(t,"symbolSize"),toSymbol:c.getItemVisual(t,"symbol"),style:e})})),l.updateData(p),u.line.eachItemGraphicEl((function(t,n){t.traverse((function(t){ys(t).dataModel=e}))})),this.markKeep(l),l.group.silent=e.get("silent")||t.get("silent")},e.type="markLine",e}(cz);var wz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.createMarkerModelFromSeries=function(t,n,i){return new e(t,n,i)},e.type="markArea",e.defaultOption={zlevel:0,z:1,tooltip:{trigger:"item"},animation:!1,label:{show:!0,position:"top"},itemStyle:{borderWidth:0},emphasis:{label:{show:!0,position:"top"}}},e}(ez),Sz=Lr(),Mz=function(t,e,n,i){var r=oz(t,i[0]),o=oz(t,i[1]),a=r.coord,s=o.coord;a[0]=Q(a[0],-1/0),a[1]=Q(a[1],-1/0),s[0]=Q(s[0],1/0),s[1]=Q(s[1],1/0);var l=M([{},r,o]);return l.coord=[r.coord,o.coord],l.x0=r.x,l.y0=r.y,l.x1=o.x,l.y1=o.y,l};function Iz(t){return!isNaN(t)&&!isFinite(t)}function Tz(t,e,n,i){var r=1-t;return Iz(e[r])&&Iz(n[r])}function Cz(t,e){var n=e.coord[0],i=e.coord[1];return!!(Wb(t,"cartesian2d")&&n&&i&&(Tz(1,n,i)||Tz(0,n,i)))||(sz(t,{coord:n,x:e.x0,y:e.y0})||sz(t,{coord:i,x:e.x1,y:e.y1}))}function Az(t,e,n,i,r){var o,a=i.coordinateSystem,s=t.getItemModel(e),l=Zi(s.get(n[0]),r.getWidth()),u=Zi(s.get(n[1]),r.getHeight());if(isNaN(l)||isNaN(u)){if(i.getMarkerPosition)o=i.getMarkerPosition(t.getValues(n,e));else{var h=[d=t.get(n[0],e),f=t.get(n[1],e)];a.clampData&&a.clampData(h,h),o=a.dataToPoint(h,!0)}if(Wb(a,"cartesian2d")){var c=a.getAxis("x"),p=a.getAxis("y"),d=t.get(n[0],e),f=t.get(n[1],e);Iz(d)?o[0]=c.toGlobalCoord(c.getExtent()["x0"===n[0]?0:1]):Iz(f)&&(o[1]=p.toGlobalCoord(p.getExtent()["y0"===n[1]?0:1]))}isNaN(l)||(o[0]=l),isNaN(u)||(o[1]=u)}else o=[l,u];return o}var Dz=[["x0","y0"],["x1","y0"],["x1","y1"],["x0","y1"]],Lz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.updateTransform=function(t,e,n){e.eachSeries((function(t){var e=ez.getMarkerModelFromSeries(t,"markArea");if(e){var i=e.getData();i.each((function(e){var r=O(Dz,(function(r){return Az(i,e,r,t,n)}));i.setItemLayout(e,r),i.getItemGraphicEl(e).setShape("points",r)}))}}),this)},e.prototype.renderSeries=function(t,e,n,i){var r=t.coordinateSystem,o=t.id,a=t.getData(),s=this.markerGroupMap,l=s.get(o)||s.set(o,{group:new zi});this.group.add(l.group),this.markKeep(l);var u=function(t,e,n){var i,r,o=["x0","y0","x1","y1"];t?(i=O(t&&t.dimensions,(function(t){var n=e.getData();return T({name:t},n.getDimensionInfo(n.mapDimension(t))||{})})),r=new Pm(O(o,(function(t,e){return{name:t,type:i[e%2].type}})),n)):r=new Pm(i=[{name:"value",type:"float"}],n);var a=O(n.get("data"),V(Mz,e,t,n));t&&(a=N(a,V(Cz,t)));var s=t?function(t,e,n,i){return t.coord[Math.floor(i/2)][i%2]}:function(t){return t.value};return r.initData(a,null,s),r.hasItemOption=!0,r}(r,t,e);e.setData(u),u.each((function(e){var n=O(Dz,(function(n){return Az(u,e,n,t,i)})),o=!0;P(Dz,(function(t){if(o){var n=u.get(t[0],e),i=u.get(t[1],e);(Iz(n)||r.getAxis("x").containData(n))&&(Iz(i)||r.getAxis("y").containData(i))&&(o=!1)}})),u.setItemLayout(e,{points:n,allClipped:o});var s=u.getItemModel(e).getModel("itemStyle").getItemStyle(),l=dg(a,"color");s.fill||(s.fill=l,"string"==typeof s.fill&&(s.fill=on(s.fill,.4))),s.stroke||(s.stroke=l),u.setItemVisual(e,"style",s)})),u.diff(Sz(l).data).add((function(t){var e=u.getItemLayout(t);if(!e.allClipped){var n=new ql({shape:{points:e.points}});u.setItemGraphicEl(t,n),l.group.add(n)}})).update((function(t,n){var i=Sz(l).data.getItemGraphicEl(n),r=u.getItemLayout(t);r.allClipped?i&&l.group.remove(i):(i?Ou(i,{shape:{points:r.points}},e,t):i=new ql({shape:{points:r.points}}),u.setItemGraphicEl(t,i),l.group.add(i))})).remove((function(t){var e=Sz(l).data.getItemGraphicEl(t);l.group.remove(e)})).execute(),u.eachItemGraphicEl((function(t,n){var i=u.getItemModel(n),r=u.getItemVisual(n,"style");t.useStyle(u.getItemVisual(n,"style")),th(t,eh(i),{labelFetcher:e,labelDataIndex:n,defaultText:u.getName(n)||"",inheritColor:"string"==typeof r.fill?on(r.fill,1):"#000"}),nl(t,i),Js(t),ys(t).dataModel=e})),Sz(l).data=u,l.group.silent=e.get("silent")||t.get("silent")},e.type="markArea",e}(cz);var kz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.layoutMode={type:"box",ignoreSize:!0},n}return n(e,t),e.prototype.init=function(t,e,n){this.mergeDefaultAndTheme(t,n),t.selected=t.selected||{},this._updateSelector(t)},e.prototype.mergeOption=function(e,n){t.prototype.mergeOption.call(this,e,n),this._updateSelector(e)},e.prototype._updateSelector=function(t){var e=t.selector,n=this.ecModel;!0===e&&(e=t.selector=["all","inverse"]),F(e)&&P(e,(function(t,i){H(t)&&(t={type:t}),e[i]=S(t,function(t,e){return"all"===e?{type:"all",title:t.getLocale(["legend","selector","all"])}:"inverse"===e?{type:"inverse",title:t.getLocale(["legend","selector","inverse"])}:void 0}(n,t.type))}))},e.prototype.optionUpdated=function(){this._updateData(this.ecModel);var t=this._data;if(t[0]&&"single"===this.get("selectedMode")){for(var e=!1,n=0;n<t.length;n++){var i=t[n].get("name");if(this.isSelected(i)){this.select(i),e=!0;break}}!e&&this.select(t[0].get("name"))}},e.prototype._updateData=function(t){var e=[],n=[];t.eachRawSeries((function(i){var r,o=i.name;if(n.push(o),i.legendVisualProvider){var a=i.legendVisualProvider.getAllNames();t.isSeriesFiltered(i)||(n=n.concat(a)),a.length?e=e.concat(a):r=!0}else r=!0;r&&Cr(i)&&e.push(i.name)})),this._availableNames=n;var i=O(this.get("data")||e,(function(t){return"string"!=typeof t&&"number"!=typeof t||(t={name:t}),new Sh(t,this,this.ecModel)}),this);this._data=i},e.prototype.getData=function(){return this._data},e.prototype.select=function(t){var e=this.option.selected;"single"===this.get("selectedMode")&&P(this._data,(function(t){e[t.get("name")]=!1}));e[t]=!0},e.prototype.unSelect=function(t){"single"!==this.get("selectedMode")&&(this.option.selected[t]=!1)},e.prototype.toggleSelected=function(t){var e=this.option.selected;e.hasOwnProperty(t)||(e[t]=!0),this[e[t]?"unSelect":"select"](t)},e.prototype.allSelect=function(){var t=this._data,e=this.option.selected;P(t,(function(t){e[t.get("name",!0)]=!0}))},e.prototype.inverseSelect=function(){var t=this._data,e=this.option.selected;P(t,(function(t){var n=t.get("name",!0);e.hasOwnProperty(n)||(e[n]=!0),e[n]=!e[n]}))},e.prototype.isSelected=function(t){var e=this.option.selected;return!(e.hasOwnProperty(t)&&!e[t])&&A(this._availableNames,t)>=0},e.prototype.getOrient=function(){return"vertical"===this.get("orient")?{index:1,name:"vertical"}:{index:0,name:"horizontal"}},e.type="legend.plain",e.dependencies=["series"],e.defaultOption={zlevel:0,z:4,show:!0,orient:"horizontal",left:"center",top:0,align:"auto",backgroundColor:"rgba(0,0,0,0)",borderColor:"#ccc",borderRadius:0,borderWidth:0,padding:5,itemGap:10,itemWidth:25,itemHeight:14,inactiveColor:"#ccc",inactiveBorderColor:"#ccc",itemStyle:{borderWidth:0},textStyle:{color:"#333"},selectedMode:!0,selector:!1,selectorLabel:{show:!0,borderRadius:10,padding:[3,5,3,5],fontSize:12,fontFamily:" sans-serif",color:"#666",borderWidth:1,borderColor:"#666"},emphasis:{selectorLabel:{show:!0,color:"#eee",backgroundColor:"#666"}},selectorPosition:"auto",selectorItemGap:7,selectorButtonGap:10,tooltip:{show:!1}},e}(Nc),Pz=V,Oz=P,Rz=zi,Nz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.newlineDisabled=!1,n}return n(e,t),e.prototype.init=function(){this.group.add(this._contentGroup=new Rz),this.group.add(this._selectorGroup=new Rz),this._isFirstRender=!0},e.prototype.getContentGroup=function(){return this._contentGroup},e.prototype.getSelectorGroup=function(){return this._selectorGroup},e.prototype.render=function(t,e,n){var i=this._isFirstRender;if(this._isFirstRender=!1,this.resetInner(),t.get("show",!0)){var r=t.get("align"),o=t.get("orient");r&&"auto"!==r||(r="right"===t.get("left")&&"vertical"===o?"right":"left");var a=t.get("selector",!0),s=t.get("selectorPosition",!0);!a||s&&"auto"!==s||(s="horizontal"===o?"end":"start"),this.renderInner(r,t,e,n,a,o,s);var l=t.getBoxLayoutParams(),u={width:n.getWidth(),height:n.getHeight()},h=t.get("padding"),c=Ac(l,u,h),p=this.layoutInner(t,r,c,i,a,s),d=Ac(T({width:p.width,height:p.height},l),u,h);this.group.x=d.x-p.x,this.group.y=d.y-p.y,this.group.markRedraw(),this.group.add(this._backgroundEl=fN(p,t))}},e.prototype.resetInner=function(){this.getContentGroup().removeAll(),this._backgroundEl&&this.group.remove(this._backgroundEl),this.getSelectorGroup().removeAll()},e.prototype.renderInner=function(t,e,n,i,r,o,a){var s=this.getContentGroup(),l=ht(),u=e.get("selectedMode"),h=[];n.eachRawSeries((function(t){!t.get("legendHoverLink")&&h.push(t.id)})),Oz(e.getData(),(function(r,o){var a=r.get("name");if(!this.newlineDisabled&&(""===a||"\n"===a)){var c=new Rz;return c.newline=!0,void s.add(c)}var p=n.getSeriesByName(a)[0];if(!l.get(a)){if(p){var d=p.getData(),f=d.getVisual("style"),g=f[d.getVisual("drawType")]||f.fill,y=f.stroke,v=f.decal,m=d.getVisual("legendSymbol")||"roundRect",_=d.getVisual("symbol");this._createItem(a,o,r,e,m,_,t,g,y,v,u).on("click",Pz(zz,a,null,i,h)).on("mouseover",Pz(Vz,p.name,null,i,h)).on("mouseout",Pz(Fz,p.name,null,i,h)),l.set(a,!0)}else n.eachRawSeries((function(n){if(!l.get(a)&&n.legendVisualProvider){var s=n.legendVisualProvider;if(!s.containName(a))return;var c=s.indexOfName(a),p=s.getItemVisual(c,"style"),d=p.stroke,f=p.decal,g=p.fill,y=qe(p.fill);y&&0===y[3]&&(y[3]=.2,g=an(y,"rgba"));this._createItem(a,o,r,e,"roundRect",null,t,g,d,f,u).on("click",Pz(zz,null,a,i,h)).on("mouseover",Pz(Vz,null,a,i,h)).on("mouseout",Pz(Fz,null,a,i,h)),l.set(a,!0)}}),this);0}}),this),r&&this._createSelector(r,e,i,o,a)},e.prototype._createSelector=function(t,e,n,i,r){var o=this.getSelectorGroup();Oz(t,(function(t){var i=t.type,r=new ls({style:{x:0,y:0,align:"center",verticalAlign:"middle"},onclick:function(){n.dispatchAction({type:"all"===i?"legendAllSelect":"legendInverseSelect"})}});o.add(r),th(r,{normal:e.getModel("selectorLabel"),emphasis:e.getModel(["emphasis","selectorLabel"])},{defaultText:t.title}),Js(r)}))},e.prototype._createItem=function(t,e,n,i,r,o,a,s,l,u,h){var c=i.get("itemWidth"),p=i.get("itemHeight"),d=i.get("inactiveColor"),f=i.get("inactiveBorderColor"),g=i.get("symbolKeepAspect"),y=i.getModel("itemStyle"),v=i.isSelected(t),m=new Rz,_=n.getModel("textStyle"),x=n.get("icon"),b=n.getModel("tooltip"),w=b.parentModel,S=uy(r=x||r,0,0,c,p,v?s:d,null==g||g);if(m.add(Ez(S,r,y,l,f,u,v)),!x&&o&&(o!==r||"none"===o)){var M=.8*p;"none"===o&&(o="circle");var T=uy(o,(c-M)/2,(p-M)/2,M,M,v?s:d,null==g||g);m.add(Ez(T,o,y,l,f,u,v))}var C="left"===a?c+5:-5,A=a,D=i.get("formatter"),L=t;"string"==typeof D&&D?L=D.replace("{name}",null!=t?t:""):"function"==typeof D&&(L=D(t)),m.add(new ls({style:nh(_,{text:L,x:C,y:p/2,fill:v?_.getTextColor():d,align:A,verticalAlign:"middle"})}));var k=new os({shape:m.getBoundingRect(),invisible:!0});if(b.get("show")){var P={componentType:"legend",legendIndex:i.componentIndex,name:t,$vars:["name"]};k.tooltip=I({content:t,formatter:w.get("formatter",!0)||function(t){return t.name},formatterParams:P},b.option)}return m.add(k),m.eachChild((function(t){t.silent=!0})),k.silent=!h,this.getContentGroup().add(m),Js(m),m.__legendDataIndex=e,m},e.prototype.layoutInner=function(t,e,n,i,r,o){var a=this.getContentGroup(),s=this.getSelectorGroup();Cc(t.get("orient"),a,t.get("itemGap"),n.width,n.height);var l=a.getBoundingRect(),u=[-l.x,-l.y];if(s.markRedraw(),a.markRedraw(),r){Cc("horizontal",s,t.get("selectorItemGap",!0));var h=s.getBoundingRect(),c=[-h.x,-h.y],p=t.get("selectorButtonGap",!0),d=t.getOrient().index,f=0===d?"width":"height",g=0===d?"height":"width",y=0===d?"y":"x";"end"===o?c[d]+=l[f]+p:u[d]+=h[f]+p,c[1-d]+=l[g]/2-h[g]/2,s.x=c[0],s.y=c[1],a.x=u[0],a.y=u[1];var v={x:0,y:0};return v[f]=l[f]+p+h[f],v[g]=Math.max(l[g],h[g]),v[y]=Math.min(0,h[y]+c[1-d]),v}return a.x=u[0],a.y=u[1],this.group.getBoundingRect()},e.prototype.remove=function(){this.getContentGroup().removeAll(),this._isFirstRender=!0},e.type="legend.plain",e}(pf);function Ez(t,e,n,i,r,o,a){var s;return"line"!==e&&e.indexOf("empty")<0?(s=n.getItemStyle(),t.style.stroke=i,t.style.decal=o,a||(s.stroke=r)):s=n.getItemStyle(["borderWidth","borderColor"]),t.setStyle(s),t}function zz(t,e,n,i){Fz(t,e,n,i),n.dispatchAction({type:"legendToggleSelect",name:null!=t?t:e}),Vz(t,e,n,i)}function Bz(t){for(var e,n=t.getZr().storage.getDisplayList(),i=0,r=n.length;i<r&&!(e=n[i].states.emphasis);)i++;return e&&e.hoverLayer}function Vz(t,e,n,i){Bz(n)||n.dispatchAction({type:"highlight",seriesName:t,name:e,excludeSeriesId:i})}function Fz(t,e,n,i){Bz(n)||n.dispatchAction({type:"downplay",seriesName:t,name:e,excludeSeriesId:i})}function Gz(t){var e=t.findComponents({mainType:"legend"});e&&e.length&&t.filterSeries((function(t){for(var n=0;n<e.length;n++)if(!e[n].isSelected(t.name))return!1;return!0}))}function Hz(t,e,n){var i,r={},o="toggleSelected"===t;return n.eachComponent("legend",(function(n){o&&null!=i?n[i?"select":"unSelect"](e.name):"allSelect"===t||"inverseSelect"===t?n[t]():(n[t](e.name),i=n.isSelected(e.name)),P(n.getData(),(function(t){var e=t.get("name");if("\n"!==e&&""!==e){var i=n.isSelected(e);r.hasOwnProperty(e)?r[e]=r[e]&&i:r[e]=i}}))})),"allSelect"===t||"inverseSelect"===t?{selected:r}:{name:e.name,selected:r}}function Wz(t){t.registerComponentModel(kz),t.registerComponentView(Nz),t.registerProcessor(t.PRIORITY.PROCESSOR.SERIES_FILTER,Gz),t.registerSubTypeDefaulter("legend",(function(){return"plain"})),function(t){t.registerAction("legendToggleSelect","legendselectchanged",V(Hz,"toggleSelected")),t.registerAction("legendAllSelect","legendselectall",V(Hz,"allSelect")),t.registerAction("legendInverseSelect","legendinverseselect",V(Hz,"inverseSelect")),t.registerAction("legendSelect","legendselected",V(Hz,"select")),t.registerAction("legendUnSelect","legendunselected",V(Hz,"unSelect"))}(t)}var Yz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.setScrollDataIndex=function(t){this.option.scrollDataIndex=t},e.prototype.init=function(e,n,i){var r=Pc(e);t.prototype.init.call(this,e,n,i),Xz(this,e,r)},e.prototype.mergeOption=function(e,n){t.prototype.mergeOption.call(this,e,n),Xz(this,this.option,e)},e.type="legend.scroll",e.defaultOption=Th(kz.defaultOption,{scrollDataIndex:0,pageButtonItemGap:5,pageButtonGap:null,pageButtonPosition:"end",pageFormatter:"{current}/{total}",pageIcons:{horizontal:["M0,0L12,-10L12,10z","M0,0L-12,-10L-12,10z"],vertical:["M0,0L20,0L10,-20z","M0,0L20,0L10,20z"]},pageIconColor:"#2f4554",pageIconInactiveColor:"#aaa",pageIconSize:15,pageTextStyle:{color:"#333"},animationDurationUpdate:800}),e}(kz);function Xz(t,e,n){var i=[1,1];i[t.getOrient().index]=0,kc(e,n,{type:"box",ignoreSize:!!i})}var Uz=zi,Zz=["width","height"],jz=["x","y"],qz=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.newlineDisabled=!0,n._currentIndex=0,n}return n(e,t),e.prototype.init=function(){t.prototype.init.call(this),this.group.add(this._containerGroup=new Uz),this._containerGroup.add(this.getContentGroup()),this.group.add(this._controllerGroup=new Uz)},e.prototype.resetInner=function(){t.prototype.resetInner.call(this),this._controllerGroup.removeAll(),this._containerGroup.removeClipPath(),this._containerGroup.__rectSize=null},e.prototype.renderInner=function(e,n,i,r,o,a,s){var l=this;t.prototype.renderInner.call(this,e,n,i,r,o,a,s);var u=this._controllerGroup,h=n.get("pageIconSize",!0),c=F(h)?h:[h,h];d("pagePrev",0);var p=n.getModel("pageTextStyle");function d(t,e){var i=t+"DataIndex",o=Uu(n.get("pageIcons",!0)[n.getOrient().name][e],{onclick:B(l._pageGo,l,i,n,r)},{x:-c[0]/2,y:-c[1]/2,width:c[0],height:c[1]});o.name=t,u.add(o)}u.add(new ls({name:"pageText",style:{text:"xx/xx",fill:p.getTextColor(),font:p.getFont(),verticalAlign:"middle",align:"center"},silent:!0})),d("pageNext",1)},e.prototype.layoutInner=function(t,e,n,i,r,o){var a=this.getSelectorGroup(),s=t.getOrient().index,l=Zz[s],u=jz[s],h=Zz[1-s],c=jz[1-s];r&&Cc("horizontal",a,t.get("selectorItemGap",!0));var p=t.get("selectorButtonGap",!0),d=a.getBoundingRect(),f=[-d.x,-d.y],g=w(n);r&&(g[l]=n[l]-d[l]-p);var y=this._layoutContentAndController(t,i,g,s,l,h,c,u);if(r){if("end"===o)f[s]+=y[l]+p;else{var v=d[l]+p;f[s]-=v,y[u]-=v}y[l]+=d[l]+p,f[1-s]+=y[c]+y[h]/2-d[h]/2,y[h]=Math.max(y[h],d[h]),y[c]=Math.min(y[c],d[c]+f[1-s]),a.x=f[0],a.y=f[1],a.markRedraw()}return y},e.prototype._layoutContentAndController=function(t,e,n,i,r,o,a,s){var l=this.getContentGroup(),u=this._containerGroup,h=this._controllerGroup;Cc(t.get("orient"),l,t.get("itemGap"),i?n.width:null,i?null:n.height),Cc("horizontal",h,t.get("pageButtonItemGap",!0));var c=l.getBoundingRect(),p=h.getBoundingRect(),d=this._showController=c[r]>n[r],f=[-c.x,-c.y];e||(f[i]=l[s]);var g=[0,0],y=[-p.x,-p.y],v=tt(t.get("pageButtonGap",!0),t.get("itemGap",!0));d&&("end"===t.get("pageButtonPosition",!0)?y[i]+=n[r]-p[r]:g[i]+=p[r]+v);y[1-i]+=c[o]/2-p[o]/2,l.setPosition(f),u.setPosition(g),h.setPosition(y);var m={x:0,y:0};if(m[r]=d?n[r]:c[r],m[o]=Math.max(c[o],p[o]),m[a]=Math.min(0,p[a]+y[1-i]),u.__rectSize=n[r],d){var _={x:0,y:0};_[r]=Math.max(n[r]-p[r]-v,0),_[o]=m[o],u.setClipPath(new os({shape:_})),u.__rectSize=_[r]}else h.eachChild((function(t){t.attr({invisible:!0,silent:!0})}));var x=this._getPageInfo(t);return null!=x.pageIndex&&Ou(l,{x:x.contentPosition[0],y:x.contentPosition[1]},d?t:null),this._updatePageInfoView(t,x),m},e.prototype._pageGo=function(t,e,n){var i=this._getPageInfo(e)[t];null!=i&&n.dispatchAction({type:"legendScroll",scrollDataIndex:i,legendId:e.id})},e.prototype._updatePageInfoView=function(t,e){var n=this._controllerGroup;P(["pagePrev","pageNext"],(function(i){var r=null!=e[i+"DataIndex"],o=n.childOfName(i);o&&(o.setStyle("fill",r?t.get("pageIconColor",!0):t.get("pageIconInactiveColor",!0)),o.cursor=r?"pointer":"default")}));var i=n.childOfName("pageText"),r=t.get("pageFormatter"),o=e.pageIndex,a=null!=o?o+1:0,s=e.pageCount;i&&r&&i.setStyle("text",H(r)?r.replace("{current}",null==a?"":a+"").replace("{total}",null==s?"":s+""):r({current:a,total:s}))},e.prototype._getPageInfo=function(t){var e=t.get("scrollDataIndex",!0),n=this.getContentGroup(),i=this._containerGroup.__rectSize,r=t.getOrient().index,o=Zz[r],a=jz[r],s=this._findTargetItemIndex(e),l=n.children(),u=l[s],h=l.length,c=h?1:0,p={contentPosition:[n.x,n.y],pageCount:c,pageIndex:c-1,pagePrevDataIndex:null,pageNextDataIndex:null};if(!u)return p;var d=m(u);p.contentPosition[r]=-d.s;for(var f=s+1,g=d,y=d,v=null;f<=h;++f)(!(v=m(l[f]))&&y.e>g.s+i||v&&!_(v,g.s))&&(g=y.i>g.i?y:v)&&(null==p.pageNextDataIndex&&(p.pageNextDataIndex=g.i),++p.pageCount),y=v;for(f=s-1,g=d,y=d,v=null;f>=-1;--f)(v=m(l[f]))&&_(y,v.s)||!(g.i<y.i)||(y=g,null==p.pagePrevDataIndex&&(p.pagePrevDataIndex=g.i),++p.pageCount,++p.pageIndex),g=v;return p;function m(t){if(t){var e=t.getBoundingRect(),n=e[a]+t[a];return{s:n,e:n+e[o],i:t.__legendDataIndex}}}function _(t,e){return t.e>=e&&t.s<=e+i}},e.prototype._findTargetItemIndex=function(t){return this._showController?(this.getContentGroup().eachChild((function(i,r){var o=i.__legendDataIndex;null==n&&null!=o&&(n=r),o===t&&(e=r)})),null!=e?e:n):0;var e,n},e.type="legend.scroll",e}(Nz);function Kz(t){em(Wz),t.registerComponentModel(Yz),t.registerComponentView(qz),function(t){t.registerAction("legendScroll","legendscroll",(function(t,e){var n=t.scrollDataIndex;null!=n&&e.eachComponent({mainType:"legend",subType:"scroll",query:t},(function(t){t.setScrollDataIndex(n)}))}))}(t)}var $z=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="dataZoom.inside",e.defaultOption=Th($R.defaultOption,{disabled:!1,zoomLock:!1,zoomOnMouseWheel:!0,moveOnMouseMove:!0,moveOnMouseWheel:!1,preventDefaultMouseMove:!0}),e}($R),Jz=Lr();function Qz(t,e,n){Jz(t).coordSysRecordMap.each((function(t){var i=t.dataZoomInfoMap.get(e.uid);i&&(i.getRange=n)}))}function tB(t,e){if(e){t.removeKey(e.model.uid);var n=e.controller;n&&n.dispose()}}function eB(t,e){t.dispatchAction({type:"dataZoom",animation:{easing:"cubicOut",duration:100},batch:e})}function nB(t,e,n,i){return t.coordinateSystem.containPoint([n,i])}function iB(t){t.registerProcessor(t.PRIORITY.PROCESSOR.FILTER,(function(t,e){var n=Jz(e),i=n.coordSysRecordMap||(n.coordSysRecordMap=ht());i.each((function(t){t.dataZoomInfoMap=null})),t.eachComponent({mainType:"dataZoom",subType:"inside"},(function(t){P(qR(t).infoList,(function(n){var r=n.model.uid,o=i.get(r)||i.set(r,function(t,e){var n={model:e,containsPoint:V(nB,e),dispatchAction:V(eB,t),dataZoomInfoMap:null,controller:null},i=n.controller=new QS(t.getZr());return P(["pan","zoom","scrollMove"],(function(t){i.on(t,(function(e){var i=[];n.dataZoomInfoMap.each((function(r){if(e.isAvailableBehavior(r.model.option)){var o=(r.getRange||{})[t],a=o&&o(r.dzReferCoordSysInfo,n.model.mainType,n.controller,e);!r.model.get("disabled",!0)&&a&&i.push({dataZoomId:r.model.id,start:a[0],end:a[1]})}})),i.length&&n.dispatchAction(i)}))})),n}(e,n.model));(o.dataZoomInfoMap||(o.dataZoomInfoMap=ht())).set(t.uid,{dzReferCoordSysInfo:n,model:t,getRange:null})}))})),i.each((function(t){var e,n=t.controller,r=t.dataZoomInfoMap;if(r){var o=r.keys()[0];null!=o&&(e=r.get(o))}if(e){var a=function(t){var e,n="type_",i={type_true:2,type_move:1,type_false:0,type_undefined:-1},r=!0;return t.each((function(t){var o=t.model,a=!o.get("disabled",!0)&&(!o.get("zoomLock",!0)||"move");i[n+a]>i[n+e]&&(e=a),r=r&&o.get("preventDefaultMouseMove",!0)})),{controlType:e,opt:{zoomOnMouseWheel:!0,moveOnMouseMove:!0,moveOnMouseWheel:!0,preventDefaultMouseMove:!!r}}}(r);n.enable(a.controlType,a.opt),n.setPointerChecker(t.containsPoint),Tf(t,"dispatchAction",e.model.get("throttle",!0),"fixRate")}else tB(i,t)}))}))}var rB=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="dataZoom.inside",e}return n(e,t),e.prototype.render=function(e,n,i){t.prototype.render.apply(this,arguments),e.noTarget()?this._clear():(this.range=e.getPercentRange(),Qz(i,e,{pan:B(oB.pan,this),zoom:B(oB.zoom,this),scrollMove:B(oB.scrollMove,this)}))},e.prototype.dispose=function(){this._clear(),t.prototype.dispose.apply(this,arguments)},e.prototype._clear=function(){!function(t,e){for(var n=Jz(t).coordSysRecordMap,i=n.keys(),r=0;r<i.length;r++){var o=i[r],a=n.get(o),s=a.dataZoomInfoMap;if(s){var l=e.uid;s.get(l)&&(s.removeKey(l),s.keys().length||tB(n,a))}}}(this.api,this.dataZoomModel),this.range=null},e.type="dataZoom.inside",e}(tN),oB={zoom:function(t,e,n,i){var r=this.range,o=r.slice(),a=t.axisModels[0];if(a){var s=sB[e](null,[i.originX,i.originY],a,n,t),l=(s.signal>0?s.pixelStart+s.pixelLength-s.pixel:s.pixel-s.pixelStart)/s.pixelLength*(o[1]-o[0])+o[0],u=Math.max(1/i.scale,0);o[0]=(o[0]-l)*u+l,o[1]=(o[1]-l)*u+l;var h=this.dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();return sA(0,o,[0,100],0,h.minSpan,h.maxSpan),this.range=o,r[0]!==o[0]||r[1]!==o[1]?o:void 0}},pan:aB((function(t,e,n,i,r,o){var a=sB[i]([o.oldX,o.oldY],[o.newX,o.newY],e,r,n);return a.signal*(t[1]-t[0])*a.pixel/a.pixelLength})),scrollMove:aB((function(t,e,n,i,r,o){return sB[i]([0,0],[o.scrollDelta,o.scrollDelta],e,r,n).signal*(t[1]-t[0])*o.scrollDelta}))};function aB(t){return function(e,n,i,r){var o=this.range,a=o.slice(),s=e.axisModels[0];if(s)return sA(t(a,s,e,n,i,r),a,[0,100],"all"),this.range=a,o[0]!==a[0]||o[1]!==a[1]?a:void 0}}var sB={grid:function(t,e,n,i,r){var o=n.axis,a={},s=r.model.coordinateSystem.getRect();return t=t||[0,0],"x"===o.dim?(a.pixel=e[0]-t[0],a.pixelLength=s.width,a.pixelStart=s.x,a.signal=o.inverse?1:-1):(a.pixel=e[1]-t[1],a.pixelLength=s.height,a.pixelStart=s.y,a.signal=o.inverse?-1:1),a},polar:function(t,e,n,i,r){var o=n.axis,a={},s=r.model.coordinateSystem,l=s.getRadiusAxis().getExtent(),u=s.getAngleAxis().getExtent();return t=t?s.pointToCoord(t):[0,0],e=s.pointToCoord(e),"radiusAxis"===n.mainType?(a.pixel=e[0]-t[0],a.pixelLength=l[1]-l[0],a.pixelStart=l[0],a.signal=o.inverse?1:-1):(a.pixel=e[1]-t[1],a.pixelLength=u[1]-u[0],a.pixelStart=u[0],a.signal=o.inverse?-1:1),a},singleAxis:function(t,e,n,i,r){var o=n.axis,a=r.model.coordinateSystem.getRect(),s={};return t=t||[0,0],"horizontal"===o.orient?(s.pixel=e[0]-t[0],s.pixelLength=a.width,s.pixelStart=a.x,s.signal=o.inverse?1:-1):(s.pixel=e[1]-t[1],s.pixelLength=a.height,s.pixelStart=a.y,s.signal=o.inverse?-1:1),s}};function lB(t){sN(t),t.registerComponentModel($z),t.registerComponentView(rB),iB(t)}var uB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.type="dataZoom.slider",e.layoutMode="box",e.defaultOption=Th($R.defaultOption,{show:!0,right:"ph",top:"ph",width:"ph",height:"ph",left:null,bottom:null,borderColor:"#d2dbee",borderRadius:3,backgroundColor:"rgba(47,69,84,0)",dataBackground:{lineStyle:{color:"#d2dbee",width:.5},areaStyle:{color:"#d2dbee",opacity:.2}},selectedDataBackground:{lineStyle:{color:"#8fb0f7",width:.5},areaStyle:{color:"#8fb0f7",opacity:.2}},fillerColor:"rgba(135,175,274,0.2)",handleIcon:"path://M-9.35,34.56V42m0-40V9.5m-2,0h4a2,2,0,0,1,2,2v21a2,2,0,0,1-2,2h-4a2,2,0,0,1-2-2v-21A2,2,0,0,1-11.35,9.5Z",handleSize:"100%",handleStyle:{color:"#fff",borderColor:"#ACB8D1"},moveHandleSize:7,moveHandleIcon:"path://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",moveHandleStyle:{color:"#D2DBEE",opacity:.7},showDetail:!0,showDataShadow:"auto",realtime:!0,zoomLock:!1,textStyle:{color:"#6E7079"},brushSelect:!0,brushStyle:{color:"rgba(135,175,274,0.15)"},emphasis:{handleStyle:{borderColor:"#8FB0F7"},moveHandleStyle:{color:"#8FB0F7"}}}),e}($R),hB=os,cB="horizontal",pB="vertical",dB=["line","bar","candlestick","scatter"],fB={easing:"cubicOut",duration:100},gB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._displayables={},n}return n(e,t),e.prototype.init=function(t,e){this.api=e,this._onBrush=B(this._onBrush,this),this._onBrushEnd=B(this._onBrushEnd,this)},e.prototype.render=function(e,n,i,r){if(t.prototype.render.apply(this,arguments),Tf(this,"_dispatchZoomAction",e.get("throttle"),"fixRate"),this._orient=e.getOrient(),!1!==e.get("show")){if(e.noTarget())return this._clear(),void this.group.removeAll();r&&"dataZoom"===r.type&&r.from===this.uid||this._buildView(),this._updateView()}else this.group.removeAll()},e.prototype.dispose=function(){this._clear(),t.prototype.dispose.apply(this,arguments)},e.prototype._clear=function(){var t,e,n;(n=(t=this)[e="_dispatchZoomAction"])&&n[wf]&&(t[e]=n[wf]);var i=this.api.getZr();i.off("mousemove",this._onBrush),i.off("mouseup",this._onBrushEnd)},e.prototype._buildView=function(){var t=this.group;t.removeAll(),this._brushing=!1,this._displayables.brushRect=null,this._resetLocation(),this._resetInterval();var e=this._displayables.sliderGroup=new zi;this._renderBackground(),this._renderHandle(),this._renderDataShadow(),t.add(e),this._positionGroup()},e.prototype._resetLocation=function(){var t=this.dataZoomModel,e=this.api,n=t.get("brushSelect")?7:0,i=this._findCoordRect(),r={width:e.getWidth(),height:e.getHeight()},o=this._orient===cB?{right:r.width-i.x-i.width,top:r.height-30-7-n,width:i.width,height:30}:{right:7,top:i.y,width:30,height:i.height},a=Pc(t.option);P(["right","top","width","height"],(function(t){"ph"===a[t]&&(a[t]=o[t])}));var s=Ac(a,r);this._location={x:s.x,y:s.y},this._size=[s.width,s.height],this._orient===pB&&this._size.reverse()},e.prototype._positionGroup=function(){var t=this.group,e=this._location,n=this._orient,i=this.dataZoomModel.getFirstTargetAxisModel(),r=i&&i.get("inverse"),o=this._displayables.sliderGroup,a=(this._dataShadowInfo||{}).otherAxisInverse;o.attr(n!==cB||r?n===cB&&r?{scaleY:a?1:-1,scaleX:-1}:n!==pB||r?{scaleY:a?-1:1,scaleX:-1,rotation:Math.PI/2}:{scaleY:a?-1:1,scaleX:1,rotation:Math.PI/2}:{scaleY:a?1:-1,scaleX:1});var s=t.getBoundingRect([o]);t.x=e.x-s.x,t.y=e.y-s.y,t.markRedraw()},e.prototype._getViewExtent=function(){return[0,this._size[0]]},e.prototype._renderBackground=function(){var t=this.dataZoomModel,e=this._size,n=this._displayables.sliderGroup,i=t.get("brushSelect");n.add(new hB({silent:!0,shape:{x:0,y:0,width:e[0],height:e[1]},style:{fill:t.get("backgroundColor")},z2:-40}));var r=new hB({shape:{x:0,y:0,width:e[0],height:e[1]},style:{fill:"transparent"},z2:0,onclick:B(this._onClickPanel,this)}),o=this.api.getZr();i?(r.on("mousedown",this._onBrushStart,this),r.cursor="crosshair",o.on("mousemove",this._onBrush),o.on("mouseup",this._onBrushEnd)):(o.off("mousemove",this._onBrush),o.off("mouseup",this._onBrushEnd)),n.add(r)},e.prototype._renderDataShadow=function(){var t=this._dataShadowInfo=this._prepareDataShadowInfo();if(this._displayables.dataShadowSegs=[],t){var e=this._size,n=t.series,i=n.getRawData(),r=n.getShadowDim?n.getShadowDim():t.otherDim;if(null!=r){var o=i.getDataExtent(r),a=.3*(o[1]-o[0]);o=[o[0]-a,o[1]+a];var s,l=[0,e[1]],u=[0,e[0]],h=[[e[0],0],[0,0]],c=[],p=u[1]/(i.count()-1),d=0,f=Math.round(i.count()/e[0]);i.each([r],(function(t,e){if(f>0&&e%f)d+=p;else{var n=null==t||isNaN(t)||""===t,i=n?0:Ui(t,o,l,!0);n&&!s&&e?(h.push([h[h.length-1][0],0]),c.push([c[c.length-1][0],0])):!n&&s&&(h.push([d,0]),c.push([d,0])),h.push([d,i]),c.push([d,i]),d+=p,s=n}}));for(var g=this.dataZoomModel,y=0;y<3;y++){var v=m(1===y);this._displayables.sliderGroup.add(v),this._displayables.dataShadowSegs.push(v)}}}function m(t){var e=g.getModel(t?"selectedDataBackground":"dataBackground"),n=new zi,i=new ql({shape:{points:h},segmentIgnoreThreshold:1,style:e.getModel("areaStyle").getAreaStyle(),silent:!0,z2:-20}),r=new $l({shape:{points:c},segmentIgnoreThreshold:1,style:e.getModel("lineStyle").getLineStyle(),silent:!0,z2:-19});return n.add(i),n.add(r),n}},e.prototype._prepareDataShadowInfo=function(){var t=this.dataZoomModel,e=t.get("showDataShadow");if(!1!==e){var n,i=this.ecModel;return t.eachTargetAxis((function(r,o){P(t.getAxisProxy(r,o).getTargetSeriesModels(),(function(t){if(!(n||!0!==e&&A(dB,t.get("type"))<0)){var a,s=i.getComponent(ZR(r),o).axis,l={x:"y",y:"x",radius:"angle",angle:"radius"}[r],u=t.coordinateSystem;null!=l&&u.getOtherAxis&&(a=u.getOtherAxis(s).inverse),l=t.getData().mapDimension(l),n={thisAxis:s,series:t,thisDim:r,otherDim:l,otherAxisInverse:a}}}),this)}),this),n}},e.prototype._renderHandle=function(){var t=this.group,e=this._displayables,n=e.handles=[null,null],i=e.handleLabels=[null,null],r=this._displayables.sliderGroup,o=this._size,a=this.dataZoomModel,s=this.api,l=a.get("borderRadius")||0,u=a.get("brushSelect"),h=e.filler=new hB({silent:u,style:{fill:a.get("fillerColor")},textConfig:{position:"inside"}});r.add(h),r.add(new hB({silent:!0,subPixelOptimize:!0,shape:{x:0,y:0,width:o[0],height:o[1],r:l},style:{stroke:a.get("dataBackgroundColor")||a.get("borderColor"),lineWidth:1,fill:"rgba(0,0,0,0)"}})),P([0,1],(function(e){var o=a.get("handleIcon");!ay[o]&&o.indexOf("path://")<0&&o.indexOf("image://")<0&&(o="path://"+o);var s=uy(o,-1,0,2,2,null,!0);s.attr({cursor:yB(this._orient),draggable:!0,drift:B(this._onDragMove,this,e),ondragend:B(this._onDragEnd,this),onmouseover:B(this._showDataInfo,this,!0),onmouseout:B(this._showDataInfo,this,!1),z2:5});var l=s.getBoundingRect(),u=a.get("handleSize");this._handleHeight=Zi(u,this._size[1]),this._handleWidth=l.width/l.height*this._handleHeight,s.setStyle(a.getModel("handleStyle").getItemStyle()),s.style.strokeNoScale=!0,s.rectHover=!0,s.ensureState("emphasis").style=a.getModel(["emphasis","handleStyle"]).getItemStyle(),Js(s);var h=a.get("handleColor");null!=h&&(s.style.fill=h),r.add(n[e]=s);var c=a.getModel("textStyle");t.add(i[e]=new ls({silent:!0,invisible:!0,style:{x:0,y:0,text:"",verticalAlign:"middle",align:"center",fill:c.getTextColor(),font:c.getFont()},z2:10}))}),this);var c=h;if(u){var p=Zi(a.get("moveHandleSize"),o[1]),d=e.moveHandle=new os({style:a.getModel("moveHandleStyle").getItemStyle(),silent:!0,shape:{r:[0,0,2,2],y:o[1]-.5,height:p}}),f=.8*p,g=e.moveHandleIcon=uy(a.get("moveHandleIcon"),-f/2,-f/2,f,f,"#fff",!0);g.silent=!0,g.y=o[1]+p/2-.5,d.ensureState("emphasis").style=a.getModel(["emphasis","moveHandleStyle"]).getItemStyle();var y=Math.min(o[1]/2,Math.max(p,10));(c=e.moveZone=new os({invisible:!0,shape:{y:o[1]-y,height:p+y}})).on("mouseover",(function(){s.enterEmphasis(d)})).on("mouseout",(function(){s.leaveEmphasis(d)})),r.add(d),r.add(g),r.add(c)}c.attr({draggable:!0,cursor:yB(this._orient),drift:B(this._onDragMove,this,"all"),ondragstart:B(this._showDataInfo,this,!0),ondragend:B(this._onDragEnd,this),onmouseover:B(this._showDataInfo,this,!0),onmouseout:B(this._showDataInfo,this,!1)})},e.prototype._resetInterval=function(){var t=this._range=this.dataZoomModel.getPercentRange(),e=this._getViewExtent();this._handleEnds=[Ui(t[0],[0,100],e,!0),Ui(t[1],[0,100],e,!0)]},e.prototype._updateInterval=function(t,e){var n=this.dataZoomModel,i=this._handleEnds,r=this._getViewExtent(),o=n.findRepresentativeAxisProxy().getMinMaxSpan(),a=[0,100];sA(e,i,r,n.get("zoomLock")?"all":t,null!=o.minSpan?Ui(o.minSpan,a,r,!0):null,null!=o.maxSpan?Ui(o.maxSpan,a,r,!0):null);var s=this._range,l=this._range=qi([Ui(i[0],r,a,!0),Ui(i[1],r,a,!0)]);return!s||s[0]!==l[0]||s[1]!==l[1]},e.prototype._updateView=function(t){var e=this._displayables,n=this._handleEnds,i=qi(n.slice()),r=this._size;P([0,1],(function(t){var i=e.handles[t],o=this._handleHeight;i.attr({scaleX:o/2,scaleY:o/2,x:n[t]+(t?-1:1),y:r[1]/2-o/2})}),this),e.filler.setShape({x:i[0],y:0,width:i[1]-i[0],height:r[1]});var o={x:i[0],width:i[1]-i[0]};e.moveHandle&&(e.moveHandle.setShape(o),e.moveZone.setShape(o),e.moveZone.getBoundingRect(),e.moveHandleIcon&&e.moveHandleIcon.attr("x",o.x+o.width/2));for(var a=e.dataShadowSegs,s=[0,i[0],i[1],r[0]],l=0;l<a.length;l++){var u=a[l],h=u.getClipPath();h||(h=new os,u.setClipPath(h)),h.setShape({x:s[l],y:0,width:s[l+1]-s[l],height:r[1]})}this._updateDataInfo(t)},e.prototype._updateDataInfo=function(t){var e=this.dataZoomModel,n=this._displayables,i=n.handleLabels,r=this._orient,o=["",""];if(e.get("showDetail")){var a=e.findRepresentativeAxisProxy();if(a){var s=a.getAxisModel().axis,l=this._range,u=t?a.calculateDataWindow({start:l[0],end:l[1]}).valueWindow:a.getDataValueWindow();o=[this._formatLabel(u[0],s),this._formatLabel(u[1],s)]}}var h=qi(this._handleEnds.slice());function c(t){var e=Vu(n.handles[t].parent,this.group),a=Gu(0===t?"right":"left",e),s=this._handleWidth/2+5,l=Fu([h[t]+(0===t?-s:s),this._size[1]/2],e);i[t].setStyle({x:l[0],y:l[1],verticalAlign:r===cB?"middle":a,align:r===cB?a:"center",text:o[t]})}c.call(this,0),c.call(this,1)},e.prototype._formatLabel=function(t,e){var n=this.dataZoomModel,i=n.get("labelFormatter"),r=n.get("labelPrecision");null!=r&&"auto"!==r||(r=e.getPixelPrecision());var o=null==t||isNaN(t)?"":"category"===e.type||"time"===e.type?e.scale.getLabel({value:Math.round(t)}):t.toFixed(Math.min(r,20));return G(i)?i(t,o):H(i)?i.replace("{value}",o):o},e.prototype._showDataInfo=function(t){t=this._dragging||t;var e=this._displayables,n=e.handleLabels;n[0].attr("invisible",!t),n[1].attr("invisible",!t),e.moveHandle&&this.api[t?"enterEmphasis":"leaveEmphasis"](e.moveHandle,1)},e.prototype._onDragMove=function(t,e,n,i){this._dragging=!0,ee(i.event);var r=Fu([e,n],this._displayables.sliderGroup.getLocalTransform(),!0),o=this._updateInterval(t,r[0]),a=this.dataZoomModel.get("realtime");this._updateView(!a),o&&a&&this._dispatchZoomAction(!0)},e.prototype._onDragEnd=function(){this._dragging=!1,this._showDataInfo(!1),!this.dataZoomModel.get("realtime")&&this._dispatchZoomAction(!1)},e.prototype._onClickPanel=function(t){var e=this._size,n=this._displayables.sliderGroup.transformCoordToLocal(t.offsetX,t.offsetY);if(!(n[0]<0||n[0]>e[0]||n[1]<0||n[1]>e[1])){var i=this._handleEnds,r=(i[0]+i[1])/2,o=this._updateInterval("all",n[0]-r);this._updateView(),o&&this._dispatchZoomAction(!1)}},e.prototype._onBrushStart=function(t){var e=t.offsetX,n=t.offsetY;this._brushStart=new In(e,n),this._brushing=!0,this._brushStartTime=+new Date},e.prototype._onBrushEnd=function(t){if(this._brushing){var e=this._displayables.brushRect;if(this._brushing=!1,e){e.attr("ignore",!0);var n=e.shape;if(!(+new Date-this._brushStartTime<200&&Math.abs(n.width)<5)){var i=this._getViewExtent(),r=[0,100];this._range=qi([Ui(n.x,i,r,!0),Ui(n.x+n.width,i,r,!0)]),this._handleEnds=[n.x,n.x+n.width],this._updateView(),this._dispatchZoomAction(!1)}}}},e.prototype._onBrush=function(t){this._brushing&&(ee(t.event),this._updateBrushRect(t.offsetX,t.offsetY))},e.prototype._updateBrushRect=function(t,e){var n=this._displayables,i=this.dataZoomModel,r=n.brushRect;r||(r=n.brushRect=new hB({silent:!0,style:i.getModel("brushStyle").getItemStyle()}),n.sliderGroup.add(r)),r.attr("ignore",!1);var o=this._brushStart,a=this._displayables.sliderGroup,s=a.transformCoordToLocal(t,e),l=a.transformCoordToLocal(o.x,o.y),u=this._size;s[0]=Math.max(Math.min(u[0],s[0]),0),r.setShape({x:l[0],y:0,width:s[0]-l[0],height:u[1]})},e.prototype._dispatchZoomAction=function(t){var e=this._range;this.api.dispatchAction({type:"dataZoom",from:this.uid,dataZoomId:this.dataZoomModel.id,animation:t?fB:null,start:e[0],end:e[1]})},e.prototype._findCoordRect=function(){var t,e=qR(this.dataZoomModel).infoList;if(!t&&e.length){var n=e[0].model.coordinateSystem;t=n.getRect&&n.getRect()}if(!t){var i=this.api.getWidth(),r=this.api.getHeight();t={x:.2*i,y:.2*r,width:.6*i,height:.6*r}}return t},e.type="dataZoom.slider",e}(tN);function yB(t){return"vertical"===t?"ns-resize":"ew-resize"}function vB(t){t.registerComponentModel(uB),t.registerComponentView(gB),sN(t)}var mB=function(t,e,n){var i=w((_B[t]||{})[e]);return n&&F(i)?i[i.length-1]:i},_B={color:{active:["#006edd","#e0ffff"],inactive:["rgba(0,0,0,0)"]},colorHue:{active:[0,360],inactive:[0,0]},colorSaturation:{active:[.3,1],inactive:[0,0]},colorLightness:{active:[.9,.5],inactive:[0,0]},colorAlpha:{active:[.3,1],inactive:[0,0]},opacity:{active:[.3,1],inactive:[0,0]},symbol:{active:["circle","roundRect","diamond"],inactive:["none"]},symbolSize:{active:[10,50],inactive:[0,0]}},xB=eT.mapVisual,bB=eT.eachVisual,wB=F,SB=P,MB=qi,IB=Ui,TB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.stateList=["inRange","outOfRange"],n.replacableOptionKeys=["inRange","outOfRange","target","controller","color"],n.layoutMode={type:"box",ignoreSize:!0},n.dataBound=[-1/0,1/0],n.targetVisuals={},n.controllerVisuals={},n}return n(e,t),e.prototype.init=function(t,e,n){this.mergeDefaultAndTheme(t,n)},e.prototype.optionUpdated=function(t,e){var n=this.option;a.canvasSupported||(n.realtime=!1),!e&&bE(n,t,this.replacableOptionKeys),this.textStyleModel=this.getModel("textStyle"),this.resetItemSize(),this.completeVisualOption()},e.prototype.resetVisual=function(t){var e=this.stateList;t=B(t,this),this.controllerVisuals=xE(this.option.controller,e,t),this.targetVisuals=xE(this.option.target,e,t)},e.prototype.getTargetSeriesIndices=function(){var t=this.option.seriesIndex,e=[];return null==t||"all"===t?this.ecModel.eachSeries((function(t,n){e.push(n)})):e=_r(t),e},e.prototype.eachTargetSeries=function(t,e){P(this.getTargetSeriesIndices(),(function(n){var i=this.ecModel.getSeriesByIndex(n);i&&t.call(e,i)}),this)},e.prototype.isTargetSeries=function(t){var e=!1;return this.eachTargetSeries((function(n){n===t&&(e=!0)})),e},e.prototype.formatValueText=function(t,e,n){var i,r=this.option,o=r.precision,a=this.dataBound,s=r.formatter;n=n||["<",">"],F(t)&&(t=t.slice(),i=!0);var l=e?t:i?[u(t[0]),u(t[1])]:u(t);return H(s)?s.replace("{value}",i?l[0]:l).replace("{value2}",i?l[1]:l):G(s)?i?s(t[0],t[1]):s(t):i?t[0]===a[0]?n[0]+" "+l[1]:t[1]===a[1]?n[1]+" "+l[0]:l[0]+" - "+l[1]:l;function u(t){return t===a[0]?"min":t===a[1]?"max":(+t).toFixed(Math.min(o,20))}},e.prototype.resetExtent=function(){var t=this.option,e=MB([t.min,t.max]);this._dataExtent=e},e.prototype.getDataDimension=function(t){var e=this.option.dimension,n=t.dimensions;if(null!=e||n.length){if(null!=e)return t.getDimension(e);for(var i=t.dimensions,r=i.length-1;r>=0;r--){var o=i[r];if(!t.getDimensionInfo(o).isCalculationCoord)return o}}},e.prototype.getExtent=function(){return this._dataExtent.slice()},e.prototype.completeVisualOption=function(){var t=this.ecModel,e=this.option,n={inRange:e.inRange,outOfRange:e.outOfRange},i=e.target||(e.target={}),r=e.controller||(e.controller={});S(i,n),S(r,n);var o=this.isCategory();function a(n){wB(e.color)&&!n.inRange&&(n.inRange={color:e.color.slice().reverse()}),n.inRange=n.inRange||{color:t.get("gradientColor")}}a.call(this,i),a.call(this,r),function(t,e,n){var i=t[e],r=t[n];i&&!r&&(r=t[n]={},SB(i,(function(t,e){if(eT.isValidType(e)){var n=mB(e,"inactive",o);null!=n&&(r[e]=n,"color"!==e||r.hasOwnProperty("opacity")||r.hasOwnProperty("colorAlpha")||(r.opacity=[0,0]))}})))}.call(this,i,"inRange","outOfRange"),function(t){var e=(t.inRange||{}).symbol||(t.outOfRange||{}).symbol,n=(t.inRange||{}).symbolSize||(t.outOfRange||{}).symbolSize,i=this.get("inactiveColor");SB(this.stateList,(function(r){var a=this.itemSize,s=t[r];s||(s=t[r]={color:o?i:[i]}),null==s.symbol&&(s.symbol=e&&w(e)||(o?"roundRect":["roundRect"])),null==s.symbolSize&&(s.symbolSize=n&&w(n)||(o?a[0]:[a[0],a[0]])),s.symbol=xB(s.symbol,(function(t){return"none"===t||"square"===t?"roundRect":t}));var l=s.symbolSize;if(null!=l){var u=-1/0;bB(l,(function(t){t>u&&(u=t)})),s.symbolSize=xB(l,(function(t){return IB(t,[0,u],[0,a[0]],!0)}))}}),this)}.call(this,r)},e.prototype.resetItemSize=function(){this.itemSize=[parseFloat(this.get("itemWidth")),parseFloat(this.get("itemHeight"))]},e.prototype.isCategory=function(){return!!this.option.categories},e.prototype.setSelected=function(t){},e.prototype.getSelected=function(){return null},e.prototype.getValueState=function(t){return null},e.prototype.getVisualMeta=function(t){return null},e.type="visualMap",e.dependencies=["series"],e.defaultOption={show:!0,zlevel:0,z:4,seriesIndex:"all",min:0,max:200,left:0,right:null,top:null,bottom:0,itemWidth:null,itemHeight:null,inverse:!1,orient:"vertical",backgroundColor:"rgba(0,0,0,0)",borderColor:"#ccc",contentColor:"#5793f3",inactiveColor:"#aaa",borderWidth:0,padding:5,textGap:10,precision:0,textStyle:{color:"#333"}},e}(Nc),CB=[20,140],AB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.optionUpdated=function(e,n){t.prototype.optionUpdated.apply(this,arguments),this.resetExtent(),this.resetVisual((function(t){t.mappingMethod="linear",t.dataExtent=this.getExtent()})),this._resetRange()},e.prototype.resetItemSize=function(){t.prototype.resetItemSize.apply(this,arguments);var e=this.itemSize;(null==e[0]||isNaN(e[0]))&&(e[0]=CB[0]),(null==e[1]||isNaN(e[1]))&&(e[1]=CB[1])},e.prototype._resetRange=function(){var t=this.getExtent(),e=this.option.range;!e||e.auto?(t.auto=1,this.option.range=t):F(e)&&(e[0]>e[1]&&e.reverse(),e[0]=Math.max(e[0],t[0]),e[1]=Math.min(e[1],t[1]))},e.prototype.completeVisualOption=function(){t.prototype.completeVisualOption.apply(this,arguments),P(this.stateList,(function(t){var e=this.option.controller[t].symbolSize;e&&e[0]!==e[1]&&(e[0]=e[1]/3)}),this)},e.prototype.setSelected=function(t){this.option.range=t.slice(),this._resetRange()},e.prototype.getSelected=function(){var t=this.getExtent(),e=qi((this.get("range")||[]).slice());return e[0]>t[1]&&(e[0]=t[1]),e[1]>t[1]&&(e[1]=t[1]),e[0]<t[0]&&(e[0]=t[0]),e[1]<t[0]&&(e[1]=t[0]),e},e.prototype.getValueState=function(t){var e=this.option.range,n=this.getExtent();return(e[0]<=n[0]||e[0]<=t)&&(e[1]>=n[1]||t<=e[1])?"inRange":"outOfRange"},e.prototype.findTargetDataIndices=function(t){var e=[];return this.eachTargetSeries((function(n){var i=[],r=n.getData();r.each(this.getDataDimension(r),(function(e,n){t[0]<=e&&e<=t[1]&&i.push(n)}),this),e.push({seriesId:n.id,dataIndex:i})}),this),e},e.prototype.getVisualMeta=function(t){var e=DB(this,"outOfRange",this.getExtent()),n=DB(this,"inRange",this.option.range.slice()),i=[];function r(e,n){i.push({value:e,color:t(e,n)})}for(var o=0,a=0,s=n.length,l=e.length;a<l&&(!n.length||e[a]<=n[0]);a++)e[a]<n[o]&&r(e[a],"outOfRange");for(var u=1;o<s;o++,u=0)u&&i.length&&r(n[o],"outOfRange"),r(n[o],"inRange");for(u=1;a<l;a++)(!n.length||n[n.length-1]<e[a])&&(u&&(i.length&&r(i[i.length-1].value,"outOfRange"),u=0),r(e[a],"outOfRange"));var h=i.length;return{stops:i,outerColors:[h?i[0].color:"transparent",h?i[h-1].color:"transparent"]}},e.type="visualMap.continuous",e.defaultOption=Th(TB.defaultOption,{align:"auto",calculable:!1,hoverLink:!0,realtime:!0,handleIcon:"path://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",handleSize:"120%",handleStyle:{borderColor:"#fff",borderWidth:1},indicatorIcon:"circle",indicatorSize:"50%",indicatorStyle:{borderColor:"#fff",borderWidth:2,shadowBlur:2,shadowOffsetX:1,shadowOffsetY:1,shadowColor:"rgba(0,0,0,0.2)"}}),e}(TB);function DB(t,e,n){if(n[0]===n[1])return n.slice();for(var i=(n[1]-n[0])/200,r=n[0],o=[],a=0;a<=200&&r<n[1];a++)o.push(r),r+=i;return o.push(n[1]),o}var LB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n.autoPositionValues={left:1,right:1,top:1,bottom:1},n}return n(e,t),e.prototype.init=function(t,e){this.ecModel=t,this.api=e},e.prototype.render=function(t,e,n,i){this.visualMapModel=t,!1!==t.get("show")?this.doRender(t,e,n,i):this.group.removeAll()},e.prototype.renderBackground=function(t){var e=this.visualMapModel,n=pc(e.get("padding")||0),i=t.getBoundingRect();t.add(new os({z2:-1,silent:!0,shape:{x:i.x-n[3],y:i.y-n[0],width:i.width+n[3]+n[1],height:i.height+n[0]+n[2]},style:{fill:e.get("backgroundColor"),stroke:e.get("borderColor"),lineWidth:e.get("borderWidth")}}))},e.prototype.getControllerVisual=function(t,e,n){var i=(n=n||{}).forceState,r=this.visualMapModel,o={};if("symbol"===e&&(o.symbol=r.get("itemSymbol")),"color"===e){var a=r.get("contentColor");o.color=a}function s(t){return o[t]}function l(t,e){o[t]=e}var u=r.controllerVisuals[i||r.getValueState(t)];return P(eT.prepareVisualTypes(u),(function(i){var r=u[i];n.convertOpacityToAlpha&&"opacity"===i&&(i="colorAlpha",r=u.__alphaForOpacity),eT.dependsOn(i,e)&&r&&r.applyVisual(t,s,l)})),o[e]},e.prototype.positionGroup=function(t){var e=this.visualMapModel,n=this.api;Dc(t,e.getBoxLayoutParams(),{width:n.getWidth(),height:n.getHeight()})},e.prototype.doRender=function(t,e,n,i){},e.type="visualMap",e}(pf),kB=[["left","right","width"],["top","bottom","height"]];function PB(t,e,n){var i=t.option,r=i.align;if(null!=r&&"auto"!==r)return r;for(var o={width:e.getWidth(),height:e.getHeight()},a="horizontal"===i.orient?1:0,s=kB[a],l=[0,null,10],u={},h=0;h<3;h++)u[kB[1-a][h]]=l[h],u[s[h]]=2===h?n[0]:i[s[h]];var c=[["x","width",3],["y","height",0]][a],p=Ac(u,o,i.padding);return s[(p.margin[c[2]]||0)+p[c[0]]+.5*p[c[1]]<.5*o[c[1]]?0:1]}function OB(t,e){return P(t||[],(function(t){null!=t.dataIndex&&(t.dataIndexInside=t.dataIndex,t.dataIndex=null),t.highlightKey="visualMap"+(e?e.componentIndex:"")})),t}var RB=Ui,NB=P,EB=Math.min,zB=Math.max,BB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._shapes={},n._dataInterval=[],n._handleEnds=[],n._hoverLinkDataIndices=[],n}return n(e,t),e.prototype.doRender=function(t,e,n,i){this._api=n,i&&"selectDataRange"===i.type&&i.from===this.uid||this._buildView()},e.prototype._buildView=function(){this.group.removeAll();var t=this.visualMapModel,e=this.group;this._orient=t.get("orient"),this._useHandle=t.get("calculable"),this._resetInterval(),this._renderBar(e);var n=t.get("text");this._renderEndsText(e,n,0),this._renderEndsText(e,n,1),this._updateView(!0),this.renderBackground(e),this._updateView(),this._enableHoverLinkToSeries(),this._enableHoverLinkFromSeries(),this.positionGroup(e)},e.prototype._renderEndsText=function(t,e,n){if(e){var i=e[1-n];i=null!=i?i+"":"";var r=this.visualMapModel,o=r.get("textGap"),a=r.itemSize,s=this._shapes.mainGroup,l=this._applyTransform([a[0]/2,0===n?-o:a[1]+o],s),u=this._applyTransform(0===n?"bottom":"top",s),h=this._orient,c=this.visualMapModel.textStyleModel;this.group.add(new ls({style:{x:l[0],y:l[1],verticalAlign:"horizontal"===h?"middle":u,align:"horizontal"===h?u:"center",text:i,font:c.getFont(),fill:c.getTextColor()}}))}},e.prototype._renderBar=function(t){var e=this.visualMapModel,n=this._shapes,i=e.itemSize,r=this._orient,o=this._useHandle,a=PB(e,this.api,i),s=n.mainGroup=this._createBarGroup(a),l=new zi;s.add(l),l.add(n.outOfRange=VB()),l.add(n.inRange=VB(null,o?GB(this._orient):null,B(this._dragHandle,this,"all",!1),B(this._dragHandle,this,"all",!0))),l.setClipPath(new os({shape:{x:0,y:0,width:i[0],height:i[1],r:3}}));var u=e.textStyleModel.getTextRect("国"),h=zB(u.width,u.height);o&&(n.handleThumbs=[],n.handleLabels=[],n.handleLabelPoints=[],this._createHandle(e,s,0,i,h,r),this._createHandle(e,s,1,i,h,r)),this._createIndicator(e,s,i,h,r),t.add(s)},e.prototype._createHandle=function(t,e,n,i,r,o){var a=B(this._dragHandle,this,n,!1),s=B(this._dragHandle,this,n,!0),l=Yn(t.get("handleSize"),i[0]),u=uy(t.get("handleIcon"),-l/2,-l/2,l,l,null,!0),h=GB(this._orient);u.attr({cursor:h,draggable:!0,drift:a,ondragend:s,onmousemove:function(t){ee(t.event)}}),u.x=i[0]/2,u.useStyle(t.getModel("handleStyle").getItemStyle()),u.setStyle({strokeNoScale:!0,strokeFirst:!0}),u.style.lineWidth*=2,u.ensureState("emphasis").style=t.getModel(["emphasis","handleStyle"]).getItemStyle(),il(u,!0),e.add(u);var c=this.visualMapModel.textStyleModel,p=new ls({cursor:h,draggable:!0,drift:a,onmousemove:function(t){ee(t.event)},ondragend:s,style:{x:0,y:0,text:"",font:c.getFont(),fill:c.getTextColor()}});p.ensureState("blur").style={opacity:.1},p.stateTransition={duration:200},this.group.add(p);var d=[l,0],f=this._shapes;f.handleThumbs[n]=u,f.handleLabelPoints[n]=d,f.handleLabels[n]=p},e.prototype._createIndicator=function(t,e,n,i,r){var o=Yn(t.get("indicatorSize"),n[0]),a=uy(t.get("indicatorIcon"),-o/2,-o/2,o,o,null,!0);a.attr({cursor:"move",invisible:!0,silent:!0,x:n[0]/2});var s=t.getModel("indicatorStyle").getItemStyle();if(a instanceof Ja){var l=a.style;a.useStyle(I({image:l.image,x:l.x,y:l.y,width:l.width,height:l.height},s))}else a.useStyle(s);e.add(a);var u=this.visualMapModel.textStyleModel,h=new ls({silent:!0,invisible:!0,style:{x:0,y:0,text:"",font:u.getFont(),fill:u.getTextColor()}});this.group.add(h);var c=[("horizontal"===r?i/2:6)+n[0]/2,0],p=this._shapes;p.indicator=a,p.indicatorLabel=h,p.indicatorLabelPoint=c,this._firstShowIndicator=!0},e.prototype._dragHandle=function(t,e,n,i){if(this._useHandle){if(this._dragging=!e,!e){var r=this._applyTransform([n,i],this._shapes.mainGroup,!0);this._updateInterval(t,r[1]),this._hideIndicator(),this._updateView()}e===!this.visualMapModel.get("realtime")&&this.api.dispatchAction({type:"selectDataRange",from:this.uid,visualMapId:this.visualMapModel.id,selected:this._dataInterval.slice()}),e?!this._hovering&&this._clearHoverLinkToSeries():FB(this.visualMapModel)&&this._doHoverLinkToSeries(this._handleEnds[t],!1)}},e.prototype._resetInterval=function(){var t=this.visualMapModel,e=this._dataInterval=t.getSelected(),n=t.getExtent(),i=[0,t.itemSize[1]];this._handleEnds=[RB(e[0],n,i,!0),RB(e[1],n,i,!0)]},e.prototype._updateInterval=function(t,e){e=e||0;var n=this.visualMapModel,i=this._handleEnds,r=[0,n.itemSize[1]];sA(e,i,r,t,0);var o=n.getExtent();this._dataInterval=[RB(i[0],r,o,!0),RB(i[1],r,o,!0)]},e.prototype._updateView=function(t){var e=this.visualMapModel,n=e.getExtent(),i=this._shapes,r=[0,e.itemSize[1]],o=t?r:this._handleEnds,a=this._createBarVisual(this._dataInterval,n,o,"inRange"),s=this._createBarVisual(n,n,r,"outOfRange");i.inRange.setStyle({fill:a.barColor}).setShape("points",a.barPoints),i.outOfRange.setStyle({fill:s.barColor}).setShape("points",s.barPoints),this._updateHandle(o,a)},e.prototype._createBarVisual=function(t,e,n,i){var r={forceState:i,convertOpacityToAlpha:!0},o=this._makeColorGradient(t,r),a=[this.getControllerVisual(t[0],"symbolSize",r),this.getControllerVisual(t[1],"symbolSize",r)],s=this._createBarPoints(n,a);return{barColor:new uu(0,0,0,1,o),barPoints:s,handlesColor:[o[0].color,o[o.length-1].color]}},e.prototype._makeColorGradient=function(t,e){var n=[],i=(t[1]-t[0])/100;n.push({color:this.getControllerVisual(t[0],"color",e),offset:0});for(var r=1;r<100;r++){var o=t[0]+i*r;if(o>t[1])break;n.push({color:this.getControllerVisual(o,"color",e),offset:r/100})}return n.push({color:this.getControllerVisual(t[1],"color",e),offset:1}),n},e.prototype._createBarPoints=function(t,e){var n=this.visualMapModel.itemSize;return[[n[0]-e[0],t[0]],[n[0],t[0]],[n[0],t[1]],[n[0]-e[1],t[1]]]},e.prototype._createBarGroup=function(t){var e=this._orient,n=this.visualMapModel.get("inverse");return new zi("horizontal"!==e||n?"horizontal"===e&&n?{scaleX:"bottom"===t?-1:1,rotation:-Math.PI/2}:"vertical"!==e||n?{scaleX:"left"===t?1:-1}:{scaleX:"left"===t?1:-1,scaleY:-1}:{scaleX:"bottom"===t?1:-1,rotation:Math.PI/2})},e.prototype._updateHandle=function(t,e){if(this._useHandle){var n=this._shapes,i=this.visualMapModel,r=n.handleThumbs,o=n.handleLabels,a=i.itemSize,s=i.getExtent();NB([0,1],(function(l){var u=r[l];u.setStyle("fill",e.handlesColor[l]),u.y=t[l];var h=RB(t[l],[0,a[1]],s,!0),c=this.getControllerVisual(h,"symbolSize");u.scaleX=u.scaleY=c/a[0],u.x=a[0]-c/2;var p=Fu(n.handleLabelPoints[l],Vu(u,this.group));o[l].setStyle({x:p[0],y:p[1],text:i.formatValueText(this._dataInterval[l]),verticalAlign:"middle",align:"vertical"===this._orient?this._applyTransform("left",n.mainGroup):"center"})}),this)}},e.prototype._showIndicator=function(t,e,n,i){var r=this.visualMapModel,o=r.getExtent(),a=r.itemSize,s=[0,a[1]],l=this._shapes,u=l.indicator;if(u){u.attr("invisible",!1);var h=this.getControllerVisual(t,"color",{convertOpacityToAlpha:!0}),c=this.getControllerVisual(t,"symbolSize"),p=RB(t,o,s,!0),d=a[0]-c/2,f={x:u.x,y:u.y};u.y=p,u.x=d;var g=Fu(l.indicatorLabelPoint,Vu(u,this.group)),y=l.indicatorLabel;y.attr("invisible",!1);var v=this._applyTransform("left",l.mainGroup),m="horizontal"===this._orient;y.setStyle({text:(n||"")+r.formatValueText(e),verticalAlign:m?v:"middle",align:m?"center":v});var _={x:d,y:p,style:{fill:h}},x={style:{x:g[0],y:g[1]}};if(r.ecModel.isAnimationEnabled()&&!this._firstShowIndicator){var b={duration:100,easing:"cubicInOut",additive:!0};u.x=f.x,u.y=f.y,u.animateTo(_,b),y.animateTo(x,b)}else u.attr(_),y.attr(x);this._firstShowIndicator=!1;var w=this._shapes.handleLabels;if(w)for(var S=0;S<w.length;S++)this._api.enterBlur(w[S])}},e.prototype._enableHoverLinkToSeries=function(){var t=this;this._shapes.mainGroup.on("mousemove",(function(e){if(t._hovering=!0,!t._dragging){var n=t.visualMapModel.itemSize,i=t._applyTransform([e.offsetX,e.offsetY],t._shapes.mainGroup,!0,!0);i[1]=EB(zB(0,i[1]),n[1]),t._doHoverLinkToSeries(i[1],0<=i[0]&&i[0]<=n[0])}})).on("mouseout",(function(){t._hovering=!1,!t._dragging&&t._clearHoverLinkToSeries()}))},e.prototype._enableHoverLinkFromSeries=function(){var t=this.api.getZr();this.visualMapModel.option.hoverLink?(t.on("mouseover",this._hoverLinkFromSeriesMouseOver,this),t.on("mouseout",this._hideIndicator,this)):this._clearHoverLinkFromSeries()},e.prototype._doHoverLinkToSeries=function(t,e){var n=this.visualMapModel,i=n.itemSize;if(n.option.hoverLink){var r=[0,i[1]],o=n.getExtent();t=EB(zB(r[0],t),r[1]);var a=function(t,e,n){var i=6,r=t.get("hoverLinkDataSize");r&&(i=RB(r,e,n,!0)/2);return i}(n,o,r),s=[t-a,t+a],l=RB(t,r,o,!0),u=[RB(s[0],r,o,!0),RB(s[1],r,o,!0)];s[0]<r[0]&&(u[0]=-1/0),s[1]>r[1]&&(u[1]=1/0),e&&(u[0]===-1/0?this._showIndicator(l,u[1],"< ",a):u[1]===1/0?this._showIndicator(l,u[0],"> ",a):this._showIndicator(l,l,"≈ ",a));var h=this._hoverLinkDataIndices,c=[];(e||FB(n))&&(c=this._hoverLinkDataIndices=n.findTargetDataIndices(u));var p=function(t,e){var n={},i={};return r(t||[],n),r(e||[],i,n),[o(n),o(i)];function r(t,e,n){for(var i=0,r=t.length;i<r;i++){var o=Tr(t[i].seriesId,null);if(null==o)return;for(var a=_r(t[i].dataIndex),s=n&&n[o],l=0,u=a.length;l<u;l++){var h=a[l];s&&s[h]?s[h]=null:(e[o]||(e[o]={}))[h]=1}}}function o(t,e){var n=[];for(var i in t)if(t.hasOwnProperty(i)&&null!=t[i])if(e)n.push(+i);else{var r=o(t[i],!0);r.length&&n.push({seriesId:i,dataIndex:r})}return n}}(h,c);this._dispatchHighDown("downplay",OB(p[0],n)),this._dispatchHighDown("highlight",OB(p[1],n))}},e.prototype._hoverLinkFromSeriesMouseOver=function(t){var e=t.target,n=this.visualMapModel;if(e&&null!=ys(e).dataIndex){var i=ys(e),r=this.ecModel.getSeriesByIndex(i.seriesIndex);if(n.isTargetSeries(r)){var o=r.getData(i.dataType),a=o.get(n.getDataDimension(o),i.dataIndex);isNaN(a)||this._showIndicator(a,a)}}},e.prototype._hideIndicator=function(){var t=this._shapes;t.indicator&&t.indicator.attr("invisible",!0),t.indicatorLabel&&t.indicatorLabel.attr("invisible",!0);var e=this._shapes.handleLabels;if(e)for(var n=0;n<e.length;n++)this._api.leaveBlur(e[n])},e.prototype._clearHoverLinkToSeries=function(){this._hideIndicator();var t=this._hoverLinkDataIndices;this._dispatchHighDown("downplay",OB(t,this.visualMapModel)),t.length=0},e.prototype._clearHoverLinkFromSeries=function(){this._hideIndicator();var t=this.api.getZr();t.off("mouseover",this._hoverLinkFromSeriesMouseOver),t.off("mouseout",this._hideIndicator)},e.prototype._applyTransform=function(t,e,n,i){var r=Vu(e,i?null:this.group);return F(t)?Fu(t,r,n):Gu(t,r,n)},e.prototype._dispatchHighDown=function(t,e){e&&e.length&&this.api.dispatchAction({type:t,batch:e})},e.prototype.dispose=function(){this._clearHoverLinkFromSeries(),this._clearHoverLinkToSeries()},e.prototype.remove=function(){this._clearHoverLinkFromSeries(),this._clearHoverLinkToSeries()},e.type="visualMap.continuous",e}(LB);function VB(t,e,n,i){return new ql({shape:{points:t},draggable:!!n,cursor:e,drift:n,onmousemove:function(t){ee(t.event)},ondragend:i})}function FB(t){var e=t.get("hoverLinkOnHandle");return!!(null==e?t.get("realtime"):e)}function GB(t){return"vertical"===t?"ns-resize":"ew-resize"}var HB={type:"selectDataRange",event:"dataRangeSelected",update:"update"},WB=function(t,e){e.eachComponent({mainType:"visualMap",query:t},(function(e){e.setSelected(t.selected)}))},YB=[{createOnAllSeries:!0,reset:function(t,e){var n=[];return e.eachComponent("visualMap",(function(e){var i,r,o,a,s,l=t.pipelineContext;!e.isTargetSeries(t)||l&&l.large||n.push((i=e.stateList,r=e.targetVisuals,o=B(e.getValueState,e),a=e.getDataDimension(t.getData()),s={},P(i,(function(t){var e=eT.prepareVisualTypes(r[t]);s[t]=e})),{progress:function(t,e){var n,i;function l(t){return pg(e,i,t)}function u(t,n){fg(e,i,t,n)}for(null!=a&&(n=e.getDimension(a));null!=(i=t.next());){var h=e.getRawDataItem(i);if(!h||!1!==h.visualMap)for(var c=null!=a?e.get(n,i):i,p=o(c),d=r[p],f=s[p],g=0,y=f.length;g<y;g++){var v=f[g];d[v]&&d[v].applyVisual(c,l,u)}}}}))})),n}},{createOnAllSeries:!0,reset:function(t,e){var n=t.getData(),i=[];e.eachComponent("visualMap",(function(e){if(e.isTargetSeries(t)){var r=e.getVisualMeta(B(XB,null,t,e))||{stops:[],outerColors:[]},o=e.getDataDimension(n),a=n.getDimensionInfo(o);null!=a&&(r.dimension=a.index,i.push(r))}})),t.getData().setVisual("visualMeta",i)}}];function XB(t,e,n,i){for(var r=e.targetVisuals[i],o=eT.prepareVisualTypes(r),a={color:dg(t.getData(),"color")},s=0,l=o.length;s<l;s++){var u=o[s],h=r["opacity"===u?"__alphaForOpacity":u];h&&h.applyVisual(n,c,p)}return a.color;function c(t){return a[t]}function p(t,e){a[t]=e}}var UB=P;function ZB(t){var e=t&&t.visualMap;F(e)||(e=e?[e]:[]),UB(e,(function(t){if(t){jB(t,"splitList")&&!jB(t,"pieces")&&(t.pieces=t.splitList,delete t.splitList);var e=t.pieces;e&&F(e)&&UB(e,(function(t){X(t)&&(jB(t,"start")&&!jB(t,"min")&&(t.min=t.start),jB(t,"end")&&!jB(t,"max")&&(t.max=t.end))}))}}))}function jB(t,e){return t&&t.hasOwnProperty&&t.hasOwnProperty(e)}var qB=!1;function KB(t){qB||(qB=!0,t.registerSubTypeDefaulter("visualMap",(function(t){return t.categories||(t.pieces?t.pieces.length>0:t.splitNumber>0)&&!t.calculable?"piecewise":"continuous"})),t.registerAction(HB,WB),P(YB,(function(e){t.registerVisual(t.PRIORITY.VISUAL.COMPONENT,e)})),t.registerPreprocessor(ZB))}function $B(t){t.registerComponentModel(AB),t.registerComponentView(BB),KB(t)}var JB=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n._pieceList=[],n}return n(e,t),e.prototype.optionUpdated=function(e,n){t.prototype.optionUpdated.apply(this,arguments),this.resetExtent();var i=this._mode=this._determineMode();this._pieceList=[],QB[this._mode].call(this,this._pieceList),this._resetSelected(e,n);var r=this.option.categories;this.resetVisual((function(t,e){"categories"===i?(t.mappingMethod="category",t.categories=w(r)):(t.dataExtent=this.getExtent(),t.mappingMethod="piecewise",t.pieceList=O(this._pieceList,(function(t){return t=w(t),"inRange"!==e&&(t.visual=null),t})))}))},e.prototype.completeVisualOption=function(){var e=this.option,n={},i=eT.listVisualTypes(),r=this.isCategory();function o(t,e,n){return t&&t[e]&&t[e].hasOwnProperty(n)}P(e.pieces,(function(t){P(i,(function(e){t.hasOwnProperty(e)&&(n[e]=1)}))})),P(n,(function(t,n){var i=!1;P(this.stateList,(function(t){i=i||o(e,t,n)||o(e.target,t,n)}),this),!i&&P(this.stateList,(function(t){(e[t]||(e[t]={}))[n]=mB(n,"inRange"===t?"active":"inactive",r)}))}),this),t.prototype.completeVisualOption.apply(this,arguments)},e.prototype._resetSelected=function(t,e){var n=this.option,i=this._pieceList,r=(e?n:t).selected||{};if(n.selected=r,P(i,(function(t,e){var n=this.getSelectedMapKey(t);r.hasOwnProperty(n)||(r[n]=!0)}),this),"single"===n.selectedMode){var o=!1;P(i,(function(t,e){var n=this.getSelectedMapKey(t);r[n]&&(o?r[n]=!1:o=!0)}),this)}},e.prototype.getSelectedMapKey=function(t){return"categories"===this._mode?t.value+"":t.index+""},e.prototype.getPieceList=function(){return this._pieceList},e.prototype._determineMode=function(){var t=this.option;return t.pieces&&t.pieces.length>0?"pieces":this.option.categories?"categories":"splitNumber"},e.prototype.setSelected=function(t){this.option.selected=w(t)},e.prototype.getValueState=function(t){var e=eT.findPieceIndex(t,this._pieceList);return null!=e&&this.option.selected[this.getSelectedMapKey(this._pieceList[e])]?"inRange":"outOfRange"},e.prototype.findTargetDataIndices=function(t){var e=[],n=this._pieceList;return this.eachTargetSeries((function(i){var r=[],o=i.getData();o.each(this.getDataDimension(o),(function(e,i){eT.findPieceIndex(e,n)===t&&r.push(i)}),this),e.push({seriesId:i.id,dataIndex:r})}),this),e},e.prototype.getRepresentValue=function(t){var e;if(this.isCategory())e=t.value;else if(null!=t.value)e=t.value;else{var n=t.interval||[];e=n[0]===-1/0&&n[1]===1/0?0:(n[0]+n[1])/2}return e},e.prototype.getVisualMeta=function(t){if(!this.isCategory()){var e=[],n=["",""],i=this,r=this._pieceList.slice();if(r.length){var o=r[0].interval[0];o!==-1/0&&r.unshift({interval:[-1/0,o]}),(o=r[r.length-1].interval[1])!==1/0&&r.push({interval:[o,1/0]})}else r.push({interval:[-1/0,1/0]});var a=-1/0;return P(r,(function(t){var e=t.interval;e&&(e[0]>a&&s([a,e[0]],"outOfRange"),s(e.slice()),a=e[1])}),this),{stops:e,outerColors:n}}function s(r,o){var a=i.getRepresentValue({interval:r});o||(o=i.getValueState(a));var s=t(a,o);r[0]===-1/0?n[0]=s:r[1]===1/0?n[1]=s:e.push({value:r[0],color:s},{value:r[1],color:s})}},e.type="visualMap.piecewise",e.defaultOption=Th(TB.defaultOption,{selected:null,minOpen:!1,maxOpen:!1,align:"auto",itemWidth:20,itemHeight:14,itemSymbol:"roundRect",pieces:null,categories:null,splitNumber:5,selectedMode:"multiple",itemGap:10,hoverLink:!0}),e}(TB),QB={splitNumber:function(t){var e=this.option,n=Math.min(e.precision,20),i=this.getExtent(),r=e.splitNumber;r=Math.max(parseInt(r,10),1),e.splitNumber=r;for(var o=(i[1]-i[0])/r;+o.toFixed(n)!==o&&n<5;)n++;e.precision=n,o=+o.toFixed(n),e.minOpen&&t.push({interval:[-1/0,i[0]],close:[0,0]});for(var a=0,s=i[0];a<r;s+=o,a++){var l=a===r-1?i[1]:s+o;t.push({interval:[s,l],close:[1,1]})}e.maxOpen&&t.push({interval:[i[1],1/0],close:[0,0]}),ur(t),P(t,(function(t,e){t.index=e,t.text=this.formatValueText(t.interval)}),this)},categories:function(t){var e=this.option;P(e.categories,(function(e){t.push({text:this.formatValueText(e,!0),value:e})}),this),tV(e,t)},pieces:function(t){var e=this.option;P(e.pieces,(function(e,n){X(e)||(e={value:e});var i={text:"",index:n};if(null!=e.label&&(i.text=e.label),e.hasOwnProperty("value")){var r=i.value=e.value;i.interval=[r,r],i.close=[1,1]}else{for(var o=i.interval=[],a=i.close=[0,0],s=[1,0,1],l=[-1/0,1/0],u=[],h=0;h<2;h++){for(var c=[["gte","gt","min"],["lte","lt","max"]][h],p=0;p<3&&null==o[h];p++)o[h]=e[c[p]],a[h]=s[p],u[h]=2===p;null==o[h]&&(o[h]=l[h])}u[0]&&o[1]===1/0&&(a[0]=0),u[1]&&o[0]===-1/0&&(a[1]=0),o[0]===o[1]&&a[0]&&a[1]&&(i.value=o[0])}i.visual=eT.retrieveVisuals(e),t.push(i)}),this),tV(e,t),ur(t),P(t,(function(t){var e=t.close,n=[["<","≤"][e[1]],[">","≥"][e[0]]];t.text=t.text||this.formatValueText(null!=t.value?t.value:t.interval,!1,n)}),this)}};function tV(t,e){var n=t.inverse;("vertical"===t.orient?!n:n)&&e.reverse()}var eV=function(t){function e(){var n=null!==t&&t.apply(this,arguments)||this;return n.type=e.type,n}return n(e,t),e.prototype.doRender=function(){var t=this.group;t.removeAll();var e=this.visualMapModel,n=e.get("textGap"),i=e.textStyleModel,r=i.getFont(),o=i.getTextColor(),a=this._getItemAlign(),s=e.itemSize,l=this._getViewData(),u=l.endsText,h=Q(e.get("showLabel",!0),!u);u&&this._renderEndsText(t,u[0],s,h,a),P(l.viewPieceList,(function(i){var l=i.piece,u=new zi;u.onclick=B(this._onItemClick,this,l),this._enableHoverLink(u,i.indexInModelPieceList);var c=e.getRepresentValue(l);if(this._createItemSymbol(u,c,[0,0,s[0],s[1]]),h){var p=this.visualMapModel.getValueState(c);u.add(new ls({style:{x:"right"===a?-n:s[0]+n,y:s[1]/2,text:l.text,verticalAlign:"middle",align:a,font:r,fill:o,opacity:"outOfRange"===p?.5:1}}))}t.add(u)}),this),u&&this._renderEndsText(t,u[1],s,h,a),Cc(e.get("orient"),t,e.get("itemGap")),this.renderBackground(t),this.positionGroup(t)},e.prototype._enableHoverLink=function(t,e){var n=this;t.on("mouseover",(function(){return i("highlight")})).on("mouseout",(function(){return i("downplay")}));var i=function(t){var i=n.visualMapModel;i.option.hoverLink&&n.api.dispatchAction({type:t,batch:OB(i.findTargetDataIndices(e),i)})}},e.prototype._getItemAlign=function(){var t=this.visualMapModel,e=t.option;if("vertical"===e.orient)return PB(t,this.api,t.itemSize);var n=e.align;return n&&"auto"!==n||(n="left"),n},e.prototype._renderEndsText=function(t,e,n,i,r){if(e){var o=new zi,a=this.visualMapModel.textStyleModel;o.add(new ls({style:{x:i?"right"===r?n[0]:0:n[0]/2,y:n[1]/2,verticalAlign:"middle",align:i?r:"center",text:e,font:a.getFont(),fill:a.getTextColor()}})),t.add(o)}},e.prototype._getViewData=function(){var t=this.visualMapModel,e=O(t.getPieceList(),(function(t,e){return{piece:t,indexInModelPieceList:e}})),n=t.get("text"),i=t.get("orient"),r=t.get("inverse");return("horizontal"===i?r:!r)?e.reverse():n&&(n=n.slice().reverse()),{viewPieceList:e,endsText:n}},e.prototype._createItemSymbol=function(t,e,n){t.add(uy(this.getControllerVisual(e,"symbol"),n[0],n[1],n[2],n[3],this.getControllerVisual(e,"color")))},e.prototype._onItemClick=function(t){var e=this.visualMapModel,n=e.option,i=w(n.selected),r=e.getSelectedMapKey(t);"single"===n.selectedMode?(i[r]=!0,P(i,(function(t,e){i[e]=e===r}))):i[r]=!i[r],this.api.dispatchAction({type:"selectDataRange",from:this.uid,visualMapId:this.visualMapModel.id,selected:i})},e.type="visualMap.piecewise",e}(LB);function nV(t){t.registerComponentModel(JB),t.registerComponentView(eV),KB(t)}var iV={label:{enabled:!0},decal:{show:!1}},rV=Lr(),oV={};function aV(t,e){var n=t.getModel("aria");if(n.get("enabled")){var i=w(iV);S(i.label,t.getLocaleModel().get("aria"),!1),S(n.option,i,!1),function(){if(n.getModel("decal").get("show")){var e=ht();t.eachSeries((function(t){if(t.useColorPaletteOnData){var n=e.get(t.type);n||(n={},e.set(t.type,n)),rV(t).scope=n}})),t.eachRawSeries((function(e){if(!t.isSeriesFiltered(e))if("function"!=typeof e.enableAriaDecal){var n=e.getData();if(e.useColorPaletteOnData){var i=e.getRawData(),r={},o=rV(e).scope;n.each((function(t){var e=n.getRawIndex(t);r[e]=t}));var a=i.count();i.each((function(t){var s=r[t],l=i.getName(t)||t+"",h=hp(e.ecModel,l,o,a),c=n.getItemVisual(s,"decal");n.setItemVisual(s,"decal",u(c,h))}))}else{var s=hp(e.ecModel,e.name,oV,t.getSeriesCount()),l=n.getVisual("decal");n.setVisual("decal",u(l,s))}}else e.enableAriaDecal();function u(t,e){var n=t?I(I({},e),t):e;return n.dirty=!0,n}}))}}(),function(){var i=t.getLocaleModel().get("aria"),o=n.getModel("label");if(o.option=T(o.option,i),!o.get("enabled"))return;var a=e.getZr().dom;if(o.get("description"))return void a.setAttribute("aria-label",o.get("description"));var s,l=t.getSeriesCount(),u=o.get(["data","maxCount"])||10,h=o.get(["series","maxCount"])||10,c=Math.min(l,h);if(l<1)return;var p=function(){var e=t.get("title");e&&e.length&&(e=e[0]);return e&&e.text}();if(p){var d=o.get(["general","withTitle"]);s=r(d,{title:p})}else s=o.get(["general","withoutTitle"]);var f=[],g=l>1?o.get(["series","multiple","prefix"]):o.get(["series","single","prefix"]);s+=r(g,{seriesCount:l}),t.eachSeries((function(e,n){if(n<c){var i=void 0,a=e.get("name")?"withName":"withoutName";i=r(i=l>1?o.get(["series","multiple",a]):o.get(["series","single",a]),{seriesId:e.seriesIndex,seriesName:e.get("name"),seriesType:(_=e.subType,t.getLocaleModel().get(["series","typeNames"])[_]||"自定义图")});var s=e.getData();if(s.count()>u)i+=r(o.get(["data","partialData"]),{displayCnt:u});else i+=o.get(["data","allData"]);for(var h=[],p=0;p<s.count();p++)if(p<u){var d=s.getName(p),g=fd(s,p),y=o.get(["data",d?"withName":"withoutName"]);h.push(r(y,{name:d,value:g}))}var v=o.get(["data","separator","middle"]),m=o.get(["data","separator","end"]);i+=h.join(v)+m,f.push(i)}var _}));var y=o.getModel(["series","multiple","separator"]),v=y.get("middle"),m=y.get("end");s+=f.join(v)+m,a.setAttribute("aria-label",s)}()}function r(t,e){if("string"!=typeof t)return t;var n=t;return P(e,(function(t,e){n=n.replace(new RegExp("\\{\\s*"+e+"\\s*\\}","g"),t)})),n}}function sV(t){if(t&&t.aria){var e=t.aria;null!=e.show&&(e.enabled=e.show),e.label=e.label||{},P(["description","general","series","data"],(function(t){null!=e[t]&&(e.label[t]=e[t])}))}}var lV={value:"eq","<":"lt","<=":"lte",">":"gt",">=":"gte","=":"eq","!=":"ne","<>":"ne"},uV=function(){function t(t){if(null==(this._condVal=H(t)?new RegExp(t):$(t)?t:null)){var e="";0,yr(e)}}return t.prototype.evaluate=function(t){var e=typeof t;return"string"===e?this._condVal.test(t):"number"===e&&this._condVal.test(t+"")},t}(),hV=function(){function t(){}return t.prototype.evaluate=function(){return this.value},t}(),cV=function(){function t(){}return t.prototype.evaluate=function(){for(var t=this.children,e=0;e<t.length;e++)if(!t[e].evaluate())return!1;return!0},t}(),pV=function(){function t(){}return t.prototype.evaluate=function(){for(var t=this.children,e=0;e<t.length;e++)if(t[e].evaluate())return!0;return!1},t}(),dV=function(){function t(){}return t.prototype.evaluate=function(){return!this.child.evaluate()},t}(),fV=function(){function t(){}return t.prototype.evaluate=function(){for(var t=!!this.valueParser,e=(0,this.getValue)(this.valueGetterParam),n=t?this.valueParser(e):null,i=0;i<this.subCondList.length;i++)if(!this.subCondList[i].evaluate(t?n:e))return!1;return!0},t}();function gV(t,e){if(!0===t||!1===t){var n=new hV;return n.value=t,n}var i="";return vV(t)||yr(i),t.and?yV("and",t,e):t.or?yV("or",t,e):t.not?function(t,e){var n=t.not,i="";0;vV(n)||yr(i);var r=new dV;r.child=gV(n,e),r.child||yr(i);return r}(t,e):function(t,e){for(var n="",i=e.prepareGetValue(t),r=[],o=z(t),a=t.parser,s=a?Sd(a):null,l=0;l<o.length;l++){var u=o[l];if("parser"!==u&&!e.valueGetterAttrMap.get(u)){var h=dt(lV,u)?lV[u]:u,c=t[u],p=s?s(c):c,d=Ad(h,p)||"reg"===h&&new uV(p);d||yr(n),r.push(d)}}r.length||yr(n);var f=new fV;return f.valueGetterParam=i,f.valueParser=s,f.getValue=e.getValue,f.subCondList=r,f}(t,e)}function yV(t,e,n){var i=e[t],r="";F(i)||yr(r),i.length||yr(r);var o="and"===t?new cV:new pV;return o.children=O(i,(function(t){return gV(t,n)})),o.children.length||yr(r),o}function vV(t){return X(t)&&!k(t)}var mV=function(){function t(t,e){this._cond=gV(t,e)}return t.prototype.evaluate=function(){return this._cond.evaluate()},t}();var _V={type:"echarts:filter",transform:function(t){for(var e,n,i,r=t.upstream,o=(n=t.config,i={valueGetterAttrMap:ht({dimension:!0}),prepareGetValue:function(t){var e="",n=t.dimension;dt(t,"dimension")||yr(e);var i=r.getDimensionInfo(n);return i||yr(e),{dimIdx:i.index}},getValue:function(t){return r.retrieveValueFromItem(e,t.dimIdx)}},new mV(n,i)),a=[],s=0,l=r.count();s<l;s++)e=r.getRawDataItem(s),o.evaluate()&&a.push(e);return{data:a}}};var xV={type:"echarts:sort",transform:function(t){var e=t.upstream,n=t.config,i="",r=_r(n);r.length||yr(i);var o=[];P(r,(function(t){var n=t.dimension,r=t.order,a=t.parser,s=t.incomparable;if(null==n&&yr(i),"asc"!==r&&"desc"!==r&&yr(i),s&&"min"!==s&&"max"!==s){var l="";0,yr(l)}if("asc"!==r&&"desc"!==r){var u="";0,yr(u)}var h=e.getDimensionInfo(n);h||yr(i);var c=a?Sd(a):null;a&&!c&&yr(i),o.push({dimIdx:h.index,parser:c,comparator:new Td(r,s)})}));var a=e.sourceFormat;a!==Gc&&a!==Hc&&yr(i);for(var s=[],l=0,u=e.count();l<u;l++)s.push(e.getRawDataItem(l));return s.sort((function(t,n){for(var i=0;i<o.length;i++){var r=o[i],a=e.retrieveValueFromItem(t,r.dimIdx),s=e.retrieveValueFromItem(n,r.dimIdx);r.parser&&(a=r.parser(a),s=r.parser(s));var l=r.comparator.evaluate(a,s);if(0!==l)return l}return 0})),{data:s}}};var bV=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="dataset",e}return n(e,t),e.prototype.init=function(e,n,i){t.prototype.init.call(this,e,n,i),this._sourceManager=new zd(this),Bd(this)},e.prototype.mergeOption=function(e,n){t.prototype.mergeOption.call(this,e,n),Bd(this)},e.prototype.optionUpdated=function(){this._sourceManager.dirty()},e.prototype.getSourceManager=function(){return this._sourceManager},e.type="dataset",e.defaultOption={seriesLayoutBy:Uc},e}(Nc),wV=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.type="dataset",e}return n(e,t),e.type="dataset",e}(pf);em([function(t){t.registerPainter("canvas",vb)}]),em([function(t){t.registerPainter("svg",lb)}]),em([function(t){t.registerChartView(Jb),t.registerSeriesModel(mb),t.registerLayout(Qb("line",!0)),t.registerProcessor(t.PRIORITY.PROCESSOR.STATISTIC,nw("line"))},function(t){t.registerChartView(pw),t.registerSeriesModel(rw),t.registerLayout(t.PRIORITY.VISUAL.LAYOUT,V(h_,"bar")),t.registerLayout(t.PRIORITY.VISUAL.PROGRESSIVE_LAYOUT,c_),t.registerVisual({seriesType:"bar",reset:function(t){t.getData().setVisual("legendSymbol","roundRect")}}),t.registerProcessor(t.PRIORITY.PROCESSOR.STATISTIC,nw("bar")),t.registerAction({type:"changeAxisOrder",event:"changeAxisOrder",update:"update"},(function(t,e){var n=t.componentType||"series";e.eachComponent({mainType:n,query:t},(function(e){t.sortInfo&&e.axis.setCategorySortInfo(t.sortInfo)}))}))},function(t){t.registerChartView(Ow),t.registerSeriesModel(Ew),Kg("pie",t.registerAction),t.registerLayout(V(Iw,"pie")),t.registerProcessor(Tw("pie"))},function(t){em(NS),t.registerSeriesModel(zw),t.registerChartView(Gw),t.registerLayout(Qb("scatter"))},function(t){em(qS),t.registerChartView(FS),t.registerSeriesModel(GS),t.registerLayout(ES),t.registerProcessor(Tw("radar")),t.registerPreprocessor(VS)},function(t){em(QM),t.registerChartView(VM),t.registerSeriesModel(FM),t.registerLayout(HM),t.registerProcessor(t.PRIORITY.PROCESSOR.STATISTIC,GM),Kg("map",t.registerAction)},function(t){t.registerChartView(cI),t.registerSeriesModel(CI),t.registerLayout(DI),t.registerVisual(LI),function(t){t.registerAction({type:"treeExpandAndCollapse",event:"treeExpandAndCollapse",update:"update"},(function(t,e){e.eachComponent({mainType:"series",subType:"tree",query:t},(function(e){var n=t.dataIndex,i=e.getData().tree.getNodeByDataIndex(n);i.isExpand=!i.isExpand}))})),t.registerAction({type:"treeRoam",event:"treeRoam",update:"none"},(function(t,e){e.eachComponent({mainType:"series",subType:"tree",query:t},(function(e){var n=$M(e.coordinateSystem,t);e.setCenter&&e.setCenter(n.center),e.setZoom&&e.setZoom(n.zoom)}))}))}(t)},function(t){t.registerSeriesModel(BI),t.registerChartView($I),t.registerVisual(fT),t.registerLayout(CT),function(t){for(var e=0;e<EI.length;e++)t.registerAction({type:EI[e],update:"updateView"},NI);t.registerAction({type:"treemapRootToNode",update:"updateView"},(function(t,e){e.eachComponent({mainType:"series",subType:"treemap",query:t},(function(e,n){var i=kI(t,["treemapZoomToNode","treemapRootToNode"],e);if(i){var r=e.getViewRoot();r&&(t.direction=OI(r,i.node)?"rollUp":"drillDown"),e.resetViewRoot(i.node)}}))}))}(t)},function(t){t.registerChartView(TC),t.registerSeriesModel(OC),t.registerProcessor(OT),t.registerVisual(RT),t.registerVisual(ET),t.registerLayout(UT),t.registerLayout(t.PRIORITY.VISUAL.POST_CHART_LAYOUT,QT),t.registerLayout(eC),t.registerCoordinateSystem("graphView",{dimensions:YM.dimensions,create:nC}),t.registerAction({type:"focusNodeAdjacency",event:"focusNodeAdjacency",update:"series:focusNodeAdjacency"},(function(){})),t.registerAction({type:"unfocusNodeAdjacency",event:"unfocusNodeAdjacency",update:"series:unfocusNodeAdjacency"},(function(){})),t.registerAction(RC,(function(t,e){e.eachComponent({mainType:"series",query:t},(function(e){var n=$M(e.coordinateSystem,t);e.setCenter&&e.setCenter(n.center),e.setZoom&&e.setZoom(n.zoom)}))}))},function(t){t.registerChartView(VC),t.registerSeriesModel(FC)},function(t){t.registerChartView(WC),t.registerSeriesModel(YC),t.registerLayout(XC),t.registerProcessor(Tw("funnel"))},function(t){em(vD),t.registerChartView(UC),t.registerSeriesModel($C),t.registerVisual(t.PRIORITY.VISUAL.BRUSH,tA)},function(t){t.registerChartView(xD),t.registerSeriesModel(bD),t.registerLayout(wD),t.registerVisual(RD),t.registerAction({type:"dragNode",event:"dragnode",update:"update"},(function(t,e){e.eachComponent({mainType:"series",subType:"sankey",query:t},(function(e){e.setNodePosition(t.dataIndex,[t.localX,t.localY])}))}))},function(t){t.registerSeriesModel(ED),t.registerChartView(zD),t.registerVisual(WD),t.registerLayout(XD),t.registerTransform(UD)},function(t){t.registerChartView(jD),t.registerSeriesModel(oL),t.registerPreprocessor(aL),t.registerVisual(cL),t.registerLayout(dL)},function(t){t.registerChartView(vL),t.registerSeriesModel(mL),t.registerLayout(Qb("effectScatter"))},function(t){t.registerChartView(TL),t.registerSeriesModel(LL),t.registerLayout(IL),t.registerVisual(PL)},function(t){t.registerChartView(NL),t.registerSeriesModel(EL)},function(t){t.registerChartView(FL),t.registerSeriesModel(rk),t.registerLayout(V(h_,"pictorialBar"))},function(t){t.registerChartView(ok),t.registerSeriesModel(ak),t.registerLayout(sk),t.registerProcessor(Tw("themeRiver"))},function(t){t.registerChartView(pk),t.registerSeriesModel(dk),t.registerLayout(V(yk,"sunburst")),t.registerProcessor(V(Tw,"sunburst")),t.registerVisual(mk),function(t){t.registerAction({type:hk,update:"updateView"},(function(t,e){e.eachComponent({mainType:"series",subType:"sunburst",query:t},(function(e,n){var i=kI(t,[hk],e);if(i){var r=e.getViewRoot();r&&(t.direction=OI(r,i.node)?"rollUp":"drillDown"),e.resetViewRoot(i.node)}}))})),t.registerAction({type:ck,update:"none"},(function(t,e,n){t=I({},t),e.eachComponent({mainType:"series",subType:"sunburst",query:t},(function(e){var n=kI(t,[ck],e);n&&(t.dataIndex=n.node.dataIndex)})),n.dispatchAction(I(t,{type:"highlight"}))})),t.registerAction({type:"sunburstUnhighlight",update:"updateView"},(function(t,e,n){t=I({},t),n.dispatchAction(I(t,{type:"downplay"}))}))}(t)},function(t){t.registerChartView(gP),t.registerSeriesModel(fP)}]),em((function(t){em(NS),em(NO)})),em((function(t){em(NO),SS.registerAxisPointerClass("PolarAxisPointer",EO),t.registerCoordinateSystem("polar",qO),t.registerComponentModel(BO),t.registerComponentView(cR),qw(t,"angle",FO,uR),qw(t,"radius",GO,hR),t.registerComponentView(tR),t.registerComponentView(rR),t.registerLayout(V(lR,"bar"))})),em(QM),em((function(t){em(NO),SS.registerAxisPointerClass("SingleAxisPointer",MR),t.registerComponentView(AR),t.registerComponentView(gR),t.registerComponentModel(vR),qw(t,"single",vR,vR.defaultOption),t.registerCoordinateSystem("single",bR)})),em(vD),em((function(t){t.registerComponentModel(DR),t.registerComponentView(OR),t.registerCoordinateSystem("calendar",NR)})),em((function(t){t.registerComponentModel(FR),t.registerComponentView(GR),t.registerPreprocessor(VR)})),em((function(t){t.registerComponentModel(dN),t.registerComponentView(gN),cN("saveAsImage",yN),cN("magicType",_N),cN("dataView",TN),cN("dataZoom",qN),cN("restore",kN),em(lN)})),em((function(t){em(NO),t.registerComponentModel(JN),t.registerComponentView(pE),t.registerAction({type:"showTip",event:"showTip",update:"tooltip:manuallyShowTip"},(function(){})),t.registerAction({type:"hideTip",event:"hideTip",update:"tooltip:manuallyHideTip"},(function(){}))})),em(NO),em((function(t){t.registerComponentView(RE),t.registerComponentModel(NE),t.registerPreprocessor(vE),t.registerVisual(t.PRIORITY.VISUAL.BRUSH,DE),t.registerAction({type:"brush",event:"brush",update:"updateVisual"},(function(t,e){e.eachComponent({mainType:"brush",query:t},(function(e){e.setAreas(t.areas)}))})),t.registerAction({type:"brushSelect",event:"brushSelected",update:"none"},(function(){})),t.registerAction({type:"brushEnd",event:"brushEnd",update:"none"},(function(){})),cN("brush",BE)})),em((function(t){t.registerComponentModel(VE),t.registerComponentView(FE)})),em((function(t){t.registerComponentModel(HE),t.registerComponentView(ZE),t.registerSubTypeDefaulter("timeline",(function(){return"slider"})),function(t){t.registerAction({type:"timelineChange",event:"timelineChanged",update:"prepareAndUpdate"},(function(t,e){var n=e.getComponent("timeline");return n&&null!=t.currentIndex&&(n.setCurrentIndex(t.currentIndex),!n.get("loop",!0)&&n.isIndexMax()&&n.setPlayState(!1)),e.resetOption("timeline",{replaceMerge:n.get("replaceMerge",!0)}),T({currentIndex:n.option.currentIndex},t)})),t.registerAction({type:"timelinePlayChange",event:"timelinePlayChanged",update:"update"},(function(t,e){var n=e.getComponent("timeline");n&&null!=t.playState&&n.setPlayState(t.playState)}))}(t),t.registerPreprocessor(KE)})),em((function(t){t.registerComponentModel(nz),t.registerComponentView(dz),t.registerPreprocessor((function(t){t.markPoint=t.markPoint||{}}))})),em((function(t){t.registerComponentModel(fz),t.registerComponentView(bz),t.registerPreprocessor((function(t){t.markLine=t.markLine||{}}))})),em((function(t){t.registerComponentModel(wz),t.registerComponentView(Lz),t.registerPreprocessor((function(t){t.markArea=t.markArea||{}}))})),em((function(t){em(Wz),em(Kz)})),em((function(t){em(lB),em(vB)})),em(lB),em(vB),em((function(t){em($B),em(nV)})),em($B),em(nV),em((function(t){t.registerPreprocessor(sV),t.registerVisual(t.PRIORITY.VISUAL.ARIA,aV)})),em((function(t){t.registerTransform(_V),t.registerTransform(xV)})),em((function(t){t.registerComponentModel(bV),t.registerComponentView(wV)})),t.Axis=vx,t.ChartView=yf,t.ComponentModel=Nc,t.ComponentView=pf,t.List=Pm,t.Model=Sh,t.PRIORITY=Wy,t.SeriesModel=rf,t.color=ln,t.connect=function(t){if(F(t)){var e=t;t=null,Ey(e,(function(e){null!=e.group&&(t=e.group)})),t=t||"g_"+Rv++,Ey(e,(function(e){e.group=t}))}return Pv[t]=!0,t},t.dataTool={},t.dependencies={zrender:"5.0.4"},t.disConnect=Ev,t.disconnect=zv,t.dispose=function(t){"string"==typeof t?t=kv[t]:t instanceof mv||(t=Bv(t)),t instanceof mv&&!t.isDisposed()&&t.dispose()},t.env=a,t.extendChartView=function(t){var e=yf.extend(t);return yf.registerClass(e),e},t.extendComponentModel=function(t){var e=Nc.extend(t);return Nc.registerClass(e),e},t.extendComponentView=function(t){var e=pf.extend(t);return pf.registerClass(e),e},t.extendSeriesModel=function(t){var e=rf.extend(t);return rf.registerClass(e),e},t.format=ox,t.getCoordinateSystemDimensions=function(t){var e=_p.get(t);if(e)return e.getDimensionsInfo?e.getDimensionsInfo():e.dimensions.slice()},t.getInstanceByDom=Bv,t.getInstanceById=function(t){return kv[t]},t.getMap=function(t){var e=lg(t);return e&&e[0]&&{geoJson:e[0].geoJSON,specialAreas:e[0].specialAreas}},t.graphic=rx,t.helper=K_,t.init=function(t,e,n){var i=Bv(t);if(i)return i;var r=new mv(t,e,n);return r.id="ec_"+Ov++,kv[r.id]=r,Er(t,Nv,r.id),pv(r),Ey(Tv,(function(t){t(r)})),r},t.innerDrawElementOnCanvas=Ty,t.matrix=Se,t.number=nx,t.parseGeoJSON=ex,t.parseGeoJson=ex,t.registerAction=Yv,t.registerCoordinateSystem=Xv,t.registerLayout=Uv,t.registerLoading=Kv,t.registerLocale=Oh,t.registerMap=$v,t.registerPostInit=Hv,t.registerPostUpdate=Wv,t.registerPreprocessor=Fv,t.registerProcessor=Gv,t.registerTheme=Vv,t.registerTransform=Jv,t.registerVisual=Zv,t.setCanvasCreator=function(t){m("createCanvas",t)},t.throttle=If,t.time=ix,t.use=em,t.util=ax,t.vector=zt,t.version="5.0.2",t.zrUtil=gt,t.zrender=Yi,Object.defineProperty(t,"__esModule",{value:!0})}));
diff --git a/src/main/resources/web/js/main.js b/src/main/resources/web/js/main.js
new file mode 100644
index 0000000..e69de29
diff --git a/src/main/resources/web/js/main_chart.js b/src/main/resources/web/js/main_chart.js
new file mode 100644
index 0000000..cbae906
--- /dev/null
+++ b/src/main/resources/web/js/main_chart.js
@@ -0,0 +1,226 @@
+var echarts = require('echarts');
+
+var ROOT_PATH = 'https://echarts.apache.org/examples';
+var UP_COLOR = '#00da3c';
+var DOWN_COLOR = '#ec0000';
+
+
+$.get(ROOT_PATH + '/data/asset/data/stock-DJI.json', function (rawData) {
+    var data = splitData(rawData);
+    initTradeChart(elementID, data)
+}
+
+
+function splitData(rawData) {
+    var categoryData = [];
+    var values = [];
+    var volumes = [];
+    for (var i = 0; i < rawData.length; i++) {
+        categoryData.push(rawData[i].splice(0, 1)[0]);
+        values.push(rawData[i]);
+
+        volumes.push([
+            i,
+            rawData[i][4],
+            rawData[i][0] > rawData[i][1] ? 1 : -1
+        ]);
+    }
+
+    return {
+        categoryData: categoryData,
+        values: values,
+        volumes: volumes
+    };
+}
+
+function calculateMovingAverage(dayCount, data) {
+    var result = [];
+    for (var i = 0, len = data.values.length; i < len; i++) {
+        if (i < dayCount) {
+            result.push('-');
+            continue;
+        }
+        var sum = 0;
+        for (var j = 0; j < dayCount; j++) {
+            sum += data.values[i - j][1];
+        }
+        result.push(+(sum / dayCount).toFixed(3));
+    }
+    return result;
+}
+
+function initTradeChart(elementID, data) {
+    var chartDom = document.getElementById(elementID);
+    var myChart = echarts.init(chartDom);
+
+    myChart.setOption({
+        animation: false,
+        tooltip: {
+            trigger: 'axis',
+            axisPointer: {
+                type: 'cross'
+            },
+            borderWidth: 1,
+            borderColor: '#ccc',
+            padding: 10,
+            textStyle: {
+                color: '#000'
+            },
+            position: function (pos, params, el, elRect, size) {
+                var obj = {top: 10};
+                obj[['left', 'right'][+(pos[0] < size.viewSize[0] / 2)]] = 30;
+                return obj;
+            }
+        },
+        axisPointer: {
+            link: {xAxisIndex: 'all'},
+            label: {
+                backgroundColor: '#777'
+            }
+        },
+        visualMap: {
+            show: false,
+            seriesIndex: 1,
+            dimension: 2,
+            pieces: [{
+                value: 1,
+                color: DOWN_COLOR
+            }, {
+                value: -1,
+                color: UP_COLOR
+            }]
+        },
+        grid: [
+            {
+                left: '10%',
+                right: '8%',
+                height: '50%'
+            },
+            {
+                left: '10%',
+                right: '8%',
+                top: '58%',
+                height: '13%'
+            }
+        ],
+        xAxis: [
+            {
+                type: 'category',
+                data: data.categoryData,
+                scale: true,
+                boundaryGap: false,
+                axisLine: {onZero: false},
+                splitLine: {show: false},
+                splitNumber: 20,
+                min: 'dataMin',
+                max: 'dataMax',
+                axisPointer: {
+                    z: 100
+                }
+            },
+            {
+                type: 'category',
+                gridIndex: 1,
+                data: data.categoryData,
+                scale: true,
+                boundaryGap: false,
+                axisLine: {onZero: false},
+                axisTick: {show: false},
+                splitLine: {show: false},
+                axisLabel: {show: false},
+                splitNumber: 20,
+                min: 'dataMin',
+                max: 'dataMax'
+            }
+        ],
+        yAxis: [
+            {
+                scale: true,
+            },
+            {
+                scale: true,
+                gridIndex: 1,
+                splitNumber: 2,
+                axisLabel: {show: false},
+                axisLine: {show: false},
+                axisTick: {show: false},
+                splitLine: {show: false}
+            }
+        ],
+        dataZoom: [
+            {
+                type: 'inside',
+                xAxisIndex: [0, 1],
+                start: 98,
+                end: 100
+            },
+            {
+                show: true,
+                xAxisIndex: [0, 1],
+                type: 'slider',
+                top: '85%',
+                start: 98,
+                end: 100
+            }
+        ],
+        series: [
+            {
+                name: 'Dow-Jones index',
+                type: 'candlestick',
+                data: data.values,
+                itemStyle: {
+                    color: UP_COLOR,
+                    color0: DOWN_COLOR,
+                    borderColor: null,
+                    borderColor0: null
+                },
+                tooltip: {
+                    formatter: function (param) {
+                        param = param[0];
+                        return [
+                            'Date: ' + param.name + '<hr size=1 style="margin: 3px 0">',
+                            'Open: ' + param.data[0] + '<br/>',
+                            'Close: ' + param.data[1] + '<br/>',
+                            'Lowest: ' + param.data[2] + '<br/>',
+                            'Highest: ' + param.data[3] + '<br/>'
+                        ].join('');
+                    }
+                }
+            },
+            {
+                name: 'Volume',
+                type: 'bar',
+                xAxisIndex: 1,
+                yAxisIndex: 1,
+                data: data.volumes
+            },
+            {
+                name: 'MA5',
+                type: 'line',
+                data: calculateMA(7, data),
+                smooth: true,
+                lineStyle: {
+                    opacity: 0.5
+                }
+            },
+            {
+                name: 'MA20',
+                type: 'line',
+                data: calculateMA(20, data),
+                smooth: true,
+                lineStyle: {
+                    opacity: 0.5
+                }
+            },
+            {
+                name: 'MA50',
+                type: 'line',
+                data: calculateMA(50, data),
+                smooth: true,
+                lineStyle: {
+                    opacity: 0.5
+                }
+            },
+        ]
+    }, true);
+});
diff --git a/src/main/resources/web/page_market_overview.tmpl b/src/main/resources/web/page_market_overview.tmpl
new file mode 100644
index 0000000..2a2092f
--- /dev/null
+++ b/src/main/resources/web/page_market_overview.tmpl
@@ -0,0 +1,27 @@
+<div class="d-flex justify-content-between flex-wrap flex-md-nowrap align-items-center pt-3 pb-2 mb-3 border-bottom">
+    <h1">Market Overview</h1>
+</div>
+
+<h2>Open Trades</h2>
+<div class="table-responsive">
+    <table class="table table-striped table-sm">
+        <thead>
+        <tr>
+            <th>#</th>
+            <th>Header</th>
+            <th>Header</th>
+            <th>Header</th>
+            <th>Header</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td>1,001</td>
+            <td>random</td>
+            <td>data</td>
+            <td>placeholder</td>
+            <td>text</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
diff --git a/src/main/resources/web/page_market_symbol.tmpl b/src/main/resources/web/page_market_symbol.tmpl
new file mode 100644
index 0000000..e376515
--- /dev/null
+++ b/src/main/resources/web/page_market_symbol.tmpl
@@ -0,0 +1,47 @@
+<div class="d-flex justify-content-between flex-wrap flex-md-nowrap align-items-center pt-3 pb-2 mb-3 border-bottom">
+    <h1>Sign {{sign_name}}</h1>
+</div>
+
+<canvas id="sign_chart" class="my-4 w-100" id="myChart" width="900" height="380"></canvas>
+
+<h2>Open Trades</h2>
+<div class="table-responsive">
+    <table class="table table-striped table-sm">
+        <thead>
+        <tr>
+            <th>#</th>
+            <th>Header</th>
+            <th>Header</th>
+            <th>Header</th>
+            <th>Header</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td>1,001</td>
+            <td>random</td>
+            <td>data</td>
+            <td>placeholder</td>
+            <td>text</td>
+        </tr>
+        <tr>
+            <td>1,002</td>
+            <td>placeholder</td>
+            <td>irrelevant</td>
+            <td>visual</td>
+            <td>layout</td>
+        </tr>
+        <tr>
+            <td>1,003</td>
+            <td>data</td>
+            <td>rich</td>
+            <td>dashboard</td>
+            <td>tabular</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+
+<script>
+    initTradeChart("sign_chart", [])
+</script>
\ No newline at end of file
diff --git a/src/test/java/se/koc/trader/exchange/binance/BinanceRestAPITest.java b/src/test/java/se/koc/trader/exchange/binance/BinanceRestAPITest.java
new file mode 100644
index 0000000..ad16216
--- /dev/null
+++ b/src/test/java/se/koc/trader/exchange/binance/BinanceRestAPITest.java
@@ -0,0 +1,28 @@
+package se.koc.trader.exchange.binance;
+
+import org.junit.jupiter.api.Test;
+import zutil.net.ws.rest.RESTClientFactory;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BinanceRestAPITest {
+
+    public BinanceRestAPI getRestAPI() {
+        try {
+            return RESTClientFactory.createClient(new URL("https://api.binance.com"), BinanceRestAPI.class);
+        } catch (MalformedURLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+
+    @Test
+    public void getServerTime() {
+        BinanceRestAPI rest = getRestAPI();
+        assertTrue(rest.getServerTime() > 0, "Unable to retrieve server time");
+    }
+}
\ No newline at end of file