@leafer/miniapp 1.9.9 → 1.9.10

package/dist/miniapp.module.js

@@ -249,7 +249,7 @@ class LeafData {
 
 let tempA, tempB, tempTo;
 
-const {max: max$5} = Math, tempFour = [ 0, 0, 0, 0 ];
+const {max: max$6} = Math, tempFour = [ 0, 0, 0, 0 ];
 
 const FourNumberHelper = {
     zero: [ ...tempFour ],
@@ -263,7 +263,7 @@ const FourNumberHelper = {
         return to;
     },
     setTemp(top, right, bottom, left) {
-        return set$1(tempFour, top, right, bottom, left);
+        return set$2(tempFour, top, right, bottom, left);
     },
     toTempAB(a, b, change) {
         tempTo = change ? isNumber(a) ? b : a : [];
@@ -301,24 +301,24 @@ const FourNumberHelper = {
         return data;
     },
     max(t, other, change) {
-        if (isNumber(t) && isNumber(other)) return max$5(t, other);
+        if (isNumber(t) && isNumber(other)) return max$6(t, other);
         toTempAB(t, other, change);
-        return set$1(tempTo, max$5(tempA[0], tempB[0]), max$5(tempA[1], tempB[1]), max$5(tempA[2], tempB[2]), max$5(tempA[3], tempB[3]));
+        return set$2(tempTo, max$6(tempA[0], tempB[0]), max$6(tempA[1], tempB[1]), max$6(tempA[2], tempB[2]), max$6(tempA[3], tempB[3]));
     },
     add(t, other, change) {
         if (isNumber(t) && isNumber(other)) return t + other;
         toTempAB(t, other, change);
-        return set$1(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
+        return set$2(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
     },
     swapAndScale(t, scaleX, scaleY, change) {
         if (isNumber(t)) return scaleX === scaleY ? t * scaleX : [ t * scaleY, t * scaleX ];
         const to = change ? t : [];
         const [top, right, bottom, left] = t.length === 4 ? t : get$5(t);
-        return set$1(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
+        return set$2(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
     }
 };
 
-const {set: set$1, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
+const {set: set$2, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
 
 const {round: round$6, pow: pow$2, PI: PI$4} = Math;
 
@@ -720,7 +720,7 @@ const M$b = MatrixHelper;
 
 const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
 
-const {sin: sin$5, cos: cos$5, abs: abs$7, sqrt: sqrt$4, atan2: atan2$2, min: min$1, round: round$5} = Math;
+const {sin: sin$5, cos: cos$5, abs: abs$a, sqrt: sqrt$4, atan2: atan2$2, min: min$2, round: round$5} = Math;
 
 const PointHelper = {
     defaultPoint: getPointData(),
@@ -813,12 +813,12 @@ const PointHelper = {
         return getDistanceFrom(t.x, t.y, point.x, point.y);
     },
     getDistanceFrom(x1, y1, x2, y2) {
-        const x = abs$7(x2 - x1);
-        const y = abs$7(y2 - y1);
+        const x = abs$a(x2 - x1);
+        const y = abs$a(y2 - y1);
         return sqrt$4(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
-        return min$1(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
+        return min$2(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
     },
     getAngle(t, to) {
         return getAtan2(t, to) / OneRadian;
@@ -2592,11 +2592,11 @@ const RectHelper = {
     }
 };
 
-const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$2, abs: abs$6, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
+const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$2, abs: abs$9, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
 
 const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
 
-const {set: set, toNumberPoints: toNumberPoints$1} = PointHelper;
+const {set: set$1, toNumberPoints: toNumberPoints$1} = PointHelper;
 
 const {M: M$a, L: L$a, C: C$8, Q: Q$7, Z: Z$8} = PathCommandMap;
 
@@ -2667,14 +2667,14 @@ const BezierHelper = {
         const lenCB = hypot(CBx, CBy);
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
-        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$6(totalRadian - PI$3) < 1e-12) {
+        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$9(totalRadian - PI$3) < 1e-12) {
             if (data) data.push(L$a, x1, y1);
             if (setPointBounds) {
                 setPoint$4(setPointBounds, fromX, fromY);
                 addPoint$2(setPointBounds, x1, y1);
             }
-            if (setStartPoint) set(setStartPoint, fromX, fromY);
-            if (setEndPoint) set(setEndPoint, x1, y1);
+            if (setStartPoint) set$1(setStartPoint, fromX, fromY);
+            if (setEndPoint) set$1(setEndPoint, x1, y1);
             return;
         }
         const anticlockwise = BAx * CBy - CBx * BAy < 0;
@@ -2700,7 +2700,7 @@ const BezierHelper = {
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2; else if (totalRadian > PI2) totalRadian -= PI2;
         if (anticlockwise) totalRadian -= PI2;
-        const parts = ceil$2(abs$6(totalRadian / PI_2));
+        const parts = ceil$2(abs$9(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$4(partRadian / 4);
         const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin$4(partRadian / 2);
@@ -2714,7 +2714,7 @@ const BezierHelper = {
         let fromX = cx + x, fromY = cy + y;
         if (data) data.push(data.length ? L$a : M$a, fromX, fromY);
         if (setPointBounds) setPoint$4(setPointBounds, fromX, fromY);
-        if (setStartPoint) set(setStartPoint, fromX, fromY);
+        if (setStartPoint) set$1(setStartPoint, fromX, fromY);
         for (let i = 0; i < parts; i++) {
             endCos = cos$4(endRadian);
             endSin = sin$4(endRadian);
@@ -2733,7 +2733,7 @@ const BezierHelper = {
             startRadian = endRadian;
             endRadian += partRadian;
         }
-        if (setEndPoint) set(setEndPoint, cx + x, cy + y);
+        if (setEndPoint) set$1(setEndPoint, cx + x, cy + y);
     },
     quadraticCurveTo(data, fromX, fromY, x1, y1, toX, toY) {
         data.push(C$8, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
@@ -3167,7 +3167,7 @@ const {M: M$8, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
-const {tan: tan, min: min, abs: abs$5} = Math;
+const {tan: tan, min: min$1, abs: abs$8} = Math;
 
 const startPoint = {};
 
@@ -3225,7 +3225,7 @@ const PathCommandDataHelper = {
     arcTo(data, x1, y1, x2, y2, radius, lastX, lastY) {
         if (!isUndefined(lastX)) {
             const d = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2);
-            radius = min(radius, min(d / 2, d / 2 * abs$5(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
+            radius = min$1(radius, min$1(d / 2, d / 2 * abs$8(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
         data.push(U$4, x1, y1, x2, y2, radius);
     },
@@ -4023,7 +4023,7 @@ const I$1 = ImageManager;
 
 const {IMAGE: IMAGE, create: create$1} = IncrementId;
 
-const {floor: floor$2, max: max$4} = Math;
+const {floor: floor$2, max: max$5} = Math;
 
 class LeaferImage {
     get url() {
@@ -4112,7 +4112,7 @@ class LeaferImage {
             }
             if (data) return data;
         }
-        const canvas = Platform.origin.createCanvas(max$4(floor$2(width + (xGap || 0)), 1), max$4(floor$2(height + (yGap || 0)), 1));
+        const canvas = Platform.origin.createCanvas(max$5(floor$2(width + (xGap || 0)), 1), max$5(floor$2(height + (yGap || 0)), 1));
         const ctx = canvas.getContext("2d");
         if (opacity) ctx.globalAlpha = opacity;
         ctx.imageSmoothingEnabled = smooth === false ? false : true;
@@ -6815,7 +6815,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.9";
+const version = "1.9.10";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7634,7 +7634,7 @@ class Picker {
             children: [ target ]
         } : target);
         const {list: list} = this.findList;
-        const leaf = this.getBestMatchLeaf(list, options.bottomList, ignoreHittable);
+        const leaf = this.getBestMatchLeaf(list, options.bottomList, ignoreHittable, !!options.findList);
         const path = ignoreHittable ? this.getPath(leaf) : this.getHitablePath(leaf);
         this.clear();
         return through ? {
@@ -7649,7 +7649,7 @@ class Picker {
     hitPoint(hitPoint, hitRadius, options) {
         return !!this.getByPoint(hitPoint, hitRadius, options).target;
     }
-    getBestMatchLeaf(list, bottomList, ignoreHittable) {
+    getBestMatchLeaf(list, bottomList, ignoreHittable, allowNull) {
         const findList = this.findList = new LeafList;
         if (list.length) {
             let find;
@@ -7680,15 +7680,27 @@ class Picker {
                 if (findList.length) return findList.list[0];
             }
         }
+        if (allowNull) return null;
         return ignoreHittable ? list[0] : list.find(item => LeafHelper.worldHittable(item));
     }
     getPath(leaf) {
-        const path = new LeafList;
+        const path = new LeafList, syncList = [], {target: target} = this;
         while (leaf) {
+            if (leaf.syncEventer) syncList.push(leaf.syncEventer);
             path.add(leaf);
             leaf = leaf.parent;
+            if (leaf === target) break;
+        }
+        if (syncList.length) {
+            syncList.forEach(item => {
+                while (item) {
+                    if (item.__.hittable) path.add(item);
+                    item = item.parent;
+                    if (item === target) break;
+                }
+            });
         }
-        if (this.target) path.add(this.target);
+        if (target) path.add(target);
         return path;
     }
     getHitablePath(leaf) {
@@ -8186,12 +8198,12 @@ class ImageData extends RectData {
     }
     __getData() {
         const data = super.__getData();
-        delete data.fill;
+        if (data.url) delete data.fill;
         return data;
     }
     __getInputData(names, options) {
         const data = super.__getInputData(names, options);
-        delete data.fill;
+        if (data.url) delete data.fill;
         return data;
     }
 }
@@ -8210,7 +8222,7 @@ class CanvasData extends RectData {
     }
 }
 
-const {max: max$3, add: add$1} = FourNumberHelper;
+const {max: max$4, add: add$1} = FourNumberHelper;
 
 const UIBounds = {
     __updateStrokeSpread() {
@@ -8226,7 +8238,7 @@ const UIBounds = {
         }
         if (data.__useArrow) spread += strokeWidth * 5;
         if (box) {
-            spread = max$3(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
+            spread = max$4(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
             boxSpread = Math.max(boxSpread, box.__layout.strokeBoxSpread);
         }
         this.__layout.strokeBoxSpread = boxSpread;
@@ -8236,86 +8248,18 @@ const UIBounds = {
         let spread = 0;
         const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = this.__, {strokeSpread: strokeSpread} = this.__layout, box = this.__box;
         if (shadow) spread = Effect.getShadowRenderSpread(this, shadow);
-        if (blur) spread = max$3(spread, blur);
+        if (blur) spread = max$4(spread, blur);
         if (filter) spread = add$1(spread, Filter.getSpread(filter));
         if (renderSpread) spread = add$1(spread, renderSpread);
         if (strokeSpread) spread = add$1(spread, strokeSpread);
         let shapeSpread = spread;
-        if (innerShadow) shapeSpread = max$3(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
-        if (backgroundBlur) shapeSpread = max$3(shapeSpread, backgroundBlur);
+        if (innerShadow) shapeSpread = max$4(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
+        if (backgroundBlur) shapeSpread = max$4(shapeSpread, backgroundBlur);
         this.__layout.renderShapeSpread = shapeSpread;
-        return box ? max$3(box.__updateRenderSpread(), spread) : spread;
+        return box ? max$4(box.__updateRenderSpread(), spread) : spread;
     }
 };
 
-const {float: float$1} = MathHelper;
-
-const tempContent = new Bounds, tempMerge = new Bounds, tempIntersect = new Bounds;
-
-const DragBoundsHelper = {
-    limitMove(leaf, move) {
-        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
-        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, move, true);
-        D$2.axisMove(leaf, move);
-    },
-    limitScaleOf(leaf, origin, scale) {
-        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
-        if (dragBounds) D$2.getValidScaleOf(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, true);
-    },
-    axisMove(leaf, move) {
-        const {draggable: draggable} = leaf;
-        if (draggable === "x") move.y = 0;
-        if (draggable === "y") move.x = 0;
-    },
-    getDragBounds(leaf) {
-        const {dragBounds: dragBounds} = leaf;
-        return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
-    },
-    isInnerMode(content, dragBounds, dragBoundsType, sideType) {
-        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > dragBounds[sideType];
-    },
-    getValidMove(content, dragBounds, dragBoundsType, move, change) {
-        const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height;
-        const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
-        if (!change) move = Object.assign({}, move);
-        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
-            if (x > dragBounds.x) move.x += dragBounds.x - x; else if (right < boundsRight) move.x += boundsRight - right;
-        } else {
-            if (x < dragBounds.x) move.x += dragBounds.x - x; else if (right > boundsRight) move.x += boundsRight - right;
-        }
-        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
-            if (y > dragBounds.y) move.y += dragBounds.y - y; else if (bottom < boundsBottom) move.y += boundsBottom - bottom;
-        } else {
-            if (y < dragBounds.y) move.y += dragBounds.y - y; else if (bottom > boundsBottom) move.y += boundsBottom - bottom;
-        }
-        move.x = float$1(move.x);
-        move.y = float$1(move.y);
-        return move;
-    },
-    getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, change) {
-        if (!change) scale = Object.assign({}, scale);
-        let fitScaleX, fitScaleY;
-        tempContent.set(content).scaleOf(origin, scale.x, scale.y).unsign();
-        tempMerge.set(tempContent).add(dragBounds);
-        tempIntersect.set(tempContent).intersect(dragBounds);
-        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
-            fitScaleX = tempMerge.width / tempContent.width;
-        } else {
-            fitScaleX = tempIntersect.width / tempContent.width;
-        }
-        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
-            fitScaleY = tempMerge.height / tempContent.height;
-        } else {
-            fitScaleY = tempIntersect.height / tempContent.height;
-        }
-        scale.x = float$1(tempIntersect.width) ? scale.x * fitScaleX : 1;
-        scale.y = float$1(tempIntersect.height) ? scale.y * fitScaleY : 1;
-        return scale;
-    }
-};
-
-const D$2 = DragBoundsHelper;
-
 const {stintSet: stintSet$1} = DataHelper;
 
 const UIRender = {
@@ -9981,6 +9925,102 @@ class UIEvent extends Event {
     }
 }
 
+const {float: float$1, sign: sign$2} = MathHelper, {min: min, max: max$3, abs: abs$7} = Math;
+
+const tempContent = new Bounds, tempDragBounds = new Bounds;
+
+const DragBoundsHelper = {
+    limitMove(leaf, move) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, move, true);
+        D$2.axisMove(leaf, move);
+    },
+    limitScaleOf(leaf, origin, scale, lockRatio) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidScaleOf(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, lockRatio, true);
+    },
+    axisMove(leaf, move) {
+        const {draggable: draggable} = leaf;
+        if (draggable === "x") move.y = 0;
+        if (draggable === "y") move.x = 0;
+    },
+    getDragBounds(leaf) {
+        const {dragBounds: dragBounds} = leaf;
+        return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
+    },
+    isInnerMode(content, dragBounds, dragBoundsType, sideType) {
+        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > dragBounds[sideType];
+    },
+    getValidMove(content, dragBounds, dragBoundsType, move, change) {
+        const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height;
+        const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
+        if (!change) move = Object.assign({}, move);
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+            if (x > dragBounds.x) move.x += dragBounds.x - x; else if (right < boundsRight) move.x += boundsRight - right;
+        } else {
+            if (x < dragBounds.x) move.x += dragBounds.x - x; else if (right > boundsRight) move.x += boundsRight - right;
+        }
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
+            if (y > dragBounds.y) move.y += dragBounds.y - y; else if (bottom < boundsBottom) move.y += boundsBottom - bottom;
+        } else {
+            if (y < dragBounds.y) move.y += dragBounds.y - y; else if (bottom > boundsBottom) move.y += boundsBottom - bottom;
+        }
+        move.x = float$1(move.x);
+        move.y = float$1(move.y);
+        return move;
+    },
+    getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, lockRatio, change) {
+        if (!change) scale = Object.assign({}, scale);
+        tempDragBounds.set(dragBounds);
+        tempContent.set(content).scaleOf(origin, scale.x, scale.y);
+        const originLeftScale = (origin.x - content.x) / content.width, originRightScale = 1 - originLeftScale;
+        const originTopScale = (origin.y - content.y) / content.height, originBottomScale = 1 - originTopScale;
+        let correctScaleX, correctScaleY, aScale, bScale, aSize, bSize;
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+            correctScaleX = scale.x < 0 ? 1 / scale.x : 1;
+            if (scale.x < 0) tempContent.scaleOf(origin, correctScaleX, 1);
+            aSize = float$1(tempContent.minX - tempDragBounds.minX);
+            bSize = float$1(tempDragBounds.maxX - tempContent.maxX);
+            aScale = originLeftScale && aSize > 0 ? 1 + aSize / (originLeftScale * tempContent.width) : 1;
+            bScale = originRightScale && bSize > 0 ? 1 + bSize / (originRightScale * tempContent.width) : 1;
+            correctScaleX *= max$3(aScale, bScale);
+        } else {
+            if (scale.x < 0) tempContent.unsign();
+            aSize = float$1(tempDragBounds.minX - tempContent.minX);
+            bSize = float$1(tempContent.maxX - tempDragBounds.maxX);
+            aScale = originLeftScale && aSize > 0 ? 1 - aSize / (originLeftScale * tempContent.width) : 1;
+            bScale = originRightScale && bSize > 0 ? 1 - bSize / (originRightScale * tempContent.width) : 1;
+            correctScaleX = min(aScale, bScale);
+        }
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
+            correctScaleY = scale.y < 0 ? 1 / scale.y : 1;
+            if (scale.y < 0) tempContent.scaleOf(origin, 1, correctScaleY);
+            aSize = float$1(tempContent.minY - tempDragBounds.minY);
+            bSize = float$1(tempDragBounds.maxY - tempContent.maxY);
+            aScale = originTopScale && aSize > 0 ? 1 + aSize / (originTopScale * tempContent.height) : 1;
+            bScale = originBottomScale && bSize > 0 ? 1 + bSize / (originBottomScale * tempContent.height) : 1;
+            correctScaleY *= max$3(aScale, bScale);
+            if (lockRatio) {
+                aScale = max$3(abs$7(correctScaleX), abs$7(correctScaleY));
+                correctScaleX = sign$2(correctScaleX) * aScale;
+                correctScaleY = sign$2(correctScaleY) * aScale;
+            }
+        } else {
+            if (scale.y < 0) tempContent.unsign();
+            aSize = float$1(tempDragBounds.minY - tempContent.minY);
+            bSize = float$1(tempContent.maxY - tempDragBounds.maxY);
+            aScale = originTopScale && aSize > 0 ? 1 - aSize / (originTopScale * tempContent.height) : 1;
+            bScale = originBottomScale && bSize > 0 ? 1 - bSize / (originBottomScale * tempContent.height) : 1;
+            correctScaleY = min(aScale, bScale);
+        }
+        scale.x *= isFinite(correctScaleX) ? correctScaleX : 1;
+        scale.y *= isFinite(correctScaleY) ? correctScaleY : 1;
+        return scale;
+    }
+};
+
+const D$2 = DragBoundsHelper;
+
 let PointerEvent = class PointerEvent extends UIEvent {};
 
 PointerEvent.POINTER = "pointer";
@@ -11637,7 +11677,14 @@ const PaintModule = {
 
 let origin$1 = {}, tempMatrix$1 = getMatrixData();
 
-const {get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, multiplyParent: multiplyParent, scale: scaleHelper, rotate: rotate$2, skew: skewHelper} = MatrixHelper;
+const {get: get$3, set: set, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, multiplyParent: multiplyParent, scale: scaleHelper, rotate: rotate$2, skew: skewHelper} = MatrixHelper;
+
+function stretchMode(data, box, scaleX, scaleY) {
+    const transform = get$3();
+    translate$1(transform, box.x, box.y);
+    if (scaleX) scaleHelper(transform, scaleX, scaleY);
+    data.transform = transform;
+}
 
 function fillOrFitMode(data, box, x, y, scaleX, scaleY, rotation) {
     const transform = get$3();
@@ -11654,8 +11701,11 @@ function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew, clipScaleX, c
     const transform = get$3();
     layout$3(transform, box, x, y, scaleX, scaleY, rotation, skew);
     if (clipScaleX) {
-        tempMatrix$1.a = clipScaleX, tempMatrix$1.d = clipScaleY;
-        multiplyParent(transform, tempMatrix$1);
+        if (rotation || skew) {
+            set(tempMatrix$1);
+            scaleOfOuter$1(tempMatrix$1, box, clipScaleX, clipScaleY);
+            multiplyParent(transform, tempMatrix$1);
+        } else scaleOfOuter$1(transform, box, clipScaleX, clipScaleY);
     }
     data.transform = transform;
 }
@@ -11751,7 +11801,10 @@ function getPatternData(paint, box, image) {
     if (offset) PointHelper.move(tempImage, offset);
     switch (mode) {
       case "stretch":
-        if (!sameBox) width = box.width, height = box.height;
+        if (!sameBox) {
+            scaleX = box.width / width, scaleY = box.height / height;
+            stretchMode(data, box, scaleX, scaleY);
+        }
         break;
 
       case "normal":
@@ -11760,7 +11813,7 @@ function getPatternData(paint, box, image) {
             let clipScaleX, clipScaleY;
             if (clipSize) clipScaleX = box.width / clipSize.width, clipScaleY = box.height / clipSize.height;
             clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew, clipScaleX, clipScaleY);
-            if (clipScaleX) scaleX = scaleX ? scaleX * clipScaleX : scaleX, scaleY = scaleY ? scaleY * clipScaleY : clipScaleY;
+            if (clipScaleX) scaleX = scaleX ? scaleX * clipScaleX : clipScaleX, scaleY = scaleY ? scaleY * clipScaleY : clipScaleY;
         }
         break;
 
@@ -11777,17 +11830,14 @@ function getPatternData(paint, box, image) {
         if (scaleX) fillOrFitMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation);
     }
     if (!data.transform) {
-        if (box.x || box.y) {
-            data.transform = get$2();
-            translate(data.transform, box.x, box.y);
-        }
+        if (box.x || box.y) translate(data.transform = get$2(), box.x, box.y);
     }
-    if (scaleX && mode !== "stretch") {
+    data.width = width;
+    data.height = height;
+    if (scaleX) {
         data.scaleX = scaleX;
         data.scaleY = scaleY;
     }
-    data.width = width;
-    data.height = height;
     if (opacity) data.opacity = opacity;
     if (filters) data.filters = filters;
     if (repeat) data.repeat = isString(repeat) ? repeat === "x" ? "repeat-x" : "repeat-y" : "repeat";
@@ -11919,7 +11969,7 @@ function ignoreRender(ui, value) {
 
 const {get: get$1, scale: scale$2, copy: copy$4} = MatrixHelper;
 
-const {floor: floor$1, ceil: ceil$1, max: max$2, abs: abs$4} = Math;
+const {floor: floor$1, ceil: ceil$1, max: max$2, abs: abs$6} = Math;
 
 function createPattern(ui, paint, pixelRatio) {
     let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true, paint.scaleFixed);
@@ -11930,8 +11980,8 @@ function createPattern(ui, paint, pixelRatio) {
         scaleX *= pixelRatio;
         scaleY *= pixelRatio;
         if (sx) {
-            sx = abs$4(sx);
-            sy = abs$4(sy);
+            sx = abs$6(sx);
+            sy = abs$6(sy);
             imageMatrix = get$1();
             copy$4(imageMatrix, transform);
             scale$2(imageMatrix, 1 / sx, 1 / sy);
@@ -12073,6 +12123,7 @@ const PaintImageModule = {
     recycleImage: recycleImage,
     createData: createData,
     getPatternData: getPatternData,
+    stretchMode: stretchMode,
     fillOrFitMode: fillOrFitMode,
     clipMode: clipMode,
     repeatMode: repeatMode
@@ -12183,7 +12234,7 @@ const PaintGradientModule = {
     getTransform: getTransform
 };
 
-const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$1} = Math;
+const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$1, abs: abs$5} = Math;
 
 const tempBounds = {}, tempMatrix = new Matrix;
 
@@ -12227,7 +12278,7 @@ function shadow$1(ui, current, shape) {
 function getShadowRenderSpread(_ui, shadow) {
     let top = 0, right = 0, bottom = 0, left = 0, x, y, spread, blur;
     shadow.forEach(item => {
-        x = item.x || 0, y = item.y || 0, spread = item.spread || 0, blur = (item.blur || 0) * 1.5;
+        x = item.x || 0, y = item.y || 0, blur = (item.blur || 0) * 1.5, spread = abs$5(item.spread || 0);
         top = max$1(top, spread + blur - y);
         right = max$1(right, spread + blur + x);
         bottom = max$1(bottom, spread + blur + y);
@@ -13009,7 +13060,10 @@ function targetAttr(fn) {
                             t.setDimOthers(false);
                             t.setBright(false);
                             if (isArray(value) && value.length > 1 && value[0].locked) value.splice(0, 1);
-                            if (t.single) t.element.syncEventer = null;
+                            if (t.single) {
+                                delete t.element.syncEventer;
+                                delete t.element.__world.ignorePixelSnap;
+                            }
                         }
                         const type = isSelect ? EditorEvent.BEFORE_SELECT : EditorEvent.BEFORE_HOVER;
                         if (this.hasEvent(type)) this.emitEvent(new EditorEvent(type, {
@@ -13030,7 +13084,15 @@ function mergeConfigAttr() {
         defineKey(target, key, {
             get() {
                 const {config: config, element: element, dragPoint: dragPoint, editBox: editBox, app: app} = this, mergeConfig = Object.assign({}, config);
-                if (element && element.editConfig) Object.assign(mergeConfig, element.editConfig);
+                if (element && element.editConfig) {
+                    let {editConfig: editConfig} = element;
+                    if (editConfig.hover || editConfig.hoverStyle) {
+                        editConfig = Object.assign({}, editConfig);
+                        delete editConfig.hover;
+                        delete editConfig.hoverStyle;
+                    }
+                    Object.assign(mergeConfig, editConfig);
+                }
                 if (editBox.config) Object.assign(mergeConfig, editBox.config);
                 if (dragPoint) {
                     if (dragPoint.editConfig) Object.assign(mergeConfig, dragPoint.editConfig);
@@ -13047,7 +13109,7 @@ function mergeConfigAttr() {
     };
 }
 
-const {abs: abs$3} = Math;
+const {abs: abs$4} = Math;
 
 const {copy: copy$2, scale: scale$1} = MatrixHelper;
 
@@ -13090,7 +13152,7 @@ class Stroker extends UI {
                 leaf = list[i];
                 const {worldTransform: worldTransform, worldRenderBounds: worldRenderBounds} = leaf;
                 if (worldRenderBounds.width && worldRenderBounds.height && (!bounds || bounds.hit(worldRenderBounds, options.matrix))) {
-                    const aScaleX = abs$3(worldTransform.scaleX), aScaleY = abs$3(worldTransform.scaleY);
+                    const aScaleX = abs$4(worldTransform.scaleX), aScaleY = abs$4(worldTransform.scaleY);
                     copy$2(matrix$1, worldTransform);
                     matrix$1.half = strokeWidth % 2;
                     if (aScaleX !== aScaleY) {
@@ -13104,7 +13166,7 @@ class Stroker extends UI {
                         canvas.setWorld(matrix$1, options.matrix);
                         canvas.beginPath();
                         if (leaf.__.__useArrow) leaf.__drawPath(canvas); else leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
-                        data.strokeWidth = strokeWidth / abs$3(worldTransform.scaleX);
+                        data.strokeWidth = strokeWidth / abs$4(worldTransform.scaleX);
                     }
                     if (stroke) isString(stroke) ? Paint.stroke(stroke, this, canvas) : Paint.strokes(stroke, this, canvas);
                     if (fill) isString(fill) ? Paint.fill(fill, this, canvas) : Paint.fills(fill, this, canvas);
@@ -13216,8 +13278,10 @@ class EditSelect extends Group {
     onHover() {
         const {editor: editor} = this;
         if (this.running && !this.dragging && !editor.dragging) {
-            const {stroke: stroke, strokeWidth: strokeWidth, hover: hover, hoverStyle: hoverStyle} = editor.mergeConfig;
-            this.hoverStroker.setTarget(hover ? this.editor.hoverTarget : null, Object.assign({
+            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;
+            this.hoverStroker.setTarget(hover ? hoverTarget : null, Object.assign({
                 stroke: stroke,
                 strokeWidth: strokeWidth
             }, hoverStyle || {}));
@@ -13397,13 +13461,11 @@ class EditSelect extends Group {
 
 const {topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bottomRight: bottomRight, bottom: bottom$1, bottomLeft: bottomLeft, left: left$2} = Direction9;
 
-const {toPoint: toPoint} = AroundHelper;
-
-const {within: within$3, sign: sign$1} = MathHelper;
+const {toPoint: toPoint} = AroundHelper, {within: within$3, sign: sign$1} = MathHelper, {abs: abs$3} = Math;
 
 const EditDataHelper = {
     getScaleData(target, startBounds, direction, totalMoveOrScale, lockRatio, around, flipable, scaleMode) {
-        let align, origin = {}, scaleX = 1, scaleY = 1;
+        let align, origin = {}, scaleX = 1, scaleY = 1, lockScale;
         const {boxBounds: boxBounds, widthRange: widthRange, heightRange: heightRange, dragBounds: dragBounds, worldBoxBounds: worldBoxBounds} = target;
         const {width: width, height: height} = startBounds;
         const originChangedScaleX = target.scaleX / startBounds.scaleX;
@@ -13473,23 +13535,22 @@ const EditDataHelper = {
                 if (lockRatio === "corner" && direction % 2) {
                     lockRatio = false;
                 } else {
-                    let scale;
                     switch (direction) {
                       case top$1:
                       case bottom$1:
-                        scale = scaleY;
+                        scaleX = scaleY;
                         break;
 
                       case left$2:
                       case right$2:
-                        scale = scaleX;
+                        scaleY = scaleX;
                         break;
 
                       default:
-                        scale = Math.sqrt(Math.abs(scaleX * scaleY));
+                        lockScale = Math.sqrt(abs$3(scaleX * scaleY));
+                        scaleX = sign$1(scaleX) * lockScale;
+                        scaleY = sign$1(scaleY) * lockScale;
                     }
-                    scaleX = scaleX < 0 ? -scale : scale;
-                    scaleY = scaleY < 0 ? -scale : scale;
                 }
             }
         }
@@ -13507,7 +13568,7 @@ const EditDataHelper = {
                 x: scaleX,
                 y: scaleY
             };
-            DragBoundsHelper.limitScaleOf(target, origin, scaleData);
+            DragBoundsHelper.limitScaleOf(target, origin, scaleData, lockRatio);
             scaleX = scaleData.x;
             scaleY = scaleData.y;
         }
@@ -13519,9 +13580,13 @@ const EditDataHelper = {
             const nowHeight = boxBounds.height * target.scaleY;
             scaleY = within$3(nowHeight * scaleY, heightRange) / nowHeight;
         }
-        if (useScaleX && Math.abs(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
-        if (useScaleY && Math.abs(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
-        if (lockRatio && scaleX !== scaleY) scaleY = scaleX = Math.min(scaleX, scaleY);
+        if (useScaleX && abs$3(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
+        if (useScaleY && abs$3(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
+        if (lockRatio && scaleX !== scaleY) {
+            lockScale = Math.min(abs$3(scaleX), abs$3(scaleY));
+            scaleX = sign$1(scaleX) * lockScale;
+            scaleY = sign$1(scaleY) * lockScale;
+        }
         return {
             origin: origin,
             scaleX: scaleX,
@@ -13771,7 +13836,7 @@ class EditBox extends Group {
         return this.scaleX * this.scaleY < 0;
     }
     get canUse() {
-        return this.visible && this.view.visible;
+        return this.app && this.visible && this.view.visible;
     }
     get canGesture() {
         if (!this.canUse) return false;
@@ -13852,7 +13917,7 @@ class EditBox extends Group {
     }
     load() {
         const {target: target, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, resizePoints: resizePoints, resizeLines: resizeLines} = this;
-        const {stroke: stroke, strokeWidth: strokeWidth, resizeLine: resizeLine} = mergeConfig;
+        const {stroke: stroke, strokeWidth: strokeWidth, resizeLine: resizeLine, ignorePixelSnap: ignorePixelSnap} = mergeConfig;
         const pointsStyle = this.getPointsStyle();
         const middlePointsStyle = this.getMiddlePointsStyle();
         this.visible = !target.locked;
@@ -13872,16 +13937,16 @@ class EditBox extends Group {
             strokeWidth: strokeWidth,
             editConfig: editConfig
         }, mergeConfig.rect || {}));
-        const syncEventer = single && this.transformTool.editTool;
-        rect.hittable = !syncEventer;
-        rect.syncEventer = syncEventer && this.editor;
-        if (syncEventer) {
+        const rectThrough = isNull(mergeConfig.rectThrough) ? single : mergeConfig.rectThrough;
+        rect.hittable = !rectThrough;
+        if (rectThrough) {
             target.syncEventer = rect;
             this.app.interaction.bottomList = [ {
                 target: rect,
                 proxy: target
             } ];
         }
+        if (single) DataHelper.stintSet(target.__world, "ignorePixelSnap", ignorePixelSnap);
         updateMoveCursor(this);
     }
     update() {