@leafer/worker 2.0.2 → 2.0.4

package/dist/worker.js

@@ -233,6 +233,7 @@ var LeaferUI = function(exports) {
         }
         destroy() {
             this.__input = this.__middle = null;
+            if (this.__complexData) this.__complexData.destroy();
         }
     }
     const IncrementId = {
@@ -323,6 +324,7 @@ var LeaferUI = function(exports) {
     };
     const {set: set$2, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
     const {round: round$6, pow: pow$2, max: max$6, floor: floor$3, PI: PI$4} = Math;
+    const tempScaleData$1 = {};
     const MathHelper = {
         within(value, min, max) {
             if (isObject(min)) max = min.max, min = min.min;
@@ -366,6 +368,24 @@ var LeaferUI = function(exports) {
             } else if (scale) MathHelper.assignScale(scaleData, scale);
             return scaleData;
         },
+        getScaleFixedData(worldScaleData, scaleFixed, unscale, abs, _localScaleData) {
+            let {scaleX: scaleX, scaleY: scaleY} = worldScaleData;
+            if (abs || scaleFixed) scaleX < 0 && (scaleX = -scaleX), scaleY < 0 && (scaleY = -scaleY);
+            if (scaleFixed) {
+                if (scaleFixed === true) {
+                    scaleX = scaleY = unscale ? 1 : 1 / scaleX;
+                } else {
+                    let minScale;
+                    if (isNumber(scaleFixed)) minScale = scaleFixed; else if (scaleFixed === "zoom-in") minScale = 1;
+                    if (minScale) {
+                        if (scaleX > minScale || scaleY > minScale) scaleX = scaleY = unscale ? 1 : 1 / scaleX; else scaleX = scaleY = unscale ? 1 : 1 / minScale;
+                    }
+                }
+            }
+            tempScaleData$1.scaleX = scaleX;
+            tempScaleData$1.scaleY = scaleY;
+            return tempScaleData$1;
+        },
         assignScale(scaleData, scale) {
             if (isNumber(scale)) {
                 scaleData.scaleX = scaleData.scaleY = scale;
@@ -845,8 +865,8 @@ var LeaferUI = function(exports) {
             if (isObject(originPoints[0])) points = [], originPoints.forEach(p => points.push(p.x, p.y));
             return points;
         },
-        isSame(t, point) {
-            return float$5(t.x) === float$5(point.x) && float$5(t.y) === float$5(point.y);
+        isSame(t, point, quick) {
+            return quick ? t.x === point.x && t.y === point.y : float$5(t.x) === float$5(point.x) && float$5(t.y) === float$5(point.y);
         },
         reset(t) {
             P$7.reset(t);
@@ -918,8 +938,8 @@ var LeaferUI = function(exports) {
         getAtan2(to) {
             return PointHelper.getAtan2(this, to);
         }
-        isSame(point) {
-            return PointHelper.isSame(this, point);
+        isSame(point, quick) {
+            return PointHelper.isSame(this, point, quick);
         }
         reset() {
             PointHelper.reset(this);
@@ -1163,9 +1183,9 @@ var LeaferUI = function(exports) {
             }
             if (!onlyBoxSize) to.x += box.x, to.y += box.y;
         },
-        getPoint(around, box, to) {
+        getPoint(around, box, to, onlyBoxSize = true) {
             if (!to) to = {};
-            AroundHelper.toPoint(around, box, to, true);
+            AroundHelper.toPoint(around, box, to, onlyBoxSize);
             return to;
         }
     };
@@ -1420,6 +1440,9 @@ var LeaferUI = function(exports) {
                 y: y + height
             } ];
         },
+        getPoint(t, around, onlyBoxSize = false, to) {
+            return AroundHelper.getPoint(around, t, to, onlyBoxSize);
+        },
         hitRadiusPoint(t, point, pointMatrix) {
             if (pointMatrix) point = PointHelper.tempToInnerRadiusPointOf(point, pointMatrix);
             return point.x >= t.x - point.radiusX && point.x <= t.x + t.width + point.radiusX && (point.y >= t.y - point.radiusY && point.y <= t.y + t.height + point.radiusY);
@@ -1588,6 +1611,9 @@ var LeaferUI = function(exports) {
         getPoints() {
             return BoundsHelper.getPoints(this);
         }
+        getPoint(around, onlyBoxSize, to) {
+            return BoundsHelper.getPoint(this, around, onlyBoxSize, to);
+        }
         hitPoint(point, pointMatrix) {
             return BoundsHelper.hitPoint(this, point, pointMatrix);
         }
@@ -2581,10 +2607,10 @@ var LeaferUI = function(exports) {
             const centerY = y1 + c * sin$4(startRadian + totalRadian / 2 + PI_2 * sign);
             startRadian -= PI_2 * sign;
             endRadian -= PI_2 * sign;
-            return ellipse$6(data, centerX, centerY, radius, radius, 0, startRadian / OneRadian, endRadian / OneRadian, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
+            return ellipse$8(data, centerX, centerY, radius, radius, 0, startRadian / OneRadian, endRadian / OneRadian, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
         },
         arc(data, x, y, radius, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint) {
-            return ellipse$6(data, x, y, radius, radius, 0, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
+            return ellipse$8(data, x, y, radius, radius, 0, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint);
         },
         ellipse(data, cx, cy, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint) {
             const rotationRadian = rotation * OneRadian;
@@ -2685,9 +2711,9 @@ var LeaferUI = function(exports) {
             return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
         }
     };
-    const {getPointAndSet: getPointAndSet, toTwoPointBounds: toTwoPointBounds$1, ellipse: ellipse$6} = BezierHelper;
+    const {getPointAndSet: getPointAndSet, toTwoPointBounds: toTwoPointBounds$1, ellipse: ellipse$8} = BezierHelper;
     const {sin: sin$3, cos: cos$3, sqrt: sqrt$2, atan2: atan2} = Math;
-    const {ellipse: ellipse$5} = BezierHelper;
+    const {ellipse: ellipse$7} = BezierHelper;
     const EllipseHelper = {
         ellipticalArc(data, fromX, fromY, radiusX, radiusY, rotation, largeFlag, sweepFlag, toX, toY, curveMode) {
             const halfX = (toX - fromX) / 2;
@@ -2724,7 +2750,7 @@ var LeaferUI = function(exports) {
             const centerY = fromY + halfY + rotationSin * cx + rotationCos * cy;
             const anticlockwise = totalRadian < 0 ? 1 : 0;
             if (curveMode || Platform.ellipseToCurve) {
-                ellipse$5(data, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
+                ellipse$7(data, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
             } else {
                 if (radiusX === radiusY && !rotation) {
                     data.push(PathCommandMap.O, centerX, centerY, radiusX, startRadian / OneRadian, endRadian / OneRadian, anticlockwise);
@@ -2743,7 +2769,7 @@ var LeaferUI = function(exports) {
         }
     };
     const {M: M$9, m: m, L: L$9, l: l, H: H, h: h, V: V, v: v, C: C$7, c: c, S: S$1, s: s, Q: Q$6, q: q, T: T, t: t, A: A, a: a, Z: Z$7, z: z, N: N$5, D: D$6, X: X$5, G: G$5, F: F$6, O: O$6, P: P$5, U: U$5} = PathCommandMap;
-    const {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$4, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
+    const {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$6, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
     const {ellipticalArc: ellipticalArc} = EllipseHelper;
     const debug$f = Debug.get("PathConvert");
     const setEndPoint$1 = {};
@@ -2972,14 +2998,14 @@ var LeaferUI = function(exports) {
                     break;
 
                   case G$5:
-                    ellipse$4(curveMode ? data : copyData(data, old, i, 9), old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], old[i + 6], old[i + 7], old[i + 8], null, setEndPoint$1);
+                    ellipse$6(curveMode ? data : copyData(data, old, i, 9), old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], old[i + 6], old[i + 7], old[i + 8], null, setEndPoint$1);
                     x = setEndPoint$1.x;
                     y = setEndPoint$1.y;
                     i += 9;
                     break;
 
                   case F$6:
-                    curveMode ? ellipse$4(data, old[i + 1], old[i + 2], old[i + 3], old[i + 4], 0, 0, 360, false) : copyData(data, old, i, 5);
+                    curveMode ? ellipse$6(data, old[i + 1], old[i + 2], old[i + 3], old[i + 4], 0, 0, 360, false) : copyData(data, old, i, 5);
                     x = old[i + 1] + old[i + 3];
                     y = old[i + 2];
                     i += 5;
@@ -3127,7 +3153,7 @@ var LeaferUI = function(exports) {
         drawEllipse(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
             BezierHelper.ellipse(null, x, y, radiusX, radiusY, isNull(rotation) ? 0 : rotation, isNull(startAngle) ? 0 : startAngle, isNull(endAngle) ? 360 : endAngle, anticlockwise, null, null, startPoint);
             data.push(M$8, startPoint.x, startPoint.y);
-            ellipse$3(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+            ellipse$5(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
         },
         drawArc(data, x, y, radius, startAngle, endAngle, anticlockwise) {
             BezierHelper.arc(null, x, y, radius, isNull(startAngle) ? 0 : startAngle, isNull(endAngle) ? 360 : endAngle, anticlockwise, null, null, startPoint);
@@ -3138,8 +3164,8 @@ var LeaferUI = function(exports) {
             BezierHelper.points(data, points, curve, close);
         }
     };
-    const {ellipse: ellipse$3, arc: arc$2} = PathCommandDataHelper;
-    const {moveTo: moveTo$4, lineTo: lineTo$3, quadraticCurveTo: quadraticCurveTo, bezierCurveTo: bezierCurveTo, closePath: closePath$3, beginPath: beginPath, rect: rect$2, roundRect: roundRect$1, ellipse: ellipse$2, arc: arc$1, arcTo: arcTo$2, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
+    const {ellipse: ellipse$5, arc: arc$2} = PathCommandDataHelper;
+    const {moveTo: moveTo$4, lineTo: lineTo$3, quadraticCurveTo: quadraticCurveTo, bezierCurveTo: bezierCurveTo, closePath: closePath$3, beginPath: beginPath, rect: rect$2, roundRect: roundRect$1, ellipse: ellipse$4, arc: arc$1, arcTo: arcTo$2, drawEllipse: drawEllipse, drawArc: drawArc, drawPoints: drawPoints$2} = PathCommandDataHelper;
     class PathCreator {
         set path(value) {
             this.__path = value;
@@ -3195,7 +3221,7 @@ var LeaferUI = function(exports) {
             return this;
         }
         ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
-            ellipse$2(this.__path, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+            ellipse$4(this.__path, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
             this.paint();
             return this;
         }
@@ -3312,7 +3338,7 @@ var LeaferUI = function(exports) {
         }
     };
     const {M: M$6, L: L$6, C: C$4, Q: Q$3, Z: Z$4, N: N$2, D: D$3, X: X$2, G: G$2, F: F$3, O: O$3, P: P$2, U: U$2} = PathCommandMap;
-    const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$1} = BezierHelper;
+    const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$3} = BezierHelper;
     const {addPointBounds: addPointBounds, copy: copy$9, addPoint: addPoint$1, setPoint: setPoint$3, addBounds: addBounds, toBounds: toBounds$2} = TwoPointBoundsHelper;
     const debug$d = Debug.get("PathBounds");
     let radius, radiusX, radiusY;
@@ -3388,7 +3414,7 @@ var LeaferUI = function(exports) {
                     break;
 
                   case G$2:
-                    ellipse$1(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8], tempPointBounds, setEndPoint);
+                    ellipse$3(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8], tempPointBounds, setEndPoint);
                     i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                     x = setEndPoint.x;
                     y = setEndPoint.y;
@@ -3861,6 +3887,7 @@ var LeaferUI = function(exports) {
             return image;
         },
         recycle(image) {
+            if (image.parent) image = image.parent;
             image.use--;
             setTimeout(() => {
                 if (!image.use) {
@@ -4026,8 +4053,10 @@ var LeaferUI = function(exports) {
             return undefined;
         }
         clearLevels(_checkUse) {}
+        destroyFilter() {}
         destroy() {
             this.clearLevels();
+            this.destroyFilter();
             const {view: view} = this;
             if (view && view.close) view.close();
             this.config = {
@@ -4198,7 +4227,6 @@ var LeaferUI = function(exports) {
                 if (this.__setAttr(key, value)) {
                     const data = this.__;
                     DataHelper.stintSet(data, "__useDim", data.dim || data.bright || data.dimskip);
-                    this.__layout.surfaceChange();
                 }
             }
         }));
@@ -4243,7 +4271,6 @@ var LeaferUI = function(exports) {
         return decorateLeafAttr(defaultValue, key => attr({
             set(value) {
                 if (this.__setAttr(key, value)) {
-                    this.__layout.surfaceChange();
                     this.waitParent(() => {
                         this.parent.__layout.childrenSortChange();
                     });
@@ -4277,7 +4304,6 @@ var LeaferUI = function(exports) {
             set(value) {
                 if (this.__setAttr(key, value)) {
                     this.__layout.hitCanvasChanged = true;
-                    if (Debug.showBounds === "hit") this.__layout.surfaceChange();
                     if (this.leafer) this.leafer.updateCursor();
                 }
             }
@@ -4465,6 +4491,10 @@ var LeaferUI = function(exports) {
             if (layout.stateStyleChanged) leaf.updateState();
             if (layout.opacityChanged) updateAllWorldOpacity(leaf);
             leaf.__updateChange();
+            if (layout.surfaceChanged) {
+                if (leaf.__hasComplex) L$4.updateComplex(leaf);
+                layout.surfaceChanged = false;
+            }
         },
         updateAllChange(leaf) {
             updateChange$1(leaf);
@@ -4489,6 +4519,9 @@ var LeaferUI = function(exports) {
             if (!fromWorld) fromWorld = leaf.__nowWorld;
             if (leaf.__worldFlipped || Platform.fullImageShadow) currentCanvas.copyWorldByReset(fromCanvas, fromWorld, leaf.__nowWorld, blendMode, onlyResetTransform); else currentCanvas.copyWorldToInner(fromCanvas, fromWorld, leaf.__layout.renderBounds, blendMode);
         },
+        renderComplex(_leaf, _canvas, _options) {},
+        updateComplex(_leaf) {},
+        checkComplex(_leaf) {},
         moveWorld(t, x, y = 0, isInnerPoint, transition) {
             const local = isObject(x) ? Object.assign({}, x) : {
                 x: x,
@@ -4600,6 +4633,9 @@ var LeaferUI = function(exports) {
             divideParent(matrix$3, relative.scrollWorldTransform);
             return temp ? matrix$3 : Object.assign({}, matrix$3);
         },
+        updateScaleFixedWorld(_t) {},
+        updateOuterBounds(_t) {},
+        cacheId(_t) {},
         drop(t, parent, index, resize) {
             t.setTransform(L$4.getRelativeWorld(t, parent, true), resize);
             parent.add(t, index);
@@ -4646,7 +4682,8 @@ var LeaferUI = function(exports) {
             return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localStrokeBounds;
         },
         localRenderBounds(target) {
-            return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localRenderBounds;
+            const {__: __, __layout: __layout} = target;
+            return __.eraser || __.visible === 0 ? null : __layout.localOuterBounds || __layout.localRenderBounds;
         },
         maskLocalBoxBounds(target, index) {
             return checkMask(target, index) && target.__localBoxBounds;
@@ -4655,7 +4692,8 @@ var LeaferUI = function(exports) {
             return checkMask(target, index) && target.__layout.localStrokeBounds;
         },
         maskLocalRenderBounds(target, index) {
-            return checkMask(target, index) && target.__layout.localRenderBounds;
+            const {__layout: __layout} = target;
+            return checkMask(target, index) && (__layout.localOuterBounds || __layout.localRenderBounds);
         },
         excludeRenderBounds(child, options) {
             if (options.bounds && !options.bounds.hit(child.__world, options.matrix)) return true;
@@ -4775,11 +4813,11 @@ var LeaferUI = function(exports) {
                 w.height *= scaleY;
                 w.scaleX *= scaleX;
                 w.scaleY *= scaleY;
-                if (branch.isBranch) scale$2(branch, x, y, scaleX, scaleY, a, b);
+                if (branch.isBranch) scale$3(branch, x, y, scaleX, scaleY, a, b);
             }
         }
     };
-    const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$9, scale: scale$2} = BranchHelper;
+    const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$9, scale: scale$3} = BranchHelper;
     const WaitHelper = {
         run(wait) {
             if (wait && wait.length) {
@@ -5164,7 +5202,6 @@ var LeaferUI = function(exports) {
         }
         opacityChange() {
             this.opacityChanged = true;
-            this.surfaceChanged || this.surfaceChange();
         }
         childrenSortChange() {
             if (!this.childrenSortChanged) {
@@ -5252,7 +5289,7 @@ var LeaferUI = function(exports) {
             }
         }
         static emitWorld(leaf) {
-            if (leaf.leaferIsReady) leaf.emit(WORLD, this);
+            if (leaf.leaferIsReady) leaf.emit(WORLD, leaf);
         }
     }
     BoundsEvent.RESIZE = "bounds.resize";
@@ -5579,6 +5616,7 @@ var LeaferUI = function(exports) {
             const {parent: parent, __layout: __layout, __world: __world, __scrollWorld: __scrollWorld, __: __} = this;
             multiplyParent$2(this.__local || __layout, parent ? parent.__scrollWorld || parent.__world : defaultWorld, __world, !!__layout.affectScaleOrRotation, __);
             if (__scrollWorld) translateInner(Object.assign(__scrollWorld, __world), __.scrollX, __.scrollY);
+            if (__layout.scaleFixed) LeafHelper.updateScaleFixedWorld(this);
         },
         __updateLocalMatrix() {
             if (this.__local) {
@@ -5601,12 +5639,13 @@ var LeaferUI = function(exports) {
     };
     const {updateMatrix: updateMatrix$3, updateAllMatrix: updateAllMatrix$3} = LeafHelper;
     const {updateBounds: updateBounds$2} = BranchHelper;
-    const {toOuterOf: toOuterOf$2, copyAndSpread: copyAndSpread$3, copy: copy$6} = BoundsHelper;
+    const {toOuterOf: toOuterOf$2, copyAndSpread: copyAndSpread$4, copy: copy$6} = BoundsHelper;
     const {toBounds: toBounds$1} = PathBounds;
     const LeafBounds = {
         __updateWorldBounds() {
             const {__layout: __layout, __world: __world} = this;
             toOuterOf$2(__layout.renderBounds, __world, __world);
+            if (this.__hasComplex) LeafHelper.checkComplex(this);
             if (__layout.resized) {
                 if (__layout.resized === "inner") this.__onUpdateSize();
                 if (this.__hasLocalEvent) BoundsEvent.emitLocal(this);
@@ -5656,6 +5695,7 @@ var LeaferUI = function(exports) {
                 layout.renderChanged = undefined;
                 if (this.parent) this.parent.__layout.renderChange();
             }
+            if (layout.outerScale) LeafHelper.updateOuterBounds(this);
             layout.resized || (layout.resized = "local");
             layout.boundsChanged = undefined;
         },
@@ -5706,11 +5746,11 @@ var LeaferUI = function(exports) {
         },
         __updateStrokeBounds(_bounds) {
             const layout = this.__layout;
-            copyAndSpread$3(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread);
+            copyAndSpread$4(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread);
         },
         __updateRenderBounds(_bounds) {
             const layout = this.__layout, {renderSpread: renderSpread} = layout;
-            isNumber(renderSpread) && renderSpread <= 0 ? copy$6(layout.renderBounds, layout.strokeBounds) : copyAndSpread$3(layout.renderBounds, layout.boxBounds, renderSpread);
+            isNumber(renderSpread) && renderSpread <= 0 ? copy$6(layout.renderBounds, layout.strokeBounds) : copyAndSpread$4(layout.renderBounds, layout.boxBounds, renderSpread);
         }
     };
     const LeafRender = {
@@ -5721,7 +5761,7 @@ var LeaferUI = function(exports) {
                 const data = this.__;
                 if (data.bright && !options.topRendering) return options.topList.add(this);
                 canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
-                canvas.opacity = options.dimOpacity && !data.dimskip ? data.opacity * options.dimOpacity : data.opacity;
+                canvas.opacity = options.ignoreOpacity ? 1 : options.dimOpacity && !data.dimskip ? data.opacity * options.dimOpacity : data.opacity;
                 if (this.__.__single) {
                     if (data.eraser === "path") return this.__renderEraser(canvas, options);
                     const tempCanvas = canvas.getSameCanvas(true, true);
@@ -5773,7 +5813,7 @@ var LeaferUI = function(exports) {
                     if (data.eraser === "path") return this.__renderEraser(canvas, options);
                     const tempCanvas = canvas.getSameCanvas(false, true);
                     this.__renderBranch(tempCanvas, options);
-                    canvas.opacity = options.dimOpacity ? data.opacity * options.dimOpacity : data.opacity;
+                    canvas.opacity = options.ignoreOpacity ? 1 : options.dimOpacity ? data.opacity * options.dimOpacity : data.opacity;
                     canvas.copyWorldByReset(tempCanvas, nowWorld, nowWorld, data.__blendMode, true);
                     tempCanvas.recycle(nowWorld);
                 } else {
@@ -5789,7 +5829,7 @@ var LeaferUI = function(exports) {
                 const {children: children} = this;
                 for (let i = 0, len = children.length; i < len; i++) {
                     child = children[i];
-                    excludeRenderBounds$1(child, options) || (child.__.complex ? child.__renderComplex(canvas, options) : child.__render(canvas, options));
+                    excludeRenderBounds$1(child, options) || (child.__hasComplex ? LeafHelper.renderComplex(child, canvas, options) : child.__render(canvas, options));
                 }
             }
         },
@@ -5802,12 +5842,12 @@ var LeaferUI = function(exports) {
             }
         }
     };
-    const tempScaleData$1 = {};
     const {LEAF: LEAF, create: create} = IncrementId;
-    const {stintSet: stintSet$4} = DataHelper;
+    const {stintSet: stintSet$6} = DataHelper;
     const {toInnerPoint: toInnerPoint, toOuterPoint: toOuterPoint, multiplyParent: multiplyParent$1} = MatrixHelper;
     const {toOuterOf: toOuterOf$1} = BoundsHelper;
     const {copy: copy$5, move: move$8} = PointHelper;
+    const {getScaleFixedData: getScaleFixedData$1} = MathHelper;
     const {moveLocal: moveLocal, zoomOfLocal: zoomOfLocal, rotateOfLocal: rotateOfLocal, skewOfLocal: skewOfLocal, moveWorld: moveWorld, zoomOfWorld: zoomOfWorld, rotateOfWorld: rotateOfWorld, skewOfWorld: skewOfWorld, transform: transform, transformWorld: transformWorld, setTransform: setTransform, getFlipTransform: getFlipTransform, getLocalOrigin: getLocalOrigin, getRelativeWorld: getRelativeWorld, drop: drop} = LeafHelper;
     exports.Leaf = class Leaf {
         get tag() {
@@ -5965,6 +6005,7 @@ var LeaferUI = function(exports) {
                 this.__level = this.parent ? this.parent.__level + 1 : 1;
                 if (this.animation) this.__runAnimation("in");
                 if (this.__bubbleMap) this.__emitLifeEvent(ChildEvent.MOUNTED);
+                if (leafer.cacheId) LeafHelper.cacheId(this);
             } else {
                 this.__emitLifeEvent(ChildEvent.UNMOUNTED);
             }
@@ -6082,8 +6123,8 @@ var LeaferUI = function(exports) {
                 const cameraWorld = this.__cameraWorld, world = this.__world;
                 multiplyParent$1(world, options.matrix, cameraWorld, undefined, world);
                 toOuterOf$1(this.__layout.renderBounds, cameraWorld, cameraWorld);
-                stintSet$4(cameraWorld, "half", world.half);
-                stintSet$4(cameraWorld, "ignorePixelSnap", world.ignorePixelSnap);
+                stintSet$6(cameraWorld, "half", world.half);
+                stintSet$6(cameraWorld, "ignorePixelSnap", world.ignorePixelSnap);
                 return cameraWorld;
             } else {
                 return this.__world;
@@ -6094,13 +6135,8 @@ var LeaferUI = function(exports) {
             if (scaleX < 0) scaleX = -scaleX;
             return scaleX > 1 ? scaleX : 1;
         }
-        getRenderScaleData(abs, scaleFixed) {
-            let {scaleX: scaleX, scaleY: scaleY} = ImageManager.patternLocked ? this.__world : this.__nowWorld;
-            if (abs) scaleX < 0 && (scaleX = -scaleX), scaleY < 0 && (scaleY = -scaleY);
-            if (scaleFixed === true || scaleFixed === "zoom-in" && scaleX > 1 && scaleY > 1) scaleX = scaleY = 1;
-            tempScaleData$1.scaleX = scaleX;
-            tempScaleData$1.scaleY = scaleY;
-            return tempScaleData$1;
+        getRenderScaleData(abs, scaleFixed, unscale = true) {
+            return getScaleFixedData$1(ImageManager.patternLocked ? this.__world : this.__nowWorld || this.__world, scaleFixed, unscale, abs);
         }
         getTransform(relative) {
             return this.__layout.getTransform(relative || "local");
@@ -6139,14 +6175,16 @@ var LeaferUI = function(exports) {
                 relative.innerToWorld(world, to, distance);
                 world = to ? to : world;
             }
-            toInnerPoint(this.scrollWorldTransform, world, to, distance);
+            toInnerPoint(this.worldTransform, world, to, distance);
         }
         innerToWorld(inner, to, distance, relative) {
-            toOuterPoint(this.scrollWorldTransform, inner, to, distance);
+            toOuterPoint(this.worldTransform, inner, to, distance);
             if (relative) relative.worldToInner(to ? to : inner, null, distance);
         }
         getBoxPoint(world, relative, distance, change) {
-            return this.getBoxPointByInner(this.getInnerPoint(world, relative, distance, change), null, null, true);
+            const inner = this.getInnerPoint(world, relative, distance, change);
+            if (distance) return inner;
+            return this.getBoxPointByInner(inner, null, null, true);
         }
         getBoxPointByInner(inner, _relative, _distance, change) {
             const point = change ? inner : Object.assign({}, inner), {x: x, y: y} = this.boxBounds;
@@ -6262,7 +6300,6 @@ var LeaferUI = function(exports) {
         __drawHitPath(_canvas) {}
         __updateHitCanvas() {}
         __render(_canvas, _options) {}
-        __renderComplex(_canvas, _options) {}
         __drawFast(_canvas, _options) {}
         __draw(_canvas, _options, _originCanvas) {}
         __clip(_canvas, _options) {}
@@ -6273,7 +6310,7 @@ var LeaferUI = function(exports) {
         __drawPath(_canvas) {}
         __drawRenderPath(_canvas) {}
         __updatePath() {}
-        __updateRenderPath() {}
+        __updateRenderPath(_updateCache) {}
         getMotionPathData() {
             return Plugin.need("path");
         }
@@ -6341,9 +6378,11 @@ var LeaferUI = function(exports) {
             return 0;
         }
         __updateRenderSpread() {
+            let layout;
             const {children: children} = this;
             for (let i = 0, len = children.length; i < len; i++) {
-                if (children[i].__layout.renderSpread) return 1;
+                layout = children[i].__layout;
+                if (layout.renderSpread || layout.localOuterBounds) return 1;
             }
             return 0;
         }
@@ -6598,7 +6637,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "2.0.2";
+    const version = "2.0.4";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -7405,7 +7444,7 @@ var LeaferUI = function(exports) {
             this.config = {};
             if (userConfig) this.config = DataHelper.default(userConfig, this.config);
             this.picker = new Picker(this.target = target, this);
-            this.finder = Creator.finder && Creator.finder();
+            this.finder = Creator.finder && Creator.finder(target, this.config);
         }
         getByPoint(hitPoint, hitRadius, options) {
             const {target: target, picker: picker} = this;
@@ -7443,7 +7482,9 @@ var LeaferUI = function(exports) {
             set(value) {
                 this.__setAttr(key, value);
                 if (value) this.__.__useEffect = true;
-                this.__layout.renderChanged || this.__layout.renderChange();
+                const layout = this.__layout;
+                layout.renderChanged || layout.renderChange();
+                layout.surfaceChange();
             }
         }));
     }
@@ -7528,7 +7569,7 @@ var LeaferUI = function(exports) {
         }
     };
     const {parse: parse, objectToCanvasData: objectToCanvasData} = PathConvert;
-    const {stintSet: stintSet$3} = DataHelper, {hasTransparent: hasTransparent$2} = ColorConvert;
+    const {stintSet: stintSet$5} = DataHelper, {hasTransparent: hasTransparent$2} = ColorConvert;
     const emptyPaint = {
         originPaint: {}
     };
@@ -7594,7 +7635,7 @@ var LeaferUI = function(exports) {
         setFill(value) {
             if (this.__naturalWidth) this.__removeNaturalSize();
             if (isString(value) || !value) {
-                stintSet$3(this, "__isTransparentFill", hasTransparent$2(value));
+                stintSet$5(this, "__isTransparentFill", hasTransparent$2(value));
                 this.__isFills && this.__removePaint("fill", true);
                 this._fill = value;
             } else if (isObject(value)) {
@@ -7603,7 +7644,7 @@ var LeaferUI = function(exports) {
         }
         setStroke(value) {
             if (isString(value) || !value) {
-                stintSet$3(this, "__isTransparentStroke", hasTransparent$2(value));
+                stintSet$5(this, "__isTransparentStroke", hasTransparent$2(value));
                 this.__isStrokes && this.__removePaint("stroke", true);
                 this._stroke = value;
             } else if (isObject(value)) {
@@ -7636,15 +7677,16 @@ var LeaferUI = function(exports) {
             this.__needComputePaint = undefined;
         }
         __getRealStrokeWidth(childStyle) {
-            let {strokeWidth: strokeWidth, strokeWidthFixed: strokeWidthFixed} = this;
+            let {strokeWidth: strokeWidth, strokeScaleFixed: strokeScaleFixed} = this;
             if (childStyle) {
                 if (childStyle.strokeWidth) strokeWidth = childStyle.strokeWidth;
-                if (!isUndefined(childStyle.strokeWidthFixed)) strokeWidthFixed = childStyle.strokeWidthFixed;
+                if (!isUndefined(childStyle.strokeScaleFixed)) strokeScaleFixed = childStyle.strokeScaleFixed;
             }
-            if (strokeWidthFixed) {
-                const scale = this.__leaf.getClampRenderScale();
-                return scale > 1 ? strokeWidth / scale : strokeWidth;
-            } else return strokeWidth;
+            if (strokeScaleFixed) {
+                const {scaleX: scaleX} = this.__leaf.getRenderScaleData(true, strokeScaleFixed, false);
+                if (scaleX !== 1) return strokeWidth * scaleX;
+            }
+            return strokeWidth;
         }
         __setPaint(attrName, value) {
             this.__setInput(attrName, value);
@@ -7661,11 +7703,11 @@ var LeaferUI = function(exports) {
             if (removeInput) this.__removeInput(attrName);
             PaintImage.recycleImage(attrName, this);
             if (attrName === "fill") {
-                stintSet$3(this, "__isAlphaPixelFill", undefined);
+                stintSet$5(this, "__isAlphaPixelFill", undefined);
                 this._fill = this.__isFills = undefined;
             } else {
-                stintSet$3(this, "__isAlphaPixelStroke", undefined);
-                stintSet$3(this, "__hasMultiStrokeStyle", undefined);
+                stintSet$5(this, "__isAlphaPixelStroke", undefined);
+                stintSet$5(this, "__hasMultiStrokeStyle", undefined);
                 this._stroke = this.__isStrokes = undefined;
             }
         }
@@ -7716,7 +7758,11 @@ var LeaferUI = function(exports) {
         }
     }
     class PolygonData extends LineData {}
-    class StarData extends UIData {}
+    class StarData extends UIData {
+        get __boxStroke() {
+            return !this.__pathInputed;
+        }
+    }
     class PathData extends UIData {
         get __pathInputed() {
             return 2;
@@ -7812,7 +7858,7 @@ var LeaferUI = function(exports) {
             const data = this.__, {strokeAlign: strokeAlign, __maxStrokeWidth: strokeWidth} = data, box = this.__box;
             if ((data.stroke || data.hitStroke === "all") && strokeWidth && strokeAlign !== "inside") {
                 boxSpread = spread = strokeAlign === "center" ? strokeWidth / 2 : strokeWidth;
-                if (!data.__boxStroke) {
+                if (!data.__boxStroke || data.__useArrow) {
                     const miterLimitAddWidth = data.__isLinePath ? 0 : 10 * spread;
                     const storkeCapAddWidth = data.strokeCap === "none" ? 0 : strokeWidth;
                     spread += Math.max(miterLimitAddWidth, storkeCapAddWidth);
@@ -7841,22 +7887,22 @@ var LeaferUI = function(exports) {
             return box ? max$4(box.__updateRenderSpread(), spread) : spread;
         }
     };
-    const {stintSet: stintSet$2} = DataHelper;
+    const {stintSet: stintSet$4} = DataHelper;
     const UIRender = {
         __updateChange() {
             const data = this.__;
             if (data.__useStroke) {
                 const useStroke = data.__useStroke = !!(data.stroke && data.strokeWidth);
-                stintSet$2(this.__world, "half", useStroke && data.strokeAlign === "center" && data.strokeWidth % 2);
-                stintSet$2(data, "__fillAfterStroke", useStroke && data.strokeAlign === "outside" && data.fill && !data.__isTransparentFill);
+                stintSet$4(this.__world, "half", useStroke && data.strokeAlign === "center" && data.strokeWidth % 2);
+                stintSet$4(data, "__fillAfterStroke", useStroke && data.strokeAlign === "outside" && data.fill && !data.__isTransparentFill);
             }
             if (data.__useEffect) {
                 const {shadow: shadow, fill: fill, stroke: stroke} = data, otherEffect = data.innerShadow || data.blur || data.backgroundBlur || data.filter;
-                stintSet$2(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !Effect.isTransformShadow(shadow[0]) && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
+                stintSet$4(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !Effect.isTransformShadow(shadow[0]) && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
                 data.__useEffect = !!(shadow || otherEffect);
             }
             data.__checkSingle();
-            stintSet$2(data, "__complex", data.__isFills || data.__isStrokes || data.cornerRadius || data.__useEffect);
+            stintSet$4(data, "__complex", data.__isFills || data.__isStrokes || data.cornerRadius || data.__useEffect);
         },
         __drawFast(canvas, options) {
             drawFast(this, canvas, options);
@@ -7963,6 +8009,12 @@ var LeaferUI = function(exports) {
         get isFrame() {
             return false;
         }
+        set strokeWidthFixed(value) {
+            this.strokeScaleFixed = value;
+        }
+        get strokeWidthFixed() {
+            return this.strokeScaleFixed;
+        }
         set scale(value) {
             MathHelper.assignScale(this, value);
         }
@@ -8018,6 +8070,9 @@ var LeaferUI = function(exports) {
         getPathString(curve, pathForRender, floatLength) {
             return PathConvert.stringify(this.getPath(curve, pathForRender), floatLength);
         }
+        asPath(curve, pathForRender) {
+            this.path = this.getPath(curve, pathForRender);
+        }
         load() {
             this.__.__computePaint();
         }
@@ -8027,16 +8082,18 @@ var LeaferUI = function(exports) {
                 data.lazy && !this.__inLazyBounds && !Export.running ? data.__needComputePaint = true : data.__computePaint();
             }
         }
-        __updateRenderPath() {
+        __updateRenderPath(updateCache) {
             const data = this.__;
             if (data.path) {
                 data.__pathForRender = data.cornerRadius ? PathCorner.smooth(data.path, data.cornerRadius, data.cornerSmoothing) : data.path;
-                if (data.__useArrow) PathArrow.addArrows(this);
+                if (data.__useArrow) PathArrow.addArrows(this, updateCache);
             } else data.__pathForRender && (data.__pathForRender = undefined);
         }
         __drawRenderPath(canvas) {
+            const data = this.__;
             canvas.beginPath();
-            this.__drawPathByData(canvas, this.__.__pathForRender);
+            if (data.__useArrow) PathArrow.updateArrow(this);
+            this.__drawPathByData(canvas, data.__pathForRender);
         }
         __drawPath(canvas) {
             canvas.beginPath();
@@ -8085,6 +8142,7 @@ var LeaferUI = function(exports) {
         static setEditOuter(_toolName) {}
         static setEditInner(_editorName) {}
         destroy() {
+            this.__.__willDestroy = true;
             this.fill = this.stroke = null;
             if (this.__animate) this.killAnimate();
             super.destroy();
@@ -8145,7 +8203,7 @@ var LeaferUI = function(exports) {
     __decorate([ strokeType(undefined, true) ], exports.UI.prototype, "stroke", void 0);
     __decorate([ strokeType("inside") ], exports.UI.prototype, "strokeAlign", void 0);
     __decorate([ strokeType(1, true) ], exports.UI.prototype, "strokeWidth", void 0);
-    __decorate([ strokeType(false) ], exports.UI.prototype, "strokeWidthFixed", void 0);
+    __decorate([ strokeType(false) ], exports.UI.prototype, "strokeScaleFixed", void 0);
     __decorate([ strokeType("none") ], exports.UI.prototype, "strokeCap", void 0);
     __decorate([ strokeType("miter") ], exports.UI.prototype, "strokeJoin", void 0);
     __decorate([ strokeType() ], exports.UI.prototype, "dashPattern", void 0);
@@ -8609,6 +8667,9 @@ var LeaferUI = function(exports) {
         get isBranchLeaf() {
             return true;
         }
+        get __useSelfBox() {
+            return this.pathInputed;
+        }
         constructor(data) {
             super(data);
             this.__layout.renderChanged || this.__layout.renderChange();
@@ -8624,7 +8685,7 @@ var LeaferUI = function(exports) {
         }
         __updateRectBoxBounds() {}
         __updateBoxBounds(_secondLayout) {
-            if (this.children.length && !this.pathInputed) {
+            if (this.children.length && !this.__useSelfBox) {
                 const data = this.__;
                 if (data.__autoSide) {
                     if (data.__hasSurface) this.__extraUpdate();
@@ -8713,37 +8774,37 @@ var LeaferUI = function(exports) {
     __decorate([ surfaceType("#FFFFFF") ], exports.Frame.prototype, "fill", void 0);
     __decorate([ affectRenderBoundsType("hide") ], exports.Frame.prototype, "overflow", void 0);
     exports.Frame = __decorate([ registerUI() ], exports.Frame);
-    const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse} = PathCommandDataHelper;
+    const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse$2} = PathCommandDataHelper;
     exports.Ellipse = class Ellipse extends exports.UI {
         get __tag() {
             return "Ellipse";
         }
         __updatePath() {
-            const {width: width, height: height, innerRadius: innerRadius, startAngle: startAngle, endAngle: endAngle} = this.__;
+            const data = this.__, {width: width, height: height, innerRadius: innerRadius, startAngle: startAngle, endAngle: endAngle} = data;
             const rx = width / 2, ry = height / 2;
-            const path = this.__.path = [];
+            const path = data.path = [];
             let open;
             if (innerRadius) {
                 if (startAngle || endAngle) {
-                    if (innerRadius < 1) ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false); else open = true;
-                    ellipse(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
+                    if (innerRadius < 1) ellipse$2(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false); else open = true;
+                    ellipse$2(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
                 } else {
                     if (innerRadius < 1) {
-                        ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius);
+                        ellipse$2(path, rx, ry, rx * innerRadius, ry * innerRadius);
                         moveTo$3(path, width, ry);
                     }
-                    ellipse(path, rx, ry, rx, ry, 0, 360, 0, true);
+                    ellipse$2(path, rx, ry, rx, ry, 0, 360, 0, true);
                 }
             } else {
                 if (startAngle || endAngle) {
                     moveTo$3(path, rx, ry);
-                    ellipse(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
+                    ellipse$2(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
                 } else {
-                    ellipse(path, rx, ry, rx, ry);
+                    ellipse$2(path, rx, ry, rx, ry);
                 }
             }
             if (!open) closePath$2(path);
-            if (Platform.ellipseToCurve) this.__.path = this.getPath(true);
+            if (Platform.ellipseToCurve || data.__useArrow) data.path = this.getPath(true);
         }
     };
     __decorate([ dataProcessor(EllipseData) ], exports.Ellipse.prototype, "__", void 0);
@@ -8922,7 +8983,7 @@ var LeaferUI = function(exports) {
     __decorate([ dataType(false) ], exports.Canvas.prototype, "safeResize", void 0);
     __decorate([ resizeType() ], exports.Canvas.prototype, "contextSettings", void 0);
     exports.Canvas = __decorate([ registerUI() ], exports.Canvas);
-    const {copyAndSpread: copyAndSpread$2, includes: includes, spread: spread, setList: setList} = BoundsHelper, {stintSet: stintSet$1} = DataHelper;
+    const {copyAndSpread: copyAndSpread$3, includes: includes, spread: spread, setList: setList} = BoundsHelper, {stintSet: stintSet$3} = DataHelper;
     exports.Text = class Text extends exports.UI {
         get __tag() {
             return "Text";
@@ -8938,9 +8999,9 @@ var LeaferUI = function(exports) {
             data.__letterSpacing = UnitConvert.number(letterSpacing, fontSize);
             data.__baseLine = data.__lineHeight - (data.__lineHeight - fontSize * .7) / 2;
             data.__font = `${italic ? "italic " : ""}${textCase === "small-caps" ? "small-caps " : ""}${fontWeight !== "normal" ? fontWeight + " " : ""}${fontSize || 12}px ${fontFamily || "caption"}`;
-            stintSet$1(data, "__padding", padding && MathHelper.fourNumber(padding));
-            stintSet$1(data, "__clipText", textOverflow !== "show" && !data.__autoSize);
-            stintSet$1(data, "__isCharMode", width || height || data.__letterSpacing || textCase !== "none");
+            stintSet$3(data, "__padding", padding && MathHelper.fourNumber(padding));
+            stintSet$3(data, "__clipText", textOverflow !== "show" && !data.__autoSize);
+            stintSet$3(data, "__isCharMode", width || height || data.__letterSpacing || textCase !== "none");
             data.__textDrawData = TextConvert.getDrawData((data.__isPlacehold = data.placeholder && data.text === "") ? data.placeholder : data.text, this.__);
         }
         __updateBoxBounds() {
@@ -8975,7 +9036,7 @@ var LeaferUI = function(exports) {
         }
         __updateRenderBounds() {
             const {renderBounds: renderBounds, renderSpread: renderSpread} = this.__layout;
-            copyAndSpread$2(renderBounds, this.__.__textBoxBounds, renderSpread);
+            copyAndSpread$3(renderBounds, this.__.__textBoxBounds, renderSpread);
             if (this.__box) this.__box.__layout.renderBounds = renderBounds;
         }
         __updateChange() {
@@ -9199,7 +9260,7 @@ var LeaferUI = function(exports) {
             if (this.viewReady) this.renderer.update();
         }
         __render(canvas, options) {
-            if (canvas.context) this.forEach(leafer => options.matrix ? leafer.__render(canvas, options) : canvas.copyWorld(leafer.canvas, options.bounds));
+            if (canvas.context) this.forEach(leafer => options.matrix ? leafer.__render(canvas, options) : canvas.copyWorld(leafer.canvas, options.bounds, undefined, undefined, true));
         }
         __onResize(event) {
             this.forEach(leafer => leafer.resize(event));
@@ -10153,6 +10214,14 @@ var LeaferUI = function(exports) {
         stopDragAnimate() {
             this.dragger.stopAnimate();
         }
+        replaceDownTarget(target) {
+            const {downData: downData} = this;
+            if (downData && target) {
+                const {path: path} = downData;
+                path.remove(path.list[0]);
+                path.addAt(target, 0);
+            }
+        }
         updateDownData(data, options, merge) {
             const {downData: downData} = this;
             if (!data && downData) data = downData;
@@ -10515,8 +10584,8 @@ var LeaferUI = function(exports) {
                 canvas.save();
                 if (item.transform) canvas.transform(item.transform);
                 if (originPaint.scaleFixed) {
-                    const {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true);
-                    if (originPaint.scaleFixed === true || originPaint.scaleFixed === "zoom-in" && scaleX > 1 && scaleY > 1) canvas.scale(1 / scaleX, 1 / scaleY);
+                    const {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true, originPaint.scaleFixed, false);
+                    if (scaleX !== 1) canvas.scale(scaleX, scaleY);
                 }
                 if (originPaint.blendMode) canvas.blendMode = originPaint.blendMode;
                 fillPathOrText(ui, canvas, renderOptions);
@@ -10674,13 +10743,13 @@ var LeaferUI = function(exports) {
             }
         }
     }
-    const {getSpread: getSpread, copyAndSpread: copyAndSpread$1, toOuterOf: toOuterOf, getOuterOf: getOuterOf, getByMove: getByMove, move: move$7, getIntersectData: getIntersectData} = BoundsHelper;
+    const {getSpread: getSpread, copyAndSpread: copyAndSpread$2, toOuterOf: toOuterOf, getOuterOf: getOuterOf, getByMove: getByMove, move: move$7, getIntersectData: getIntersectData} = BoundsHelper;
     const tempBounds$2 = {};
     function shape(ui, current, options) {
         const canvas = current.getSameCanvas();
         const currentBounds = current.bounds, nowWorld = ui.__nowWorld, layout = ui.__layout;
         const nowWorldShapeBounds = ui.__nowWorldShapeBounds || (ui.__nowWorldShapeBounds = {});
-        toOuterOf(layout.strokeSpread ? (copyAndSpread$1(tempBounds$2, layout.boxBounds, layout.strokeSpread), 
+        toOuterOf(layout.strokeSpread ? (copyAndSpread$2(tempBounds$2, layout.boxBounds, layout.strokeSpread), 
         tempBounds$2) : layout.boxBounds, nowWorld, nowWorldShapeBounds);
         let bounds, renderBounds, matrix, fitMatrix, shapeBounds, worldCanvas;
         let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true);
@@ -10734,7 +10803,7 @@ var LeaferUI = function(exports) {
         };
     }
     let recycleMap;
-    const {stintSet: stintSet} = DataHelper, {hasTransparent: hasTransparent$1} = ColorConvert;
+    const {stintSet: stintSet$2} = DataHelper, {hasTransparent: hasTransparent$1} = ColorConvert;
     function compute(attrName, ui) {
         const data = ui.__, leafPaints = [];
         let paints = data.__input[attrName], isAlphaPixel, isTransparent;
@@ -10757,12 +10826,12 @@ var LeaferUI = function(exports) {
                 isTransparent = true;
             }
             if (attrName === "fill") {
-                stintSet(data, "__isAlphaPixelFill", isAlphaPixel);
-                stintSet(data, "__isTransparentFill", isTransparent);
+                stintSet$2(data, "__isAlphaPixelFill", isAlphaPixel);
+                stintSet$2(data, "__isTransparentFill", isTransparent);
             } else {
-                stintSet(data, "__isAlphaPixelStroke", isAlphaPixel);
-                stintSet(data, "__isTransparentStroke", isTransparent);
-                stintSet(data, "__hasMultiStrokeStyle", maxChildStrokeWidth);
+                stintSet$2(data, "__isAlphaPixelStroke", isAlphaPixel);
+                stintSet$2(data, "__isTransparentStroke", isTransparent);
+                stintSet$2(data, "__hasMultiStrokeStyle", maxChildStrokeWidth);
             }
         } else {
             data.__removePaint(attrName, false);
@@ -10831,11 +10900,11 @@ var LeaferUI = function(exports) {
         shape: shape
     };
     let cache$1, box$2 = new Bounds;
-    const {isSame: isSame} = BoundsHelper;
+    const {isSame: isSame$1} = BoundsHelper;
     function image(ui, attrName, paint, boxBounds, firstUse) {
         let leafPaint, event;
         const image = ImageManager.get(paint, paint.type);
-        if (cache$1 && paint === cache$1.paint && isSame(boxBounds, cache$1.boxBounds)) {
+        if (cache$1 && paint === cache$1.paint && isSame$1(boxBounds, cache$1.boxBounds)) {
             leafPaint = cache$1.leafPaint;
         } else {
             leafPaint = {
@@ -10913,6 +10982,7 @@ var LeaferUI = function(exports) {
             const clip = transform && !transform.onlyScale || data.path || data.cornerRadius;
             if (clip || opacity && opacity < 1 || blendMode) leafPaint.complex = clip ? 2 : true;
         }
+        if (paint.filter) PaintImage.applyFilter(leafPaint, image, paint.filter, ui);
         return true;
     }
     function onLoad(ui, event) {
@@ -11099,7 +11169,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$1, copy: copy$4} = MatrixHelper;
+    const {get: get$1, scale: scale$2, copy: copy$4} = MatrixHelper;
     const {getFloorScale: getFloorScale} = MathHelper, {abs: abs$6} = Math;
     function createPatternTask(paint, ui, canvas, renderOptions) {
         if (!paint.patternTask) {
@@ -11116,7 +11186,7 @@ var LeaferUI = function(exports) {
         let {scaleX: scaleX, scaleY: scaleY} = PaintImage.getImageRenderScaleData(paint, ui, canvas, renderOptions), id = paint.film ? paint.nowIndex : scaleX + "-" + scaleY;
         if (paint.patternId !== id && !ui.destroyed) {
             if (!(Platform.image.isLarge(paint.image, scaleX, scaleY) && !paint.data.repeat)) {
-                const {image: image, data: data} = paint, {opacity: opacity, filters: filters} = paint.originPaint, {transform: transform, gap: gap} = data, fixScale = PaintImage.getPatternFixScale(paint, scaleX, scaleY);
+                const {image: image, data: data} = paint, {opacity: opacity} = paint.originPaint, {transform: transform, gap: gap} = data, fixScale = PaintImage.getPatternFixScale(paint, scaleX, scaleY);
                 let imageMatrix, xGap, yGap, {width: width, height: height} = image;
                 if (fixScale) scaleX *= fixScale, scaleY *= fixScale;
                 width *= scaleX;
@@ -11130,9 +11200,9 @@ var LeaferUI = function(exports) {
                     scaleY *= getFloorScale(height + (yGap || 0));
                     imageMatrix = get$1();
                     if (transform) copy$4(imageMatrix, transform);
-                    scale$1(imageMatrix, 1 / scaleX, 1 / scaleY);
+                    scale$2(imageMatrix, 1 / scaleX, 1 / scaleY);
                 }
-                const imageCanvas = image.getCanvas(width, height, opacity, filters, xGap, yGap, ui.leafer && ui.leafer.config.smooth, data.interlace);
+                const imageCanvas = image.getCanvas(width, height, opacity, undefined, xGap, yGap, ui.leafer && ui.leafer.config.smooth, data.interlace);
                 const pattern = image.getPattern(imageCanvas, data.repeat || (Platform.origin.noRepeat || "no-repeat"), imageMatrix, paint);
                 paint.style = pattern;
                 paint.patternId = id;
@@ -11159,7 +11229,7 @@ var LeaferUI = function(exports) {
             if (drawImage) {
                 if (data.repeat) {
                     drawImage = false;
-                } else if (!(originPaint.changeful || paint.film || Platform.name === "miniapp" && ResizeEvent.isResizing(ui) || exporting)) {
+                } else if (!(originPaint.changeful || paint.film || Platform.name === "miniapp" || exporting)) {
                     drawImage = Platform.image.isLarge(image, scaleX, scaleY) || image.width * scaleX > 8096 || image.height * scaleY > 8096;
                 }
             }
@@ -11218,6 +11288,7 @@ var LeaferUI = function(exports) {
                     if (!recycleMap) recycleMap = {};
                     recycleMap[url] = true;
                     ImageManager.recyclePaint(paint);
+                    if (data.__willDestroy && image.parent) PaintImage.recycleFilter(image, data.__leaf);
                     if (image.loading) {
                         if (!input) {
                             input = data.__input && data.__input[attrName] || [];
@@ -11638,7 +11709,7 @@ var LeaferUI = function(exports) {
             }, row = {
                 words: []
             };
-            if (__letterSpacing) content = [ ...content ];
+            content = [ ...content ];
             for (let i = 0, len = content.length; i < len; i++) {
                 char = content[i];
                 if (char === "\n") {
@@ -12073,8 +12144,11 @@ var LeaferUI = function(exports) {
                                     });
                                     if (isObject(check)) value = check; else if (check === false) return;
                                 }
-                                t.setDimOthers(false);
-                                t.setBright(false);
+                                if (t.hasDimOthers) {
+                                    t.setDimOthers(false);
+                                    t.setBright(false);
+                                    t.hasDimOthers = undefined;
+                                }
                                 if (isArray(value) && value.length > 1 && value[0].locked) value.splice(0, 1);
                                 if (t.single) {
                                     delete t.element.syncEventer;
@@ -12098,7 +12172,8 @@ var LeaferUI = function(exports) {
         return (target, key) => {
             defineKey(target, key, {
                 get() {
-                    const {config: config, element: element, dragPoint: dragPoint, editBox: editBox, app: app} = this, mergeConfig = Object.assign({}, config);
+                    const {config: config, element: element, dragPoint: dragPoint, editBox: editBox, editTool: editTool, innerEditor: innerEditor, app: app} = this, mergeConfig = Object.assign({}, config);
+                    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) {
@@ -12976,8 +13051,11 @@ var LeaferUI = function(exports) {
             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;
             editMask.visible = mask ? true : 0;
-            editor.setDimOthers(dimOthers);
-            editor.setBright(!!dimOthers || bright);
+            if (!isUndefined(dimOthers) || !isUndefined(bright)) {
+                editor.setDimOthers(dimOthers);
+                editor.setBright(!!dimOthers || bright);
+                editor.hasDimOthers = true;
+            }
             if (spread) BoundsHelper.spread(bounds, spread);
             if (this.view.worldOpacity) {
                 const {width: width, height: height} = bounds;
@@ -12996,7 +13074,8 @@ var LeaferUI = function(exports) {
                         resizeL = resizeLines[(i - 1) / 2];
                         resizeL.set(point);
                         resizeL.visible = resizeP.visible && !hideResizeLines;
-                        resizeP.visible = rotateP.visible = showPoints && !!middlePoint;
+                        if (resizeP.visible) resizeP.visible = !!middlePoint;
+                        if (rotateP.visible) rotateP.visible = !!middlePoint;
                         if ((i + 1) / 2 % 2) {
                             resizeL.width = width + resizeL.height;
                             if (hideOnSmall && resizeP.width * 2 > width) resizeP.visible = false;
@@ -13082,8 +13161,9 @@ var LeaferUI = function(exports) {
         onDragStart(e) {
             this.dragging = true;
             const point = this.dragPoint = e.current, {pointType: pointType} = point;
-            const {moveable: moveable, resizeable: resizeable, rotateable: rotateable, skewable: skewable} = this.mergeConfig;
+            const {moveable: moveable, resizeable: resizeable, rotateable: rotateable, skewable: skewable, onCopy: onCopy} = this.mergeConfig;
             if (pointType === "move") {
+                if (e.altKey && onCopy && onCopy() && this.editor.single) this.app.interaction.replaceDownTarget(this.target);
                 moveable && (this.moving = true);
             } else {
                 if (pointType.includes("rotate") || this.isHoldRotateKey(e) || !resizeable) {
@@ -13202,26 +13282,31 @@ var LeaferUI = function(exports) {
             updatePointCursor(this, e);
         }
         onArrow(e) {
-            if (this.canUse && this.mergeConfig.keyEvent) {
+            if (this.canUse) {
                 let x = 0, y = 0;
-                const distance = e.shiftKey ? 10 : 1;
                 switch (e.code) {
                   case "ArrowDown":
-                    y = distance;
+                    y = 1;
                     break;
 
                   case "ArrowUp":
-                    y = -distance;
+                    y = -1;
                     break;
 
                   case "ArrowLeft":
-                    x = -distance;
+                    x = -1;
                     break;
 
                   case "ArrowRight":
-                    x = distance;
+                    x = 1;
+                }
+                if (x || y) {
+                    const {keyEvent: keyEvent, arrowStep: arrowStep, arrowFastStep: arrowFastStep} = this.mergeConfig;
+                    if (keyEvent) {
+                        const step = e.shiftKey ? arrowFastStep : arrowStep;
+                        this.transformTool.move(x * step, y * step);
+                    }
                 }
-                if (x || y) this.transformTool.move(x, y);
             }
         }
         onDoubleTap(e) {
@@ -13326,6 +13411,8 @@ var LeaferUI = function(exports) {
         pointSize: 10,
         pointRadius: 16,
         rotateGap: 45,
+        arrowStep: 1,
+        arrowFastStep: 10,
         buttonsDirection: "bottom",
         buttonsMargin: 12,
         hideOnSmall: true,
@@ -15781,7 +15868,7 @@ var LeaferUI = function(exports) {
     __decorate([ arrowType("angle") ], exports.Arrow.prototype, "endArrow", void 0);
     exports.Arrow = __decorate([ registerUI() ], exports.Arrow);
     const {M: M$2, L: L$2, C: C$2, Q: Q$1, O: O$1} = PathCommandMap;
-    const {rotate: rotate$1, copyFrom: copyFrom$1, scale: scale} = PointHelper;
+    const {rotate: rotate$1, copyFrom: copyFrom$1, scale: scale$1} = PointHelper;
     const point$1 = {};
     const PathMatrixHelper = {
         layout(data, x, y, scaleX, scaleY, rotation, origin) {
@@ -15825,17 +15912,19 @@ var LeaferUI = function(exports) {
     function setPoint$2(data, startIndex, x, y, scaleX, scaleY, rotation, origin) {
         copyFrom$1(point$1, data[startIndex], data[startIndex + 1]);
         if (rotation) rotate$1(point$1, rotation, origin);
-        if (scaleX) scale(point$1, scaleX, scaleY);
+        if (scaleX) scale$1(point$1, scaleX, scaleY);
         data[startIndex] = x + point$1.x;
         data[startIndex + 1] = y + point$1.y;
     }
     const {layout: layout$2, rotate: rotate} = PathMatrixHelper;
     const {getAngle: getAngle} = PointHelper;
-    const half = {
+    const zero = {
+        x: 0
+    }, half = {
         x: -.5
     };
     const angle = {
-        connect: half,
+        connect: zero,
         offset: {
             x: -.71,
             bevelJoin: .36,
@@ -15853,61 +15942,83 @@ var LeaferUI = function(exports) {
         path: [ 1, -3, -3, 2, 0, 0, 2, -1, 0 ]
     };
     const triangleLinePath = [ 1, -3, 0, 2, -3, -2, 2, 0, 0, 2, -3, 2, 2, -3, 0 ];
-    const triangle = {
-        connect: half,
+    const triangleFill = {
+        connect: zero,
         offset: {
             x: -.9,
             bevelJoin: .624,
             roundJoin: .4
         },
-        path: [ ...triangleLinePath, 1, -2.05, 1.1, 2, -2.05, -1.1 ],
-        dashPath: [ 1, -2, 0, 2, -.5, 0 ]
+        path: [ ...triangleLinePath ]
     };
-    const arrowLinePath = [ 1, -3, 0, 2, -3.5, -1.8, 2, 0, 0, 2, -3.5, 1.8, 2, -3, 0 ];
-    const arrow = {
-        connect: half,
-        offset: {
-            x: -1.1,
-            bevelJoin: .872,
-            roundJoin: .6
-        },
-        path: [ ...arrowLinePath, 1, -2.25, .95, 2, -2.25, -.95 ],
-        dashPath: [ 1, -3, 0, 2, -.5, 0 ]
+    const triangle = DataHelper.clone(triangleFill);
+    triangle.path = [ ...triangleLinePath, 1, -2.05, 1.1, 2, -2.05, -1.1 ];
+    triangle.dashPath = [ 1, -2, 0, 2, -.5, 0 ];
+    const triangleFlipFill = {
+        connect: zero,
+        offset: half,
+        path: [ ...triangleFill.path ]
     };
     const triangleFlip = {
+        connect: zero,
         offset: half,
         path: [ ...triangle.path ],
         dashPath: [ 1, -2.5, 0, 2, -1, 0 ]
     };
+    rotate(triangleFlipFill.path, 180, {
+        x: -1.5,
+        y: 0
+    });
     rotate(triangleFlip.path, 180, {
         x: -1.5,
         y: 0
     });
+    const arrowLinePath = [ 1, -3, 0, 2, -3.5, -1.8, 2, 0, 0, 2, -3.5, 1.8, 2, -3, 0 ];
+    const arrowFill = {
+        connect: zero,
+        offset: {
+            x: -1.1,
+            bevelJoin: .872,
+            roundJoin: .6
+        },
+        path: [ ...arrowLinePath ]
+    };
+    const arrow = DataHelper.clone(arrowFill);
+    arrow.path = [ ...arrowLinePath, 1, -2.25, .95, 2, -2.25, -.95 ];
+    arrow.dashPath = [ 1, -3, 0, 2, -.5, 0 ];
     const circleLine = {
         connect: {
-            x: -1.3
+            x: -1.8
         },
         path: [ 1, 1.8, -.1, 2, 1.8, 0, 26, 0, 0, 1.8, 0, 359, 0 ]
     };
-    const circle = {
+    const circleFill = {
         connect: {
             x: .5
         },
-        path: [ ...circleLine.path, 1, 0, 0, 26, 0, 0, 1, 0, 360, 0 ],
-        dashPath: [ 1, -.5, 0, 2, .5, 0 ]
+        path: [ ...circleLine.path ]
     };
+    const circle = DataHelper.clone(circleFill);
+    circle.path = [ ...circleLine.path, 1, 0, 0, 26, 0, 0, 1, 0, 360, 0 ];
+    circle.dashPath = [ 1, -.5, 0, 2, .5, 0 ];
     const squareLine = {
         connect: {
-            x: -1.3
+            x: -1.4
         },
         path: [ 1, -1.4, 0, 2, -1.4, -1.4, 2, 1.4, -1.4, 2, 1.4, 1.4, 2, -1.4, 1.4, 2, -1.4, 0 ]
     };
+    const squareFill = {
+        path: [ ...squareLine.path ]
+    };
     const square = {
         path: [ ...squareLine.path, 2, -1.4, -.49, 2, 1, -.49, 1, -1.4, .49, 2, 1, .49 ]
     };
     const diamondLine = DataHelper.clone(squareLine);
+    diamondLine.connect.x = -1.9;
+    const diamondFill = DataHelper.clone(squareFill);
     const diamond = DataHelper.clone(square);
     rotate(diamondLine.path, 45);
+    rotate(diamondFill.path, 45);
     rotate(diamond.path, 45);
     const mark = {
         offset: half,
@@ -15927,19 +16038,33 @@ var LeaferUI = function(exports) {
         "diamond-line": diamondLine,
         mark: mark
     };
+    const fillArrows = {
+        triangle: triangleFill,
+        "triangle-flip": triangleFlipFill,
+        arrow: arrowFill,
+        circle: circleFill,
+        square: squareFill,
+        diamond: diamondFill
+    };
     function getArrowPath(ui, arrow, from, to, size, connectOffset, hasDashPattern) {
-        let pathData, scale;
+        let pathData, scale = 1, rotation = 0, fill;
         const {strokeCap: strokeCap, strokeJoin: strokeJoin} = ui.__;
         if (isObject(arrow)) {
             if (arrow.type) {
-                scale = arrow.scale;
+                scale = arrow.scale || 1;
+                rotation = arrow.rotation || 0;
                 pathData = arrows[arrow.type];
+                if (scale > 1) {
+                    const fillData = fillArrows[arrow.type];
+                    if (fillData) pathData = fillData, fill = true;
+                }
             } else pathData = arrow;
         } else {
             pathData = arrows[arrow];
         }
+        if (!fill) fill = pathData.fill;
         const {offset: offset, connect: connect, path: path, dashPath: dashPath} = pathData;
-        let connectX = connect ? connect.x : 0;
+        let connectX = connect ? connect.x * scale : 0;
         let offsetX = offset ? offset.x : 0;
         const data = [ ...path ];
         if (hasDashPattern && dashPath) data.push(...dashPath);
@@ -15947,22 +16072,31 @@ var LeaferUI = function(exports) {
         if (offset) {
             if (strokeJoin === "round" && offset.roundJoin) offsetX += offset.roundJoin; else if (strokeJoin === "bevel" && offset.bevelJoin) offsetX += offset.bevelJoin;
         }
-        if (scale) layout$2(data, 0, 0, scale, scale);
+        if (scale !== 1) layout$2(data, 0, 0, scale, scale);
         if (offsetX) layout$2(data, offsetX, 0);
-        layout$2(data, to.x, to.y, size, size, getAngle(from, to));
+        layout$2(data, to.x, to.y, size, size, getAngle(from, to) + rotation);
         connectOffset.x = (connectX + offsetX) * size;
-        return data;
+        const arrowData = {
+            data: data
+        };
+        if (fill) arrowData.fill = fill;
+        return arrowData;
     }
     const {M: M$1, L: L$1, C: C$1, Q: Q, Z: Z$1, N: N, D: D, X: X, G: G, F: F, O: O, P: P, U: U} = PathCommandMap;
-    const {copy: copy, copyFrom: copyFrom, getDistancePoint: getDistancePoint} = PointHelper;
+    const {copy: copy, copyFrom: copyFrom, getDistancePoint: getDistancePoint, isSame: isSame} = PointHelper;
+    const {stintSet: stintSet$1} = DataHelper;
     const connectPoint = {};
     const first = {}, second = {};
-    const last = {}, now = {};
+    const old = {}, last = {}, now = {};
     const PathArrowModule = {
         list: arrows,
-        addArrows(ui) {
-            const {startArrow: startArrow, endArrow: endArrow, strokeWidth: strokeWidth, dashPattern: dashPattern, __pathForRender: data, cornerRadius: cornerRadius} = ui.__;
+        fillList: fillArrows,
+        addArrows(ui, updateCache) {
+            const uData = ui.__;
+            const {startArrow: startArrow, endArrow: endArrow, __strokeWidth: strokeWidth, dashPattern: dashPattern, __pathForRender: data, cornerRadius: cornerRadius} = uData;
             const clonePathForArrow = !cornerRadius;
+            if (!updateCache) uData.__strokeWidthCache = strokeWidth;
+            let startArrowPath, singleStartArrow, endArrowPath, singleEndArrow;
             let command, i = 0, len = data.length, count = 0, useStartArrow = startArrow && startArrow !== "none";
             while (i < len) {
                 command = data[i];
@@ -15970,6 +16104,7 @@ var LeaferUI = function(exports) {
                   case M$1:
                   case L$1:
                     if (count < 2 || i + 6 >= len) {
+                        copy(old, now);
                         copyFrom(now, data[i + 1], data[i + 2]);
                         if (!count && useStartArrow) copy(first, now);
                     }
@@ -15977,12 +16112,18 @@ var LeaferUI = function(exports) {
                     break;
 
                   case C$1:
-                    if (count === 1 || i + 7 >= len - 3) copyPoints(data, last, now, i + 3);
+                    if (count === 1 || i + 7 >= len - 3) {
+                        copyPoints(data, last, now, i + 3);
+                        old.x = data[i + 1], old.y = data[i + 2];
+                    }
                     i += 7;
                     break;
 
                   case Q:
-                    if (count === 1 || i + 5 >= len - 3) copyPoints(data, last, now, i + 1);
+                    if (count === 1 || i + 5 >= len - 3) {
+                        copyPoints(data, last, now, i + 1);
+                        copy(old, last);
+                    }
                     i += 5;
                     break;
 
@@ -16020,6 +16161,7 @@ var LeaferUI = function(exports) {
                   case U:
                     if (count === 1 || i + 6 >= len - 3) {
                         copyPoints(data, last, now, i + 1);
+                        copy(old, last);
                         if (i + 6 !== len) {
                             now.x -= (now.x - last.x) / 10;
                             now.y -= (now.y - last.y) / 10;
@@ -16030,13 +16172,13 @@ var LeaferUI = function(exports) {
                 }
                 count++;
                 if (count === 1 && command !== M$1) return;
-                if (count === 2 && useStartArrow) copy(second, command === L$1 ? now : last);
+                if (count === 2 && useStartArrow) copy(second, command === L$1 ? now : isSame(old, first) ? last : old);
                 if (i === len) {
-                    const path = ui.__.__pathForRender = clonePathForArrow ? [ ...data ] : data;
-                    const pathForArrow = ui.__.__pathForArrow = [];
+                    const path = uData.__pathForRender = clonePathForArrow ? [ ...data ] : data;
                     if (useStartArrow) {
-                        const startArrowPath = getArrowPath(ui, startArrow, second, first, strokeWidth, connectPoint, !!dashPattern);
-                        dashPattern ? pathForArrow.push(...startArrowPath) : path.push(...startArrowPath);
+                        startArrowPath = getArrowPath(ui, startArrow, second, first, strokeWidth, connectPoint, !!dashPattern);
+                        singleStartArrow = startArrowPath.fill || dashPattern;
+                        if (!singleStartArrow) path.push(...startArrowPath.data);
                         if (connectPoint.x) {
                             getDistancePoint(first, second, -connectPoint.x, true);
                             path[1] = second.x;
@@ -16044,8 +16186,10 @@ var LeaferUI = function(exports) {
                         }
                     }
                     if (endArrow && endArrow !== "none") {
-                        const endArrowPath = getArrowPath(ui, endArrow, last, now, strokeWidth, connectPoint, !!dashPattern);
-                        dashPattern ? pathForArrow.push(...endArrowPath) : path.push(...endArrowPath);
+                        if (isSame(last, now)) copy(last, old);
+                        endArrowPath = getArrowPath(ui, endArrow, last, now, strokeWidth, connectPoint, !!dashPattern);
+                        singleEndArrow = endArrowPath.fill || dashPattern;
+                        if (!singleEndArrow) path.push(...endArrowPath.data);
                         if (connectPoint.x) {
                             getDistancePoint(now, last, -connectPoint.x, true);
                             let index;
@@ -16072,10 +16216,21 @@ var LeaferUI = function(exports) {
                 } else {
                     copy(last, now);
                 }
+                stintSet$1(uData, "__startArrowPath", singleStartArrow && startArrowPath);
+                stintSet$1(uData, "__endArrowPath", singleEndArrow && endArrowPath);
             }
         },
-        register(name, data) {
+        updateArrow(ui) {
+            const data = ui.__;
+            if (data.strokeScaleFixed) {
+                if (data.__strokeWidthCache !== data.__strokeWidth) {
+                    ui.__updateRenderPath(true);
+                }
+            }
+        },
+        register(name, data, fillData) {
             this.list[name] = data;
+            if (fillData) this.fillList[name] = data;
         },
         get(name) {
             return this.list[name];
@@ -16094,12 +16249,26 @@ var LeaferUI = function(exports) {
     exports.UI.addAttr("endArrow", "none", arrowType);
     Object.assign(PathArrow, PathArrowModule);
     Object.assign(Paint, {
-        strokeArrow(_stroke, ui, canvas, _renderOptions) {
-            if (ui.__.dashPattern) {
+        strokeArrow(stroke, ui, canvas, _renderOptions) {
+            const {__startArrowPath: __startArrowPath, __endArrowPath: __endArrowPath, dashPattern: dashPattern} = ui.__;
+            if (dashPattern) canvas.dashPattern = null;
+            if (__startArrowPath) {
                 canvas.beginPath();
-                ui.__drawPathByData(canvas, ui.__.__pathForArrow);
-                canvas.dashPattern = null;
+                ui.__drawPathByData(canvas, __startArrowPath.data);
                 canvas.stroke();
+                if (__startArrowPath.fill) {
+                    canvas.fillStyle = stroke;
+                    canvas.fill();
+                }
+            }
+            if (__endArrowPath) {
+                canvas.beginPath();
+                ui.__drawPathByData(canvas, __endArrowPath.data);
+                canvas.stroke();
+                if (__endArrowPath.fill) {
+                    canvas.fillStyle = stroke;
+                    canvas.fill();
+                }
             }
         }
     });
@@ -16512,7 +16681,7 @@ var LeaferUI = function(exports) {
     exports.UI.addAttr("autoWidth", undefined, autoBoundsType);
     exports.UI.addAttr("autoHeight", undefined, autoBoundsType);
     exports.UI.addAttr("autoBox", undefined, boundsType);
-    const {copyAndSpread: copyAndSpread} = BoundsHelper;
+    const {copyAndSpread: copyAndSpread$1} = BoundsHelper;
     box$1.__updateFlowLayout = function() {
         const {leaferIsCreated: leaferIsCreated, flow: flow} = this;
         if (leaferIsCreated) this.leafer.created = false;
@@ -16542,7 +16711,7 @@ var LeaferUI = function(exports) {
         const same = layout.contentBounds === layout.boxBounds;
         if (padding) {
             if (same) layout.shrinkContent();
-            copyAndSpread(layout.contentBounds, layout.boxBounds, padding, true);
+            copyAndSpread$1(layout.contentBounds, layout.boxBounds, padding, true);
         } else {
             if (!same) layout.shrinkContentCancel();
         }
@@ -16563,7 +16732,7 @@ var LeaferUI = function(exports) {
                         boxBounds.width = data.width, boxBounds.x = 0;
                     }
                 }
-                flow && secondLayout && data.padding && copyAndSpread(boxBounds, boxBounds, data.padding, false, data.__autoSize ? null : data.__autoWidth ? "width" : "height");
+                flow && secondLayout && data.padding && copyAndSpread$1(boxBounds, boxBounds, data.padding, false, data.__autoSize ? null : data.__autoWidth ? "width" : "height");
                 this.__updateNaturalSize();
             } else {
                 this.__updateRectBoxBounds();
@@ -18366,9 +18535,7 @@ var LeaferUI = function(exports) {
     const {Yes: Yes, NoAndSkip: NoAndSkip, YesAndSkip: YesAndSkip} = exports.Answer;
     const idCondition = {}, classNameCondition = {}, tagCondition = {};
     class Finder {
-        constructor(target) {
-            this.innerIdMap = {};
-            this.idMap = {};
+        constructor(target, _config) {
             this.methods = {
                 id: (leaf, name) => leaf.id === name ? (this.target && (this.idMap[name] = leaf), 
                 1) : 0,
@@ -18378,6 +18545,13 @@ var LeaferUI = function(exports) {
                 tag: (leaf, name) => leaf.__tag === name ? 1 : 0,
                 tags: (leaf, nameMap) => nameMap[leaf.__tag] ? 1 : 0
             };
+            this.idMap = {};
+            this.innerIdMap = {};
+            const app = target && target.app;
+            if (app) {
+                app.idMap ? this.idMap = app.idMap : app.idMap = this.idMap;
+                app.innerIdMap ? this.innerIdMap = app.innerIdMap : app.innerIdMap = this.innerIdMap;
+            }
             if (this.target = target) this.__listenEvents();
         }
         getBy(condition, branch, one, options) {
@@ -18498,8 +18672,13 @@ var LeaferUI = function(exports) {
         return getSelector(this).getBy(condition, this, true, options);
     };
     Plugin.add("find");
-    Creator.finder = function(target) {
-        return new Finder(target);
+    Creator.finder = function(target, config) {
+        return new Finder(target, config);
+    };
+    LeafHelper.cacheId = function(t) {
+        const {leafer: leafer, id: id} = t;
+        if (id) leafer.app.idMap[id] = t;
+        if (leafer.cacheInnerId) leafer.app.innerIdMap[t.innerId] = t;
     };
     const {setPoint: setPoint, addPoint: addPoint, toBounds: toBounds} = TwoPointBoundsHelper;
     function getTrimBounds(canvas) {
@@ -18771,7 +18950,7 @@ var LeaferUI = function(exports) {
         style: {
             dragBoundsType: "outer",
             strokeAlign: "center",
-            strokeWidthFixed: "zoom-in",
+            strokeScaleFixed: "zoom-in",
             width: 6,
             height: 6,
             opacity: .5,
@@ -19008,6 +19187,141 @@ var LeaferUI = function(exports) {
             fill: "white"
         }
     });
+    const {stintSet: stintSet} = DataHelper;
+    function scaleFixedType(defaultValue) {
+        return decorateLeafAttr(defaultValue, key => attr({
+            set(value) {
+                if (this.__setAttr(key, value)) {
+                    const layout = this.__layout;
+                    doBoundsType(this);
+                    if (!isNumber(value)) value = value ? 1 : 0;
+                    stintSet(layout, "scaleFixed", value);
+                    stintSet(layout, "outerScale", value ? 1 / value : 0);
+                    if (!layout.outerScale && layout.localOuterBounds) layout.localOuterBounds = undefined;
+                }
+            }
+        }));
+    }
+    const {scale: scale} = MatrixHelper;
+    const {copyAndSpread: copyAndSpread} = BoundsHelper;
+    const {getScaleFixedData: getScaleFixedData} = MathHelper;
+    LeafHelper.updateScaleFixedWorld = function(t) {
+        const {__world: __world, __: __} = t, {scaleX: scaleX, scaleY: scaleY} = getScaleFixedData(__world, __.scaleFixed);
+        if (scaleX !== 1) {
+            scale(__world, scaleX, scaleY);
+            __world.scaleX *= scaleX, __world.scaleY *= scaleY;
+        }
+    };
+    LeafHelper.updateOuterBounds = function(t) {
+        const layout = t.__layout, {localRenderBounds: localRenderBounds} = layout;
+        const localOuterBounds = layout.localOuterBounds || (layout.localOuterBounds = {});
+        const {width: width, height: height} = localRenderBounds;
+        const scale = layout.outerScale - 1;
+        copyAndSpread(localOuterBounds, localRenderBounds, [ height * scale, width * scale ]);
+        if (t.parent) t.parent.__layout.renderChange();
+    };
+    Plugin.add("scale-fixed");
+    exports.UI.addAttr("scaleFixed", undefined, scaleFixedType);
+    class EllipseBoxData extends BoxData {}
+    const ellipse$1 = exports.Ellipse.prototype;
+    exports.EllipseBox = class EllipseBox extends exports.Box {
+        get __tag() {
+            return "EllipseBox";
+        }
+        __updatePath() {}
+    };
+    __decorate([ dataProcessor(EllipseBoxData) ], exports.EllipseBox.prototype, "__", void 0);
+    __decorate([ pathType(0) ], exports.EllipseBox.prototype, "innerRadius", void 0);
+    __decorate([ pathType(0) ], exports.EllipseBox.prototype, "startAngle", void 0);
+    __decorate([ pathType(0) ], exports.EllipseBox.prototype, "endAngle", void 0);
+    __decorate([ rewrite(ellipse$1.__updatePath) ], exports.EllipseBox.prototype, "__updatePath", null);
+    exports.EllipseBox = __decorate([ rewriteAble(), registerUI() ], exports.EllipseBox);
+    class PolygonBoxData extends BoxData {
+        get __usePathBox() {
+            return this.points || this.__pathInputed;
+        }
+    }
+    const polygon = exports.Polygon.prototype;
+    exports.PolygonBox = class PolygonBox extends exports.Box {
+        get __tag() {
+            return "PolygonBox";
+        }
+        __updatePath() {}
+    };
+    __decorate([ dataProcessor(PolygonBoxData) ], exports.PolygonBox.prototype, "__", void 0);
+    __decorate([ pathType(3) ], exports.PolygonBox.prototype, "sides", void 0);
+    __decorate([ pathType() ], exports.PolygonBox.prototype, "points", void 0);
+    __decorate([ pathType(0) ], exports.PolygonBox.prototype, "curve", void 0);
+    __decorate([ rewrite(polygon.__updatePath) ], exports.PolygonBox.prototype, "__updatePath", null);
+    exports.PolygonBox = __decorate([ rewriteAble(), registerUI() ], exports.PolygonBox);
+    class StarBoxData extends BoxData {}
+    const ellipse = exports.Star.prototype;
+    exports.StarBox = class StarBox extends exports.Box {
+        get __tag() {
+            return "StarBox";
+        }
+        __updatePath() {}
+    };
+    __decorate([ pathType(5) ], exports.StarBox.prototype, "corners", void 0);
+    __decorate([ pathType(.382) ], exports.StarBox.prototype, "innerRadius", void 0);
+    __decorate([ dataProcessor(StarBoxData) ], exports.StarBox.prototype, "__", void 0);
+    __decorate([ rewrite(ellipse.__updatePath) ], exports.StarBox.prototype, "__updatePath", null);
+    exports.StarBox = __decorate([ rewriteAble(), registerUI() ], exports.StarBox);
+    class PathBoxData extends BoxData {}
+    exports.PathBox = class PathBox extends exports.Box {
+        get __tag() {
+            return "PathBox";
+        }
+    };
+    __decorate([ dataProcessor(PathBoxData) ], exports.PathBox.prototype, "__", void 0);
+    __decorate([ affectStrokeBoundsType("center") ], exports.PathBox.prototype, "strokeAlign", void 0);
+    exports.PathBox = __decorate([ registerUI() ], exports.PathBox);
+    class ImageBoxData extends BoxData {
+        get __urlType() {
+            return "image";
+        }
+        setUrl(value) {
+            this.__setImageFill(value);
+            this._url = value;
+        }
+        __setImageFill(value) {
+            this.fill = value ? {
+                type: this.__urlType,
+                mode: "stretch",
+                url: value
+            } : undefined;
+        }
+        __getData() {
+            const data = super.__getData();
+            if (data.url) delete data.fill;
+            return data;
+        }
+        __getInputData(names, options) {
+            const data = super.__getInputData(names, options);
+            if (data.url) delete data.fill;
+            return data;
+        }
+    }
+    exports.ImageBox = class ImageBox extends exports.Box {
+        get __tag() {
+            return "ImageBox";
+        }
+        get ready() {
+            const {image: image} = this;
+            return image && image.ready;
+        }
+        get image() {
+            const {fill: fill} = this.__;
+            return isArray(fill) && fill[0].image;
+        }
+        get __useSelfBox() {
+            return true;
+        }
+    };
+    __decorate([ dataProcessor(ImageBoxData) ], exports.ImageBox.prototype, "__", void 0);
+    __decorate([ boundsType("") ], exports.ImageBox.prototype, "url", void 0);
+    exports.ImageBox = __decorate([ registerUI() ], exports.ImageBox);
+    Plugin.add("box");
     exports.AlignHelper = AlignHelper;
     exports.AnimateEasing = AnimateEasing;
     exports.AnimateEvent = AnimateEvent;
@@ -19045,6 +19359,7 @@ var LeaferUI = function(exports) {
     exports.EditorScaleEvent = EditorScaleEvent;
     exports.EditorSkewEvent = EditorSkewEvent;
     exports.Effect = Effect;
+    exports.EllipseBoxData = EllipseBoxData;
     exports.EllipseData = EllipseData;
     exports.EllipseHelper = EllipseHelper;
     exports.Event = Event;
@@ -19061,6 +19376,7 @@ var LeaferUI = function(exports) {
     exports.HighBezierHelper = HighBezierHelper;
     exports.HighCurveHelper = HighCurveHelper;
     exports.HitCanvasManager = HitCanvasManager;
+    exports.ImageBoxData = ImageBoxData;
     exports.ImageData = ImageData;
     exports.ImageEvent = ImageEvent;
     exports.ImageManager = ImageManager;
@@ -19110,6 +19426,7 @@ var LeaferUI = function(exports) {
     exports.PathArrow = PathArrow;
     exports.PathArrowModule = PathArrowModule;
     exports.PathBounds = PathBounds;
+    exports.PathBoxData = PathBoxData;
     exports.PathCommandDataHelper = PathCommandDataHelper;
     exports.PathCommandMap = PathCommandMap;
     exports.PathCommandNodeHelper = PathCommandNodeHelper;
@@ -19130,6 +19447,7 @@ var LeaferUI = function(exports) {
     exports.Point = Point;
     exports.PointHelper = PointHelper;
     exports.PointerButton = PointerButton;
+    exports.PolygonBoxData = PolygonBoxData;
     exports.PolygonData = PolygonData;
     exports.PropertyEvent = PropertyEvent;
     exports.RectData = RectData;
@@ -19145,6 +19463,7 @@ var LeaferUI = function(exports) {
     exports.Scroller = Scroller;
     exports.SelectArea = SelectArea;
     exports.Selector = Selector;
+    exports.StarBoxData = StarBoxData;
     exports.StarData = StarData;
     exports.State = State;
     exports.StringNumberMap = StringNumberMap;