@leafer/worker 2.0.6 → 2.0.7

package/dist/worker.module.js

@@ -531,13 +531,13 @@ const MatrixHelper = {
         to.f = t.f * pixelRatio;
     },
     scaleOfOuter(t, origin, scaleX, scaleY) {
-        M$b.toInnerPoint(t, origin, tempPoint$5);
-        M$b.scaleOfInner(t, tempPoint$5, scaleX, scaleY);
+        M$c.toInnerPoint(t, origin, tempPoint$5);
+        M$c.scaleOfInner(t, tempPoint$5, scaleX, scaleY);
     },
     scaleOfInner(t, origin, scaleX, scaleY = scaleX) {
-        M$b.translateInner(t, origin.x, origin.y);
-        M$b.scale(t, scaleX, scaleY);
-        M$b.translateInner(t, -origin.x, -origin.y);
+        M$c.translateInner(t, origin.x, origin.y);
+        M$c.scale(t, scaleX, scaleY);
+        M$c.translateInner(t, -origin.x, -origin.y);
     },
     rotate(t, rotation) {
         const {a: a, b: b, c: c, d: d} = t;
@@ -550,13 +550,13 @@ const MatrixHelper = {
         t.d = c * sinR + d * cosR;
     },
     rotateOfOuter(t, origin, rotation) {
-        M$b.toInnerPoint(t, origin, tempPoint$5);
-        M$b.rotateOfInner(t, tempPoint$5, rotation);
+        M$c.toInnerPoint(t, origin, tempPoint$5);
+        M$c.rotateOfInner(t, tempPoint$5, rotation);
     },
     rotateOfInner(t, origin, rotation) {
-        M$b.translateInner(t, origin.x, origin.y);
-        M$b.rotate(t, rotation);
-        M$b.translateInner(t, -origin.x, -origin.y);
+        M$c.translateInner(t, origin.x, origin.y);
+        M$c.rotate(t, rotation);
+        M$c.translateInner(t, -origin.x, -origin.y);
     },
     skew(t, skewX, skewY) {
         const {a: a, b: b, c: c, d: d} = t;
@@ -572,13 +572,13 @@ const MatrixHelper = {
         }
     },
     skewOfOuter(t, origin, skewX, skewY) {
-        M$b.toInnerPoint(t, origin, tempPoint$5);
-        M$b.skewOfInner(t, tempPoint$5, skewX, skewY);
+        M$c.toInnerPoint(t, origin, tempPoint$5);
+        M$c.skewOfInner(t, tempPoint$5, skewX, skewY);
     },
     skewOfInner(t, origin, skewX, skewY = 0) {
-        M$b.translateInner(t, origin.x, origin.y);
-        M$b.skew(t, skewX, skewY);
-        M$b.translateInner(t, -origin.x, -origin.y);
+        M$c.translateInner(t, origin.x, origin.y);
+        M$c.skew(t, skewX, skewY);
+        M$c.translateInner(t, -origin.x, -origin.y);
     },
     multiply(t, child) {
         const {a: a, b: b, c: c, d: d, e: e, f: f} = t;
@@ -617,15 +617,15 @@ const MatrixHelper = {
         to.f = e * parent.b + f * parent.d + parent.f;
     },
     divide(t, child) {
-        M$b.multiply(t, M$b.tempInvert(child));
+        M$c.multiply(t, M$c.tempInvert(child));
     },
     divideParent(t, parent) {
-        M$b.multiplyParent(t, M$b.tempInvert(parent));
+        M$c.multiplyParent(t, M$c.tempInvert(parent));
     },
     tempInvert(t) {
-        const {tempMatrix: tempMatrix} = M$b;
-        M$b.copy(tempMatrix, t);
-        M$b.invert(tempMatrix);
+        const {tempMatrix: tempMatrix} = M$c;
+        M$c.copy(tempMatrix, t);
+        M$c.invert(tempMatrix);
         return tempMatrix;
     },
     invert(t) {
@@ -703,7 +703,7 @@ const MatrixHelper = {
         }
         t.e = x;
         t.f = y;
-        if (origin = origin || around) M$b.translateInner(t, -origin.x, -origin.y, !around);
+        if (origin = origin || around) M$c.translateInner(t, -origin.x, -origin.y, !around);
     },
     getLayout(t, origin, around, firstSkewY) {
         const {a: a, b: b, c: c, d: d, e: e, f: f} = t;
@@ -764,11 +764,11 @@ const MatrixHelper = {
         return world;
     },
     reset(t) {
-        M$b.set(t);
+        M$c.set(t);
     }
 };
 
-const M$b = MatrixHelper;
+const M$c = MatrixHelper;
 
 const {float: float$5} = MathHelper;
 
@@ -2706,14 +2706,14 @@ const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
 
 const {set: set$1, toNumberPoints: toNumberPoints$1} = PointHelper;
 
-const {M: M$a, L: L$a, C: C$8, Q: Q$7, Z: Z$8} = PathCommandMap;
+const {M: M$b, L: L$b, C: C$9, Q: Q$7, Z: Z$9} = PathCommandMap;
 
 const tempPoint$3 = {};
 
 const BezierHelper = {
     points(data, originPoints, curve, close) {
         let points = toNumberPoints$1(originPoints);
-        data.push(M$a, points[0], points[1]);
+        data.push(M$b, points[0], points[1]);
         if (curve && points.length > 5) {
             let aX, aY, bX, bY, cX, cY, c1X, c1Y, c2X, c2Y;
             let baX, baY, ba, cb, d, len = points.length;
@@ -2744,7 +2744,7 @@ const BezierHelper = {
                 if (i === 2) {
                     if (!close) data.push(Q$7, c1X, c1Y, bX, bY);
                 } else {
-                    if (baX || baY) data.push(C$8, c2X, c2Y, c1X, c1Y, bX, bY);
+                    if (baX || baY) data.push(C$9, c2X, c2Y, c1X, c1Y, bX, bY);
                 }
                 c2X = bX + cb * cX;
                 c2Y = bY + cb * cY;
@@ -2752,10 +2752,10 @@ const BezierHelper = {
             if (!close) data.push(Q$7, c2X, c2Y, points[len - 2], points[len - 1]);
         } else {
             for (let i = 2, len = points.length; i < len; i += 2) {
-                data.push(L$a, points[i], points[i + 1]);
+                data.push(L$b, points[i], points[i + 1]);
             }
         }
-        if (close) data.push(Z$8);
+        if (close) data.push(Z$9);
     },
     rect(data, x, y, width, height) {
         PathHelper.creator.path = data;
@@ -2778,7 +2778,7 @@ const BezierHelper = {
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
         if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$9(totalRadian - PI$3) < 1e-12) {
-            if (data) data.push(L$a, x1, y1);
+            if (data) data.push(L$b, x1, y1);
             if (setPointBounds) {
                 setPoint$4(setPointBounds, fromX, fromY);
                 addPoint$2(setPointBounds, x1, y1);
@@ -2822,7 +2822,7 @@ const BezierHelper = {
         let startX = x = rotationCos * radiusX * startCos - rotationSin * radiusY * startSin;
         let startY = y = rotationSin * radiusX * startCos + rotationCos * radiusY * startSin;
         let fromX = cx + x, fromY = cy + y;
-        if (data) data.push(data.length ? L$a : M$a, fromX, fromY);
+        if (data) data.push(data.length ? L$b : M$b, fromX, fromY);
         if (setPointBounds) setPoint$4(setPointBounds, fromX, fromY);
         if (setStartPoint) set$1(setStartPoint, fromX, fromY);
         for (let i = 0; i < parts; i++) {
@@ -2834,7 +2834,7 @@ const BezierHelper = {
             y1 = cy + startY - control * (rotationSin * radiusX * startSin - rotationCos * radiusY * startCos);
             x2 = cx + x + control * (rotationCos * radiusX * endSin + rotationSin * radiusY * endCos);
             y2 = cy + y + control * (rotationSin * radiusX * endSin - rotationCos * radiusY * endCos);
-            if (data) data.push(C$8, x1, y1, x2, y2, cx + x, cy + y);
+            if (data) data.push(C$9, x1, y1, x2, y2, cx + x, cy + y);
             if (setPointBounds) toTwoPointBounds$1(cx + startX, cy + startY, x1, y1, x2, y2, cx + x, cy + y, setPointBounds, true);
             startX = x;
             startY = y;
@@ -2846,7 +2846,7 @@ const BezierHelper = {
         if (setEndPoint) set$1(setEndPoint, cx + x, cy + y);
     },
     quadraticCurveTo(data, fromX, fromY, x1, y1, toX, toY) {
-        data.push(C$8, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
+        data.push(C$9, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
     },
     toTwoPointBoundsByQuadraticCurve(fromX, fromY, x1, y1, toX, toY, pointBounds, addMode) {
         toTwoPointBounds$1(fromX, fromY, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY, pointBounds, addMode);
@@ -2896,6 +2896,32 @@ const BezierHelper = {
     getDerivative(t, fromV, v1, v2, toV) {
         const o = 1 - t;
         return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
+    },
+    cut(t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        if (t <= 0) return {
+            left: null,
+            right: [ x1, y1, x2, y2, toX, toY ]
+        }; else if (t >= 1) return {
+            left: [ x1, y1, x2, y2, toX, toY ],
+            right: null
+        };
+        const u = 1 - t;
+        const leftX1 = fromX * u + x1 * t;
+        const leftY1 = fromY * u + y1 * t;
+        const P12x = x1 * u + x2 * t;
+        const P12y = y1 * u + y2 * t;
+        const rightX2 = x2 * u + toX * t;
+        const rightY2 = y2 * u + toY * t;
+        const leftX2 = leftX1 * u + P12x * t;
+        const leftY2 = leftY1 * u + P12y * t;
+        const rightX1 = P12x * u + rightX2 * t;
+        const rightY1 = P12y * u + rightY2 * t;
+        const leftX = leftX2 * u + rightX1 * t;
+        const leftY = leftY2 * u + rightY1 * t;
+        return {
+            left: [ leftX1, leftY1, leftX2, leftY2, leftX, leftY ],
+            right: [ rightX1, rightY1, rightX2, rightY2, toX, toY ]
+        };
     }
 };
 
@@ -2961,9 +2987,9 @@ const PathCommandNodeHelper = {
     }
 };
 
-const {M: M$9, m: m, L: L$9, l: l, H: H, h: h, V: V, v: v, C: C$7, c: c, S: S$1, s: s, Q: Q$6, q: q, T: T, t: t, A: A, a: a, Z: Z$7, z: z, N: N$5, D: D$6, X: X$5, G: G$5, F: F$6, O: O$6, P: P$5, U: U$5} = PathCommandMap;
+const {M: M$a, m: m, L: L$a, l: l, H: H, h: h, V: V, v: v, C: C$8, c: c, S: S$1, s: s, Q: Q$6, q: q, T: T, t: t, A: A, a: a, Z: Z$8, z: z, N: N$5, D: D$6, X: X$5, G: G$5, F: F$6, O: O$6, P: P$5, U: U$5} = PathCommandMap;
 
-const {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$6, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
+const {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$4, arc: arc$3, ellipse: ellipse$6, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
 
 const {ellipticalArc: ellipticalArc} = EllipseHelper;
 
@@ -3053,10 +3079,10 @@ const PathConvert = {
                 old[i + 1] += x;
                 old[i + 2] += y;
 
-              case M$9:
+              case M$a:
                 x = old[i + 1];
                 y = old[i + 2];
-                data.push(M$9, x, y);
+                data.push(M$a, x, y);
                 i += 3;
                 break;
 
@@ -3065,7 +3091,7 @@ const PathConvert = {
 
               case H:
                 x = old[i + 1];
-                data.push(L$9, x, y);
+                data.push(L$a, x, y);
                 i += 2;
                 break;
 
@@ -3074,7 +3100,7 @@ const PathConvert = {
 
               case V:
                 y = old[i + 1];
-                data.push(L$9, x, y);
+                data.push(L$a, x, y);
                 i += 2;
                 break;
 
@@ -3082,10 +3108,10 @@ const PathConvert = {
                 old[i + 1] += x;
                 old[i + 2] += y;
 
-              case L$9:
+              case L$a:
                 x = old[i + 1];
                 y = old[i + 2];
-                data.push(L$9, x, y);
+                data.push(L$a, x, y);
                 i += 3;
                 break;
 
@@ -3097,14 +3123,14 @@ const PathConvert = {
                 command = S$1;
 
               case S$1:
-                smooth = lastCommand === C$7 || lastCommand === S$1;
+                smooth = lastCommand === C$8 || lastCommand === S$1;
                 x1 = smooth ? x * 2 - controlX : old[i + 1];
                 y1 = smooth ? y * 2 - controlY : old[i + 2];
                 controlX = old[i + 1];
                 controlY = old[i + 2];
                 x = old[i + 3];
                 y = old[i + 4];
-                data.push(C$7, x1, y1, controlX, controlY, x, y);
+                data.push(C$8, x1, y1, controlX, controlY, x, y);
                 i += 5;
                 break;
 
@@ -3115,14 +3141,14 @@ const PathConvert = {
                 old[i + 4] += y;
                 old[i + 5] += x;
                 old[i + 6] += y;
-                command = C$7;
+                command = C$8;
 
-              case C$7:
+              case C$8:
                 controlX = old[i + 3];
                 controlY = old[i + 4];
                 x = old[i + 5];
                 y = old[i + 6];
-                data.push(C$7, old[i + 1], old[i + 2], controlX, controlY, x, y);
+                data.push(C$8, old[i + 1], old[i + 2], controlX, controlY, x, y);
                 i += 7;
                 break;
 
@@ -3169,8 +3195,8 @@ const PathConvert = {
                 break;
 
               case z:
-              case Z$7:
-                data.push(Z$7);
+              case Z$8:
+                data.push(Z$8);
                 i++;
                 break;
 
@@ -3224,7 +3250,7 @@ const PathConvert = {
                 break;
 
               case U$5:
-                arcTo$3(curveMode ? data : copyData(data, old, i, 6), x, y, old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], null, setEndPoint$1);
+                arcTo$4(curveMode ? data : copyData(data, old, i, 6), x, y, old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], null, setEndPoint$1);
                 x = setEndPoint$1.x;
                 y = setEndPoint$1.y;
                 i += 6;
@@ -3246,15 +3272,15 @@ const PathConvert = {
             list.forEach(item => {
                 switch (item.name) {
                   case "M":
-                    data.push(M$9, item.x, item.y);
+                    data.push(M$a, item.x, item.y);
                     break;
 
                   case "L":
-                    data.push(L$9, item.x, item.y);
+                    data.push(L$a, item.x, item.y);
                     break;
 
                   case "C":
-                    data.push(C$7, item.x1, item.y1, item.x2, item.y2, item.x, item.y);
+                    data.push(C$8, item.x1, item.y1, item.x2, item.y2, item.x, item.y);
                     break;
 
                   case "Q":
@@ -3262,7 +3288,7 @@ const PathConvert = {
                     break;
 
                   case "Z":
-                    data.push(Z$7);
+                    data.push(Z$8);
                 }
             });
             return data;
@@ -3286,7 +3312,7 @@ const PathConvert = {
 
 const {current: current, pushData: pushData, copyData: copyData} = PathConvert;
 
-const {M: M$8, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F: F$5, O: O$5, P: P$4, U: U$4} = PathCommandMap;
+const {M: M$9, L: L$9, C: C$7, Q: Q$5, Z: Z$7, N: N$4, D: D$5, X: X$4, G: G$4, F: F$5, O: O$5, P: P$4, U: U$4} = PathCommandMap;
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
@@ -3299,19 +3325,19 @@ const PathCommandDataHelper = {
         data.length = 0;
     },
     moveTo(data, x, y) {
-        data.push(M$8, x, y);
+        data.push(M$9, x, y);
     },
     lineTo(data, x, y) {
-        data.push(L$8, x, y);
+        data.push(L$9, x, y);
     },
     bezierCurveTo(data, x1, y1, x2, y2, x, y) {
-        data.push(C$6, x1, y1, x2, y2, x, y);
+        data.push(C$7, x1, y1, x2, y2, x, y);
     },
     quadraticCurveTo(data, x1, y1, x, y) {
         data.push(Q$5, x1, y1, x, y);
     },
     closePath(data) {
-        data.push(Z$6);
+        data.push(Z$7);
     },
     rect(data, x, y, width, height) {
         data.push(N$4, x, y, width, height);
@@ -3356,12 +3382,12 @@ const PathCommandDataHelper = {
     },
     drawEllipse(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
         BezierHelper.ellipse(null, x, y, radiusX, radiusY, isNull(rotation) ? 0 : rotation, isNull(startAngle) ? 0 : startAngle, isNull(endAngle) ? 360 : endAngle, anticlockwise, null, null, startPoint);
-        data.push(M$8, startPoint.x, startPoint.y);
+        data.push(M$9, startPoint.x, startPoint.y);
         ellipse$5(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
     },
     drawArc(data, x, y, radius, startAngle, endAngle, anticlockwise) {
         BezierHelper.arc(null, x, y, radius, isNull(startAngle) ? 0 : startAngle, isNull(endAngle) ? 360 : endAngle, anticlockwise, null, null, startPoint);
-        data.push(M$8, startPoint.x, startPoint.y);
+        data.push(M$9, startPoint.x, startPoint.y);
         arc$2(data, x, y, radius, startAngle, endAngle, anticlockwise);
     },
     drawPoints(data, points, curve, close) {
@@ -3371,7 +3397,7 @@ const PathCommandDataHelper = {
 
 const {ellipse: ellipse$5, arc: arc$2} = PathCommandDataHelper;
 
-const {moveTo: moveTo$4, lineTo: lineTo$3, quadraticCurveTo: quadraticCurveTo, bezierCurveTo: bezierCurveTo, closePath: closePath$3, beginPath: beginPath, rect: rect$2, roundRect: roundRect$1, ellipse: ellipse$4, arc: arc$1, arcTo: arcTo$2, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
+const {moveTo: moveTo$4, lineTo: lineTo$3, quadraticCurveTo: quadraticCurveTo, bezierCurveTo: bezierCurveTo, closePath: closePath$3, beginPath: beginPath, rect: rect$2, roundRect: roundRect$1, ellipse: ellipse$4, arc: arc$1, arcTo: arcTo$3, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
 
 class PathCreator {
     set path(value) {
@@ -3438,7 +3464,7 @@ class PathCreator {
         return this;
     }
     arcTo(x1, y1, x2, y2, radius) {
-        arcTo$2(this.__path, x1, y1, x2, y2, radius);
+        arcTo$3(this.__path, x1, y1, x2, y2, radius);
         this.paint();
         return this;
     }
@@ -3463,7 +3489,7 @@ class PathCreator {
     paint() {}
 }
 
-const {M: M$7, L: L$7, C: C$5, Q: Q$4, Z: Z$5, N: N$3, D: D$4, X: X$3, G: G$3, F: F$4, O: O$4, P: P$3, U: U$3} = PathCommandMap;
+const {M: M$8, L: L$8, C: C$6, Q: Q$4, Z: Z$6, N: N$3, D: D$4, X: X$3, G: G$3, F: F$4, O: O$4, P: P$3, U: U$3} = PathCommandMap;
 
 const debug$e = Debug.get("PathDrawer");
 
@@ -3475,17 +3501,17 @@ const PathDrawer = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M$7:
+              case M$8:
                 drawer.moveTo(data[i + 1], data[i + 2]);
                 i += 3;
                 break;
 
-              case L$7:
+              case L$8:
                 drawer.lineTo(data[i + 1], data[i + 2]);
                 i += 3;
                 break;
 
-              case C$5:
+              case C$6:
                 drawer.bezierCurveTo(data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6]);
                 i += 7;
                 break;
@@ -3495,7 +3521,7 @@ const PathDrawer = {
                 i += 5;
                 break;
 
-              case Z$5:
+              case Z$6:
                 drawer.closePath();
                 i += 1;
                 break;
@@ -3548,9 +3574,9 @@ const PathDrawer = {
     }
 };
 
-const {M: M$6, L: L$6, C: C$4, Q: Q$3, Z: Z$4, N: N$2, D: D$3, X: X$2, G: G$2, F: F$3, O: O$3, P: P$2, U: U$2} = PathCommandMap;
+const {M: M$7, L: L$7, C: C$5, Q: Q$3, Z: Z$5, N: N$2, D: D$3, X: X$2, G: G$2, F: F$3, O: O$3, P: P$2, U: U$2} = PathCommandMap;
 
-const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$3} = BezierHelper;
+const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$2, arc: arc, ellipse: ellipse$3} = BezierHelper;
 
 const {addPointBounds: addPointBounds, copy: copy$9, addPoint: addPoint$1, setPoint: setPoint$3, addBounds: addBounds, toBounds: toBounds$2} = TwoPointBoundsHelper;
 
@@ -3576,22 +3602,22 @@ const PathBounds = {
         while (i < len) {
             command = data[i];
             if (i === 0) {
-                if (command === Z$4 || command === C$4 || command === Q$3) {
+                if (command === Z$5 || command === C$5 || command === Q$3) {
                     setPoint$3(setPointBounds, x, y);
                 } else {
                     setPoint$3(setPointBounds, data[i + 1], data[i + 2]);
                 }
             }
             switch (command) {
-              case M$6:
-              case L$6:
+              case M$7:
+              case L$7:
                 x = data[i + 1];
                 y = data[i + 2];
                 addPoint$1(setPointBounds, x, y);
                 i += 3;
                 break;
 
-              case C$4:
+              case C$5:
                 toX = data[i + 5];
                 toY = data[i + 6];
                 toTwoPointBounds(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY, tempPointBounds);
@@ -3613,7 +3639,7 @@ const PathBounds = {
                 i += 5;
                 break;
 
-              case Z$4:
+              case Z$5:
                 i += 1;
                 break;
 
@@ -3668,7 +3694,7 @@ const PathBounds = {
                 break;
 
               case U$2:
-                arcTo$1(null, x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], tempPointBounds, setEndPoint);
+                arcTo$2(null, x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], tempPointBounds, setEndPoint);
                 i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                 x = setEndPoint.x;
                 y = setEndPoint.y;
@@ -3683,11 +3709,11 @@ const PathBounds = {
     }
 };
 
-const {M: M$5, L: L$5, Z: Z$3} = PathCommandMap;
+const {M: M$6, L: L$6, Z: Z$4} = PathCommandMap;
 
-const {getCenterX: getCenterX, getCenterY: getCenterY} = PointHelper;
+const {getCenterX: getCenterX$1, getCenterY: getCenterY$1} = PointHelper;
 
-const {arcTo: arcTo} = PathCommandDataHelper;
+const {arcTo: arcTo$1} = PathCommandDataHelper;
 
 const PathCorner = {
     smooth(data, cornerRadius, _cornerSmoothing) {
@@ -3699,43 +3725,43 @@ const PathCorner = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M$5:
+              case M$6:
                 startX = lastX = data[i + 1];
                 startY = lastY = data[i + 2];
                 i += 3;
-                if (data[i] === L$5) {
+                if (data[i] === L$6) {
                     secondX = data[i + 1];
                     secondY = data[i + 2];
-                    three ? smooth.push(M$5, startX, startY) : smooth.push(M$5, getCenterX(startX, secondX), getCenterY(startY, secondY));
+                    three ? smooth.push(M$6, startX, startY) : smooth.push(M$6, getCenterX$1(startX, secondX), getCenterY$1(startY, secondY));
                 } else {
-                    smooth.push(M$5, startX, startY);
+                    smooth.push(M$6, startX, startY);
                 }
                 break;
 
-              case L$5:
+              case L$6:
                 x = data[i + 1];
                 y = data[i + 2];
                 i += 3;
                 switch (data[i]) {
-                  case L$5:
-                    arcTo(smooth, x, y, data[i + 1], data[i + 2], cornerRadius, lastX, lastY, three);
+                  case L$6:
+                    arcTo$1(smooth, x, y, data[i + 1], data[i + 2], cornerRadius, lastX, lastY, three);
                     break;
 
-                  case Z$3:
-                    arcTo(smooth, x, y, startX, startY, cornerRadius, lastX, lastY, three);
+                  case Z$4:
+                    arcTo$1(smooth, x, y, startX, startY, cornerRadius, lastX, lastY, three);
                     break;
 
                   default:
-                    smooth.push(L$5, x, y);
+                    smooth.push(L$6, x, y);
                 }
                 lastX = x;
                 lastY = y;
                 break;
 
-              case Z$3:
-                if (lastCommand !== Z$3) {
-                    arcTo(smooth, startX, startY, secondX, secondY, cornerRadius, lastX, lastY, three);
-                    smooth.push(Z$3);
+              case Z$4:
+                if (lastCommand !== Z$4) {
+                    arcTo$1(smooth, startX, startY, secondX, secondY, cornerRadius, lastX, lastY, three);
+                    smooth.push(Z$4);
                 }
                 i += 1;
                 break;
@@ -3747,7 +3773,7 @@ const PathCorner = {
             }
             lastCommand = command;
         }
-        if (command !== Z$3) {
+        if (command !== Z$4) {
             smooth[1] = startX;
             smooth[2] = startY;
         }
@@ -4789,7 +4815,7 @@ const LeafHelper = {
         if (layout.opacityChanged) updateAllWorldOpacity(leaf);
         leaf.__updateChange();
         if (layout.surfaceChanged) {
-            if (leaf.__hasComplex) L$4.updateComplex(leaf);
+            if (leaf.__hasComplex) L$5.updateComplex(leaf);
             layout.surfaceChanged = false;
         }
     },
@@ -4825,7 +4851,7 @@ const LeafHelper = {
             y: y
         };
         isInnerPoint ? toOuterPoint$1(t.localTransform, local, local, true) : t.parent && toInnerPoint$1(t.parent.scrollWorldTransform, local, local, true);
-        L$4.moveLocal(t, local.x, local.y, transition);
+        L$5.moveLocal(t, local.x, local.y, transition);
     },
     moveLocal(t, x, y = 0, transition) {
         if (isObject(x)) y = x.y, x = x.x;
@@ -4838,7 +4864,7 @@ const LeafHelper = {
         }, transition) : (t.x = x, t.y = y);
     },
     zoomOfWorld(t, origin, scaleX, scaleY, resize, transition) {
-        L$4.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
+        L$5.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
     },
     zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition) {
         const o = t.__localMatrix;
@@ -4848,8 +4874,8 @@ const LeafHelper = {
         }
         copy$8(matrix$3, o);
         scaleOfOuter$2(matrix$3, origin, scaleX, scaleY);
-        if (L$4.hasHighPosition(t)) {
-            L$4.setTransform(t, matrix$3, resize, transition);
+        if (L$5.hasHighPosition(t)) {
+            L$5.setTransform(t, matrix$3, resize, transition);
         } else {
             const x = t.x + matrix$3.e - o.e, y = t.y + matrix$3.f - o.f;
             if (transition && !resize) t.animate({
@@ -4861,41 +4887,41 @@ const LeafHelper = {
         }
     },
     rotateOfWorld(t, origin, angle, transition) {
-        L$4.rotateOfLocal(t, getTempLocal(t, origin), angle, transition);
+        L$5.rotateOfLocal(t, getTempLocal(t, origin), angle, transition);
     },
     rotateOfLocal(t, origin, angle, transition) {
         const o = t.__localMatrix;
         copy$8(matrix$3, o);
         rotateOfOuter$2(matrix$3, origin, angle);
-        if (L$4.hasHighPosition(t)) L$4.setTransform(t, matrix$3, false, transition); else t.set({
+        if (L$5.hasHighPosition(t)) L$5.setTransform(t, matrix$3, false, transition); else t.set({
             x: t.x + matrix$3.e - o.e,
             y: t.y + matrix$3.f - o.f,
             rotation: MathHelper.formatRotation(t.rotation + angle)
         }, transition);
     },
     skewOfWorld(t, origin, skewX, skewY, resize, transition) {
-        L$4.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize, transition);
+        L$5.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize, transition);
     },
     skewOfLocal(t, origin, skewX, skewY = 0, resize, transition) {
         copy$8(matrix$3, t.__localMatrix);
         skewOfOuter(matrix$3, origin, skewX, skewY);
-        L$4.setTransform(t, matrix$3, resize, transition);
+        L$5.setTransform(t, matrix$3, resize, transition);
     },
     transformWorld(t, transform, resize, transition) {
         copy$8(matrix$3, t.worldTransform);
         multiplyParent$3(matrix$3, transform);
         if (t.parent) divideParent(matrix$3, t.parent.scrollWorldTransform);
-        L$4.setTransform(t, matrix$3, resize, transition);
+        L$5.setTransform(t, matrix$3, resize, transition);
     },
     transform(t, transform, resize, transition) {
         copy$8(matrix$3, t.localTransform);
         multiplyParent$3(matrix$3, transform);
-        L$4.setTransform(t, matrix$3, resize, transition);
+        L$5.setTransform(t, matrix$3, resize, transition);
     },
     setTransform(t, transform, resize, transition) {
-        const data = t.__, originPoint = data.origin && L$4.getInnerOrigin(t, data.origin);
-        const layout = getLayout(transform, originPoint, data.around && L$4.getInnerOrigin(t, data.around));
-        if (L$4.hasOffset(t)) {
+        const data = t.__, originPoint = data.origin && L$5.getInnerOrigin(t, data.origin);
+        const layout = getLayout(transform, originPoint, data.around && L$5.getInnerOrigin(t, data.around));
+        if (L$5.hasOffset(t)) {
             layout.x -= data.offsetX;
             layout.y -= data.offsetY;
         }
@@ -4904,7 +4930,7 @@ const LeafHelper = {
             delete layout.scaleX, delete layout.scaleY;
             if (originPoint) {
                 BoundsHelper.scale(t.boxBounds, Math.abs(scaleX), Math.abs(scaleY));
-                const changedPoint = L$4.getInnerOrigin(t, data.origin);
+                const changedPoint = L$5.getInnerOrigin(t, data.origin);
                 PointHelper.move(layout, originPoint.x - changedPoint.x, originPoint.y - changedPoint.y);
             }
             t.set(layout);
@@ -4914,11 +4940,11 @@ const LeafHelper = {
     getFlipTransform(t, axis) {
         const m = getMatrixData();
         const sign = axis === "x" ? 1 : -1;
-        scaleOfOuter$2(m, L$4.getLocalOrigin(t, "center"), -1 * sign, 1 * sign);
+        scaleOfOuter$2(m, L$5.getLocalOrigin(t, "center"), -1 * sign, 1 * sign);
         return m;
     },
     getLocalOrigin(t, origin) {
-        return PointHelper.tempToOuterOf(L$4.getInnerOrigin(t, origin), t.localTransform);
+        return PointHelper.tempToOuterOf(L$5.getInnerOrigin(t, origin), t.localTransform);
     },
     getInnerOrigin(t, origin) {
         const innerOrigin = {};
@@ -4934,11 +4960,11 @@ const LeafHelper = {
     updateOuterBounds(_t) {},
     cacheId(_t) {},
     drop(t, parent, index, resize) {
-        t.setTransform(L$4.getRelativeWorld(t, parent, true), resize);
+        t.setTransform(L$5.getRelativeWorld(t, parent, true), resize);
         parent.add(t, index);
     },
     hasHighPosition(t) {
-        return t.origin || t.around || L$4.hasOffset(t);
+        return t.origin || t.around || L$5.hasOffset(t);
     },
     hasOffset(t) {
         return t.offsetX || t.offsetY;
@@ -4958,14 +4984,14 @@ const LeafHelper = {
             const x = move.x * speed, y = move.y * speed;
             move.x -= x, move.y -= y;
             t.move(x, y);
-            Platform.requestRender(() => L$4.animateMove(t, move, speed));
+            Platform.requestRender(() => L$5.animateMove(t, move, speed));
         }
     }
 };
 
-const L$4 = LeafHelper;
+const L$5 = LeafHelper;
 
-const {updateAllMatrix: updateAllMatrix$4, updateMatrix: updateMatrix$4, updateAllWorldOpacity: updateAllWorldOpacity, updateAllChange: updateAllChange$1, updateChange: updateChange$1} = L$4;
+const {updateAllMatrix: updateAllMatrix$4, updateMatrix: updateMatrix$4, updateAllWorldOpacity: updateAllWorldOpacity, updateAllChange: updateAllChange$1, updateChange: updateChange$1} = L$5;
 
 function getTempLocal(t, worldPoint) {
     t.updateLayout();
@@ -7053,7 +7079,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.0.6";
+const version = "2.0.7";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -8583,7 +8609,7 @@ let UI = UI_1 = class UI extends Leaf {
     __updateRenderPath(updateCache) {
         const data = this.__;
         if (data.path) {
-            data.__pathForRender = data.cornerRadius ? PathCorner.smooth(data.path, data.cornerRadius, data.cornerSmoothing) : data.path;
+            data.__pathForRender = data.cornerRadius || data.path.radius ? PathCorner.smooth(data.path, data.cornerRadius, data.cornerSmoothing) : data.path;
             if (data.__useArrow) PathArrow.addArrows(this, updateCache);
         } else data.__pathForRender && (data.__pathForRender = undefined);
     }
@@ -9416,7 +9442,7 @@ let Ellipse = class Ellipse extends UI {
             }
         }
         if (!open) closePath$2(path);
-        if (Platform.ellipseToCurve || data.__useArrow) data.path = this.getPath(true);
+        if (Platform.ellipseToCurve || data.__useArrow || data.cornerRadius) data.path = this.getPath(true);
     }
 };
 
@@ -9442,7 +9468,7 @@ let Polygon = class Polygon extends UI {
         const data = this.__;
         const path = data.path = [];
         if (data.points) {
-            drawPoints$1(path, data.points, data.curve, true);
+            drawPoints$1(path, data.points, data.curve, data.closed);
         } else {
             const {width: width, height: height, sides: sides} = data;
             const rx = width / 2, ry = height / 2;
@@ -15572,7 +15598,7 @@ let LineEditTool = class LineEditTool extends EditTool {
 
 LineEditTool = __decorate([ registerEditTool() ], LineEditTool);
 
-const {M: M$4, L: L$3, C: C$3, Q: Q$2, Z: Z$2, N: N$1, D: D$1, X: X$1, G: G$1, F: F$1, O: O$2, P: P$1, U: U$1} = PathCommandMap;
+const {M: M$5, L: L$4, C: C$4, Q: Q$2, Z: Z$3, N: N$1, D: D$1, X: X$1, G: G$1, F: F$1, O: O$2, P: P$1, U: U$1} = PathCommandMap;
 
 const PathScaler = {
     scale(data, scaleX, scaleY) {
@@ -15582,13 +15608,13 @@ const PathScaler = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M$4:
-              case L$3:
+              case M$5:
+              case L$4:
                 scalePoints(data, scaleX, scaleY, i, 1);
                 i += 3;
                 break;
 
-              case C$3:
+              case C$4:
                 scalePoints(data, scaleX, scaleY, i, 3);
                 i += 7;
                 break;
@@ -15598,7 +15624,7 @@ const PathScaler = {
                 i += 5;
                 break;
 
-              case Z$2:
+              case Z$3:
                 i += 1;
                 break;
 
@@ -16235,13 +16261,13 @@ const MultiTouchHelper = {
         return "rotate";
     },
     detect(data, config) {
-        const {state: state} = M$3;
-        const type = M$3.getType(data, config);
+        const {state: state} = M$4;
+        const type = M$4.getType(data, config);
         if (!state.totalData) {
             state.startTime = Date.now();
             state.center = data.center;
         }
-        M$3.add(data, state.totalData);
+        M$4.add(data, state.totalData);
         state.totalData = data;
         if (type === state.type) {
             state.typeCount++;
@@ -16250,7 +16276,7 @@ const MultiTouchHelper = {
             state.type = type;
             state.typeCount = 1;
         }
-        if (Date.now() - state.startTime >= (config.time || 160)) return M$3.getType(state.totalData, config);
+        if (Date.now() - state.startTime >= (config.time || 160)) return M$4.getType(state.totalData, config);
         return "none";
     },
     add(data, add) {
@@ -16261,7 +16287,7 @@ const MultiTouchHelper = {
         data.center = add.center;
     },
     reset() {
-        const {state: state} = M$3;
+        const {state: state} = M$4;
         state.type = "none";
         state.typeCount = 0;
         state.startTime = 0;
@@ -16269,7 +16295,7 @@ const MultiTouchHelper = {
     }
 };
 
-const M$3 = MultiTouchHelper;
+const M$4 = MultiTouchHelper;
 
 const {abs: abs$2, max: max$1} = Math, {sign: sign, within: within$2} = MathHelper;
 
@@ -17050,7 +17076,7 @@ __decorate([ arrowType("angle") ], Arrow.prototype, "endArrow", void 0);
 
 Arrow = __decorate([ registerUI() ], Arrow);
 
-const {M: M$2, L: L$2, C: C$2, Q: Q$1, O: O$1} = PathCommandMap;
+const {M: M$3, L: L$3, C: C$3, Q: Q$1, O: O$1} = PathCommandMap;
 
 const {rotate: rotate$1, copyFrom: copyFrom$1, scale: scale$1} = PointHelper;
 
@@ -17062,13 +17088,13 @@ const PathMatrixHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M$2:
-              case L$2:
+              case M$3:
+              case L$3:
                 setPoint$2(data, i + 1, x, y, scaleX, scaleY, rotation, origin);
                 i += 3;
                 break;
 
-              case C$2:
+              case C$3:
                 for (j = 1; j < 6; j += 2) setPoint$2(data, i + j, x, y, scaleX, scaleY, rotation, origin);
                 i += 7;
                 break;
@@ -17308,7 +17334,7 @@ function getArrowPath(ui, arrow, from, to, size, connectOffset, hasDashPattern)
     return arrowData;
 }
 
-const {M: M$1, L: L$1, C: C$1, Q: Q, Z: Z$1, N: N, D: D, X: X, G: G, F: F, O: O, P: P, U: U} = PathCommandMap;
+const {M: M$2, L: L$2, C: C$2, Q: Q, Z: Z$2, N: N, D: D, X: X, G: G, F: F, O: O, P: P, U: U} = PathCommandMap;
 
 const {copy: copy, copyFrom: copyFrom, getDistancePoint: getDistancePoint, isSame: isSame} = PointHelper;
 
@@ -17333,8 +17359,8 @@ const PathArrowModule = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M$1:
-              case L$1:
+              case M$2:
+              case L$2:
                 if (count < 2 || i + 6 >= len) {
                     copy(old, now);
                     copyFrom(now, data[i + 1], data[i + 2]);
@@ -17343,7 +17369,7 @@ const PathArrowModule = {
                 i += 3;
                 break;
 
-              case C$1:
+              case C$2:
                 if (count === 1 || i + 7 >= len - 3) {
                     copyPoints(data, last, now, i + 3);
                     old.x = data[i + 1], old.y = data[i + 2];
@@ -17359,7 +17385,7 @@ const PathArrowModule = {
                 i += 5;
                 break;
 
-              case Z$1:
+              case Z$2:
                 return;
 
               case N:
@@ -17403,8 +17429,8 @@ const PathArrowModule = {
                 break;
             }
             count++;
-            if (count === 1 && command !== M$1) return;
-            if (count === 2 && useStartArrow) copy(second, command === L$1 ? now : isSame(old, first) ? last : old);
+            if (count === 1 && command !== M$2) return;
+            if (count === 2 && useStartArrow) copy(second, command === L$2 ? now : isSame(old, first) ? last : old);
             if (i === len) {
                 const path = uData.__pathForRender = clonePathForArrow ? [ ...data ] : data;
                 if (useStartArrow) {
@@ -17426,11 +17452,11 @@ const PathArrowModule = {
                         getDistancePoint(now, last, -connectPoint.x, true);
                         let index;
                         switch (command) {
-                          case L$1:
+                          case L$2:
                             index = i - 3 + 1;
                             break;
 
-                          case C$1:
+                          case C$2:
                             index = i - 7 + 5;
                             break;
 
@@ -19172,7 +19198,7 @@ const HighBezierHelper = {
 
 const {getDistance: getDistance} = HighBezierHelper;
 
-const {M: M, L: L, C: C, Z: Z} = PathCommandMap, {float: float$1} = MathHelper;
+const {M: M$1, L: L$1, C: C$1, Z: Z$1} = PathCommandMap, {float: float$1} = MathHelper;
 
 const tempPoint = {}, tempFrom = {};
 
@@ -19183,18 +19209,18 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M:
-              case L:
+              case M$1:
+              case L$1:
                 HighCurveHelper.transformPoints(data, matrix, i, 1);
                 i += 3;
                 break;
 
-              case C:
+              case C$1:
                 HighCurveHelper.transformPoints(data, matrix, i, 3);
                 i += 7;
                 break;
 
-              case Z:
+              case Z$1:
                 i += 1;
             }
         }
@@ -19215,17 +19241,17 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M:
-              case L:
+              case M$1:
+              case L$1:
                 toX = data[i + 1];
                 toY = data[i + 2];
-                distance = command === L && i > 0 ? PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                distance = command === L$1 && i > 0 ? PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
                 x = toX;
                 y = toY;
                 i += 3;
                 break;
 
-              case C:
+              case C$1:
                 toX = data[i + 5];
                 toY = data[i + 6];
                 distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
@@ -19234,7 +19260,7 @@ const HighCurveHelper = {
                 i += 7;
                 break;
 
-              case Z:
+              case Z$1:
                 i += 1;
 
               default:
@@ -19259,8 +19285,8 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M:
-              case L:
+              case M$1:
+              case L$1:
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
@@ -19279,7 +19305,7 @@ const HighCurveHelper = {
                 i += 3;
                 break;
 
-              case C:
+              case C$1:
                 toX = data[i + 5];
                 toY = data[i + 6];
                 distance = segments[index];
@@ -19295,7 +19321,7 @@ const HighCurveHelper = {
                 i += 7;
                 break;
 
-              case Z:
+              case Z$1:
                 i += 1;
 
               default:
@@ -19316,8 +19342,8 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-              case M:
-              case L:
+              case M$1:
+              case L$1:
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
@@ -19340,7 +19366,7 @@ const HighCurveHelper = {
                 path.push(command, x, y);
                 break;
 
-              case C:
+              case C$1:
                 x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
                 toX = data[i + 5];
                 toY = data[i + 6];
@@ -19359,7 +19385,7 @@ const HighCurveHelper = {
                 path.push(command, x1, y1, x2, y2, toX, toY);
                 break;
 
-              case Z:
+              case Z$1:
                 i += 1;
                 path.push(command);
 
@@ -20880,4 +20906,265 @@ ImageBox = __decorate([ registerUI() ], ImageBox);
 
 Plugin.add("box");
 
+function getTangentDistance(r, x, y, lastX, lastY, nextX, nextY) {
+    const ux = lastX - x, uy = lastY - y;
+    const vx = nextX - x, vy = nextY - y;
+    const lenU = Math.sqrt(ux * ux + uy * uy);
+    const lenV = Math.sqrt(vx * vx + vy * vy);
+    if (lenU < .001 || lenV < .001) return 0;
+    const cosTheta = (ux * vx + uy * vy) / (lenU * lenV);
+    const safeCos = Math.max(-.99999, Math.min(.99999, cosTheta));
+    let d = r * Math.sqrt((1 - safeCos) / (1 + safeCos));
+    const maxD = Math.min(lenU / 2, lenV / 2);
+    return Math.min(d, maxD);
+}
+
+function getCorrectT(d, x, y, x1, y1, x2, y2, toX, toY) {
+    if (d <= 0) return 0;
+    const chordLen = Math.sqrt(Math.pow(toX - x, 2) + Math.pow(toY - y, 2));
+    if (d >= chordLen) return .5;
+    const vx0 = 3 * (x1 - x);
+    const vy0 = 3 * (y1 - y);
+    let v0mag = Math.sqrt(vx0 * vx0 + vy0 * vy0);
+    if (v0mag < 1e-6) v0mag = chordLen || 1;
+    let t = Math.min(.5, d / v0mag);
+    const tempP = {
+        x: 0,
+        y: 0
+    };
+    for (let i = 0; i < 5; i++) {
+        BezierHelper.getPointAndSet(t, x, y, x1, y1, x2, y2, toX, toY, tempP);
+        const dx = tempP.x - x;
+        const dy = tempP.y - y;
+        const currentDist = Math.sqrt(dx * dx + dy * dy);
+        if (currentDist < 1e-6) {
+            t = t * 1.5;
+            continue;
+        }
+        const vxt = BezierHelper.getDerivative(t, x, x1, x2, toX);
+        const vyt = BezierHelper.getDerivative(t, y, y1, y2, toY);
+        const f_prime = (dx * vxt + dy * vyt) / currentDist;
+        if (Math.abs(f_prime) < 1e-6) break;
+        const deltaT = (currentDist - d) / f_prime;
+        const nextT = t - deltaT;
+        const safeNextT = Math.max(0, Math.min(.6, nextT));
+        if (Math.abs(safeNextT - t) < 1e-5) {
+            t = safeNextT;
+            break;
+        }
+        t = safeNextT;
+    }
+    return Math.max(0, Math.min(.5, t));
+}
+
+const {M: M, L: L, C: C, Z: Z} = PathCommandMap;
+
+const {getCenterX: getCenterX, getCenterY: getCenterY} = PointHelper;
+
+const {arcTo: arcTo} = PathCommandDataHelper;
+
+PathCorner.smooth = function smooth(data, cornerRadius, _cornerSmoothing) {
+    const radius = data.radius;
+    if (isNeedConvert(data)) data = PathConvert.toCanvasData(data, true);
+    let command, lastCommand, commandLen;
+    let i = 0, countCommand = 0, x = 0, y = 0, startX = 0, startY = 0, startR = 0, secondX = 0, secondY = 0, lastX = 0, lastY = 0, r, x1, y1, x2, y2, toX, toY;
+    if (isArray(cornerRadius)) cornerRadius = cornerRadius[0] || 0;
+    const len = data.length, three = len === 9;
+    const smooth = [];
+    while (i < len) {
+        command = data[i];
+        r = radius ? isUndefined(radius[countCommand]) ? cornerRadius : radius[countCommand] : cornerRadius;
+        switch (command) {
+          case M:
+            startX = lastX = data[i + 1];
+            startY = lastY = data[i + 2];
+            startR = r;
+            i += 3;
+            const end = findEndPoint(data, i);
+            switch (data[i]) {
+              case L:
+                secondX = data[i + 1];
+                secondY = data[i + 2];
+                if (three) smooth.push(M, startX, startY); else {
+                    if (end) smooth.push(M, getCenterX(startX, secondX), getCenterY(startY, secondY)); else smooth.push(M, startX, startY);
+                }
+                break;
+
+              case C:
+                if (end) {
+                    const {left: left, right: right} = setAfterC(data, i, r, end.x, end.y, startX, startY, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6]);
+                    if (left && right) {
+                        smooth.push(M, secondX = left[4], secondY = left[5]);
+                        break;
+                    }
+                }
+
+              default:
+                smooth.push(M, secondX = startX, secondY = startY);
+            }
+            break;
+
+          case L:
+            x = data[i + 1];
+            y = data[i + 2];
+            i += 3;
+            switch (data[i]) {
+              case L:
+                arcTo(smooth, x, y, data[i + 1], data[i + 2], r, lastX, lastY, three);
+                break;
+
+              case C:
+                const {left: left, right: right} = setAfterC(data, i, r, lastX, lastY, x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6]);
+                if (left && right) arcTo(smooth, x, y, left[4], left[5], r, lastX, lastY, three); else smooth.push(L, x, y);
+                break;
+
+              case Z:
+                arcTo(smooth, x, y, startX, startY, r, lastX, lastY, three);
+                break;
+
+              default:
+                smooth.push(L, x, y);
+            }
+            lastX = x;
+            lastY = y;
+            break;
+
+          case C:
+            x1 = data[i + 1];
+            y1 = data[i + 2];
+            x2 = data[i + 3];
+            y2 = data[i + 4];
+            x = data[i + 5];
+            y = data[i + 6];
+            i += 7;
+            switch (data[i]) {
+              case L:
+                toX = data[i + 1], toY = data[i + 2];
+                setBeforeC(smooth, r, lastX, lastY, x1, y1, x2, y2, x, y, toX, toY, three);
+                break;
+
+              case C:
+                smooth.push(C, x1, y1, x2, y2, x, y);
+                break;
+
+              case Z:
+                toX = startX, toY = startY;
+                setBeforeC(smooth, r, lastX, lastY, x1, y1, x2, y2, x, y, toX, toY, three);
+                break;
+            }
+            lastX = x;
+            lastY = y;
+            break;
+
+          case Z:
+            if (lastCommand !== Z) {
+                arcTo(smooth, startX, startY, secondX, secondY, startR, lastX, lastY, three);
+                smooth.push(Z);
+            }
+            i += 1;
+            break;
+
+          default:
+            commandLen = PathNumberCommandLengthMap[command];
+            for (let j = 0; j < commandLen; j++) smooth.push(data[i + j]);
+            i += commandLen;
+        }
+        lastCommand = command;
+        countCommand++;
+    }
+    return smooth;
+};
+
+function isNeedConvert(data) {
+    let command, i = 0;
+    const len = data.length;
+    while (i < len) {
+        command = data[i];
+        switch (command) {
+          case M:
+            i += 3;
+            break;
+
+          case L:
+            i += 3;
+            break;
+
+          case C:
+            i += 7;
+            break;
+
+          case Z:
+            i += 1;
+            break;
+
+          default:
+            return true;
+        }
+    }
+    return false;
+}
+
+function findEndPoint(data, i) {
+    let command, commandLen, x, y;
+    const len = data.length;
+    while (i < len) {
+        command = data[i];
+        switch (command) {
+          case M:
+            return undefined;
+
+          case L:
+            x = data[i + 1];
+            y = data[i + 2];
+            i += 3;
+            break;
+
+          case C:
+            x = data[i + 5];
+            y = data[i + 6];
+            i += 7;
+            break;
+
+          case Z:
+            return {
+                x: x,
+                y: y
+            };
+
+          default:
+            commandLen = PathNumberCommandLengthMap[command];
+            i += commandLen;
+        }
+    }
+    return undefined;
+}
+
+function setAfterC(data, i, cornerRadius, lastX, lastY, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+    const d = getTangentDistance(cornerRadius, fromX, fromY, lastX, lastY, x1, y1);
+    const t = getCorrectT(d, fromX, fromY, x1, y1, x2, y2, toX, toY);
+    const two = BezierHelper.cut(t, fromX, fromY, x1, y1, x2, y2, toX, toY);
+    const {left: left, right: right} = two;
+    if (left && right) {
+        data[i + 1] = right[0];
+        data[i + 2] = right[1];
+        data[i + 3] = right[2];
+        data[i + 4] = right[3];
+    }
+    return two;
+}
+
+function setBeforeC(smooth, cornerRadius, fromX, fromY, x1, y1, x2, y2, toX, toY, nextX, nextY, three) {
+    const d = getTangentDistance(cornerRadius, toX, toY, x2, y2, nextX, nextY);
+    const t = getCorrectT(d, toX, toY, x2, y2, x1, y1, fromX, fromY);
+    const {left: left, right: right} = BezierHelper.cut(1 - t, fromX, fromY, x1, y1, x2, y2, toX, toY);
+    if (left && right) {
+        smooth.push(C, left[0], left[1], left[2], left[3], left[4], left[5]);
+        arcTo(smooth, toX, toY, nextX, nextY, cornerRadius, left[4], left[5], three);
+    } else {
+        smooth.push(C, x1, y1, x2, y2, toX, toY);
+    }
+}
+
+Plugin.add("corner");
+
 export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseBox, EllipseBoxData, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, FourNumberHelper, Frame, FrameData, Group, GroupData, HTMLText, HTMLTextData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageBox, ImageBoxData, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferFilm, LeaferImage, LeaferTypeCreator, LeaferVideo, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, MyTouchEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathBox, PathBoxData, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonBox, PolygonBoxData, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, Scroller, SelectArea, Selector, Star, StarBox, StarBoxData, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TextEditor, TouchEvent, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, UnitConvertHelper, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, dimType, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite$1 as isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, motionPathType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, scrollType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$3 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$4 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };