@leafer/miniapp 1.12.0 → 1.12.2

package/dist/miniapp.module.js

@@ -216,7 +216,7 @@ class LeafData {
     }
 }
 
-const {floor: floor$3, max: max$6} = Math;
+const {floor: floor$3, max: max$7} = Math;
 
 const Platform = {
     toURL(text, fileType) {
@@ -242,7 +242,7 @@ const Platform = {
             return url;
         },
         resize(image, width, height, xGap, yGap, clip, smooth, opacity, _filters) {
-            const canvas = Platform.origin.createCanvas(max$6(floor$3(width + (xGap || 0)), 1), max$6(floor$3(height + (yGap || 0)), 1));
+            const canvas = Platform.origin.createCanvas(max$7(floor$3(width + (xGap || 0)), 1), max$7(floor$3(height + (yGap || 0)), 1));
             const ctx = canvas.getContext("2d");
             if (opacity) ctx.globalAlpha = opacity;
             ctx.imageSmoothingEnabled = smooth === false ? false : true;
@@ -289,7 +289,7 @@ const I$2 = IncrementId;
 
 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 ],
@@ -341,9 +341,9 @@ const FourNumberHelper = {
         return data;
     },
     max(t, other, change) {
-        if (isNumber(t) && isNumber(other)) return max$5(t, other);
+        if (isNumber(t) && isNumber(other)) return max$6(t, other);
         toTempAB(t, other, change);
-        return set$2(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;
@@ -360,7 +360,7 @@ const FourNumberHelper = {
 
 const {set: set$2, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
 
-const {round: round$6, pow: pow$2, max: max$4, floor: floor$2, PI: PI$4} = Math;
+const {round: round$6, pow: pow$2, max: max$5, floor: floor$2, PI: PI$4} = Math;
 
 const MathHelper = {
     within(value, min, max) {
@@ -414,7 +414,7 @@ const MathHelper = {
         }
     },
     getFloorScale(num, min = 1) {
-        return max$4(floor$2(num), min) / num;
+        return max$5(floor$2(num), min) / num;
     },
     randInt: randInt,
     randColor(opacity) {
@@ -461,9 +461,9 @@ function getMatrixData() {
 
 const {sin: sin$6, cos: cos$6, acos: acos, sqrt: sqrt$5} = Math;
 
-const {float: float$3} = MathHelper;
+const {float: float$5} = MathHelper;
 
-const tempPoint$4 = {};
+const tempPoint$5 = {};
 
 function getWorld() {
     return Object.assign(Object.assign(Object.assign({}, getMatrixData()), getBoundsData()), {
@@ -522,8 +522,8 @@ const MatrixHelper = {
         to.f = t.f * pixelRatio;
     },
     scaleOfOuter(t, origin, scaleX, scaleY) {
-        M$b.toInnerPoint(t, origin, tempPoint$4);
-        M$b.scaleOfInner(t, tempPoint$4, scaleX, scaleY);
+        M$b.toInnerPoint(t, origin, tempPoint$5);
+        M$b.scaleOfInner(t, tempPoint$5, scaleX, scaleY);
     },
     scaleOfInner(t, origin, scaleX, scaleY = scaleX) {
         M$b.translateInner(t, origin.x, origin.y);
@@ -541,8 +541,8 @@ const MatrixHelper = {
         t.d = c * sinR + d * cosR;
     },
     rotateOfOuter(t, origin, rotation) {
-        M$b.toInnerPoint(t, origin, tempPoint$4);
-        M$b.rotateOfInner(t, tempPoint$4, rotation);
+        M$b.toInnerPoint(t, origin, tempPoint$5);
+        M$b.rotateOfInner(t, tempPoint$5, rotation);
     },
     rotateOfInner(t, origin, rotation) {
         M$b.translateInner(t, origin.x, origin.y);
@@ -563,8 +563,8 @@ const MatrixHelper = {
         }
     },
     skewOfOuter(t, origin, skewX, skewY) {
-        M$b.toInnerPoint(t, origin, tempPoint$4);
-        M$b.skewOfInner(t, tempPoint$4, skewX, skewY);
+        M$b.toInnerPoint(t, origin, tempPoint$5);
+        M$b.skewOfInner(t, tempPoint$5, skewX, skewY);
     },
     skewOfInner(t, origin, skewX, skewY = 0) {
         M$b.translateInner(t, origin.x, origin.y);
@@ -712,12 +712,12 @@ const MatrixHelper = {
                 const cosR = c / scaleY;
                 rotation = PI_2 - (d > 0 ? acos(-cosR) : -acos(cosR));
             }
-            const cosR = float$3(cos$6(rotation));
+            const cosR = float$5(cos$6(rotation));
             const sinR = sin$6(rotation);
-            scaleX = float$3(scaleX), scaleY = float$3(scaleY);
-            skewX = cosR ? float$3((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
-            skewY = cosR ? float$3((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
-            rotation = float$3(rotation / OneRadian);
+            scaleX = float$5(scaleX), scaleY = float$5(scaleY);
+            skewX = cosR ? float$5((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
+            skewY = cosR ? float$5((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
+            rotation = float$5(rotation / OneRadian);
         } else {
             scaleX = a;
             scaleY = d;
@@ -761,9 +761,11 @@ const MatrixHelper = {
 
 const M$b = MatrixHelper;
 
+const {float: float$4} = MathHelper;
+
 const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
 
-const {sin: sin$5, cos: cos$5, abs: abs$a, sqrt: sqrt$4, atan2: atan2$2, min: min$2, round: round$5} = Math;
+const {sin: sin$5, cos: cos$5, abs: abs$a, sqrt: sqrt$4, atan2: atan2$2, min: min$3, round: round$5} = Math;
 
 const PointHelper = {
     defaultPoint: getPointData(),
@@ -812,22 +814,27 @@ const PointHelper = {
     },
     tempToInnerOf(t, matrix) {
         const {tempPoint: temp} = P$7;
-        copy$d(temp, t);
+        copy$c(temp, t);
         toInnerPoint$2(matrix, temp, temp);
         return temp;
     },
     tempToOuterOf(t, matrix) {
         const {tempPoint: temp} = P$7;
-        copy$d(temp, t);
+        copy$c(temp, t);
         toOuterPoint$3(matrix, temp, temp);
         return temp;
     },
     tempToInnerRadiusPointOf(t, matrix) {
         const {tempRadiusPoint: temp} = P$7;
-        copy$d(temp, t);
+        copy$c(temp, t);
         P$7.toInnerRadiusPointOf(t, matrix, temp);
         return temp;
     },
+    copyRadiusPoint(t, point, x, y) {
+        copy$c(t, point);
+        setRadius(t, x, y);
+        return t;
+    },
     toInnerRadiusPointOf(t, matrix, to) {
         to || (to = t);
         toInnerPoint$2(matrix, t, to);
@@ -861,7 +868,7 @@ const PointHelper = {
         return sqrt$4(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
-        return min$2(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
+        return min$3(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
     },
     getAngle(t, to) {
         return getAtan2(t, to) / OneRadian;
@@ -895,7 +902,7 @@ const PointHelper = {
         return points;
     },
     isSame(t, point) {
-        return t.x === point.x && t.y === point.y;
+        return float$4(t.x) === float$4(point.x) && float$4(t.y) === float$4(point.y);
     },
     reset(t) {
         P$7.reset(t);
@@ -904,7 +911,7 @@ const PointHelper = {
 
 const P$7 = PointHelper;
 
-const {getDistanceFrom: getDistanceFrom, copy: copy$d, getAtan2: getAtan2} = P$7;
+const {getDistanceFrom: getDistanceFrom, copy: copy$c, setRadius: setRadius, getAtan2: getAtan2} = P$7;
 
 class Point {
     constructor(x, y) {
@@ -979,7 +986,7 @@ class Point {
     }
 }
 
-const tempPoint$3 = new Point;
+const tempPoint$4 = new Point;
 
 class Matrix {
     constructor(a, b, c, d, e, f) {
@@ -1250,7 +1257,7 @@ const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$5, addPoint: addPo
 
 const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
 
-const {float: float$2, fourNumber: fourNumber$1} = MathHelper;
+const {float: float$3, fourNumber: fourNumber$1} = MathHelper;
 
 const {floor: floor$1, ceil: ceil$2} = Math;
 
@@ -1315,7 +1322,7 @@ const BoundsHelper = {
         return t;
     },
     toOffsetOutBounds(t, to, offsetBounds) {
-        if (!to) to = t; else copy$c(to, t);
+        if (!to) to = t; else copy$b(to, t);
         if (!offsetBounds) offsetBounds = t;
         to.offsetX = B.maxX(offsetBounds);
         to.offsetY = B.maxY(offsetBounds);
@@ -1425,10 +1432,10 @@ const BoundsHelper = {
         }
     },
     float(t, maxLength) {
-        t.x = float$2(t.x, maxLength);
-        t.y = float$2(t.y, maxLength);
-        t.width = float$2(t.width, maxLength);
-        t.height = float$2(t.height, maxLength);
+        t.x = float$3(t.x, maxLength);
+        t.y = float$3(t.y, maxLength);
+        t.width = float$3(t.width, maxLength);
+        t.height = float$3(t.height, maxLength);
     },
     add(t, bounds, isPoint) {
         right$4 = t.x + t.width;
@@ -1462,7 +1469,7 @@ const BoundsHelper = {
             if (bounds && (bounds.width || bounds.height)) {
                 if (first) {
                     first = false;
-                    if (!addMode) copy$c(t, bounds);
+                    if (!addMode) copy$b(t, bounds);
                 } else {
                     add$2(t, bounds);
                 }
@@ -1549,7 +1556,7 @@ const BoundsHelper = {
 
 const B = BoundsHelper;
 
-const {add: add$2, copy: copy$c} = B;
+const {add: add$2, copy: copy$b} = B;
 
 class Bounds {
     get minX() {
@@ -2247,7 +2254,7 @@ __decorate([ contextMethod() ], Canvas$1.prototype, "measureText", null);
 
 __decorate([ contextMethod() ], Canvas$1.prototype, "strokeText", null);
 
-const {copy: copy$b, multiplyParent: multiplyParent$4, pixelScale: pixelScale} = MatrixHelper, {round: round$4} = Math, tempPixelBounds = new Bounds, tempPixelBounds2 = new Bounds;
+const {copy: copy$a, multiplyParent: multiplyParent$4, pixelScale: pixelScale} = MatrixHelper, {round: round$4} = Math, tempPixelBounds = new Bounds, tempPixelBounds2 = new Bounds;
 
 const minSize = {
     width: 1,
@@ -2407,7 +2414,7 @@ class LeaferCanvasBase extends Canvas$1 {
         const {pixelRatio: pixelRatio} = this;
         this.filter = `blur(${blur * pixelRatio}px)`;
     }
-    copyWorld(canvas, from, to, blendMode, ceilPixel = true) {
+    copyWorld(canvas, from, to, blendMode, ceilPixel) {
         if (blendMode) this.blendMode = blendMode;
         if (from) {
             this.setTempPixelBounds(from, ceilPixel);
@@ -2418,7 +2425,7 @@ class LeaferCanvasBase extends Canvas$1 {
         }
         if (blendMode) this.blendMode = "source-over";
     }
-    copyWorldToInner(canvas, fromWorld, toInnerBounds, blendMode, ceilPixel = true) {
+    copyWorldToInner(canvas, fromWorld, toInnerBounds, blendMode, ceilPixel) {
         if (fromWorld.b || fromWorld.c) {
             this.save();
             this.resetTransform();
@@ -2431,7 +2438,7 @@ class LeaferCanvasBase extends Canvas$1 {
             if (blendMode) this.blendMode = "source-over";
         }
     }
-    copyWorldByReset(canvas, from, to, blendMode, onlyResetTransform, ceilPixel = true) {
+    copyWorldByReset(canvas, from, to, blendMode, onlyResetTransform, ceilPixel) {
         this.resetTransform();
         this.copyWorld(canvas, from, to, blendMode, ceilPixel);
         if (!onlyResetTransform) this.useWorldTransform();
@@ -2501,7 +2508,7 @@ class LeaferCanvasBase extends Canvas$1 {
     getSameCanvas(useSameWorldTransform, useSameSmooth) {
         const {size: size, pixelSnap: pixelSnap} = this, canvas = this.manager ? this.manager.get(size) : Creator.canvas(Object.assign({}, size));
         canvas.save();
-        if (useSameWorldTransform) copy$b(canvas.worldTransform, this.worldTransform), canvas.useWorldTransform();
+        if (useSameWorldTransform) copy$a(canvas.worldTransform, this.worldTransform), canvas.useWorldTransform();
         if (useSameSmooth) canvas.smooth = this.smooth;
         canvas.pixelSnap !== pixelSnap && (canvas.pixelSnap = pixelSnap);
         return canvas;
@@ -2642,7 +2649,7 @@ const RectHelper = {
     }
 };
 
-const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$1, abs: abs$9, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
+const {sin: sin$4, cos: cos$4, hypot: hypot$1, atan2: atan2$1, ceil: ceil$1, abs: abs$9, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
 
 const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
 
@@ -2650,7 +2657,7 @@ 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 tempPoint$3 = {};
 
 const BezierHelper = {
     points(data, originPoints, curve, close) {
@@ -2658,7 +2665,7 @@ const BezierHelper = {
         data.push(M$a, points[0], points[1]);
         if (curve && points.length > 5) {
             let aX, aY, bX, bY, cX, cY, c1X, c1Y, c2X, c2Y;
-            let ba, cb, d, len = points.length;
+            let baX, baY, ba, cb, d, len = points.length;
             const t = curve === true ? .5 : curve;
             if (close) {
                 points = [ points[len - 2], points[len - 1], ...points, points[0], points[1], points[2], points[3] ];
@@ -2671,7 +2678,9 @@ const BezierHelper = {
                 bY = points[i + 1];
                 cX = points[i + 2];
                 cY = points[i + 3];
-                ba = sqrt$3(pow$1(bX - aX, 2) + pow$1(bY - aY, 2));
+                baX = bX - aX;
+                baY = bY - aY;
+                ba = sqrt$3(pow$1(baX, 2) + pow$1(baY, 2));
                 cb = sqrt$3(pow$1(cX - bX, 2) + pow$1(cY - bY, 2));
                 if (!ba && !cb) continue;
                 d = ba + cb;
@@ -2684,7 +2693,7 @@ const BezierHelper = {
                 if (i === 2) {
                     if (!close) data.push(Q$7, c1X, c1Y, bX, bY);
                 } else {
-                    data.push(C$8, c2X, c2Y, c1X, c1Y, bX, bY);
+                    if (baX || baY) data.push(C$8, c2X, c2Y, c1X, c1Y, bX, bY);
                 }
                 c2X = bX + cb * cX;
                 c2Y = bY + cb * cY;
@@ -2713,8 +2722,8 @@ const BezierHelper = {
         const CBy = toY - y1;
         let startRadian = atan2$1(BAy, BAx);
         let endRadian = atan2$1(CBy, CBx);
-        const lenBA = hypot(BAx, BAy);
-        const lenCB = hypot(CBx, CBy);
+        const lenBA = hypot$1(BAx, BAy);
+        const lenCB = hypot$1(CBx, CBy);
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
         if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$9(totalRadian - PI$3) < 1e-12) {
@@ -2819,8 +2828,8 @@ const BezierHelper = {
         addMode ? addPoint$2(pointBounds, fromX, fromY) : setPoint$4(pointBounds, fromX, fromY);
         addPoint$2(pointBounds, toX, toY);
         for (let i = 0, len = tList.length; i < len; i++) {
-            getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$2);
-            addPoint$2(pointBounds, tempPoint$2.x, tempPoint$2.y);
+            getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$3);
+            addPoint$2(pointBounds, tempPoint$3.x, tempPoint$3.y);
         }
     },
     getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, setPoint) {
@@ -3230,7 +3239,7 @@ const {M: M$8, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
-const {tan: tan, min: min$1, abs: abs$8} = Math;
+const {tan: tan, min: min$2, abs: abs$8} = Math;
 
 const startPoint = {};
 
@@ -3269,6 +3278,7 @@ const PathCommandDataHelper = {
         }
     },
     ellipse(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
+        if (radiusX === radiusY) return arc$2(data, x, y, radiusX, startAngle, endAngle, anticlockwise);
         if (isNull(rotation)) {
             data.push(F$5, x, y, radiusX, radiusY);
         } else {
@@ -3281,6 +3291,7 @@ const PathCommandDataHelper = {
         if (isNull(startAngle)) {
             data.push(P$4, x, y, radius);
         } else {
+            if (isNull(startAngle)) startAngle = 0;
             if (isNull(endAngle)) endAngle = 360;
             data.push(O$5, x, y, radius, startAngle, endAngle, anticlockwise ? 1 : 0);
         }
@@ -3288,7 +3299,7 @@ const PathCommandDataHelper = {
     arcTo(data, x1, y1, x2, y2, radius, lastX, lastY) {
         if (!isUndefined(lastX)) {
             const d = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2);
-            radius = min$1(radius, min$1(d / 2, d / 2 * abs$8(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
+            radius = min$2(radius, min$2(d / 2, d / 2 * abs$8(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
         data.push(U$4, x1, y1, x2, y2, radius);
     },
@@ -3490,7 +3501,7 @@ 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
 
 const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$1} = BezierHelper;
 
-const {addPointBounds: addPointBounds, copy: copy$a, addPoint: addPoint$1, setPoint: setPoint$3, addBounds: addBounds, toBounds: toBounds$2} = TwoPointBoundsHelper;
+const {addPointBounds: addPointBounds, copy: copy$9, addPoint: addPoint$1, setPoint: setPoint$3, addBounds: addBounds, toBounds: toBounds$2} = TwoPointBoundsHelper;
 
 const debug$d = Debug.get("PathBounds");
 
@@ -3572,7 +3583,7 @@ const PathBounds = {
 
               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);
-                i === 0 ? copy$a(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
+                i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                 x = setEndPoint.x;
                 y = setEndPoint.y;
                 i += 9;
@@ -3590,7 +3601,7 @@ const PathBounds = {
 
               case O$3:
                 arc(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], tempPointBounds, setEndPoint);
-                i === 0 ? copy$a(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
+                i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                 x = setEndPoint.x;
                 y = setEndPoint.y;
                 i += 7;
@@ -3607,7 +3618,7 @@ const PathBounds = {
 
               case U$2:
                 arcTo$1(null, x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], tempPointBounds, setEndPoint);
-                i === 0 ? copy$a(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
+                i === 0 ? copy$9(setPointBounds, tempPointBounds) : addPointBounds(setPointBounds, tempPointBounds);
                 x = setEndPoint.x;
                 y = setEndPoint.y;
                 i += 6;
@@ -3631,6 +3642,7 @@ const PathCorner = {
     smooth(data, cornerRadius, _cornerSmoothing) {
         let command, lastCommand, commandLen;
         let i = 0, x = 0, y = 0, startX = 0, startY = 0, secondX = 0, secondY = 0, lastX = 0, lastY = 0;
+        if (isArray(cornerRadius)) cornerRadius = cornerRadius[0] || 0;
         const len = data.length;
         const smooth = [];
         while (i < len) {
@@ -4046,7 +4058,9 @@ const R = Resource;
 const ImageManager = {
     maxRecycled: 10,
     recycledList: [],
-    patternTasker: new TaskProcessor,
+    patternTasker: new TaskProcessor({
+        parallel: 1
+    }),
     get(config) {
         let image = Resource.get(config.url);
         if (!image) Resource.set(config.url, image = Creator.image(config));
@@ -4627,7 +4641,7 @@ function registerUIEvent() {
     };
 }
 
-const {copy: copy$9, toInnerPoint: toInnerPoint$1, toOuterPoint: toOuterPoint$1, scaleOfOuter: scaleOfOuter$2, rotateOfOuter: rotateOfOuter$2, skewOfOuter: skewOfOuter, multiplyParent: multiplyParent$3, divideParent: divideParent, getLayout: getLayout} = MatrixHelper;
+const {copy: copy$8, toInnerPoint: toInnerPoint$1, toOuterPoint: toOuterPoint$1, scaleOfOuter: scaleOfOuter$2, rotateOfOuter: rotateOfOuter$2, skewOfOuter: skewOfOuter, multiplyParent: multiplyParent$3, divideParent: divideParent, getLayout: getLayout} = MatrixHelper;
 
 const matrix$3 = {}, {round: round$3} = Math;
 
@@ -4725,7 +4739,7 @@ const LeafHelper = {
             if (scaleY) transition = scaleY;
             scaleY = scaleX;
         }
-        copy$9(matrix$3, o);
+        copy$8(matrix$3, o);
         scaleOfOuter$2(matrix$3, origin, scaleX, scaleY);
         if (L$4.hasHighPosition(t)) {
             L$4.setTransform(t, matrix$3, resize, transition);
@@ -4744,7 +4758,7 @@ const LeafHelper = {
     },
     rotateOfLocal(t, origin, angle, transition) {
         const o = t.__localMatrix;
-        copy$9(matrix$3, o);
+        copy$8(matrix$3, o);
         rotateOfOuter$2(matrix$3, origin, angle);
         if (L$4.hasHighPosition(t)) L$4.setTransform(t, matrix$3, false, transition); else t.set({
             x: t.x + matrix$3.e - o.e,
@@ -4756,18 +4770,18 @@ const LeafHelper = {
         L$4.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize, transition);
     },
     skewOfLocal(t, origin, skewX, skewY = 0, resize, transition) {
-        copy$9(matrix$3, t.__localMatrix);
+        copy$8(matrix$3, t.__localMatrix);
         skewOfOuter(matrix$3, origin, skewX, skewY);
         L$4.setTransform(t, matrix$3, resize, transition);
     },
     transformWorld(t, transform, resize, transition) {
-        copy$9(matrix$3, t.worldTransform);
+        copy$8(matrix$3, t.worldTransform);
         multiplyParent$3(matrix$3, transform);
         if (t.parent) divideParent(matrix$3, t.parent.scrollWorldTransform);
         L$4.setTransform(t, matrix$3, resize, transition);
     },
     transform(t, transform, resize, transition) {
-        copy$9(matrix$3, t.localTransform);
+        copy$8(matrix$3, t.localTransform);
         multiplyParent$3(matrix$3, transform);
         L$4.setTransform(t, matrix$3, resize, transition);
     },
@@ -4805,7 +4819,7 @@ const LeafHelper = {
         return innerOrigin;
     },
     getRelativeWorld(t, relative, temp) {
-        copy$9(matrix$3, t.worldTransform);
+        copy$8(matrix$3, t.worldTransform);
         divideParent(matrix$3, relative.scrollWorldTransform);
         return temp ? matrix$3 : Object.assign({}, matrix$3);
     },
@@ -4951,10 +4965,53 @@ const BranchHelper = {
             if (exclude && exclude === branch) continue;
             updateBounds$4(branch);
         }
+    },
+    move(branch, x, y) {
+        let w;
+        const {children: children} = branch;
+        for (let i = 0, len = children.length; i < len; i++) {
+            branch = children[i];
+            w = branch.__world;
+            w.e += x;
+            w.f += y;
+            w.x += x;
+            w.y += y;
+            if (branch.isBranch) move$9(branch, x, y);
+        }
+    },
+    scale(branch, x, y, scaleX, scaleY, a, b) {
+        let w;
+        const {children: children} = branch;
+        const changeScaleX = scaleX - 1;
+        const changeScaleY = scaleY - 1;
+        for (let i = 0, len = children.length; i < len; i++) {
+            branch = children[i];
+            w = branch.__world;
+            w.a *= scaleX;
+            w.d *= scaleY;
+            if (w.b || w.c) {
+                w.b *= scaleX;
+                w.c *= scaleY;
+            }
+            if (w.e === w.x && w.f === w.y) {
+                w.x = w.e += (w.e - a) * changeScaleX + x;
+                w.y = w.f += (w.f - b) * changeScaleY + y;
+            } else {
+                w.e += (w.e - a) * changeScaleX + x;
+                w.f += (w.f - b) * changeScaleY + y;
+                w.x += (w.x - a) * changeScaleX + x;
+                w.y += (w.y - b) * changeScaleY + y;
+            }
+            w.width *= scaleX;
+            w.height *= scaleY;
+            w.scaleX *= scaleX;
+            w.scaleY *= scaleY;
+            if (branch.isBranch) scale$2(branch, x, y, scaleX, scaleY, a, b);
+        }
     }
 };
 
-const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack} = BranchHelper;
+const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$9, scale: scale$2} = BranchHelper;
 
 const WaitHelper = {
     run(wait) {
@@ -4970,7 +5027,7 @@ const WaitHelper = {
 
 const {getRelativeWorld: getRelativeWorld$1, updateBounds: updateBounds$3} = LeafHelper;
 
-const {toOuterOf: toOuterOf$3, getPoints: getPoints, copy: copy$8} = BoundsHelper;
+const {toOuterOf: toOuterOf$3, getPoints: getPoints, copy: copy$7} = BoundsHelper;
 
 const localContent = "_localContentBounds";
 
@@ -5209,7 +5266,7 @@ class LeafLayout {
             matrix = getRelativeWorld$1(leaf, relative, true);
         }
         if (!layoutBounds) layoutBounds = MatrixHelper.getLayout(matrix);
-        copy$8(layoutBounds, bounds);
+        copy$7(layoutBounds, bounds);
         PointHelper.copy(layoutBounds, point);
         if (unscale) {
             const {scaleX: scaleX, scaleY: scaleY} = layoutBounds;
@@ -5831,7 +5888,7 @@ const LeafDataProxy = {
 
 const {setLayout: setLayout, multiplyParent: multiplyParent$2, translateInner: translateInner, defaultWorld: defaultWorld} = MatrixHelper;
 
-const {toPoint: toPoint$4, tempPoint: tempPoint$1} = AroundHelper;
+const {toPoint: toPoint$4, tempPoint: tempPoint$2} = AroundHelper;
 
 const LeafMatrix = {
     __updateWorldMatrix() {
@@ -5851,8 +5908,8 @@ const LeafMatrix = {
             local.e = data.x + data.offsetX;
             local.f = data.y + data.offsetY;
             if (data.around || data.origin) {
-                toPoint$4(data.around || data.origin, layout.boxBounds, tempPoint$1);
-                translateInner(local, -tempPoint$1.x, -tempPoint$1.y, !data.around);
+                toPoint$4(data.around || data.origin, layout.boxBounds, tempPoint$2);
+                translateInner(local, -tempPoint$2.x, -tempPoint$2.y, !data.around);
             }
         }
         this.__layout.matrixChanged = undefined;
@@ -5863,7 +5920,7 @@ const {updateMatrix: updateMatrix$3, updateAllMatrix: updateAllMatrix$3} = LeafH
 
 const {updateBounds: updateBounds$2} = BranchHelper;
 
-const {toOuterOf: toOuterOf$2, copyAndSpread: copyAndSpread$3, copy: copy$7} = BoundsHelper;
+const {toOuterOf: toOuterOf$2, copyAndSpread: copyAndSpread$3, copy: copy$6} = BoundsHelper;
 
 const {toBounds: toBounds$1} = PathBounds;
 
@@ -5974,7 +6031,7 @@ const LeafBounds = {
     },
     __updateRenderBounds(_bounds) {
         const layout = this.__layout, {renderSpread: renderSpread} = layout;
-        isNumber(renderSpread) && renderSpread <= 0 ? copy$7(layout.renderBounds, layout.strokeBounds) : copyAndSpread$3(layout.renderBounds, layout.boxBounds, renderSpread);
+        isNumber(renderSpread) && renderSpread <= 0 ? copy$6(layout.renderBounds, layout.strokeBounds) : copyAndSpread$3(layout.renderBounds, layout.boxBounds, renderSpread);
     }
 };
 
@@ -6079,7 +6136,7 @@ const {toInnerPoint: toInnerPoint, toOuterPoint: toOuterPoint, multiplyParent: m
 
 const {toOuterOf: toOuterOf$1} = BoundsHelper;
 
-const {copy: copy$6, move: move$8} = PointHelper;
+const {copy: copy$5, move: move$8} = PointHelper;
 
 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;
 
@@ -6398,14 +6455,14 @@ let Leaf = class Leaf {
         if (this.parent) {
             this.parent.worldToInner(world, to, distance, relative);
         } else {
-            if (to) copy$6(to, world);
+            if (to) copy$5(to, world);
         }
     }
     localToWorld(local, to, distance, relative) {
         if (this.parent) {
             this.parent.innerToWorld(local, to, distance, relative);
         } else {
-            if (to) copy$6(to, local);
+            if (to) copy$5(to, local);
         }
     }
     worldToInner(world, to, distance, relative) {
@@ -6518,10 +6575,10 @@ let Leaf = class Leaf {
     hit(_world, _hitRadius) {
         return true;
     }
-    __hitWorld(_point) {
+    __hitWorld(_point, _forceHitFill) {
         return true;
     }
-    __hit(_local) {
+    __hit(_local, _forceHitFill) {
         return true;
     }
     __hitFill(_inner) {
@@ -6880,7 +6937,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.12.0";
+const version = "1.12.2";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7682,6 +7739,10 @@ class Renderer {
 
 Renderer.clipSpread = 10;
 
+const tempPoint$1 = {};
+
+const {copyRadiusPoint: copyRadiusPoint$1} = PointHelper;
+
 const {hitRadiusPoint: hitRadiusPoint$1} = BoundsHelper;
 
 class Picker {
@@ -7808,15 +7869,15 @@ class Picker {
         this.eachFind(branch.children, branch.__onlyHitMask);
     }
     eachFind(children, hitMask) {
-        let child, hit;
+        let child, hit, data;
         const {point: point} = this, len = children.length;
         for (let i = len - 1; i > -1; i--) {
-            child = children[i];
-            if (!child.__.visible || hitMask && !child.__.mask) continue;
-            hit = child.__.hitRadius ? true : hitRadiusPoint$1(child.__world, point);
+            child = children[i], data = child.__;
+            if (!data.visible || hitMask && !data.mask) continue;
+            hit = hitRadiusPoint$1(child.__world, data.hitRadius ? copyRadiusPoint$1(tempPoint$1, point, data.hitRadius) : point);
             if (child.isBranch) {
                 if (hit || child.__ignoreHitWorld) {
-                    if (child.isBranchLeaf && child.__.__clipAfterFill && !child.__hitWorld(point)) continue;
+                    if (child.isBranchLeaf && data.__clipAfterFill && !child.__hitWorld(point, true)) continue;
                     if (child.topChildren) this.eachFind(child.topChildren, false);
                     this.eachFind(child.children, child.__onlyHitMask);
                     if (child.isBranchLeaf) this.hitChild(child, point);
@@ -8303,7 +8364,7 @@ class CanvasData extends RectData {
     }
 }
 
-const {max: max$3, add: add$1} = FourNumberHelper;
+const {max: max$4, add: add$1} = FourNumberHelper;
 
 const UIBounds = {
     __updateStrokeSpread() {
@@ -8319,7 +8380,7 @@ const UIBounds = {
         }
         if (data.__useArrow) spread += strokeWidth * 5;
         if (box) {
-            spread = max$3(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
+            spread = max$4(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
             boxSpread = Math.max(boxSpread, box.__layout.strokeBoxSpread);
         }
         this.__layout.strokeBoxSpread = boxSpread;
@@ -8329,15 +8390,15 @@ const UIBounds = {
         let spread = 0;
         const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = this.__, {strokeSpread: strokeSpread} = this.__layout, box = this.__box;
         if (shadow) spread = Effect.getShadowRenderSpread(this, shadow);
-        if (blur) spread = max$3(spread, blur);
+        if (blur) spread = max$4(spread, blur);
         if (filter) spread = add$1(spread, Filter.getSpread(filter));
         if (renderSpread) spread = add$1(spread, renderSpread);
         if (strokeSpread) spread = add$1(spread, strokeSpread);
         let shapeSpread = spread;
-        if (innerShadow) shapeSpread = max$3(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
-        if (backgroundBlur) shapeSpread = max$3(shapeSpread, backgroundBlur);
+        if (innerShadow) shapeSpread = max$4(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
+        if (backgroundBlur) shapeSpread = max$4(shapeSpread, backgroundBlur);
         this.__layout.renderShapeSpread = shapeSpread;
-        return box ? max$3(box.__updateRenderSpread(), spread) : spread;
+        return box ? max$4(box.__updateRenderSpread(), spread) : spread;
     }
 };
 
@@ -8393,7 +8454,7 @@ const UIRender = {
                 if (stroke && !__fillAfterStroke) data.__isStrokes ? Paint.strokes(stroke, this, canvas, options) : Paint.stroke(stroke, this, canvas, options);
             }
         } else {
-            if (data.__pathInputed) drawFast(this, canvas, options); else this.__drawFast(canvas, options);
+            if (data.__pathForRender) drawFast(this, canvas, options); else this.__drawFast(canvas, options);
         }
     },
     __drawShape(canvas, options) {
@@ -8517,7 +8578,7 @@ let UI = UI_1 = class UI extends Leaf {
     getPath(curve, pathForRender) {
         this.__layout.update();
         let path = pathForRender ? this.__.__pathForRender : this.__.path;
-        if (!path) pen.set(path = []), this.__drawPathByBox(pen);
+        if (!path) pen.set(path = []), this.__drawPathByBox(pen, !pathForRender);
         return curve ? PathConvert.toCanvasData(path, true) : path;
     }
     getPathString(curve, pathForRender, floatLength) {
@@ -8545,17 +8606,18 @@ let UI = UI_1 = class UI extends Leaf {
     }
     __drawPath(canvas) {
         canvas.beginPath();
-        this.__drawPathByData(canvas, this.__.path);
+        this.__drawPathByData(canvas, this.__.path, true);
     }
-    __drawPathByData(drawer, data) {
-        data ? PathDrawer.drawPathByData(drawer, data) : this.__drawPathByBox(drawer);
+    __drawPathByData(drawer, data, ignoreCornerRadius) {
+        data ? PathDrawer.drawPathByData(drawer, data) : this.__drawPathByBox(drawer, ignoreCornerRadius);
     }
-    __drawPathByBox(drawer) {
+    __drawPathByBox(drawer, ignoreCornerRadius) {
         const {x: x, y: y, width: width, height: height} = this.__layout.boxBounds;
-        if (this.__.cornerRadius) {
+        if (this.__.cornerRadius && !ignoreCornerRadius) {
             const {cornerRadius: cornerRadius} = this.__;
             drawer.roundRect(x, y, width, height, isNumber(cornerRadius) ? [ cornerRadius ] : cornerRadius);
         } else drawer.rect(x, y, width, height);
+        drawer.closePath();
     }
     drawImagePlaceholder(_paint, canvas, renderOptions) {
         Paint.fill(this.__.placeholderColor, this, canvas, renderOptions);
@@ -8824,6 +8886,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
     get layoutLocked() {
         return !this.layouter.running;
     }
+    get view() {
+        return this.canvas && this.canvas.view;
+    }
     get FPS() {
         return this.renderer ? this.renderer.FPS : 60;
     }
@@ -8875,7 +8940,6 @@ let Leafer = Leafer_1 = class Leafer extends Group {
         this.__controllers.push(this.renderer = Creator.renderer(this, canvas, config), this.watcher = Creator.watcher(this, config), this.layouter = Creator.layouter(this, config));
         if (this.isApp) this.__setApp();
         this.__checkAutoLayout();
-        this.view = canvas.view;
         if (!parentApp) {
             this.selector = Creator.selector(this);
             this.interaction = Creator.interaction(this, canvas, this.selector, config);
@@ -9155,7 +9219,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
                         if (this.canvasManager) this.canvasManager.destroy();
                     }
                     if (this.canvas) this.canvas.destroy();
-                    this.config.view = this.view = this.parentApp = null;
+                    this.config.view = this.parentApp = null;
                     if (this.userConfig) this.userConfig.view = null;
                     super.destroy();
                     setTimeout(() => {
@@ -9339,7 +9403,6 @@ let Ellipse = class Ellipse extends UI {
             if (startAngle || endAngle) {
                 if (innerRadius < 1) ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false);
                 ellipse(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
-                if (innerRadius < 1) closePath$2(path);
             } else {
                 if (innerRadius < 1) {
                     ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius);
@@ -9347,16 +9410,16 @@ let Ellipse = class Ellipse extends UI {
                 }
                 ellipse(path, rx, ry, rx, ry, 0, 360, 0, true);
             }
-            if (Platform.ellipseToCurve) this.__.path = this.getPath(true);
         } else {
             if (startAngle || endAngle) {
                 moveTo$3(path, rx, ry);
                 ellipse(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
-                closePath$2(path);
             } else {
                 ellipse(path, rx, ry, rx, ry);
             }
         }
+        closePath$2(path);
+        if (Platform.ellipseToCurve) this.__.path = this.getPath(true);
     }
 };
 
@@ -10007,7 +10070,7 @@ class UIEvent extends Event {
     }
 }
 
-const {min: min, max: max$2, abs: abs$7} = Math, {float: float$1, sign: sign$2} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
+const {min: min$1, max: max$3, abs: abs$7} = Math, {float: float$2, sign: sign$2} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
 
 const tempContent = new Bounds, tempDragBounds = new Bounds;
 
@@ -10047,8 +10110,8 @@ const DragBoundsHelper = {
         } 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);
+        move.x = float$2(move.x);
+        move.y = float$2(move.y);
         return move;
     },
     getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, lockRatio, change) {
@@ -10060,44 +10123,44 @@ const DragBoundsHelper = {
         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);
+            aSize = float$2(tempContent.minX - tempDragBounds.minX);
+            bSize = float$2(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$2(aScale, bScale);
+            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);
+                if (float$2(minX(content) - minX(dragBounds)) <= 0 || float$2(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);
+            aSize = float$2(tempDragBounds.minX - tempContent.minX);
+            bSize = float$2(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);
+            correctScaleX *= min$1(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);
+            aSize = float$2(tempContent.minY - tempDragBounds.minY);
+            bSize = float$2(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$2(aScale, bScale);
+            correctScaleY *= max$3(aScale, bScale);
             if (lockRatio) {
-                aScale = max$2(abs$7(correctScaleX), abs$7(correctScaleY));
+                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);
+                if (float$2(minY(content) - minY(dragBounds)) <= 0 || float$2(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);
+            aSize = float$2(tempDragBounds.minY - tempContent.minY);
+            bSize = float$2(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);
+            correctScaleY *= min$1(aScale, bScale);
         }
         scale.x *= isFinite$1(correctScaleX) ? correctScaleX : 1;
         scale.y *= isFinite$1(correctScaleY) ? correctScaleY : 1;
@@ -10246,6 +10309,8 @@ MoveEvent.START = "move.start";
 
 MoveEvent.MOVE = "move";
 
+MoveEvent.DRAG_ANIMATE = "move.drag_animate";
+
 MoveEvent.END = "move.end";
 
 MoveEvent = __decorate([ registerUIEvent() ], MoveEvent);
@@ -10344,6 +10409,7 @@ const InteractionHelper = {
             ctrlKey: e.ctrlKey,
             shiftKey: e.shiftKey,
             metaKey: e.metaKey,
+            time: Date.now(),
             buttons: isUndefined(e.buttons) ? 1 : e.buttons === 0 ? pointerUpButtons : e.buttons,
             origin: e
         };
@@ -10379,6 +10445,7 @@ const {getDragEventData: getDragEventData, getDropEventData: getDropEventData, g
 
 class Dragger {
     constructor(interaction) {
+        this.dragDataList = [];
         this.interaction = interaction;
     }
     setDragData(data) {
@@ -10441,6 +10508,7 @@ class Dragger {
         this.dragData = getDragEventData(downData, dragData, data);
         if (throughPath) this.dragData.throughPath = throughPath;
         this.dragData.path = path;
+        this.dragDataList.push(this.dragData);
         if (this.moving) {
             data.moving = true;
             this.dragData.moveType = "drag";
@@ -10491,9 +10559,9 @@ class Dragger {
         interaction.emit(DragEvent.ENTER, data, path, dragEnterPath);
         this.dragEnterPath = path;
     }
-    dragEnd(data, speed) {
+    dragEnd(data) {
         if (!this.dragging && !this.moving) return;
-        if (this.checkDragEndAnimate(data, speed)) return;
+        if (this.checkDragEndAnimate(data)) return;
         this.dragEndReal(data);
     }
     dragEndReal(data) {
@@ -10535,11 +10603,13 @@ class Dragger {
     }
     dragReset() {
         DragEvent.list = DragEvent.data = this.draggableList = this.dragData = this.downData = this.dragOverPath = this.dragEnterPath = null;
+        this.dragDataList = [];
     }
     checkDragEndAnimate(_data, _speed) {
         return false;
     }
     animate(_func, _off) {}
+    stopAnimate() {}
     checkDragOut(_data) {}
     autoMoveOnDragOut(_data) {}
     autoMoveCancel() {}
@@ -10933,6 +11003,9 @@ class InteractionBase {
             this.pointerHover(hoverData);
         }
     }
+    stopDragAnimate() {
+        this.dragger.stopAnimate();
+    }
     updateDownData(data, options, merge) {
         const {downData: downData} = this;
         if (!data && downData) data = downData;
@@ -11116,7 +11189,7 @@ Platform.getSelector = function(leaf) {
     return leaf.leafer ? leaf.leafer.selector : Platform.selector || (Platform.selector = Creator.selector());
 };
 
-const {toInnerRadiusPointOf: toInnerRadiusPointOf, copy: copy$5, setRadius: setRadius} = PointHelper;
+const {toInnerRadiusPointOf: toInnerRadiusPointOf, copyRadiusPoint: copyRadiusPoint} = PointHelper;
 
 const {hitRadiusPoint: hitRadiusPoint, hitPoint: hitPoint} = BoundsHelper;
 
@@ -11126,8 +11199,7 @@ const leaf$1 = Leaf.prototype;
 
 leaf$1.hit = function(worldPoint, hitRadius = 0) {
     this.updateLayout();
-    copy$5(worldRadiusPoint, worldPoint);
-    setRadius(worldRadiusPoint, hitRadius);
+    copyRadiusPoint(worldRadiusPoint, worldPoint, hitRadius);
     const world = this.__world;
     if (hitRadius ? !hitRadiusPoint(world, worldRadiusPoint) : !hitPoint(world, worldRadiusPoint)) return false;
     return this.isBranch ? Platform.getSelector(this).hitPoint(Object.assign({}, worldRadiusPoint), hitRadius, {
@@ -11135,14 +11207,14 @@ leaf$1.hit = function(worldPoint, hitRadius = 0) {
     }) : this.__hitWorld(worldRadiusPoint);
 };
 
-leaf$1.__hitWorld = function(point) {
+leaf$1.__hitWorld = function(point, forceHitFill) {
     const data = this.__;
     if (!data.hitSelf) return false;
     const world = this.__world, layout = this.__layout;
     const isSmall = world.width < 10 && world.height < 10;
     if (data.hitRadius) {
-        copy$5(inner, point), point = inner;
-        setRadius(point, data.hitRadius);
+        copyRadiusPoint(inner, point, data.hitRadius);
+        point = inner;
     }
     toInnerRadiusPointOf(point, world, inner);
     if (data.hitBox || isSmall) {
@@ -11153,7 +11225,7 @@ leaf$1.__hitWorld = function(point) {
         this.__updateHitCanvas();
         if (!layout.boundsChanged) layout.hitCanvasChanged = false;
     }
-    return this.__hit(inner);
+    return this.__hit(inner, forceHitFill);
 };
 
 leaf$1.__hitFill = function(inner) {
@@ -11220,12 +11292,12 @@ ui$5.__updateHitCanvas = function() {
     h.setStrokeOptions(data);
 };
 
-ui$5.__hit = function(inner) {
+ui$5.__hit = function(inner, forceHitFill) {
     if (this.__box && this.__box.__hit(inner)) return true;
     const data = this.__;
     if (data.__isHitPixel && this.__hitPixel(inner)) return true;
     const {hitFill: hitFill} = data;
-    const needHitFillPath = (data.fill || data.__isCanvas) && (hitFill === "path" || hitFill === "pixel" && !(data.__isAlphaPixelFill || data.__isCanvas)) || hitFill === "all";
+    const needHitFillPath = (data.fill || data.__isCanvas) && (hitFill === "path" || hitFill === "pixel" && !(data.__isAlphaPixelFill || data.__isCanvas)) || hitFill === "all" || forceHitFill;
     if (needHitFillPath && this.__hitFill(inner)) return true;
     const {hitStroke: hitStroke, __maxStrokeWidth: strokeWidth} = data;
     const needHitStrokePath = data.stroke && (hitStroke === "path" || hitStroke === "pixel" && !data.__isAlphaPixelStroke) || hitStroke === "all";
@@ -12062,10 +12134,12 @@ const {getFloorScale: getFloorScale} = MathHelper, {abs: abs$6} = Math;
 function createPatternTask(paint, ui, canvas, renderOptions) {
     if (!paint.patternTask) {
         paint.patternTask = ImageManager.patternTasker.add(() => __awaiter(this, void 0, void 0, function*() {
-            paint.patternTask = null;
-            if (canvas.bounds.hit(ui.__nowWorld)) PaintImage.createPattern(paint, ui, canvas, renderOptions);
+            PaintImage.createPattern(paint, ui, canvas, renderOptions);
             ui.forceUpdate("surface");
-        }), 300);
+        }), 0, () => {
+            paint.patternTask = null;
+            return canvas.bounds.hit(ui.__nowWorld);
+        });
     }
 }
 
@@ -12315,7 +12389,7 @@ const PaintGradientModule = {
     getTransform: getTransform
 };
 
-const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$1, abs: abs$5} = Math;
+const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$2, abs: abs$5} = Math;
 
 const tempBounds = {}, tempMatrix = new Matrix;
 
@@ -12360,10 +12434,10 @@ 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, 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);
-        left = max$1(left, spread + blur - x);
+        top = max$2(top, spread + blur - y);
+        right = max$2(right, spread + blur + x);
+        bottom = max$2(bottom, spread + blur + y);
+        left = max$2(left, spread + blur - x);
     });
     return top === right && right === bottom && bottom === left ? top : [ top, right, bottom, left ];
 }
@@ -13248,7 +13322,11 @@ class Stroker extends UI {
                     matrix$1.half = strokeWidth % 2;
                     canvas.setWorld(matrix$1, options.matrix);
                     canvas.beginPath();
-                    if (leaf.__.__useArrow) leaf.__drawPath(canvas); else leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
+                    if (this.strokePathType === "path") {
+                        leaf.__drawPath(canvas);
+                    } else {
+                        if (leaf.__.__useArrow) leaf.__drawPath(canvas); else leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
+                    }
                     data.strokeWidth = strokeWidth / Math.max(aScaleX, aScaleY);
                     if (stroke) isString(stroke) ? Paint.stroke(stroke, this, canvas, options) : Paint.strokes(stroke, this, canvas, options);
                     if (fill) isString(fill) ? Paint.fill(fill, this, canvas, options) : Paint.fills(fill, this, canvas, options);
@@ -13265,6 +13343,8 @@ class Stroker extends UI {
 
 __decorate([ targetAttr(onTarget$1) ], Stroker.prototype, "target", void 0);
 
+__decorate([ surfaceType("render-path") ], Stroker.prototype, "strokePathType", void 0);
+
 function onTarget$1(stroker) {
     const value = stroker.target;
     stroker.list = value ? isArray(value) ? value : [ value ] : [];
@@ -13379,10 +13459,11 @@ class EditSelect extends Group {
     }
     update() {
         this.hoverStroker.update();
-        const {stroke: stroke, strokeWidth: strokeWidth, selectedStyle: selectedStyle} = this.editor.mergedConfig;
+        const {stroke: stroke, strokeWidth: strokeWidth, selectedPathType: selectedPathType, selectedStyle: selectedStyle} = this.editor.mergedConfig;
         this.targetStroker.update(Object.assign({
             stroke: stroke,
-            strokeWidth: strokeWidth && Math.max(1, strokeWidth / 2)
+            strokeWidth: strokeWidth && Math.max(1, strokeWidth / 2),
+            strokePathType: selectedPathType
         }, selectedStyle || {}));
     }
     onPointerMove(e) {
@@ -14767,7 +14848,7 @@ class TransformTool {
         const {target: target, mergeConfig: mergeConfig, single: single, dragStartData: dragStartData} = this.editBox;
         let {around: around, lockRatio: lockRatio, flipable: flipable, editSize: editSize} = mergeConfig, totalMove;
         if (e instanceof ZoomEvent) {
-            around = target.getBoxPoint(e);
+            if (!around) around = target.getBoxPoint(e);
             totalMove = e.totalScale;
         } else {
             totalMove = e.getInnerTotal(target);
@@ -15824,7 +15905,11 @@ function addViewport(leafer, mergeConfig, custom) {
     addViewportConfig(leafer.parentApp ? leafer.parentApp : leafer, mergeConfig);
     if (leafer.isApp || custom) return;
     leafer.__eventIds.push(leafer.on_(MoveEvent.BEFORE_MOVE, e => {
-        leafer.zoomLayer.move(leafer.getValidMove(e.moveX, e.moveY, false));
+        const move = leafer.getValidMove(e.moveX, e.moveY, false);
+        leafer.zoomLayer.move(move);
+    }), leafer.on_(MoveEvent.DRAG_ANIMATE, () => {
+        const move = leafer.getValidMove(0, 0);
+        if (move.x || move.y) leafer.interaction.stopDragAnimate();
     }), leafer.on_(MoveEvent.END, e => {
         LeafHelper.animateMove(leafer.zoomLayer, leafer.getValidMove(e.moveX, e.moveY));
     }), leafer.on_(ZoomEvent.BEFORE_ZOOM, e => {
@@ -15975,7 +16060,7 @@ const MultiTouchHelper = {
 
 const M$3 = MultiTouchHelper;
 
-const {abs: abs$2, max: max} = Math, {sign: sign, within: within$2} = MathHelper;
+const {abs: abs$2, max: max$1} = Math, {sign: sign, within: within$2} = MathHelper;
 
 const WheelEventHelper = {
     getMove(event, config) {
@@ -15986,8 +16071,8 @@ const WheelEventHelper = {
             deltaY = 0;
         }
         const absX = abs$2(deltaX), absY = abs$2(deltaY);
-        if (absX > 50) deltaX = max(50, absX / 3) * sign(deltaX);
-        if (absY > 50) deltaY = max(50, absY / 3) * sign(deltaY);
+        if (absX > 50) deltaX = max$1(50, absX / 3) * sign(deltaX);
+        if (absY > 50) deltaY = max$1(50, absY / 3) * sign(deltaY);
         return {
             x: -deltaX * moveSpeed * 2,
             y: -deltaY * moveSpeed * 2
@@ -16137,7 +16222,7 @@ leafer.getValidMove = function(moveX, moveY, checkLimit = true) {
         if (type.includes("x")) move$4.y = 0; else if (type.includes("y")) move$4.x = 0; else Math.abs(move$4.x) > Math.abs(move$4.y) ? move$4.y = 0 : move$4.x = 0;
         if (checkLimit && type.includes("limit")) {
             bounds.set(this.__world).addPoint(this.zoomLayer);
-            DragBoundsHelper.getValidMove(bounds, this.canvas.bounds, "inner", move$4, true);
+            DragBoundsHelper.getValidMove(bounds, this.canvas.bounds, "auto", move$4, true);
             if (type.includes("x")) move$4.y = 0; else if (type.includes("y")) move$4.x = 0;
         }
     }
@@ -16245,22 +16330,52 @@ interaction.multiTouch = function(data, list) {
 
 const dragger = Dragger.prototype;
 
-const {abs: abs$1} = Math;
+const {abs: abs$1, min: min, max: max, hypot: hypot} = Math;
 
-dragger.checkDragEndAnimate = function(data, speed) {
-    const {moveX: moveX, moveY: moveY} = this.dragData;
-    const absMoveX = abs$1(moveX), absMoveY = abs$1(moveY), minMove = speed ? 1 : .1;
-    const dragAnimate = this.canAnimate && this.moving && (absMoveX > minMove || absMoveY > minMove) && this.interaction.m.dragAnimate;
+dragger.checkDragEndAnimate = function(data) {
+    const {interaction: interaction} = this;
+    const dragAnimate = this.canAnimate && this.moving && interaction.m.dragAnimate;
     if (dragAnimate) {
-        const inertia = data.pointerType === "touch" ? 3 : 1, maxMove = 70;
-        speed = speed ? isNumber(dragAnimate) ? dragAnimate : .95 : inertia;
-        if (absMoveX * speed > maxMove) speed = maxMove / absMoveX; else if (absMoveY * speed > maxMove) speed = maxMove / absMoveY;
-        data = Object.assign({}, data);
-        PointHelper.move(data, moveX * speed, moveY * speed);
-        this.drag(data);
-        this.animate(() => {
-            this.dragEnd(data, 1);
-        });
+        const inertia = isNumber(dragAnimate) ? dragAnimate : .95;
+        const stopMove = .15;
+        const maxMove = 150;
+        let moveX = 0, moveY = 0, flickSpeed = 0;
+        let totalWeight = 0, weight, w = 3, s, frame;
+        const {dragDataList: dragDataList} = this, len = dragDataList.length;
+        for (let i = len - 1; i >= max(len - 3, 0); i--) {
+            frame = dragDataList[i];
+            if (frame.time && Date.now() - frame.time > 100) break;
+            weight = w--;
+            moveX += frame.moveX * weight;
+            moveY += frame.moveY * weight;
+            totalWeight += weight;
+            s = hypot(frame.moveX, frame.moveY);
+            if (s > flickSpeed) flickSpeed = s;
+        }
+        if (totalWeight) moveX /= totalWeight, moveY /= totalWeight;
+        if (flickSpeed > 8) {
+            const t = min((flickSpeed - 8) / 17, 1);
+            const boost = 1.15 + t * (1.6 - 1.15);
+            moveX *= boost;
+            moveY *= boost;
+        }
+        const maxAbs = max(abs$1(moveX), abs$1(moveY));
+        if (maxAbs > maxMove) {
+            s = maxMove / maxAbs;
+            moveX *= s;
+            moveY *= s;
+        }
+        const step = () => {
+            moveX *= inertia;
+            moveY *= inertia;
+            data = Object.assign({}, data);
+            if (abs$1(moveX) < stopMove && abs$1(moveY) < stopMove) return this.dragEndReal(data);
+            PointHelper.move(data, moveX, moveY);
+            this.drag(data);
+            this.animate(step);
+            interaction.emit(MoveEvent.DRAG_ANIMATE, data);
+        };
+        this.animate(step);
     }
     return dragAnimate;
 };
@@ -16271,6 +16386,13 @@ dragger.animate = function(func, off) {
     this.animateWait = func;
 };
 
+dragger.stopAnimate = function() {
+    this.animate(null, "off");
+    this.interaction.target.nextRender(() => {
+        if (this.dragData) this.dragEndReal(this.dragData);
+    });
+};
+
 dragger.checkDragOut = function(data) {
     const {interaction: interaction} = this;
     this.autoMoveCancel();
@@ -16342,7 +16464,6 @@ function getFixBounds(bounds, scaleBounds) {
 Plugin.add("view");
 
 Leafer.prototype.zoom = function(zoomType, optionsOrPadding, scroll, transition) {
-    this.killAnimate();
     let padding;
     if (isData(optionsOrPadding)) {
         padding = optionsOrPadding.padding;
@@ -16355,8 +16476,9 @@ Leafer.prototype.zoom = function(zoomType, optionsOrPadding, scroll, transition)
         x: limitBounds.x + limitBounds.width / 2,
         y: limitBounds.y + limitBounds.height / 2
     };
+    zoomLayer.killAnimate();
     let changeScale;
-    const {x: x, y: y, scaleX: scaleX, scaleY: scaleY} = zoomLayer.__;
+    const {x: x, y: y, scaleX: scaleX, scaleY: scaleY} = zoomLayer.__, {boxBounds: boxBounds} = zoomLayer;
     if (isString(zoomType)) {
         switch (zoomType) {
           case "in":
@@ -16368,16 +16490,16 @@ Leafer.prototype.zoom = function(zoomType, optionsOrPadding, scroll, transition)
             break;
 
           case "fit":
-            zoomType = this.boxBounds;
+            zoomType = boxBounds;
             break;
 
           case "fit-width":
-            zoomType = new Bounds(this.boxBounds);
+            zoomType = new Bounds(boxBounds);
             zoomType.height = 0;
             break;
 
           case "fit-height":
-            zoomType = new Bounds(this.boxBounds);
+            zoomType = new Bounds(boxBounds);
             zoomType.width = 0;
             break;
         }
@@ -17640,6 +17762,8 @@ let Animate = class Animate extends Eventer {
     }
     constructor(target, keyframe, options, isTemp) {
         super();
+        this.nowIndex = 0;
+        this.playedTotalTime = 0;
         if (keyframe) {
             if (keyframe.keyframes) options = keyframe, keyframe = keyframe.keyframes; else if (keyframe.style) options = keyframe, 
             keyframe = keyframe.style;
@@ -17686,7 +17810,7 @@ let Animate = class Animate extends Eventer {
     play() {
         if (this.destroyed) return;
         this.running = true;
-        if (!this.started) this.clearTimer(), this.start(); else if (!this.timer) this.requestAnimate();
+        if (!this.started) this.clearTimer(), this.start(); else if (!this.timer) this.startRequestAnimate();
         this.emitType(AnimateEvent.PLAY);
     }
     pause() {
@@ -17700,14 +17824,28 @@ let Animate = class Animate extends Eventer {
         this.complete();
         this.emitType(AnimateEvent.STOP);
     }
-    seek(time) {
+    seek(time, includeDelay) {
         if (this.destroyed) return;
-        if (isObject(time)) time = UnitConvert.number(time, this.duration);
+        const {delay: delay} = this;
+        if (isObject(time)) time = UnitConvert.number(time, this.duration + (includeDelay ? delay : 0));
+        if (includeDelay) time -= delay;
         if (time) time /= this.speed;
-        if (!this.started || time < this.time) this.start(true);
+        let waitBeginTime;
+        if (time < 0) {
+            waitBeginTime = -time;
+            time = 0;
+        }
+        if (!this.started || time < this.time || !time) this.start(true);
         this.time = time;
-        this.animate(0, true);
-        this.clearTimer(() => this.requestAnimate());
+        if (!waitBeginTime) this.animate(0, true);
+        this.clearTimer(() => {
+            if (waitBeginTime) {
+                this.timer = setTimeout(() => {
+                    this.timer = 0;
+                    this.begin();
+                }, waitBeginTime * 1e3);
+            } else this.startRequestAnimate();
+        });
         this.emitType(AnimateEvent.SEEK);
     }
     kill(complete = true, killStyle) {
@@ -17790,14 +17928,24 @@ let Animate = class Animate extends Eventer {
             }
         }
     }
-    requestAnimate() {
+    startRequestAnimate() {
         this.requestAnimateTime = Date.now();
+        this.requestAnimatePageTime = 0;
+        if (!this.waitRequestRender) this.requestAnimate();
+    }
+    requestAnimate() {
+        this.waitRequestRender = true;
         Platform.requestRender(this.animate.bind(this));
     }
-    animate(_runtime, seek) {
+    animate(pageTime, seek) {
         if (!seek) {
+            this.waitRequestRender = false;
             if (!this.running) return;
-            this.time += (Date.now() - this.requestAnimateTime) / 1e3;
+            let frameTime;
+            if (pageTime && this.requestAnimatePageTime) frameTime = pageTime - this.requestAnimatePageTime; else frameTime = Date.now() - this.requestAnimateTime;
+            this.time += frameTime / 1e3;
+            this.requestAnimatePageTime = pageTime;
+            this.requestAnimateTime = Date.now();
         }
         const {duration: duration} = this, realTime = this.time * this.speed;
         if (realTime < duration) {
@@ -17838,21 +17986,24 @@ let Animate = class Animate extends Eventer {
     }
     start(seek) {
         this.requestAnimateTime = 1;
-        const {reverse: reverse} = this;
+        const {reverse: reverse, jump: jump} = this;
         if (reverse || this.mainReverse) this.mainReverse = reverse;
         if (this.looped) this.looped = 0;
         if (seek) this.begin(true); else {
             const {delay: delay} = this;
-            if (delay) this.timer = setTimeout(() => {
-                this.timer = 0;
-                this.begin();
-            }, delay / this.speed * 1e3); else this.begin();
+            if (delay) {
+                if (jump) this.begin(true);
+                this.timer = setTimeout(() => {
+                    this.timer = 0;
+                    this.begin();
+                }, delay / this.speed * 1e3);
+            } else this.begin();
         }
     }
     begin(seek) {
         this.playedTotalTime = this.time = 0;
         this.mainReverse ? this.setTo() : this.setFrom();
-        if (!seek) this.requestAnimate();
+        if (!seek) this.startRequestAnimate();
     }
     end() {
         this.mainReverse ? this.setFrom() : this.setTo();
@@ -17968,6 +18119,8 @@ __decorate([ animateAttr(true) ], Animate.prototype, "autoplay", void 0);
 
 __decorate([ animateAttr() ], Animate.prototype, "join", void 0);
 
+__decorate([ animateAttr() ], Animate.prototype, "jump", void 0);
+
 __decorate([ animateAttr() ], Animate.prototype, "attrs", void 0);
 
 Animate = __decorate([ useModule(LeafEventer) ], Animate);
@@ -18206,7 +18359,7 @@ const hslMatch = /^hsl\((\d+),\s*(\d+)%\s*,\s*(\d+)%/i;
 
 const hslaMatch = /^hsla\((\d+),\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d*\.?\d+)/i;
 
-const int = parseInt, float = parseFloat, {round: round$1} = Math;
+const int = parseInt, float$1 = parseFloat, {round: round$1} = Math;
 
 let cache = {}, totalCache = 0;
 
@@ -18319,18 +18472,18 @@ function rgbaToRGBA(color) {
         r: int(match[1]),
         g: int(match[2]),
         b: int(match[3]),
-        a: float(match[4])
+        a: float$1(match[4])
     };
 }
 
 function hslToRGBA(color) {
     const match = hslMatch.exec(color);
-    return hsla(float(match[1]), float(match[2]), float(match[3]), 1);
+    return hsla(float$1(match[1]), float$1(match[2]), float$1(match[3]), 1);
 }
 
 function hslaToRGBA(color) {
     const match = hslaMatch.exec(color);
-    return hsla(float(match[1]), float(match[2]), float(match[3]), float(match[4]));
+    return hsla(float$1(match[1]), float$1(match[2]), float$1(match[3]), float$1(match[4]));
 }
 
 const n1 = 1 / 6, n2 = .5, n3 = 2 / 3, n4 = 1 / 3;
@@ -18569,7 +18722,7 @@ const HighBezierHelper = {
 
 const {getDistance: getDistance} = HighBezierHelper;
 
-const {M: M, L: L, C: C, Z: Z} = PathCommandMap;
+const {M: M, L: L, C: C, Z: Z} = PathCommandMap, {float: float} = MathHelper;
 
 const tempPoint = {}, tempFrom = {};
 
@@ -18706,7 +18859,7 @@ const HighCurveHelper = {
     getDistancePath(distanceData, motionDistance, motionPrecision) {
         const {segments: segments, data: data} = distanceData, path = [];
         motionDistance = UnitConvert.number(motionDistance, distanceData.total);
-        let total = 0, distance, to = {};
+        let total = 0, distance, cutDistance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
         let x1, y1, x2, y2, t;
         const len = data.length;
@@ -18718,14 +18871,17 @@ const HighCurveHelper = {
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
-                if (total + distance >= motionDistance || !distanceData.total) {
+                if (total + distance > motionDistance || !distanceData.total) {
                     if (!i) x = toX, y = toY;
                     tempFrom.x = x;
                     tempFrom.y = y;
                     to.x = toX;
                     to.y = toY;
-                    PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
-                    path.push(command, to.x, to.y);
+                    cutDistance = float(motionDistance - total);
+                    if (cutDistance) {
+                        PointHelper.getDistancePoint(tempFrom, to, cutDistance, true);
+                        path.push(command, to.x, to.y);
+                    }
                     return path;
                 }
                 x = toX;
@@ -18739,9 +18895,12 @@ const HighCurveHelper = {
                 toX = data[i + 5];
                 toY = data[i + 6];
                 distance = segments[index];
-                if (total + distance >= motionDistance) {
-                    t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
-                    HighBezierHelper.cut(path, t, x, y, x1, y1, x2, y2, toX, toY);
+                if (total + distance > motionDistance) {
+                    cutDistance = float(motionDistance - total);
+                    if (cutDistance) {
+                        t = HighBezierHelper.getT(cutDistance, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
+                        HighBezierHelper.cut(path, t, x, y, x1, y1, x2, y2, toX, toY);
+                    }
                     return path;
                 }
                 x = toX;
@@ -19472,6 +19631,7 @@ class Finder {
         for (let i = 0, len = children.length; i < len; i++) {
             child = children[i];
             result = method(child, options);
+            if (typeof result === "boolean") result = result ? 1 : 0;
             if (result === Yes || result === YesAndSkip) {
                 if (list) {
                     list.push(child);
@@ -19815,4 +19975,4 @@ Plugin.add("bright");
 
 UI.addAttr("bright", false, dimType);
 
-export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, FourNumberHelper, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, MyTouchEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TouchEvent, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, dimType, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite$1 as isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, motionPathType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, scrollType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$2 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$3 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };
+export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, FourNumberHelper, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, MyTouchEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TouchEvent, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, dimType, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite$1 as isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, motionPathType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, scrollType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$2 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$4 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };