q2-tecton-elements 1.51.1 → 1.52.1

package/dist/q2-tecton-elements/dataSample-7b62e101.js

@@ -0,0 +1,2602 @@
+import { ag as a, I as r, a4 as t, ah as i, D as e, ai as n, aj as s, ak as o, al as l, am as u, an as v, m as f, ao as c, ap as h, a0 as d, aq as x, a3 as y, ar as A, as as g, at as C, au as m, av as b, aw as p, ax as w, _ as M, ay as k, az as L, aA as T, y as S, aB as G, aC as I, aD as D, aE as V, a6 as N, aF as B, Q as O, aG as P, aH as z, aI as F, aJ as E, aK as Z, aL as R, j as W, aM as _, aN as j, aO as U, aP as X, aQ as Y, aR as $, aS as K, aT as H, aU as Q, W as q, G as J, aV as aa, aW as ra, a as ta, aX as ia, aY as ea, aZ as na, a_ as sa, a$ as oa, a9 as la, b0 as ua, b1 as va, E as fa, b2 as ca, b3 as ha, d as da, b4 as xa, i as ya, V as Aa, b5 as ga } from "./charting-1abfb877.js";
+
+/**
+ * @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 Ca = /** @class */ function() {
+  function CoordSysInfo(a) {
+    this.coordSysDims = [];
+    this.axisMap = t();
+    this.categoryAxisMap = t();
+    this.coordSysName = a;
+  }
+  return CoordSysInfo;
+}();
+
+function getCoordSysInfoBySeries(a) {
+  var r = a.get("coordinateSystem");
+  var t = new Ca(r);
+  var i = ma[r];
+  if (i) {
+    i(a, t, t.axisMap, t.categoryAxisMap);
+    return t;
+  }
+}
+
+var ma = {
+  cartesian2d: function(r, t, i, e) {
+    var n = r.getReferringComponents("xAxis", a).models[0];
+    var s = r.getReferringComponents("yAxis", a).models[0];
+    t.coordSysDims = [ "x", "y" ];
+    i.set("x", n);
+    i.set("y", s);
+    if (isCategory(n)) {
+      e.set("x", n);
+      t.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(s)) {
+      e.set("y", s);
+      t.firstCategoryDimIndex == null && (t.firstCategoryDimIndex = 1);
+    }
+  },
+  singleAxis: function(r, t, i, e) {
+    var n = r.getReferringComponents("singleAxis", a).models[0];
+    t.coordSysDims = [ "single" ];
+    i.set("single", n);
+    if (isCategory(n)) {
+      e.set("single", n);
+      t.firstCategoryDimIndex = 0;
+    }
+  },
+  polar: function(r, t, i, e) {
+    var n = r.getReferringComponents("polar", a).models[0];
+    var s = n.findAxisModel("radiusAxis");
+    var o = n.findAxisModel("angleAxis");
+    t.coordSysDims = [ "radius", "angle" ];
+    i.set("radius", s);
+    i.set("angle", o);
+    if (isCategory(s)) {
+      e.set("radius", s);
+      t.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(o)) {
+      e.set("angle", o);
+      t.firstCategoryDimIndex == null && (t.firstCategoryDimIndex = 1);
+    }
+  },
+  geo: function(a, r, t, i) {
+    r.coordSysDims = [ "lng", "lat" ];
+  },
+  parallel: function(a, t, i, e) {
+    var n = a.ecModel;
+    var s = n.getComponent("parallel", a.get("parallelIndex"));
+    var o = t.coordSysDims = s.dimensions.slice();
+    r(s.parallelAxisIndex, (function(a, r) {
+      var s = n.getComponent("parallelAxis", a);
+      var l = o[r];
+      i.set(l, s);
+      if (isCategory(s)) {
+        e.set(l, s);
+        if (t.firstCategoryDimIndex == null) {
+          t.firstCategoryDimIndex = r;
+        }
+      }
+    }));
+  }
+};
+
+function isCategory(a) {
+  return a.get("type") === "category";
+}
+
+function getCoordSysDimDefs(a, r) {
+  var t = a.get("coordinateSystem");
+  var i = v.get(t);
+  var e;
+  if (r && r.coordSysDims) {
+    e = f(r.coordSysDims, (function(a) {
+      var t = {
+        name: a
+      };
+      var i = r.axisMap.get(a);
+      if (i) {
+        var e = i.get("type");
+        t.type = c(e);
+      }
+      return t;
+    }));
+  }
+  if (!e) {
+    // Get dimensions from registered coordinate system
+    e = i && (i.getDimensionsInfo ? i.getDimensionsInfo() : i.dimensions.slice()) || [ "x", "y" ];
+  }
+  return e;
+}
+
+function injectOrdinalMeta(a, t, i) {
+  var e;
+  var n;
+  i && r(a, (function(a, r) {
+    var s = a.coordDim;
+    var o = i.categoryAxisMap.get(s);
+    if (o) {
+      if (e == null) {
+        e = r;
+      }
+      a.ordinalMeta = o.getOrdinalMeta();
+      if (t) {
+        a.createInvertedIndices = true;
+      }
+    }
+    if (a.otherDims.itemName != null) {
+      n = true;
+    }
+  }));
+  if (!n && e != null) {
+    a[e].otherDims.itemName = 0;
+  }
+  return e;
+}
+
+/**
+ * Caution: there are side effects to `sourceManager` in this method.
+ * Should better only be called in `Series['getInitialData']`.
+ */ function createSeriesData(a, r, t) {
+  t = t || {};
+  var v = r.getSourceManager();
+  var f;
+  var c = false;
+  if (a) {
+    c = true;
+    f = i(a);
+  } else {
+    f = v.getSource();
+    // Is series.data. not dataset.
+        c = f.sourceFormat === h;
+  }
+  var d = getCoordSysInfoBySeries(r);
+  var x = getCoordSysDimDefs(r, d);
+  var y = t.useEncodeDefaulter;
+  var A = e(y) ? y : y ? n(s, x, r) : null;
+  var g = {
+    coordDimensions: x,
+    generateCoord: t.generateCoord,
+    encodeDefine: r.getEncode(),
+    encodeDefaulter: A,
+    canOmitUnusedDimensions: !c
+  };
+  var C = o(f, g);
+  var m = injectOrdinalMeta(C.dimensions, t.createInvertedIndices, d);
+  var b = !c ? v.getSharedDataStore(C) : null;
+  var p = l(r, {
+    schema: C,
+    store: b
+  });
+  var w = new u(C, r);
+  w.setCalculationInfo(p);
+  var M = m != null && isNeedCompleteOrdinalData(f) ? function(a, r, t, i) {
+    // Use dataIndex as ordinal value in categoryAxis
+    return i === m ? t : this.defaultDimValueGetter(a, r, t, i);
+  } : null;
+  w.hasItemOption = false;
+  w.initData(
+  // Try to reuse the data store in sourceManager if using dataset.
+  c ? f : b, null, M);
+  return w;
+}
+
+function isNeedCompleteOrdinalData(a) {
+  if (a.sourceFormat === h) {
+    var r = firstDataNotNull(a.data || []);
+    return !d(x(r));
+  }
+}
+
+function firstDataNotNull(a) {
+  var r = 0;
+  while (r < a.length && a[r] == null) {
+    r++;
+  }
+  return a[r];
+}
+
+/*
+* 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.
+*/
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+var ba = /** @class */ function() {
+  function AxisModelCommonMixin() {}
+  AxisModelCommonMixin.prototype.getNeedCrossZero = function() {
+    var a = this.option;
+    return !a.scale;
+  };
+  /**
+   * Should be implemented by each axis model if necessary.
+   * @return coordinate system model
+   */  AxisModelCommonMixin.prototype.getCoordSysModel = function() {
+    return;
+  };
+  return AxisModelCommonMixin;
+}();
+
+var pa = y();
+
+function tickValuesToNumbers(a, r) {
+  var t = f(r, (function(r) {
+    return a.scale.parse(r);
+  }));
+  if (a.type === "time" && t.length > 0) {
+    // Time axis needs duplicate first/last tick (see TimeScale.getTicks())
+    // The first and last tick/label don't get drawn
+    t.sort();
+    t.unshift(t[0]);
+    t.push(t[t.length - 1]);
+  }
+  return t;
+}
+
+function createAxisLabels(a) {
+  var r = a.getLabelModel().get("customValues");
+  if (r) {
+    var t = A(a);
+    return {
+      labels: tickValuesToNumbers(a, r).map((function(r) {
+        var i = {
+          value: r
+        };
+        return {
+          formattedLabel: t(i),
+          rawLabel: a.scale.getLabel(i),
+          tickValue: r
+        };
+      }))
+    };
+  }
+  // Only ordinal scale support tick interval
+    return a.type === "category" ? makeCategoryLabels(a) : makeRealNumberLabels(a);
+}
+
+/**
+ * @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(a, r) {
+  var t = a.getTickModel().get("customValues");
+  if (t) {
+    return {
+      ticks: tickValuesToNumbers(a, t)
+    };
+  }
+  // Only ordinal scale support tick interval
+    return a.type === "category" ? makeCategoryTicks(a, r) : {
+    ticks: f(a.scale.getTicks(), (function(a) {
+      return a.value;
+    }))
+  };
+}
+
+function makeCategoryLabels(a) {
+  var r = a.getLabelModel();
+  var t = makeCategoryLabelsActually(a, r);
+  return !r.get("show") || a.scale.isBlank() ? {
+    labels: [],
+    labelCategoryInterval: t.labelCategoryInterval
+  } : t;
+}
+
+function makeCategoryLabelsActually(a, r) {
+  var t = getListCache(a, "labels");
+  var i = g(r);
+  var n = listCacheGet(t, i);
+  if (n) {
+    return n;
+  }
+  var s;
+  var o;
+  if (e(i)) {
+    s = makeLabelsByCustomizedCategoryInterval(a, i);
+  } else {
+    o = i === "auto" ? makeAutoCategoryInterval(a) : i;
+    s = makeLabelsByNumericCategoryInterval(a, o);
+  }
+  // Cache to avoid calling interval function repeatedly.
+    return listCacheSet(t, i, {
+    labels: s,
+    labelCategoryInterval: o
+  });
+}
+
+function makeCategoryTicks(a, r) {
+  var t = getListCache(a, "ticks");
+  var i = g(r);
+  var n = listCacheGet(t, i);
+  if (n) {
+    return n;
+  }
+  var s;
+  var o;
+  // Optimize for the case that large category data and no label displayed,
+  // we should not return all ticks.
+    if (!r.get("show") || a.scale.isBlank()) {
+    s = [];
+  }
+  if (e(i)) {
+    s = makeLabelsByCustomizedCategoryInterval(a, i, 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 (i === "auto") {
+    var l = makeCategoryLabelsActually(a, a.getLabelModel());
+    o = l.labelCategoryInterval;
+    s = f(l.labels, (function(a) {
+      return a.tickValue;
+    }));
+  } else {
+    o = i;
+    s = makeLabelsByNumericCategoryInterval(a, o, true);
+  }
+  // Cache to avoid calling interval function repeatedly.
+    return listCacheSet(t, i, {
+    ticks: s,
+    tickCategoryInterval: o
+  });
+}
+
+function makeRealNumberLabels(a) {
+  var r = a.scale.getTicks();
+  var t = A(a);
+  return {
+    labels: f(r, (function(r, i) {
+      return {
+        level: r.level,
+        formattedLabel: t(r, i),
+        rawLabel: a.scale.getLabel(r),
+        tickValue: r.value
+      };
+    }))
+  };
+}
+
+function getListCache(a, r) {
+  // Because key can be a function, and cache size always is small, we use array cache.
+  return pa(a)[r] || (pa(a)[r] = []);
+}
+
+function listCacheGet(a, r) {
+  for (var t = 0; t < a.length; t++) {
+    if (a[t].key === r) {
+      return a[t].value;
+    }
+  }
+}
+
+function listCacheSet(a, r, t) {
+  a.push({
+    key: r,
+    value: t
+  });
+  return t;
+}
+
+function makeAutoCategoryInterval(a) {
+  var r = pa(a).autoInterval;
+  return r != null ? r : pa(a).autoInterval = a.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(a) {
+  var r = fetchAutoCategoryIntervalCalculationParams(a);
+  var t = A(a);
+  var i = (r.axisRotate - r.labelRotate) / 180 * Math.PI;
+  var e = a.scale;
+  var n = e.getExtent();
+  // Providing this method is for optimization:
+  // avoid generating a long array by `getTicks`
+  // in large category data case.
+    var s = e.count();
+  if (n[1] - n[0] < 1) {
+    return 0;
+  }
+  var o = 1;
+  // Simple optimization. Empirical value: tick count should less than 40.
+    if (s > 40) {
+    o = Math.max(1, Math.floor(s / 40));
+  }
+  var l = n[0];
+  var u = a.dataToCoord(l + 1) - a.dataToCoord(l);
+  var v = Math.abs(u * Math.cos(i));
+  var f = Math.abs(u * Math.sin(i));
+  var c = 0;
+  var h = 0;
+  // Caution: Performance sensitive for large category data.
+  // Consider dataZoom, we should make appropriate step to avoid O(n) loop.
+    for (;l <= n[1]; l += o) {
+    var d = 0;
+    var x = 0;
+    // Not precise, do not consider align and vertical align
+    // and each distance from axis line yet.
+        var y = C(t({
+      value: l
+    }), r.font, "center", "top");
+    // Magic number
+        d = y.width * 1.3;
+    x = y.height * 1.3;
+    // Min size, void long loop.
+        c = Math.max(c, d, 7);
+    h = Math.max(h, x, 7);
+  }
+  var g = c / v;
+  var m = h / f;
+  // 0/0 is NaN, 1/0 is Infinity.
+    isNaN(g) && (g = Infinity);
+  isNaN(m) && (m = Infinity);
+  var b = Math.max(0, Math.floor(Math.min(g, m)));
+  var p = pa(a.model);
+  var w = a.getExtent();
+  var M = p.lastAutoInterval;
+  var k = p.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 (M != null && k != null && Math.abs(M - b) <= 1 && Math.abs(k - s) <= 1 && M > b && p.axisExtent0 === w[0] && p.axisExtent1 === w[1]) {
+    b = M;
+  }
+  // Only update cache if cache not used, otherwise the
+  // changing of interval is too insensitive.
+   else {
+    p.lastTickCount = s;
+    p.lastAutoInterval = b;
+    p.axisExtent0 = w[0];
+    p.axisExtent1 = w[1];
+  }
+  return b;
+}
+
+function fetchAutoCategoryIntervalCalculationParams(a) {
+  var r = a.getLabelModel();
+  return {
+    axisRotate: a.getRotate ? a.getRotate() : a.isHorizontal && !a.isHorizontal() ? 90 : 0,
+    labelRotate: r.get("rotate") || 0,
+    font: r.getFont()
+  };
+}
+
+function makeLabelsByNumericCategoryInterval(a, r, t) {
+  var i = A(a);
+  var e = a.scale;
+  var n = e.getExtent();
+  var s = a.getLabelModel();
+  var o = [];
+  // TODO: axisType: ordinalTime, pick the tick from each month/day/year/...
+    var l = Math.max((r || 0) + 1, 1);
+  var u = n[0];
+  var v = e.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 (u !== 0 && l > 1 && v / l > 2) {
+    u = Math.round(Math.ceil(u / l) * l);
+  }
+  // (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 f = m(a);
+  var c = s.get("showMinLabel") || f;
+  var h = s.get("showMaxLabel") || f;
+  if (c && u !== n[0]) {
+    addItem(n[0]);
+  }
+  // Optimize: avoid generating large array by `ordinalScale.getTicks()`.
+    var d = u;
+  for (;d <= n[1]; d += l) {
+    addItem(d);
+  }
+  if (h && d - l !== n[1]) {
+    addItem(n[1]);
+  }
+  function addItem(a) {
+    var r = {
+      value: a
+    };
+    o.push(t ? a : {
+      formattedLabel: i(r),
+      rawLabel: e.getLabel(r),
+      tickValue: a
+    });
+  }
+  return o;
+}
+
+function makeLabelsByCustomizedCategoryInterval(a, t, i) {
+  var e = a.scale;
+  var n = A(a);
+  var s = [];
+  r(e.getTicks(), (function(a) {
+    var r = e.getLabel(a);
+    var o = a.value;
+    if (t(a.value, r)) {
+      s.push(i ? o : {
+        formattedLabel: n(a),
+        rawLabel: r,
+        tickValue: o
+      });
+    }
+  }));
+  return s;
+}
+
+var wa = [ 0, 1 ];
+
+/**
+ * Base class of Axis.
+ */ var Ma = /** @class */ function() {
+  function Axis(a, r, t) {
+    this.onBand = false;
+    this.inverse = false;
+    this.dim = a;
+    this.scale = r;
+    this._extent = t || [ 0, 0 ];
+  }
+  /**
+   * If axis extent contain given coord
+   */  Axis.prototype.contain = function(a) {
+    var r = this._extent;
+    var t = Math.min(r[0], r[1]);
+    var i = Math.max(r[0], r[1]);
+    return a >= t && a <= i;
+  };
+  /**
+   * If axis extent contain given data
+   */  Axis.prototype.containData = function(a) {
+    return this.scale.contain(a);
+  };
+  /**
+   * Get coord extent.
+   */  Axis.prototype.getExtent = function() {
+    return this._extent.slice();
+  };
+  /**
+   * Get precision used for formatting
+   */  Axis.prototype.getPixelPrecision = function(a) {
+    return b(a || this.scale.getExtent(), this._extent);
+  };
+  /**
+   * Set coord extent
+   */  Axis.prototype.setExtent = function(a, r) {
+    var t = this._extent;
+    t[0] = a;
+    t[1] = r;
+  };
+  /**
+   * Convert data to coord. Data is the rank if it has an ordinal scale
+   */  Axis.prototype.dataToCoord = function(a, r) {
+    var t = this._extent;
+    var i = this.scale;
+    a = i.normalize(a);
+    if (this.onBand && i.type === "ordinal") {
+      t = t.slice();
+      fixExtentWithBands(t, i.count());
+    }
+    return p(a, wa, t, r);
+  };
+  /**
+   * Convert coord to data. Data is the rank if it has an ordinal scale
+   */  Axis.prototype.coordToData = function(a, r) {
+    var t = this._extent;
+    var i = this.scale;
+    if (this.onBand && i.type === "ordinal") {
+      t = t.slice();
+      fixExtentWithBands(t, i.count());
+    }
+    var e = p(a, t, wa, r);
+    return this.scale.scale(e);
+  };
+  /**
+   * Convert pixel point to data in axis
+   */  Axis.prototype.pointToData = function(a, r) {
+    // 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(a) {
+    a = a || {};
+    var r = a.tickModel || this.getTickModel();
+    var t = createAxisTicks(this, r);
+    var i = t.ticks;
+    var e = f(i, (function(a) {
+      return {
+        coord: this.dataToCoord(this.scale.type === "ordinal" ? this.scale.getRawOrdinalNumber(a) : a),
+        tickValue: a
+      };
+    }), this);
+    var n = r.get("alignWithLabel");
+    fixOnBandTicksCoords(this, e, n, a.clamp);
+    return e;
+  };
+  Axis.prototype.getMinorTicksCoords = function() {
+    if (this.scale.type === "ordinal") {
+      // Category axis doesn't support minor ticks
+      return [];
+    }
+    var a = this.model.getModel("minorTick");
+    var r = a.get("splitNumber");
+    // Protection.
+        if (!(r > 0 && r < 100)) {
+      r = 5;
+    }
+    var t = this.scale.getMinorTicks(r);
+    var i = f(t, (function(a) {
+      return f(a, (function(a) {
+        return {
+          coord: this.dataToCoord(a),
+          tickValue: a
+        };
+      }), this);
+    }), this);
+    return i;
+  };
+  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 overridden 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 a = this._extent;
+    var r = this.scale.getExtent();
+    var t = r[1] - r[0] + (this.onBand ? 1 : 0);
+    // Fix #2728, avoid NaN when only one data.
+        t === 0 && (t = 1);
+    var i = Math.abs(a[1] - a[0]);
+    return Math.abs(i) / t;
+  };
+  /**
+   * Only be called in category axis.
+   * Can be overridden, 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(a, r) {
+  var t = a[1] - a[0];
+  var i = r;
+  var e = t / i / 2;
+  a[0] += e;
+  a[1] -= e;
+}
+
+// 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(a, t, i, e) {
+  var n = t.length;
+  if (!a.onBand || i || !n) {
+    return;
+  }
+  var s = a.getExtent();
+  var o;
+  var l;
+  if (n === 1) {
+    t[0].coord = s[0];
+    o = t[1] = {
+      coord: s[1]
+    };
+  } else {
+    var u = t[n - 1].tickValue - t[0].tickValue;
+    var v = (t[n - 1].coord - t[0].coord) / u;
+    r(t, (function(a) {
+      a.coord -= v / 2;
+    }));
+    var f = a.scale.getExtent();
+    l = 1 + f[1] - t[n - 1].tickValue;
+    o = {
+      coord: t[n - 1].coord + v * l
+    };
+    t.push(o);
+  }
+  var c = s[0] > s[1];
+  // Handling clamp.
+    if (littleThan(t[0].coord, s[0])) {
+    e ? t[0].coord = s[0] : t.shift();
+  }
+  if (e && littleThan(s[0], t[0].coord)) {
+    t.unshift({
+      coord: s[0]
+    });
+  }
+  if (littleThan(s[1], o.coord)) {
+    e ? o.coord = s[1] : t.pop();
+  }
+  if (e && littleThan(o.coord, s[1])) {
+    t.push({
+      coord: s[1]
+    });
+  }
+  function littleThan(a, r) {
+    // Avoid rounding error cause calculated tick coord different with extent.
+    // It may cause an extra unnecessary tick added.
+    a = w(a);
+    r = w(r);
+    return c ? a > r : a < r;
+  }
+}
+
+const ka = Ma;
+
+var La = /** @class */ function(a) {
+  M(GridModel, a);
+  function GridModel() {
+    return a !== null && a.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;
+}(k);
+
+const Ta = La;
+
+var Sa = /** @class */ function(r) {
+  M(CartesianAxisModel, r);
+  function CartesianAxisModel() {
+    return r !== null && r.apply(this, arguments) || this;
+  }
+  CartesianAxisModel.prototype.getCoordSysModel = function() {
+    return this.getReferringComponents("grid", a).models[0];
+  };
+  CartesianAxisModel.type = "cartesian2dAxis";
+  return CartesianAxisModel;
+}(k);
+
+L(Sa, ba);
+
+var Ga = {
+  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 Ia = T({
+  // 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"
+  }
+}, Ga);
+
+var Da = T({
+  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,
+    // Length of minor tick
+    length: 3,
+    // Line style
+    lineStyle: {}
+  },
+  minorSplitLine: {
+    show: false,
+    lineStyle: {
+      color: "#F4F7FD",
+      width: 1
+    }
+  }
+}, Ga);
+
+var Va = T({
+  splitNumber: 6,
+  axisLabel: {
+    // To eliminate labels that are not nice
+    showMinLabel: false,
+    showMaxLabel: false,
+    rich: {
+      primary: {
+        fontWeight: "bold"
+      }
+    }
+  },
+  splitLine: {
+    show: false
+  }
+}, Da);
+
+var Na = S({
+  logBase: 10
+}, Da);
+
+const Ba = {
+  category: Ia,
+  value: Da,
+  time: Va,
+  log: Na
+};
+
+/*
+* 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 Oa = {
+  value: 1,
+  category: 1,
+  time: 1,
+  log: 1
+};
+
+/**
+ * Generate sub axis model class
+ * @param axisName 'x' 'y' 'radius' 'angle' 'parallel' ...
+ */ function axisModelCreator(a, t, i, e) {
+  r(Oa, (function(r, n) {
+    var s = T(T({}, Ba[n], true), e, true);
+    var o = /** @class */ function(a) {
+      M(AxisModel, a);
+      function AxisModel() {
+        var r = a !== null && a.apply(this, arguments) || this;
+        r.type = t + "Axis." + n;
+        return r;
+      }
+      AxisModel.prototype.mergeDefaultAndTheme = function(a, r) {
+        var t = V(this);
+        var i = t ? G(a) : {};
+        var e = r.getTheme();
+        T(a, e.get(n + "Axis"));
+        T(a, this.getDefaultOption());
+        a.type = getAxisType(a);
+        if (t) {
+          I(a, i, t);
+        }
+      };
+      AxisModel.prototype.optionUpdated = function() {
+        var a = this.option;
+        if (a.type === "category") {
+          this.__ordinalMeta = D.createByAxisModel(this);
+        }
+      };
+      /**
+       * Should not be called before all of 'getInitailData' finished.
+       * Because categories are collected during initializing data.
+       */      AxisModel.prototype.getCategories = function(a) {
+        var r = this.option;
+        // FIXME
+        // warning if called before all of 'getInitailData' finished.
+                if (r.type === "category") {
+          if (a) {
+            return r.data;
+          }
+          return this.__ordinalMeta.categories;
+        }
+      };
+      AxisModel.prototype.getOrdinalMeta = function() {
+        return this.__ordinalMeta;
+      };
+      AxisModel.type = t + "Axis." + n;
+      AxisModel.defaultOption = s;
+      return AxisModel;
+    }(i);
+    a.registerComponentModel(o);
+  }));
+  a.registerSubTypeDefaulter(t + "Axis", getAxisType);
+}
+
+function getAxisType(a) {
+  // Default axis with data is category axis
+  return a.type || (a.data ? "category" : "value");
+}
+
+var Pa = /** @class */ function() {
+  function Cartesian(a) {
+    this.type = "cartesian";
+    this._dimList = [];
+    this._axes = {};
+    this.name = a || "";
+  }
+  Cartesian.prototype.getAxis = function(a) {
+    return this._axes[a];
+  };
+  Cartesian.prototype.getAxes = function() {
+    return f(this._dimList, (function(a) {
+      return this._axes[a];
+    }), this);
+  };
+  Cartesian.prototype.getAxesByScale = function(a) {
+    a = a.toLowerCase();
+    return N(this.getAxes(), (function(r) {
+      return r.scale.type === a;
+    }));
+  };
+  Cartesian.prototype.addAxis = function(a) {
+    var r = a.dim;
+    this._axes[r] = a;
+    this._dimList.push(r);
+  };
+  return Cartesian;
+}();
+
+const za = Pa;
+
+var Fa = [ "x", "y" ];
+
+function canCalculateAffineTransform(a) {
+  return a.type === "interval" || a.type === "time";
+}
+
+var Ea = /** @class */ function(a) {
+  M(Cartesian2D, a);
+  function Cartesian2D() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = "cartesian2d";
+    r.dimensions = Fa;
+    return r;
+  }
+  /**
+   * 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 a = this.getAxis("x").scale;
+    var r = this.getAxis("y").scale;
+    if (!canCalculateAffineTransform(a) || !canCalculateAffineTransform(r)) {
+      return;
+    }
+    var t = a.getExtent();
+    var i = r.getExtent();
+    var e = this.dataToPoint([ t[0], i[0] ]);
+    var n = this.dataToPoint([ t[1], i[1] ]);
+    var s = t[1] - t[0];
+    var o = i[1] - i[0];
+    if (!s || !o) {
+      return;
+    }
+    // Accelerate data to point calculation on the special large time series data.
+        var l = (n[0] - e[0]) / s;
+    var u = (n[1] - e[1]) / o;
+    var v = e[0] - t[0] * l;
+    var f = e[1] - i[0] * u;
+    var c = this._transform = [ l, 0, 0, u, v, f ];
+    this._invTransform = B([], c);
+  };
+  /**
+   * 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(a) {
+    var r = this.getAxis("x");
+    var t = this.getAxis("y");
+    return r.contain(r.toLocalCoord(a[0])) && t.contain(t.toLocalCoord(a[1]));
+  };
+  Cartesian2D.prototype.containData = function(a) {
+    return this.getAxis("x").containData(a[0]) && this.getAxis("y").containData(a[1]);
+  };
+  Cartesian2D.prototype.containZone = function(a, r) {
+    var t = this.dataToPoint(a);
+    var i = this.dataToPoint(r);
+    var e = this.getArea();
+    var n = new O(t[0], t[1], i[0] - t[0], i[1] - t[1]);
+    return e.intersect(n);
+  };
+  Cartesian2D.prototype.dataToPoint = function(a, r, t) {
+    t = t || [];
+    var i = a[0];
+    var e = a[1];
+    // Fast path
+        if (this._transform && i != null && isFinite(i) && e != null && isFinite(e)) {
+      return P(t, a, this._transform);
+    }
+    var n = this.getAxis("x");
+    var s = this.getAxis("y");
+    t[0] = n.toGlobalCoord(n.dataToCoord(i, r));
+    t[1] = s.toGlobalCoord(s.dataToCoord(e, r));
+    return t;
+  };
+  Cartesian2D.prototype.clampData = function(a, r) {
+    var t = this.getAxis("x").scale;
+    var i = this.getAxis("y").scale;
+    var e = t.getExtent();
+    var n = i.getExtent();
+    var s = t.parse(a[0]);
+    var o = i.parse(a[1]);
+    r = r || [];
+    r[0] = Math.min(Math.max(Math.min(e[0], e[1]), s), Math.max(e[0], e[1]));
+    r[1] = Math.min(Math.max(Math.min(n[0], n[1]), o), Math.max(n[0], n[1]));
+    return r;
+  };
+  Cartesian2D.prototype.pointToData = function(a, r) {
+    var t = [];
+    if (this._invTransform) {
+      return P(t, a, this._invTransform);
+    }
+    var i = this.getAxis("x");
+    var e = this.getAxis("y");
+    t[0] = i.coordToData(i.toLocalCoord(a[0]), r);
+    t[1] = e.coordToData(e.toLocalCoord(a[1]), r);
+    return t;
+  };
+  Cartesian2D.prototype.getOtherAxis = function(a) {
+    return this.getAxis(a.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(a) {
+    a = a || 0;
+    var r = this.getAxis("x").getGlobalExtent();
+    var t = this.getAxis("y").getGlobalExtent();
+    var i = Math.min(r[0], r[1]) - a;
+    var e = Math.min(t[0], t[1]) - a;
+    var n = Math.max(r[0], r[1]) - i + a;
+    var s = Math.max(t[0], t[1]) - e + a;
+    return new O(i, e, n, s);
+  };
+  return Cartesian2D;
+}(za);
+
+const Za = Ea;
+
+var Ra = /** @class */ function(a) {
+  M(Axis2D, a);
+  function Axis2D(r, t, i, e, n) {
+    var s = a.call(this, r, t, i) || this;
+    /**
+     * Index of axis, can be used as key
+     * Injected outside.
+     */    s.index = 0;
+    s.type = e || "value";
+    s.position = n || "bottom";
+    return s;
+  }
+  Axis2D.prototype.isHorizontal = function() {
+    var a = this.position;
+    return a === "top" || a === "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(a) {
+    var r = this.getExtent();
+    r[0] = this.toGlobalCoord(r[0]);
+    r[1] = this.toGlobalCoord(r[1]);
+    a && r[0] > r[1] && r.reverse();
+    return r;
+  };
+  Axis2D.prototype.pointToData = function(a, r) {
+    return this.coordToData(this.toLocalCoord(a[this.dim === "x" ? 0 : 1]), r);
+  };
+  /**
+   * Set ordinalSortInfo
+   * @param info new OrdinalSortInfo
+   */  Axis2D.prototype.setCategorySortInfo = function(a) {
+    if (this.type !== "category") {
+      return false;
+    }
+    this.model.option.categorySortInfo = a;
+    this.scale.setSortInfo(a);
+  };
+  return Axis2D;
+}(ka);
+
+const Wa = Ra;
+
+var _a = Math.log;
+
+function alignScaleTicks(a, r, t) {
+  var i = E.prototype;
+  // NOTE: There is a precondition for log scale  here:
+  // In log scale we store _interval and _extent of exponent value.
+  // So if we use the method of InternalScale to set/get these data.
+  // It process the exponent value, which is linear and what we want here.
+    var e = i.getTicks.call(t);
+  var n = i.getTicks.call(t, true);
+  var s = e.length - 1;
+  var o = i.getInterval.call(t);
+  var l = z(a, r);
+  var u = l.extent;
+  var v = l.fixMin;
+  var f = l.fixMax;
+  if (a.type === "log") {
+    var c = _a(a.base);
+    u = [ _a(u[0]) / c, _a(u[1]) / c ];
+  }
+  a.setExtent(u[0], u[1]);
+  a.calcNiceExtent({
+    splitNumber: s,
+    fixMin: v,
+    fixMax: f
+  });
+  var h = i.getExtent.call(a);
+  // Need to update the rawExtent.
+  // Because value in rawExtent may be not parsed. e.g. 'dataMin', 'dataMax'
+    if (v) {
+    u[0] = h[0];
+  }
+  if (f) {
+    u[1] = h[1];
+  }
+  var d = i.getInterval.call(a);
+  var x = u[0];
+  var y = u[1];
+  if (v && f) {
+    // User set min, max, divide to get new interval
+    d = (y - x) / s;
+  } else if (v) {
+    y = u[0] + d * s;
+    // User set min, expand extent on the other side
+        while (y < u[1] && isFinite(y) && isFinite(u[1])) {
+      d = F(d);
+      y = u[0] + d * s;
+    }
+  } else if (f) {
+    // User set max, expand extent on the other side
+    x = u[1] - d * s;
+    while (x > u[0] && isFinite(x) && isFinite(u[0])) {
+      d = F(d);
+      x = u[1] - d * s;
+    }
+  } else {
+    var A = a.getTicks().length - 1;
+    if (A > s) {
+      d = F(d);
+    }
+    var g = d * s;
+    y = Math.ceil(u[1] / d) * d;
+    x = w(y - g);
+    // Not change the result that crossing zero.
+        if (x < 0 && u[0] >= 0) {
+      x = 0;
+      y = w(g);
+    } else if (y > 0 && u[1] <= 0) {
+      y = 0;
+      x = -w(g);
+    }
+  }
+  // Adjust min, max based on the extent of alignTo. When min or max is set in alignTo scale
+    var C = (e[0].value - n[0].value) / o;
+  var m = (e[s].value - n[s].value) / o;
+  // NOTE: Must in setExtent -> setInterval -> setNiceExtent order.
+    i.setExtent.call(a, x + d * C, y + d * m);
+  i.setInterval.call(a, d);
+  if (C || m) {
+    i.setNiceExtent.call(a, x + d, y - d);
+  }
+}
+
+var ja = /** @class */ function() {
+  function Grid(a, r, t) {
+    // 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 = Fa;
+    this._initCartesian(a, r, t);
+    this.model = a;
+  }
+  Grid.prototype.getRect = function() {
+    return this._rect;
+  };
+  Grid.prototype.update = function(a, t) {
+    var i = this._axesMap;
+    this._updateScale(a, this.model);
+    function updateAxisTicks(a) {
+      var t;
+      // Axis is added in order of axisIndex.
+            var i = K(a);
+      var e = i.length;
+      if (!e) {
+        return;
+      }
+      var n = [];
+      // Process once and calculate the ticks for those don't use alignTicks.
+            for (var s = e - 1; s >= 0; s--) {
+        var o = +i[s];
+ // Convert to number.
+                var l = a[o];
+        var u = l.model;
+        var v = l.scale;
+        if (
+        // Only value and log axis without interval support alignTicks.
+        H(v) && u.get("alignTicks") && u.get("interval") == null) {
+          n.push(l);
+        } else {
+          Q(v, u);
+          if (H(v)) {
+            // Can only align to interval or log axis.
+            t = l;
+          }
+        }
+      }
+      // All axes has set alignTicks. Pick the first one.
+      // PENDING. Should we find the axis that both set interval, min, max and align to this one?
+            if (n.length) {
+        if (!t) {
+          t = n.pop();
+          Q(t.scale, t.model);
+        }
+        r(n, (function(a) {
+          alignScaleTicks(a.scale, a.model, t.scale);
+        }));
+      }
+    }
+    updateAxisTicks(i.x);
+    updateAxisTicks(i.y);
+    // Key: axisDim_axisIndex, value: boolean, whether onZero target.
+        var e = {};
+    r(i.x, (function(a) {
+      fixAxisOnZero(i, "y", a, e);
+    }));
+    r(i.y, (function(a) {
+      fixAxisOnZero(i, "x", a, e);
+    }));
+    // Resize again if containLabel is enabled
+    // FIXME It may cause getting wrong grid size in data processing stage
+        this.resize(this.model, t);
+  };
+  /**
+   * Resize the grid
+   */  Grid.prototype.resize = function(a, t, i) {
+    var e = a.getBoxLayoutParams();
+    var n = !i && a.get("containLabel");
+    var s = Z(e, {
+      width: t.getWidth(),
+      height: t.getHeight()
+    });
+    this._rect = s;
+    var o = this._axesList;
+    adjustAxes();
+    // Minus label size
+        if (n) {
+      r(o, (function(a) {
+        if (!a.model.get([ "axisLabel", "inside" ])) {
+          var r = R(a);
+          if (r) {
+            var t = a.isHorizontal() ? "height" : "width";
+            var i = a.model.get([ "axisLabel", "margin" ]);
+            s[t] -= r[t] + i;
+            if (a.position === "top") {
+              s.y += r.height + i;
+            } else if (a.position === "left") {
+              s.x += r.width + i;
+            }
+          }
+        }
+      }));
+      adjustAxes();
+    }
+    r(this._coordsList, (function(a) {
+      // Calculate affine matrix to accelerate the data to point transform.
+      // If all the axes scales are time or value.
+      a.calcAffineTransform();
+    }));
+    function adjustAxes() {
+      r(o, (function(a) {
+        var r = a.isHorizontal();
+        var t = r ? [ 0, s.width ] : [ 0, s.height ];
+        var i = a.inverse ? 1 : 0;
+        a.setExtent(t[i], t[1 - i]);
+        updateAxisTransform(a, r ? s.x : s.y);
+      }));
+    }
+  };
+  Grid.prototype.getAxis = function(a, r) {
+    var t = this._axesMap[a];
+    if (t != null) {
+      return t[r || 0];
+    }
+  };
+  Grid.prototype.getAxes = function() {
+    return this._axesList.slice();
+  };
+  Grid.prototype.getCartesian = function(a, r) {
+    if (a != null && r != null) {
+      var t = "x" + a + "y" + r;
+      return this._coordsMap[t];
+    }
+    if (W(a)) {
+      r = a.yAxisIndex;
+      a = a.xAxisIndex;
+    }
+    for (var i = 0, e = this._coordsList; i < e.length; i++) {
+      if (e[i].getAxis("x").index === a || e[i].getAxis("y").index === r) {
+        return e[i];
+      }
+    }
+  };
+  Grid.prototype.getCartesians = function() {
+    return this._coordsList.slice();
+  };
+  /**
+   * @implements
+   */  Grid.prototype.convertToPixel = function(a, r, t) {
+    var i = this._findConvertTarget(r);
+    return i.cartesian ? i.cartesian.dataToPoint(t) : i.axis ? i.axis.toGlobalCoord(i.axis.dataToCoord(t)) : null;
+  };
+  /**
+   * @implements
+   */  Grid.prototype.convertFromPixel = function(a, r, t) {
+    var i = this._findConvertTarget(r);
+    return i.cartesian ? i.cartesian.pointToData(t) : i.axis ? i.axis.coordToData(i.axis.toLocalCoord(t)) : null;
+  };
+  Grid.prototype._findConvertTarget = function(r) {
+    var t = r.seriesModel;
+    var i = r.xAxisModel || t && t.getReferringComponents("xAxis", a).models[0];
+    var e = r.yAxisModel || t && t.getReferringComponents("yAxis", a).models[0];
+    var n = r.gridModel;
+    var s = this._coordsList;
+    var o;
+    var l;
+    if (t) {
+      o = t.coordinateSystem;
+      _(s, o) < 0 && (o = null);
+    } else if (i && e) {
+      o = this.getCartesian(i.componentIndex, e.componentIndex);
+    } else if (i) {
+      l = this.getAxis("x", i.componentIndex);
+    } else if (e) {
+      l = this.getAxis("y", e.componentIndex);
+    }
+    // Lowest priority.
+     else if (n) {
+      var u = n.coordinateSystem;
+      if (u === this) {
+        o = this._coordsList[0];
+      }
+    }
+    return {
+      cartesian: o,
+      axis: l
+    };
+  };
+  /**
+   * @implements
+   */  Grid.prototype.containPoint = function(a) {
+    var r = this._coordsList[0];
+    if (r) {
+      return r.containPoint(a);
+    }
+  };
+  /**
+   * Initialize cartesian coordinate systems
+   */  Grid.prototype._initCartesian = function(a, t, i) {
+    var e = this;
+    var n = this;
+    var s = {
+      left: false,
+      right: false,
+      top: false,
+      bottom: false
+    };
+    var o = {
+      x: {},
+      y: {}
+    };
+    var l = {
+      x: 0,
+      y: 0
+    };
+    // Create axis
+        t.eachComponent("xAxis", createAxisCreator("x"), this);
+    t.eachComponent("yAxis", createAxisCreator("y"), this);
+    if (!l.x || !l.y) {
+      // Roll back when there no either x or y axis
+      this._axesMap = {};
+      this._axesList = [];
+      return;
+    }
+    this._axesMap = o;
+    // Create cartesian2d
+        r(o.x, (function(t, i) {
+      r(o.y, (function(r, n) {
+        var s = "x" + i + "y" + n;
+        var o = new Za(s);
+        o.master = e;
+        o.model = a;
+        e._coordsMap[s] = o;
+        e._coordsList.push(o);
+        o.addAxis(t);
+        o.addAxis(r);
+      }));
+    }));
+    function createAxisCreator(r) {
+      return function(t, i) {
+        if (!isAxisUsedInTheGrid(t, a)) {
+          return;
+        }
+        var e = t.get("position");
+        if (r === "x") {
+          // Fix position
+          if (e !== "top" && e !== "bottom") {
+            // Default bottom of X
+            e = s.bottom ? "top" : "bottom";
+          }
+        } else {
+          // Fix position
+          if (e !== "left" && e !== "right") {
+            // Default left of Y
+            e = s.left ? "right" : "left";
+          }
+        }
+        s[e] = true;
+        var u = new Wa(r, j(t), [ 0, 0 ], t.get("type"), e);
+        var v = u.type === "category";
+        u.onBand = v && t.get("boundaryGap");
+        u.inverse = t.get("inverse");
+        // Inject axis into axisModel
+                t.axis = u;
+        // Inject axisModel into axis
+                u.model = t;
+        // Inject grid info axis
+                u.grid = n;
+        // Index of axis, can be used as key
+                u.index = i;
+        n._axesList.push(u);
+        o[r][i] = u;
+        l[r]++;
+      };
+    }
+  };
+  /**
+   * Update cartesian properties from series.
+   */  Grid.prototype._updateScale = function(a, t) {
+    // Reset scale
+    r(this._axesList, (function(a) {
+      a.scale.setExtent(Infinity, -Infinity);
+      if (a.type === "category") {
+        var r = a.model.get("categorySortInfo");
+        a.scale.setSortInfo(r);
+      }
+    }));
+    a.eachSeries((function(a) {
+      if (U(a)) {
+        var r = X(a);
+        var i = r.xAxisModel;
+        var e = r.yAxisModel;
+        if (!isAxisUsedInTheGrid(i, t) || !isAxisUsedInTheGrid(e, t)) {
+          return;
+        }
+        var n = this.getCartesian(i.componentIndex, e.componentIndex);
+        var s = a.getData();
+        var o = n.getAxis("x");
+        var l = n.getAxis("y");
+        unionExtent(s, o);
+        unionExtent(s, l);
+      }
+    }), this);
+    function unionExtent(a, t) {
+      r(Y(a, t.dim), (function(r) {
+        t.scale.unionExtentFromData(a, r);
+      }));
+    }
+  };
+  /**
+   * @param dim 'x' or 'y' or 'auto' or null/undefined
+   */  Grid.prototype.getTooltipAxes = function(a) {
+    var t = [];
+    var i = [];
+    r(this.getCartesians(), (function(r) {
+      var e = a != null && a !== "auto" ? r.getAxis(a) : r.getBaseAxis();
+      var n = r.getOtherAxis(e);
+      _(t, e) < 0 && t.push(e);
+      _(i, n) < 0 && i.push(n);
+    }));
+    return {
+      baseAxes: t,
+      otherAxes: i
+    };
+  };
+  Grid.create = function(a, r) {
+    var t = [];
+    a.eachComponent("grid", (function(i, e) {
+      var n = new Grid(i, a, r);
+      n.name = "grid_" + e;
+      // dataSampling requires axis extent, so resize
+      // should be performed in create stage.
+            n.resize(i, r, true);
+      i.coordinateSystem = n;
+      t.push(n);
+    }));
+    // Inject the coordinateSystems into seriesModel
+        a.eachSeries((function(a) {
+      if (!U(a)) {
+        return;
+      }
+      var r = X(a);
+      var t = r.xAxisModel;
+      var i = r.yAxisModel;
+      var e = t.getCoordSysModel();
+      var n = e.coordinateSystem;
+      a.coordinateSystem = n.getCartesian(t.componentIndex, i.componentIndex);
+    }));
+    return t;
+  };
+  // For deciding which dimensions to use when creating list data
+    Grid.dimensions = Fa;
+  return Grid;
+}();
+
+/**
+ * Check if the axis is used in the specified grid.
+ */ function isAxisUsedInTheGrid(a, r) {
+  return a.getCoordSysModel() === r;
+}
+
+function fixAxisOnZero(a, r, t, 
+// Key: see `getOnZeroRecordKey`
+i) {
+  t.getAxesOnZeroOf = function() {
+    // TODO: onZero of multiple axes.
+    return n ? [ n ] : [];
+  };
+  // 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 e = a[r];
+  var n;
+  var s = t.model;
+  var o = s.get([ "axisLine", "onZero" ]);
+  var l = s.get([ "axisLine", "onZeroAxisIndex" ]);
+  if (!o) {
+    return;
+  }
+  // If target axis is specified.
+    if (l != null) {
+    if (canOnZeroToAxis(e[l])) {
+      n = e[l];
+    }
+  } else {
+    // Find the first available other axis.
+    for (var u in e) {
+      if (e.hasOwnProperty(u) && canOnZeroToAxis(e[u]) && !i[getOnZeroRecordKey(e[u])]) {
+        n = e[u];
+        break;
+      }
+    }
+  }
+  if (n) {
+    i[getOnZeroRecordKey(n)] = true;
+  }
+  function getOnZeroRecordKey(a) {
+    return a.dim + "_" + a.index;
+  }
+}
+
+function canOnZeroToAxis(a) {
+  return a && a.type !== "category" && a.type !== "time" && $(a);
+}
+
+function updateAxisTransform(a, r) {
+  var t = a.getExtent();
+  var i = t[0] + t[1];
+  // Fast transform
+    a.toGlobalCoord = a.dim === "x" ? function(a) {
+    return a + r;
+  } : function(a) {
+    return i - a + r;
+  };
+  a.toLocalCoord = a.dim === "x" ? function(a) {
+    return a - r;
+  } : function(a) {
+    return i - a + r;
+  };
+}
+
+const Ua = ja;
+
+var Xa = y();
+
+function rectCoordAxisBuildSplitArea(a, r, i, e) {
+  var n = i.axis;
+  if (n.scale.isBlank()) {
+    return;
+  }
+  // TODO: TYPE
+    var s = i.getModel("splitArea");
+  var o = s.getModel("areaStyle");
+  var l = o.get("color");
+  var u = e.coordinateSystem.getRect();
+  var v = n.getTicksCoords({
+    tickModel: s,
+    clamp: true
+  });
+  if (!v.length) {
+    return;
+  }
+  // For Making appropriate splitArea animation, the color and anid
+  // should be corresponding to previous one if possible.
+    var f = l.length;
+  var c = Xa(a).splitAreaColors;
+  var h = t();
+  var x = 0;
+  if (c) {
+    for (var y = 0; y < v.length; y++) {
+      var A = c.get(v[y].tickValue);
+      if (A != null) {
+        x = (A + (f - 1) * y) % f;
+        break;
+      }
+    }
+  }
+  var g = n.toGlobalCoord(v[0].coord);
+  var C = o.getAreaStyle();
+  l = d(l) ? l : [ l ];
+  for (var y = 1; y < v.length; y++) {
+    var m = n.toGlobalCoord(v[y].coord);
+    var b = void 0;
+    var p = void 0;
+    var w = void 0;
+    var M = void 0;
+    if (n.isHorizontal()) {
+      b = g;
+      p = u.y;
+      w = m - b;
+      M = u.height;
+      g = b + w;
+    } else {
+      b = u.x;
+      p = g;
+      w = u.width;
+      M = m - p;
+      g = p + M;
+    }
+    var k = v[y - 1].tickValue;
+    k != null && h.set(k, x);
+    r.add(new q({
+      anid: k != null ? "area_" + k : null,
+      shape: {
+        x: b,
+        y: p,
+        width: w,
+        height: M
+      },
+      style: S({
+        fill: l[x]
+      }, C),
+      autoBatch: true,
+      silent: true
+    }));
+    x = (x + 1) % f;
+  }
+  Xa(a).splitAreaColors = h;
+}
+
+function rectCoordAxisHandleRemove(a) {
+  Xa(a).splitAreaColors = null;
+}
+
+var Ya = [ "axisLine", "axisTickLabel", "axisName" ];
+
+var $a = [ "splitArea", "splitLine", "minorSplitLine" ];
+
+var Ka = /** @class */ function(a) {
+  M(CartesianAxisView, a);
+  function CartesianAxisView() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = CartesianAxisView.type;
+    r.axisPointerClass = "CartesianAxisPointer";
+    return r;
+  }
+  /**
+   * @override
+   */  CartesianAxisView.prototype.render = function(t, i, e, n) {
+    this.group.removeAll();
+    var s = this._axisGroup;
+    this._axisGroup = new J;
+    this.group.add(this._axisGroup);
+    if (!t.get("show")) {
+      return;
+    }
+    var o = t.getCoordSysModel();
+    var l = aa(o, t);
+    var u = new ra(t, ta({
+      handleAutoShown: function(a) {
+        var r = o.coordinateSystem.getCartesians();
+        for (var i = 0; i < r.length; i++) {
+          if (H(r[i].getOtherAxis(t.axis).scale)) {
+            // 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;
+      }
+    }, l));
+    r(Ya, u.add, u);
+    this._axisGroup.add(u.getGroup());
+    r($a, (function(a) {
+      if (t.get([ a, "show" ])) {
+        Ha[a](this, this._axisGroup, t, o);
+      }
+    }), this);
+    // THIS is a special case for bar racing chart.
+    // Update the axis label from the natural initial layout to
+    // sorted layout should has no animation.
+        var v = n && n.type === "changeAxisOrder" && n.isInitSort;
+    if (!v) {
+      ia(s, this._axisGroup, t);
+    }
+    a.prototype.render.call(this, t, i, e, n);
+  };
+  CartesianAxisView.prototype.remove = function() {
+    rectCoordAxisHandleRemove(this);
+  };
+  CartesianAxisView.type = "cartesianAxis";
+  return CartesianAxisView;
+}(ea);
+
+var Ha = {
+  splitLine: function(a, r, t, i) {
+    var e = t.axis;
+    if (e.scale.isBlank()) {
+      return;
+    }
+    var n = t.getModel("splitLine");
+    var s = n.getModel("lineStyle");
+    var o = s.get("color");
+    o = d(o) ? o : [ o ];
+    var l = i.coordinateSystem.getRect();
+    var u = e.isHorizontal();
+    var v = 0;
+    var f = e.getTicksCoords({
+      tickModel: n
+    });
+    var c = [];
+    var h = [];
+    var x = s.getLineStyle();
+    for (var y = 0; y < f.length; y++) {
+      var A = e.toGlobalCoord(f[y].coord);
+      if (u) {
+        c[0] = A;
+        c[1] = l.y;
+        h[0] = A;
+        h[1] = l.y + l.height;
+      } else {
+        c[0] = l.x;
+        c[1] = A;
+        h[0] = l.x + l.width;
+        h[1] = A;
+      }
+      var g = v++ % o.length;
+      var C = f[y].tickValue;
+      var m = new na({
+        anid: C != null ? "line_" + f[y].tickValue : null,
+        autoBatch: true,
+        shape: {
+          x1: c[0],
+          y1: c[1],
+          x2: h[0],
+          y2: h[1]
+        },
+        style: S({
+          stroke: o[g]
+        }, x),
+        silent: true
+      });
+      sa(m.shape, x.lineWidth);
+      r.add(m);
+    }
+  },
+  minorSplitLine: function(a, r, t, i) {
+    var e = t.axis;
+    var n = t.getModel("minorSplitLine");
+    var s = n.getModel("lineStyle");
+    var o = i.coordinateSystem.getRect();
+    var l = e.isHorizontal();
+    var u = e.getMinorTicksCoords();
+    if (!u.length) {
+      return;
+    }
+    var v = [];
+    var f = [];
+    var c = s.getLineStyle();
+    for (var h = 0; h < u.length; h++) {
+      for (var d = 0; d < u[h].length; d++) {
+        var x = e.toGlobalCoord(u[h][d].coord);
+        if (l) {
+          v[0] = x;
+          v[1] = o.y;
+          f[0] = x;
+          f[1] = o.y + o.height;
+        } else {
+          v[0] = o.x;
+          v[1] = x;
+          f[0] = o.x + o.width;
+          f[1] = x;
+        }
+        var y = new na({
+          anid: "minor_line_" + u[h][d].tickValue,
+          autoBatch: true,
+          shape: {
+            x1: v[0],
+            y1: v[1],
+            x2: f[0],
+            y2: f[1]
+          },
+          style: c,
+          silent: true
+        });
+        sa(y.shape, c.lineWidth);
+        r.add(y);
+      }
+    }
+  },
+  splitArea: function(a, r, t, i) {
+    rectCoordAxisBuildSplitArea(a, r, t, i);
+  }
+};
+
+var Qa = /** @class */ function(a) {
+  M(CartesianXAxisView, a);
+  function CartesianXAxisView() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = CartesianXAxisView.type;
+    return r;
+  }
+  CartesianXAxisView.type = "xAxis";
+  return CartesianXAxisView;
+}(Ka);
+
+var qa = /** @class */ function(a) {
+  M(CartesianYAxisView, a);
+  function CartesianYAxisView() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = Qa.type;
+    return r;
+  }
+  CartesianYAxisView.type = "yAxis";
+  return CartesianYAxisView;
+}(Ka);
+
+// Grid view
+var Ja = /** @class */ function(a) {
+  M(GridView, a);
+  function GridView() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = "grid";
+    return r;
+  }
+  GridView.prototype.render = function(a, r) {
+    this.group.removeAll();
+    if (a.get("show")) {
+      this.group.add(new q({
+        shape: a.coordinateSystem.getRect(),
+        style: S({
+          fill: a.get("backgroundColor")
+        }, a.getItemStyle()),
+        silent: true,
+        z2: -1
+      }));
+    }
+  };
+  GridView.type = "grid";
+  return GridView;
+}(oa);
+
+var ar = {
+  // gridIndex: 0,
+  // gridId: '',
+  offset: 0
+};
+
+function install$2(a) {
+  a.registerComponentView(Ja);
+  a.registerComponentModel(Ta);
+  a.registerCoordinateSystem("cartesian2d", Ua);
+  axisModelCreator(a, "x", Sa, ar);
+  axisModelCreator(a, "y", Sa, ar);
+  a.registerComponentView(Qa);
+  a.registerComponentView(qa);
+  a.registerPreprocessor((function(a) {
+    // Only create grid when need
+    if (a.xAxis && a.yAxis && !a.grid) {
+      a.grid = {};
+    }
+  }));
+}
+
+function install$1(a) {
+  la(install$2);
+  la(ua);
+}
+
+var rr = /** @class */ function(a) {
+  M(TitleModel, a);
+  function TitleModel() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = TitleModel.type;
+    r.layoutMode = {
+      type: "box",
+      ignoreSize: true
+    };
+    return r;
+  }
+  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;
+}(k);
+
+// View
+var tr = /** @class */ function(a) {
+  M(TitleView, a);
+  function TitleView() {
+    var r = a !== null && a.apply(this, arguments) || this;
+    r.type = TitleView.type;
+    return r;
+  }
+  TitleView.prototype.render = function(a, r, t) {
+    this.group.removeAll();
+    if (!a.get("show")) {
+      return;
+    }
+    var i = this.group;
+    var e = a.getModel("textStyle");
+    var n = a.getModel("subtextStyle");
+    var s = a.get("textAlign");
+    var o = va(a.get("textBaseline"), a.get("textVerticalAlign"));
+    var l = new fa({
+      style: ca(e, {
+        text: a.get("text"),
+        fill: e.getTextColor()
+      }, {
+        disableBox: true
+      }),
+      z2: 10
+    });
+    var u = l.getBoundingRect();
+    var v = a.get("subtext");
+    var f = new fa({
+      style: ca(n, {
+        text: v,
+        fill: n.getTextColor(),
+        y: u.height + a.get("itemGap"),
+        verticalAlign: "top"
+      }, {
+        disableBox: true
+      }),
+      z2: 10
+    });
+    var c = a.get("link");
+    var h = a.get("sublink");
+    var d = a.get("triggerEvent", true);
+    l.silent = !c && !d;
+    f.silent = !h && !d;
+    if (c) {
+      l.on("click", (function() {
+        ha(c, "_" + a.get("target"));
+      }));
+    }
+    if (h) {
+      f.on("click", (function() {
+        ha(h, "_" + a.get("subtarget"));
+      }));
+    }
+    da(l).eventData = da(f).eventData = d ? {
+      componentType: "title",
+      componentIndex: a.componentIndex
+    } : null;
+    i.add(l);
+    v && i.add(f);
+    // If no subText, but add subTextEl, there will be an empty line.
+        var x = i.getBoundingRect();
+    var y = a.getBoxLayoutParams();
+    y.width = x.width;
+    y.height = x.height;
+    var A = Z(y, {
+      width: t.getWidth(),
+      height: t.getHeight()
+    }, a.get("padding"));
+    // Adjust text align based on position
+        if (!s) {
+      // Align left if title is on the left. center and right is same
+      s = a.get("left") || a.get("right");
+      // @ts-ignore
+            if (s === "middle") {
+        s = "center";
+      }
+      // Adjust layout by text align
+            if (s === "right") {
+        A.x += A.width;
+      } else if (s === "center") {
+        A.x += A.width / 2;
+      }
+    }
+    if (!o) {
+      o = a.get("top") || a.get("bottom");
+      // @ts-ignore
+            if (o === "center") {
+        o = "middle";
+      }
+      if (o === "bottom") {
+        A.y += A.height;
+      } else if (o === "middle") {
+        A.y += A.height / 2;
+      }
+      o = o || "top";
+    }
+    i.x = A.x;
+    i.y = A.y;
+    i.markRedraw();
+    var g = {
+      align: s,
+      verticalAlign: o
+    };
+    l.setStyle(g);
+    f.setStyle(g);
+    // Render background
+    // Get groupRect again because textAlign has been changed
+        x = i.getBoundingRect();
+    var C = A.margin;
+    var m = a.getItemStyle([ "color", "opacity" ]);
+    m.fill = a.get("backgroundColor");
+    var b = new q({
+      shape: {
+        x: x.x - C[3],
+        y: x.y - C[0],
+        width: x.width + C[1] + C[3],
+        height: x.height + C[0] + C[2],
+        r: a.get("borderRadius")
+      },
+      style: m,
+      subPixelOptimize: true,
+      silent: true
+    });
+    i.add(b);
+  };
+  TitleView.type = "title";
+  return TitleView;
+}(oa);
+
+function install(a) {
+  a.registerComponentModel(rr);
+  a.registerComponentView(tr);
+}
+
+/**
+ * @return label string. Not null/undefined
+ */ function getDefaultLabel(a, r) {
+  var t = a.mapDimensionsAll("defaultedLabel");
+  var i = t.length;
+  // Simple optimization (in lots of cases, label dims length is 1)
+    if (i === 1) {
+    var e = xa(a, r, t[0]);
+    return e != null ? e + "" : null;
+  } else if (i) {
+    var n = [];
+    for (var s = 0; s < t.length; s++) {
+      n.push(xa(a, r, t[s]));
+    }
+    return n.join(" ");
+  }
+}
+
+function getDefaultInterpolatedLabel(a, r) {
+  var t = a.mapDimensionsAll("defaultedLabel");
+  if (!d(r)) {
+    return r + "";
+  }
+  var i = [];
+  for (var e = 0; e < t.length; e++) {
+    var n = a.getDimensionIndex(t[e]);
+    if (n >= 0) {
+      i.push(r[n]);
+    }
+  }
+  return i.join(" ");
+}
+
+/*
+* 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(a, r) {
+  return a.type === r;
+}
+
+function createGridClipPath(a, r, t, i, n) {
+  var s = a.getArea();
+  var o = s.x;
+  var l = s.y;
+  var u = s.width;
+  var v = s.height;
+  var f = t.get([ "lineStyle", "width" ]) || 2;
+  // Expand the clip path a bit to avoid the border is clipped and looks thinner
+    o -= f / 2;
+  l -= f / 2;
+  u += f;
+  v += f;
+  // fix: https://github.com/apache/incubator-echarts/issues/11369
+    u = Math.ceil(u);
+  if (o !== Math.floor(o)) {
+    o = Math.floor(o);
+    // if no extra 1px on `width`, it will still be clipped since `x` is floored
+        u++;
+  }
+  var c = new q({
+    shape: {
+      x: o,
+      y: l,
+      width: u,
+      height: v
+    }
+  });
+  if (r) {
+    var h = a.getBaseAxis();
+    var d = h.isHorizontal();
+    var x = h.inverse;
+    if (d) {
+      if (x) {
+        c.shape.x += u;
+      }
+      c.shape.width = 0;
+    } else {
+      if (!x) {
+        c.shape.y += v;
+      }
+      c.shape.height = 0;
+    }
+    var y = e(n) ? function(a) {
+      n(a, c);
+    } : null;
+    ya(c, {
+      shape: {
+        width: u,
+        height: v,
+        x: o,
+        y: l
+      }
+    }, t, null, i, y);
+  }
+  return c;
+}
+
+function createPolarClipPath(a, r, t) {
+  var i = a.getArea();
+  // Avoid float number rounding error for symbol on the edge of axis extent.
+    var e = w(i.r0, 1);
+  var n = w(i.r, 1);
+  var s = new Aa({
+    shape: {
+      cx: w(a.cx, 1),
+      cy: w(a.cy, 1),
+      r0: e,
+      r: n,
+      startAngle: i.startAngle,
+      endAngle: i.endAngle,
+      clockwise: i.clockwise
+    }
+  });
+  if (r) {
+    var o = a.getBaseAxis().dim === "angle";
+    if (o) {
+      s.shape.endAngle = i.startAngle;
+    } else {
+      s.shape.r = e;
+    }
+    ya(s, {
+      shape: {
+        endAngle: i.endAngle,
+        r: n
+      }
+    }, t);
+  }
+  return s;
+}
+
+function createClipPath(a, r, t, i, e) {
+  if (!a) {
+    return null;
+  } else if (a.type === "polar") {
+    return createPolarClipPath(a, r, t);
+  } else if (a.type === "cartesian2d") {
+    return createGridClipPath(a, r, t, i, e);
+  }
+  return null;
+}
+
+var ir = {
+  average: function(a) {
+    var r = 0;
+    var t = 0;
+    for (var i = 0; i < a.length; i++) {
+      if (!isNaN(a[i])) {
+        r += a[i];
+        t++;
+      }
+    }
+    // Return NaN if count is 0
+        return t === 0 ? NaN : r / t;
+  },
+  sum: function(a) {
+    var r = 0;
+    for (var t = 0; t < a.length; t++) {
+      // Ignore NaN
+      r += a[t] || 0;
+    }
+    return r;
+  },
+  max: function(a) {
+    var r = -Infinity;
+    for (var t = 0; t < a.length; t++) {
+      a[t] > r && (r = a[t]);
+    }
+    // NaN will cause illegal axis extent.
+        return isFinite(r) ? r : NaN;
+  },
+  min: function(a) {
+    var r = Infinity;
+    for (var t = 0; t < a.length; t++) {
+      a[t] < r && (r = a[t]);
+    }
+    // NaN will cause illegal axis extent.
+        return isFinite(r) ? r : NaN;
+  },
+  minmax: function(a) {
+    var r = -Infinity;
+    var t = -Infinity;
+    for (var i = 0; i < a.length; i++) {
+      var e = a[i];
+      var n = Math.abs(e);
+      if (n > r) {
+        r = n;
+        t = e;
+      }
+    }
+    return isFinite(t) ? t : NaN;
+  },
+  // TODO
+  // Median
+  nearest: function(a) {
+    return a[0];
+  }
+};
+
+var indexSampler = function(a) {
+  return Math.round(a.length / 2);
+};
+
+function dataSample(a) {
+  return {
+    seriesType: a,
+    // FIXME:TS never used, so comment it
+    // modifyOutputEnd: true,
+    reset: function(a, r, t) {
+      var i = a.getData();
+      var n = a.get("sampling");
+      var s = a.coordinateSystem;
+      var o = i.count();
+      // Only cartesian2d support down sampling. Disable it when there is few data.
+            if (o > 10 && s.type === "cartesian2d" && n) {
+        var l = s.getBaseAxis();
+        var u = s.getOtherAxis(l);
+        var v = l.getExtent();
+        var f = t.getDevicePixelRatio();
+        // Coordinste system has been resized
+                var c = Math.abs(v[1] - v[0]) * (f || 1);
+        var h = Math.round(o / c);
+        if (isFinite(h) && h > 1) {
+          if (n === "lttb") {
+            a.setData(i.lttbDownSample(i.mapDimension(u.dim), 1 / h));
+          }
+          var d = void 0;
+          if (ga(n)) {
+            d = ir[n];
+          } else if (e(n)) {
+            d = n;
+          }
+          if (d) {
+            // Only support sample the first dim mapped from value axis.
+            a.setData(i.downSample(i.mapDimension(u.dim), 1 / h, d, indexSampler));
+          }
+        }
+      }
+    }
+  };
+}
+
+export { getDefaultInterpolatedLabel as a, createGridClipPath as b, createSeriesData as c, createPolarClipPath as d, dataSample as e, install$1 as f, getDefaultLabel as g, install as h, isCoordinateSystemType as i, createClipPath as j };
+//# sourceMappingURL=dataSample-7b62e101.js.map