@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/processor/dataStack.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/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.push(stackInfo);
+    }
+  });
+  // Process each stack group
+  stackInfoMap.each(function (stackInfoList) {
+    if (stackInfoList.length === 0) {
+      return;
+    }
+    // Check if stack order needs to be reversed
+    var firstSeries = stackInfoList[0].seriesModel;
+    var stackOrder = firstSeries.get('stackOrder') || 'seriesAsc';
+    if (stackOrder === 'seriesDesc') {
+      stackInfoList.reverse();
+    }
+    // Set stackedOnSeries for each series in the final order
+    util.each(stackInfoList, function (stackInfo, index) {
+      stackInfo.data.setCalculationInfo('stackedOnSeries', index > 0 ? stackInfoList[index - 1].seriesModel : null);
+    });
+    // Calculate stack values
+    calculateStack(stackInfoList);
+  });
+}
+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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/processor/negativeDataFilter.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/renderer/installCanvasRenderer.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var Painter = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/canvas/Painter.js');
+
+function install(registers) {
+  registers.registerPainter('canvas', Painter.default);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/renderer/installSVGRenderer.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var Painter = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/svg/Painter.js');
+
+function install(registers) {
+  registers.registerPainter('svg', Painter.default);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/scale/Interval.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var number = require('../util/number.js');
+var format = require('../util/format.js');
+var Scale = require('./Scale.js');
+var helper = require('./helper.js');
+var _break = require('./break.js');
+
+var roundNumber = number.round;
+var IntervalScale = /** @class */function (_super) {
+  tslib_es6.__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) {
+    // `Scale#parse` (and its overrids) are typically applied at the axis values input
+    // in echarts option. e.g., `axis.min/max`, `dataZoom.min/max`, etc.
+    // but `series.data` is not included, which uses `dataValueHelper.ts`#`parseDataValue`.
+    // `Scale#parse` originally introduced in fb8c813215098b9d2458966229bb95c510883d5e
+    // at 2016 for dataZoom start/end settings (See `parseAxisModelMinMax`).
+    //
+    // Historically `scale/Interval.ts` returns the input value directly. But numeric
+    // values (such as a number-like string '123') effectively passed through here and
+    // were involved in calculations, which was error-prone and inconsistent with the
+    // declared TS return type. Previously such issues are fixed separately in different
+    // places case by case (such as #2475).
+    //
+    // Now, we perform actual parse to ensure its `number` type here. The parsing rule
+    // follows the series data parsing rule (`dataValueHelper.ts`#`parseDataValue`)
+    // and maintains compatibility as much as possible (thus a more strict parsing
+    // `number.ts`#`numericToNumber` is not used here.)
+    //
+    // FIXME: `ScaleDataValue` also need to be modified to include numeric string type,
+    //  since it effectively does.
+    return val == null || val === '' ? NaN
+    // If string (like '-'), using '+' parse to NaN
+    // If object, also parse to NaN
+    : Number(val);
+  };
+  IntervalScale.prototype.contain = function (val) {
+    return helper.contain(val, this._extent);
+  };
+  IntervalScale.prototype.normalize = function (val) {
+    return this._calculator.normalize(val, this._extent);
+  };
+  IntervalScale.prototype.scale = function (val) {
+    return this._calculator.scale(val, this._extent);
+  };
+  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);
+  };
+  /**
+   * @override
+   */
+  IntervalScale.prototype.getTicks = function (opt) {
+    opt = opt || {};
+    var interval = this._interval;
+    var extent = this._extent;
+    var niceTickExtent = this._niceExtent;
+    var intervalPrecision = this._intervalPrecision;
+    var scaleBreakHelper = _break.getScaleBreakHelper();
+    var ticks = [];
+    // If interval is 0, return [];
+    if (!interval) {
+      return ticks;
+    }
+    if (opt.breakTicks === 'only_break' && scaleBreakHelper) {
+      scaleBreakHelper.addBreaksToTicks(ticks, this._brkCtx.breaks, this._extent);
+      return ticks;
+    }
+    // Consider this case: using dataZoom toolbox, zoom and zoom.
+    var safeLimit = 10000;
+    if (extent[0] < niceTickExtent[0]) {
+      if (opt.expandToNicedExtent) {
+        ticks.push({
+          value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
+        });
+      } else {
+        ticks.push({
+          value: extent[0]
+        });
+      }
+    }
+    var estimateNiceMultiple = function (tickVal, targetTick) {
+      return Math.round((targetTick - tickVal) / interval);
+    };
+    var tick = niceTickExtent[0];
+    while (tick <= niceTickExtent[1]) {
+      ticks.push({
+        value: tick
+      });
+      // Avoid rounding error
+      tick = roundNumber(tick + interval, intervalPrecision);
+      if (this._brkCtx) {
+        var moreMultiple = this._brkCtx.calcNiceTickMultiple(tick, estimateNiceMultiple);
+        if (moreMultiple >= 0) {
+          tick = roundNumber(tick + moreMultiple * interval, intervalPrecision);
+        }
+      }
+      if (ticks.length > 0 && 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 (opt.expandToNicedExtent) {
+        ticks.push({
+          value: roundNumber(lastNiceTick + interval, intervalPrecision)
+        });
+      } else {
+        ticks.push({
+          value: extent[1]
+        });
+      }
+    }
+    if (scaleBreakHelper) {
+      scaleBreakHelper.pruneTicksByBreak(opt.pruneByBreak, ticks, this._brkCtx.breaks, function (item) {
+        return item.value;
+      }, this._interval, this._extent);
+    }
+    if (opt.breakTicks !== 'none' && scaleBreakHelper) {
+      scaleBreakHelper.addBreaksToTicks(ticks, this._brkCtx.breaks, this._extent);
+    }
+    return ticks;
+  };
+  IntervalScale.prototype.getMinorTicks = function (splitNumber) {
+    var ticks = this.getTicks({
+      expandToNicedExtent: true
+    });
+    // NOTE: In log-scale, do not support minor ticks when breaks exist.
+    //  because currently log-scale minor ticks is calculated based on raw values
+    //  rather than log-transformed value, due to an odd effect when breaks exist.
+    var minorTicks = [];
+    var extent = this.getExtent();
+    for (var i = 1; i < ticks.length; i++) {
+      var nextTick = ticks[i];
+      var prevTick = ticks[i - 1];
+      if (prevTick["break"] || nextTick["break"]) {
+        // Do not build minor ticks to the adjacent ticks to breaks ticks,
+        // since the interval might be irregular.
+        continue;
+      }
+      var count = 0;
+      var minorTicksGroup = [];
+      var interval = nextTick.value - prevTick.value;
+      var minorInterval = interval / splitNumber;
+      var minorIntervalPrecision = helper.getIntervalPrecision(minorInterval);
+      while (count < splitNumber - 1) {
+        var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval, minorIntervalPrecision);
+        // For the first and last interval. The count may be less than splitNumber.
+        if (minorTick > extent[0] && minorTick < extent[1]) {
+          minorTicksGroup.push(minorTick);
+        }
+        count++;
+      }
+      var scaleBreakHelper = _break.getScaleBreakHelper();
+      scaleBreakHelper && scaleBreakHelper.pruneTicksByBreak('auto', minorTicksGroup, this._getNonTransBreaks(), function (value) {
+        return value;
+      }, this._interval, extent);
+      minorTicks.push(minorTicksGroup);
+    }
+    return minorTicks;
+  };
+  IntervalScale.prototype._getNonTransBreaks = function () {
+    return this._brkCtx ? this._brkCtx.breaks : [];
+  };
+  /**
+   * @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);
+  };
+  /**
+   * FIXME: refactor - disallow override, use composition instead.
+   *
+   * The override of `calcNiceTicks` should ensure these members are provided:
+   *  this._intervalPrecision
+   *  this._interval
+   *
+   * @param splitNumber By default `5`.
+   */
+  IntervalScale.prototype.calcNiceTicks = function (splitNumber, minInterval, maxInterval) {
+    splitNumber = splitNumber || 5;
+    var extent = this._extent.slice();
+    var span = this._getExtentSpanWithBreaks();
+    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();
+      this._innerSetExtent(extent[0], extent[1]);
+      extent = this._extent.slice();
+    }
+    var result = helper.intervalScaleNiceTicks(extent, span, splitNumber, minInterval, maxInterval);
+    this._intervalPrecision = result.intervalPrecision;
+    this._interval = result.interval;
+    this._niceExtent = result.niceTickExtent;
+  };
+  IntervalScale.prototype.calcNiceExtent = function (opt) {
+    var extent = this._extent.slice();
+    // 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._innerSetExtent(extent[0], extent[1]);
+    extent = this._extent.slice();
+    this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+    var interval = this._interval;
+    var intervalPrecition = this._intervalPrecision;
+    if (!opt.fixMin) {
+      extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval, intervalPrecition);
+    }
+    if (!opt.fixMax) {
+      extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval, intervalPrecition);
+    }
+    this._innerSetExtent(extent[0], extent[1]);
+  };
+  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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/scale/Log.js

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Scale = require('./Scale.js');
+var number = require('../util/number.js');
+var Interval = require('./Interval.js');
+var helper = require('./helper.js');
+var _break = require('./break.js');
+
+var fixRound = number.round;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var mathPow = Math.pow;
+var mathLog = Math.log;
+var LogScale = /** @class */function (_super) {
+  tslib_es6.__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();
+    return _this;
+  }
+  /**
+   * @param Whether expand the ticks to niced extent.
+   */
+  LogScale.prototype.getTicks = function (opt) {
+    opt = opt || {};
+    var extent = this._extent.slice();
+    var originalExtent = this._originalScale.getExtent();
+    var ticks = _super.prototype.getTicks.call(this, opt);
+    var base = this.base;
+    var originalBreaks = this._originalScale._innerGetBreaks();
+    var scaleBreakHelper = _break.getScaleBreakHelper();
+    return util.map(ticks, function (tick) {
+      var val = tick.value;
+      var roundingCriterion = null;
+      var powVal = mathPow(base, val);
+      // Fix #4158
+      if (val === extent[0] && this._fixMin) {
+        roundingCriterion = originalExtent[0];
+      } else if (val === extent[1] && this._fixMax) {
+        roundingCriterion = originalExtent[1];
+      }
+      var vBreak;
+      if (scaleBreakHelper) {
+        var transformed = scaleBreakHelper.getTicksLogTransformBreak(tick, base, originalBreaks, fixRoundingError);
+        vBreak = transformed.vBreak;
+        if (roundingCriterion == null) {
+          roundingCriterion = transformed.brkRoundingCriterion;
+        }
+      }
+      if (roundingCriterion != null) {
+        powVal = fixRoundingError(powVal, roundingCriterion);
+      }
+      return {
+        value: powVal,
+        "break": vBreak
+      };
+    }, this);
+  };
+  LogScale.prototype._getNonTransBreaks = function () {
+    return this._originalScale._innerGetBreaks();
+  };
+  LogScale.prototype.setExtent = function (start, end) {
+    this._originalScale.setExtent(start, end);
+    var loggedExtent = helper.logTransform(this.base, [start, end]);
+    _super.prototype.setExtent.call(this, loggedExtent[0], loggedExtent[1]);
+  };
+  /**
+   * @return {number} end
+   */
+  LogScale.prototype.getExtent = function () {
+    var base = this.base;
+    var extent = _super.prototype.getExtent.call(this);
+    extent[0] = mathPow(base, extent[0]);
+    extent[1] = mathPow(base, extent[1]);
+    // Fix #4158
+    var originalExtent = this._originalScale.getExtent();
+    this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
+    this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
+    return extent;
+  };
+  LogScale.prototype.unionExtentFromData = function (data, dim) {
+    this._originalScale.unionExtentFromData(data, dim);
+    var loggedOther = helper.logTransform(this.base, data.getApproximateExtent(dim), true);
+    this._innerUnionExtent(loggedOther);
+  };
+  /**
+   * 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.slice();
+    var span = this._getExtentSpanWithBreaks();
+    if (!isFinite(span) || 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 = [fixRound(mathCeil(extent[0] / interval) * interval), fixRound(mathFloor(extent[1] / interval) * interval)];
+    this._interval = interval;
+    this._intervalPrecision = helper.getIntervalPrecision(interval);
+    this._niceExtent = niceExtent;
+  };
+  LogScale.prototype.calcNiceExtent = function (opt) {
+    _super.prototype.calcNiceExtent.call(this, opt);
+    this._fixMin = opt.fixMin;
+    this._fixMax = opt.fixMax;
+  };
+  LogScale.prototype.contain = function (val) {
+    val = mathLog(val) / mathLog(this.base);
+    return _super.prototype.contain.call(this, val);
+  };
+  LogScale.prototype.normalize = function (val) {
+    val = mathLog(val) / mathLog(this.base);
+    return _super.prototype.normalize.call(this, val);
+  };
+  LogScale.prototype.scale = function (val) {
+    val = _super.prototype.scale.call(this, val);
+    return mathPow(this.base, val);
+  };
+  LogScale.prototype.setBreaksFromOption = function (breakOptionList) {
+    var scaleBreakHelper = _break.getScaleBreakHelper();
+    if (!scaleBreakHelper) {
+      return;
+    }
+    var _a = scaleBreakHelper.logarithmicParseBreaksFromOption(breakOptionList, this.base, util.bind(this.parse, this)),
+      parsedOriginal = _a.parsedOriginal,
+      parsedLogged = _a.parsedLogged;
+    this._originalScale._innerSetBreak(parsedOriginal);
+    this._innerSetBreak(parsedLogged);
+  };
+  LogScale.type = 'log';
+  return LogScale;
+}(Interval.default);
+function fixRoundingError(val, originalVal) {
+  return fixRound(val, number.getPrecision(originalVal));
+}
+Scale.default.registerClass(LogScale);
+
+exports.default = LogScale;