@leafer/worker 1.9.9 → 1.9.11

package/dist/worker.js

@@ -230,7 +230,7 @@ var LeaferUI = function(exports) {
         }
     }
     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 ],
         tempFour: tempFour,
@@ -243,7 +243,7 @@ var LeaferUI = function(exports) {
             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 : [];
@@ -281,23 +281,23 @@ var LeaferUI = function(exports) {
             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;
     const MathHelper = {
         within(value, min, max) {
@@ -682,7 +682,7 @@ var LeaferUI = function(exports) {
     };
     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(),
         tempPoint: {},
@@ -774,12 +774,12 @@ var LeaferUI = function(exports) {
             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;
@@ -2417,9 +2417,9 @@ var LeaferUI = function(exports) {
             data[0] ? drawer.arcTo(x, y, right, y, data[0]) : drawer.lineTo(x, y);
         }
     };
-    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;
     const tempPoint$2 = {};
     const BezierHelper = {
@@ -2487,14 +2487,14 @@ var LeaferUI = function(exports) {
             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;
@@ -2520,7 +2520,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2534,7 +2534,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2553,7 +2553,7 @@ var LeaferUI = function(exports) {
                 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);
@@ -2973,7 +2973,7 @@ var LeaferUI = function(exports) {
     const {current: current, pushData: pushData, copyData: copyData} = PathConvert;
     const {M: M$8, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F: F$5, O: O$5, P: P$4, U: U$4} = PathCommandMap;
     const {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 = {};
     const PathCommandDataHelper = {
         beginPath(data) {
@@ -3029,7 +3029,7 @@ var LeaferUI = function(exports) {
         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);
         },
@@ -3611,7 +3611,12 @@ var LeaferUI = function(exports) {
         runTask() {
             const task = this.list[this.index];
             if (!task) {
-                this.nextTask();
+                this.timer = setTimeout(() => this.nextTask());
+                return;
+            }
+            if (task.isCancel) {
+                this.index++;
+                this.runTask();
                 return;
             }
             task.run().then(() => {
@@ -3642,16 +3647,15 @@ var LeaferUI = function(exports) {
         }
         setParallelList() {
             let task;
+            const {config: config, list: list, index: index} = this;
             this.parallelList = [];
             this.parallelSuccessNumber = 0;
-            let end = this.index + this.config.parallel;
-            if (end > this.list.length) end = this.list.length;
-            for (let i = this.index; i < end; i++) {
-                task = this.list[i];
-                if (task.parallel) {
-                    this.parallelList.push(task);
-                } else {
-                    break;
+            let end = index + config.parallel;
+            if (end > list.length) end = list.length;
+            if (config.parallel > 1) {
+                for (let i = index; i < end; i++) {
+                    task = list[i];
+                    if (task.parallel) this.parallelList.push(task); else break;
                 }
             }
         }
@@ -3787,7 +3791,7 @@ var LeaferUI = function(exports) {
     };
     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() {
             return this.config.url;
@@ -3875,7 +3879,7 @@ var LeaferUI = function(exports) {
                 }
                 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;
@@ -6409,7 +6413,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "1.9.9";
+    const version = "1.9.11";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -7045,7 +7049,7 @@ var LeaferUI = function(exports) {
                 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 ? {
@@ -7060,7 +7064,7 @@ var LeaferUI = function(exports) {
         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;
@@ -7091,15 +7095,27 @@ var LeaferUI = function(exports) {
                     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) {
@@ -7556,12 +7572,12 @@ var LeaferUI = function(exports) {
         }
         __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;
         }
     }
@@ -7578,7 +7594,7 @@ var LeaferUI = function(exports) {
             return data;
         }
     }
-    const {max: max$3, add: add$1} = FourNumberHelper;
+    const {max: max$4, add: add$1} = FourNumberHelper;
     const UIBounds = {
         __updateStrokeSpread() {
             let spread = 0, boxSpread = 0;
@@ -7593,7 +7609,7 @@ var LeaferUI = function(exports) {
             }
             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;
@@ -7603,81 +7619,17 @@ var LeaferUI = function(exports) {
             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;
-        }
-    };
-    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;
+            return box ? max$4(box.__updateRenderSpread(), spread) : spread;
         }
     };
-    const D$2 = DragBoundsHelper;
     const {stintSet: stintSet$1} = DataHelper;
     const UIRender = {
         __updateChange() {
@@ -9134,6 +9086,102 @@ var LeaferUI = function(exports) {
             EventCreator.changeName(oldName, newName);
         }
     }
+    const {min: min, max: max$3, abs: abs$7} = Math, {float: float$1, sign: sign$2} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
+    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 = 1, correctScaleY = 1, aScale, bScale, aSize, bSize;
+            if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+                if (scale.x < 0) tempContent.scaleOf(origin, correctScaleX = 1 / scale.x, 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) {
+                    if (float$1(minX(content) - minX(dragBounds)) <= 0 || float$1(maxX(dragBounds) - maxX(content)) <= 0) tempContent.scaleOf(origin, correctScaleX = 1 / scale.x, 1);
+                    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")) {
+                if (scale.y < 0) tempContent.scaleOf(origin, 1, correctScaleY = 1 / scale.y);
+                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) {
+                    if (float$1(minY(content) - minY(dragBounds)) <= 0 || float$1(maxY(dragBounds) - maxY(content)) <= 0) tempContent.scaleOf(origin, 1, correctScaleY = 1 / scale.y);
+                    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;
     exports.PointerEvent = class PointerEvent extends UIEvent {};
     exports.PointerEvent.POINTER = "pointer";
     exports.PointerEvent.BEFORE_DOWN = "pointer.before_down";
@@ -10105,9 +10153,9 @@ var LeaferUI = function(exports) {
     const ui$5 = exports.UI.prototype;
     ui$5.__updateHitCanvas = function() {
         if (this.__box) this.__box.__updateHitCanvas();
-        const leafer = this.leafer || this.parent && this.parent.leafer;
-        if (!leafer) return;
-        const data = this.__, {hitCanvasManager: hitCanvasManager} = leafer;
+        const {hitCanvasManager: hitCanvasManager} = this.leafer || this.parent && this.parent.leafer || {};
+        if (!hitCanvasManager) return;
+        const data = this.__;
         const isHitPixelFill = (data.__isAlphaPixelFill || data.__isCanvas) && data.hitFill === "pixel";
         const isHitPixelStroke = data.__isAlphaPixelStroke && data.hitStroke === "pixel";
         const isHitPixel = isHitPixelFill || isHitPixelStroke;
@@ -10545,7 +10593,13 @@ var LeaferUI = function(exports) {
         shape: shape
     };
     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();
         translate$1(transform, box.x + x, box.y + y);
@@ -10560,8 +10614,11 @@ var LeaferUI = function(exports) {
         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;
     }
@@ -10649,7 +10706,10 @@ var LeaferUI = function(exports) {
         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":
@@ -10658,7 +10718,7 @@ var LeaferUI = function(exports) {
                 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;
 
@@ -10675,17 +10735,14 @@ var LeaferUI = function(exports) {
             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";
@@ -10804,7 +10861,7 @@ var LeaferUI = function(exports) {
         if (leafer && leafer.viewReady) leafer.renderer.ignore = 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);
         const id = scaleX + "-" + scaleY + "-" + pixelRatio;
@@ -10814,8 +10871,8 @@ var LeaferUI = function(exports) {
             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);
@@ -10953,6 +11010,7 @@ var LeaferUI = function(exports) {
         recycleImage: recycleImage,
         createData: createData,
         getPatternData: getPatternData,
+        stretchMode: stretchMode,
         fillOrFitMode: fillOrFitMode,
         clipMode: clipMode,
         repeatMode: repeatMode
@@ -11044,7 +11102,7 @@ var LeaferUI = function(exports) {
         conicGradient: conicGradient,
         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;
     const offsetOutBounds$1 = {};
     function shadow$1(ui, current, shape) {
@@ -11084,7 +11142,7 @@ var LeaferUI = function(exports) {
     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);
@@ -11094,11 +11152,11 @@ var LeaferUI = function(exports) {
     }
     function getShadowTransform(ui, canvas, _shape, shadow, outBounds, otherScale, isInnerShaodw) {
         if (shadow.spread) {
-            const spreadScale = 1 + shadow.spread * 2 / ui.__layout.strokeBounds.width * otherScale * (isInnerShaodw ? -1 : 1);
+            const spread = shadow.spread * 2 * otherScale * (isInnerShaodw ? -1 : 1), {width: width, height: height} = ui.__layout.strokeBounds;
             tempMatrix.set().scaleOfOuter({
                 x: (outBounds.x + outBounds.width / 2) * canvas.pixelRatio,
                 y: (outBounds.y + outBounds.height / 2) * canvas.pixelRatio
-            }, spreadScale);
+            }, 1 + spread / width, 1 + spread / height);
             return tempMatrix;
         }
         return undefined;
@@ -11776,7 +11834,10 @@ var LeaferUI = function(exports) {
                                 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, {
@@ -11796,7 +11857,15 @@ var LeaferUI = function(exports) {
             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);
@@ -11812,7 +11881,7 @@ var LeaferUI = function(exports) {
             });
         };
     }
-    const {abs: abs$3} = Math;
+    const {abs: abs$4} = Math;
     const {copy: copy$2, scale: scale$1} = MatrixHelper;
     const {setListWithFn: setListWithFn} = BoundsHelper;
     const {worldBounds: worldBounds} = LeafBoundsHelper;
@@ -11849,7 +11918,7 @@ var LeaferUI = function(exports) {
                     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) {
@@ -11863,7 +11932,7 @@ var LeaferUI = function(exports) {
                             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);
@@ -11968,8 +12037,10 @@ var LeaferUI = function(exports) {
         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 || {}));
@@ -12147,11 +12218,10 @@ 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;
-    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;
@@ -12221,23 +12291,22 @@ var LeaferUI = function(exports) {
                     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;
                     }
                 }
             }
@@ -12255,7 +12324,7 @@ var LeaferUI = function(exports) {
                     x: scaleX,
                     y: scaleY
                 };
-                DragBoundsHelper.limitScaleOf(target, origin, scaleData);
+                DragBoundsHelper.limitScaleOf(target, origin, scaleData, lockRatio);
                 scaleX = scaleData.x;
                 scaleY = scaleData.y;
             }
@@ -12267,9 +12336,13 @@ var LeaferUI = function(exports) {
                 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,
@@ -12512,7 +12585,7 @@ var LeaferUI = function(exports) {
             return this.scaleX * this.scaleY < 0;
         }
         get canUse() {
-            return this.visible && this.view.visible;
+            return this.app && this.editor.editing;
         }
         get canGesture() {
             if (!this.canUse) return false;
@@ -12593,7 +12666,7 @@ var LeaferUI = function(exports) {
         }
         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;
@@ -12613,16 +12686,16 @@ var LeaferUI = function(exports) {
                 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() {
@@ -12786,29 +12859,25 @@ var LeaferUI = function(exports) {
             this.dragPoint = null;
         }
         onTransformStart(e) {
-            if (this.canUse) {
-                if (this.moving) this.editor.opacity = this.mergedConfig.hideOnMove ? 0 : 1;
-                if (this.resizing) ResizeEvent.resizingKeys = this.editor.leafList.keys;
-                const {dragStartData: dragStartData, target: target} = this;
-                dragStartData.x = e.x;
-                dragStartData.y = e.y;
-                dragStartData.totalOffset = getPointData();
-                dragStartData.point = {
-                    x: target.x,
-                    y: target.y
-                };
-                dragStartData.bounds = Object.assign({}, target.getLayoutBounds("box", "local"));
-                dragStartData.rotation = target.rotation;
-            }
+            if (this.moving) this.editor.opacity = this.mergedConfig.hideOnMove ? 0 : 1;
+            if (this.resizing) ResizeEvent.resizingKeys = this.editor.leafList.keys;
+            const {dragStartData: dragStartData, target: target} = this;
+            dragStartData.x = e.x;
+            dragStartData.y = e.y;
+            dragStartData.totalOffset = getPointData();
+            dragStartData.point = {
+                x: target.x,
+                y: target.y
+            };
+            dragStartData.bounds = Object.assign({}, target.getLayoutBounds("box", "local"));
+            dragStartData.rotation = target.rotation;
         }
         onTransformEnd(e) {
-            if (this.canUse) {
-                if (this.canDragLimitAnimate && (e instanceof exports.DragEvent || e instanceof exports.MoveEvent)) this.transformTool.onMove(e);
-                if (this.resizing) ResizeEvent.resizingKeys = null;
-                this.dragging = this.gesturing = this.moving = this.resizing = this.rotating = this.skewing = false;
-                this.editor.opacity = 1;
-                this.update();
-            }
+            if (this.canDragLimitAnimate && (e instanceof exports.DragEvent || e instanceof exports.MoveEvent)) this.transformTool.onMove(e);
+            if (this.resizing) ResizeEvent.resizingKeys = null;
+            this.dragging = this.gesturing = this.moving = this.resizing = this.rotating = this.skewing = false;
+            this.editor.opacity = 1;
+            this.editor.update();
         }
         onMove(e) {
             if (this.canGesture && e.moveType !== "drag") {
@@ -12837,6 +12906,12 @@ var LeaferUI = function(exports) {
                 }
             }
         }
+        onGestureStart(e) {
+            if (this.canGesture && e.moveType !== "drag") this.onTransformStart(e);
+        }
+        onGestureEnd(e) {
+            if (this.canGesture && e.moveType !== "drag") this.onTransformEnd(e);
+        }
         isHoldRotateKey(e) {
             const {rotateKey: rotateKey} = this.mergedConfig;
             if (rotateKey) return e.isHoldKeys(rotateKey);
@@ -12906,7 +12981,7 @@ var LeaferUI = function(exports) {
             const {rect: rect, editor: editor, __eventIds: events} = this;
             events.push(rect.on_([ [ exports.PointerEvent.DOUBLE_TAP, this.onDoubleTap, this ], [ exports.PointerEvent.LONG_PRESS, this.onLongPress, this ] ]));
             this.waitLeafer(() => {
-                events.push(editor.app.on_([ [ [ exports.KeyEvent.HOLD, exports.KeyEvent.UP ], this.onKey, this ], [ exports.KeyEvent.DOWN, this.onArrow, this ], [ [ exports.MoveEvent.START, exports.MoveEvent.BEFORE_MOVE ], this.onMove, this, true ], [ [ exports.ZoomEvent.START, exports.ZoomEvent.BEFORE_ZOOM ], this.onScale, this, true ], [ [ exports.RotateEvent.START, exports.RotateEvent.BEFORE_ROTATE ], this.onRotate, this, true ], [ [ exports.MoveEvent.END, exports.ZoomEvent.END, exports.RotateEvent.END ], this.onTransformEnd, this ] ]));
+                events.push(editor.app.on_([ [ [ exports.KeyEvent.HOLD, exports.KeyEvent.UP ], this.onKey, this ], [ exports.KeyEvent.DOWN, this.onArrow, this ], [ exports.MoveEvent.BEFORE_MOVE, this.onMove, this, true ], [ exports.ZoomEvent.BEFORE_ZOOM, this.onScale, this, true ], [ exports.RotateEvent.BEFORE_ROTATE, this.onRotate, this, true ], [ [ exports.MoveEvent.START, exports.ZoomEvent.START, exports.RotateEvent.START ], this.onGestureStart, this ], [ [ exports.MoveEvent.END, exports.ZoomEvent.END, exports.RotateEvent.END ], this.onGestureEnd, this ] ]));
             });
         }
         __removeListenEvents() {
@@ -15195,6 +15270,68 @@ var LeaferUI = function(exports) {
             this.__htmlChanged = true;
         }
     }
+    const unicodeEntities = {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " ",
+        ensp: " ",
+        emsp: " ",
+        thinsp: " ",
+        ndash: "–",
+        mdash: "—",
+        hellip: "…",
+        middot: "·",
+        bull: "•",
+        laquo: "«",
+        raquo: "»",
+        lsquo: "‘",
+        rsquo: "’",
+        ldquo: "“",
+        rdquo: "”",
+        cent: "¢",
+        pound: "£",
+        yen: "¥",
+        euro: "€",
+        times: "×",
+        divide: "÷",
+        plusmn: "±",
+        minus: "−",
+        frac12: "½",
+        frac14: "¼",
+        frac34: "¾",
+        sup2: "²",
+        sup3: "³",
+        deg: "°",
+        reg: "®",
+        copy: "©",
+        trade: "™",
+        section: "§",
+        para: "¶",
+        dagger: "†",
+        Dagger: "‡",
+        larr: "←",
+        uarr: "↑",
+        rarr: "→",
+        darr: "↓",
+        harr: "↔",
+        alpha: "α",
+        beta: "β",
+        gamma: "γ",
+        delta: "δ",
+        pi: "π",
+        sigma: "σ",
+        omega: "ω",
+        Omega: "Ω",
+        micro: "µ",
+        infinity: "∞",
+        not: "¬",
+        equiv: "≡",
+        le: "≤",
+        ge: "≥"
+    };
     exports.HTMLText = class HTMLText extends exports.Image {
         get __tag() {
             return "HTMLText";
@@ -15214,7 +15351,7 @@ var LeaferUI = function(exports) {
                 document.body.appendChild(div);
                 const {width: width, height: height} = div.getBoundingClientRect();
                 const realWidth = width + 10;
-                const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${realWidth}" height="${height}">\n                        <foreignObject width="${realWidth}" height="${height}">\n                            <style>\n                                * {\n                                    margin: 0;\n                                    padding: 0;\n                                    box-sizing: border-box;\n                                }\n                            </style>\n                            <body xmlns="http://www.w3.org/1999/xhtml">\n                                ${this.text}\n                            </body>\n                        </foreignObject>\n                    </svg>`;
+                const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${realWidth}" height="${height}">\n                        <foreignObject width="${realWidth}" height="${height}">\n                            <style>\n                                * {\n                                    margin: 0;\n                                    padding: 0;\n                                    box-sizing: border-box;\n                                }\n                            </style>\n                            <body xmlns="http://www.w3.org/1999/xhtml">\n                                ${this.decodeText(this.text)}\n                            </body>\n                        </foreignObject>\n                    </svg>`;
                 data.__setImageFill("data:image/svg+xml," + encodeURIComponent(svg));
                 data.__naturalWidth = realWidth / data.pixelRatio;
                 data.__naturalHeight = height / data.pixelRatio;
@@ -15227,6 +15364,29 @@ var LeaferUI = function(exports) {
             if (this.textEditing && !options.exporting) return;
             super.__draw(canvas, options, originCanvas);
         }
+        decodeText(text) {
+            if (!text.includes("&")) return text;
+            let result = "", i = 0, entity, value;
+            while (i < text.length) {
+                if (text[i] === "&") {
+                    const semicolonIndex = text.indexOf(";", i + 1);
+                    if (semicolonIndex > i + 1) {
+                        entity = text.slice(i + 1, semicolonIndex);
+                        value = unicodeEntities[entity];
+                        if (value !== undefined) {
+                            result += value;
+                            i = semicolonIndex + 1;
+                            continue;
+                        }
+                    }
+                }
+                result += text[i++];
+            }
+            return result;
+        }
+        static addUnicodeEntity(entity, unicode) {
+            if (isString(entity)) unicodeEntities[entity] = unicode; else Object.assign(unicodeEntities, entity);
+        }
     };
     __decorate([ dataProcessor(HTMLTextData) ], exports.HTMLText.prototype, "__", void 0);
     __decorate([ boundsType("") ], exports.HTMLText.prototype, "text", void 0);