@visactor/vue-vtable 1.17.1 → 1.17.2

package/dist/vue-vtable.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@visactor/vtable'), require('vue'), require('@visactor/vutils')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@visactor/vtable', 'vue', '@visactor/vutils'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueVTable = {}, global.VTable, global.vue, global.vutils));
-})(this, (function (exports, VTable, vue, vutils) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@visactor/vtable'), require('vue'), require('@visactor/vutils'), require('@visactor/vtable/es/vrender')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@visactor/vtable', 'vue', '@visactor/vutils', '@visactor/vtable/es/vrender'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueVTable = {}, global.VTable, global.Vue, global.VUtils, global.VTable.vrender));
+})(this, (function (exports, VTable, vue, vutils, vrender) { 'use strict';
 
   function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -515,1791 +515,7 @@
       }
   }
 
-  class Generator {
-    static GenAutoIncrementId() {
-      return Generator.auto_increment_id++;
-    }
-  }
-  Generator.auto_increment_id = 0;
-
-  var MeasureModeEnum;
-  !function (MeasureModeEnum) {
-    MeasureModeEnum[MeasureModeEnum.estimate = 0] = "estimate", MeasureModeEnum[MeasureModeEnum.actualBounding = 1] = "actualBounding", MeasureModeEnum[MeasureModeEnum.fontBounding = 2] = "fontBounding";
-  }(MeasureModeEnum || (MeasureModeEnum = {}));
-
-  const circleThreshold = vutils.tau - 1e-8;
-  class BoundsContext {
-    constructor(bounds) {
-      this.init(bounds);
-    }
-    init(bounds) {
-      this.bounds = bounds;
-    }
-    arc(cx, cy, r, sa, ea, ccw) {
-      if (Math.abs(ea - sa) > circleThreshold) return this.bounds.add(cx - r, cy - r), void this.bounds.add(cx + r, cy + r);
-      let s,
-        i,
-        x,
-        y,
-        xmin = 1 / 0,
-        xmax = -1 / 0,
-        ymin = 1 / 0,
-        ymax = -1 / 0;
-      function update(a) {
-        x = r * Math.cos(a), y = r * Math.sin(a), x < xmin && (xmin = x), x > xmax && (xmax = x), y < ymin && (ymin = y), y > ymax && (ymax = y);
-      }
-      if (update(sa), update(ea), ea !== sa) if ((sa %= vutils.tau) < 0 && (sa += vutils.tau), (ea %= vutils.tau) < 0 && (ea += vutils.tau), ea < sa && (ccw = !ccw, s = sa, sa = ea, ea = s), ccw) for (ea -= vutils.tau, s = sa - sa % vutils.halfPi, i = 0; i < 4 && s > ea; ++i, s -= vutils.halfPi) update(s);else for (s = sa - sa % vutils.halfPi + vutils.halfPi, i = 0; i < 4 && s < ea; ++i, s += vutils.halfPi) update(s);
-      this.bounds.add(cx + xmin, cy + ymin), this.bounds.add(cx + xmax, cy + ymax);
-    }
-    arcTo(x1, y1, x2, y2, radius) {
-      this.bounds.add(x1, y1);
-    }
-    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
-      this.bounds.add(cp1x, cp1y), this.bounds.add(cp2x, cp2y), this.bounds.add(x, y);
-    }
-    closePath() {}
-    ellipse() {
-      throw new Error("不支持ellipse");
-    }
-    lineTo(x, y) {
-      this.bounds.add(x, y);
-    }
-    moveTo(x, y) {
-      this.bounds.add(x, y);
-    }
-    quadraticCurveTo(cpx, cpy, x, y) {
-      this.bounds.add(cpx, cpy), this.bounds.add(x, y);
-    }
-    rect(x, y, w, h) {
-      this.bounds.add(x, y), this.bounds.add(x + w, y + h);
-    }
-    clear() {
-      this.bounds.clear();
-    }
-    release() {}
-  }
-
-  class CurvePath {
-    constructor() {
-      this.curves = [], this.bounds = new vutils.AABBBounds();
-    }
-    getCurveLengths() {
-      return this.curves.map(curve => curve.getLength());
-    }
-    getPointAt(t) {
-      return {
-        x: 0,
-        y: 0
-      };
-    }
-    getLength() {
-      return 0;
-    }
-    getBounds() {
-      return this.bounds;
-    }
-  }
-
-  const rePathCommand = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:[eE][-+]?\d+)?)/gi,
-    commandLengths = {
-      m: 2,
-      l: 2,
-      h: 1,
-      v: 1,
-      c: 6,
-      s: 4,
-      q: 4,
-      t: 2,
-      a: 7,
-      M: 2,
-      L: 2,
-      H: 1,
-      V: 1,
-      C: 6,
-      S: 4,
-      Q: 4,
-      T: 2,
-      A: 7
-    };
-  const enumCommandMap = {
-    A: 0,
-    AT: 1,
-    C: 2,
-    Z: 3,
-    E: 4,
-    L: 5,
-    M: 6,
-    Q: 7,
-    R: 8
-  };
-  let currPath, coordsStr, commandChar, coordStr, coordNumber, standardCommandLen;
-  function parseSvgPath(str) {
-    if (!str) return [];
-    const paths = str.match(/[mzlhvcsqta][^mzlhvcsqta]*/gi);
-    if (null === paths) return [];
-    let currCommandData, coordsStrArr;
-    const result = [];
-    for (let i = 0, len = paths.length; i < len; i++) if (currPath = paths[i], coordsStr = currPath.slice(1), commandChar = currPath[0], currCommandData = [commandChar], coordsStrArr = coordsStr.match(rePathCommand), null !== coordsStrArr) {
-      for (let i = 0, len = coordsStrArr.length; i < len; i++) coordStr = coordsStrArr[i], coordNumber = parseFloat(coordStr), Number.isNaN(coordNumber) || currCommandData.push(coordNumber);
-      if (standardCommandLen = commandLengths[commandChar], currCommandData.length - 1 > standardCommandLen) {
-        let subCommand,
-          bestCommandChar = commandChar;
-        for (let i = 1, len = currCommandData.length; i < len; i += standardCommandLen) {
-          subCommand = [bestCommandChar];
-          for (let j = i, subLen = i + standardCommandLen; j < subLen; j++) subCommand.push(currCommandData[j]);
-          result.push(subCommand), "m" === bestCommandChar ? bestCommandChar = "l" : "M" === bestCommandChar && (bestCommandChar = "L");
-        }
-      } else result.push(currCommandData);
-    } else result.push(currCommandData);
-    return result;
-  }
-
-  var UpdateTag;
-  !function (UpdateTag) {
-    UpdateTag[UpdateTag.NONE = 0] = "NONE", UpdateTag[UpdateTag.UPDATE_BOUNDS = 1] = "UPDATE_BOUNDS", UpdateTag[UpdateTag.UPDATE_SHAPE = 2] = "UPDATE_SHAPE", UpdateTag[UpdateTag.CLEAR_SHAPE = 253] = "CLEAR_SHAPE", UpdateTag[UpdateTag.UPDATE_SHAPE_AND_BOUNDS = 3] = "UPDATE_SHAPE_AND_BOUNDS", UpdateTag[UpdateTag.INIT = 179] = "INIT", UpdateTag[UpdateTag.CLEAR_BOUNDS = 254] = "CLEAR_BOUNDS", UpdateTag[UpdateTag.UPDATE_GLOBAL_MATRIX = 32] = "UPDATE_GLOBAL_MATRIX", UpdateTag[UpdateTag.CLEAR_GLOBAL_MATRIX = 223] = "CLEAR_GLOBAL_MATRIX", UpdateTag[UpdateTag.UPDATE_LOCAL_MATRIX = 16] = "UPDATE_LOCAL_MATRIX", UpdateTag[UpdateTag.CLEAR_LOCAL_MATRIX = 239] = "CLEAR_LOCAL_MATRIX", UpdateTag[UpdateTag.UPDATE_GLOBAL_LOCAL_MATRIX = 48] = "UPDATE_GLOBAL_LOCAL_MATRIX", UpdateTag[UpdateTag.UPDATE_LAYOUT = 128] = "UPDATE_LAYOUT", UpdateTag[UpdateTag.CLEAR_LAYOUT = 127] = "CLEAR_LAYOUT";
-  }(UpdateTag || (UpdateTag = {}));
-  var IContainPointMode;
-  !function (IContainPointMode) {
-    IContainPointMode[IContainPointMode.GLOBAL = 1] = "GLOBAL", IContainPointMode[IContainPointMode.LOCAL = 16] = "LOCAL", IContainPointMode[IContainPointMode.GLOBAL_ACCURATE = 3] = "GLOBAL_ACCURATE", IContainPointMode[IContainPointMode.LOCAL_ACCURATE = 48] = "LOCAL_ACCURATE";
-  }(IContainPointMode || (IContainPointMode = {}));
-  var AttributeUpdateType;
-  !function (AttributeUpdateType) {
-    AttributeUpdateType[AttributeUpdateType.INIT = 0] = "INIT", AttributeUpdateType[AttributeUpdateType.DEFAULT = 1] = "DEFAULT", AttributeUpdateType[AttributeUpdateType.STATE = 2] = "STATE", AttributeUpdateType[AttributeUpdateType.ANIMATE_BIND = 10] = "ANIMATE_BIND", AttributeUpdateType[AttributeUpdateType.ANIMATE_PLAY = 11] = "ANIMATE_PLAY", AttributeUpdateType[AttributeUpdateType.ANIMATE_START = 12] = "ANIMATE_START", AttributeUpdateType[AttributeUpdateType.ANIMATE_UPDATE = 13] = "ANIMATE_UPDATE", AttributeUpdateType[AttributeUpdateType.ANIMATE_END = 14] = "ANIMATE_END", AttributeUpdateType[AttributeUpdateType.TRANSLATE = 20] = "TRANSLATE", AttributeUpdateType[AttributeUpdateType.TRANSLATE_TO = 21] = "TRANSLATE_TO", AttributeUpdateType[AttributeUpdateType.SCALE = 22] = "SCALE", AttributeUpdateType[AttributeUpdateType.SCALE_TO = 23] = "SCALE_TO", AttributeUpdateType[AttributeUpdateType.ROTATE = 24] = "ROTATE", AttributeUpdateType[AttributeUpdateType.ROTATE_TO = 25] = "ROTATE_TO";
-  }(AttributeUpdateType || (AttributeUpdateType = {}));
-  var AnimateStatus;
-  !function (AnimateStatus) {
-    AnimateStatus[AnimateStatus.INITIAL = 0] = "INITIAL", AnimateStatus[AnimateStatus.RUNNING = 1] = "RUNNING", AnimateStatus[AnimateStatus.PAUSED = 2] = "PAUSED", AnimateStatus[AnimateStatus.END = 3] = "END";
-  }(AnimateStatus || (AnimateStatus = {}));
-  var AnimateMode;
-  !function (AnimateMode) {
-    AnimateMode[AnimateMode.NORMAL = 0] = "NORMAL", AnimateMode[AnimateMode.SET_ATTR_IMMEDIATELY = 1] = "SET_ATTR_IMMEDIATELY";
-  }(AnimateMode || (AnimateMode = {}));
-  var AnimateStepType;
-  !function (AnimateStepType) {
-    AnimateStepType.wait = "wait", AnimateStepType.from = "from", AnimateStepType.to = "to", AnimateStepType.customAnimate = "customAnimate";
-  }(AnimateStepType || (AnimateStepType = {}));
-  var Direction;
-  !function (Direction) {
-    Direction[Direction.ROW = 1] = "ROW", Direction[Direction.COLUMN = 2] = "COLUMN";
-  }(Direction || (Direction = {}));
-  var CurveTypeEnum;
-  !function (CurveTypeEnum) {
-    CurveTypeEnum[CurveTypeEnum.CubicBezierCurve = 0] = "CubicBezierCurve", CurveTypeEnum[CurveTypeEnum.QuadraticBezierCurve = 1] = "QuadraticBezierCurve", CurveTypeEnum[CurveTypeEnum.ArcCurve = 2] = "ArcCurve", CurveTypeEnum[CurveTypeEnum.LineCurve = 3] = "LineCurve", CurveTypeEnum[CurveTypeEnum.EllipseCurve = 4] = "EllipseCurve", CurveTypeEnum[CurveTypeEnum.MoveCurve = 5] = "MoveCurve";
-  }(CurveTypeEnum || (CurveTypeEnum = {}));
-  var BaseRenderContributionTime;
-  !function (BaseRenderContributionTime) {
-    BaseRenderContributionTime[BaseRenderContributionTime.beforeFillStroke = 0] = "beforeFillStroke", BaseRenderContributionTime[BaseRenderContributionTime.afterFillStroke = 1] = "afterFillStroke";
-  }(BaseRenderContributionTime || (BaseRenderContributionTime = {}));
-
-  function segments(x, y, rx, ry, large, sweep, rotateX, ox, oy) {
-    const th = vutils.degreeToRadian(rotateX),
-      sin_th = Math.sin(th),
-      cos_th = Math.cos(th),
-      px = cos_th * (ox - x) * .5 + sin_th * (oy - y) * .5,
-      py = cos_th * (oy - y) * .5 - sin_th * (ox - x) * .5;
-    let pl = px * px / ((rx = Math.abs(rx)) * rx) + py * py / ((ry = Math.abs(ry)) * ry);
-    pl > 1 && (pl = Math.sqrt(pl), rx *= pl, ry *= pl);
-    const a00 = cos_th / rx,
-      a01 = sin_th / rx,
-      a10 = -sin_th / ry,
-      a11 = cos_th / ry,
-      x0 = a00 * ox + a01 * oy,
-      y0 = a10 * ox + a11 * oy,
-      x1 = a00 * x + a01 * y,
-      y1 = a10 * x + a11 * y;
-    let sfactor_sq = 1 / ((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) - .25;
-    sfactor_sq < 0 && (sfactor_sq = 0);
-    let sfactor = Math.sqrt(sfactor_sq);
-    sweep === large && (sfactor = -sfactor);
-    const xc = .5 * (x0 + x1) - sfactor * (y1 - y0),
-      yc = .5 * (y0 + y1) + sfactor * (x1 - x0),
-      th0 = Math.atan2(y0 - yc, x0 - xc);
-    let th_arc = Math.atan2(y1 - yc, x1 - xc) - th0;
-    th_arc < 0 && 1 === sweep ? th_arc += vutils.tau : th_arc > 0 && 0 === sweep && (th_arc -= vutils.tau);
-    const segs = Math.ceil(Math.abs(th_arc / (vutils.halfPi + .001))),
-      result = [];
-    for (let i = 0; i < segs; ++i) {
-      const th2 = th0 + i * th_arc / segs,
-        th3 = th0 + (i + 1) * th_arc / segs;
-      result[i] = [xc, yc, th2, th3, rx, ry, sin_th, cos_th];
-    }
-    return result;
-  }
-  function bezier(params) {
-    const cx = params[0],
-      cy = params[1],
-      th0 = params[2],
-      th1 = params[3],
-      rx = params[4],
-      ry = params[5],
-      sin_th = params[6],
-      cos_th = params[7],
-      a00 = cos_th * rx,
-      a01 = -sin_th * ry,
-      a10 = sin_th * rx,
-      a11 = cos_th * ry,
-      cos_th0 = Math.cos(th0),
-      sin_th0 = Math.sin(th0),
-      cos_th1 = Math.cos(th1),
-      sin_th1 = Math.sin(th1),
-      th_half = .5 * (th1 - th0),
-      sin_th_h2 = Math.sin(.5 * th_half),
-      t = 8 / 3 * sin_th_h2 * sin_th_h2 / Math.sin(th_half),
-      x1 = cx + cos_th0 - t * sin_th0,
-      y1 = cy + sin_th0 + t * cos_th0,
-      x3 = cx + cos_th1,
-      y3 = cy + sin_th1,
-      x2 = x3 + t * sin_th1,
-      y2 = y3 - t * cos_th1;
-    return [a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3];
-  }
-  function drawArc(context, x, y, coords) {
-    const seg = segments(coords[5], coords[6], coords[0], coords[1], coords[3], coords[4], coords[2], x, y);
-    for (let i = 0; i < seg.length; ++i) {
-      const bez = bezier(seg[i]);
-      context.bezierCurveTo(bez[0], bez[1], bez[2], bez[3], bez[4], bez[5]);
-    }
-  }
-  const addArcToBezierPath = (bezierPath, startAngle, endAngle, cx, cy, rx, ry) => {
-    const delta = Math.abs(endAngle - startAngle),
-      count = delta > .5 * Math.PI ? Math.ceil(2 * delta / Math.PI) : 1,
-      stepAngle = (endAngle - startAngle) / count;
-    for (let i = 0; i < count; i++) {
-      const sa = startAngle + stepAngle * i,
-        ea = startAngle + stepAngle * (i + 1),
-        len = 4 * Math.tan(Math.abs(stepAngle) / 4) / 3,
-        dir = ea < sa ? -1 : 1,
-        c1 = Math.cos(sa),
-        s1 = Math.sin(sa),
-        c2 = Math.cos(ea),
-        s2 = Math.sin(ea),
-        x1 = c1 * rx + cx,
-        y1 = s1 * ry + cy,
-        x4 = c2 * rx + cx,
-        y4 = s2 * ry + cy,
-        hx = rx * len * dir,
-        hy = ry * len * dir;
-      bezierPath.push(x1 - hx * s1, y1 + hy * c1, x4 + hx * s2, y4 - hy * c2, x4, y4);
-    }
-  };
-
-  const commandFuncs = [(command, context, x, y, sx, sy, z) => context.arc(command[1] * sx + x, command[2] * sy + y, command[3] * (sx + sy) / 2, command[4], command[5], command[6], z), (command, context, x, y, sx, sy, z) => context.arcTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, command[5] * (sx + sy) / 2, z), (command, context, x, y, sx, sy, z) => context.bezierCurveTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, command[5] * sx + x, command[6] * sy + y, z), (command, context, x, y) => context.closePath(), (command, context, x, y, sx, sy) => context.ellipse(command[1] * sx + x, command[2] * sy + y, command[3] * sx, command[4] * sy, command[5], command[6], command[7], command[8]), (command, context, x, y, sx, sy, z) => context.lineTo(command[1] * sx + x, command[2] * sy + y, z), (command, context, x, y, sx, sy, z) => context.moveTo(command[1] * sx + x, command[2] * sy + y, z), (command, context, x, y, sx, sy, z) => context.quadraticCurveTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, z), (command, context, x, y, sx, sy, z) => context.rect(command[1] * sx + x, command[2] * sy + y, command[3] * sx, command[4] * sy, z)];
-  function renderCommandList(commandList, context) {
-    let x = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let y = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-    let sx = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
-    let sy = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
-    let z = arguments.length > 6 ? arguments[6] : undefined;
-    for (let i = 0; i < commandList.length; i++) {
-      const command = commandList[i];
-      commandFuncs[command[0]](command, context, x, y, sx, sy, z);
-    }
-  }
-
-  class Curve {
-    getLength(direction) {
-      return null != direction ? this.calcProjLength(direction) : (Number.isFinite(this.length) || (this.length = this.calcLength()), this.length);
-    }
-  }
-
-  function snapLength(xArr, yArr) {
-    let totalLength = 0;
-    const count = xArr.length;
-    for (let i = 0; i < count; i++) {
-      const x = xArr[i],
-        y = yArr[i],
-        nextX = xArr[(i + 1) % count],
-        nextY = yArr[(i + 1) % count];
-      totalLength += vutils.PointService.distanceNN(x, y, nextX, nextY);
-    }
-    return totalLength / 2;
-  }
-  function cubicLength(p0, p1, p2, p3, iterationCount) {
-    return snapLength([p0.x, p1.x, p2.x, p3.x], [p0.y, p1.y, p2.y, p3.y]);
-  }
-  function cubicCalc(p0, p1, p2, p3, t) {
-    const one = 1 - t;
-    return one * one * one * p0 + 3 * p1 * t * one * one + 3 * p2 * t * t * one + p3 * t * t * t;
-  }
-  function cubicPointAt(p0, p1, p2, p3, t) {
-    const x = cubicCalc(p0.x, p1.x, p2.x, p3.x, t),
-      y = cubicCalc(p0.y, p1.y, p2.y, p3.y, t);
-    return new vutils.Point(x, y);
-  }
-
-  class CubicBezierCurve extends Curve {
-    constructor(p0, p1, p2, p3) {
-      super(), this.type = CurveTypeEnum.CubicBezierCurve, this.p0 = p0, this.p1 = p1, this.p2 = p2, this.p3 = p3;
-    }
-    _validPoint() {
-      return Number.isFinite(this.p0.x + this.p0.y + this.p1.x + this.p1.y + this.p2.x + this.p2.y + this.p3.x + this.p3.y);
-    }
-    getPointAt(t) {
-      if (!1 !== this.defined) return cubicPointAt(this.p0, this.p1, this.p2, this.p3, t);
-      throw new Error("defined为false的点不能getPointAt");
-    }
-    calcLength() {
-      return this._validPoint() ? cubicLength(this.p0, this.p1, this.p2, this.p3) : 60;
-    }
-    calcProjLength(direction) {
-      return direction === Direction.ROW ? vutils.abs(this.p0.x - this.p3.x) : direction === Direction.COLUMN ? vutils.abs(this.p0.y - this.p3.y) : 0;
-    }
-    getAngleAt(t) {
-      const minT = vutils.max(t - .01, 0),
-        maxT = vutils.min(t + .01, 1),
-        minP = this.getPointAt(minT),
-        maxP = this.getPointAt(maxT);
-      return vutils.atan2(maxP.y - minP.y, maxP.x - minP.x);
-    }
-  }
-
-  class LineCurve extends Curve {
-    constructor(p0, p1) {
-      super(), this.type = CurveTypeEnum.LineCurve, this.p0 = p0, this.p1 = p1;
-    }
-    getPointAt(t) {
-      if (!1 !== this.defined) return vutils.PointService.pointAtPP(this.p0, this.p1, t);
-      throw new Error("defined为false的点不能getPointAt");
-    }
-    getAngleAt(t) {
-      return null == this.angle && (this.angle = vutils.atan2(this.p1.y - this.p0.y, this.p1.x - this.p0.x)), this.angle;
-    }
-    _validPoint() {
-      return Number.isFinite(this.p0.x + this.p0.y + this.p1.x + this.p1.y);
-    }
-    calcLength() {
-      return this._validPoint() ? vutils.PointService.distancePP(this.p0, this.p1) : 60;
-    }
-    calcProjLength(direction) {
-      return direction === Direction.ROW ? vutils.abs(this.p0.x - this.p1.x) : direction === Direction.COLUMN ? vutils.abs(this.p0.y - this.p1.y) : 0;
-    }
-  }
-
-  class SegContext {
-    get endX() {
-      return this._lastX;
-    }
-    get endY() {
-      return this._lastY;
-    }
-    constructor(curveType, direction) {
-      this.init(curveType, direction);
-    }
-    init(curveType, direction) {
-      this._lastX = this._lastY = this._startX = this._startY = 0, this.curveType = curveType, this.direction = direction, this.curves = [];
-    }
-    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y, defined, p) {
-      const curve = new CubicBezierCurve(new vutils.Point(this._lastX, this._lastY), new vutils.Point(cp1x, cp1y), new vutils.Point(cp2x, cp2y), new vutils.Point(x, y));
-      curve.originP1 = this._lastOriginP, curve.originP2 = p, curve.defined = defined, this.curves.push(curve), this._lastX = x, this._lastY = y, this._lastOriginP = p;
-    }
-    closePath() {
-      if (this.curves.length < 2) return;
-      const lastCurve = this.curves[this.curves.length - 1];
-      this.lineTo(this._startX, this._startY, lastCurve.defined, this._startOriginP);
-    }
-    ellipse() {
-      throw new Error("SegContext不支持调用ellipse");
-    }
-    lineTo(x, y, defined, p) {
-      const curve = this.addLinearCurve(x, y, defined, this._lastOriginP, p);
-      this.curves.push(curve), this._lastX = x, this._lastY = y, this._lastOriginP = p;
-    }
-    moveTo(x, y, p) {
-      return this._lastX = this._startX = x, this._lastY = this._startY = y, this._lastOriginP = p, this._startOriginP = p, this;
-    }
-    quadraticCurveTo(cpx, cpy, x, y) {
-      throw new Error("SegContext不支持调用quadraticCurveTo");
-    }
-    clear() {
-      this.curves = [], this.length = NaN;
-    }
-    tryUpdateLength(direction) {
-      return this.getLength(direction);
-    }
-    addLinearCurve(x, y, defined, p1, p2) {
-      const curve = new LineCurve(new vutils.Point(this._lastX, this._lastY), new vutils.Point(x, y));
-      return curve.originP1 = p1, curve.originP2 = p2, curve.defined = defined, curve;
-    }
-    getPointAt(t) {
-      throw new Error("暂未实现");
-    }
-    getCurveLengths() {
-      return [];
-    }
-    getLength(direction) {
-      var _a, _b;
-      if (direction === Direction.COLUMN) {
-        if (!this.curves.length) return 0;
-        const sc = this.curves[0],
-          ec = this.curves[this.curves.length - 1],
-          endP = null !== (_a = ec.p3) && void 0 !== _a ? _a : ec.p1;
-        return vutils.abs(sc.p0.y - endP.y);
-      }
-      if (direction === Direction.ROW) {
-        if (!this.curves.length) return 0;
-        const sc = this.curves[0],
-          ec = this.curves[this.curves.length - 1],
-          endP = null !== (_b = ec.p3) && void 0 !== _b ? _b : ec.p1;
-        return vutils.abs(sc.p0.x - endP.x);
-      }
-      return Number.isFinite(this.length) || (this.length = this.curves.reduce((l, c) => l + c.getLength(), 0)), this.length;
-    }
-  }
-  class ReflectSegContext extends SegContext {
-    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y, defined, p) {
-      return super.bezierCurveTo(cp1y, cp1x, cp2y, cp2x, y, x, defined, p);
-    }
-    lineTo(x, y, defined, p) {
-      return super.lineTo(y, x, defined, p);
-    }
-    moveTo(x, y, p) {
-      return super.moveTo(y, x, p);
-    }
-    clear() {
-      return super.clear();
-    }
-  }
-
-  function genCurveSegments(path, points) {
-    let defined0 = !1;
-    for (let i = 0, n = points.length; i <= n; i++) i >= n === defined0 && ((defined0 = !defined0) ? path.lineStart() : path.lineEnd()), defined0 && path.point(points[i]);
-  }
-  function genSegContext(curveType, direction, points) {
-    const curveDirection = null != direction ? direction : vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y) ? Direction.ROW : Direction.COLUMN;
-    return "monotoneY" === curveType ? new ReflectSegContext(curveType, curveDirection) : new SegContext(curveType, curveDirection);
-  }
-
-  class Linear {
-    constructor(context, startPoint) {
-      this.context = context, startPoint && (this.startPoint = startPoint);
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._point = 0, this.startPoint && this.point(this.startPoint);
-    }
-    lineEnd() {
-      (this._line || 0 !== this._line && 1 === this._point) && this.context.closePath(), this._line = 1 - this._line;
-    }
-    point(p) {
-      const x = p.x,
-        y = p.y;
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._line ? this.context.lineTo(x, y, !1 !== this._lastDefined && !1 !== p.defined, p) : this.context.moveTo(x, y, p);
-          break;
-        case 1:
-          this._point = 2;
-        default:
-          this.context.lineTo(x, y, !1 !== this._lastDefined && !1 !== p.defined, p);
-      }
-      this._lastDefined = p.defined;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  function genLinearSegments(points) {
-    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    const segContext = genSegContext("linear", direction, points);
-    return genLinearTypeSegments(new Linear(segContext, startPoint), points), segContext;
-  }
-  function genLinearTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-
-  function point$2(curveClass, x, y, defined, p) {
-    curveClass.context.bezierCurveTo((2 * curveClass._x0 + curveClass._x1) / 3, (2 * curveClass._y0 + curveClass._y1) / 3, (curveClass._x0 + 2 * curveClass._x1) / 3, (curveClass._y0 + 2 * curveClass._y1) / 3, (curveClass._x0 + 4 * curveClass._x1 + x) / 6, (curveClass._y0 + 4 * curveClass._y1 + y) / 6, defined, curveClass.lastPoint1);
-  }
-  class Basis {
-    constructor(context, startPoint) {
-      this.context = context, this.startPoint = startPoint;
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0, this.startPoint && this.point(this.startPoint);
-    }
-    lineEnd() {
-      if (2 === this._point) point$2(this, 6 * this._x1 - (this._x0 + 4 * this._x1), 6 * this._y1 - (this._y0 + 4 * this._y1), !1 !== this._lastDefined1 && !1 !== this._lastDefined2, this.lastPoint1);
-      (this._line || 0 !== this._line && 1 === this._point) && this.context.closePath(), this._line = 1 - this._line;
-    }
-    point(p) {
-      const x = p.x,
-        y = p.y;
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._line ? this.context.lineTo(x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2, p) : this.context.moveTo(x, y, p);
-          break;
-        case 1:
-          this._point = 2;
-          break;
-        default:
-          point$2(this, x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2);
-      }
-      this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y, this._lastDefined1 = this._lastDefined2, this._lastDefined2 = p.defined, this.lastPoint0 = this.lastPoint1, this.lastPoint1 = p;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  function genBasisTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-  function genBasisSegments(points) {
-    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    if (points.length < 3 - Number(!!startPoint)) return genLinearSegments(points, params);
-    const segContext = genSegContext("basis", direction, points);
-    return genBasisTypeSegments(new Basis(segContext, startPoint), points), segContext;
-  }
-
-  function sign(x) {
-    return x < 0 ? -1 : 1;
-  }
-  function slope3(curveClass, x2, y2) {
-    const h0 = curveClass._x1 - curveClass._x0,
-      h1 = x2 - curveClass._x1,
-      s0 = (curveClass._y1 - curveClass._y0) / (h0 || Number(h1 < 0 && -0)),
-      s1 = (y2 - curveClass._y1) / (h1 || Number(h0 < 0 && -0)),
-      p = (s0 * h1 + s1 * h0) / (h0 + h1);
-    return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), .5 * Math.abs(p)) || 0;
-  }
-  function slope2(curveClass, t) {
-    const h = curveClass._x1 - curveClass._x0;
-    return h ? (3 * (curveClass._y1 - curveClass._y0) / h - t) / 2 : t;
-  }
-  function point$1(curveClass, t0, t1, defined, p) {
-    const x0 = curveClass._x0,
-      y0 = curveClass._y0,
-      x1 = curveClass._x1,
-      y1 = curveClass._y1,
-      dx = (x1 - x0) / 3;
-    curveClass.context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1, defined, curveClass.lastPoint1);
-  }
-  class MonotoneX {
-    constructor(context, startPoint) {
-      this.context = context, this.startPoint = startPoint;
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0, this.startPoint && this.point(this.startPoint);
-    }
-    lineEnd() {
-      switch (this._point) {
-        case 2:
-          this.context.lineTo(this._x1, this._y1, !1 !== this._lastDefined1 && !1 !== this._lastDefined2, this.lastPoint1);
-          break;
-        case 3:
-          point$1(this, this._t0, slope2(this, this._t0), !1 !== this._lastDefined1 && !1 !== this._lastDefined2, this.lastPoint1);
-      }
-      (this._line || 0 !== this._line && 1 === this._point) && this.context.closePath(), this._line = 1 - this._line;
-    }
-    point(p) {
-      let t1 = NaN;
-      const x = p.x,
-        y = p.y;
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._line ? this.context.lineTo(x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2, p) : this.context.moveTo(x, y, p);
-          break;
-        case 1:
-          this._point = 2;
-          break;
-        case 2:
-          this._point = 3, point$1(this, slope2(this, t1 = slope3(this, x, y)), t1, !1 !== this._lastDefined1 && !1 !== this._lastDefined2);
-          break;
-        default:
-          point$1(this, this._t0, t1 = slope3(this, x, y), !1 !== this._lastDefined1 && !1 !== this._lastDefined2);
-      }
-      this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y, this._t0 = t1, this._lastDefined1 = this._lastDefined2, this._lastDefined2 = !1 !== p.defined, this.lastPoint0 = this.lastPoint1, this.lastPoint1 = p;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  class MonotoneY extends MonotoneX {
-    constructor(context, startPoint) {
-      super(context, startPoint);
-    }
-    point(p) {
-      return super.point({
-        y: p.x,
-        x: p.y,
-        defined: p.defined
-      });
-    }
-  }
-  function genMonotoneXTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-  function genMonotoneXSegments(points) {
-    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    if (points.length < 3 - Number(!!startPoint)) return genLinearSegments(points, params);
-    const segContext = genSegContext("monotoneX", direction, points);
-    return genMonotoneXTypeSegments(new MonotoneX(segContext, startPoint), points), segContext;
-  }
-  function genMonotoneYTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-  function genMonotoneYSegments(points) {
-    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    if (points.length < 3 - Number(!!startPoint)) return genLinearSegments(points, params);
-    const segContext = genSegContext("monotoneY", direction, points);
-    return genMonotoneYTypeSegments(new MonotoneY(segContext, startPoint), points), segContext;
-  }
-
-  class Step {
-    constructor(context) {
-      let t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : .5;
-      let startPoint = arguments.length > 2 ? arguments[2] : undefined;
-      this.context = context, this._t = t, this.startPoint = startPoint;
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._x = this._y = NaN, this._point = 0, this.startPoint && this.point(this.startPoint);
-    }
-    lineEnd() {
-      0 < this._t && this._t < 1 && 2 === this._point && this.context.lineTo(this._x, this._y, !1 !== this._lastDefined, this.lastPoint), (this._line || 0 !== this._line && 1 === this._point) && this.context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
-    }
-    point(p) {
-      const x = p.x,
-        y = p.y;
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._line ? this.context.lineTo(x, y, !1 !== this._lastDefined && !1 !== p.defined, p) : this.context.moveTo(x, y, p);
-          break;
-        case 1:
-          this._point = 2;
-        default:
-          if (this._t <= 0) this.context.lineTo(this._x, y, !1 !== this._lastDefined && !1 !== p.defined, this.lastPoint), this.context.lineTo(x, y, !1 !== this._lastDefined && !1 !== p.defined, p);else {
-            const x1 = this._x * (1 - this._t) + x * this._t;
-            this.context.lineTo(x1, this._y, !1 !== this._lastDefined && !1 !== p.defined, this.lastPoint), this.context.lineTo(x1, y, !1 !== this._lastDefined && !1 !== p.defined, p);
-          }
-      }
-      this._lastDefined = p.defined, this._x = x, this._y = y, this.lastPoint = p;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  function genStepSegments(points, t) {
-    let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    const segContext = new SegContext("step", null != direction ? direction : vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y) ? Direction.ROW : Direction.COLUMN);
-    return genStepTypeSegments(new Step(segContext, t, startPoint), points), segContext;
-  }
-  function genStepTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-
-  class LinearClosed extends Linear {
-    lineEnd() {
-      this.context.closePath();
-    }
-  }
-  function genLinearClosedSegments(points) {
-    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      direction: direction,
-      startPoint: startPoint
-    } = params;
-    if (points.length < 2 - Number(!!startPoint)) return null;
-    const segContext = genSegContext("linear", direction, points);
-    return genLinearClosedTypeSegments(new LinearClosed(segContext, startPoint), points), segContext;
-  }
-  function genLinearClosedTypeSegments(path, points) {
-    return genCurveSegments(path, points);
-  }
-
-  function point(curveClass, x, y, defined, p) {
-    let x1 = curveClass._x1,
-      y1 = curveClass._y1,
-      x2 = curveClass._x2,
-      y2 = curveClass._y2;
-    if (curveClass._l01_a > vutils.epsilon) {
-      const a = 2 * curveClass._l01_2a + 3 * curveClass._l01_a * curveClass._l12_a + curveClass._l12_2a,
-        n = 3 * curveClass._l01_a * (curveClass._l01_a + curveClass._l12_a);
-      x1 = (x1 * a - curveClass._x0 * curveClass._l12_2a + curveClass._x2 * curveClass._l01_2a) / n, y1 = (y1 * a - curveClass._y0 * curveClass._l12_2a + curveClass._y2 * curveClass._l01_2a) / n;
-    }
-    if (curveClass._l23_a > vutils.epsilon) {
-      const b = 2 * curveClass._l23_2a + 3 * curveClass._l23_a * curveClass._l12_a + curveClass._l12_2a,
-        m = 3 * curveClass._l23_a * (curveClass._l23_a + curveClass._l12_a);
-      x2 = (x2 * b + curveClass._x1 * curveClass._l23_2a - x * curveClass._l12_2a) / m, y2 = (y2 * b + curveClass._y1 * curveClass._l23_2a - y * curveClass._l12_2a) / m;
-    }
-    curveClass.context.bezierCurveTo(x1, y1, x2, y2, curveClass._x2, curveClass._y2, defined, curveClass.lastPoint1);
-  }
-  class CatmullRom {
-    constructor(context) {
-      let alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : .5;
-      let startPoint = arguments.length > 2 ? arguments[2] : undefined;
-      this.context = context, this.startPoint = startPoint, this._alpha = alpha;
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
-    }
-    lineEnd() {
-      switch (this._point) {
-        case 2:
-          this.context.lineTo(this._x2, this._y2, !1 !== this._lastDefined1 && !1 !== this._lastDefined2, this.lastPoint1);
-          break;
-        case 3:
-          this.point({
-            x: this._x2,
-            y: this._y2
-          });
-      }
-      (this._line || 0 !== this._line && 1 === this._point) && this.context.closePath(), this._line = 1 - this._line;
-    }
-    point(p) {
-      const {
-        x: x,
-        y: y
-      } = p;
-      if (this._point) {
-        const x23 = this._x2 - x,
-          y23 = this._y2 - y;
-        this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
-      }
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._line ? this.context.lineTo(x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2) : this.context.moveTo(x, y);
-          break;
-        case 1:
-          this._point = 2;
-          break;
-        case 2:
-          this._point = 3;
-        default:
-          point(this, x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2);
-      }
-      this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y, this._lastDefined1 = this._lastDefined2, this._lastDefined2 = p.defined, this.lastPoint0 = this.lastPoint1, this.lastPoint1 = p;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  function commonGenCatmullRomSegments(type, cons) {
-    return function (points, alpha) {
-      let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      const {
-        direction: direction,
-        startPoint: startPoint
-      } = params;
-      if (points.length < 2 - Number(!!startPoint)) return null;
-      if (points.length < 3 - Number(!!startPoint)) return genLinearSegments(points, params);
-      const segContext = genSegContext(type, direction, points),
-        gatmullRom = new cons(segContext, alpha, startPoint);
-      return genCurveSegments(gatmullRom, points), segContext;
-    };
-  }
-  const genCatmullRomSegments = commonGenCatmullRomSegments("catmullRom", CatmullRom);
-
-  class CatmullRomClosed {
-    constructor(context) {
-      let alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : .5;
-      let startPoint = arguments.length > 2 ? arguments[2] : undefined;
-      this.context = context, this.startPoint = startPoint, this._alpha = alpha;
-    }
-    areaStart() {
-      this._line = 0;
-    }
-    areaEnd() {
-      this._line = NaN;
-    }
-    lineStart() {
-      this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
-    }
-    lineEnd() {
-      switch (this._point) {
-        case 1:
-          this.context.moveTo(this._x3, this._y3, this.lastPoint1), this.context.closePath();
-          break;
-        case 2:
-          this.context.lineTo(this._x3, this._y3, !1 !== this._lastDefined1 && !1 !== this._lastDefined2, this.lastPoint1), this.context.closePath();
-          break;
-        case 3:
-          this.point({
-            x: this._x3,
-            y: this._y3
-          }), this.point({
-            x: this._x4,
-            y: this._y4
-          }), this.point({
-            x: this._x5,
-            y: this._y5
-          });
-      }
-    }
-    point(p) {
-      const {
-        x: x,
-        y: y
-      } = p;
-      if (this._point) {
-        const x23 = this._x2 - x,
-          y23 = this._y2 - y;
-        this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
-      }
-      switch (this._point) {
-        case 0:
-          this._point = 1, this._x3 = x, this._y3 = y;
-          break;
-        case 1:
-          this._point = 2, this.context.moveTo(this._x4 = x, this._y4 = y, p);
-          break;
-        case 2:
-          this._point = 3, this._x5 = x, this._y5 = y;
-          break;
-        default:
-          point(this, x, y, !1 !== this._lastDefined1 && !1 !== this._lastDefined2);
-      }
-      this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y, this._lastDefined1 = this._lastDefined2, this._lastDefined2 = p.defined, this.lastPoint0 = this.lastPoint1, this.lastPoint1 = p;
-    }
-    tryUpdateLength() {
-      return this.context.tryUpdateLength();
-    }
-  }
-  const genCatmullRomClosedSegments = commonGenCatmullRomSegments("catmullRomClosed", CatmullRomClosed);
-
-  function calcLineCache(points, curveType, params) {
-    var _a, _b;
-    switch (curveType) {
-      case "linear":
-      default:
-        return genLinearSegments(points, params);
-      case "basis":
-        return genBasisSegments(points, params);
-      case "monotoneX":
-        return genMonotoneXSegments(points, params);
-      case "monotoneY":
-        return genMonotoneYSegments(points, params);
-      case "step":
-        return genStepSegments(points, .5, params);
-      case "stepBefore":
-        return genStepSegments(points, 0, params);
-      case "stepAfter":
-        return genStepSegments(points, 1, params);
-      case "catmullRom":
-        return genCatmullRomSegments(points, null !== (_a = null == params ? void 0 : params.curveTension) && void 0 !== _a ? _a : .5, params);
-      case "catmullRomClosed":
-        return genCatmullRomClosedSegments(points, null !== (_b = null == params ? void 0 : params.curveTension) && void 0 !== _b ? _b : .5, params);
-      case "linearClosed":
-        return genLinearClosedSegments(points, params);
-    }
-  }
-
-  class CustomPath2D extends CurvePath {
-    constructor(ctx) {
-      super(), this.commandList = [], ctx && (this._ctx = ctx), this._boundsContext = new BoundsContext(this.bounds);
-    }
-    setCtx(ctx) {
-      this._ctx = ctx;
-    }
-    moveTo(x, y) {
-      return this.commandList.push([enumCommandMap.M, x, y]), this._ctx && this._ctx.moveTo(x, y), this;
-    }
-    lineTo(x, y) {
-      return this.commandList.push([enumCommandMap.L, x, y]), this._ctx && this._ctx.lineTo(x, y), this;
-    }
-    quadraticCurveTo(aCPx, aCPy, aX, aY) {
-      return this.commandList.push([enumCommandMap.Q, aCPx, aCPy, aX, aY]), this._ctx && this._ctx.quadraticCurveTo(aCPx, aCPy, aX, aY), this;
-    }
-    bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
-      return this.commandList.push([enumCommandMap.C, aCP1x, aCP1y, aCP2x, aCP2y, aX, aY]), this._ctx && this._ctx.bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY), this;
-    }
-    arcTo(aX1, aY1, aX2, aY2, aRadius) {
-      return this.commandList.push([enumCommandMap.AT, aX1, aY1, aX2, aY2, aRadius]), this._ctx && this._ctx.arcTo(aX1, aY1, aX2, aY2, aRadius), this;
-    }
-    ellipse(aX, aY, xRadius, yRadius, aRotation, aStartAngle, aEndAngle, aClockwise) {
-      return this.commandList.push([enumCommandMap.E, aX, aY, xRadius, yRadius, aRotation, aStartAngle, aEndAngle, aClockwise]), this._ctx && this._ctx.ellipse(aX, aY, xRadius, yRadius, aRotation, aStartAngle, aEndAngle, aClockwise), this;
-    }
-    rect(x, y, w, h) {
-      return this.commandList.push([enumCommandMap.R, x, y, w, h]), this._ctx && this._ctx.rect(x, y, w, h), this;
-    }
-    arc(x, y, radius, startAngle, endAngle, counterclockwise) {
-      return this.commandList.push([enumCommandMap.A, x, y, radius, startAngle, endAngle, counterclockwise]), this._ctx && this._ctx.arc(x, y, radius, startAngle, endAngle, counterclockwise), this;
-    }
-    closePath() {
-      return this.commandList.push([enumCommandMap.Z]), this._ctx && this._ctx.closePath(), this;
-    }
-    addCurve(curve) {
-      this.curves.push(curve);
-    }
-    clear() {
-      this.transformCbList = null, this.commandList.length = 0, this.curves.length = 0;
-    }
-    beginPath() {
-      this.clear();
-    }
-    toString() {
-      if (!this.toStringCbList) {
-        const list = [];
-        list[enumCommandMap.M] = cmd => `M${cmd[1]} ${cmd[2]}`, list[enumCommandMap.L] = cmd => `L${cmd[1]} ${cmd[2]}`, list[enumCommandMap.Q] = cmd => `Q${cmd[1]} ${cmd[2]} ${cmd[3]} ${cmd[4]}`, list[enumCommandMap.C] = cmd => `C${cmd[1]} ${cmd[2]} ${cmd[3]} ${cmd[4]} ${cmd[5]} ${cmd[6]}`, list[enumCommandMap.A] = cmd => {
-          const bezierPathList = [];
-          addArcToBezierPath(bezierPathList, cmd[4], cmd[5], cmd[1], cmd[2], cmd[3], cmd[3]);
-          let path = "";
-          for (let i = 0; i < bezierPathList.length; i += 6) path += `C${bezierPathList[i]} ${bezierPathList[i + 1]} ${bezierPathList[i + 2]} ${bezierPathList[i + 3]} ${bezierPathList[i + 4]} ${bezierPathList[i + 5]}`;
-          return path;
-        }, list[enumCommandMap.R] = cmd => `M${cmd[1]} ${cmd[2]} h${cmd[3]} v${cmd[4]} H${cmd[1]}Z`, list[enumCommandMap.Z] = cmd => "Z", this.toStringCbList = list;
-      }
-      const list = this.toStringCbList;
-      let path = "";
-      return this.commandList.forEach(c => {
-        path += list[c[0]](c);
-      }), path;
-    }
-    fromString(str, x, y, sX, sY) {
-      this.clear();
-      const commandStrList = parseSvgPath(str);
-      return this._runCommandStrList(commandStrList, x, y, sX, sY), this._updateBounds(), this;
-    }
-    fromLine(line) {
-      const {
-        points: points,
-        curveType: curveType,
-        clipRangeByDimension: clipRangeByDimension
-      } = line.attribute;
-      if (!points) return;
-      const cache = calcLineCache(points, curveType);
-      "x" === clipRangeByDimension ? this.direction = Direction.ROW : "y" === clipRangeByDimension ? this.direction = Direction.COLUMN : "auto" === clipRangeByDimension && (this.direction = cache.direction), this.curves = cache.curves;
-    }
-    fromCustomPath2D(path, x, y, sX, sY) {
-      return this.clear(), this._runCommandList(path.commandList, x, y, sX, sY), this._updateBounds(), this;
-    }
-    transform(x, y, sx, sy) {
-      const commandList = this.commandList;
-      if (!this.transformCbList) {
-        const list = [];
-        list[enumCommandMap.M] = this.moveToTransform, list[enumCommandMap.L] = this.lineToTransform, list[enumCommandMap.Q] = this.quadraticCurveToTransform, list[enumCommandMap.C] = this.bezierCurveToTransform, list[enumCommandMap.AT] = this.arcToTransform, list[enumCommandMap.E] = this.ellipseTransform, list[enumCommandMap.R] = this.rectTransform, list[enumCommandMap.A] = this.arcTransform, list[enumCommandMap.Z] = this.closePathTransform, this.transformCbList = list;
-      }
-      commandList.forEach(cmd => {
-        this.transformCbList[cmd[0]](cmd, x, y, sx, sy);
-      }), this._updateBounds();
-    }
-    moveToTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y;
-    }
-    lineToTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y;
-    }
-    quadraticCurveToTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * sx + x, cmd[4] = cmd[4] * sy + y;
-    }
-    bezierCurveToTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * sx + x, cmd[4] = cmd[4] * sy + y, cmd[5] = cmd[5] * sx + x, cmd[6] = cmd[6] * sy + y;
-    }
-    arcToTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * sx + x, cmd[4] = cmd[4] * sy + y, cmd[5] = cmd[5] * (sx + sy) / 2;
-    }
-    ellipseTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * sx, cmd[4] = cmd[4] * sy;
-    }
-    rectTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * sx, cmd[4] = cmd[4] * sy;
-    }
-    arcTransform(cmd, x, y, sx, sy) {
-      cmd[1] = cmd[1] * sx + x, cmd[2] = cmd[2] * sy + y, cmd[3] = cmd[3] * (sx + sy) / 2;
-    }
-    closePathTransform() {}
-    _runCommandStrList(commandStrList) {
-      let l = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      let t = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-      let sX = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-      let sY = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
-      let current,
-        tempX,
-        tempY,
-        tempControlX,
-        tempControlY,
-        previous = null,
-        x = 0,
-        y = 0,
-        controlX = 0,
-        controlY = 0;
-      for (let i = 0, len = commandStrList.length; i < len; ++i) {
-        switch (current = commandStrList[i], 1 === sX && 1 === sY || (current = scale(current, sX, sY)), current[0]) {
-          case "l":
-            x += current[1], y += current[2], this.lineTo(x + l, y + t);
-            break;
-          case "L":
-            x = current[1], y = current[2], this.lineTo(x + l, y + t);
-            break;
-          case "h":
-            x += current[1], this.lineTo(x + l, y + t);
-            break;
-          case "H":
-            x = current[1], this.lineTo(x + l, y + t);
-            break;
-          case "v":
-            y += current[1], this.lineTo(x + l, y + t);
-            break;
-          case "V":
-            y = current[1], this.lineTo(x + l, y + t);
-            break;
-          case "m":
-            x += current[1], y += current[2], this.moveTo(x + l, y + t);
-            break;
-          case "M":
-            x = current[1], y = current[2], this.moveTo(x + l, y + t);
-            break;
-          case "c":
-            tempX = x + current[5], tempY = y + current[6], controlX = x + current[3], controlY = y + current[4], this.bezierCurveTo(x + current[1] + l, y + current[2] + t, controlX + l, controlY + t, tempX + l, tempY + t), x = tempX, y = tempY;
-            break;
-          case "C":
-            x = current[5], y = current[6], controlX = current[3], controlY = current[4], this.bezierCurveTo(current[1] + l, current[2] + t, controlX + l, controlY + t, x + l, y + t);
-            break;
-          case "s":
-            tempX = x + current[3], tempY = y + current[4], controlX = 2 * x - controlX, controlY = 2 * y - controlY, this.bezierCurveTo(controlX + l, controlY + t, x + current[1] + l, y + current[2] + t, tempX + l, tempY + t), controlX = x + current[1], controlY = y + current[2], x = tempX, y = tempY;
-            break;
-          case "S":
-            tempX = current[3], tempY = current[4], controlX = 2 * x - controlX, controlY = 2 * y - controlY, this.bezierCurveTo(controlX + l, controlY + t, current[1] + l, current[2] + t, tempX + l, tempY + t), x = tempX, y = tempY, controlX = current[1], controlY = current[2];
-            break;
-          case "q":
-            tempX = x + current[3], tempY = y + current[4], controlX = x + current[1], controlY = y + current[2], this.quadraticCurveTo(controlX + l, controlY + t, tempX + l, tempY + t), x = tempX, y = tempY;
-            break;
-          case "Q":
-            tempX = current[3], tempY = current[4], this.quadraticCurveTo(current[1] + l, current[2] + t, tempX + l, tempY + t), x = tempX, y = tempY, controlX = current[1], controlY = current[2];
-            break;
-          case "t":
-            tempX = x + current[1], tempY = y + current[2], null === previous[0].match(/[QqTt]/) ? (controlX = x, controlY = y) : "t" === previous[0] ? (controlX = 2 * x - tempControlX, controlY = 2 * y - tempControlY) : "q" === previous[0] && (controlX = 2 * x - controlX, controlY = 2 * y - controlY), tempControlX = controlX, tempControlY = controlY, this.quadraticCurveTo(controlX + l, controlY + t, tempX + l, tempY + t), x = tempX, y = tempY, controlX = x + current[1], controlY = y + current[2];
-            break;
-          case "T":
-            tempX = current[1], tempY = current[2], controlX = 2 * x - controlX, controlY = 2 * y - controlY, this.quadraticCurveTo(controlX + l, controlY + t, tempX + l, tempY + t), x = tempX, y = tempY;
-            break;
-          case "a":
-            drawArc(this, x + l, y + t, [current[1], current[2], current[3], current[4], current[5], current[6] + x + l, current[7] + y + t]), x += current[6], y += current[7];
-            break;
-          case "A":
-            drawArc(this, x + l, y + t, [current[1], current[2], current[3], current[4], current[5], current[6] + l, current[7] + t]), x = current[6], y = current[7];
-            break;
-          case "z":
-          case "Z":
-            this.closePath();
-        }
-        previous = current;
-      }
-    }
-    _runCommandList(commandList) {
-      let l = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      let t = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-      let sX = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-      let sY = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
-      if (0 !== l || 0 !== t || 1 !== sX || 1 !== sY) for (let i = 0, len = commandList.length; i < len; ++i) {
-        const current = commandList[i].slice();
-        switch (current[0]) {
-          case enumCommandMap.L:
-            this.lineToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.M:
-            this.moveToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.C:
-            this.bezierCurveToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.Q:
-            this.quadraticCurveToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.A:
-            this.arcToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.E:
-            this.ellipseTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.R:
-            this.rectTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.AT:
-            this.arcToTransform(current, l, t, sX, sY);
-            break;
-          case enumCommandMap.Z:
-            this.closePath();
-        }
-      } else this.commandList = commandList.map(entry => entry.slice());
-    }
-    _updateBounds() {
-      this.bounds.clear(), renderCommandList(this.commandList, this._boundsContext);
-    }
-    release() {
-      this.commandList = [], this._boundsContext = null, this._ctx = null;
-    }
-    getLength() {
-      if (this.direction === Direction.COLUMN) {
-        if (!this.curves.length) return 0;
-        const sc = this.curves[0],
-          ec = this.curves[this.curves.length - 1];
-        return vutils.abs(sc.p0.y - ec.p1.y);
-      }
-      if (this.direction === Direction.ROW) {
-        if (!this.curves.length) return 0;
-        const sc = this.curves[0],
-          ec = this.curves[this.curves.length - 1];
-        return vutils.abs(sc.p0.x - ec.p1.x);
-      }
-      return this.curves.reduce((l, c) => l + c.getLength(), 0);
-    }
-    getAttrAt(distance) {
-      if (!this.curves) return {
-        pos: {
-          x: 0,
-          y: 0
-        },
-        angle: 0
-      };
-      let curve,
-        _dis = 0;
-      for (let i = 0; i < this.curves.length; i++) {
-        curve = this.curves[i];
-        const cl = curve.getLength(this.direction);
-        if (_dis + cl >= distance) break;
-        _dis += cl;
-      }
-      const t = (distance - _dis) / curve.getLength(this.direction);
-      return {
-        pos: curve.getPointAt(t),
-        angle: curve.getAngleAt(t)
-      };
-    }
-  }
-  const temp = ["l", 0, 0, 0, 0, 0, 0, 0];
-  function scale(current, sX, sY) {
-    const c = temp[0] = current[0];
-    if ("a" === c || "A" === c) temp[1] = sX * current[1], temp[2] = sY * current[2], temp[3] = current[3], temp[4] = current[4], temp[5] = current[5], temp[6] = sX * current[6], temp[7] = sY * current[7];else if ("h" === c || "H" === c) temp[1] = sX * current[1];else if ("v" === c || "V" === c) temp[1] = sY * current[1];else for (let i = 1, n = current.length; i < n; ++i) temp[i] = (i % 2 == 1 ? sX : sY) * current[i];
-    return temp;
-  }
-
-  const DefaultLayout = {
-    alignSelf: "auto"
-  };
-  const DefaultTransform = {
-    x: 0,
-    y: 0,
-    z: 0,
-    dx: 0,
-    dy: 0,
-    dz: 0,
-    scrollX: 0,
-    scrollY: 0,
-    scaleX: 1,
-    scaleY: 1,
-    scaleZ: 1,
-    angle: 0,
-    alpha: 0,
-    beta: 0,
-    scaleCenter: [0, 0],
-    anchor: [0, 0],
-    anchor3d: [0, 0],
-    postMatrix: new vutils.Matrix()
-  };
-  const DefaultFillStyle = {
-    fillOpacity: 1,
-    fill: !1,
-    shadowBlur: 0,
-    shadowColor: "black",
-    shadowOffsetX: 0,
-    shadowOffsetY: 0
-  };
-  const commonStroke = {
-    strokeOpacity: 1,
-    lineDash: [],
-    lineDashOffset: 0,
-    lineWidth: 1,
-    lineCap: "butt",
-    lineJoin: "miter",
-    miterLimit: 10,
-    strokeBoundsBuffer: 2,
-    stroke: !1
-  };
-  const DefaultStrokeStyle = Object.assign({
-    outerBorder: Object.assign(Object.assign({}, commonStroke), {
-      distance: 0
-    }),
-    innerBorder: Object.assign(Object.assign({}, commonStroke), {
-      distance: 0
-    })
-  }, commonStroke);
-  const DefaultTextStyle = {
-    text: "",
-    maxLineWidth: 1 / 0,
-    maxWidth: 1 / 0,
-    textAlign: "left",
-    textBaseline: "alphabetic",
-    fontSize: 16,
-    fontFamily: "PingFang SC,Microsoft Yahei,system-ui,-apple-system,segoe ui,\n    Roboto,Helvetica,Arial,sans-serif, apple color emoji,segoe ui emoji,segoe ui symbol",
-    fontWeight: "",
-    ellipsis: "…",
-    fontVariant: "",
-    fontStyle: "",
-    lineHeight: void 0,
-    underline: 0,
-    lineThrough: 0,
-    scaleIn3d: !1,
-    direction: "horizontal",
-    wordBreak: "break-all",
-    ignoreBuf: !1,
-    verticalMode: 0,
-    wrap: !1,
-    whiteSpace: "no-wrap",
-    heightLimit: 1 / 0,
-    lineClamp: 1 / 0,
-    suffixPosition: "end",
-    underlineDash: [],
-    underlineOffset: 0,
-    disableAutoClipedPoptip: void 0,
-    measureMode: MeasureModeEnum.fontBounding,
-    keepCenterInLine: !1
-  };
-  const DefaultPickStyle = {
-    pickStrokeBuffer: 0
-  };
-  const DefaultStyle = Object.assign(Object.assign(Object.assign(Object.assign({
-    forceBoundsWidth: void 0,
-    forceBoundsHeight: void 0,
-    opacity: 1,
-    background: null,
-    backgroundOpacity: 1,
-    backgroundCornerRadius: 0,
-    texture: null,
-    textureColor: "black",
-    textureSize: 10,
-    texturePadding: 2,
-    backgroundMode: "no-repeat",
-    backgroundFit: !0,
-    blur: 0,
-    cursor: null,
-    html: null,
-    react: null
-  }, DefaultFillStyle), DefaultStrokeStyle), DefaultLayout), DefaultPickStyle);
-  const DefaultConnectAttribute = {
-    connectedType: "none",
-    connectedStyle: {},
-    connectedX: NaN,
-    connectedY: NaN
-  };
-  const DefaultDebugAttribute = {
-    _debug_bounds: !1
-  };
-  const DefaultAttribute = Object.assign(Object.assign(Object.assign({
-    strokeSeg: null,
-    renderable: !0,
-    pickable: !0,
-    shadowGraphic: void 0,
-    childrenPickable: !0,
-    fillPickable: !0,
-    strokePickable: !0,
-    visible: !0,
-    zIndex: 0,
-    layout: null,
-    boundsPadding: 0,
-    fillStrokeOrder: 0,
-    renderStyle: "default",
-    pickMode: "accurate",
-    customPickShape: null,
-    boundsMode: "accurate",
-    keepDirIn3d: !0,
-    shadowRootIdx: 1,
-    globalZIndex: 1,
-    globalCompositeOperation: "",
-    overflow: "hidden",
-    shadowPickMode: "graphic",
-    keepStrokeScale: !1
-  }, DefaultDebugAttribute), DefaultStyle), DefaultTransform);
-  const DefaultArcAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    startAngle: 0,
-    endAngle: vutils.pi2,
-    innerRadius: 0,
-    outerRadius: 1,
-    innerPadding: 0,
-    outerPadding: 0,
-    cornerRadius: 0,
-    padRadius: 0,
-    padAngle: 0,
-    cap: !1,
-    forceShowCap: !1
-  });
-  const DefaultAreaAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultConnectAttribute), {
-    points: [],
-    segments: [],
-    curveType: "linear",
-    clipRange: 1,
-    closePath: !1,
-    curveTension: 1
-  });
-  const DefaultCircleAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    radius: 1,
-    startAngle: 0,
-    endAngle: vutils.pi2
-  });
-  const DefaultGroupAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    width: 0,
-    height: 0,
-    cornerRadius: 0,
-    path: [],
-    clip: !1,
-    visibleAll: !0,
-    display: "relative",
-    flexDirection: "row",
-    flexWrap: "wrap",
-    justifyContent: "flex-start",
-    alignItems: "flex-start",
-    alignContent: "flex-start",
-    baseOpacity: 1
-  });
-  const DefaultGlyphAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    path: "",
-    width: 0,
-    height: 0,
-    cornerRadius: 0,
-    clip: !1
-  });
-  const DefaultLineAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultConnectAttribute), {
-    points: [],
-    segments: [],
-    curveType: "linear",
-    clipRange: 1,
-    clipRangeByDimension: "default",
-    closePath: !1,
-    curveTension: 1
-  });
-  const DefaultPathAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    path: new CustomPath2D(),
-    fillStrokeOrder: 1,
-    customPath: () => {
-      vutils.Logger.getInstance().warn("空函数");
-    }
-  });
-  const DefaultPolygonAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    points: [],
-    cornerRadius: 0,
-    closePath: !0
-  });
-  const DefaultRectAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    width: 0,
-    height: 0,
-    x1: 0,
-    y1: 0,
-    strokeBoundsBuffer: 0,
-    cornerRadius: 0
-  });
-  Object.assign(Object.assign({}, DefaultAttribute), {
-    width: 0,
-    height: 0,
-    x1: 0,
-    y1: 0,
-    cornerRadius: 0,
-    length: 0
-  });
-  const DefaultSymbolAttribute = Object.assign(Object.assign({}, DefaultAttribute), {
-    symbolType: "circle",
-    size: 10,
-    keepDirIn3d: !0
-  });
-  const DefaultTextAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultTextStyle), {
-    strokeBoundsBuffer: 0,
-    keepDirIn3d: !0
-  });
-  const DefaultRichTextAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultTextStyle), {
-    editable: !1,
-    width: 300,
-    height: 300,
-    ellipsis: !0,
-    wordBreak: "break-word",
-    verticalDirection: "top",
-    textAlign: "left",
-    textBaseline: "top",
-    layoutDirection: "horizontal",
-    textConfig: [],
-    disableAutoWrapLine: !1,
-    maxHeight: void 0,
-    maxWidth: void 0,
-    singleLine: !1
-  });
-  const DefaultImageAttribute = Object.assign(Object.assign({
-    repeatX: "no-repeat",
-    repeatY: "no-repeat",
-    image: "",
-    width: 0,
-    height: 0
-  }, DefaultAttribute), {
-    fill: !0,
-    cornerRadius: 0
-  });
-  const DefaultRichTextIconAttribute = Object.assign(Object.assign({}, DefaultImageAttribute), {
-    backgroundShowMode: "never",
-    backgroundWidth: 0,
-    backgroundHeight: 0,
-    textAlign: "left",
-    textBaseline: "middle",
-    direction: "horizontal",
-    margin: 0,
-    id: "",
-    width: 20,
-    height: 20,
-    backgroundFill: "rgba(101, 117, 168, 0.1)",
-    backgroundFillOpacity: 1,
-    backgroundStroke: !1,
-    backgroundStrokeOpacity: 1,
-    backgroundRadius: 4,
-    opacity: 1
-  });
-
-  class Application {}
-  const application = new Application();
-
-  const defaultThemeObj = {
-      arc: DefaultArcAttribute,
-      area: DefaultAreaAttribute,
-      circle: DefaultCircleAttribute,
-      line: DefaultLineAttribute,
-      path: DefaultPathAttribute,
-      symbol: DefaultSymbolAttribute,
-      text: DefaultTextAttribute,
-      rect: DefaultRectAttribute,
-      polygon: DefaultPolygonAttribute,
-      richtext: DefaultRichTextAttribute,
-      richtextIcon: DefaultRichTextIconAttribute,
-      image: DefaultImageAttribute,
-      group: DefaultGroupAttribute,
-      glyph: DefaultGlyphAttribute
-    },
-    themeKeys = Object.keys(defaultThemeObj);
-  function newThemeObj() {
-    return {
-      arc: Object.assign({}, defaultThemeObj.arc),
-      area: Object.assign({}, defaultThemeObj.area),
-      circle: Object.assign({}, defaultThemeObj.circle),
-      line: Object.assign({}, defaultThemeObj.line),
-      path: Object.assign({}, defaultThemeObj.path),
-      symbol: Object.assign({}, defaultThemeObj.symbol),
-      text: Object.assign({}, defaultThemeObj.text),
-      rect: Object.assign({}, defaultThemeObj.rect),
-      polygon: Object.assign({}, defaultThemeObj.polygon),
-      richtext: Object.assign({}, defaultThemeObj.richtext),
-      richtextIcon: Object.assign({}, defaultThemeObj.richtextIcon),
-      image: Object.assign({}, defaultThemeObj.image),
-      group: Object.assign({}, defaultThemeObj.group),
-      glyph: Object.assign({}, defaultThemeObj.glyph)
-    };
-  }
-  function combine(out, t) {
-    Object.keys(t).forEach(k => {
-      out[k] = t[k];
-    });
-  }
-  const globalThemeObj = newThemeObj();
-  class Theme {
-    constructor() {
-      this.initTheme(), this.dirty = !1;
-    }
-    initTheme() {
-      this._defaultTheme = {}, themeKeys.forEach(key => {
-        this._defaultTheme[key] = Object.create(globalThemeObj[key]);
-      }), this.combinedTheme = this._defaultTheme;
-    }
-    getTheme(group) {
-      if (!group) return this.combinedTheme;
-      if (!this.dirty) return this.combinedTheme;
-      let parentTheme = {};
-      const parentGroup = this.getParentWithTheme(group);
-      return parentGroup && (parentTheme = parentGroup.theme), this.applyTheme(group, parentTheme), this.combinedTheme;
-    }
-    getParentWithTheme(group) {
-      for (; group.parent;) if ((group = group.parent).theme) return group;
-      return null;
-    }
-    applyTheme(group, pt) {
-      let force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;
-      if (this.dirty) {
-        const parentGroup = this.getParentWithTheme(group);
-        if (parentGroup) {
-          const parentTheme = parentGroup.theme;
-          (parentTheme.dirty || force) && parentTheme.applyTheme(parentGroup, pt, !0);
-        }
-        this.userTheme ? this.doCombine(parentGroup && parentGroup.theme.combinedTheme) : (parentGroup ? this.combinedTheme = parentGroup.theme.combinedTheme : (this.combinedTheme = this._defaultTheme, vutils.Logger.getInstance().warn("未知错误，走到不应该走的区域里")), this.dirty = !1);
-      }
-      return this.combinedTheme;
-    }
-    doCombine(parentCombinedTheme) {
-      const userTheme = this.userTheme,
-        combinedTheme = this.combinedTheme;
-      themeKeys.forEach(k => {
-        const obj = Object.create(globalThemeObj[k]);
-        parentCombinedTheme && parentCombinedTheme[k] && combine(obj, parentCombinedTheme[k]), combinedTheme[k] && combine(obj, combinedTheme[k]), userTheme[k] && combine(obj, userTheme[k]), this.combinedTheme[k] = obj;
-      }), userTheme.common && themeKeys.forEach(k => {
-        combine(this.combinedTheme[k], userTheme.common);
-      }), this.dirty = !1;
-    }
-    setTheme(t, g) {
-      let userTheme = this.userTheme;
-      userTheme ? Object.keys(t).forEach(k => {
-        userTheme[k] ? Object.assign(userTheme[k], t[k]) : userTheme[k] = Object.assign({}, t[k]);
-      }) : userTheme = t, this.userTheme = userTheme, this.dirty = !0, this.dirtyChildren(g);
-    }
-    resetTheme(t, g) {
-      this.userTheme = t, this.dirty = !0, this.dirtyChildren(g);
-    }
-    dirtyChildren(g) {
-      g.forEachChildren(item => {
-        item.isContainer && (item.theme && (item.theme.dirty = !0), this.dirtyChildren(item));
-      });
-    }
-  }
-  const globalTheme = new Theme();
-  function getTheme(graphic, theme) {
-    return graphic.glyphHost ? getTheme(graphic.glyphHost) : theme ? (graphic.isContainer, theme) : getThemeFromGroup(graphic) || graphic.attachedThemeGraphic && getTheme(graphic.attachedThemeGraphic) || globalTheme.getTheme();
-  }
-  function getThemeFromGroup(graphic) {
-    let g;
-    if (g = graphic.isContainer ? graphic : graphic.parent, g) {
-      for (; g && !g.theme;) g = g.parent;
-      return g ? (g.theme || g.createTheme(), g.theme.getTheme(g)) : globalTheme.getTheme();
-    }
-    return null;
-  }
-
-  function textAttributesToStyle(attrs) {
-    const style = {},
-      parsePxValue = value => /^\d+(\.\d+)?$/.test(`${value}`) ? `${value}px` : `${value}`;
-    return ["textAlign", "fontFamily", "fontVariant", "fontStyle", "fontWeight"].forEach(key => {
-      attrs[key] && (style[vutils.lowerCamelCaseToMiddle(key)] = attrs[key]);
-    }), ["fontSize", "lineHeight"].forEach(key => {
-      const styleKey = vutils.lowerCamelCaseToMiddle(key);
-      vutils.isNil(attrs[key]) || (style[styleKey] = parsePxValue(attrs[key]));
-    }), vutils.isValid(attrs.maxLineWidth) && (style["max-width"] = parsePxValue(attrs.maxLineWidth)), attrs.underline ? style["text-decoration"] = "underline" : attrs.lineThrough && (style["text-decoration"] = "line-through"), attrs.fill && vutils.isString(attrs.fill) && (style.color = attrs.fill), style;
-  }
-
-  class HtmlAttributePlugin {
-    constructor() {
-      this.name = "HtmlAttributePlugin", this.activeEvent = "onRegister", this._uid = Generator.GenAutoIncrementId(), this.key = this.name + this._uid, this.htmlMap = {}, this.renderId = 0, this.onWheel = ev => {
-        try {
-          const newEvent = new ev.constructor(ev.type, ev);
-          this.pluginService.stage.window.getContext().getCanvas().nativeCanvas.dispatchEvent(newEvent);
-        } catch (err) {
-          return;
-        }
-      };
-    }
-    activate(context) {
-      this.pluginService = context, context.stage.hooks.afterRender.tap(this.key, stage => {
-        stage && stage === this.pluginService.stage && this.drawHTML([...context.stage.getChildren()]);
-      });
-    }
-    deactivate(context) {
-      context.stage.hooks.afterRender.taps = context.stage.hooks.afterRender.taps.filter(item => item.name !== this.key), application.graphicService.hooks.onRemove.unTap(this.key), application.graphicService.hooks.onRelease.unTap(this.key), this.release();
-    }
-    getWrapContainer(stage, userContainer, domParams) {
-      let nativeContainer;
-      return nativeContainer = userContainer ? "string" == typeof userContainer ? application.global.getElementById(userContainer) : userContainer : stage.window.getContainer(), {
-        wrapContainer: application.global.createDom(Object.assign({
-          tagName: "div",
-          parent: nativeContainer
-        }, domParams)),
-        nativeContainer: nativeContainer
-      };
-    }
-    parseDefaultStyleFromGraphic(graphic) {
-      const attrs = "text" === graphic.type && graphic.attribute ? graphic.attribute : getTheme(graphic).text;
-      return textAttributesToStyle(attrs);
-    }
-    getTransformOfText(graphic) {
-      const textTheme = getTheme(graphic).text,
-        {
-          textAlign = textTheme.textAlign,
-          textBaseline = textTheme.textBaseline
-        } = graphic.attribute,
-        cssAttrs = graphic.globalTransMatrix.toTransformAttrs(),
-        {
-          rotateDeg: rotateDeg,
-          scaleX: scaleX,
-          scaleY: scaleY
-        } = cssAttrs,
-        translateMap = {
-          left: "0",
-          start: "0",
-          end: "-100%",
-          center: "-50%",
-          right: "-100%",
-          top: "0",
-          middle: "-50%",
-          bottom: "-100%",
-          alphabetic: "-79%"
-        },
-        originMap = {
-          left: "0",
-          start: "0",
-          end: "100%",
-          center: "50%",
-          right: "100%",
-          top: "0",
-          middle: "50%",
-          bottom: "100%",
-          alphabetic: "79%"
-        };
-      return {
-        textAlign: textAlign,
-        transform: `translate(${translateMap[textAlign]},${translateMap[textBaseline]}) rotate(${rotateDeg}deg) scaleX(${scaleX}) scaleY(${scaleY})`,
-        transformOrigin: `${originMap[textAlign]} ${originMap[textBaseline]}`
-      };
-    }
-    updateStyleOfWrapContainer(graphic, stage, wrapContainer, nativeContainer, options) {
-      const {
-        pointerEvents: pointerEvents,
-        penetrateEventList = []
-      } = options;
-      let calculateStyle = this.parseDefaultStyleFromGraphic(graphic);
-      calculateStyle.display = !1 !== graphic.attribute.visible ? "block" : "none", calculateStyle.pointerEvents = !0 === pointerEvents ? "all" : pointerEvents || "none", "none" !== calculateStyle.pointerEvents && (this.removeWrapContainerEventListener(wrapContainer), penetrateEventList.forEach(event => {
-        "wheel" === event && wrapContainer.addEventListener("wheel", this.onWheel);
-      })), wrapContainer.style.position || (wrapContainer.style.position = "absolute", nativeContainer.style.position = "relative");
-      let left = 0,
-        top = 0;
-      const b = graphic.globalAABBBounds;
-      let anchorType = options.anchorType;
-      if (vutils.isNil(anchorType) && (anchorType = "text" === graphic.type ? "position" : "boundsLeftTop"), "boundsLeftTop" === anchorType && (anchorType = "top-left"), "position" === anchorType || b.empty()) {
-        const matrix = graphic.globalTransMatrix;
-        left = matrix.e, top = matrix.f;
-      } else {
-        const anchor = vutils.calculateAnchorOfBounds(b, anchorType);
-        left = anchor.x, top = anchor.y;
-      }
-      const containerTL = application.global.getElementTopLeft(nativeContainer, !1),
-        windowTL = stage.window.getTopLeft(!1),
-        viewBox = stage.viewBox,
-        offsetX = left + windowTL.left - containerTL.left + viewBox.x1,
-        offsetTop = top + windowTL.top - containerTL.top + viewBox.y1;
-      if (calculateStyle.left = `${offsetX}px`, calculateStyle.top = `${offsetTop}px`, "text" === graphic.type && "position" === anchorType && (calculateStyle = Object.assign(Object.assign({}, calculateStyle), this.getTransformOfText(graphic))), vutils.isFunction(options.style)) {
-        const userStyle = options.style({
-          top: offsetTop,
-          left: offsetX,
-          width: b.width(),
-          height: b.height()
-        }, graphic, wrapContainer);
-        userStyle && (calculateStyle = Object.assign(Object.assign({}, calculateStyle), userStyle));
-      } else vutils.isObject(options.style) ? calculateStyle = Object.assign(Object.assign({}, calculateStyle), options.style) : vutils.isString(options.style) && options.style && (calculateStyle = Object.assign(Object.assign({}, calculateStyle), vutils.styleStringToObject(options.style)));
-      application.global.updateDom(wrapContainer, {
-        width: options.width,
-        height: options.height,
-        style: calculateStyle
-      });
-    }
-    clearCacheContainer() {
-      this.htmlMap && Object.keys(this.htmlMap).forEach(key => {
-        this.htmlMap[key] && this.htmlMap[key].renderId !== this.renderId && this.removeElement(key);
-      }), this.renderId += 1;
-    }
-    drawHTML(layers) {
-      "browser" === application.global.env && (layers.sort((a, b) => {
-        var _a, _b;
-        return (null !== (_a = a.attribute.zIndex) && void 0 !== _a ? _a : DefaultAttribute.zIndex) - (null !== (_b = b.attribute.zIndex) && void 0 !== _b ? _b : DefaultAttribute.zIndex);
-      }).forEach(group => {
-        this.renderGroupHTML(group);
-      }), this.clearCacheContainer());
-    }
-    renderGroupHTML(group) {
-      this.renderGraphicHTML(group), group.forEachChildren(g => {
-        g.isContainer ? this.renderGroupHTML(g) : this.renderGraphicHTML(g);
-      });
-    }
-    removeElement(id) {
-      if (!this.htmlMap || !this.htmlMap[id]) return;
-      const {
-        wrapContainer: wrapContainer
-      } = this.htmlMap[id];
-      wrapContainer && application.global.removeDom(wrapContainer), this.htmlMap[id] = null;
-    }
-    removeWrapContainerEventListener(wrapContainer) {
-      wrapContainer.removeEventListener("wheel", this.onWheel);
-    }
-    renderGraphicHTML(graphic) {
-      var _a;
-      const {
-        html: html
-      } = graphic.attribute;
-      if (!html) return;
-      const stage = graphic.stage;
-      if (!stage) return;
-      const {
-        dom: dom,
-        container: container
-      } = html;
-      if (!dom) return;
-      const id = vutils.isNil(html.id) ? `${null !== (_a = graphic.id) && void 0 !== _a ? _a : graphic._uid}_react` : html.id;
-      if (this.htmlMap && this.htmlMap[id] && container && container !== this.htmlMap[id].container && this.removeElement(id), this.htmlMap && this.htmlMap[id]) "string" == typeof dom ? this.htmlMap[id].wrapContainer.innerHTML = dom : dom !== this.htmlMap[id].wrapContainer.firstChild && (this.htmlMap[id].wrapContainer.removeChild(this.htmlMap[id].wrapContainer.firstChild), this.htmlMap[id].wrapContainer.appendChild(dom));else {
-        const {
-          wrapContainer: wrapContainer,
-          nativeContainer: nativeContainer
-        } = this.getWrapContainer(stage, container);
-        wrapContainer && ("string" == typeof dom ? wrapContainer.innerHTML = dom : wrapContainer.appendChild(dom), this.htmlMap || (this.htmlMap = {}), this.htmlMap[id] = {
-          wrapContainer: wrapContainer,
-          nativeContainer: nativeContainer,
-          container: container,
-          renderId: this.renderId
-        });
-      }
-      if (!this.htmlMap || !this.htmlMap[id]) return;
-      const {
-        wrapContainer: wrapContainer,
-        nativeContainer: nativeContainer
-      } = this.htmlMap[id];
-      this.updateStyleOfWrapContainer(graphic, stage, wrapContainer, nativeContainer, html), this.htmlMap[id].renderId = this.renderId;
-    }
-    release() {
-      "browser" === application.global.env && this.removeAllDom(this.pluginService.stage.defaultLayer);
-    }
-    removeAllDom(g) {
-      this.htmlMap && (Object.keys(this.htmlMap).forEach(key => {
-        this.removeElement(key);
-      }), this.htmlMap = null);
-    }
-  }
-
-  class VTableVueAttributePlugin extends HtmlAttributePlugin {
+  class VTableVueAttributePlugin extends vrender.HtmlAttributePlugin {
       renderQueue = new Set();
       isRendering = false;
       renderGraphicHTML(graphic) {
@@ -2441,7 +657,7 @@
           let nativeContainer;
           if (userContainer) {
               nativeContainer =
-                  typeof userContainer === 'string' ? application.global.getElementById(userContainer) : userContainer;
+                  typeof userContainer === 'string' ? vrender.application.global.getElementById(userContainer) : userContainer;
           }
           else {
               nativeContainer = stage.window.getContainer();
@@ -2459,7 +675,7 @@
               };
           }
           return {
-              wrapContainer: application.global.createDom({ tagName: 'div', parent: nativeContainer }),
+              wrapContainer: vrender.application.global.createDom({ tagName: 'div', parent: nativeContainer }),
               nativeContainer
           };
       }
@@ -2505,7 +721,7 @@
           this.applyUserStyles(options, calculateStyle, { offsetX, offsetTop, graphic, wrapContainer });
           const styleChanged = !vutils.isEqual(record.lastStyle, calculateStyle);
           if (styleChanged) {
-              application.global.updateDom(wrapContainer, {
+              vrender.application.global.updateDom(wrapContainer, {
                   width,
                   height,
                   style: calculateStyle
@@ -2534,7 +750,7 @@
           return vutils.calculateAnchorOfBounds(bounds, anchorType || 'top-left');
       }
       calculateOffset(stage, nativeContainer, x, y) {
-          const containerTL = application.global.getElementTopLeft(nativeContainer, false);
+          const containerTL = vrender.application.global.getElementTopLeft(nativeContainer, false);
           const windowTL = stage.window.getTopLeft(false);
           return {
               left: x + windowTL.left - containerTL.left,
@@ -2603,7 +819,7 @@
 
   function useCellRender(props, tableRef) {
       vue.watchEffect(() => {
-          if (!props?.customConfig?.createReactContainer) {
+          if (!props?.options?.customConfig?.createReactContainer) {
               return;
           }
           if (!tableRef.value) {
@@ -3041,7 +1257,7 @@
   }
   CheckBox.symbol = 'CheckBox';
 
-  const version = "1.17.1";
+  const version = "1.17.2";
 
   exports.VTable = VTable__namespace;
   Object.defineProperty(exports, 'register', {