@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/graphic.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/tool/path.js");
+const matrix = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.js");
+const vector = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/vector.js");
+const Path = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Path.js");
+const Transformable = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/Transformable.js");
+const Image = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Image.js");
+const Group = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+const Text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.js");
+const Circle = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Circle.js");
+const Ellipse = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Ellipse.js");
+const Sector = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Sector.js");
+const Ring = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Ring.js");
+const Polygon = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polygon.js");
+const Polyline = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polyline.js");
+const Rect = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.js");
+const Line = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Line.js");
+const BezierCurve = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/BezierCurve.js");
+const Arc = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Arc.js");
+const CompoundPath = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/CompoundPath.js");
+const LinearGradient = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/LinearGradient.js");
+const RadialGradient = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/RadialGradient.js");
+const BoundingRect = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.js");
+const OrientedBoundingRect = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/OrientedBoundingRect.js");
+const Point = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/Point.js");
+const IncrementalDisplayable = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/IncrementalDisplayable.js");
+const subPixelOptimize$1 = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/helper/subPixelOptimize.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const innerStore = require("./innerStore.js");
+const basicTransition = require("../animation/basicTransition.js");
+var mathMax = Math.max;
+var mathMin = Math.min;
+var _customShapeMap = {};
+function extendShape(opts) {
+  return Path.default.extend(opts);
+}
+var extendPathFromString = path.extendFromString;
+function extendPath(pathData, opts) {
+  return extendPathFromString(pathData, opts);
+}
+function registerShape(name, ShapeClass) {
+  _customShapeMap[name] = ShapeClass;
+}
+function getShapeClass(name) {
+  if (_customShapeMap.hasOwnProperty(name)) {
+    return _customShapeMap[name];
+  }
+}
+function makePath(pathData, opts, rect, layout) {
+  var path$1 = path.createFromString(pathData, opts);
+  if (rect) {
+    if (layout === "center") {
+      rect = centerGraphic(rect, path$1.getBoundingRect());
+    }
+    resizePath(path$1, rect);
+  }
+  return path$1;
+}
+function makeImage(imageUrl, rect, layout) {
+  var zrImg = new Image.default({
+    style: {
+      image: imageUrl,
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height
+    },
+    onload: function(img) {
+      if (layout === "center") {
+        var boundingRect = {
+          width: img.width,
+          height: img.height
+        };
+        zrImg.setStyle(centerGraphic(rect, boundingRect));
+      }
+    }
+  });
+  return zrImg;
+}
+function centerGraphic(rect, boundingRect) {
+  var aspect = boundingRect.width / boundingRect.height;
+  var width = rect.height * aspect;
+  var height;
+  if (width <= rect.width) {
+    height = rect.height;
+  } else {
+    width = rect.width;
+    height = width / aspect;
+  }
+  var cx = rect.x + rect.width / 2;
+  var cy = rect.y + rect.height / 2;
+  return {
+    x: cx - width / 2,
+    y: cy - height / 2,
+    width,
+    height
+  };
+}
+var mergePath = path.mergePath;
+function resizePath(path2, rect) {
+  if (!path2.applyTransform) {
+    return;
+  }
+  var pathRect = path2.getBoundingRect();
+  var m = pathRect.calculateTransform(rect);
+  path2.applyTransform(m);
+}
+function subPixelOptimizeLine(shape, lineWidth) {
+  subPixelOptimize$1.subPixelOptimizeLine(shape, shape, {
+    lineWidth
+  });
+  return shape;
+}
+function subPixelOptimizeRect(param) {
+  subPixelOptimize$1.subPixelOptimizeRect(param.shape, param.shape, param.style);
+  return param;
+}
+var subPixelOptimize = subPixelOptimize$1.subPixelOptimize;
+function getTransform(target, ancestor) {
+  var mat = matrix.identity([]);
+  while (target && target !== ancestor) {
+    matrix.mul(mat, target.getLocalTransform(), mat);
+    target = target.parent;
+  }
+  return mat;
+}
+function applyTransform(target, transform, invert) {
+  if (transform && !util.isArrayLike(transform)) {
+    transform = Transformable.default.getLocalTransform(transform);
+  }
+  if (invert) {
+    transform = matrix.invert([], transform);
+  }
+  return vector.applyTransform([], target, transform);
+}
+function transformDirection(direction, transform, invert) {
+  var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);
+  var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);
+  var vertex = [direction === "left" ? -hBase : direction === "right" ? hBase : 0, direction === "top" ? -vBase : direction === "bottom" ? vBase : 0];
+  vertex = applyTransform(vertex, transform, invert);
+  return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? "right" : "left" : vertex[1] > 0 ? "bottom" : "top";
+}
+function isNotGroup(el) {
+  return !el.isGroup;
+}
+function isPath(el) {
+  return el.shape != null;
+}
+function groupTransition(g1, g2, animatableModel) {
+  if (!g1 || !g2) {
+    return;
+  }
+  function getElMap(g) {
+    var elMap = {};
+    g.traverse(function(el) {
+      if (isNotGroup(el) && el.anid) {
+        elMap[el.anid] = el;
+      }
+    });
+    return elMap;
+  }
+  function getAnimatableProps(el) {
+    var obj = {
+      x: el.x,
+      y: el.y,
+      rotation: el.rotation
+    };
+    if (isPath(el)) {
+      obj.shape = util.extend({}, el.shape);
+    }
+    return obj;
+  }
+  var elMap1 = getElMap(g1);
+  g2.traverse(function(el) {
+    if (isNotGroup(el) && el.anid) {
+      var oldEl = elMap1[el.anid];
+      if (oldEl) {
+        var newProp = getAnimatableProps(el);
+        el.attr(getAnimatableProps(oldEl));
+        basicTransition.updateProps(el, newProp, animatableModel, innerStore.getECData(el).dataIndex);
+      }
+    }
+  });
+}
+function clipPointsByRect(points, rect) {
+  return util.map(points, function(point) {
+    var x = point[0];
+    x = mathMax(x, rect.x);
+    x = mathMin(x, rect.x + rect.width);
+    var y = point[1];
+    y = mathMax(y, rect.y);
+    y = mathMin(y, rect.y + rect.height);
+    return [x, y];
+  });
+}
+function clipRectByRect(targetRect, rect) {
+  var x = mathMax(targetRect.x, rect.x);
+  var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);
+  var y = mathMax(targetRect.y, rect.y);
+  var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height);
+  if (x2 >= x && y2 >= y) {
+    return {
+      x,
+      y,
+      width: x2 - x,
+      height: y2 - y
+    };
+  }
+}
+function createIcon(iconStr, opt, rect) {
+  var innerOpts = util.extend({
+    rectHover: true
+  }, opt);
+  var style = innerOpts.style = {
+    strokeNoScale: true
+  };
+  rect = rect || {
+    x: -1,
+    y: -1,
+    width: 2,
+    height: 2
+  };
+  if (iconStr) {
+    return iconStr.indexOf("image://") === 0 ? (style.image = iconStr.slice(8), util.defaults(style, rect), new Image.default(innerOpts)) : makePath(iconStr.replace("path://", ""), innerOpts, rect, "center");
+  }
+}
+function linePolygonIntersect(a1x, a1y, a2x, a2y, points) {
+  for (var i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
+    var p = points[i];
+    if (lineLineIntersect(a1x, a1y, a2x, a2y, p[0], p[1], p2[0], p2[1])) {
+      return true;
+    }
+    p2 = p;
+  }
+}
+function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+  var mx = a2x - a1x;
+  var my = a2y - a1y;
+  var nx = b2x - b1x;
+  var ny = b2y - b1y;
+  var nmCrossProduct = crossProduct2d(nx, ny, mx, my);
+  if (nearZero(nmCrossProduct)) {
+    return false;
+  }
+  var b1a1x = a1x - b1x;
+  var b1a1y = a1y - b1y;
+  var q = crossProduct2d(b1a1x, b1a1y, mx, my) / nmCrossProduct;
+  if (q < 0 || q > 1) {
+    return false;
+  }
+  var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;
+  if (p < 0 || p > 1) {
+    return false;
+  }
+  return true;
+}
+function crossProduct2d(x1, y1, x2, y2) {
+  return x1 * y2 - x2 * y1;
+}
+function nearZero(val) {
+  return val <= 1e-6 && val >= -1e-6;
+}
+function setTooltipConfig(opt) {
+  var itemTooltipOption = opt.itemTooltipOption;
+  var componentModel = opt.componentModel;
+  var itemName = opt.itemName;
+  var itemTooltipOptionObj = util.isString(itemTooltipOption) ? {
+    formatter: itemTooltipOption
+  } : itemTooltipOption;
+  var mainType = componentModel.mainType;
+  var componentIndex = componentModel.componentIndex;
+  var formatterParams = {
+    componentType: mainType,
+    name: itemName,
+    $vars: ["name"]
+  };
+  formatterParams[mainType + "Index"] = componentIndex;
+  var formatterParamsExtra = opt.formatterParamsExtra;
+  if (formatterParamsExtra) {
+    util.each(util.keys(formatterParamsExtra), function(key) {
+      if (!util.hasOwn(formatterParams, key)) {
+        formatterParams[key] = formatterParamsExtra[key];
+        formatterParams.$vars.push(key);
+      }
+    });
+  }
+  var ecData = innerStore.getECData(opt.el);
+  ecData.componentMainType = mainType;
+  ecData.componentIndex = componentIndex;
+  ecData.tooltipConfig = {
+    name: itemName,
+    option: util.defaults({
+      content: itemName,
+      encodeHTMLContent: true,
+      formatterParams
+    }, itemTooltipOptionObj)
+  };
+}
+function traverseElement(el, cb) {
+  var stopped;
+  if (el.isGroup) {
+    stopped = cb(el);
+  }
+  if (!stopped) {
+    el.traverse(cb);
+  }
+}
+function traverseElements(els, cb) {
+  if (els) {
+    if (util.isArray(els)) {
+      for (var i = 0; i < els.length; i++) {
+        traverseElement(els[i], cb);
+      }
+    } else {
+      traverseElement(els, cb);
+    }
+  }
+}
+registerShape("circle", Circle.default);
+registerShape("ellipse", Ellipse.default);
+registerShape("sector", Sector.default);
+registerShape("ring", Ring.default);
+registerShape("polygon", Polygon.default);
+registerShape("polyline", Polyline.default);
+registerShape("rect", Rect.default);
+registerShape("line", Line.default);
+registerShape("bezierCurve", BezierCurve.default);
+registerShape("arc", Arc.default);
+exports.Path = Path.default;
+exports.Image = Image.default;
+exports.Group = Group.default;
+exports.Text = Text.default;
+exports.Circle = Circle.default;
+exports.Ellipse = Ellipse.default;
+exports.Sector = Sector.default;
+exports.Ring = Ring.default;
+exports.Polygon = Polygon.default;
+exports.Polyline = Polyline.default;
+exports.Rect = Rect.default;
+exports.Line = Line.default;
+exports.BezierCurve = BezierCurve.default;
+exports.Arc = Arc.default;
+exports.CompoundPath = CompoundPath.default;
+exports.LinearGradient = LinearGradient.default;
+exports.RadialGradient = RadialGradient.default;
+exports.BoundingRect = BoundingRect.default;
+exports.OrientedBoundingRect = OrientedBoundingRect.default;
+exports.Point = Point.default;
+exports.IncrementalDisplayable = IncrementalDisplayable.default;
+exports.initProps = basicTransition.initProps;
+exports.isElementRemoved = basicTransition.isElementRemoved;
+exports.removeElement = basicTransition.removeElement;
+exports.removeElementWithFadeOut = basicTransition.removeElementWithFadeOut;
+exports.updateProps = basicTransition.updateProps;
+exports.applyTransform = applyTransform;
+exports.clipPointsByRect = clipPointsByRect;
+exports.clipRectByRect = clipRectByRect;
+exports.createIcon = createIcon;
+exports.extendPath = extendPath;
+exports.extendShape = extendShape;
+exports.getShapeClass = getShapeClass;
+exports.getTransform = getTransform;
+exports.groupTransition = groupTransition;
+exports.lineLineIntersect = lineLineIntersect;
+exports.linePolygonIntersect = linePolygonIntersect;
+exports.makeImage = makeImage;
+exports.makePath = makePath;
+exports.mergePath = mergePath;
+exports.registerShape = registerShape;
+exports.resizePath = resizePath;
+exports.setTooltipConfig = setTooltipConfig;
+exports.subPixelOptimize = subPixelOptimize;
+exports.subPixelOptimizeLine = subPixelOptimizeLine;
+exports.subPixelOptimizeRect = subPixelOptimizeRect;
+exports.transformDirection = transformDirection;
+exports.traverseElements = traverseElements;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/innerStore.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const model = require("./model.js");
+var getECData = model.makeInner();
+var setCommonECData = function(seriesIndex, dataType, dataIdx, el) {
+  if (el) {
+    var ecData = getECData(el);
+    ecData.dataIndex = dataIdx;
+    ecData.dataType = dataType;
+    ecData.seriesIndex = seriesIndex;
+    ecData.ssrType = "chart";
+    if (el.type === "group") {
+      el.traverse(function(child) {
+        var childECData = getECData(child);
+        childECData.seriesIndex = seriesIndex;
+        childECData.dataIndex = dataIdx;
+        childECData.dataType = dataType;
+        childECData.ssrType = "chart";
+      });
+    }
+  }
+};
+exports.getECData = getECData;
+exports.setCommonECData = setCommonECData;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/layout.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const BoundingRect = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.js");
+const number = require("./number.js");
+const format = require("./format.js");
+var each = util.each;
+var LOCATION_PARAMS = ["left", "right", "top", "bottom", "width", "height"];
+var HV_NAMES = [["width", "left", "right"], ["height", "top", "bottom"]];
+function boxLayout(orient, group, gap, maxWidth, maxHeight) {
+  var x = 0;
+  var y = 0;
+  if (maxWidth == null) {
+    maxWidth = Infinity;
+  }
+  if (maxHeight == null) {
+    maxHeight = Infinity;
+  }
+  var currentLineMaxSize = 0;
+  group.eachChild(function(child, idx) {
+    var rect = child.getBoundingRect();
+    var nextChild = group.childAt(idx + 1);
+    var nextChildRect = nextChild && nextChild.getBoundingRect();
+    var nextX;
+    var nextY;
+    if (orient === "horizontal") {
+      var moveX = rect.width + (nextChildRect ? -nextChildRect.x + rect.x : 0);
+      nextX = x + moveX;
+      if (nextX > maxWidth || child.newline) {
+        x = 0;
+        nextX = moveX;
+        y += currentLineMaxSize + gap;
+        currentLineMaxSize = rect.height;
+      } else {
+        currentLineMaxSize = Math.max(currentLineMaxSize, rect.height);
+      }
+    } else {
+      var moveY = rect.height + (nextChildRect ? -nextChildRect.y + rect.y : 0);
+      nextY = y + moveY;
+      if (nextY > maxHeight || child.newline) {
+        x += currentLineMaxSize + gap;
+        y = 0;
+        nextY = moveY;
+        currentLineMaxSize = rect.width;
+      } else {
+        currentLineMaxSize = Math.max(currentLineMaxSize, rect.width);
+      }
+    }
+    if (child.newline) {
+      return;
+    }
+    child.x = x;
+    child.y = y;
+    child.markRedraw();
+    orient === "horizontal" ? x = nextX + gap : y = nextY + gap;
+  });
+}
+var box = boxLayout;
+util.curry(boxLayout, "vertical");
+util.curry(boxLayout, "horizontal");
+function getLayoutRect(positionInfo, containerRect, margin) {
+  margin = format.normalizeCssArray(margin || 0);
+  var containerWidth = containerRect.width;
+  var containerHeight = containerRect.height;
+  var left = number.parsePercent(positionInfo.left, containerWidth);
+  var top = number.parsePercent(positionInfo.top, containerHeight);
+  var right = number.parsePercent(positionInfo.right, containerWidth);
+  var bottom = number.parsePercent(positionInfo.bottom, containerHeight);
+  var width = number.parsePercent(positionInfo.width, containerWidth);
+  var height = number.parsePercent(positionInfo.height, containerHeight);
+  var verticalMargin = margin[2] + margin[0];
+  var horizontalMargin = margin[1] + margin[3];
+  var aspect = positionInfo.aspect;
+  if (isNaN(width)) {
+    width = containerWidth - right - horizontalMargin - left;
+  }
+  if (isNaN(height)) {
+    height = containerHeight - bottom - verticalMargin - top;
+  }
+  if (aspect != null) {
+    if (isNaN(width) && isNaN(height)) {
+      if (aspect > containerWidth / containerHeight) {
+        width = containerWidth * 0.8;
+      } else {
+        height = containerHeight * 0.8;
+      }
+    }
+    if (isNaN(width)) {
+      width = aspect * height;
+    }
+    if (isNaN(height)) {
+      height = width / aspect;
+    }
+  }
+  if (isNaN(left)) {
+    left = containerWidth - right - width - horizontalMargin;
+  }
+  if (isNaN(top)) {
+    top = containerHeight - bottom - height - verticalMargin;
+  }
+  switch (positionInfo.left || positionInfo.right) {
+    case "center":
+      left = containerWidth / 2 - width / 2 - margin[3];
+      break;
+    case "right":
+      left = containerWidth - width - horizontalMargin;
+      break;
+  }
+  switch (positionInfo.top || positionInfo.bottom) {
+    case "middle":
+    case "center":
+      top = containerHeight / 2 - height / 2 - margin[0];
+      break;
+    case "bottom":
+      top = containerHeight - height - verticalMargin;
+      break;
+  }
+  left = left || 0;
+  top = top || 0;
+  if (isNaN(width)) {
+    width = containerWidth - horizontalMargin - left - (right || 0);
+  }
+  if (isNaN(height)) {
+    height = containerHeight - verticalMargin - top - (bottom || 0);
+  }
+  var rect = new BoundingRect.default(left + margin[3], top + margin[0], width, height);
+  rect.margin = margin;
+  return rect;
+}
+function fetchLayoutMode(ins) {
+  var layoutMode = ins.layoutMode || ins.constructor.layoutMode;
+  return util.isObject(layoutMode) ? layoutMode : layoutMode ? {
+    type: layoutMode
+  } : null;
+}
+function mergeLayoutParam(targetOption, newOption, opt) {
+  var ignoreSize = opt && opt.ignoreSize;
+  !util.isArray(ignoreSize) && (ignoreSize = [ignoreSize, ignoreSize]);
+  var hResult = merge(HV_NAMES[0], 0);
+  var vResult = merge(HV_NAMES[1], 1);
+  copy(HV_NAMES[0], targetOption, hResult);
+  copy(HV_NAMES[1], targetOption, vResult);
+  function merge(names, hvIdx) {
+    var newParams = {};
+    var newValueCount = 0;
+    var merged = {};
+    var mergedValueCount = 0;
+    var enoughParamNumber = 2;
+    each(names, function(name) {
+      merged[name] = targetOption[name];
+    });
+    each(names, function(name) {
+      hasProp(newOption, name) && (newParams[name] = merged[name] = newOption[name]);
+      hasValue(newParams, name) && newValueCount++;
+      hasValue(merged, name) && mergedValueCount++;
+    });
+    if (ignoreSize[hvIdx]) {
+      if (hasValue(newOption, names[1])) {
+        merged[names[2]] = null;
+      } else if (hasValue(newOption, names[2])) {
+        merged[names[1]] = null;
+      }
+      return merged;
+    }
+    if (mergedValueCount === enoughParamNumber || !newValueCount) {
+      return merged;
+    } else if (newValueCount >= enoughParamNumber) {
+      return newParams;
+    } else {
+      for (var i = 0; i < names.length; i++) {
+        var name_1 = names[i];
+        if (!hasProp(newParams, name_1) && hasProp(targetOption, name_1)) {
+          newParams[name_1] = targetOption[name_1];
+          break;
+        }
+      }
+      return newParams;
+    }
+  }
+  function hasProp(obj, name) {
+    return obj.hasOwnProperty(name);
+  }
+  function hasValue(obj, name) {
+    return obj[name] != null && obj[name] !== "auto";
+  }
+  function copy(names, target, source) {
+    each(names, function(name) {
+      target[name] = source[name];
+    });
+  }
+}
+function getLayoutParams(source) {
+  return copyLayoutParams({}, source);
+}
+function copyLayoutParams(target, source) {
+  source && target && each(LOCATION_PARAMS, function(name) {
+    source.hasOwnProperty(name) && (target[name] = source[name]);
+  });
+  return target;
+}
+exports.HV_NAMES = HV_NAMES;
+exports.LOCATION_PARAMS = LOCATION_PARAMS;
+exports.box = box;
+exports.copyLayoutParams = copyLayoutParams;
+exports.fetchLayoutMode = fetchLayoutMode;
+exports.getLayoutParams = getLayoutParams;
+exports.getLayoutRect = getLayoutRect;
+exports.mergeLayoutParam = mergeLayoutParam;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function throwError(msg) {
+  throw new Error(msg);
+}
+exports.throwError = throwError;