office-viewer 0.3.12 → 0.3.14

package/lib/node_modules/echarts/lib/processor/dataStack.js

@@ -1,97 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var util = require('../../../zrender/lib/core/util.js');
-var number = require('../util/number.js');
-
-// (1) [Caution]: the logic is correct based on the premises:
-//     data processing stage is blocked in stream.
-//     See <module:echarts/stream/Scheduler#performDataProcessorTasks>
-// (2) Only register once when import repeatedly.
-//     Should be executed after series is filtered and before stack calculation.
-function dataStack(ecModel) {
-  var stackInfoMap = util.createHashMap();
-  ecModel.eachSeries(function (seriesModel) {
-    var stack = seriesModel.get('stack');
-    // Compatible: when `stack` is set as '', do not stack.
-    if (stack) {
-      var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []);
-      var data = seriesModel.getData();
-      var stackInfo = {
-        // Used for calculate axis extent automatically.
-        // TODO: Type getCalculationInfo return more specific type?
-        stackResultDimension: data.getCalculationInfo('stackResultDimension'),
-        stackedOverDimension: data.getCalculationInfo('stackedOverDimension'),
-        stackedDimension: data.getCalculationInfo('stackedDimension'),
-        stackedByDimension: data.getCalculationInfo('stackedByDimension'),
-        isStackedByIndex: data.getCalculationInfo('isStackedByIndex'),
-        data: data,
-        seriesModel: seriesModel
-      };
-      // If stacked on axis that do not support data stack.
-      if (!stackInfo.stackedDimension || !(stackInfo.isStackedByIndex || stackInfo.stackedByDimension)) {
-        return;
-      }
-      stackInfoList.length && data.setCalculationInfo('stackedOnSeries', stackInfoList[stackInfoList.length - 1].seriesModel);
-      stackInfoList.push(stackInfo);
-    }
-  });
-  stackInfoMap.each(calculateStack);
-}
-function calculateStack(stackInfoList) {
-  util.each(stackInfoList, function (targetStackInfo, idxInStack) {
-    var resultVal = [];
-    var resultNaN = [NaN, NaN];
-    var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension];
-    var targetData = targetStackInfo.data;
-    var isStackedByIndex = targetStackInfo.isStackedByIndex;
-    var stackStrategy = targetStackInfo.seriesModel.get('stackStrategy') || 'samesign';
-    // Should not write on raw data, because stack series model list changes
-    // depending on legend selection.
-    targetData.modify(dims, function (v0, v1, dataIndex) {
-      var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex);
-      // Consider `connectNulls` of line area, if value is NaN, stackedOver
-      // should also be NaN, to draw a appropriate belt area.
-      if (isNaN(sum)) {
-        return resultNaN;
-      }
-      var byValue;
-      var stackedDataRawIndex;
-      if (isStackedByIndex) {
-        stackedDataRawIndex = targetData.getRawIndex(dataIndex);
-      } else {
-        byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex);
-      }
-      // If stackOver is NaN, chart view will render point on value start.
-      var stackedOver = NaN;
-      for (var j = idxInStack - 1; j >= 0; j--) {
-        var stackInfo = stackInfoList[j];
-        // Has been optimized by inverted indices on `stackedByDimension`.
-        if (!isStackedByIndex) {
-          stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue);
-        }
-        if (stackedDataRawIndex >= 0) {
-          var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex);
-          // Considering positive stack, negative stack and empty data
-          if (stackStrategy === 'all' // single stack group
-          || stackStrategy === 'positive' && val > 0 || stackStrategy === 'negative' && val < 0 || stackStrategy === 'samesign' && sum >= 0 && val > 0 // All positive stack
-          || stackStrategy === 'samesign' && sum <= 0 && val < 0 // All negative stack
-          ) {
-            // The sum has to be very small to be affected by the
-            // floating arithmetic problem. An incorrect result will probably
-            // cause axis min/max to be filtered incorrectly.
-            sum = number.addSafe(sum, val);
-            stackedOver = val;
-            break;
-          }
-        }
-      }
-      resultVal[0] = sum;
-      resultVal[1] = stackedOver;
-      return resultVal;
-    });
-  });
-}
-
-exports["default"] = dataStack;

package/lib/node_modules/echarts/lib/processor/negativeDataFilter.js

@@ -1,25 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var util = require('../../../zrender/lib/core/util.js');
-
-function negativeDataFilter(seriesType) {
-  return {
-    seriesType: seriesType,
-    reset: function (seriesModel, ecModel) {
-      var data = seriesModel.getData();
-      data.filterSelf(function (idx) {
-        // handle negative value condition
-        var valueDim = data.mapDimension('value');
-        var curValue = data.get(valueDim, idx);
-        if (util.isNumber(curValue) && !isNaN(curValue) && curValue < 0) {
-          return false;
-        }
-        return true;
-      });
-    }
-  };
-}
-
-exports["default"] = negativeDataFilter;

package/lib/node_modules/echarts/lib/renderer/installCanvasRenderer.js

@@ -1,11 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var Painter = require('../../../zrender/lib/canvas/Painter.js');
-
-function install(registers) {
-  registers.registerPainter('canvas', Painter["default"]);
-}
-
-exports.install = install;

package/lib/node_modules/echarts/lib/renderer/installSVGRenderer.js

@@ -1,11 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var Painter = require('../../../zrender/lib/svg/Painter.js');
-
-function install(registers) {
-  registers.registerPainter('svg', Painter["default"]);
-}
-
-exports.install = install;

package/lib/node_modules/echarts/lib/scale/Interval.js

@@ -1,230 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var number = require('../util/number.js');
-var format = require('../util/format.js');
-var Scale = require('./Scale.js');
-var helper = require('./helper.js');
-
-var roundNumber = number.round;
-var IntervalScale = /** @class */function (_super) {
-  tslib.__extends(IntervalScale, _super);
-  function IntervalScale() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-    _this.type = 'interval';
-    // Step is calculated in adjustExtent.
-    _this._interval = 0;
-    _this._intervalPrecision = 2;
-    return _this;
-  }
-  IntervalScale.prototype.parse = function (val) {
-    return val;
-  };
-  IntervalScale.prototype.contain = function (val) {
-    return helper.contain(val, this._extent);
-  };
-  IntervalScale.prototype.normalize = function (val) {
-    return helper.normalize(val, this._extent);
-  };
-  IntervalScale.prototype.scale = function (val) {
-    return helper.scale(val, this._extent);
-  };
-  IntervalScale.prototype.setExtent = function (start, end) {
-    var thisExtent = this._extent;
-    // start,end may be a Number like '25',so...
-    if (!isNaN(start)) {
-      thisExtent[0] = parseFloat(start);
-    }
-    if (!isNaN(end)) {
-      thisExtent[1] = parseFloat(end);
-    }
-  };
-  IntervalScale.prototype.unionExtent = function (other) {
-    var extent = this._extent;
-    other[0] < extent[0] && (extent[0] = other[0]);
-    other[1] > extent[1] && (extent[1] = other[1]);
-    // unionExtent may called by it's sub classes
-    this.setExtent(extent[0], extent[1]);
-  };
-  IntervalScale.prototype.getInterval = function () {
-    return this._interval;
-  };
-  IntervalScale.prototype.setInterval = function (interval) {
-    this._interval = interval;
-    // Dropped auto calculated niceExtent and use user-set extent.
-    // We assume user wants to set both interval, min, max to get a better result.
-    this._niceExtent = this._extent.slice();
-    this._intervalPrecision = helper.getIntervalPrecision(interval);
-  };
-  /**
-   * @param expandToNicedExtent Whether expand the ticks to niced extent.
-   */
-  IntervalScale.prototype.getTicks = function (expandToNicedExtent) {
-    var interval = this._interval;
-    var extent = this._extent;
-    var niceTickExtent = this._niceExtent;
-    var intervalPrecision = this._intervalPrecision;
-    var ticks = [];
-    // If interval is 0, return [];
-    if (!interval) {
-      return ticks;
-    }
-    // Consider this case: using dataZoom toolbox, zoom and zoom.
-    var safeLimit = 10000;
-    if (extent[0] < niceTickExtent[0]) {
-      if (expandToNicedExtent) {
-        ticks.push({
-          value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
-        });
-      } else {
-        ticks.push({
-          value: extent[0]
-        });
-      }
-    }
-    var tick = niceTickExtent[0];
-    while (tick <= niceTickExtent[1]) {
-      ticks.push({
-        value: tick
-      });
-      // Avoid rounding error
-      tick = roundNumber(tick + interval, intervalPrecision);
-      if (tick === ticks[ticks.length - 1].value) {
-        // Consider out of safe float point, e.g.,
-        // -3711126.9907707 + 2e-10 === -3711126.9907707
-        break;
-      }
-      if (ticks.length > safeLimit) {
-        return [];
-      }
-    }
-    // Consider this case: the last item of ticks is smaller
-    // than niceTickExtent[1] and niceTickExtent[1] === extent[1].
-    var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
-    if (extent[1] > lastNiceTick) {
-      if (expandToNicedExtent) {
-        ticks.push({
-          value: roundNumber(lastNiceTick + interval, intervalPrecision)
-        });
-      } else {
-        ticks.push({
-          value: extent[1]
-        });
-      }
-    }
-    return ticks;
-  };
-  IntervalScale.prototype.getMinorTicks = function (splitNumber) {
-    var ticks = this.getTicks(true);
-    var minorTicks = [];
-    var extent = this.getExtent();
-    for (var i = 1; i < ticks.length; i++) {
-      var nextTick = ticks[i];
-      var prevTick = ticks[i - 1];
-      var count = 0;
-      var minorTicksGroup = [];
-      var interval = nextTick.value - prevTick.value;
-      var minorInterval = interval / splitNumber;
-      while (count < splitNumber - 1) {
-        var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
-        // For the first and last interval. The count may be less than splitNumber.
-        if (minorTick > extent[0] && minorTick < extent[1]) {
-          minorTicksGroup.push(minorTick);
-        }
-        count++;
-      }
-      minorTicks.push(minorTicksGroup);
-    }
-    return minorTicks;
-  };
-  /**
-   * @param opt.precision If 'auto', use nice presision.
-   * @param opt.pad returns 1.50 but not 1.5 if precision is 2.
-   */
-  IntervalScale.prototype.getLabel = function (data, opt) {
-    if (data == null) {
-      return '';
-    }
-    var precision = opt && opt.precision;
-    if (precision == null) {
-      precision = number.getPrecision(data.value) || 0;
-    } else if (precision === 'auto') {
-      // Should be more precise then tick.
-      precision = this._intervalPrecision;
-    }
-    // (1) If `precision` is set, 12.005 should be display as '12.00500'.
-    // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
-    var dataNum = roundNumber(data.value, precision, true);
-    return format.addCommas(dataNum);
-  };
-  /**
-   * @param splitNumber By default `5`.
-   */
-  IntervalScale.prototype.calcNiceTicks = function (splitNumber, minInterval, maxInterval) {
-    splitNumber = splitNumber || 5;
-    var extent = this._extent;
-    var span = extent[1] - extent[0];
-    if (!isFinite(span)) {
-      return;
-    }
-    // User may set axis min 0 and data are all negative
-    // FIXME If it needs to reverse ?
-    if (span < 0) {
-      span = -span;
-      extent.reverse();
-    }
-    var result = helper.intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
-    this._intervalPrecision = result.intervalPrecision;
-    this._interval = result.interval;
-    this._niceExtent = result.niceTickExtent;
-  };
-  IntervalScale.prototype.calcNiceExtent = function (opt) {
-    var extent = this._extent;
-    // If extent start and end are same, expand them
-    if (extent[0] === extent[1]) {
-      if (extent[0] !== 0) {
-        // Expand extent
-        // Note that extents can be both negative. See #13154
-        var expandSize = Math.abs(extent[0]);
-        // In the fowllowing case
-        //      Axis has been fixed max 100
-        //      Plus data are all 100 and axis extent are [100, 100].
-        // Extend to the both side will cause expanded max is larger than fixed max.
-        // So only expand to the smaller side.
-        if (!opt.fixMax) {
-          extent[1] += expandSize / 2;
-          extent[0] -= expandSize / 2;
-        } else {
-          extent[0] -= expandSize / 2;
-        }
-      } else {
-        extent[1] = 1;
-      }
-    }
-    var span = extent[1] - extent[0];
-    // If there are no data and extent are [Infinity, -Infinity]
-    if (!isFinite(span)) {
-      extent[0] = 0;
-      extent[1] = 1;
-    }
-    this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
-    // let extent = this._extent;
-    var interval = this._interval;
-    if (!opt.fixMin) {
-      extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
-    }
-    if (!opt.fixMax) {
-      extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
-    }
-  };
-  IntervalScale.prototype.setNiceExtent = function (min, max) {
-    this._niceExtent = [min, max];
-  };
-  IntervalScale.type = 'interval';
-  return IntervalScale;
-}(Scale["default"]);
-Scale["default"].registerClass(IntervalScale);
-
-exports["default"] = IntervalScale;

package/lib/node_modules/echarts/lib/scale/Log.js

@@ -1,140 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var util = require('../../../zrender/lib/core/util.js');
-var Scale = require('./Scale.js');
-var number = require('../util/number.js');
-var helper = require('./helper.js');
-var Interval = require('./Interval.js');
-
-var scaleProto = Scale["default"].prototype;
-// FIXME:TS refactor: not good to call it directly with `this`?
-var intervalScaleProto = Interval["default"].prototype;
-var roundingErrorFix = number.round;
-var mathFloor = Math.floor;
-var mathCeil = Math.ceil;
-var mathPow = Math.pow;
-var mathLog = Math.log;
-var LogScale = /** @class */function (_super) {
-  tslib.__extends(LogScale, _super);
-  function LogScale() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-    _this.type = 'log';
-    _this.base = 10;
-    _this._originalScale = new Interval["default"]();
-    // FIXME:TS actually used by `IntervalScale`
-    _this._interval = 0;
-    return _this;
-  }
-  /**
-   * @param Whether expand the ticks to niced extent.
-   */
-  LogScale.prototype.getTicks = function (expandToNicedExtent) {
-    var originalScale = this._originalScale;
-    var extent = this._extent;
-    var originalExtent = originalScale.getExtent();
-    var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
-    return util.map(ticks, function (tick) {
-      var val = tick.value;
-      var powVal = number.round(mathPow(this.base, val));
-      // Fix #4158
-      powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
-      powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
-      return {
-        value: powVal
-      };
-    }, this);
-  };
-  LogScale.prototype.setExtent = function (start, end) {
-    var base = mathLog(this.base);
-    // log(-Infinity) is NaN, so safe guard here
-    start = mathLog(Math.max(0, start)) / base;
-    end = mathLog(Math.max(0, end)) / base;
-    intervalScaleProto.setExtent.call(this, start, end);
-  };
-  /**
-   * @return {number} end
-   */
-  LogScale.prototype.getExtent = function () {
-    var base = this.base;
-    var extent = scaleProto.getExtent.call(this);
-    extent[0] = mathPow(base, extent[0]);
-    extent[1] = mathPow(base, extent[1]);
-    // Fix #4158
-    var originalScale = this._originalScale;
-    var originalExtent = originalScale.getExtent();
-    this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
-    this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
-    return extent;
-  };
-  LogScale.prototype.unionExtent = function (extent) {
-    this._originalScale.unionExtent(extent);
-    var base = this.base;
-    extent[0] = mathLog(extent[0]) / mathLog(base);
-    extent[1] = mathLog(extent[1]) / mathLog(base);
-    scaleProto.unionExtent.call(this, extent);
-  };
-  LogScale.prototype.unionExtentFromData = function (data, dim) {
-    // TODO
-    // filter value that <= 0
-    this.unionExtent(data.getApproximateExtent(dim));
-  };
-  /**
-   * Update interval and extent of intervals for nice ticks
-   * @param approxTickNum default 10 Given approx tick number
-   */
-  LogScale.prototype.calcNiceTicks = function (approxTickNum) {
-    approxTickNum = approxTickNum || 10;
-    var extent = this._extent;
-    var span = extent[1] - extent[0];
-    if (span === Infinity || span <= 0) {
-      return;
-    }
-    var interval = number.quantity(span);
-    var err = approxTickNum / span * interval;
-    // Filter ticks to get closer to the desired count.
-    if (err <= 0.5) {
-      interval *= 10;
-    }
-    // Interval should be integer
-    while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
-      interval *= 10;
-    }
-    var niceExtent = [number.round(mathCeil(extent[0] / interval) * interval), number.round(mathFloor(extent[1] / interval) * interval)];
-    this._interval = interval;
-    this._niceExtent = niceExtent;
-  };
-  LogScale.prototype.calcNiceExtent = function (opt) {
-    intervalScaleProto.calcNiceExtent.call(this, opt);
-    this._fixMin = opt.fixMin;
-    this._fixMax = opt.fixMax;
-  };
-  LogScale.prototype.parse = function (val) {
-    return val;
-  };
-  LogScale.prototype.contain = function (val) {
-    val = mathLog(val) / mathLog(this.base);
-    return helper.contain(val, this._extent);
-  };
-  LogScale.prototype.normalize = function (val) {
-    val = mathLog(val) / mathLog(this.base);
-    return helper.normalize(val, this._extent);
-  };
-  LogScale.prototype.scale = function (val) {
-    val = helper.scale(val, this._extent);
-    return mathPow(this.base, val);
-  };
-  LogScale.type = 'log';
-  return LogScale;
-}(Scale["default"]);
-var proto = LogScale.prototype;
-proto.getMinorTicks = intervalScaleProto.getMinorTicks;
-proto.getLabel = intervalScaleProto.getLabel;
-function fixRoundingError(val, originalVal) {
-  return roundingErrorFix(val, number.getPrecision(originalVal));
-}
-Scale["default"].registerClass(LogScale);
-
-exports["default"] = LogScale;

package/lib/node_modules/echarts/lib/scale/Ordinal.js

@@ -1,171 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var Scale = require('./Scale.js');
-var OrdinalMeta = require('../data/OrdinalMeta.js');
-var helper = require('./helper.js');
-var util = require('../../../zrender/lib/core/util.js');
-
-var OrdinalScale = /** @class */function (_super) {
-  tslib.__extends(OrdinalScale, _super);
-  function OrdinalScale(setting) {
-    var _this = _super.call(this, setting) || this;
-    _this.type = 'ordinal';
-    var ordinalMeta = _this.getSetting('ordinalMeta');
-    // Caution: Should not use instanceof, consider ec-extensions using
-    // import approach to get OrdinalMeta class.
-    if (!ordinalMeta) {
-      ordinalMeta = new OrdinalMeta["default"]({});
-    }
-    if (util.isArray(ordinalMeta)) {
-      ordinalMeta = new OrdinalMeta["default"]({
-        categories: util.map(ordinalMeta, function (item) {
-          return util.isObject(item) ? item.value : item;
-        })
-      });
-    }
-    _this._ordinalMeta = ordinalMeta;
-    _this._extent = _this.getSetting('extent') || [0, ordinalMeta.categories.length - 1];
-    return _this;
-  }
-  OrdinalScale.prototype.parse = function (val) {
-    // Caution: Math.round(null) will return `0` rather than `NaN`
-    if (val == null) {
-      return NaN;
-    }
-    return util.isString(val) ? this._ordinalMeta.getOrdinal(val)
-    // val might be float.
-    : Math.round(val);
-  };
-  OrdinalScale.prototype.contain = function (rank) {
-    rank = this.parse(rank);
-    return helper.contain(rank, this._extent) && this._ordinalMeta.categories[rank] != null;
-  };
-  /**
-   * Normalize given rank or name to linear [0, 1]
-   * @param val raw ordinal number.
-   * @return normalized value in [0, 1].
-   */
-  OrdinalScale.prototype.normalize = function (val) {
-    val = this._getTickNumber(this.parse(val));
-    return helper.normalize(val, this._extent);
-  };
-  /**
-   * @param val normalized value in [0, 1].
-   * @return raw ordinal number.
-   */
-  OrdinalScale.prototype.scale = function (val) {
-    val = Math.round(helper.scale(val, this._extent));
-    return this.getRawOrdinalNumber(val);
-  };
-  OrdinalScale.prototype.getTicks = function () {
-    var ticks = [];
-    var extent = this._extent;
-    var rank = extent[0];
-    while (rank <= extent[1]) {
-      ticks.push({
-        value: rank
-      });
-      rank++;
-    }
-    return ticks;
-  };
-  OrdinalScale.prototype.getMinorTicks = function (splitNumber) {
-    // Not support.
-    return;
-  };
-  /**
-   * @see `Ordinal['_ordinalNumbersByTick']`
-   */
-  OrdinalScale.prototype.setSortInfo = function (info) {
-    if (info == null) {
-      this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
-      return;
-    }
-    var infoOrdinalNumbers = info.ordinalNumbers;
-    var ordinalsByTick = this._ordinalNumbersByTick = [];
-    var ticksByOrdinal = this._ticksByOrdinalNumber = [];
-    // Unnecessary support negative tick in `realtimeSort`.
-    var tickNum = 0;
-    var allCategoryLen = this._ordinalMeta.categories.length;
-    for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) {
-      var ordinalNumber = infoOrdinalNumbers[tickNum];
-      ordinalsByTick[tickNum] = ordinalNumber;
-      ticksByOrdinal[ordinalNumber] = tickNum;
-    }
-    // Handle that `series.data` only covers part of the `axis.category.data`.
-    var unusedOrdinal = 0;
-    for (; tickNum < allCategoryLen; ++tickNum) {
-      while (ticksByOrdinal[unusedOrdinal] != null) {
-        unusedOrdinal++;
-      }
-      ordinalsByTick.push(unusedOrdinal);
-      ticksByOrdinal[unusedOrdinal] = tickNum;
-    }
-  };
-  OrdinalScale.prototype._getTickNumber = function (ordinal) {
-    var ticksByOrdinalNumber = this._ticksByOrdinalNumber;
-    // also support ordinal out of range of `ordinalMeta.categories.length`,
-    // where ordinal numbers are used as tick value directly.
-    return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal;
-  };
-  /**
-   * @usage
-   * ```js
-   * const ordinalNumber = ordinalScale.getRawOrdinalNumber(tickVal);
-   *
-   * // case0
-   * const rawOrdinalValue = axisModel.getCategories()[ordinalNumber];
-   * // case1
-   * const rawOrdinalValue = this._ordinalMeta.categories[ordinalNumber];
-   * // case2
-   * const coord = axis.dataToCoord(ordinalNumber);
-   * ```
-   *
-   * @param {OrdinalNumber} tickNumber index of display
-   */
-  OrdinalScale.prototype.getRawOrdinalNumber = function (tickNumber) {
-    var ordinalNumbersByTick = this._ordinalNumbersByTick;
-    // tickNumber may be out of range, e.g., when axis max is larger than `ordinalMeta.categories.length`.,
-    // where ordinal numbers are used as tick value directly.
-    return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber;
-  };
-  /**
-   * Get item on tick
-   */
-  OrdinalScale.prototype.getLabel = function (tick) {
-    if (!this.isBlank()) {
-      var ordinalNumber = this.getRawOrdinalNumber(tick.value);
-      var cateogry = this._ordinalMeta.categories[ordinalNumber];
-      // Note that if no data, ordinalMeta.categories is an empty array.
-      // Return empty if it's not exist.
-      return cateogry == null ? '' : cateogry + '';
-    }
-  };
-  OrdinalScale.prototype.count = function () {
-    return this._extent[1] - this._extent[0] + 1;
-  };
-  OrdinalScale.prototype.unionExtentFromData = function (data, dim) {
-    this.unionExtent(data.getApproximateExtent(dim));
-  };
-  /**
-   * @override
-   * If value is in extent range
-   */
-  OrdinalScale.prototype.isInExtentRange = function (value) {
-    value = this._getTickNumber(value);
-    return this._extent[0] <= value && this._extent[1] >= value;
-  };
-  OrdinalScale.prototype.getOrdinalMeta = function () {
-    return this._ordinalMeta;
-  };
-  OrdinalScale.prototype.calcNiceTicks = function () {};
-  OrdinalScale.prototype.calcNiceExtent = function () {};
-  OrdinalScale.type = 'ordinal';
-  return OrdinalScale;
-}(Scale["default"]);
-Scale["default"].registerClass(OrdinalScale);
-
-exports["default"] = OrdinalScale;