@leafer/worker 2.0.5 → 2.0.7

package/dist/worker.js

@@ -491,13 +491,13 @@ var LeaferUI = function(exports) {
             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;
@@ -510,13 +510,13 @@ var LeaferUI = function(exports) {
             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;
@@ -532,13 +532,13 @@ var LeaferUI = function(exports) {
             }
         },
         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;
@@ -577,15 +577,15 @@ var LeaferUI = function(exports) {
             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) {
@@ -663,7 +663,7 @@ var LeaferUI = function(exports) {
             }
             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;
@@ -724,10 +724,10 @@ var LeaferUI = function(exports) {
             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;
     const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
     const {sin: sin$5, cos: cos$5, abs: abs$a, sqrt: sqrt$4, atan2: atan2$2, min: min$3, round: round$5} = Math;
@@ -2521,12 +2521,12 @@ var LeaferUI = function(exports) {
     const {sin: sin$4, cos: cos$4, hypot: hypot$1, atan2: atan2$1, ceil: ceil$1, abs: abs$9, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
     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;
@@ -2557,7 +2557,7 @@ var LeaferUI = function(exports) {
                     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;
@@ -2565,10 +2565,10 @@ var LeaferUI = function(exports) {
                 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;
@@ -2591,7 +2591,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2635,7 +2635,7 @@ var LeaferUI = function(exports) {
             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++) {
@@ -2647,7 +2647,7 @@ var LeaferUI = function(exports) {
                 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;
@@ -2659,7 +2659,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2709,6 +2709,32 @@ var LeaferUI = function(exports) {
         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 ]
+            };
         }
     };
     const {getPointAndSet: getPointAndSet, toTwoPointBounds: toTwoPointBounds$1, ellipse: ellipse$8} = BezierHelper;
@@ -2768,8 +2794,8 @@ var LeaferUI = function(exports) {
             return [];
         }
     };
-    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 {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$6, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
+    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$4, arc: arc$3, ellipse: ellipse$6, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
     const {ellipticalArc: ellipticalArc} = EllipseHelper;
     const debug$f = Debug.get("PathConvert");
     const setEndPoint$1 = {};
@@ -2855,10 +2881,10 @@ var LeaferUI = function(exports) {
                     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;
 
@@ -2867,7 +2893,7 @@ var LeaferUI = function(exports) {
 
                   case H:
                     x = old[i + 1];
-                    data.push(L$9, x, y);
+                    data.push(L$a, x, y);
                     i += 2;
                     break;
 
@@ -2876,7 +2902,7 @@ var LeaferUI = function(exports) {
 
                   case V:
                     y = old[i + 1];
-                    data.push(L$9, x, y);
+                    data.push(L$a, x, y);
                     i += 2;
                     break;
 
@@ -2884,10 +2910,10 @@ var LeaferUI = function(exports) {
                     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;
 
@@ -2899,14 +2925,14 @@ var LeaferUI = function(exports) {
                     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;
 
@@ -2917,14 +2943,14 @@ var LeaferUI = function(exports) {
                     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;
 
@@ -2971,8 +2997,8 @@ var LeaferUI = function(exports) {
                     break;
 
                   case z:
-                  case Z$7:
-                    data.push(Z$7);
+                  case Z$8:
+                    data.push(Z$8);
                     i++;
                     break;
 
@@ -3026,7 +3052,7 @@ var LeaferUI = function(exports) {
                     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;
@@ -3048,15 +3074,15 @@ var LeaferUI = function(exports) {
                 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":
@@ -3064,7 +3090,7 @@ var LeaferUI = function(exports) {
                         break;
 
                       case "Z":
-                        data.push(Z$7);
+                        data.push(Z$8);
                     }
                 });
                 return data;
@@ -3086,7 +3112,7 @@ var LeaferUI = function(exports) {
         }
     };
     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;
     const {tan: tan, min: min$2, abs: abs$8} = Math;
     const startPoint = {};
@@ -3095,19 +3121,19 @@ var LeaferUI = function(exports) {
             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);
@@ -3152,12 +3178,12 @@ var LeaferUI = function(exports) {
         },
         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) {
@@ -3165,7 +3191,7 @@ var LeaferUI = function(exports) {
         }
     };
     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) {
             this.__path = value;
@@ -3231,7 +3257,7 @@ var LeaferUI = function(exports) {
             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;
         }
@@ -3255,7 +3281,7 @@ var LeaferUI = function(exports) {
         }
         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");
     const PathDrawer = {
         drawPathByData(drawer, data) {
@@ -3265,17 +3291,17 @@ var LeaferUI = function(exports) {
             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;
@@ -3285,7 +3311,7 @@ var LeaferUI = function(exports) {
                     i += 5;
                     break;
 
-                  case Z$5:
+                  case Z$6:
                     drawer.closePath();
                     i += 1;
                     break;
@@ -3337,8 +3363,8 @@ var LeaferUI = function(exports) {
             }
         }
     };
-    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 {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$3} = BezierHelper;
+    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$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;
     const debug$d = Debug.get("PathBounds");
     let radius, radiusX, radiusY;
@@ -3357,22 +3383,22 @@ var LeaferUI = function(exports) {
             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);
@@ -3394,7 +3420,7 @@ var LeaferUI = function(exports) {
                     i += 5;
                     break;
 
-                  case Z$4:
+                  case Z$5:
                     i += 1;
                     break;
 
@@ -3449,7 +3475,7 @@ var LeaferUI = function(exports) {
                     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;
@@ -3463,9 +3489,9 @@ var LeaferUI = function(exports) {
             }
         }
     };
-    const {M: M$5, L: L$5, Z: Z$3} = PathCommandMap;
-    const {getCenterX: getCenterX, getCenterY: getCenterY} = PointHelper;
-    const {arcTo: arcTo} = PathCommandDataHelper;
+    const {M: M$6, L: L$6, Z: Z$4} = PathCommandMap;
+    const {getCenterX: getCenterX$1, getCenterY: getCenterY$1} = PointHelper;
+    const {arcTo: arcTo$1} = PathCommandDataHelper;
     const PathCorner = {
         smooth(data, cornerRadius, _cornerSmoothing) {
             let command, lastCommand, commandLen;
@@ -3476,43 +3502,43 @@ var LeaferUI = function(exports) {
             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;
@@ -3524,7 +3550,7 @@ var LeaferUI = function(exports) {
                 }
                 lastCommand = command;
             }
-            if (command !== Z$3) {
+            if (command !== Z$4) {
                 smooth[1] = startX;
                 smooth[2] = startY;
             }
@@ -4492,7 +4518,7 @@ var LeaferUI = function(exports) {
             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;
             }
         },
@@ -4528,7 +4554,7 @@ var LeaferUI = function(exports) {
                 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;
@@ -4541,7 +4567,7 @@ var LeaferUI = function(exports) {
             }, 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;
@@ -4551,8 +4577,8 @@ var LeaferUI = function(exports) {
             }
             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({
@@ -4564,41 +4590,41 @@ var LeaferUI = function(exports) {
             }
         },
         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;
             }
@@ -4607,7 +4633,7 @@ var LeaferUI = function(exports) {
                 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);
@@ -4617,11 +4643,11 @@ var LeaferUI = function(exports) {
         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 = {};
@@ -4637,11 +4663,11 @@ var LeaferUI = function(exports) {
         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;
@@ -4661,12 +4687,12 @@ var LeaferUI = function(exports) {
                 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 {updateAllMatrix: updateAllMatrix$4, updateMatrix: updateMatrix$4, updateAllWorldOpacity: updateAllWorldOpacity, updateAllChange: updateAllChange$1, updateChange: updateChange$1} = L$4;
+    const L$5 = LeafHelper;
+    const {updateAllMatrix: updateAllMatrix$4, updateMatrix: updateMatrix$4, updateAllWorldOpacity: updateAllWorldOpacity, updateAllChange: updateAllChange$1, updateChange: updateChange$1} = L$5;
     function getTempLocal(t, worldPoint) {
         t.updateLayout();
         return t.parent ? PointHelper.tempToInnerOf(worldPoint, t.parent.scrollWorldTransform) : worldPoint;
@@ -6637,7 +6663,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "2.0.5";
+    const version = "2.0.7";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -8045,6 +8071,7 @@ var LeaferUI = function(exports) {
         createProxyData() {
             return undefined;
         }
+        clearProxyData() {}
         find(_condition, _options) {
             return Plugin.need("find");
         }
@@ -8085,7 +8112,7 @@ var LeaferUI = function(exports) {
         __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);
         }
@@ -8804,7 +8831,7 @@ var LeaferUI = function(exports) {
                 }
             }
             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);
         }
     };
     __decorate([ dataProcessor(EllipseData) ], exports.Ellipse.prototype, "__", void 0);
@@ -8822,7 +8849,7 @@ var LeaferUI = function(exports) {
             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;
@@ -10963,17 +10990,19 @@ var LeaferUI = function(exports) {
         return leafPaint;
     }
     function checkSizeAndCreateData(ui, attrName, paint, image, leafPaint, boxBounds) {
+        let needUpdate = true;
         const data = ui.__;
         if (attrName === "fill" && !data.__naturalWidth) {
             data.__naturalWidth = image.width / data.pixelRatio;
             data.__naturalHeight = image.height / data.pixelRatio;
             if (data.__autoSide) {
                 ui.forceUpdate("width");
+                LeafHelper.updateBounds(ui);
                 if (ui.__proxyData) {
                     ui.setProxyAttr("width", data.width);
                     ui.setProxyAttr("height", data.height);
                 }
-                return false;
+                needUpdate = false;
             }
         }
         if (!leafPaint.data) {
@@ -10983,7 +11012,7 @@ var LeaferUI = function(exports) {
             if (clip || opacity && opacity < 1 || blendMode) leafPaint.complex = clip ? 2 : true;
         }
         if (paint.filter) PaintImage.applyFilter(leafPaint, image, paint.filter, ui);
-        return true;
+        return needUpdate;
     }
     function onLoad(ui, event) {
         emit(ui, ImageEvent.LOAD, event);
@@ -11386,10 +11415,10 @@ var LeaferUI = function(exports) {
     const realFrom = {};
     const realTo = {};
     function conicGradient(paint, box) {
-        let {from: from, to: to, type: type, opacity: opacity, stretch: stretch} = paint;
+        let {from: from, to: to, type: type, opacity: opacity, rotation: rotation, stretch: stretch} = paint;
         toPoint$1(from || "center", box, realFrom);
         toPoint$1(to || "bottom", box, realTo);
-        const style = Platform.conicGradientSupport ? Platform.canvas.createConicGradient(0, realFrom.x, realFrom.y) : Platform.canvas.createRadialGradient(realFrom.x, realFrom.y, 0, realFrom.x, realFrom.y, getDistance$1(realFrom, realTo));
+        const style = Platform.conicGradientSupport ? Platform.canvas.createConicGradient(rotation ? rotation * OneRadian : 0, realFrom.x, realFrom.y) : Platform.canvas.createRadialGradient(realFrom.x, realFrom.y, 0, realFrom.x, realFrom.y, getDistance$1(realFrom, realTo));
         const data = {
             type: type,
             style: style
@@ -12144,11 +12173,7 @@ var LeaferUI = function(exports) {
                                     });
                                     if (isObject(check)) value = check; else if (check === false) return;
                                 }
-                                if (t.hasDimOthers) {
-                                    t.setDimOthers(false);
-                                    t.setBright(false);
-                                    t.hasDimOthers = undefined;
-                                }
+                                if (t.hasDimOthers) t.cancelDimOthers();
                                 if (isArray(value) && value.length > 1 && value[0].locked) value.splice(0, 1);
                                 if (t.single) {
                                     delete t.element.syncEventer;
@@ -13055,6 +13080,8 @@ var LeaferUI = function(exports) {
                 editor.setDimOthers(dimOthers);
                 editor.setBright(!!dimOthers || bright);
                 editor.hasDimOthers = true;
+            } else if (editor.hasDimOthers) {
+                editor.cancelDimOthers();
             }
             if (spread) BoundsHelper.spread(bounds, spread);
             if (this.view.worldOpacity) {
@@ -14044,6 +14071,11 @@ var LeaferUI = function(exports) {
         setBright(value) {
             this.setDimOthers(value, "bright", this.list);
         }
+        cancelDimOthers() {
+            this.setDimOthers(false);
+            this.setBright(false);
+            this.hasDimOthers = undefined;
+        }
         update() {
             if (this.editing) {
                 if (!this.element.parent) return this.cancel();
@@ -14495,7 +14527,7 @@ var LeaferUI = function(exports) {
         }
     };
     exports.LineEditTool = __decorate([ registerEditTool() ], exports.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) {
             if (!data) return;
@@ -14504,13 +14536,13 @@ var LeaferUI = function(exports) {
             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;
@@ -14520,7 +14552,7 @@ var LeaferUI = function(exports) {
                     i += 5;
                     break;
 
-                  case Z$2:
+                  case Z$3:
                     i += 1;
                     break;
 
@@ -15104,13 +15136,13 @@ var LeaferUI = function(exports) {
             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++;
@@ -15119,7 +15151,7 @@ var LeaferUI = function(exports) {
                 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) {
@@ -15130,14 +15162,14 @@ var LeaferUI = function(exports) {
             data.center = add.center;
         },
         reset() {
-            const {state: state} = M$3;
+            const {state: state} = M$4;
             state.type = "none";
             state.typeCount = 0;
             state.startTime = 0;
             state.totalData = null;
         }
     };
-    const M$3 = MultiTouchHelper;
+    const M$4 = MultiTouchHelper;
     const {abs: abs$2, max: max$1} = Math, {sign: sign, within: within$2} = MathHelper;
     const WheelEventHelper = {
         getMove(event, config) {
@@ -15867,7 +15899,7 @@ var LeaferUI = function(exports) {
     __decorate([ dataProcessor(ArrowData) ], exports.Arrow.prototype, "__", void 0);
     __decorate([ arrowType("angle") ], exports.Arrow.prototype, "endArrow", void 0);
     exports.Arrow = __decorate([ registerUI() ], exports.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;
     const point$1 = {};
     const PathMatrixHelper = {
@@ -15876,13 +15908,13 @@ var LeaferUI = function(exports) {
             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;
@@ -16082,7 +16114,7 @@ var LeaferUI = function(exports) {
         if (fill) arrowData.fill = fill;
         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;
     const {stintSet: stintSet$1} = DataHelper;
     const connectPoint = {};
@@ -16101,8 +16133,8 @@ var LeaferUI = function(exports) {
             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]);
@@ -16111,7 +16143,7 @@ var LeaferUI = function(exports) {
                     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];
@@ -16127,7 +16159,7 @@ var LeaferUI = function(exports) {
                     i += 5;
                     break;
 
-                  case Z$1:
+                  case Z$2:
                     return;
 
                   case N:
@@ -16171,8 +16203,8 @@ var LeaferUI = function(exports) {
                     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) {
@@ -16194,11 +16226,11 @@ var LeaferUI = function(exports) {
                             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;
 
@@ -17790,7 +17822,7 @@ var LeaferUI = function(exports) {
         }
     };
     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 = {};
     const HighCurveHelper = {
         transform(data, matrix) {
@@ -17799,18 +17831,18 @@ var LeaferUI = function(exports) {
             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;
                 }
             }
@@ -17831,17 +17863,17 @@ var LeaferUI = function(exports) {
             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);
@@ -17850,7 +17882,7 @@ var LeaferUI = function(exports) {
                     i += 7;
                     break;
 
-                  case Z:
+                  case Z$1:
                     i += 1;
 
                   default:
@@ -17875,8 +17907,8 @@ var LeaferUI = function(exports) {
             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];
@@ -17895,7 +17927,7 @@ var LeaferUI = function(exports) {
                     i += 3;
                     break;
 
-                  case C:
+                  case C$1:
                     toX = data[i + 5];
                     toY = data[i + 6];
                     distance = segments[index];
@@ -17911,7 +17943,7 @@ var LeaferUI = function(exports) {
                     i += 7;
                     break;
 
-                  case Z:
+                  case Z$1:
                     i += 1;
 
                   default:
@@ -17932,8 +17964,8 @@ var LeaferUI = function(exports) {
             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];
@@ -17956,7 +17988,7 @@ var LeaferUI = function(exports) {
                     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];
@@ -17975,7 +18007,7 @@ var LeaferUI = function(exports) {
                     path.push(command, x1, y1, x2, y2, toX, toY);
                     break;
 
-                  case Z:
+                  case Z$1:
                     i += 1;
                     path.push(command);
 
@@ -19322,6 +19354,256 @@ var LeaferUI = function(exports) {
     __decorate([ boundsType("") ], exports.ImageBox.prototype, "url", void 0);
     exports.ImageBox = __decorate([ registerUI() ], exports.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");
     exports.AlignHelper = AlignHelper;
     exports.AnimateEasing = AnimateEasing;
     exports.AnimateEvent = AnimateEvent;