@leafer/worker 2.1.3 → 2.1.5

package/dist/worker.js

@@ -240,7 +240,7 @@ var LeaferUI = function(exports) {
         RUNTIME: "runtime",
         LEAF: "leaf",
         TASK: "task",
-        CNAVAS: "canvas",
+        CANVAS: "canvas",
         IMAGE: "image",
         types: {},
         create(typeName) {
@@ -434,7 +434,7 @@ var LeaferUI = function(exports) {
     }
     const {sin: sin$6, cos: cos$6, acos: acos, sqrt: sqrt$5} = Math;
     const {float: float$6} = MathHelper;
-    const tempPoint$5 = {};
+    const tempPoint$6 = {};
     function getWorld() {
         return Object.assign(Object.assign(Object.assign({}, getMatrixData()), getBoundsData()), {
             scaleX: 1,
@@ -491,8 +491,8 @@ var LeaferUI = function(exports) {
             to.f = t.f * pixelRatio;
         },
         scaleOfOuter(t, origin, scaleX, scaleY) {
-            M$c.toInnerPoint(t, origin, tempPoint$5);
-            M$c.scaleOfInner(t, tempPoint$5, scaleX, scaleY);
+            M$c.toInnerPoint(t, origin, tempPoint$6);
+            M$c.scaleOfInner(t, tempPoint$6, scaleX, scaleY);
         },
         scaleOfInner(t, origin, scaleX, scaleY = scaleX) {
             M$c.translateInner(t, origin.x, origin.y);
@@ -510,8 +510,8 @@ var LeaferUI = function(exports) {
             t.d = c * sinR + d * cosR;
         },
         rotateOfOuter(t, origin, rotation) {
-            M$c.toInnerPoint(t, origin, tempPoint$5);
-            M$c.rotateOfInner(t, tempPoint$5, rotation);
+            M$c.toInnerPoint(t, origin, tempPoint$6);
+            M$c.rotateOfInner(t, tempPoint$6, rotation);
         },
         rotateOfInner(t, origin, rotation) {
             M$c.translateInner(t, origin.x, origin.y);
@@ -532,8 +532,8 @@ var LeaferUI = function(exports) {
             }
         },
         skewOfOuter(t, origin, skewX, skewY) {
-            M$c.toInnerPoint(t, origin, tempPoint$5);
-            M$c.skewOfInner(t, tempPoint$5, skewX, skewY);
+            M$c.toInnerPoint(t, origin, tempPoint$6);
+            M$c.skewOfInner(t, tempPoint$6, skewX, skewY);
         },
         skewOfInner(t, origin, skewX, skewY = 0) {
             M$c.translateInner(t, origin.x, origin.y);
@@ -729,7 +729,7 @@ var LeaferUI = function(exports) {
     };
     const M$c = MatrixHelper;
     const {float: float$5} = MathHelper;
-    const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
+    const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$4} = MatrixHelper;
     const {sin: sin$5, cos: cos$5, abs: abs$b, sqrt: sqrt$4, atan2: atan2$2, min: min$3, round: round$5} = Math;
     const PointHelper = {
         defaultPoint: getPointData(),
@@ -785,7 +785,7 @@ var LeaferUI = function(exports) {
         tempToOuterOf(t, matrix) {
             const {tempPoint: temp} = P$7;
             copy$c(temp, t);
-            toOuterPoint$3(matrix, temp, temp);
+            toOuterPoint$4(matrix, temp, temp);
             return temp;
         },
         tempToInnerRadiusPointOf(t, matrix) {
@@ -809,7 +809,7 @@ var LeaferUI = function(exports) {
             toInnerPoint$2(matrix, t, to);
         },
         toOuterOf(t, matrix, to) {
-            toOuterPoint$3(matrix, t, to);
+            toOuterPoint$4(matrix, t, to);
         },
         getCenter(t, to) {
             return {
@@ -869,7 +869,7 @@ var LeaferUI = function(exports) {
             return quick ? t.x === point.x && t.y === point.y : float$5(t.x) === float$5(point.x) && float$5(t.y) === float$5(point.y);
         },
         reset(t) {
-            P$7.reset(t);
+            t.x = t.y = 0;
         }
     };
     const P$7 = PointHelper;
@@ -946,7 +946,7 @@ var LeaferUI = function(exports) {
             return this;
         }
     }
-    const tempPoint$4 = new Point;
+    const tempPoint$5 = new Point;
     class Matrix {
         constructor(a, b, c, d, e, f) {
             this.set(a, b, c, d, e, f);
@@ -1073,6 +1073,7 @@ var LeaferUI = function(exports) {
         }
         reset() {
             MatrixHelper.reset(this);
+            return this;
         }
     }
     const tempMatrix$2 = new Matrix;
@@ -1199,7 +1200,7 @@ var LeaferUI = function(exports) {
         }
     };
     const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$5, addPoint: addPoint$3, toBounds: toBounds$3} = TwoPointBoundsHelper;
-    const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
+    const {toOuterPoint: toOuterPoint$3} = MatrixHelper;
     const {float: float$4, fourNumber: fourNumber$1} = MathHelper;
     const {floor: floor$2, ceil: ceil$2} = Math;
     let right$4, bottom$3, boundsRight, boundsBottom;
@@ -1306,16 +1307,16 @@ var LeaferUI = function(exports) {
             } else {
                 point$2.x = t.x;
                 point$2.y = t.y;
-                toOuterPoint$2(matrix, point$2, toPoint$5);
+                toOuterPoint$3(matrix, point$2, toPoint$5);
                 setPoint$5(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
                 point$2.x = t.x + t.width;
-                toOuterPoint$2(matrix, point$2, toPoint$5);
+                toOuterPoint$3(matrix, point$2, toPoint$5);
                 addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
                 point$2.y = t.y + t.height;
-                toOuterPoint$2(matrix, point$2, toPoint$5);
+                toOuterPoint$3(matrix, point$2, toPoint$5);
                 addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
                 point$2.x = t.x;
-                toOuterPoint$2(matrix, point$2, toPoint$5);
+                toOuterPoint$3(matrix, point$2, toPoint$5);
                 addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
                 toBounds$3(tempPointBounds$1, to);
             }
@@ -2177,7 +2178,7 @@ var LeaferUI = function(exports) {
             this.worldTransform = {};
             if (!config) config = minSize;
             this.manager = manager;
-            this.innerId = IncrementId.create(IncrementId.CNAVAS);
+            this.innerId = IncrementId.create(IncrementId.CANVAS);
             const {width: width, height: height, pixelRatio: pixelRatio} = config;
             this.autoLayout = !width || !height;
             this.size.pixelRatio = pixelRatio || Platform.devicePixelRatio;
@@ -2327,6 +2328,7 @@ var LeaferUI = function(exports) {
         }
         useGrayscaleAlpha(bounds) {
             this.setTempPixelBounds(bounds, true, true);
+            if (!tempPixelBounds.width || !tempPixelBounds.height) return;
             let alpha, pixel;
             const {context: context} = this, imageData = context.getImageData(tempPixelBounds.x, tempPixelBounds.y, tempPixelBounds.width, tempPixelBounds.height), {data: data} = imageData;
             for (let i = 0, len = data.length; i < len; i += 4) {
@@ -2522,7 +2524,7 @@ var LeaferUI = function(exports) {
     const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
     const {set: set$1, toNumberPoints: toNumberPoints$1} = PointHelper;
     const {M: M$b, L: L$b, C: C$9, Q: Q$7, Z: Z$9} = PathCommandMap;
-    const tempPoint$3 = {};
+    const tempPoint$4 = {};
     const BezierHelper = {
         points(data, originPoints, curve, close) {
             let points = toNumberPoints$1(originPoints);
@@ -2607,10 +2609,10 @@ var LeaferUI = function(exports) {
             const centerY = y1 + c * sin$4(startRadian + totalRadian / 2 + PI_2 * sign);
             startRadian -= PI_2 * sign;
             endRadian -= PI_2 * sign;
-            return ellipse$8(data, centerX, centerY, radius, radius, 0, startRadian / OneRadian, endRadian / OneRadian, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
+            return ellipse$7(data, centerX, centerY, radius, radius, 0, startRadian / OneRadian, endRadian / OneRadian, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
         },
         arc(data, x, y, radius, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint) {
-            return ellipse$8(data, x, y, radius, radius, 0, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
+            return ellipse$7(data, x, y, radius, radius, 0, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
         },
         ellipse(data, cx, cy, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint) {
             const rotationRadian = rotation * OneRadian;
@@ -2692,8 +2694,8 @@ var LeaferUI = function(exports) {
             addMode ? addPoint$2(pointBounds, fromX, fromY) : setPoint$4(pointBounds, fromX, fromY);
             addPoint$2(pointBounds, toX, toY);
             for (let i = 0, len = tList.length; i < len; i++) {
-                getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$3);
-                addPoint$2(pointBounds, tempPoint$3.x, tempPoint$3.y);
+                getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$4);
+                addPoint$2(pointBounds, tempPoint$4.x, tempPoint$4.y);
             }
         },
         getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, setPoint) {
@@ -2737,9 +2739,9 @@ var LeaferUI = function(exports) {
             };
         }
     };
-    const {getPointAndSet: getPointAndSet, toTwoPointBounds: toTwoPointBounds$1, ellipse: ellipse$8} = BezierHelper;
+    const {getPointAndSet: getPointAndSet, toTwoPointBounds: toTwoPointBounds$1, ellipse: ellipse$7} = BezierHelper;
     const {sin: sin$3, cos: cos$3, sqrt: sqrt$2, atan2: atan2} = Math;
-    const {ellipse: ellipse$7} = BezierHelper;
+    const {ellipse: ellipse$6} = BezierHelper;
     const EllipseHelper = {
         ellipticalArc(data, fromX, fromY, radiusX, radiusY, rotation, largeFlag, sweepFlag, toX, toY, curveMode) {
             const halfX = (toX - fromX) / 2;
@@ -2776,7 +2778,7 @@ var LeaferUI = function(exports) {
             const centerY = fromY + halfY + rotationSin * cx + rotationCos * cy;
             const anticlockwise = totalRadian < 0 ? 1 : 0;
             if (curveMode || Platform.ellipseToCurve) {
-                ellipse$7(data, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
+                ellipse$6(data, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
             } else {
                 if (radiusX === radiusY && !rotation) {
                     data.push(PathCommandMap.O, centerX, centerY, radiusX, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
@@ -2795,7 +2797,7 @@ var LeaferUI = function(exports) {
         }
     };
     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 {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$4, arc: arc$3, ellipse: ellipse$5, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
     const {ellipticalArc: ellipticalArc} = EllipseHelper;
     const debug$f = Debug.get("PathConvert");
     const setEndPoint$1 = {};
@@ -2850,7 +2852,8 @@ var LeaferUI = function(exports) {
                     current.length = PathCommandLengthMap[char];
                     current.index = 0;
                     pushData(data, current.name);
-                    if (char === "m") current.name = PathCommandMap["l"]; else if (char === "M") current.name = PathCommandMap["L"]; else if (!needConvert && convertCommand[char]) needConvert = true;
+                    if (char === "m") current.name = PathCommandMap["l"]; else if (char === "M") current.name = PathCommandMap["L"];
+                    if (!needConvert && convertCommand[char]) needConvert = true;
                 } else {
                     if (char === "-" || char === "+") {
                         if (lastChar === "e" || lastChar === "E") {
@@ -2926,8 +2929,8 @@ var LeaferUI = function(exports) {
 
                   case 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];
+                    x1 = smooth ? x * 2 - controlX : x;
+                    y1 = smooth ? y * 2 - controlY : y;
                     controlX = old[i + 1];
                     controlY = old[i + 2];
                     x = old[i + 3];
@@ -2961,8 +2964,8 @@ var LeaferUI = function(exports) {
 
                   case T:
                     smooth = lastCommand === Q$6 || lastCommand === T;
-                    controlX = smooth ? x * 2 - controlX : old[i + 1];
-                    controlY = smooth ? y * 2 - controlY : old[i + 2];
+                    controlX = smooth ? x * 2 - controlX : x;
+                    controlY = smooth ? y * 2 - controlY : y;
                     curveMode ? quadraticCurveTo$1(data, x, y, controlX, controlY, old[i + 1], old[i + 2]) : data.push(Q$6, controlX, controlY, old[i + 1], old[i + 2]);
                     x = old[i + 1];
                     y = old[i + 2];
@@ -3026,14 +3029,14 @@ var LeaferUI = function(exports) {
                     break;
 
                   case G$5:
-                    ellipse$6(curveMode ? data : copyData(data, old, i, 9), old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], old[i + 6], old[i + 7], old[i + 8], null, setEndPoint$1);
+                    ellipse$5(curveMode ? data : copyData(data, old, i, 9), old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], old[i + 6], old[i + 7], old[i + 8], null, setEndPoint$1);
                     x = setEndPoint$1.x;
                     y = setEndPoint$1.y;
                     i += 9;
                     break;
 
                   case F$6:
-                    curveMode ? ellipse$6(data, old[i + 1], old[i + 2], old[i + 3], old[i + 4], 0, 0, 360, false) : copyData(data, old, i, 5);
+                    curveMode ? ellipse$5(data, old[i + 1], old[i + 2], old[i + 3], old[i + 4], 0, 0, 360, false) : copyData(data, old, i, 5);
                     x = old[i + 1] + old[i + 3];
                     y = old[i + 2];
                     i += 5;
@@ -3181,7 +3184,7 @@ 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$9, startPoint.x, startPoint.y);
-            ellipse$5(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+            ellipse$4(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);
@@ -3192,8 +3195,8 @@ var LeaferUI = function(exports) {
             BezierHelper.points(data, points, curve, close);
         }
     };
-    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$3, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
+    const {ellipse: ellipse$4, 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$3, arc: arc$1, arcTo: arcTo$3, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
     class PathCreator {
         set path(value) {
             this.__path = value;
@@ -3249,7 +3252,7 @@ var LeaferUI = function(exports) {
             return this;
         }
         ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
-            ellipse$4(this.__path, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+            ellipse$3(this.__path, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
             this.paint();
             return this;
         }
@@ -3366,7 +3369,7 @@ var LeaferUI = function(exports) {
         }
     };
     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 {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$2, arc: arc, ellipse: ellipse$2} = 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;
@@ -3442,7 +3445,7 @@ var LeaferUI = function(exports) {
                     break;
 
                   case G$2:
-                    ellipse$3(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8], tempPointBounds, setEndPoint);
+                    ellipse$2(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8], tempPointBounds, setEndPoint);
                     i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                     x = setEndPoint.x;
                     y = setEndPoint.y;
@@ -4474,7 +4477,7 @@ var LeaferUI = function(exports) {
             EventCreator.register(target);
         };
     }
-    const {copy: copy$8, toInnerPoint: toInnerPoint$1, toOuterPoint: toOuterPoint$1, scaleOfOuter: scaleOfOuter$2, rotateOfOuter: rotateOfOuter$2, skewOfOuter: skewOfOuter, multiplyParent: multiplyParent$3, divideParent: divideParent, getLayout: getLayout} = MatrixHelper;
+    const {copy: copy$8, toInnerPoint: toInnerPoint$1, toOuterPoint: toOuterPoint$2, scaleOfOuter: scaleOfOuter$2, rotateOfOuter: rotateOfOuter$2, skewOfOuter: skewOfOuter, multiplyParent: multiplyParent$3, divideParent: divideParent, getLayout: getLayout} = MatrixHelper;
     const matrix$3 = {}, {round: round$3} = Math;
     const LeafHelper = {
         updateAllMatrix(leaf, checkAutoLayout, waitAutoLayout) {
@@ -4555,7 +4558,7 @@ var LeaferUI = function(exports) {
                 x: x,
                 y: y
             };
-            isInnerPoint ? toOuterPoint$1(t.localTransform, local, local, true) : t.parent && toInnerPoint$1(t.parent.scrollWorldTransform, local, local, true);
+            isInnerPoint ? toOuterPoint$2(t.localTransform, local, local, true) : t.parent && toInnerPoint$1(t.parent.scrollWorldTransform, local, local, true);
             L$5.moveLocal(t, local.x, local.y, transition);
         },
         moveLocal(t, x, y = 0, transition) {
@@ -4568,10 +4571,10 @@ var LeaferUI = function(exports) {
                 y: y
             }, transition) : (t.x = x, t.y = y);
         },
-        zoomOfWorld(t, origin, scaleX, scaleY, resize, transition) {
-            L$5.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
+        zoomOfWorld(t, origin, scaleX, scaleY, resize, transition, boundsType) {
+            L$5.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition, boundsType);
         },
-        zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition) {
+        zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition, boundsType) {
             const o = t.__localMatrix;
             if (!isNumber(scaleY)) {
                 if (scaleY) transition = scaleY;
@@ -4580,7 +4583,7 @@ var LeaferUI = function(exports) {
             copy$8(matrix$3, o);
             scaleOfOuter$2(matrix$3, origin, scaleX, scaleY);
             if (L$5.hasHighPosition(t)) {
-                L$5.setTransform(t, matrix$3, resize, transition);
+                L$5.setTransform(t, matrix$3, resize, transition, boundsType);
             } else {
                 const x = t.x + matrix$3.e - o.e, y = t.y + matrix$3.f - o.f;
                 if (transition && !resize) t.animate({
@@ -4588,7 +4591,7 @@ var LeaferUI = function(exports) {
                     y: y,
                     scaleX: t.scaleX * scaleX,
                     scaleY: t.scaleY * scaleY
-                }, transition); else t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true);
+                }, transition); else t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true, boundsType);
             }
         },
         rotateOfWorld(t, origin, angle, transition) {
@@ -4612,18 +4615,18 @@ var LeaferUI = function(exports) {
             skewOfOuter(matrix$3, origin, skewX, skewY);
             L$5.setTransform(t, matrix$3, resize, transition);
         },
-        transformWorld(t, transform, resize, transition) {
+        transformWorld(t, transform, resize, transition, boundsType) {
             copy$8(matrix$3, t.worldTransform);
             multiplyParent$3(matrix$3, transform);
             if (t.parent) divideParent(matrix$3, t.parent.scrollWorldTransform);
-            L$5.setTransform(t, matrix$3, resize, transition);
+            L$5.setTransform(t, matrix$3, resize, transition, boundsType);
         },
-        transform(t, transform, resize, transition) {
+        transform(t, transform, resize, transition, boundsType) {
             copy$8(matrix$3, t.localTransform);
             multiplyParent$3(matrix$3, transform);
-            L$5.setTransform(t, matrix$3, resize, transition);
+            L$5.setTransform(t, matrix$3, resize, transition, boundsType);
         },
-        setTransform(t, transform, resize, transition) {
+        setTransform(t, transform, resize, transition, boundsType) {
             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)) {
@@ -4639,7 +4642,7 @@ var LeaferUI = function(exports) {
                     PointHelper.move(layout, originPoint.x - changedPoint.x, originPoint.y - changedPoint.y);
                 }
                 t.set(layout);
-                t.scaleResize(scaleX, scaleY, false);
+                t.scaleResize(scaleX, scaleY, false, boundsType);
             } else t.set(layout, transition);
         },
         getFlipTransform(t, axis) {
@@ -4841,11 +4844,11 @@ var LeaferUI = function(exports) {
                 w.height *= scaleY;
                 w.scaleX *= scaleX;
                 w.scaleY *= scaleY;
-                if (branch.isBranch) scale$3(branch, x, y, scaleX, scaleY, a, b);
+                if (branch.isBranch) scale$4(branch, x, y, scaleX, scaleY, a, b);
             }
         }
     };
-    const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$9, scale: scale$3} = BranchHelper;
+    const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$9, scale: scale$4} = BranchHelper;
     const WaitHelper = {
         run(wait) {
             if (wait && wait.length) {
@@ -5206,6 +5209,7 @@ var LeaferUI = function(exports) {
             this.renderChanged = true;
             this.renderSpread || (this.renderSpread = 1);
             this.boundsChanged = true;
+            this.hitCanvasChanged = true;
         }
         scaleChange() {
             this.scaleChanged = true;
@@ -5638,7 +5642,7 @@ var LeaferUI = function(exports) {
         }
     };
     const {setLayout: setLayout, multiplyParent: multiplyParent$2, translateInner: translateInner, defaultWorld: defaultWorld} = MatrixHelper;
-    const {toPoint: toPoint$4, tempPoint: tempPoint$2} = AroundHelper;
+    const {toPoint: toPoint$4, tempPoint: tempPoint$3} = AroundHelper;
     const LeafMatrix = {
         __updateWorldMatrix() {
             const {parent: parent, __layout: __layout, __world: __world, __scrollWorld: __scrollWorld, __: __} = this;
@@ -5658,8 +5662,8 @@ var LeaferUI = function(exports) {
                 local.e = data.x + data.offsetX;
                 local.f = data.y + data.offsetY;
                 if (data.around || data.origin) {
-                    toPoint$4(data.around || data.origin, layout.boxBounds, tempPoint$2);
-                    translateInner(local, -tempPoint$2.x, -tempPoint$2.y, !data.around);
+                    toPoint$4(data.around || data.origin, layout.boxBounds, tempPoint$3);
+                    translateInner(local, -tempPoint$3.x, -tempPoint$3.y, !data.around);
                 }
             }
             this.__layout.matrixChanged = undefined;
@@ -5880,7 +5884,7 @@ var LeaferUI = function(exports) {
     };
     const {LEAF: LEAF, create: create} = IncrementId;
     const {stintSet: stintSet$6} = DataHelper;
-    const {toInnerPoint: toInnerPoint, toOuterPoint: toOuterPoint, multiplyParent: multiplyParent$1} = MatrixHelper;
+    const {toInnerPoint: toInnerPoint, toOuterPoint: toOuterPoint$1, multiplyParent: multiplyParent$1} = MatrixHelper;
     const {toOuterOf: toOuterOf$1} = BoundsHelper;
     const {copy: copy$5, move: move$8} = PointHelper;
     const {getScaleFixedData: getScaleFixedData$1} = MathHelper;
@@ -6052,10 +6056,6 @@ var LeaferUI = function(exports) {
                 }
             }
         }
-        set(_data, _isTemp) {}
-        get(_name) {
-            return undefined;
-        }
         setAttr(name, value) {
             this[name] = value;
         }
@@ -6072,37 +6072,10 @@ var LeaferUI = function(exports) {
         toString(options) {
             return JSON.stringify(this.toJSON(options));
         }
-        toSVG() {
-            return undefined;
-        }
-        __SVG(_data) {}
-        toHTML() {
-            return undefined;
-        }
-        __setAttr(_attrName, _newValue) {
-            return true;
-        }
-        __getAttr(_attrName) {
-            return undefined;
-        }
-        setProxyAttr(_attrName, _newValue) {}
-        getProxyAttr(_attrName) {
-            return undefined;
-        }
-        find(_condition, _options) {
-            return undefined;
-        }
-        findTag(_tag) {
-            return undefined;
-        }
-        findOne(_condition, _options) {
-            return undefined;
-        }
-        findId(_id) {
-            return undefined;
+        scaleResize(scaleX, scaleY = scaleX, _noResize, _boundsType) {
+            this.scaleX *= scaleX;
+            this.scaleY *= scaleY;
         }
-        focus(_value) {}
-        updateState() {}
         updateLayout() {
             this.__layout.update();
         }
@@ -6118,27 +6091,6 @@ var LeaferUI = function(exports) {
         __extraUpdate() {
             if (this.leaferIsReady) this.leafer.layouter.addExtra(this);
         }
-        __updateWorldMatrix() {}
-        __updateLocalMatrix() {}
-        __updateWorldBounds() {}
-        __updateLocalBounds() {}
-        __updateLocalBoxBounds() {}
-        __updateLocalStrokeBounds() {}
-        __updateLocalRenderBounds() {}
-        __updateBoxBounds(_secondLayout, _bounds) {}
-        __updateContentBounds() {}
-        __updateStrokeBounds(_bounds) {}
-        __updateRenderBounds(_bounds) {}
-        __updateAutoLayout() {}
-        __updateFlowLayout() {}
-        __updateNaturalSize() {}
-        __updateStrokeSpread() {
-            return 0;
-        }
-        __updateRenderSpread() {
-            return 0;
-        }
-        __onUpdateSize() {}
         __updateEraser(value) {
             this.__hasEraser = value ? true : this.children.some(item => item.__.eraser);
         }
@@ -6152,7 +6104,6 @@ var LeaferUI = function(exports) {
         __updateMask(_value) {
             this.__hasMask = this.children.some(item => item.__.mask && item.__.visible && item.__.opacity);
         }
-        __renderMask(_canvas, _options) {}
         __getNowWorld(options) {
             if (options.matrix) {
                 if (!this.__cameraWorld) this.__cameraWorld = {};
@@ -6214,7 +6165,7 @@ var LeaferUI = function(exports) {
             toInnerPoint(this.worldTransform, world, to, distance);
         }
         innerToWorld(inner, to, distance, relative) {
-            toOuterPoint(this.worldTransform, inner, to, distance);
+            toOuterPoint$1(this.worldTransform, inner, to, distance);
             if (relative) relative.worldToInner(to ? to : inner, null, distance);
         }
         getBoxPoint(world, relative, distance, change) {
@@ -6269,11 +6220,11 @@ var LeaferUI = function(exports) {
             const layer = this.leafer ? this.leafer.zoomLayer : this;
             return layer.getWorldPoint(page, relative, distance, change);
         }
-        setTransform(matrix, resize, transition) {
-            setTransform(this, matrix, resize, transition);
+        setTransform(matrix, resize, transition, boundsType) {
+            setTransform(this, matrix, resize, transition, boundsType);
         }
-        transform(matrix, resize, transition) {
-            transform(this, matrix, resize, transition);
+        transform(matrix, resize, transition, boundsType) {
+            transform(this, matrix, resize, transition, boundsType);
         }
         move(x, y, transition) {
             moveLocal(this, x, y, transition);
@@ -6281,8 +6232,8 @@ var LeaferUI = function(exports) {
         moveInner(x, y, transition) {
             moveWorld(this, x, y, true, transition);
         }
-        scaleOf(origin, scaleX, scaleY, resize, transition) {
-            zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition);
+        scaleOf(origin, scaleX, scaleY, resize, transition, boundsType) {
+            zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition, boundsType);
         }
         rotateOf(origin, rotation, transition) {
             rotateOfLocal(this, getLocalOrigin(this, origin), rotation, transition);
@@ -6290,14 +6241,14 @@ var LeaferUI = function(exports) {
         skewOf(origin, skewX, skewY, resize, transition) {
             skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize, transition);
         }
-        transformWorld(worldTransform, resize, transition) {
-            transformWorld(this, worldTransform, resize, transition);
+        transformWorld(worldTransform, resize, transition, boundsType) {
+            transformWorld(this, worldTransform, resize, transition, boundsType);
         }
         moveWorld(x, y, transition) {
             moveWorld(this, x, y, false, transition);
         }
-        scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition) {
-            zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition);
+        scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition, boundsType) {
+            zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition, boundsType);
         }
         rotateOfWorld(worldOrigin, rotation) {
             rotateOfWorld(this, worldOrigin, rotation);
@@ -6308,76 +6259,12 @@ var LeaferUI = function(exports) {
         flip(axis, transition) {
             transform(this, getFlipTransform(this, axis), false, transition);
         }
-        scaleResize(scaleX, scaleY = scaleX, _noResize) {
-            this.scaleX *= scaleX;
-            this.scaleY *= scaleY;
-        }
-        __scaleResize(_scaleX, _scaleY) {}
-        resizeWidth(_width) {}
-        resizeHeight(_height) {}
-        hit(_world, _hitRadius) {
-            return true;
-        }
-        __hitWorld(_point, _forceHitFill) {
-            return true;
-        }
-        __hit(_local, _forceHitFill) {
-            return true;
-        }
-        __hitFill(_inner) {
-            return true;
-        }
-        __hitStroke(_inner, _strokeWidth) {
-            return true;
-        }
-        __hitPixel(_inner) {
-            return true;
-        }
-        __drawHitPath(_canvas) {}
-        __updateHitCanvas() {}
-        __render(_canvas, _options) {}
-        __drawFast(_canvas, _options) {}
-        __draw(_canvas, _options, _originCanvas) {}
-        __clip(_canvas, _options) {}
-        __renderShape(_canvas, _options) {}
-        __drawShape(_canvas, _options) {}
-        __updateWorldOpacity() {}
-        __updateChange() {}
-        __drawPath(_canvas) {}
-        __drawRenderPath(_canvas) {}
-        __updatePath() {}
-        __updateRenderPath(_updateCache) {}
-        getMotionPathData() {
-            return Plugin.need("path");
-        }
-        getMotionPoint(_motionDistance) {
-            return Plugin.need("path");
-        }
-        getMotionTotal() {
-            return 0;
-        }
-        __updateMotionPath() {}
-        __runAnimation(_type, _complete) {}
-        __updateSortChildren() {}
-        add(_child, _index) {}
         remove(_child, destroy) {
             if (this.parent) this.parent.remove(this, destroy);
         }
         dropTo(parent, index, resize) {
             drop(this, parent, index, resize);
         }
-        on(_type, _listener, _options) {}
-        off(_type, _listener, _options) {}
-        on_(_type, _listener, _bind, _options) {
-            return undefined;
-        }
-        off_(_id) {}
-        once(_type, _listener, _captureOrBind, _capture) {}
-        emit(_type, _event, _capture) {}
-        emitEvent(_event, _capture) {}
-        hasEvent(_type, _capture) {
-            return false;
-        }
         static changeAttr(attrName, defaultValue, fn) {
             fn ? this.addAttr(attrName, defaultValue, fn) : defineDataProcessor(this.prototype, attrName, defaultValue);
         }
@@ -6673,7 +6560,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "2.1.3";
+    const version = "2.1.5";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -7302,7 +7189,7 @@ var LeaferUI = function(exports) {
         }
     }
     Renderer.clipSpread = 10;
-    const tempPoint$1 = {};
+    const tempPoint$2 = {};
     const {copyRadiusPoint: copyRadiusPoint$1} = PointHelper;
     const {hitRadiusPoint: hitRadiusPoint$1} = BoundsHelper;
     class Picker {
@@ -7434,7 +7321,7 @@ var LeaferUI = function(exports) {
             for (let i = len - 1; i > -1; i--) {
                 child = children[i], data = child.__;
                 if (!data.visible || hitMask && !data.mask) continue;
-                hit = hitRadiusPoint$1(child.__world, data.hitRadius ? copyRadiusPoint$1(tempPoint$1, point, data.hitRadius) : point);
+                hit = hitRadiusPoint$1(child.__world, data.hitRadius ? copyRadiusPoint$1(tempPoint$2, point, data.hitRadius) : point);
                 if (child.isBranch) {
                     if (hit || child.__ignoreHitWorld) {
                         if (child.isBranchLeaf && data.__clipAfterFill && !child.__hitWorld(point, true)) continue;
@@ -8079,17 +7966,12 @@ var LeaferUI = function(exports) {
             if (!path) this.__drawPathByBox(pen);
             return pen;
         }
-        reset(_data) {}
         set(data, _transition) {
             if (data) Object.assign(this, data);
         }
         get(name) {
             return isString(name) ? this.__.__getInput(name) : this.__.__getInputData(name);
         }
-        createProxyData() {
-            return undefined;
-        }
-        clearProxyData() {}
         find(_condition, _options) {
             return Plugin.need("find");
         }
@@ -8127,6 +8009,7 @@ var LeaferUI = function(exports) {
                 data.lazy && !this.__inLazyBounds && !Export.running ? data.__needComputePaint = true : data.__computePaint();
             }
         }
+        __updatePath() {}
         __updateRenderPath(updateCache) {
             const data = this.__;
             if (data.path) {
@@ -8162,7 +8045,6 @@ var LeaferUI = function(exports) {
             this.set(keyframe);
             return Plugin.need("animate");
         }
-        killAnimate(_type, _nextStyle) {}
         export(_filename, _options) {
             return Plugin.need("export");
         }
@@ -8265,7 +8147,6 @@ var LeaferUI = function(exports) {
     __decorate([ surfaceType() ], exports.UI.prototype, "placeholderColor", void 0);
     __decorate([ dataType(100) ], exports.UI.prototype, "placeholderDelay", void 0);
     __decorate([ dataType({}) ], exports.UI.prototype, "data", void 0);
-    __decorate([ rewrite(exports.Leaf.prototype.reset) ], exports.UI.prototype, "reset", null);
     exports.UI = UI_1 = __decorate([ useModule(UIBounds), useModule(UIRender), rewriteAble() ], exports.UI);
     exports.Group = class Group extends exports.UI {
         get __tag() {
@@ -8301,9 +8182,6 @@ var LeaferUI = function(exports) {
             }
             return data;
         }
-        pick(_hitPoint, _options) {
-            return undefined;
-        }
         addAt(child, index) {
             this.add(child, index);
         }
@@ -8313,11 +8191,6 @@ var LeaferUI = function(exports) {
         addBefore(child, before) {
             this.add(child, this.children.indexOf(before));
         }
-        add(_child, _index) {}
-        addMany(..._children) {}
-        remove(_child, _destroy) {}
-        removeAll(_destroy) {}
-        clear() {}
     };
     __decorate([ dataProcessor(GroupData) ], exports.Group.prototype, "__", void 0);
     __decorate([ boundsType(0) ], exports.Group.prototype, "width", void 0);
@@ -8819,7 +8692,7 @@ var LeaferUI = function(exports) {
     __decorate([ surfaceType("#FFFFFF") ], exports.Frame.prototype, "fill", void 0);
     __decorate([ affectRenderBoundsType("hide") ], exports.Frame.prototype, "overflow", void 0);
     exports.Frame = __decorate([ registerUI() ], exports.Frame);
-    const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse$2} = PathCommandDataHelper;
+    const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse$1} = PathCommandDataHelper;
     exports.Ellipse = class Ellipse extends exports.UI {
         get __tag() {
             return "Ellipse";
@@ -8831,21 +8704,21 @@ var LeaferUI = function(exports) {
             let open;
             if (innerRadius) {
                 if (startAngle || endAngle) {
-                    if (innerRadius < 1) ellipse$2(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false); else open = true;
-                    ellipse$2(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
+                    if (innerRadius < 1) ellipse$1(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false); else open = true;
+                    ellipse$1(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
                 } else {
                     if (innerRadius < 1) {
-                        ellipse$2(path, rx, ry, rx * innerRadius, ry * innerRadius);
+                        ellipse$1(path, rx, ry, rx * innerRadius, ry * innerRadius);
                         moveTo$3(path, width, ry);
                     }
-                    ellipse$2(path, rx, ry, rx, ry, 0, 360, 0, true);
+                    ellipse$1(path, rx, ry, rx, ry, 0, 360, 0, true);
                 }
             } else {
                 if (startAngle || endAngle) {
                     moveTo$3(path, rx, ry);
-                    ellipse$2(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
+                    ellipse$1(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
                 } else {
-                    ellipse$2(path, rx, ry, rx, ry);
+                    ellipse$1(path, rx, ry, rx, ry);
                 }
             }
             if (!open) closePath$2(path);
@@ -9171,51 +9044,6 @@ var LeaferUI = function(exports) {
             this.add(path);
             return this;
         }
-        beginPath() {
-            return this;
-        }
-        moveTo(_x, _y) {
-            return this;
-        }
-        lineTo(_x, _y) {
-            return this;
-        }
-        bezierCurveTo(_x1, _y1, _x2, _y2, _x, _y) {
-            return this;
-        }
-        quadraticCurveTo(_x1, _y1, _x, _y) {
-            return this;
-        }
-        closePath() {
-            return this;
-        }
-        rect(_x, _y, _width, _height) {
-            return this;
-        }
-        roundRect(_x, _y, _width, _height, _cornerRadius) {
-            return this;
-        }
-        ellipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) {
-            return this;
-        }
-        arc(_x, _y, _radius, _startAngle, _endAngle, _anticlockwise) {
-            return this;
-        }
-        arcTo(_x1, _y1, _x2, _y2, _radius) {
-            return this;
-        }
-        drawEllipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) {
-            return this;
-        }
-        drawArc(_x, _y, _radius, _startAngle, _endAngle, _anticlockwise) {
-            return this;
-        }
-        drawPoints(_points, _curve, _close) {
-            return this;
-        }
-        clearPath() {
-            return this;
-        }
         paint() {
             const {pathElement: pathElement} = this;
             if (!pathElement.__layout.boxChanged) pathElement.forceUpdate("path");
@@ -11041,7 +10869,7 @@ var LeaferUI = function(exports) {
                 needUpdate = false;
             }
         }
-        if (paint.mode === "brush") PaintImage.brush(leafPaint, ui);
+        if (paint.mode === "brush") PaintImage.brush(leafPaint, ui, attrName);
         if (!leafPaint.data) {
             PaintImage.createData(leafPaint, image, paint, boxBounds);
             const {transform: transform} = leafPaint.data, {opacity: opacity} = paint;
@@ -11236,7 +11064,7 @@ var LeaferUI = function(exports) {
         if (scaleX) scaleHelper(transform, scaleX, scaleY);
         translate(transform, box.x + x, box.y + y);
     }
-    const {get: get$1, scale: scale$2, copy: copy$4} = MatrixHelper;
+    const {get: get$1, scale: scale$3, copy: copy$4} = MatrixHelper;
     const {getFloorScale: getFloorScale} = MathHelper, {abs: abs$7} = Math;
     function createPatternTask(paint, ui, canvas, renderOptions) {
         if (!paint.patternTask) {
@@ -11271,7 +11099,7 @@ var LeaferUI = function(exports) {
                     scaleY *= getFloorScale(height + (yGap || 0));
                     imageMatrix = get$1();
                     if (transform) copy$4(imageMatrix, transform);
-                    scale$2(imageMatrix, 1 / scaleX, 1 / scaleY);
+                    scale$3(imageMatrix, 1 / scaleX, 1 / scaleY);
                 }
                 const imageCanvas = image.getCanvas(width, height, opacity, undefined, xGap, yGap, ui.leafer && ui.leafer.config.smooth, data.interlace);
                 if (brush) {
@@ -12250,10 +12078,11 @@ var LeaferUI = function(exports) {
                     if (innerEditor) innerEditor.editConfig && Object.assign(mergeConfig, innerEditor.editConfig); else if (editTool) editTool.editConfig && Object.assign(mergeConfig, editTool.editConfig);
                     if (element && element.editConfig) {
                         let {editConfig: editConfig} = element;
-                        if (editConfig.hover || editConfig.hoverStyle) {
+                        if (editConfig.hover || editConfig.hoverStyle || editConfig.hoverPathType) {
                             editConfig = Object.assign({}, editConfig);
                             delete editConfig.hover;
                             delete editConfig.hoverStyle;
+                            delete editConfig.hoverPathType;
                         }
                         Object.assign(mergeConfig, editConfig);
                     }
@@ -12314,9 +12143,22 @@ var LeaferUI = function(exports) {
                         matrix$1.half = strokeWidth % 2;
                         canvas.setWorld(matrix$1, options.matrix);
                         canvas.beginPath();
-                        if (this.strokePathType === "path") {
+                        switch (this.strokePathType) {
+                          case "box":
+                            const {boxBounds: boxBounds} = leaf.__layout;
+                            canvas.rect(boxBounds.x, boxBounds.y, boxBounds.width, boxBounds.height);
+                            break;
+
+                          case "stroke":
+                            const {strokeBounds: strokeBounds} = leaf.__layout;
+                            canvas.rect(strokeBounds.x, strokeBounds.y, strokeBounds.width, strokeBounds.height);
+                            break;
+
+                          case "path":
                             leaf.__drawPath(canvas);
-                        } else {
+                            break;
+
+                          default:
                             if (leaf.__.__useArrow) leaf.__drawPath(canvas); else leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
                         }
                         data.strokeWidth = strokeWidth / Math.max(aScaleX, aScaleY);
@@ -12431,10 +12273,11 @@ var LeaferUI = function(exports) {
             if (this.running && !this.dragging && !editor.dragging) {
                 const {hoverTarget: hoverTarget, mergeConfig: mergeConfig} = editor, config = Object.assign({}, mergeConfig);
                 if (hoverTarget && hoverTarget.editConfig) Object.assign(config, hoverTarget.editConfig);
-                const {stroke: stroke, strokeWidth: strokeWidth, hover: hover, hoverStyle: hoverStyle} = config;
+                const {stroke: stroke, strokeWidth: strokeWidth, hover: hover, hoverStyle: hoverStyle, hoverPathType: hoverPathType} = config;
                 this.hoverStroker.setTarget(hover ? hoverTarget : null, Object.assign({
                     stroke: stroke,
-                    strokeWidth: strokeWidth
+                    strokeWidth: strokeWidth,
+                    strokePathType: hoverPathType
                 }, hoverStyle || {}));
             } else {
                 this.hoverStroker.target = null;
@@ -12614,16 +12457,17 @@ var LeaferUI = function(exports) {
     const {topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bottomRight: bottomRight, bottom: bottom$1, bottomLeft: bottomLeft, left: left$2} = exports.Direction9;
     const {toPoint: toPoint} = AroundHelper, {within: within$3, sign: sign$1} = MathHelper, {abs: abs$4} = Math;
     const EditDataHelper = {
-        getScaleData(target, startBounds, direction, totalMoveOrScale, lockRatio, around, flipable, scaleMode) {
+        getScaleData(target, startBounds, direction, totalMoveOrScale, lockRatio, around, flipable, scaleMode, boundsType) {
             let align, origin = {}, scaleX = 1, scaleY = 1, lockScale;
-            const {boxBounds: boxBounds, widthRange: widthRange, heightRange: heightRange, dragBounds: dragBounds, worldBoxBounds: worldBoxBounds} = target;
+            const {widthRange: widthRange, heightRange: heightRange, dragBounds: dragBounds, worldTransform: worldTransform, boxBounds: boxBounds} = target;
             const {width: width, height: height} = startBounds;
+            const innerBounds = target.getBounds(boundsType, "inner");
             const originChangedScaleX = target.scaleX / startBounds.scaleX;
             const originChangedScaleY = target.scaleY / startBounds.scaleY;
             const signX = sign$1(originChangedScaleX);
             const signY = sign$1(originChangedScaleY);
-            const changedScaleX = scaleMode ? originChangedScaleX : signX * boxBounds.width / width;
-            const changedScaleY = scaleMode ? originChangedScaleY : signY * boxBounds.height / height;
+            const changedScaleX = scaleMode ? originChangedScaleX : signX * innerBounds.width / width;
+            const changedScaleY = scaleMode ? originChangedScaleY : signY * innerBounds.height / height;
             if (isNumber(totalMoveOrScale)) {
                 scaleX = scaleY = Math.sqrt(totalMoveOrScale);
             } else {
@@ -12709,10 +12553,11 @@ var LeaferUI = function(exports) {
             if (useScaleY) scaleY /= changedScaleY;
             if (!flipable) {
                 const {worldTransform: worldTransform} = target;
-                if (scaleX < 0) scaleX = 1 / boxBounds.width / worldTransform.scaleX;
-                if (scaleY < 0) scaleY = 1 / boxBounds.height / worldTransform.scaleY;
+                if (scaleX < 0) scaleX = 1 / innerBounds.width / worldTransform.scaleX;
+                if (scaleY < 0) scaleY = 1 / innerBounds.height / worldTransform.scaleY;
             }
-            toPoint(around || align, boxBounds, origin, true);
+            toPoint(around || align, innerBounds, origin, true);
+            this.checkOrigin(target, origin, boundsType);
             if (dragBounds) {
                 const scaleData = {
                     x: scaleX,
@@ -12723,15 +12568,20 @@ var LeaferUI = function(exports) {
                 scaleY = scaleData.y;
             }
             if (useScaleX && widthRange) {
-                const nowWidth = boxBounds.width * target.scaleX;
+                const nowWidth = innerBounds.width * target.scaleX;
                 scaleX = within$3(nowWidth * scaleX, widthRange) / nowWidth;
             }
             if (useScaleY && heightRange) {
-                const nowHeight = boxBounds.height * target.scaleY;
+                const nowHeight = innerBounds.height * target.scaleY;
                 scaleY = within$3(nowHeight * scaleY, heightRange) / nowHeight;
             }
-            if (useScaleX && abs$4(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
-            if (useScaleY && abs$4(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
+            let minWidth = 1 * abs$4(worldTransform.scaleX), minHeight = 1 * abs$4(worldTransform.scaleY);
+            if (boundsType !== "box") {
+                minWidth += innerBounds.width - boxBounds.width;
+                minHeight += innerBounds.height - boxBounds.height;
+            }
+            if (useScaleX && abs$4(scaleX * innerBounds.width) < minWidth) scaleX = sign$1(scaleX) * minWidth / innerBounds.width;
+            if (useScaleY && abs$4(scaleY * innerBounds.height) < minHeight) scaleY = sign$1(scaleY) * minHeight / innerBounds.height;
             if (lockRatio && scaleX !== scaleY) {
                 lockScale = Math.min(abs$4(scaleX), abs$4(scaleY));
                 scaleX = sign$1(scaleX) * lockScale;
@@ -12748,7 +12598,7 @@ var LeaferUI = function(exports) {
                 around: around
             };
         },
-        getRotateData(target, direction, current, last, around) {
+        getRotateData(target, direction, current, last, around, boundsType) {
             let align, origin = {};
             switch (direction) {
               case topLeft$1:
@@ -12770,13 +12620,14 @@ var LeaferUI = function(exports) {
               default:
                 align = "center";
             }
-            toPoint(around || align, target.boxBounds, origin, true);
+            toPoint(around || align, target.getBounds(boundsType, "inner"), origin, true);
+            this.checkOrigin(target, origin, boundsType);
             return {
                 origin: origin,
                 rotation: PointHelper.getRotation(last, target.getWorldPointByBox(origin), current)
             };
         },
-        getSkewData(bounds, direction, move, around) {
+        getSkewData(target, direction, move, around, boundsType) {
             let align, origin = {}, skewX = 0, skewY = 0;
             let last;
             switch (direction) {
@@ -12819,10 +12670,12 @@ var LeaferUI = function(exports) {
                 align = "left";
                 skewY = 1;
             }
-            const {width: width, height: height} = bounds;
+            const innerBounds = target.getBounds(boundsType, "inner");
+            const {width: width, height: height} = innerBounds;
             last.x = last.x * width;
             last.y = last.y * height;
-            toPoint(around || align, bounds, origin, true);
+            toPoint(around || align, innerBounds, origin, true);
+            this.checkOrigin(target, origin, boundsType);
             const rotation = PointHelper.getRotation(last, origin, {
                 x: last.x + (skewX ? move.x : 0),
                 y: last.y + (skewY ? move.y : 0)
@@ -12834,6 +12687,13 @@ var LeaferUI = function(exports) {
                 skewY: skewY
             };
         },
+        checkOrigin(target, origin, boundsType) {
+            if (boundsType !== "box") {
+                const {boxBounds: boxBounds} = target, innerBounds = target.getBounds(boundsType, "inner");
+                origin.x += innerBounds.x - boxBounds.x;
+                origin.y += innerBounds.y - boxBounds.y;
+            }
+        },
         getAround(around, altKey) {
             return altKey && !around ? "center" : around;
         },
@@ -13097,8 +12957,8 @@ var LeaferUI = function(exports) {
             updateMoveCursor(this);
         }
         update() {
-            const {editor: editor} = this;
-            const {x: x, y: y, scaleX: scaleX, scaleY: scaleY, rotation: rotation, skewX: skewX, skewY: skewY, width: width, height: height} = this.target.getLayoutBounds("box", editor, true);
+            const {editor: editor, mergeConfig: mergeConfig} = this;
+            const {x: x, y: y, scaleX: scaleX, scaleY: scaleY, rotation: rotation, skewX: skewX, skewY: skewY, width: width, height: height} = this.target.getLayoutBounds(mergeConfig.editBoxType, editor, true);
             this.visible = !this.target.locked;
             this.set({
                 x: x,
@@ -13121,9 +12981,9 @@ var LeaferUI = function(exports) {
             if (this.app) this.rect.syncEventer = this.app.interaction.bottomList = null;
         }
         updateBounds(bounds) {
-            const {editor: editor, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, buttons: buttons, resizePoints: resizePoints, rotatePoints: rotatePoints, resizeLines: resizeLines} = this;
+            const {editor: editor, mergedConfig: mergedConfig, single: single, rect: rect, circle: circle, buttons: buttons, resizePoints: resizePoints, rotatePoints: rotatePoints, resizeLines: resizeLines} = this;
             const {editMask: editMask} = editor;
-            const {middlePoint: middlePoint, resizeable: resizeable, rotateable: rotateable, hideOnSmall: hideOnSmall, editBox: editBox, mask: mask, dimOthers: dimOthers, bright: bright, spread: spread, hideRotatePoints: hideRotatePoints, hideResizeLines: hideResizeLines} = mergeConfig;
+            const {middlePoint: middlePoint, resizeable: resizeable, rotateable: rotateable, hideOnSmall: hideOnSmall, editBox: editBox, mask: mask, dimOthers: dimOthers, bright: bright, spread: spread, hideRotatePoints: hideRotatePoints, hideResizeLines: hideResizeLines} = mergedConfig;
             editMask.visible = mask ? true : 0;
             if (!isUndefined(dimOthers) || !isUndefined(bright)) {
                 editor.setDimOthers(dimOthers);
@@ -13161,7 +13021,7 @@ var LeaferUI = function(exports) {
                         }
                     }
                 }
-                circle.visible = showPoints && rotateable && !!(mergeConfig.circle || mergeConfig.rotatePoint);
+                circle.visible = showPoints && rotateable && !!(mergedConfig.circle || mergedConfig.rotatePoint);
                 if (circle.visible) this.layoutCircle();
                 if (rect.path) rect.path = null;
                 rect.set(Object.assign(Object.assign({}, bounds), {
@@ -13269,7 +13129,8 @@ var LeaferUI = function(exports) {
             this.dragPoint = null;
         }
         onTransformStart(e) {
-            if (this.moving || this.gesturing) this.editor.opacity = this.mergedConfig.hideOnMove ? 0 : 1;
+            const {hideOnMove: hideOnMove, editBoxType: editBoxType} = this.mergedConfig;
+            if (this.moving || this.gesturing) this.editor.opacity = hideOnMove ? 0 : 1;
             if (this.resizing) ResizeEvent.resizingKeys = this.editor.leafList.keys;
             const {dragStartData: dragStartData, target: target} = this;
             dragStartData.x = e.x;
@@ -13279,7 +13140,7 @@ var LeaferUI = function(exports) {
                 x: target.x,
                 y: target.y
             };
-            dragStartData.bounds = Object.assign({}, target.getLayoutBounds("box", "local"));
+            dragStartData.bounds = Object.assign({}, target.getLayoutBounds(editBoxType, "local"));
             dragStartData.rotation = target.rotation;
         }
         onTransformEnd(e) {
@@ -13510,6 +13371,7 @@ var LeaferUI = function(exports) {
         },
         selector: true,
         editBox: true,
+        editBoxType: "box",
         hover: true,
         select: "press",
         openInner: "double",
@@ -13792,7 +13654,7 @@ var LeaferUI = function(exports) {
         }
         onScale(e) {
             const {target: target, mergeConfig: mergeConfig, single: single, dragStartData: dragStartData} = this.editBox;
-            let {around: around, lockRatio: lockRatio, flipable: flipable, editSize: editSize} = mergeConfig, totalMove;
+            let {around: around, lockRatio: lockRatio, flipable: flipable, editSize: editSize, editBoxType: editBoxType} = mergeConfig, totalMove;
             if (e instanceof exports.ZoomEvent) {
                 if (!around) around = target.getBoxPoint(e);
                 totalMove = e.totalScale;
@@ -13801,7 +13663,7 @@ var LeaferUI = function(exports) {
             }
             const {direction: direction} = e.current;
             if (e.shiftKey || target.lockRatio) lockRatio = true;
-            const data = EditDataHelper.getScaleData(target, dragStartData.bounds, direction, totalMove, lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, !single || editSize === "scale");
+            const data = EditDataHelper.getScaleData(target, dragStartData.bounds, direction, totalMove, lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, !single || editSize === "scale", editBoxType);
             const targetX = target.x, targetY = target.y;
             if (e instanceof exports.DragEvent && this.editTool && this.editTool.onScaleWithDrag) {
                 data.drag = e;
@@ -13813,7 +13675,7 @@ var LeaferUI = function(exports) {
         }
         onRotate(e) {
             const {target: target, mergeConfig: mergeConfig, dragStartData: dragStartData} = this.editBox;
-            const {around: around, rotateAround: rotateAround, rotateGap: rotateGap, diagonalRotateKey: diagonalRotateKey} = mergeConfig;
+            const {around: around, rotateAround: rotateAround, rotateGap: rotateGap, diagonalRotateKey: diagonalRotateKey, editBoxType: editBoxType} = mergeConfig;
             const {direction: direction} = e.current;
             let origin, rotation;
             if (e instanceof exports.RotateEvent) {
@@ -13821,7 +13683,7 @@ var LeaferUI = function(exports) {
                 origin = rotateAround ? AroundHelper.getPoint(rotateAround, target.boxBounds) : target.getBoxPoint(e);
             } else {
                 const isDiagonalRotate = diagonalRotateKey ? e.isHoldKeys(diagonalRotateKey) : e.shiftKey;
-                const data = EditDataHelper.getRotateData(target, direction, e, dragStartData, isDiagonalRotate ? null : rotateAround || target.around || target.origin || around || "center");
+                const data = EditDataHelper.getRotateData(target, direction, e, dragStartData, isDiagonalRotate ? null : rotateAround || target.around || target.origin || around || "center", editBoxType);
                 rotation = dragStartData.rotation + data.rotation - target.rotation;
                 origin = data.origin;
             }
@@ -13833,8 +13695,8 @@ var LeaferUI = function(exports) {
         }
         onSkew(e) {
             const {target: target, mergeConfig: mergeConfig} = this.editBox;
-            const {around: around} = mergeConfig;
-            const {origin: origin, skewX: skewX, skewY: skewY} = EditDataHelper.getSkewData(target.boxBounds, e.current.direction, e.getInnerMove(target), EditDataHelper.getAround(around, e.altKey));
+            const {around: around, editBoxType: editBoxType} = mergeConfig;
+            const {origin: origin, skewX: skewX, skewY: skewY} = EditDataHelper.getSkewData(target, e.current.direction, e.getInnerMove(target), EditDataHelper.getAround(around, e.altKey), editBoxType);
             if (!skewX && !skewY) return;
             this.skewOf(origin, skewX, skewY);
         }
@@ -13895,7 +13757,7 @@ var LeaferUI = function(exports) {
         scaleOf(origin, scaleX, scaleY = scaleX, _resize) {
             if (!this.checkTransform("resizeable")) return;
             const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-            const {beforeScale: beforeScale} = mergeConfig;
+            const {beforeScale: beforeScale, editBoxType: editBoxType} = mergeConfig;
             if (beforeScale) {
                 const check = beforeScale({
                     target: target,
@@ -13913,7 +13775,8 @@ var LeaferUI = function(exports) {
                 worldOrigin: worldOrigin,
                 scaleX: scaleX,
                 scaleY: scaleY,
-                transform: transform
+                transform: transform,
+                editBoxType: editBoxType
             };
             this.emitEvent(new EditorScaleEvent(EditorScaleEvent.BEFORE_SCALE, data));
             const event = new EditorScaleEvent(EditorScaleEvent.SCALE, data);
@@ -13941,7 +13804,7 @@ var LeaferUI = function(exports) {
         rotateOf(origin, rotation) {
             if (!this.checkTransform("rotateable")) return;
             const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-            const {beforeRotate: beforeRotate} = mergeConfig;
+            const {beforeRotate: beforeRotate, editBoxType: editBoxType} = mergeConfig;
             if (beforeRotate) {
                 const check = beforeRotate({
                     target: target,
@@ -13957,7 +13820,8 @@ var LeaferUI = function(exports) {
                 editor: editor,
                 worldOrigin: worldOrigin,
                 rotation: rotation,
-                transform: transform
+                transform: transform,
+                editBoxType: editBoxType
             };
             this.emitEvent(new EditorRotateEvent(EditorRotateEvent.BEFORE_ROTATE, data));
             const event = new EditorRotateEvent(EditorRotateEvent.ROTATE, data);
@@ -13967,7 +13831,7 @@ var LeaferUI = function(exports) {
         skewOf(origin, skewX, skewY = 0, _resize) {
             if (!this.checkTransform("skewable")) return;
             const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-            const {beforeSkew: beforeSkew} = mergeConfig;
+            const {beforeSkew: beforeSkew, editBoxType: editBoxType} = mergeConfig;
             if (beforeSkew) {
                 const check = beforeSkew({
                     target: target,
@@ -13985,7 +13849,8 @@ var LeaferUI = function(exports) {
                 worldOrigin: worldOrigin,
                 skewX: skewX,
                 skewY: skewY,
-                transform: transform
+                transform: transform,
+                editBoxType: editBoxType
             };
             this.emitEvent(new EditorSkewEvent(EditorSkewEvent.BEFORE_SKEW, data));
             const event = new EditorSkewEvent(EditorSkewEvent.SKEW, data);
@@ -14427,32 +14292,32 @@ var LeaferUI = function(exports) {
             app.unlockLayout();
         }
         onScale(e) {
-            const {scaleX: scaleX, scaleY: scaleY, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
+            const {scaleX: scaleX, scaleY: scaleY, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
             const {app: app, list: list} = editor;
             app.lockLayout();
             list.forEach(target => {
                 const resize = editor.getEditSize(target) !== "scale";
-                if (transform) target.transformWorld(transform, resize); else target.scaleOfWorld(worldOrigin, scaleX, scaleY, resize);
+                if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.scaleOfWorld(worldOrigin, scaleX, scaleY, resize, false, editBoxType);
             });
             app.unlockLayout();
         }
         onRotate(e) {
-            const {rotation: rotation, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
+            const {rotation: rotation, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
             const {app: app, list: list} = editor;
             app.lockLayout();
             list.forEach(target => {
                 const resize = editor.getEditSize(target) !== "scale";
-                if (transform) target.transformWorld(transform, resize); else target.rotateOfWorld(worldOrigin, rotation);
+                if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.rotateOfWorld(worldOrigin, rotation);
             });
             app.unlockLayout();
         }
         onSkew(e) {
-            const {skewX: skewX, skewY: skewY, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
+            const {skewX: skewX, skewY: skewY, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
             const {app: app, list: list} = editor;
             app.lockLayout();
             list.forEach(target => {
                 const resize = editor.getEditSize(target) !== "scale";
-                if (transform) target.transformWorld(transform, resize); else target.skewOfWorld(worldOrigin, skewX, skewY, resize);
+                if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.skewOfWorld(worldOrigin, skewX, skewY, resize);
             });
             app.unlockLayout();
         }
@@ -14733,15 +14598,26 @@ var LeaferUI = function(exports) {
             children[i].transform(matrix, true);
         }
     }
-    const leaf = exports.Leaf.prototype;
-    leaf.scaleResize = function(scaleX, scaleY = scaleX, noResize) {
+    const leaf = exports.Leaf.prototype, tempPoint$1 = {}, {scale: scale$2, toOuterPoint: toOuterPoint} = MatrixHelper;
+    leaf.scaleResize = function(scaleX, scaleY = scaleX, noResize, boundsType) {
         const data = this;
         if (noResize || data.editConfig && data.editConfig.editSize === "scale") {
             data.scaleX *= scaleX;
             data.scaleY *= scaleY;
         } else {
-            if (scaleX < 0) data.scaleX *= -1, scaleX = -scaleX;
-            if (scaleY < 0) data.scaleY *= -1, scaleY = -scaleY;
+            const local = this.__localMatrix;
+            if (scaleX < 0) data.scaleX *= -1, scaleX = -scaleX, scale$2(local, -1, 1);
+            if (scaleY < 0) data.scaleY *= -1, scaleY = -scaleY, scale$2(local, 1, -1);
+            if (boundsType === "stroke") {
+                const {boxBounds: boxBounds, strokeBounds: strokeBounds} = this.__layout, {x: x, y: y, width: width, height: height} = strokeBounds;
+                tempPoint$1.x = (x - boxBounds.x) * (scaleX - 1);
+                tempPoint$1.y = (y - boxBounds.y) * (scaleY - 1);
+                toOuterPoint(local, tempPoint$1, tempPoint$1, true);
+                this.x += tempPoint$1.x;
+                this.y += tempPoint$1.y;
+                scaleX = (width * scaleX - (width - boxBounds.width)) / boxBounds.width;
+                scaleY = (height * scaleY - (height - boxBounds.height)) / boxBounds.height;
+            }
             this.__scaleResize(scaleX, scaleY);
         }
     };
@@ -14807,7 +14683,8 @@ var LeaferUI = function(exports) {
     exports.UI.addAttr("editConfig", undefined, dataType);
     exports.UI.addAttr("editOuter", ui => {
         ui.updateLayout();
-        return ui.__.__isLinePath ? "LineEditTool" : "EditTool";
+        const name = (ui.tag === "Line" ? "" : ui.tag) + "EditTool";
+        return ui.__.__isLinePath ? "LineEditTool" : EditToolCreator.list[name] ? name : "EditTool";
     }, dataType);
     exports.UI.addAttr("editInner", "PathEditor", dataType);
     exports.Group.addAttr("editInner", "", dataType);
@@ -15077,8 +14954,9 @@ var LeaferUI = function(exports) {
         addViewportConfig(leafer.parentApp ? leafer.parentApp : leafer, mergeConfig);
         if (leafer.isApp || custom) return;
         leafer.__eventIds.push(leafer.on_(exports.MoveEvent.BEFORE_MOVE, e => {
-            const move = leafer.getValidMove(e.moveX, e.moveY, false);
-            if (getScrollType(leafer).includes("limit")) {
+            const limit = getScrollType(leafer).includes("limit"), stopLimit = leafer.app.config.move.scrollLimit === "stop";
+            const move = leafer.getValidMove(e.moveX, e.moveY, limit && stopLimit);
+            if (limit && !stopLimit) {
                 const testMove = leafer.getValidMove(0, 0);
                 if (testMove.x || testMove.y) {
                     const maxX = 100, maxY = 200, resistance = e.moveType === "drag" ? .3 : .05;
@@ -19316,7 +19194,7 @@ var LeaferUI = function(exports) {
     Plugin.add("scale-fixed");
     exports.UI.addAttr("scaleFixed", undefined, scaleFixedType);
     class EllipseBoxData extends BoxData {}
-    const ellipse$1 = exports.Ellipse.prototype;
+    const ellipse = exports.Ellipse.prototype;
     exports.EllipseBox = class EllipseBox extends exports.Box {
         get __tag() {
             return "EllipseBox";
@@ -19327,7 +19205,7 @@ var LeaferUI = function(exports) {
     __decorate([ pathType(0) ], exports.EllipseBox.prototype, "innerRadius", void 0);
     __decorate([ pathType(0) ], exports.EllipseBox.prototype, "startAngle", void 0);
     __decorate([ pathType(0) ], exports.EllipseBox.prototype, "endAngle", void 0);
-    __decorate([ rewrite(ellipse$1.__updatePath) ], exports.EllipseBox.prototype, "__updatePath", null);
+    __decorate([ rewrite(ellipse.__updatePath) ], exports.EllipseBox.prototype, "__updatePath", null);
     exports.EllipseBox = __decorate([ rewriteAble(), registerUI() ], exports.EllipseBox);
     class PolygonBoxData extends BoxData {
         get __usePathBox() {
@@ -19348,7 +19226,7 @@ var LeaferUI = function(exports) {
     __decorate([ rewrite(polygon.__updatePath) ], exports.PolygonBox.prototype, "__updatePath", null);
     exports.PolygonBox = __decorate([ rewriteAble(), registerUI() ], exports.PolygonBox);
     class StarBoxData extends BoxData {}
-    const ellipse = exports.Star.prototype;
+    const star = exports.Star.prototype;
     exports.StarBox = class StarBox extends exports.Box {
         get __tag() {
             return "StarBox";
@@ -19358,7 +19236,7 @@ var LeaferUI = function(exports) {
     __decorate([ pathType(5) ], exports.StarBox.prototype, "corners", void 0);
     __decorate([ pathType(.382) ], exports.StarBox.prototype, "innerRadius", void 0);
     __decorate([ dataProcessor(StarBoxData) ], exports.StarBox.prototype, "__", void 0);
-    __decorate([ rewrite(ellipse.__updatePath) ], exports.StarBox.prototype, "__updatePath", null);
+    __decorate([ rewrite(star.__updatePath) ], exports.StarBox.prototype, "__updatePath", null);
     exports.StarBox = __decorate([ rewriteAble(), registerUI() ], exports.StarBox);
     class PathBoxData extends BoxData {}
     exports.PathBox = class PathBox extends exports.Box {
@@ -19927,7 +19805,7 @@ var LeaferUI = function(exports) {
     exports.surfaceType = surfaceType;
     exports.tempBounds = tempBounds$3;
     exports.tempMatrix = tempMatrix$2;
-    exports.tempPoint = tempPoint$4;
+    exports.tempPoint = tempPoint$5;
     exports.tryToNumber = tryToNumber;
     exports.useCanvas = useCanvas;
     exports.useModule = useModule;