office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/chart/helper/LargeSymbolDraw.js

@@ -0,0 +1,269 @@
+import { __extends } from 'tslib';
+import '../../util/graphic.js';
+import { createSymbol } from '../../util/symbol.js';
+import { getECData } from '../../util/innerStore.js';
+import BoundingRect from '../../../../zrender/lib/core/BoundingRect.js';
+import Path from '../../../../zrender/lib/graphic/Path.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+
+var BOOST_SIZE_THRESHOLD = 4;
+var LargeSymbolPathShape = /** @class */function () {
+  function LargeSymbolPathShape() {}
+  return LargeSymbolPathShape;
+}();
+var LargeSymbolPath = /** @class */function (_super) {
+  __extends(LargeSymbolPath, _super);
+  function LargeSymbolPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this._off = 0;
+    _this.hoverDataIdx = -1;
+    return _this;
+  }
+  LargeSymbolPath.prototype.getDefaultShape = function () {
+    return new LargeSymbolPathShape();
+  };
+  LargeSymbolPath.prototype.reset = function () {
+    this.notClear = false;
+    this._off = 0;
+  };
+  LargeSymbolPath.prototype.buildPath = function (path, shape) {
+    var points = shape.points;
+    var size = shape.size;
+    var symbolProxy = this.symbolProxy;
+    var symbolProxyShape = symbolProxy.shape;
+    var ctx = path.getContext ? path.getContext() : path;
+    var canBoost = ctx && size[0] < BOOST_SIZE_THRESHOLD;
+    var softClipShape = this.softClipShape;
+    var i;
+    // Do draw in afterBrush.
+    if (canBoost) {
+      this._ctx = ctx;
+      return;
+    }
+    this._ctx = null;
+    for (i = this._off; i < points.length;) {
+      var x = points[i++];
+      var y = points[i++];
+      if (isNaN(x) || isNaN(y)) {
+        continue;
+      }
+      if (softClipShape && !softClipShape.contain(x, y)) {
+        continue;
+      }
+      symbolProxyShape.x = x - size[0] / 2;
+      symbolProxyShape.y = y - size[1] / 2;
+      symbolProxyShape.width = size[0];
+      symbolProxyShape.height = size[1];
+      symbolProxy.buildPath(path, symbolProxyShape, true);
+    }
+    if (this.incremental) {
+      this._off = i;
+      this.notClear = true;
+    }
+  };
+  LargeSymbolPath.prototype.afterBrush = function () {
+    var shape = this.shape;
+    var points = shape.points;
+    var size = shape.size;
+    var ctx = this._ctx;
+    var softClipShape = this.softClipShape;
+    var i;
+    if (!ctx) {
+      return;
+    }
+    // PENDING If style or other canvas status changed?
+    for (i = this._off; i < points.length;) {
+      var x = points[i++];
+      var y = points[i++];
+      if (isNaN(x) || isNaN(y)) {
+        continue;
+      }
+      if (softClipShape && !softClipShape.contain(x, y)) {
+        continue;
+      }
+      // fillRect is faster than building a rect path and draw.
+      // And it support light globalCompositeOperation.
+      ctx.fillRect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
+    }
+    if (this.incremental) {
+      this._off = i;
+      this.notClear = true;
+    }
+  };
+  LargeSymbolPath.prototype.findDataIndex = function (x, y) {
+    // TODO ???
+    // Consider transform
+    var shape = this.shape;
+    var points = shape.points;
+    var size = shape.size;
+    var w = Math.max(size[0], 4);
+    var h = Math.max(size[1], 4);
+    // Not consider transform
+    // Treat each element as a rect
+    // top down traverse
+    for (var idx = points.length / 2 - 1; idx >= 0; idx--) {
+      var i = idx * 2;
+      var x0 = points[i] - w / 2;
+      var y0 = points[i + 1] - h / 2;
+      if (x >= x0 && y >= y0 && x <= x0 + w && y <= y0 + h) {
+        return idx;
+      }
+    }
+    return -1;
+  };
+  LargeSymbolPath.prototype.contain = function (x, y) {
+    var localPos = this.transformCoordToLocal(x, y);
+    var rect = this.getBoundingRect();
+    x = localPos[0];
+    y = localPos[1];
+    if (rect.contain(x, y)) {
+      // Cache found data index.
+      var dataIdx = this.hoverDataIdx = this.findDataIndex(x, y);
+      return dataIdx >= 0;
+    }
+    this.hoverDataIdx = -1;
+    return false;
+  };
+  LargeSymbolPath.prototype.getBoundingRect = function () {
+    // Ignore stroke for large symbol draw.
+    var rect = this._rect;
+    if (!rect) {
+      var shape = this.shape;
+      var points = shape.points;
+      var size = shape.size;
+      var w = size[0];
+      var h = size[1];
+      var minX = Infinity;
+      var minY = Infinity;
+      var maxX = -Infinity;
+      var maxY = -Infinity;
+      for (var i = 0; i < points.length;) {
+        var x = points[i++];
+        var y = points[i++];
+        minX = Math.min(x, minX);
+        maxX = Math.max(x, maxX);
+        minY = Math.min(y, minY);
+        maxY = Math.max(y, maxY);
+      }
+      rect = this._rect = new BoundingRect(minX - w / 2, minY - h / 2, maxX - minX + w, maxY - minY + h);
+    }
+    return rect;
+  };
+  return LargeSymbolPath;
+}(Path);
+var LargeSymbolDraw = /** @class */function () {
+  function LargeSymbolDraw() {
+    this.group = new Group();
+  }
+  /**
+   * Update symbols draw by new data
+   */
+  LargeSymbolDraw.prototype.updateData = function (data, opt) {
+    this._clear();
+    var symbolEl = this._create();
+    symbolEl.setShape({
+      points: data.getLayout('points')
+    });
+    this._setCommon(symbolEl, data, opt);
+  };
+  LargeSymbolDraw.prototype.updateLayout = function (data) {
+    var points = data.getLayout('points');
+    this.group.eachChild(function (child) {
+      if (child.startIndex != null) {
+        var len = (child.endIndex - child.startIndex) * 2;
+        var byteOffset = child.startIndex * 4 * 2;
+        points = new Float32Array(points.buffer, byteOffset, len);
+      }
+      child.setShape('points', points);
+      // Reset draw cursor.
+      child.reset();
+    });
+  };
+  LargeSymbolDraw.prototype.incrementalPrepareUpdate = function (data) {
+    this._clear();
+  };
+  LargeSymbolDraw.prototype.incrementalUpdate = function (taskParams, data, opt) {
+    var lastAdded = this._newAdded[0];
+    var points = data.getLayout('points');
+    var oldPoints = lastAdded && lastAdded.shape.points;
+    // Merging the exists. Each element has 1e4 points.
+    // Consider the performance balance between too much elements and too much points in one shape(may affect hover optimization)
+    if (oldPoints && oldPoints.length < 2e4) {
+      var oldLen = oldPoints.length;
+      var newPoints = new Float32Array(oldLen + points.length);
+      // Concat two array
+      newPoints.set(oldPoints);
+      newPoints.set(points, oldLen);
+      // Update endIndex
+      lastAdded.endIndex = taskParams.end;
+      lastAdded.setShape({
+        points: newPoints
+      });
+    } else {
+      // Clear
+      this._newAdded = [];
+      var symbolEl = this._create();
+      symbolEl.startIndex = taskParams.start;
+      symbolEl.endIndex = taskParams.end;
+      symbolEl.incremental = true;
+      symbolEl.setShape({
+        points: points
+      });
+      this._setCommon(symbolEl, data, opt);
+    }
+  };
+  LargeSymbolDraw.prototype.eachRendered = function (cb) {
+    this._newAdded[0] && cb(this._newAdded[0]);
+  };
+  LargeSymbolDraw.prototype._create = function () {
+    var symbolEl = new LargeSymbolPath({
+      cursor: 'default'
+    });
+    symbolEl.ignoreCoarsePointer = true;
+    this.group.add(symbolEl);
+    this._newAdded.push(symbolEl);
+    return symbolEl;
+  };
+  LargeSymbolDraw.prototype._setCommon = function (symbolEl, data, opt) {
+    var hostModel = data.hostModel;
+    opt = opt || {};
+    var size = data.getVisual('symbolSize');
+    symbolEl.setShape('size', size instanceof Array ? size : [size, size]);
+    symbolEl.softClipShape = opt.clipShape || null;
+    // Create symbolProxy to build path for each data
+    symbolEl.symbolProxy = createSymbol(data.getVisual('symbol'), 0, 0, 0, 0);
+    // Use symbolProxy setColor method
+    symbolEl.setColor = symbolEl.symbolProxy.setColor;
+    var extrudeShadow = symbolEl.shape.size[0] < BOOST_SIZE_THRESHOLD;
+    symbolEl.useStyle(
+    // Draw shadow when doing fillRect is extremely slow.
+    hostModel.getModel('itemStyle').getItemStyle(extrudeShadow ? ['color', 'shadowBlur', 'shadowColor'] : ['color']));
+    var globalStyle = data.getVisual('style');
+    var visualColor = globalStyle && globalStyle.fill;
+    if (visualColor) {
+      symbolEl.setColor(visualColor);
+    }
+    var ecData = getECData(symbolEl);
+    // Enable tooltip
+    // PENDING May have performance issue when path is extremely large
+    ecData.seriesIndex = hostModel.seriesIndex;
+    symbolEl.on('mousemove', function (e) {
+      ecData.dataIndex = null;
+      var dataIndex = symbolEl.hoverDataIdx;
+      if (dataIndex >= 0) {
+        // Provide dataIndex for tooltip
+        ecData.dataIndex = dataIndex + (symbolEl.startIndex || 0);
+      }
+    });
+  };
+  LargeSymbolDraw.prototype.remove = function () {
+    this._clear();
+  };
+  LargeSymbolDraw.prototype._clear = function () {
+    this._newAdded = [];
+    this.group.removeAll();
+  };
+  return LargeSymbolDraw;
+}();
+
+export { LargeSymbolDraw as default };

package/esm/node_modules/echarts/lib/chart/helper/Line.js

@@ -0,0 +1,378 @@
+import { __extends } from 'tslib';
+import { each, isArray } from '../../../../zrender/lib/core/util.js';
+import { sub, normalize } from '../../../../zrender/lib/core/vector.js';
+import { normalizeSymbolSize, normalizeSymbolOffset, createSymbol as createSymbol$1 } from '../../util/symbol.js';
+import ECLinePath from './LinePath.js';
+import '../../util/graphic.js';
+import { SPECIAL_STATES, toggleHoverEmphasis, enterEmphasis, leaveEmphasis } from '../../util/states.js';
+import { getLabelStatesModels, setLabelStyle } from '../../label/labelStyle.js';
+import { round } from '../../util/number.js';
+import { initProps, updateProps } from '../../animation/basicTransition.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+
+var SYMBOL_CATEGORIES = ['fromSymbol', 'toSymbol'];
+function makeSymbolTypeKey(symbolCategory) {
+  return '_' + symbolCategory + 'Type';
+}
+function makeSymbolTypeValue(name, lineData, idx) {
+  var symbolType = lineData.getItemVisual(idx, name);
+  if (!symbolType || symbolType === 'none') {
+    return symbolType;
+  }
+  var symbolSize = lineData.getItemVisual(idx, name + 'Size');
+  var symbolRotate = lineData.getItemVisual(idx, name + 'Rotate');
+  var symbolOffset = lineData.getItemVisual(idx, name + 'Offset');
+  var symbolKeepAspect = lineData.getItemVisual(idx, name + 'KeepAspect');
+  var symbolSizeArr = normalizeSymbolSize(symbolSize);
+  var symbolOffsetArr = normalizeSymbolOffset(symbolOffset || 0, symbolSizeArr);
+  return symbolType + symbolSizeArr + symbolOffsetArr + (symbolRotate || '') + (symbolKeepAspect || '');
+}
+/**
+ * @inner
+ */
+function createSymbol(name, lineData, idx) {
+  var symbolType = lineData.getItemVisual(idx, name);
+  if (!symbolType || symbolType === 'none') {
+    return;
+  }
+  var symbolSize = lineData.getItemVisual(idx, name + 'Size');
+  var symbolRotate = lineData.getItemVisual(idx, name + 'Rotate');
+  var symbolOffset = lineData.getItemVisual(idx, name + 'Offset');
+  var symbolKeepAspect = lineData.getItemVisual(idx, name + 'KeepAspect');
+  var symbolSizeArr = normalizeSymbolSize(symbolSize);
+  var symbolOffsetArr = normalizeSymbolOffset(symbolOffset || 0, symbolSizeArr);
+  var symbolPath = createSymbol$1(symbolType, -symbolSizeArr[0] / 2 + symbolOffsetArr[0], -symbolSizeArr[1] / 2 + symbolOffsetArr[1], symbolSizeArr[0], symbolSizeArr[1], null, symbolKeepAspect);
+  symbolPath.__specifiedRotation = symbolRotate == null || isNaN(symbolRotate) ? void 0 : +symbolRotate * Math.PI / 180 || 0;
+  symbolPath.name = name;
+  return symbolPath;
+}
+function createLine(points) {
+  var line = new ECLinePath({
+    name: 'line',
+    subPixelOptimize: true
+  });
+  setLinePoints(line.shape, points);
+  return line;
+}
+function setLinePoints(targetShape, points) {
+  targetShape.x1 = points[0][0];
+  targetShape.y1 = points[0][1];
+  targetShape.x2 = points[1][0];
+  targetShape.y2 = points[1][1];
+  targetShape.percent = 1;
+  var cp1 = points[2];
+  if (cp1) {
+    targetShape.cpx1 = cp1[0];
+    targetShape.cpy1 = cp1[1];
+  } else {
+    targetShape.cpx1 = NaN;
+    targetShape.cpy1 = NaN;
+  }
+}
+var Line = /** @class */function (_super) {
+  __extends(Line, _super);
+  function Line(lineData, idx, seriesScope) {
+    var _this = _super.call(this) || this;
+    _this._createLine(lineData, idx, seriesScope);
+    return _this;
+  }
+  Line.prototype._createLine = function (lineData, idx, seriesScope) {
+    var seriesModel = lineData.hostModel;
+    var linePoints = lineData.getItemLayout(idx);
+    var line = createLine(linePoints);
+    line.shape.percent = 0;
+    initProps(line, {
+      shape: {
+        percent: 1
+      }
+    }, seriesModel, idx);
+    this.add(line);
+    each(SYMBOL_CATEGORIES, function (symbolCategory) {
+      var symbol = createSymbol(symbolCategory, lineData, idx);
+      // symbols must added after line to make sure
+      // it will be updated after line#update.
+      // Or symbol position and rotation update in line#beforeUpdate will be one frame slow
+      this.add(symbol);
+      this[makeSymbolTypeKey(symbolCategory)] = makeSymbolTypeValue(symbolCategory, lineData, idx);
+    }, this);
+    this._updateCommonStl(lineData, idx, seriesScope);
+  };
+  // TODO More strict on the List type in parameters?
+  Line.prototype.updateData = function (lineData, idx, seriesScope) {
+    var seriesModel = lineData.hostModel;
+    var line = this.childOfName('line');
+    var linePoints = lineData.getItemLayout(idx);
+    var target = {
+      shape: {}
+    };
+    setLinePoints(target.shape, linePoints);
+    updateProps(line, target, seriesModel, idx);
+    each(SYMBOL_CATEGORIES, function (symbolCategory) {
+      var symbolType = makeSymbolTypeValue(symbolCategory, lineData, idx);
+      var key = makeSymbolTypeKey(symbolCategory);
+      // Symbol changed
+      if (this[key] !== symbolType) {
+        this.remove(this.childOfName(symbolCategory));
+        var symbol = createSymbol(symbolCategory, lineData, idx);
+        this.add(symbol);
+      }
+      this[key] = symbolType;
+    }, this);
+    this._updateCommonStl(lineData, idx, seriesScope);
+  };
+  Line.prototype.getLinePath = function () {
+    return this.childAt(0);
+  };
+  Line.prototype._updateCommonStl = function (lineData, idx, seriesScope) {
+    var seriesModel = lineData.hostModel;
+    var line = this.childOfName('line');
+    var emphasisLineStyle = seriesScope && seriesScope.emphasisLineStyle;
+    var blurLineStyle = seriesScope && seriesScope.blurLineStyle;
+    var selectLineStyle = seriesScope && seriesScope.selectLineStyle;
+    var labelStatesModels = seriesScope && seriesScope.labelStatesModels;
+    var emphasisDisabled = seriesScope && seriesScope.emphasisDisabled;
+    var focus = seriesScope && seriesScope.focus;
+    var blurScope = seriesScope && seriesScope.blurScope;
+    // Optimization for large dataset
+    if (!seriesScope || lineData.hasItemOption) {
+      var itemModel = lineData.getItemModel(idx);
+      var emphasisModel = itemModel.getModel('emphasis');
+      emphasisLineStyle = emphasisModel.getModel('lineStyle').getLineStyle();
+      blurLineStyle = itemModel.getModel(['blur', 'lineStyle']).getLineStyle();
+      selectLineStyle = itemModel.getModel(['select', 'lineStyle']).getLineStyle();
+      emphasisDisabled = emphasisModel.get('disabled');
+      focus = emphasisModel.get('focus');
+      blurScope = emphasisModel.get('blurScope');
+      labelStatesModels = getLabelStatesModels(itemModel);
+    }
+    var lineStyle = lineData.getItemVisual(idx, 'style');
+    var visualColor = lineStyle.stroke;
+    line.useStyle(lineStyle);
+    line.style.fill = null;
+    line.style.strokeNoScale = true;
+    line.ensureState('emphasis').style = emphasisLineStyle;
+    line.ensureState('blur').style = blurLineStyle;
+    line.ensureState('select').style = selectLineStyle;
+    // Update symbol
+    each(SYMBOL_CATEGORIES, function (symbolCategory) {
+      var symbol = this.childOfName(symbolCategory);
+      if (symbol) {
+        // Share opacity and color with line.
+        symbol.setColor(visualColor);
+        symbol.style.opacity = lineStyle.opacity;
+        for (var i = 0; i < SPECIAL_STATES.length; i++) {
+          var stateName = SPECIAL_STATES[i];
+          var lineState = line.getState(stateName);
+          if (lineState) {
+            var lineStateStyle = lineState.style || {};
+            var state = symbol.ensureState(stateName);
+            var stateStyle = state.style || (state.style = {});
+            if (lineStateStyle.stroke != null) {
+              stateStyle[symbol.__isEmptyBrush ? 'stroke' : 'fill'] = lineStateStyle.stroke;
+            }
+            if (lineStateStyle.opacity != null) {
+              stateStyle.opacity = lineStateStyle.opacity;
+            }
+          }
+        }
+        symbol.markRedraw();
+      }
+    }, this);
+    var rawVal = seriesModel.getRawValue(idx);
+    setLabelStyle(this, labelStatesModels, {
+      labelDataIndex: idx,
+      labelFetcher: {
+        getFormattedLabel: function (dataIndex, stateName) {
+          return seriesModel.getFormattedLabel(dataIndex, stateName, lineData.dataType);
+        }
+      },
+      inheritColor: visualColor || '#000',
+      defaultOpacity: lineStyle.opacity,
+      defaultText: (rawVal == null ? lineData.getName(idx) : isFinite(rawVal) ? round(rawVal) : rawVal) + ''
+    });
+    var label = this.getTextContent();
+    // Always set `textStyle` even if `normalStyle.text` is null, because default
+    // values have to be set on `normalStyle`.
+    if (label) {
+      var labelNormalModel = labelStatesModels.normal;
+      label.__align = label.style.align;
+      label.__verticalAlign = label.style.verticalAlign;
+      // 'start', 'middle', 'end'
+      label.__position = labelNormalModel.get('position') || 'middle';
+      var distance = labelNormalModel.get('distance');
+      if (!isArray(distance)) {
+        distance = [distance, distance];
+      }
+      label.__labelDistance = distance;
+    }
+    this.setTextConfig({
+      position: null,
+      local: true,
+      inside: false // Can't be inside for stroke element.
+    });
+
+    toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
+  };
+  Line.prototype.highlight = function () {
+    enterEmphasis(this);
+  };
+  Line.prototype.downplay = function () {
+    leaveEmphasis(this);
+  };
+  Line.prototype.updateLayout = function (lineData, idx) {
+    this.setLinePoints(lineData.getItemLayout(idx));
+  };
+  Line.prototype.setLinePoints = function (points) {
+    var linePath = this.childOfName('line');
+    setLinePoints(linePath.shape, points);
+    linePath.dirty();
+  };
+  Line.prototype.beforeUpdate = function () {
+    var lineGroup = this;
+    var symbolFrom = lineGroup.childOfName('fromSymbol');
+    var symbolTo = lineGroup.childOfName('toSymbol');
+    var label = lineGroup.getTextContent();
+    // Quick reject
+    if (!symbolFrom && !symbolTo && (!label || label.ignore)) {
+      return;
+    }
+    var invScale = 1;
+    var parentNode = this.parent;
+    while (parentNode) {
+      if (parentNode.scaleX) {
+        invScale /= parentNode.scaleX;
+      }
+      parentNode = parentNode.parent;
+    }
+    var line = lineGroup.childOfName('line');
+    // If line not changed
+    // FIXME Parent scale changed
+    if (!this.__dirty && !line.__dirty) {
+      return;
+    }
+    var percent = line.shape.percent;
+    var fromPos = line.pointAt(0);
+    var toPos = line.pointAt(percent);
+    var d = sub([], toPos, fromPos);
+    normalize(d, d);
+    function setSymbolRotation(symbol, percent) {
+      // Fix #12388
+      // when symbol is set to be 'arrow' in markLine,
+      // symbolRotate value will be ignored, and compulsively use tangent angle.
+      // rotate by default if symbol rotation is not specified
+      var specifiedRotation = symbol.__specifiedRotation;
+      if (specifiedRotation == null) {
+        var tangent = line.tangentAt(percent);
+        symbol.attr('rotation', (percent === 1 ? -1 : 1) * Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+      } else {
+        symbol.attr('rotation', specifiedRotation);
+      }
+    }
+    if (symbolFrom) {
+      symbolFrom.setPosition(fromPos);
+      setSymbolRotation(symbolFrom, 0);
+      symbolFrom.scaleX = symbolFrom.scaleY = invScale * percent;
+      symbolFrom.markRedraw();
+    }
+    if (symbolTo) {
+      symbolTo.setPosition(toPos);
+      setSymbolRotation(symbolTo, 1);
+      symbolTo.scaleX = symbolTo.scaleY = invScale * percent;
+      symbolTo.markRedraw();
+    }
+    if (label && !label.ignore) {
+      label.x = label.y = 0;
+      label.originX = label.originY = 0;
+      var textAlign = void 0;
+      var textVerticalAlign = void 0;
+      var distance = label.__labelDistance;
+      var distanceX = distance[0] * invScale;
+      var distanceY = distance[1] * invScale;
+      var halfPercent = percent / 2;
+      var tangent = line.tangentAt(halfPercent);
+      var n = [tangent[1], -tangent[0]];
+      var cp = line.pointAt(halfPercent);
+      if (n[1] > 0) {
+        n[0] = -n[0];
+        n[1] = -n[1];
+      }
+      var dir = tangent[0] < 0 ? -1 : 1;
+      if (label.__position !== 'start' && label.__position !== 'end') {
+        var rotation = -Math.atan2(tangent[1], tangent[0]);
+        if (toPos[0] < fromPos[0]) {
+          rotation = Math.PI + rotation;
+        }
+        label.rotation = rotation;
+      }
+      var dy = void 0;
+      switch (label.__position) {
+        case 'insideStartTop':
+        case 'insideMiddleTop':
+        case 'insideEndTop':
+        case 'middle':
+          dy = -distanceY;
+          textVerticalAlign = 'bottom';
+          break;
+        case 'insideStartBottom':
+        case 'insideMiddleBottom':
+        case 'insideEndBottom':
+          dy = distanceY;
+          textVerticalAlign = 'top';
+          break;
+        default:
+          dy = 0;
+          textVerticalAlign = 'middle';
+      }
+      switch (label.__position) {
+        case 'end':
+          label.x = d[0] * distanceX + toPos[0];
+          label.y = d[1] * distanceY + toPos[1];
+          textAlign = d[0] > 0.8 ? 'left' : d[0] < -0.8 ? 'right' : 'center';
+          textVerticalAlign = d[1] > 0.8 ? 'top' : d[1] < -0.8 ? 'bottom' : 'middle';
+          break;
+        case 'start':
+          label.x = -d[0] * distanceX + fromPos[0];
+          label.y = -d[1] * distanceY + fromPos[1];
+          textAlign = d[0] > 0.8 ? 'right' : d[0] < -0.8 ? 'left' : 'center';
+          textVerticalAlign = d[1] > 0.8 ? 'bottom' : d[1] < -0.8 ? 'top' : 'middle';
+          break;
+        case 'insideStartTop':
+        case 'insideStart':
+        case 'insideStartBottom':
+          label.x = distanceX * dir + fromPos[0];
+          label.y = fromPos[1] + dy;
+          textAlign = tangent[0] < 0 ? 'right' : 'left';
+          label.originX = -distanceX * dir;
+          label.originY = -dy;
+          break;
+        case 'insideMiddleTop':
+        case 'insideMiddle':
+        case 'insideMiddleBottom':
+        case 'middle':
+          label.x = cp[0];
+          label.y = cp[1] + dy;
+          textAlign = 'center';
+          label.originY = -dy;
+          break;
+        case 'insideEndTop':
+        case 'insideEnd':
+        case 'insideEndBottom':
+          label.x = -distanceX * dir + toPos[0];
+          label.y = toPos[1] + dy;
+          textAlign = tangent[0] >= 0 ? 'right' : 'left';
+          label.originX = distanceX * dir;
+          label.originY = -dy;
+          break;
+      }
+      label.scaleX = label.scaleY = invScale;
+      label.setStyle({
+        // Use the user specified text align and baseline first
+        verticalAlign: label.__verticalAlign || textVerticalAlign,
+        align: label.__align || textAlign
+      });
+    }
+  };
+  return Line;
+}(Group);
+
+export { Line as default };