@fecp/mobile 1.0.79 → 1.1.1

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/path.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const PathProxy = require("../core/PathProxy.js");
+const line = require("./line.js");
+const cubic = require("./cubic.js");
+const quadratic = require("./quadratic.js");
+const arc = require("./arc.js");
+const curve = require("../core/curve.js");
+const windingLine = require("./windingLine.js");
+var CMD = PathProxy.default.CMD;
+var PI2 = Math.PI * 2;
+var EPSILON = 1e-4;
+function isAroundEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+var roots = [-1, -1, -1];
+var extrema = [-1, -1];
+function swapExtrema() {
+  var tmp = extrema[0];
+  extrema[0] = extrema[1];
+  extrema[1] = tmp;
+}
+function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {
+  if (y > y0 && y > y1 && y > y2 && y > y3 || y < y0 && y < y1 && y < y2 && y < y3) {
+    return 0;
+  }
+  var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots);
+  if (nRoots === 0) {
+    return 0;
+  } else {
+    var w = 0;
+    var nExtrema = -1;
+    var y0_ = void 0;
+    var y1_ = void 0;
+    for (var i = 0; i < nRoots; i++) {
+      var t = roots[i];
+      var unit = t === 0 || t === 1 ? 0.5 : 1;
+      var x_ = curve.cubicAt(x0, x1, x2, x3, t);
+      if (x_ < x) {
+        continue;
+      }
+      if (nExtrema < 0) {
+        nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema);
+        if (extrema[1] < extrema[0] && nExtrema > 1) {
+          swapExtrema();
+        }
+        y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]);
+        if (nExtrema > 1) {
+          y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]);
+        }
+      }
+      if (nExtrema === 2) {
+        if (t < extrema[0]) {
+          w += y0_ < y0 ? unit : -unit;
+        } else if (t < extrema[1]) {
+          w += y1_ < y0_ ? unit : -unit;
+        } else {
+          w += y3 < y1_ ? unit : -unit;
+        }
+      } else {
+        if (t < extrema[0]) {
+          w += y0_ < y0 ? unit : -unit;
+        } else {
+          w += y3 < y0_ ? unit : -unit;
+        }
+      }
+    }
+    return w;
+  }
+}
+function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {
+  if (y > y0 && y > y1 && y > y2 || y < y0 && y < y1 && y < y2) {
+    return 0;
+  }
+  var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots);
+  if (nRoots === 0) {
+    return 0;
+  } else {
+    var t = curve.quadraticExtremum(y0, y1, y2);
+    if (t >= 0 && t <= 1) {
+      var w = 0;
+      var y_ = curve.quadraticAt(y0, y1, y2, t);
+      for (var i = 0; i < nRoots; i++) {
+        var unit = roots[i] === 0 || roots[i] === 1 ? 0.5 : 1;
+        var x_ = curve.quadraticAt(x0, x1, x2, roots[i]);
+        if (x_ < x) {
+          continue;
+        }
+        if (roots[i] < t) {
+          w += y_ < y0 ? unit : -unit;
+        } else {
+          w += y2 < y_ ? unit : -unit;
+        }
+      }
+      return w;
+    } else {
+      var unit = roots[0] === 0 || roots[0] === 1 ? 0.5 : 1;
+      var x_ = curve.quadraticAt(x0, x1, x2, roots[0]);
+      if (x_ < x) {
+        return 0;
+      }
+      return y2 < y0 ? unit : -unit;
+    }
+  }
+}
+function windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {
+  y -= cy;
+  if (y > r || y < -r) {
+    return 0;
+  }
+  var tmp = Math.sqrt(r * r - y * y);
+  roots[0] = -tmp;
+  roots[1] = tmp;
+  var dTheta = Math.abs(startAngle - endAngle);
+  if (dTheta < 1e-4) {
+    return 0;
+  }
+  if (dTheta >= PI2 - 1e-4) {
+    startAngle = 0;
+    endAngle = PI2;
+    var dir = anticlockwise ? 1 : -1;
+    if (x >= roots[0] + cx && x <= roots[1] + cx) {
+      return dir;
+    } else {
+      return 0;
+    }
+  }
+  if (startAngle > endAngle) {
+    var tmp_1 = startAngle;
+    startAngle = endAngle;
+    endAngle = tmp_1;
+  }
+  if (startAngle < 0) {
+    startAngle += PI2;
+    endAngle += PI2;
+  }
+  var w = 0;
+  for (var i = 0; i < 2; i++) {
+    var x_ = roots[i];
+    if (x_ + cx > x) {
+      var angle = Math.atan2(y, x_);
+      var dir = anticlockwise ? 1 : -1;
+      if (angle < 0) {
+        angle = PI2 + angle;
+      }
+      if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {
+        if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {
+          dir = -dir;
+        }
+        w += dir;
+      }
+    }
+  }
+  return w;
+}
+function containPath(path, lineWidth, isStroke, x, y) {
+  var data = path.data;
+  var len = path.len();
+  var w = 0;
+  var xi = 0;
+  var yi = 0;
+  var x0 = 0;
+  var y0 = 0;
+  var x1;
+  var y1;
+  for (var i = 0; i < len; ) {
+    var cmd = data[i++];
+    var isFirst = i === 1;
+    if (cmd === CMD.M && i > 1) {
+      if (!isStroke) {
+        w += windingLine.default(xi, yi, x0, y0, x, y);
+      }
+    }
+    if (isFirst) {
+      xi = data[i];
+      yi = data[i + 1];
+      x0 = xi;
+      y0 = yi;
+    }
+    switch (cmd) {
+      case CMD.M:
+        x0 = data[i++];
+        y0 = data[i++];
+        xi = x0;
+        yi = y0;
+        break;
+      case CMD.L:
+        if (isStroke) {
+          if (line.containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {
+            return true;
+          }
+        } else {
+          w += windingLine.default(xi, yi, data[i], data[i + 1], x, y) || 0;
+        }
+        xi = data[i++];
+        yi = data[i++];
+        break;
+      case CMD.C:
+        if (isStroke) {
+          if (cubic.containStroke(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+            return true;
+          }
+        } else {
+          w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+        }
+        xi = data[i++];
+        yi = data[i++];
+        break;
+      case CMD.Q:
+        if (isStroke) {
+          if (quadratic.containStroke(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+            return true;
+          }
+        } else {
+          w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+        }
+        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 (!isFirst) {
+          w += windingLine.default(xi, yi, x1, y1, x, y);
+        } else {
+          x0 = x1;
+          y0 = y1;
+        }
+        var _x = (x - cx) * ry / rx + cx;
+        if (isStroke) {
+          if (arc.containStroke(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {
+            return true;
+          }
+        } else {
+          w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);
+        }
+        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++];
+        x1 = x0 + width;
+        y1 = y0 + height;
+        if (isStroke) {
+          if (line.containStroke(x0, y0, x1, y0, lineWidth, x, y) || line.containStroke(x1, y0, x1, y1, lineWidth, x, y) || line.containStroke(x1, y1, x0, y1, lineWidth, x, y) || line.containStroke(x0, y1, x0, y0, lineWidth, x, y)) {
+            return true;
+          }
+        } else {
+          w += windingLine.default(x1, y0, x1, y1, x, y);
+          w += windingLine.default(x0, y1, x0, y0, x, y);
+        }
+        break;
+      case CMD.Z:
+        if (isStroke) {
+          if (line.containStroke(xi, yi, x0, y0, lineWidth, x, y)) {
+            return true;
+          }
+        } else {
+          w += windingLine.default(xi, yi, x0, y0, x, y);
+        }
+        xi = x0;
+        yi = y0;
+        break;
+    }
+  }
+  if (!isStroke && !isAroundEqual(yi, y0)) {
+    w += windingLine.default(xi, yi, x0, y0, x, y) || 0;
+  }
+  return w !== 0;
+}
+function contain(pathProxy, x, y) {
+  return containPath(pathProxy, 0, false, x, y);
+}
+function containStroke(pathProxy, lineWidth, x, y) {
+  return containPath(pathProxy, lineWidth, true, x, y);
+}
+exports.contain = contain;
+exports.containStroke = containStroke;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/polygon.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const windingLine = require("./windingLine.js");
+var EPSILON = 1e-8;
+function isAroundEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+function contain(points, x, y) {
+  var w = 0;
+  var p = points[0];
+  if (!p) {
+    return false;
+  }
+  for (var i = 1; i < points.length; i++) {
+    var p2 = points[i];
+    w += windingLine.default(p[0], p[1], p2[0], p2[1], x, y);
+    p = p2;
+  }
+  var p0 = points[0];
+  if (!isAroundEqual(p[0], p0[0]) || !isAroundEqual(p[1], p0[1])) {
+    w += windingLine.default(p[0], p[1], p0[0], p0[1], x, y);
+  }
+  return w !== 0;
+}
+exports.contain = contain;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/quadratic.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const curve = require("../core/curve.js");
+function containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
+  }
+  var _l = lineWidth;
+  if (y > y0 + _l && y > y1 + _l && y > y2 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l) {
+    return false;
+  }
+  var d = curve.quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);
+  return d <= _l / 2;
+}
+exports.containStroke = containStroke;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/text.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BoundingRect = require("../core/BoundingRect.js");
+const LRU = require("../core/LRU.js");
+const platform = require("../core/platform.js");
+var textWidthCache = {};
+function getWidth(text, font) {
+  font = font || platform.DEFAULT_FONT;
+  var cacheOfFont = textWidthCache[font];
+  if (!cacheOfFont) {
+    cacheOfFont = textWidthCache[font] = new LRU.default(500);
+  }
+  var width = cacheOfFont.get(text);
+  if (width == null) {
+    width = platform.platformApi.measureText(text, font).width;
+    cacheOfFont.put(text, width);
+  }
+  return width;
+}
+function innerGetBoundingRect(text, font, textAlign, textBaseline) {
+  var width = getWidth(text, font);
+  var height = getLineHeight(font);
+  var x = adjustTextX(0, width, textAlign);
+  var y = adjustTextY(0, height, textBaseline);
+  var rect = new BoundingRect.default(x, y, width, height);
+  return rect;
+}
+function getBoundingRect(text, font, textAlign, textBaseline) {
+  var textLines = ((text || "") + "").split("\n");
+  var len = textLines.length;
+  if (len === 1) {
+    return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline);
+  } else {
+    var uniondRect = new BoundingRect.default(0, 0, 0, 0);
+    for (var i = 0; i < textLines.length; i++) {
+      var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline);
+      i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect);
+    }
+    return uniondRect;
+  }
+}
+function adjustTextX(x, width, textAlign) {
+  if (textAlign === "right") {
+    x -= width;
+  } else if (textAlign === "center") {
+    x -= width / 2;
+  }
+  return x;
+}
+function adjustTextY(y, height, verticalAlign) {
+  if (verticalAlign === "middle") {
+    y -= height / 2;
+  } else if (verticalAlign === "bottom") {
+    y -= height;
+  }
+  return y;
+}
+function getLineHeight(font) {
+  return getWidth("国", font);
+}
+function parsePercent(value, maxValue) {
+  if (typeof value === "string") {
+    if (value.lastIndexOf("%") >= 0) {
+      return parseFloat(value) / 100 * maxValue;
+    }
+    return parseFloat(value);
+  }
+  return value;
+}
+function calculateTextPosition(out, opts, rect) {
+  var textPosition = opts.position || "inside";
+  var distance = opts.distance != null ? opts.distance : 5;
+  var height = rect.height;
+  var width = rect.width;
+  var halfHeight = height / 2;
+  var x = rect.x;
+  var y = rect.y;
+  var textAlign = "left";
+  var textVerticalAlign = "top";
+  if (textPosition instanceof Array) {
+    x += parsePercent(textPosition[0], rect.width);
+    y += parsePercent(textPosition[1], rect.height);
+    textAlign = null;
+    textVerticalAlign = null;
+  } else {
+    switch (textPosition) {
+      case "left":
+        x -= distance;
+        y += halfHeight;
+        textAlign = "right";
+        textVerticalAlign = "middle";
+        break;
+      case "right":
+        x += distance + width;
+        y += halfHeight;
+        textVerticalAlign = "middle";
+        break;
+      case "top":
+        x += width / 2;
+        y -= distance;
+        textAlign = "center";
+        textVerticalAlign = "bottom";
+        break;
+      case "bottom":
+        x += width / 2;
+        y += height + distance;
+        textAlign = "center";
+        break;
+      case "inside":
+        x += width / 2;
+        y += halfHeight;
+        textAlign = "center";
+        textVerticalAlign = "middle";
+        break;
+      case "insideLeft":
+        x += distance;
+        y += halfHeight;
+        textVerticalAlign = "middle";
+        break;
+      case "insideRight":
+        x += width - distance;
+        y += halfHeight;
+        textAlign = "right";
+        textVerticalAlign = "middle";
+        break;
+      case "insideTop":
+        x += width / 2;
+        y += distance;
+        textAlign = "center";
+        break;
+      case "insideBottom":
+        x += width / 2;
+        y += height - distance;
+        textAlign = "center";
+        textVerticalAlign = "bottom";
+        break;
+      case "insideTopLeft":
+        x += distance;
+        y += distance;
+        break;
+      case "insideTopRight":
+        x += width - distance;
+        y += distance;
+        textAlign = "right";
+        break;
+      case "insideBottomLeft":
+        x += distance;
+        y += height - distance;
+        textVerticalAlign = "bottom";
+        break;
+      case "insideBottomRight":
+        x += width - distance;
+        y += height - distance;
+        textAlign = "right";
+        textVerticalAlign = "bottom";
+        break;
+    }
+  }
+  out = out || {};
+  out.x = x;
+  out.y = y;
+  out.align = textAlign;
+  out.verticalAlign = textVerticalAlign;
+  return out;
+}
+exports.adjustTextX = adjustTextX;
+exports.adjustTextY = adjustTextY;
+exports.calculateTextPosition = calculateTextPosition;
+exports.getBoundingRect = getBoundingRect;
+exports.getLineHeight = getLineHeight;
+exports.getWidth = getWidth;
+exports.innerGetBoundingRect = innerGetBoundingRect;
+exports.parsePercent = parsePercent;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var PI2 = Math.PI * 2;
+function normalizeRadian(angle) {
+  angle %= PI2;
+  if (angle < 0) {
+    angle += PI2;
+  }
+  return angle;
+}
+exports.normalizeRadian = normalizeRadian;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/contain/windingLine.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function windingLine(x0, y0, x1, y1, x, y) {
+  if (y > y0 && y > y1 || y < y0 && y < y1) {
+    return 0;
+  }
+  if (y1 === y0) {
+    return 0;
+  }
+  var t = (y - y0) / (y1 - y0);
+  var dir = y1 < y0 ? 1 : -1;
+  if (t === 1 || t === 0) {
+    dir = y1 < y0 ? 0.5 : -0.5;
+  }
+  var x_ = t * (x1 - x0) + x0;
+  return x_ === x ? Infinity : x_ > x ? dir : 0;
+}
+exports.default = windingLine;