@fecp/mobile 1.0.79 → 1.1.1

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisModelCreator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const axisDefault = require("./axisDefault.js");
+const layout = require("../util/layout.js");
+const OrdinalMeta = require("../data/OrdinalMeta.js");
+const axisCommonTypes = require("./axisCommonTypes.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function axisModelCreator(registers, axisName, BaseAxisModelClass, extraDefaultOption) {
+  util.each(axisCommonTypes.AXIS_TYPES, function(v, axisType) {
+    var defaultOption = util.merge(util.merge({}, axisDefault.default[axisType], true), extraDefaultOption, true);
+    var AxisModel = (
+      /** @class */
+      function(_super) {
+        tslib_es6.__extends(AxisModel2, _super);
+        function AxisModel2() {
+          var _this = _super !== null && _super.apply(this, arguments) || this;
+          _this.type = axisName + "Axis." + axisType;
+          return _this;
+        }
+        AxisModel2.prototype.mergeDefaultAndTheme = function(option, ecModel) {
+          var layoutMode = layout.fetchLayoutMode(this);
+          var inputPositionParams = layoutMode ? layout.getLayoutParams(option) : {};
+          var themeModel = ecModel.getTheme();
+          util.merge(option, themeModel.get(axisType + "Axis"));
+          util.merge(option, this.getDefaultOption());
+          option.type = getAxisType(option);
+          if (layoutMode) {
+            layout.mergeLayoutParam(option, inputPositionParams, layoutMode);
+          }
+        };
+        AxisModel2.prototype.optionUpdated = function() {
+          var thisOption = this.option;
+          if (thisOption.type === "category") {
+            this.__ordinalMeta = OrdinalMeta.default.createByAxisModel(this);
+          }
+        };
+        AxisModel2.prototype.getCategories = function(rawData) {
+          var option = this.option;
+          if (option.type === "category") {
+            if (rawData) {
+              return option.data;
+            }
+            return this.__ordinalMeta.categories;
+          }
+        };
+        AxisModel2.prototype.getOrdinalMeta = function() {
+          return this.__ordinalMeta;
+        };
+        AxisModel2.type = axisName + "Axis." + axisType;
+        AxisModel2.defaultOption = defaultOption;
+        return AxisModel2;
+      }(BaseAxisModelClass)
+    );
+    registers.registerComponentModel(AxisModel);
+  });
+  registers.registerSubTypeDefaulter(axisName + "Axis", getAxisType);
+}
+function getAxisType(option) {
+  return option.type || (option.data ? "category" : "value");
+}
+exports.default = axisModelCreator;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisTickLabelBuilder.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/text.js");
+const model = require("../util/model.js");
+const axisHelper = require("./axisHelper.js");
+var inner = model.makeInner();
+function tickValuesToNumbers(axis, values) {
+  var nums = util.map(values, function(val) {
+    return axis.scale.parse(val);
+  });
+  if (axis.type === "time" && nums.length > 0) {
+    nums.sort();
+    nums.unshift(nums[0]);
+    nums.push(nums[nums.length - 1]);
+  }
+  return nums;
+}
+function createAxisLabels(axis) {
+  var custom = axis.getLabelModel().get("customValues");
+  if (custom) {
+    var labelFormatter_1 = axisHelper.makeLabelFormatter(axis);
+    var extent_1 = axis.scale.getExtent();
+    var tickNumbers = tickValuesToNumbers(axis, custom);
+    var ticks = util.filter(tickNumbers, function(val) {
+      return val >= extent_1[0] && val <= extent_1[1];
+    });
+    return {
+      labels: util.map(ticks, function(numval) {
+        var tick = {
+          value: numval
+        };
+        return {
+          formattedLabel: labelFormatter_1(tick),
+          rawLabel: axis.scale.getLabel(tick),
+          tickValue: numval
+        };
+      })
+    };
+  }
+  return axis.type === "category" ? makeCategoryLabels(axis) : makeRealNumberLabels(axis);
+}
+function createAxisTicks(axis, tickModel) {
+  var custom = axis.getTickModel().get("customValues");
+  if (custom) {
+    var extent_2 = axis.scale.getExtent();
+    var tickNumbers = tickValuesToNumbers(axis, custom);
+    return {
+      ticks: util.filter(tickNumbers, function(val) {
+        return val >= extent_2[0] && val <= extent_2[1];
+      })
+    };
+  }
+  return axis.type === "category" ? makeCategoryTicks(axis, tickModel) : {
+    ticks: util.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 = axisHelper.getOptionCategoryInterval(labelModel);
+  var result = listCacheGet(labelsCache, optionLabelInterval);
+  if (result) {
+    return result;
+  }
+  var labels;
+  var numericLabelInterval;
+  if (util.isFunction(optionLabelInterval)) {
+    labels = makeLabelsByCustomizedCategoryInterval(axis, optionLabelInterval);
+  } else {
+    numericLabelInterval = optionLabelInterval === "auto" ? makeAutoCategoryInterval(axis) : optionLabelInterval;
+    labels = makeLabelsByNumericCategoryInterval(axis, numericLabelInterval);
+  }
+  return listCacheSet(labelsCache, optionLabelInterval, {
+    labels,
+    labelCategoryInterval: numericLabelInterval
+  });
+}
+function makeCategoryTicks(axis, tickModel) {
+  var ticksCache = getListCache(axis, "ticks");
+  var optionTickInterval = axisHelper.getOptionCategoryInterval(tickModel);
+  var result = listCacheGet(ticksCache, optionTickInterval);
+  if (result) {
+    return result;
+  }
+  var ticks;
+  var tickCategoryInterval;
+  if (!tickModel.get("show") || axis.scale.isBlank()) {
+    ticks = [];
+  }
+  if (util.isFunction(optionTickInterval)) {
+    ticks = makeLabelsByCustomizedCategoryInterval(axis, optionTickInterval, true);
+  } else if (optionTickInterval === "auto") {
+    var labelsResult = makeCategoryLabelsActually(axis, axis.getLabelModel());
+    tickCategoryInterval = labelsResult.labelCategoryInterval;
+    ticks = util.map(labelsResult.labels, function(labelItem) {
+      return labelItem.tickValue;
+    });
+  } else {
+    tickCategoryInterval = optionTickInterval;
+    ticks = makeLabelsByNumericCategoryInterval(axis, tickCategoryInterval, true);
+  }
+  return listCacheSet(ticksCache, optionTickInterval, {
+    ticks,
+    tickCategoryInterval
+  });
+}
+function makeRealNumberLabels(axis) {
+  var ticks = axis.scale.getTicks();
+  var labelFormatter = axisHelper.makeLabelFormatter(axis);
+  return {
+    labels: util.map(ticks, function(tick, idx) {
+      return {
+        level: tick.level,
+        formattedLabel: labelFormatter(tick, idx),
+        rawLabel: axis.scale.getLabel(tick),
+        tickValue: tick.value
+      };
+    })
+  };
+}
+function getListCache(axis, prop) {
+  return inner(axis)[prop] || (inner(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,
+    value
+  });
+  return value;
+}
+function makeAutoCategoryInterval(axis) {
+  var result = inner(axis).autoInterval;
+  return result != null ? result : inner(axis).autoInterval = axis.calculateCategoryInterval();
+}
+function calculateCategoryInterval(axis) {
+  var params = fetchAutoCategoryIntervalCalculationParams(axis);
+  var labelFormatter = axisHelper.makeLabelFormatter(axis);
+  var rotation = (params.axisRotate - params.labelRotate) / 180 * Math.PI;
+  var ordinalScale = axis.scale;
+  var ordinalExtent = ordinalScale.getExtent();
+  var tickCount = ordinalScale.count();
+  if (ordinalExtent[1] - ordinalExtent[0] < 1) {
+    return 0;
+  }
+  var step = 1;
+  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;
+  for (; tickValue <= ordinalExtent[1]; tickValue += step) {
+    var width = 0;
+    var height = 0;
+    var rect = text.getBoundingRect(labelFormatter({
+      value: tickValue
+    }), params.font, "center", "top");
+    width = rect.width * 1.3;
+    height = rect.height * 1.3;
+    maxW = Math.max(maxW, width, 7);
+    maxH = Math.max(maxH, height, 7);
+  }
+  var dw = maxW / unitW;
+  var dh = maxH / unitH;
+  isNaN(dw) && (dw = Infinity);
+  isNaN(dh) && (dh = Infinity);
+  var interval = Math.max(0, Math.floor(Math.min(dw, dh)));
+  var cache = inner(axis.model);
+  var axisExtent = axis.getExtent();
+  var lastAutoInterval = cache.lastAutoInterval;
+  var lastTickCount = cache.lastTickCount;
+  if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 && lastAutoInterval > interval && cache.axisExtent0 === axisExtent[0] && cache.axisExtent1 === axisExtent[1]) {
+    interval = lastAutoInterval;
+  } 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 = axisHelper.makeLabelFormatter(axis);
+  var ordinalScale = axis.scale;
+  var ordinalExtent = ordinalScale.getExtent();
+  var labelModel = axis.getLabelModel();
+  var result = [];
+  var step = Math.max((categoryInterval || 0) + 1, 1);
+  var startTick = ordinalExtent[0];
+  var tickCount = ordinalScale.count();
+  if (startTick !== 0 && step > 1 && tickCount / step > 2) {
+    startTick = Math.round(Math.ceil(startTick / step) * step);
+  }
+  var showAllLabel = axisHelper.shouldShowAllLabels(axis);
+  var includeMinLabel = labelModel.get("showMinLabel") || showAllLabel;
+  var includeMaxLabel = labelModel.get("showMaxLabel") || showAllLabel;
+  if (includeMinLabel && startTick !== ordinalExtent[0]) {
+    addItem(ordinalExtent[0]);
+  }
+  var tickValue = startTick;
+  for (; tickValue <= ordinalExtent[1]; tickValue += step) {
+    addItem(tickValue);
+  }
+  if (includeMaxLabel && tickValue - step !== ordinalExtent[1]) {
+    addItem(ordinalExtent[1]);
+  }
+  function addItem(tickValue2) {
+    var tickObj = {
+      value: tickValue2
+    };
+    result.push(onlyTick ? tickValue2 : {
+      formattedLabel: labelFormatter(tickObj),
+      rawLabel: ordinalScale.getLabel(tickObj),
+      tickValue: tickValue2
+    });
+  }
+  return result;
+}
+function makeLabelsByCustomizedCategoryInterval(axis, categoryInterval, onlyTick) {
+  var ordinalScale = axis.scale;
+  var labelFormatter = axisHelper.makeLabelFormatter(axis);
+  var result = [];
+  util.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,
+        tickValue
+      });
+    }
+  });
+  return result;
+}
+exports.calculateCategoryInterval = calculateCategoryInterval;
+exports.createAxisLabels = createAxisLabels;
+exports.createAxisTicks = createAxisTicks;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/Axis2D.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Axis = require("../Axis.js");
+var Axis2D = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(Axis2D2, _super);
+    function Axis2D2(dim, scale, coordExtent, axisType, position) {
+      var _this = _super.call(this, dim, scale, coordExtent) || this;
+      _this.index = 0;
+      _this.type = axisType || "value";
+      _this.position = position || "bottom";
+      return _this;
+    }
+    Axis2D2.prototype.isHorizontal = function() {
+      var position = this.position;
+      return position === "top" || position === "bottom";
+    };
+    Axis2D2.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;
+    };
+    Axis2D2.prototype.pointToData = function(point, clamp) {
+      return this.coordToData(this.toLocalCoord(point[this.dim === "x" ? 0 : 1]), clamp);
+    };
+    Axis2D2.prototype.setCategorySortInfo = function(info) {
+      if (this.type !== "category") {
+        return false;
+      }
+      this.model.option.categorySortInfo = info;
+      this.scale.setSortInfo(info);
+    };
+    return Axis2D2;
+  }(Axis.default)
+);
+exports.default = Axis2D;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/AxisModel.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Component = require("../../model/Component.js");
+const axisModelCommonMixin = require("../axisModelCommonMixin.js");
+const model = require("../../util/model.js");
+var CartesianAxisModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(CartesianAxisModel2, _super);
+    function CartesianAxisModel2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CartesianAxisModel2.prototype.getCoordSysModel = function() {
+      return this.getReferringComponents("grid", model.SINGLE_REFERRING).models[0];
+    };
+    CartesianAxisModel2.type = "cartesian2dAxis";
+    return CartesianAxisModel2;
+  }(Component.default)
+);
+util.mixin(CartesianAxisModel, axisModelCommonMixin.AxisModelCommonMixin);
+exports.CartesianAxisModel = CartesianAxisModel;
+exports.default = CartesianAxisModel;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/Cartesian.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var Cartesian = (
+  /** @class */
+  function() {
+    function Cartesian2(name) {
+      this.type = "cartesian";
+      this._dimList = [];
+      this._axes = {};
+      this.name = name || "";
+    }
+    Cartesian2.prototype.getAxis = function(dim) {
+      return this._axes[dim];
+    };
+    Cartesian2.prototype.getAxes = function() {
+      return util.map(this._dimList, function(dim) {
+        return this._axes[dim];
+      }, this);
+    };
+    Cartesian2.prototype.getAxesByScale = function(scaleType) {
+      scaleType = scaleType.toLowerCase();
+      return util.filter(this.getAxes(), function(axis) {
+        return axis.scale.type === scaleType;
+      });
+    };
+    Cartesian2.prototype.addAxis = function(axis) {
+      var dim = axis.dim;
+      this._axes[dim] = axis;
+      this._dimList.push(dim);
+    };
+    return Cartesian2;
+  }()
+);
+exports.default = Cartesian;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/Cartesian2D.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const BoundingRect = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.js");
+const Cartesian = require("./Cartesian.js");
+const matrix = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.js");
+const vector = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/vector.js");
+var cartesian2DDimensions = ["x", "y"];
+function canCalculateAffineTransform(scale) {
+  return scale.type === "interval" || scale.type === "time";
+}
+var Cartesian2D = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(Cartesian2D2, _super);
+    function Cartesian2D2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "cartesian2d";
+      _this.dimensions = cartesian2DDimensions;
+      return _this;
+    }
+    Cartesian2D2.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;
+      }
+      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 = matrix.invert([], m);
+    };
+    Cartesian2D2.prototype.getBaseAxis = function() {
+      return this.getAxesByScale("ordinal")[0] || this.getAxesByScale("time")[0] || this.getAxis("x");
+    };
+    Cartesian2D2.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]));
+    };
+    Cartesian2D2.prototype.containData = function(data) {
+      return this.getAxis("x").containData(data[0]) && this.getAxis("y").containData(data[1]);
+    };
+    Cartesian2D2.prototype.containZone = function(data1, data2) {
+      var zoneDiag1 = this.dataToPoint(data1);
+      var zoneDiag2 = this.dataToPoint(data2);
+      var area = this.getArea();
+      var zone = new BoundingRect.default(zoneDiag1[0], zoneDiag1[1], zoneDiag2[0] - zoneDiag1[0], zoneDiag2[1] - zoneDiag1[1]);
+      return area.intersect(zone);
+    };
+    Cartesian2D2.prototype.dataToPoint = function(data, clamp, out) {
+      out = out || [];
+      var xVal = data[0];
+      var yVal = data[1];
+      if (this._transform && xVal != null && isFinite(xVal) && yVal != null && isFinite(yVal)) {
+        return vector.applyTransform(out, data, this._transform);
+      }
+      var xAxis = this.getAxis("x");
+      var yAxis = this.getAxis("y");
+      out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal, clamp));
+      out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal, clamp));
+      return out;
+    };
+    Cartesian2D2.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;
+    };
+    Cartesian2D2.prototype.pointToData = function(point, clamp) {
+      var out = [];
+      if (this._invTransform) {
+        return vector.applyTransform(out, point, this._invTransform);
+      }
+      var xAxis = this.getAxis("x");
+      var yAxis = this.getAxis("y");
+      out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]), clamp);
+      out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]), clamp);
+      return out;
+    };
+    Cartesian2D2.prototype.getOtherAxis = function(axis) {
+      return this.getAxis(axis.dim === "x" ? "y" : "x");
+    };
+    Cartesian2D2.prototype.getArea = function(tolerance) {
+      tolerance = tolerance || 0;
+      var xExtent = this.getAxis("x").getGlobalExtent();
+      var yExtent = this.getAxis("y").getGlobalExtent();
+      var x = Math.min(xExtent[0], xExtent[1]) - tolerance;
+      var y = Math.min(yExtent[0], yExtent[1]) - tolerance;
+      var width = Math.max(xExtent[0], xExtent[1]) - x + tolerance;
+      var height = Math.max(yExtent[0], yExtent[1]) - y + tolerance;
+      return new BoundingRect.default(x, y, width, height);
+    };
+    return Cartesian2D2;
+  }(Cartesian.default)
+);
+exports.cartesian2DDimensions = cartesian2DDimensions;
+exports.default = Cartesian2D;