@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/label/labelGuideHelper.mjs

@@ -0,0 +1,444 @@
+import "../util/graphic.mjs";
+import PathProxy from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/PathProxy.mjs";
+import { normalizeRadian } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/util.mjs";
+import { quadraticProjectPoint, cubicProjectPoint } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/curve.mjs";
+import { retrieve2, defaults } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { invert } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.mjs";
+import { dist, lerp } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/vector.mjs";
+import { DISPLAY_STATES, SPECIAL_STATES } from "../util/states.mjs";
+import Point from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/Point.mjs";
+import Polyline from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polyline.mjs";
+import Path from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Path.mjs";
+var PI2 = Math.PI * 2;
+var CMD = PathProxy.CMD;
+var DEFAULT_SEARCH_SPACE = ["top", "right", "bottom", "left"];
+function getCandidateAnchor(pos, distance, rect, outPt, outDir) {
+  var width = rect.width;
+  var height = rect.height;
+  switch (pos) {
+    case "top":
+      outPt.set(rect.x + width / 2, rect.y - distance);
+      outDir.set(0, -1);
+      break;
+    case "bottom":
+      outPt.set(rect.x + width / 2, rect.y + height + distance);
+      outDir.set(0, 1);
+      break;
+    case "left":
+      outPt.set(rect.x - distance, rect.y + height / 2);
+      outDir.set(-1, 0);
+      break;
+    case "right":
+      outPt.set(rect.x + width + distance, rect.y + height / 2);
+      outDir.set(1, 0);
+      break;
+  }
+}
+function projectPointToArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y, out) {
+  x -= cx;
+  y -= cy;
+  var d = Math.sqrt(x * x + y * y);
+  x /= d;
+  y /= d;
+  var ox = x * r + cx;
+  var oy = y * r + cy;
+  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {
+    out[0] = ox;
+    out[1] = oy;
+    return d - r;
+  }
+  if (anticlockwise) {
+    var tmp = startAngle;
+    startAngle = normalizeRadian(endAngle);
+    endAngle = normalizeRadian(tmp);
+  } else {
+    startAngle = normalizeRadian(startAngle);
+    endAngle = normalizeRadian(endAngle);
+  }
+  if (startAngle > endAngle) {
+    endAngle += PI2;
+  }
+  var angle = Math.atan2(y, x);
+  if (angle < 0) {
+    angle += PI2;
+  }
+  if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {
+    out[0] = ox;
+    out[1] = oy;
+    return d - r;
+  }
+  var x1 = r * Math.cos(startAngle) + cx;
+  var y1 = r * Math.sin(startAngle) + cy;
+  var x2 = r * Math.cos(endAngle) + cx;
+  var y2 = r * Math.sin(endAngle) + cy;
+  var d1 = (x1 - x) * (x1 - x) + (y1 - y) * (y1 - y);
+  var d2 = (x2 - x) * (x2 - x) + (y2 - y) * (y2 - y);
+  if (d1 < d2) {
+    out[0] = x1;
+    out[1] = y1;
+    return Math.sqrt(d1);
+  } else {
+    out[0] = x2;
+    out[1] = y2;
+    return Math.sqrt(d2);
+  }
+}
+function projectPointToLine(x1, y1, x2, y2, x, y, out, limitToEnds) {
+  var dx = x - x1;
+  var dy = y - y1;
+  var dx1 = x2 - x1;
+  var dy1 = y2 - y1;
+  var lineLen = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+  dx1 /= lineLen;
+  dy1 /= lineLen;
+  var projectedLen = dx * dx1 + dy * dy1;
+  var t = projectedLen / lineLen;
+  if (limitToEnds) {
+    t = Math.min(Math.max(t, 0), 1);
+  }
+  t *= lineLen;
+  var ox = out[0] = x1 + t * dx1;
+  var oy = out[1] = y1 + t * dy1;
+  return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
+}
+function projectPointToRect(x1, y1, width, height, x, y, out) {
+  if (width < 0) {
+    x1 = x1 + width;
+    width = -width;
+  }
+  if (height < 0) {
+    y1 = y1 + height;
+    height = -height;
+  }
+  var x2 = x1 + width;
+  var y2 = y1 + height;
+  var ox = out[0] = Math.min(Math.max(x, x1), x2);
+  var oy = out[1] = Math.min(Math.max(y, y1), y2);
+  return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
+}
+var tmpPt = [];
+function nearestPointOnRect(pt, rect, out) {
+  var dist2 = projectPointToRect(rect.x, rect.y, rect.width, rect.height, pt.x, pt.y, tmpPt);
+  out.set(tmpPt[0], tmpPt[1]);
+  return dist2;
+}
+function nearestPointOnPath(pt, path, out) {
+  var xi = 0;
+  var yi = 0;
+  var x0 = 0;
+  var y0 = 0;
+  var x1;
+  var y1;
+  var minDist = Infinity;
+  var data = path.data;
+  var x = pt.x;
+  var y = pt.y;
+  for (var i = 0; i < data.length; ) {
+    var cmd = data[i++];
+    if (i === 1) {
+      xi = data[i];
+      yi = data[i + 1];
+      x0 = xi;
+      y0 = yi;
+    }
+    var d = minDist;
+    switch (cmd) {
+      case CMD.M:
+        x0 = data[i++];
+        y0 = data[i++];
+        xi = x0;
+        yi = y0;
+        break;
+      case CMD.L:
+        d = projectPointToLine(xi, yi, data[i], data[i + 1], x, y, tmpPt, true);
+        xi = data[i++];
+        yi = data[i++];
+        break;
+      case CMD.C:
+        d = cubicProjectPoint(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
+        xi = data[i++];
+        yi = data[i++];
+        break;
+      case CMD.Q:
+        d = quadraticProjectPoint(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
+        xi = data[i++];
+        yi = data[i++];
+        break;
+      case CMD.A:
+        var cx = data[i++];
+        var cy = data[i++];
+        var rx = data[i++];
+        var ry = data[i++];
+        var theta = data[i++];
+        var dTheta = data[i++];
+        i += 1;
+        var anticlockwise = !!(1 - data[i++]);
+        x1 = Math.cos(theta) * rx + cx;
+        y1 = Math.sin(theta) * ry + cy;
+        if (i <= 1) {
+          x0 = x1;
+          y0 = y1;
+        }
+        var _x = (x - cx) * ry / rx + cx;
+        d = projectPointToArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y, tmpPt);
+        xi = Math.cos(theta + dTheta) * rx + cx;
+        yi = Math.sin(theta + dTheta) * ry + cy;
+        break;
+      case CMD.R:
+        x0 = xi = data[i++];
+        y0 = yi = data[i++];
+        var width = data[i++];
+        var height = data[i++];
+        d = projectPointToRect(x0, y0, width, height, x, y, tmpPt);
+        break;
+      case CMD.Z:
+        d = projectPointToLine(xi, yi, x0, y0, x, y, tmpPt, true);
+        xi = x0;
+        yi = y0;
+        break;
+    }
+    if (d < minDist) {
+      minDist = d;
+      out.set(tmpPt[0], tmpPt[1]);
+    }
+  }
+  return minDist;
+}
+var pt0 = new Point();
+var pt1 = new Point();
+var pt2 = new Point();
+var dir = new Point();
+var dir2 = new Point();
+function updateLabelLinePoints(target, labelLineModel) {
+  if (!target) {
+    return;
+  }
+  var labelLine = target.getTextGuideLine();
+  var label = target.getTextContent();
+  if (!(label && labelLine)) {
+    return;
+  }
+  var labelGuideConfig = target.textGuideLineConfig || {};
+  var points = [[0, 0], [0, 0], [0, 0]];
+  var searchSpace = labelGuideConfig.candidates || DEFAULT_SEARCH_SPACE;
+  var labelRect = label.getBoundingRect().clone();
+  labelRect.applyTransform(label.getComputedTransform());
+  var minDist = Infinity;
+  var anchorPoint = labelGuideConfig.anchor;
+  var targetTransform = target.getComputedTransform();
+  var targetInversedTransform = targetTransform && invert([], targetTransform);
+  var len = labelLineModel.get("length2") || 0;
+  if (anchorPoint) {
+    pt2.copy(anchorPoint);
+  }
+  for (var i = 0; i < searchSpace.length; i++) {
+    var candidate = searchSpace[i];
+    getCandidateAnchor(candidate, 0, labelRect, pt0, dir);
+    Point.scaleAndAdd(pt1, pt0, dir, len);
+    pt1.transform(targetInversedTransform);
+    var boundingRect = target.getBoundingRect();
+    var dist2 = anchorPoint ? anchorPoint.distance(pt1) : target instanceof Path ? nearestPointOnPath(pt1, target.path, pt2) : nearestPointOnRect(pt1, boundingRect, pt2);
+    if (dist2 < minDist) {
+      minDist = dist2;
+      pt1.transform(targetTransform);
+      pt2.transform(targetTransform);
+      pt2.toArray(points[0]);
+      pt1.toArray(points[1]);
+      pt0.toArray(points[2]);
+    }
+  }
+  limitTurnAngle(points, labelLineModel.get("minTurnAngle"));
+  labelLine.setShape({
+    points
+  });
+}
+var tmpArr = [];
+var tmpProjPoint = new Point();
+function limitTurnAngle(linePoints, minTurnAngle) {
+  if (!(minTurnAngle <= 180 && minTurnAngle > 0)) {
+    return;
+  }
+  minTurnAngle = minTurnAngle / 180 * Math.PI;
+  pt0.fromArray(linePoints[0]);
+  pt1.fromArray(linePoints[1]);
+  pt2.fromArray(linePoints[2]);
+  Point.sub(dir, pt0, pt1);
+  Point.sub(dir2, pt2, pt1);
+  var len1 = dir.len();
+  var len2 = dir2.len();
+  if (len1 < 1e-3 || len2 < 1e-3) {
+    return;
+  }
+  dir.scale(1 / len1);
+  dir2.scale(1 / len2);
+  var angleCos = dir.dot(dir2);
+  var minTurnAngleCos = Math.cos(minTurnAngle);
+  if (minTurnAngleCos < angleCos) {
+    var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
+    tmpProjPoint.fromArray(tmpArr);
+    tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI - minTurnAngle));
+    var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
+    if (isNaN(t)) {
+      return;
+    }
+    if (t < 0) {
+      Point.copy(tmpProjPoint, pt1);
+    } else if (t > 1) {
+      Point.copy(tmpProjPoint, pt2);
+    }
+    tmpProjPoint.toArray(linePoints[1]);
+  }
+}
+function limitSurfaceAngle(linePoints, surfaceNormal, maxSurfaceAngle) {
+  if (!(maxSurfaceAngle <= 180 && maxSurfaceAngle > 0)) {
+    return;
+  }
+  maxSurfaceAngle = maxSurfaceAngle / 180 * Math.PI;
+  pt0.fromArray(linePoints[0]);
+  pt1.fromArray(linePoints[1]);
+  pt2.fromArray(linePoints[2]);
+  Point.sub(dir, pt1, pt0);
+  Point.sub(dir2, pt2, pt1);
+  var len1 = dir.len();
+  var len2 = dir2.len();
+  if (len1 < 1e-3 || len2 < 1e-3) {
+    return;
+  }
+  dir.scale(1 / len1);
+  dir2.scale(1 / len2);
+  var angleCos = dir.dot(surfaceNormal);
+  var maxSurfaceAngleCos = Math.cos(maxSurfaceAngle);
+  if (angleCos < maxSurfaceAngleCos) {
+    var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
+    tmpProjPoint.fromArray(tmpArr);
+    var HALF_PI = Math.PI / 2;
+    var angle2 = Math.acos(dir2.dot(surfaceNormal));
+    var newAngle = HALF_PI + angle2 - maxSurfaceAngle;
+    if (newAngle >= HALF_PI) {
+      Point.copy(tmpProjPoint, pt2);
+    } else {
+      tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI / 2 - newAngle));
+      var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
+      if (isNaN(t)) {
+        return;
+      }
+      if (t < 0) {
+        Point.copy(tmpProjPoint, pt1);
+      } else if (t > 1) {
+        Point.copy(tmpProjPoint, pt2);
+      }
+    }
+    tmpProjPoint.toArray(linePoints[1]);
+  }
+}
+function setLabelLineState(labelLine, ignore, stateName, stateModel) {
+  var isNormal = stateName === "normal";
+  var stateObj = isNormal ? labelLine : labelLine.ensureState(stateName);
+  stateObj.ignore = ignore;
+  var smooth = stateModel.get("smooth");
+  if (smooth && smooth === true) {
+    smooth = 0.3;
+  }
+  stateObj.shape = stateObj.shape || {};
+  if (smooth > 0) {
+    stateObj.shape.smooth = smooth;
+  }
+  var styleObj = stateModel.getModel("lineStyle").getLineStyle();
+  isNormal ? labelLine.useStyle(styleObj) : stateObj.style = styleObj;
+}
+function buildLabelLinePath(path, shape) {
+  var smooth = shape.smooth;
+  var points = shape.points;
+  if (!points) {
+    return;
+  }
+  path.moveTo(points[0][0], points[0][1]);
+  if (smooth > 0 && points.length >= 3) {
+    var len1 = dist(points[0], points[1]);
+    var len2 = dist(points[1], points[2]);
+    if (!len1 || !len2) {
+      path.lineTo(points[1][0], points[1][1]);
+      path.lineTo(points[2][0], points[2][1]);
+      return;
+    }
+    var moveLen = Math.min(len1, len2) * smooth;
+    var midPoint0 = lerp([], points[1], points[0], moveLen / len1);
+    var midPoint2 = lerp([], points[1], points[2], moveLen / len2);
+    var midPoint1 = lerp([], midPoint0, midPoint2, 0.5);
+    path.bezierCurveTo(midPoint0[0], midPoint0[1], midPoint0[0], midPoint0[1], midPoint1[0], midPoint1[1]);
+    path.bezierCurveTo(midPoint2[0], midPoint2[1], midPoint2[0], midPoint2[1], points[2][0], points[2][1]);
+  } else {
+    for (var i = 1; i < points.length; i++) {
+      path.lineTo(points[i][0], points[i][1]);
+    }
+  }
+}
+function setLabelLineStyle(targetEl, statesModels, defaultStyle) {
+  var labelLine = targetEl.getTextGuideLine();
+  var label = targetEl.getTextContent();
+  if (!label) {
+    if (labelLine) {
+      targetEl.removeTextGuideLine();
+    }
+    return;
+  }
+  var normalModel = statesModels.normal;
+  var showNormal = normalModel.get("show");
+  var labelIgnoreNormal = label.ignore;
+  for (var i = 0; i < DISPLAY_STATES.length; i++) {
+    var stateName = DISPLAY_STATES[i];
+    var stateModel = statesModels[stateName];
+    var isNormal = stateName === "normal";
+    if (stateModel) {
+      var stateShow = stateModel.get("show");
+      var isLabelIgnored = isNormal ? labelIgnoreNormal : retrieve2(label.states[stateName] && label.states[stateName].ignore, labelIgnoreNormal);
+      if (isLabelIgnored || !retrieve2(stateShow, showNormal)) {
+        var stateObj = isNormal ? labelLine : labelLine && labelLine.states[stateName];
+        if (stateObj) {
+          stateObj.ignore = true;
+        }
+        if (!!labelLine) {
+          setLabelLineState(labelLine, true, stateName, stateModel);
+        }
+        continue;
+      }
+      if (!labelLine) {
+        labelLine = new Polyline();
+        targetEl.setTextGuideLine(labelLine);
+        if (!isNormal && (labelIgnoreNormal || !showNormal)) {
+          setLabelLineState(labelLine, true, "normal", statesModels.normal);
+        }
+        if (targetEl.stateProxy) {
+          labelLine.stateProxy = targetEl.stateProxy;
+        }
+      }
+      setLabelLineState(labelLine, false, stateName, stateModel);
+    }
+  }
+  if (labelLine) {
+    defaults(labelLine.style, defaultStyle);
+    labelLine.style.fill = null;
+    var showAbove = normalModel.get("showAbove");
+    var labelLineConfig = targetEl.textGuideLineConfig = targetEl.textGuideLineConfig || {};
+    labelLineConfig.showAbove = showAbove || false;
+    labelLine.buildPath = buildLabelLinePath;
+  }
+}
+function getLabelLineStatesModels(itemModel, labelLineName) {
+  labelLineName = labelLineName || "labelLine";
+  var statesModels = {
+    normal: itemModel.getModel(labelLineName)
+  };
+  for (var i = 0; i < SPECIAL_STATES.length; i++) {
+    var stateName = SPECIAL_STATES[i];
+    statesModels[stateName] = itemModel.getModel([stateName, labelLineName]);
+  }
+  return statesModels;
+}
+export {
+  getLabelLineStatesModels,
+  limitSurfaceAngle,
+  limitTurnAngle,
+  setLabelLineStyle,
+  updateLabelLinePoints
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/label/labelLayoutHelper.mjs

@@ -0,0 +1,219 @@
+import "../util/graphic.mjs";
+import OrientedBoundingRect from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/OrientedBoundingRect.mjs";
+import BoundingRect from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.mjs";
+function prepareLayoutList(input) {
+  var list = [];
+  for (var i = 0; i < input.length; i++) {
+    var rawItem = input[i];
+    if (rawItem.defaultAttr.ignore) {
+      continue;
+    }
+    var label = rawItem.label;
+    var transform = label.getComputedTransform();
+    var localRect = label.getBoundingRect();
+    var isAxisAligned = !transform || transform[1] < 1e-5 && transform[2] < 1e-5;
+    var minMargin = label.style.margin || 0;
+    var globalRect = localRect.clone();
+    globalRect.applyTransform(transform);
+    globalRect.x -= minMargin / 2;
+    globalRect.y -= minMargin / 2;
+    globalRect.width += minMargin;
+    globalRect.height += minMargin;
+    var obb = isAxisAligned ? new OrientedBoundingRect(localRect, transform) : null;
+    list.push({
+      label,
+      labelLine: rawItem.labelLine,
+      rect: globalRect,
+      localRect,
+      obb,
+      priority: rawItem.priority,
+      defaultAttr: rawItem.defaultAttr,
+      layoutOption: rawItem.computedLayoutOption,
+      axisAligned: isAxisAligned,
+      transform
+    });
+  }
+  return list;
+}
+function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) {
+  var len = list.length;
+  if (len < 2) {
+    return;
+  }
+  list.sort(function(a, b) {
+    return a.rect[xyDim] - b.rect[xyDim];
+  });
+  var lastPos = 0;
+  var delta;
+  var adjusted = false;
+  for (var i = 0; i < len; i++) {
+    var item = list[i];
+    var rect = item.rect;
+    delta = rect[xyDim] - lastPos;
+    if (delta < 0) {
+      rect[xyDim] -= delta;
+      item.label[xyDim] -= delta;
+      adjusted = true;
+    }
+    lastPos = rect[xyDim] + rect[sizeDim];
+  }
+  var first = list[0];
+  var last = list[len - 1];
+  var minGap;
+  var maxGap;
+  updateMinMaxGap();
+  minGap < 0 && squeezeGaps(-minGap, 0.8);
+  maxGap < 0 && squeezeGaps(maxGap, 0.8);
+  updateMinMaxGap();
+  takeBoundsGap(minGap, maxGap, 1);
+  takeBoundsGap(maxGap, minGap, -1);
+  updateMinMaxGap();
+  if (minGap < 0) {
+    squeezeWhenBailout(-minGap);
+  }
+  if (maxGap < 0) {
+    squeezeWhenBailout(maxGap);
+  }
+  function updateMinMaxGap() {
+    minGap = first.rect[xyDim] - minBound;
+    maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim];
+  }
+  function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) {
+    if (gapThisBound < 0) {
+      var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound);
+      if (moveFromMaxGap > 0) {
+        shiftList(moveFromMaxGap * moveDir, 0, len);
+        var remained = moveFromMaxGap + gapThisBound;
+        if (remained < 0) {
+          squeezeGaps(-remained * moveDir, 1);
+        }
+      } else {
+        squeezeGaps(-gapThisBound * moveDir, 1);
+      }
+    }
+  }
+  function shiftList(delta2, start, end) {
+    if (delta2 !== 0) {
+      adjusted = true;
+    }
+    for (var i2 = start; i2 < end; i2++) {
+      var item2 = list[i2];
+      var rect2 = item2.rect;
+      rect2[xyDim] += delta2;
+      item2.label[xyDim] += delta2;
+    }
+  }
+  function squeezeGaps(delta2, maxSqeezePercent) {
+    var gaps = [];
+    var totalGaps = 0;
+    for (var i2 = 1; i2 < len; i2++) {
+      var prevItemRect = list[i2 - 1].rect;
+      var gap = Math.max(list[i2].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim], 0);
+      gaps.push(gap);
+      totalGaps += gap;
+    }
+    if (!totalGaps) {
+      return;
+    }
+    var squeezePercent = Math.min(Math.abs(delta2) / totalGaps, maxSqeezePercent);
+    if (delta2 > 0) {
+      for (var i2 = 0; i2 < len - 1; i2++) {
+        var movement = gaps[i2] * squeezePercent;
+        shiftList(movement, 0, i2 + 1);
+      }
+    } else {
+      for (var i2 = len - 1; i2 > 0; i2--) {
+        var movement = gaps[i2 - 1] * squeezePercent;
+        shiftList(-movement, i2, len);
+      }
+    }
+  }
+  function squeezeWhenBailout(delta2) {
+    var dir = delta2 < 0 ? -1 : 1;
+    delta2 = Math.abs(delta2);
+    var moveForEachLabel = Math.ceil(delta2 / (len - 1));
+    for (var i2 = 0; i2 < len - 1; i2++) {
+      if (dir > 0) {
+        shiftList(moveForEachLabel, 0, i2 + 1);
+      } else {
+        shiftList(-moveForEachLabel, len - i2 - 1, len);
+      }
+      delta2 -= moveForEachLabel;
+      if (delta2 <= 0) {
+        return;
+      }
+    }
+  }
+  return adjusted;
+}
+function shiftLayoutOnX(list, leftBound, rightBound, balanceShift) {
+  return shiftLayout(list, "x", "width", leftBound, rightBound);
+}
+function shiftLayoutOnY(list, topBound, bottomBound, balanceShift) {
+  return shiftLayout(list, "y", "height", topBound, bottomBound);
+}
+function hideOverlap(labelList) {
+  var displayedLabels = [];
+  labelList.sort(function(a, b) {
+    return b.priority - a.priority;
+  });
+  var globalRect = new BoundingRect(0, 0, 0, 0);
+  function hideEl(el) {
+    if (!el.ignore) {
+      var emphasisState = el.ensureState("emphasis");
+      if (emphasisState.ignore == null) {
+        emphasisState.ignore = false;
+      }
+    }
+    el.ignore = true;
+  }
+  for (var i = 0; i < labelList.length; i++) {
+    var labelItem = labelList[i];
+    var isAxisAligned = labelItem.axisAligned;
+    var localRect = labelItem.localRect;
+    var transform = labelItem.transform;
+    var label = labelItem.label;
+    var labelLine = labelItem.labelLine;
+    globalRect.copy(labelItem.rect);
+    globalRect.width -= 0.1;
+    globalRect.height -= 0.1;
+    globalRect.x += 0.05;
+    globalRect.y += 0.05;
+    var obb = labelItem.obb;
+    var overlapped = false;
+    for (var j = 0; j < displayedLabels.length; j++) {
+      var existsTextCfg = displayedLabels[j];
+      if (!globalRect.intersect(existsTextCfg.rect)) {
+        continue;
+      }
+      if (isAxisAligned && existsTextCfg.axisAligned) {
+        overlapped = true;
+        break;
+      }
+      if (!existsTextCfg.obb) {
+        existsTextCfg.obb = new OrientedBoundingRect(existsTextCfg.localRect, existsTextCfg.transform);
+      }
+      if (!obb) {
+        obb = new OrientedBoundingRect(localRect, transform);
+      }
+      if (obb.intersect(existsTextCfg.obb)) {
+        overlapped = true;
+        break;
+      }
+    }
+    if (overlapped) {
+      hideEl(label);
+      labelLine && hideEl(labelLine);
+    } else {
+      label.attr("ignore", labelItem.defaultAttr.ignore);
+      labelLine && labelLine.attr("ignore", labelItem.defaultAttr.labelGuideIgnore);
+      displayedLabels.push(labelItem);
+    }
+  }
+}
+export {
+  hideOverlap,
+  prepareLayoutList,
+  shiftLayoutOnX,
+  shiftLayoutOnY
+};