@leafer/worker 2.1.2 → 2.1.4

package/dist/worker.js

@@ -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 {
@@ -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);
@@ -1199,7 +1199,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 +1306,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);
             }
@@ -2522,7 +2522,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);
@@ -2692,8 +2692,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) {
@@ -2850,6 +2850,7 @@ 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"];
                     if (!needConvert && convertCommand[char]) needConvert = true;
                 } else {
                     if (char === "-" || char === "+") {
@@ -2882,10 +2883,9 @@ var LeaferUI = function(exports) {
                     old[i + 2] += y;
 
                   case M$a:
-                    x = old[i + 1];
-                    y = old[i + 2];
-                    if (lastCommand === command) data.push(L$a, x, y); else data.push(M$a, x, y), startX = x, 
-                    startY = y;
+                    x = startX = old[i + 1];
+                    y = startY = old[i + 2];
+                    data.push(M$a, x, y);
                     i += 3;
                     break;
 
@@ -2927,8 +2927,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];
@@ -2962,8 +2962,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];
@@ -4475,7 +4475,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) {
@@ -4556,7 +4556,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) {
@@ -4569,10 +4569,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;
@@ -4581,7 +4581,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({
@@ -4589,7 +4589,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) {
@@ -4613,18 +4613,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)) {
@@ -4640,7 +4640,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) {
@@ -4842,11 +4842,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) {
@@ -5639,7 +5639,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;
@@ -5659,8 +5659,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;
@@ -5689,39 +5689,45 @@ var LeaferUI = function(exports) {
                 this.__updateRenderPath();
                 this.__updateBoxBounds();
                 layout.resized = "inner";
-                if (data.__strokeGeometry) data.__strokeGeometry = undefined;
             }
             if (layout.localBoxChanged) {
                 if (this.__local) this.__updateLocalBoxBounds();
                 layout.localBoxChanged = undefined;
-                if (layout.strokeSpread) layout.strokeChanged = true;
-                if (layout.renderSpread) layout.renderChanged = true;
+                if (layout.strokeSpread && !layout.strokeChanged) layout.strokeChanged = layout.boxChanged ? true : 2;
+                if (layout.renderSpread && !layout.renderChanged) layout.renderChanged = layout.boxChanged ? true : 2;
                 if (this.parent) this.parent.__layout.boxChange();
             }
             layout.boxChanged = undefined;
             if (layout.strokeChanged) {
-                layout.strokeSpread = this.__updateStrokeSpread();
-                if (layout.strokeSpread) {
-                    if (layout.strokeBounds === layout.boxBounds) layout.spreadStroke();
-                    this.__updateStrokeBounds();
+                if (layout.strokeChanged === 2) {
                     this.__updateLocalStrokeBounds();
                 } else {
-                    layout.spreadStrokeCancel();
+                    layout.strokeSpread = this.__updateStrokeSpread();
+                    if (layout.strokeSpread) {
+                        if (layout.strokeBounds === layout.boxBounds) layout.spreadStroke();
+                        this.__updateStrokeBounds();
+                        this.__updateLocalStrokeBounds();
+                    } else {
+                        layout.spreadStrokeCancel();
+                    }
+                    layout.resized = "inner";
+                    if (layout.renderSpread || layout.strokeSpread !== layout.strokeBoxSpread) layout.renderChanged = true;
                 }
                 layout.strokeChanged = undefined;
-                if (layout.renderSpread || layout.strokeSpread !== layout.strokeBoxSpread) layout.renderChanged = true;
                 if (this.parent) this.parent.__layout.strokeChange();
-                layout.resized = "inner";
-                if (data.__strokeGeometry) data.__strokeGeometry = undefined;
             }
             if (layout.renderChanged) {
-                layout.renderSpread = this.__updateRenderSpread();
-                if (layout.renderSpread) {
-                    if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) layout.spreadRender();
-                    this.__updateRenderBounds();
+                if (layout.renderChanged === 2) {
                     this.__updateLocalRenderBounds();
                 } else {
-                    layout.spreadRenderCancel();
+                    layout.renderSpread = this.__updateRenderSpread();
+                    if (layout.renderSpread) {
+                        if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) layout.spreadRender();
+                        this.__updateRenderBounds();
+                        this.__updateLocalRenderBounds();
+                    } else {
+                        layout.spreadRenderCancel();
+                    }
                 }
                 layout.renderChanged = undefined;
                 if (this.parent) this.parent.__layout.renderChange();
@@ -5875,7 +5881,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;
@@ -6209,7 +6215,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) {
@@ -6264,11 +6270,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);
@@ -6276,8 +6282,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);
@@ -6285,14 +6291,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);
@@ -6303,7 +6309,7 @@ var LeaferUI = function(exports) {
         flip(axis, transition) {
             transform(this, getFlipTransform(this, axis), false, transition);
         }
-        scaleResize(scaleX, scaleY = scaleX, _noResize) {
+        scaleResize(scaleX, scaleY = scaleX, _noResize, _boundsType) {
             this.scaleX *= scaleX;
             this.scaleY *= scaleY;
         }
@@ -6668,7 +6674,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "2.1.2";
+    const version = "2.1.4";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -7297,7 +7303,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 {
@@ -7429,7 +7435,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;
@@ -11036,7 +11042,7 @@ var LeaferUI = function(exports) {
                 needUpdate = false;
             }
         }
-        if (paint.mode === "brush") PaintImage.brush(leafPaint);
+        if (paint.mode === "brush") PaintImage.brush(leafPaint, ui);
         if (!leafPaint.data) {
             PaintImage.createData(leafPaint, image, paint, boxBounds);
             const {transform: transform} = leafPaint.data, {opacity: opacity} = paint;
@@ -11231,7 +11237,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) {
@@ -11266,11 +11272,15 @@ 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);
-                const pattern = brush ? imageCanvas : image.getPattern(imageCanvas, data.repeat || (Platform.origin.noRepeat || "no-repeat"), imageMatrix, paint);
-                paint.style = pattern;
+                if (brush) {
+                    paint.style = imageCanvas;
+                    PaintImage.cacheBrush(paint, ui, canvas, renderOptions);
+                } else {
+                    paint.style = image.getPattern(imageCanvas, data.repeat || (Platform.origin.noRepeat || "no-repeat"), imageMatrix, paint);
+                }
                 paint.patternId = id;
             }
         }
@@ -12241,10 +12251,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);
                     }
@@ -12305,9 +12316,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);
@@ -12422,10 +12446,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;
@@ -12605,16 +12630,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 {
@@ -12700,10 +12726,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,
@@ -12714,15 +12741,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;
@@ -12739,7 +12771,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:
@@ -12761,13 +12793,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) {
@@ -12810,10 +12843,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)
@@ -12825,6 +12860,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;
         },
@@ -13088,8 +13130,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,
@@ -13112,9 +13154,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);
@@ -13152,7 +13194,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), {
@@ -13260,7 +13302,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;
@@ -13270,7 +13313,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) {
@@ -13501,6 +13544,7 @@ var LeaferUI = function(exports) {
         },
         selector: true,
         editBox: true,
+        editBoxType: "box",
         hover: true,
         select: "press",
         openInner: "double",
@@ -13783,7 +13827,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;
@@ -13792,7 +13836,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;
@@ -13804,7 +13848,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) {
@@ -13812,7 +13856,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;
             }
@@ -13824,8 +13868,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);
         }
@@ -13886,7 +13930,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,
@@ -13904,7 +13948,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);
@@ -13932,7 +13977,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,
@@ -13948,7 +13993,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);
@@ -13958,7 +14004,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,
@@ -13976,7 +14022,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);
@@ -14418,32 +14465,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();
         }
@@ -14724,15 +14771,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);
         }
     };
@@ -19918,7 +19976,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;