@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/roundSector.mjs

@@ -0,0 +1,218 @@
+import { isArray } from "../../core/util.mjs";
+var PI = Math.PI;
+var PI2 = PI * 2;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var mathACos = Math.acos;
+var mathATan2 = Math.atan2;
+var mathAbs = Math.abs;
+var mathSqrt = Math.sqrt;
+var mathMax = Math.max;
+var mathMin = Math.min;
+var e = 1e-4;
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+  var dx10 = x1 - x0;
+  var dy10 = y1 - y0;
+  var dx32 = x3 - x2;
+  var dy32 = y3 - y2;
+  var t = dy32 * dx10 - dx32 * dy10;
+  if (t * t < e) {
+    return;
+  }
+  t = (dx32 * (y0 - y2) - dy32 * (x0 - x2)) / t;
+  return [x0 + t * dx10, y0 + t * dy10];
+}
+function computeCornerTangents(x0, y0, x1, y1, radius, cr, clockwise) {
+  var x01 = x0 - x1;
+  var y01 = y0 - y1;
+  var lo = (clockwise ? cr : -cr) / mathSqrt(x01 * x01 + y01 * y01);
+  var ox = lo * y01;
+  var oy = -lo * x01;
+  var x11 = x0 + ox;
+  var y11 = y0 + oy;
+  var x10 = x1 + ox;
+  var y10 = y1 + oy;
+  var x00 = (x11 + x10) / 2;
+  var y00 = (y11 + y10) / 2;
+  var dx = x10 - x11;
+  var dy = y10 - y11;
+  var d2 = dx * dx + dy * dy;
+  var r = radius - cr;
+  var s = x11 * y10 - x10 * y11;
+  var d = (dy < 0 ? -1 : 1) * mathSqrt(mathMax(0, r * r * d2 - s * s));
+  var cx0 = (s * dy - dx * d) / d2;
+  var cy0 = (-s * dx - dy * d) / d2;
+  var cx1 = (s * dy + dx * d) / d2;
+  var cy1 = (-s * dx + dy * d) / d2;
+  var dx0 = cx0 - x00;
+  var dy0 = cy0 - y00;
+  var dx1 = cx1 - x00;
+  var dy1 = cy1 - y00;
+  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
+    cx0 = cx1;
+    cy0 = cy1;
+  }
+  return {
+    cx: cx0,
+    cy: cy0,
+    x0: -ox,
+    y0: -oy,
+    x1: cx0 * (radius / r - 1),
+    y1: cy0 * (radius / r - 1)
+  };
+}
+function normalizeCornerRadius(cr) {
+  var arr;
+  if (isArray(cr)) {
+    var len = cr.length;
+    if (!len) {
+      return cr;
+    }
+    if (len === 1) {
+      arr = [cr[0], cr[0], 0, 0];
+    } else if (len === 2) {
+      arr = [cr[0], cr[0], cr[1], cr[1]];
+    } else if (len === 3) {
+      arr = cr.concat(cr[2]);
+    } else {
+      arr = cr;
+    }
+  } else {
+    arr = [cr, cr, cr, cr];
+  }
+  return arr;
+}
+function buildPath(ctx, shape) {
+  var _a;
+  var radius = mathMax(shape.r, 0);
+  var innerRadius = mathMax(shape.r0 || 0, 0);
+  var hasRadius = radius > 0;
+  var hasInnerRadius = innerRadius > 0;
+  if (!hasRadius && !hasInnerRadius) {
+    return;
+  }
+  if (!hasRadius) {
+    radius = innerRadius;
+    innerRadius = 0;
+  }
+  if (innerRadius > radius) {
+    var tmp = radius;
+    radius = innerRadius;
+    innerRadius = tmp;
+  }
+  var startAngle = shape.startAngle, endAngle = shape.endAngle;
+  if (isNaN(startAngle) || isNaN(endAngle)) {
+    return;
+  }
+  var cx = shape.cx, cy = shape.cy;
+  var clockwise = !!shape.clockwise;
+  var arc = mathAbs(endAngle - startAngle);
+  var mod = arc > PI2 && arc % PI2;
+  mod > e && (arc = mod);
+  if (!(radius > e)) {
+    ctx.moveTo(cx, cy);
+  } else if (arc > PI2 - e) {
+    ctx.moveTo(cx + radius * mathCos(startAngle), cy + radius * mathSin(startAngle));
+    ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
+    if (innerRadius > e) {
+      ctx.moveTo(cx + innerRadius * mathCos(endAngle), cy + innerRadius * mathSin(endAngle));
+      ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
+    }
+  } else {
+    var icrStart = void 0;
+    var icrEnd = void 0;
+    var ocrStart = void 0;
+    var ocrEnd = void 0;
+    var ocrs = void 0;
+    var ocre = void 0;
+    var icrs = void 0;
+    var icre = void 0;
+    var ocrMax = void 0;
+    var icrMax = void 0;
+    var limitedOcrMax = void 0;
+    var limitedIcrMax = void 0;
+    var xre = void 0;
+    var yre = void 0;
+    var xirs = void 0;
+    var yirs = void 0;
+    var xrs = radius * mathCos(startAngle);
+    var yrs = radius * mathSin(startAngle);
+    var xire = innerRadius * mathCos(endAngle);
+    var yire = innerRadius * mathSin(endAngle);
+    var hasArc = arc > e;
+    if (hasArc) {
+      var cornerRadius = shape.cornerRadius;
+      if (cornerRadius) {
+        _a = normalizeCornerRadius(cornerRadius), icrStart = _a[0], icrEnd = _a[1], ocrStart = _a[2], ocrEnd = _a[3];
+      }
+      var halfRd = mathAbs(radius - innerRadius) / 2;
+      ocrs = mathMin(halfRd, ocrStart);
+      ocre = mathMin(halfRd, ocrEnd);
+      icrs = mathMin(halfRd, icrStart);
+      icre = mathMin(halfRd, icrEnd);
+      limitedOcrMax = ocrMax = mathMax(ocrs, ocre);
+      limitedIcrMax = icrMax = mathMax(icrs, icre);
+      if (ocrMax > e || icrMax > e) {
+        xre = radius * mathCos(endAngle);
+        yre = radius * mathSin(endAngle);
+        xirs = innerRadius * mathCos(startAngle);
+        yirs = innerRadius * mathSin(startAngle);
+        if (arc < PI) {
+          var it_1 = intersect(xrs, yrs, xirs, yirs, xre, yre, xire, yire);
+          if (it_1) {
+            var x0 = xrs - it_1[0];
+            var y0 = yrs - it_1[1];
+            var x1 = xre - it_1[0];
+            var y1 = yre - it_1[1];
+            var a = 1 / mathSin(mathACos((x0 * x1 + y0 * y1) / (mathSqrt(x0 * x0 + y0 * y0) * mathSqrt(x1 * x1 + y1 * y1))) / 2);
+            var b = mathSqrt(it_1[0] * it_1[0] + it_1[1] * it_1[1]);
+            limitedOcrMax = mathMin(ocrMax, (radius - b) / (a + 1));
+            limitedIcrMax = mathMin(icrMax, (innerRadius - b) / (a - 1));
+          }
+        }
+      }
+    }
+    if (!hasArc) {
+      ctx.moveTo(cx + xrs, cy + yrs);
+    } else if (limitedOcrMax > e) {
+      var crStart = mathMin(ocrStart, limitedOcrMax);
+      var crEnd = mathMin(ocrEnd, limitedOcrMax);
+      var ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, radius, crStart, clockwise);
+      var ct1 = computeCornerTangents(xre, yre, xire, yire, radius, crEnd, clockwise);
+      ctx.moveTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
+      if (limitedOcrMax < ocrMax && crStart === crEnd) {
+        ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedOcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
+      } else {
+        crStart > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crStart, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
+        ctx.arc(cx, cy, radius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), !clockwise);
+        crEnd > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crEnd, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
+      }
+    } else {
+      ctx.moveTo(cx + xrs, cy + yrs);
+      ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
+    }
+    if (!(innerRadius > e) || !hasArc) {
+      ctx.lineTo(cx + xire, cy + yire);
+    } else if (limitedIcrMax > e) {
+      var crStart = mathMin(icrStart, limitedIcrMax);
+      var crEnd = mathMin(icrEnd, limitedIcrMax);
+      var ct0 = computeCornerTangents(xire, yire, xre, yre, innerRadius, -crEnd, clockwise);
+      var ct1 = computeCornerTangents(xrs, yrs, xirs, yirs, innerRadius, -crStart, clockwise);
+      ctx.lineTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
+      if (limitedIcrMax < icrMax && crStart === crEnd) {
+        ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedIcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
+      } else {
+        crEnd > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crEnd, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
+        ctx.arc(cx, cy, innerRadius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), clockwise);
+        crStart > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crStart, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
+      }
+    } else {
+      ctx.lineTo(cx + xire, cy + yire);
+      ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
+    }
+  }
+  ctx.closePath();
+}
+export {
+  buildPath
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/smoothBezier.mjs

@@ -0,0 +1,64 @@
+import { min, max, clone, sub, scale, distance, add } from "../../core/vector.mjs";
+function smoothBezier(points, smooth, isLoop, constraint) {
+  var cps = [];
+  var v = [];
+  var v1 = [];
+  var v2 = [];
+  var prevPoint;
+  var nextPoint;
+  var min$1;
+  var max$1;
+  if (constraint) {
+    min$1 = [Infinity, Infinity];
+    max$1 = [-Infinity, -Infinity];
+    for (var i = 0, len = points.length; i < len; i++) {
+      min(min$1, min$1, points[i]);
+      max(max$1, max$1, points[i]);
+    }
+    min(min$1, min$1, constraint[0]);
+    max(max$1, max$1, constraint[1]);
+  }
+  for (var i = 0, len = points.length; i < len; i++) {
+    var point = points[i];
+    if (isLoop) {
+      prevPoint = points[i ? i - 1 : len - 1];
+      nextPoint = points[(i + 1) % len];
+    } else {
+      if (i === 0 || i === len - 1) {
+        cps.push(clone(points[i]));
+        continue;
+      } else {
+        prevPoint = points[i - 1];
+        nextPoint = points[i + 1];
+      }
+    }
+    sub(v, nextPoint, prevPoint);
+    scale(v, v, smooth);
+    var d0 = distance(point, prevPoint);
+    var d1 = distance(point, nextPoint);
+    var sum = d0 + d1;
+    if (sum !== 0) {
+      d0 /= sum;
+      d1 /= sum;
+    }
+    scale(v1, v, -d0);
+    scale(v2, v, d1);
+    var cp0 = add([], point, v1);
+    var cp1 = add([], point, v2);
+    if (constraint) {
+      max(cp0, cp0, min$1);
+      min(cp0, cp0, max$1);
+      max(cp1, cp1, min$1);
+      min(cp1, cp1, max$1);
+    }
+    cps.push(cp0);
+    cps.push(cp1);
+  }
+  if (isLoop) {
+    cps.push(cps.shift());
+  }
+  return cps;
+}
+export {
+  smoothBezier as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/subPixelOptimize.mjs

@@ -0,0 +1,59 @@
+var round = Math.round;
+function subPixelOptimizeLine(outputShape, inputShape, style) {
+  if (!inputShape) {
+    return;
+  }
+  var x1 = inputShape.x1;
+  var x2 = inputShape.x2;
+  var y1 = inputShape.y1;
+  var y2 = inputShape.y2;
+  outputShape.x1 = x1;
+  outputShape.x2 = x2;
+  outputShape.y1 = y1;
+  outputShape.y2 = y2;
+  var lineWidth = style && style.lineWidth;
+  if (!lineWidth) {
+    return outputShape;
+  }
+  if (round(x1 * 2) === round(x2 * 2)) {
+    outputShape.x1 = outputShape.x2 = subPixelOptimize(x1, lineWidth, true);
+  }
+  if (round(y1 * 2) === round(y2 * 2)) {
+    outputShape.y1 = outputShape.y2 = subPixelOptimize(y1, lineWidth, true);
+  }
+  return outputShape;
+}
+function subPixelOptimizeRect(outputShape, inputShape, style) {
+  if (!inputShape) {
+    return;
+  }
+  var originX = inputShape.x;
+  var originY = inputShape.y;
+  var originWidth = inputShape.width;
+  var originHeight = inputShape.height;
+  outputShape.x = originX;
+  outputShape.y = originY;
+  outputShape.width = originWidth;
+  outputShape.height = originHeight;
+  var lineWidth = style && style.lineWidth;
+  if (!lineWidth) {
+    return outputShape;
+  }
+  outputShape.x = subPixelOptimize(originX, lineWidth, true);
+  outputShape.y = subPixelOptimize(originY, lineWidth, true);
+  outputShape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - outputShape.x, originWidth === 0 ? 0 : 1);
+  outputShape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - outputShape.y, originHeight === 0 ? 0 : 1);
+  return outputShape;
+}
+function subPixelOptimize(position, lineWidth, positiveOrNegative) {
+  if (!lineWidth) {
+    return position;
+  }
+  var doubledPosition = round(position * 2);
+  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;
+}
+export {
+  subPixelOptimize,
+  subPixelOptimizeLine,
+  subPixelOptimizeRect
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Arc.mjs

@@ -0,0 +1,46 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+var ArcShape = /* @__PURE__ */ function() {
+  function ArcShape2() {
+    this.cx = 0;
+    this.cy = 0;
+    this.r = 0;
+    this.startAngle = 0;
+    this.endAngle = Math.PI * 2;
+    this.clockwise = true;
+  }
+  return ArcShape2;
+}();
+var Arc = function(_super) {
+  __extends(Arc2, _super);
+  function Arc2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Arc2.prototype.getDefaultStyle = function() {
+    return {
+      stroke: "#000",
+      fill: null
+    };
+  };
+  Arc2.prototype.getDefaultShape = function() {
+    return new ArcShape();
+  };
+  Arc2.prototype.buildPath = function(ctx, shape) {
+    var x = shape.cx;
+    var y = shape.cy;
+    var r = Math.max(shape.r, 0);
+    var startAngle = shape.startAngle;
+    var endAngle = shape.endAngle;
+    var clockwise = shape.clockwise;
+    var unitX = Math.cos(startAngle);
+    var unitY = Math.sin(startAngle);
+    ctx.moveTo(unitX * r + x, unitY * r + y);
+    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);
+  };
+  return Arc2;
+}(Path);
+Arc.prototype.type = "arc";
+export {
+  ArcShape,
+  Arc as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/BezierCurve.mjs

@@ -0,0 +1,98 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+import { normalize } from "../../core/vector.mjs";
+import { quadraticSubdivide, cubicSubdivide, cubicDerivativeAt, cubicAt, quadraticDerivativeAt, quadraticAt } from "../../core/curve.mjs";
+var out = [];
+var BezierCurveShape = /* @__PURE__ */ function() {
+  function BezierCurveShape2() {
+    this.x1 = 0;
+    this.y1 = 0;
+    this.x2 = 0;
+    this.y2 = 0;
+    this.cpx1 = 0;
+    this.cpy1 = 0;
+    this.percent = 1;
+  }
+  return BezierCurveShape2;
+}();
+function someVectorAt(shape, t, isTangent) {
+  var cpx2 = shape.cpx2;
+  var cpy2 = shape.cpy2;
+  if (cpx2 != null || cpy2 != null) {
+    return [
+      (isTangent ? cubicDerivativeAt : cubicAt)(shape.x1, shape.cpx1, shape.cpx2, shape.x2, t),
+      (isTangent ? cubicDerivativeAt : cubicAt)(shape.y1, shape.cpy1, shape.cpy2, shape.y2, t)
+    ];
+  } else {
+    return [
+      (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t),
+      (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t)
+    ];
+  }
+}
+var BezierCurve = function(_super) {
+  __extends(BezierCurve2, _super);
+  function BezierCurve2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  BezierCurve2.prototype.getDefaultStyle = function() {
+    return {
+      stroke: "#000",
+      fill: null
+    };
+  };
+  BezierCurve2.prototype.getDefaultShape = function() {
+    return new BezierCurveShape();
+  };
+  BezierCurve2.prototype.buildPath = function(ctx, shape) {
+    var x1 = shape.x1;
+    var y1 = shape.y1;
+    var x2 = shape.x2;
+    var y2 = shape.y2;
+    var cpx1 = shape.cpx1;
+    var cpy1 = shape.cpy1;
+    var cpx2 = shape.cpx2;
+    var cpy2 = shape.cpy2;
+    var percent = shape.percent;
+    if (percent === 0) {
+      return;
+    }
+    ctx.moveTo(x1, y1);
+    if (cpx2 == null || cpy2 == null) {
+      if (percent < 1) {
+        quadraticSubdivide(x1, cpx1, x2, percent, out);
+        cpx1 = out[1];
+        x2 = out[2];
+        quadraticSubdivide(y1, cpy1, y2, percent, out);
+        cpy1 = out[1];
+        y2 = out[2];
+      }
+      ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);
+    } else {
+      if (percent < 1) {
+        cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);
+        cpx1 = out[1];
+        cpx2 = out[2];
+        x2 = out[3];
+        cubicSubdivide(y1, cpy1, cpy2, y2, percent, out);
+        cpy1 = out[1];
+        cpy2 = out[2];
+        y2 = out[3];
+      }
+      ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);
+    }
+  };
+  BezierCurve2.prototype.pointAt = function(t) {
+    return someVectorAt(this.shape, t, false);
+  };
+  BezierCurve2.prototype.tangentAt = function(t) {
+    var p = someVectorAt(this.shape, t, true);
+    return normalize(p, p);
+  };
+  return BezierCurve2;
+}(Path);
+BezierCurve.prototype.type = "bezier-curve";
+export {
+  BezierCurveShape,
+  BezierCurve as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Circle.mjs

@@ -0,0 +1,29 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+var CircleShape = /* @__PURE__ */ function() {
+  function CircleShape2() {
+    this.cx = 0;
+    this.cy = 0;
+    this.r = 0;
+  }
+  return CircleShape2;
+}();
+var Circle = function(_super) {
+  __extends(Circle2, _super);
+  function Circle2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Circle2.prototype.getDefaultShape = function() {
+    return new CircleShape();
+  };
+  Circle2.prototype.buildPath = function(ctx, shape) {
+    ctx.moveTo(shape.cx + shape.r, shape.cy);
+    ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
+  };
+  return Circle2;
+}(Path);
+Circle.prototype.type = "circle";
+export {
+  CircleShape,
+  Circle as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Ellipse.mjs

@@ -0,0 +1,41 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+var EllipseShape = /* @__PURE__ */ function() {
+  function EllipseShape2() {
+    this.cx = 0;
+    this.cy = 0;
+    this.rx = 0;
+    this.ry = 0;
+  }
+  return EllipseShape2;
+}();
+var Ellipse = function(_super) {
+  __extends(Ellipse2, _super);
+  function Ellipse2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Ellipse2.prototype.getDefaultShape = function() {
+    return new EllipseShape();
+  };
+  Ellipse2.prototype.buildPath = function(ctx, shape) {
+    var k = 0.5522848;
+    var x = shape.cx;
+    var y = shape.cy;
+    var a = shape.rx;
+    var b = shape.ry;
+    var ox = a * k;
+    var oy = b * k;
+    ctx.moveTo(x - a, y);
+    ctx.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b);
+    ctx.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y);
+    ctx.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b);
+    ctx.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y);
+    ctx.closePath();
+  };
+  return Ellipse2;
+}(Path);
+Ellipse.prototype.type = "ellipse";
+export {
+  EllipseShape,
+  Ellipse as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Line.mjs

@@ -0,0 +1,70 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+import { subPixelOptimizeLine } from "../helper/subPixelOptimize.mjs";
+var subPixelOptimizeOutputShape = {};
+var LineShape = /* @__PURE__ */ function() {
+  function LineShape2() {
+    this.x1 = 0;
+    this.y1 = 0;
+    this.x2 = 0;
+    this.y2 = 0;
+    this.percent = 1;
+  }
+  return LineShape2;
+}();
+var Line = function(_super) {
+  __extends(Line2, _super);
+  function Line2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Line2.prototype.getDefaultStyle = function() {
+    return {
+      stroke: "#000",
+      fill: null
+    };
+  };
+  Line2.prototype.getDefaultShape = function() {
+    return new LineShape();
+  };
+  Line2.prototype.buildPath = function(ctx, shape) {
+    var x1;
+    var y1;
+    var x2;
+    var y2;
+    if (this.subPixelOptimize) {
+      var optimizedShape = subPixelOptimizeLine(subPixelOptimizeOutputShape, shape, this.style);
+      x1 = optimizedShape.x1;
+      y1 = optimizedShape.y1;
+      x2 = optimizedShape.x2;
+      y2 = optimizedShape.y2;
+    } else {
+      x1 = shape.x1;
+      y1 = shape.y1;
+      x2 = shape.x2;
+      y2 = shape.y2;
+    }
+    var percent = shape.percent;
+    if (percent === 0) {
+      return;
+    }
+    ctx.moveTo(x1, y1);
+    if (percent < 1) {
+      x2 = x1 * (1 - percent) + x2 * percent;
+      y2 = y1 * (1 - percent) + y2 * percent;
+    }
+    ctx.lineTo(x2, y2);
+  };
+  Line2.prototype.pointAt = function(p) {
+    var shape = this.shape;
+    return [
+      shape.x1 * (1 - p) + shape.x2 * p,
+      shape.y1 * (1 - p) + shape.y2 * p
+    ];
+  };
+  return Line2;
+}(Path);
+Line.prototype.type = "line";
+export {
+  LineShape,
+  Line as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polygon.mjs

@@ -0,0 +1,29 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+import { buildPath } from "../helper/poly.mjs";
+var PolygonShape = /* @__PURE__ */ function() {
+  function PolygonShape2() {
+    this.points = null;
+    this.smooth = 0;
+    this.smoothConstraint = null;
+  }
+  return PolygonShape2;
+}();
+var Polygon = function(_super) {
+  __extends(Polygon2, _super);
+  function Polygon2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Polygon2.prototype.getDefaultShape = function() {
+    return new PolygonShape();
+  };
+  Polygon2.prototype.buildPath = function(ctx, shape) {
+    buildPath(ctx, shape, true);
+  };
+  return Polygon2;
+}(Path);
+Polygon.prototype.type = "polygon";
+export {
+  PolygonShape,
+  Polygon as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polyline.mjs

@@ -0,0 +1,36 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../Path.mjs";
+import { buildPath } from "../helper/poly.mjs";
+var PolylineShape = /* @__PURE__ */ function() {
+  function PolylineShape2() {
+    this.points = null;
+    this.percent = 1;
+    this.smooth = 0;
+    this.smoothConstraint = null;
+  }
+  return PolylineShape2;
+}();
+var Polyline = function(_super) {
+  __extends(Polyline2, _super);
+  function Polyline2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Polyline2.prototype.getDefaultStyle = function() {
+    return {
+      stroke: "#000",
+      fill: null
+    };
+  };
+  Polyline2.prototype.getDefaultShape = function() {
+    return new PolylineShape();
+  };
+  Polyline2.prototype.buildPath = function(ctx, shape) {
+    buildPath(ctx, shape, false);
+  };
+  return Polyline2;
+}(Path);
+Polyline.prototype.type = "polyline";
+export {
+  PolylineShape,
+  Polyline as default
+};