@leafer/worker 1.12.0 → 1.12.2

package/dist/worker.js

@@ -199,7 +199,7 @@ var LeaferUI = function(exports) {
             this.__input = this.__middle = null;
         }
     }
-    const {floor: floor$3, max: max$6} = Math;
+    const {floor: floor$3, max: max$7} = Math;
     const Platform = {
         toURL(text, fileType) {
             let url = encodeURIComponent(text);
@@ -224,7 +224,7 @@ var LeaferUI = function(exports) {
                 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;
@@ -266,7 +266,7 @@ var LeaferUI = function(exports) {
     };
     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 ],
         tempFour: tempFour,
@@ -317,9 +317,9 @@ var LeaferUI = function(exports) {
             return data;
         },
         max(t, other, change) {
-            if (isNumber(t) && isNumber(other)) return max$5(t, other);
+            if (isNumber(t) && isNumber(other)) return max$6(t, other);
             toTempAB(t, other, change);
-            return set$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;
@@ -334,7 +334,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$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) {
             if (isObject(min)) max = min.max, min = min.min;
@@ -387,7 +387,7 @@ var LeaferUI = function(exports) {
             }
         },
         getFloorScale(num, min = 1) {
-            return max$4(floor$2(num), min) / num;
+            return max$5(floor$2(num), min) / num;
         },
         randInt: randInt,
         randColor(opacity) {
@@ -425,8 +425,8 @@ var LeaferUI = function(exports) {
         };
     }
     const {sin: sin$6, cos: cos$6, acos: acos, sqrt: sqrt$5} = Math;
-    const {float: float$3} = MathHelper;
-    const tempPoint$4 = {};
+    const {float: float$5} = MathHelper;
+    const tempPoint$5 = {};
     function getWorld() {
         return Object.assign(Object.assign(Object.assign({}, getMatrixData()), getBoundsData()), {
             scaleX: 1,
@@ -483,8 +483,8 @@ var LeaferUI = function(exports) {
             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);
@@ -502,8 +502,8 @@ var LeaferUI = function(exports) {
             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);
@@ -524,8 +524,8 @@ var LeaferUI = function(exports) {
             }
         },
         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);
@@ -673,12 +673,12 @@ var LeaferUI = function(exports) {
                     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;
@@ -720,8 +720,9 @@ var LeaferUI = function(exports) {
         }
     };
     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(),
         tempPoint: {},
@@ -769,22 +770,27 @@ var LeaferUI = function(exports) {
         },
         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);
@@ -818,7 +824,7 @@ var LeaferUI = function(exports) {
             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;
@@ -852,14 +858,14 @@ var LeaferUI = function(exports) {
             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);
         }
     };
     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) {
             this.set(x, y);
@@ -932,7 +938,7 @@ var LeaferUI = function(exports) {
             return this;
         }
     }
-    const tempPoint$3 = new Point;
+    const tempPoint$4 = new Point;
     class Matrix {
         constructor(a, b, c, d, e, f) {
             this.set(a, b, c, d, e, f);
@@ -1186,7 +1192,7 @@ var LeaferUI = function(exports) {
     };
     const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$5, addPoint: addPoint$3, toBounds: toBounds$3} = TwoPointBoundsHelper;
     const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
-    const {float: float$2, fourNumber: fourNumber$1} = MathHelper;
+    const {float: float$3, fourNumber: fourNumber$1} = MathHelper;
     const {floor: floor$1, ceil: ceil$2} = Math;
     let right$4, bottom$3, boundsRight, boundsBottom;
     const point$2 = {};
@@ -1245,7 +1251,7 @@ var LeaferUI = function(exports) {
             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);
@@ -1355,10 +1361,10 @@ var LeaferUI = function(exports) {
             }
         },
         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;
@@ -1392,7 +1398,7 @@ var LeaferUI = function(exports) {
                 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);
                     }
@@ -1477,7 +1483,7 @@ var LeaferUI = function(exports) {
         }
     };
     const B = BoundsHelper;
-    const {add: add$2, copy: copy$c} = B;
+    const {add: add$2, copy: copy$b} = B;
     class Bounds {
         get minX() {
             return BoundsHelper.minX(this);
@@ -2084,7 +2090,7 @@ var LeaferUI = function(exports) {
     __decorate([ contextMethod() ], Canvas.prototype, "fillText", null);
     __decorate([ contextMethod() ], Canvas.prototype, "measureText", null);
     __decorate([ contextMethod() ], Canvas.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,
         height: 1,
@@ -2241,7 +2247,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2252,7 +2258,7 @@ var LeaferUI = function(exports) {
             }
             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();
@@ -2265,7 +2271,7 @@ var LeaferUI = function(exports) {
                 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();
@@ -2335,7 +2341,7 @@ var LeaferUI = function(exports) {
         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;
@@ -2463,18 +2469,18 @@ var LeaferUI = function(exports) {
             data[0] ? drawer.arcTo(x, y, right, y, data[0]) : drawer.lineTo(x, y);
         }
     };
-    const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$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;
     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) {
             let points = toNumberPoints$1(originPoints);
             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] ];
@@ -2487,7 +2493,9 @@ var LeaferUI = function(exports) {
                     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;
@@ -2500,7 +2508,7 @@ var LeaferUI = function(exports) {
                     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;
@@ -2529,8 +2537,8 @@ var LeaferUI = function(exports) {
             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) {
@@ -2635,8 +2643,8 @@ var LeaferUI = function(exports) {
             addMode ? addPoint$2(pointBounds, fromX, fromY) : setPoint$4(pointBounds, fromX, fromY);
             addPoint$2(pointBounds, toX, toY);
             for (let i = 0, len = tList.length; i < len; i++) {
-                getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$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) {
@@ -3031,7 +3039,7 @@ var LeaferUI = function(exports) {
     const {current: current, pushData: pushData, copyData: copyData} = PathConvert;
     const {M: M$8, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F: F$5, O: O$5, P: P$4, U: U$4} = PathCommandMap;
     const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
-    const {tan: tan, min: min$1, abs: abs$8} = Math;
+    const {tan: tan, min: min$2, abs: abs$8} = Math;
     const startPoint = {};
     const PathCommandDataHelper = {
         beginPath(data) {
@@ -3068,6 +3076,7 @@ var LeaferUI = function(exports) {
             }
         },
         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 {
@@ -3080,6 +3089,7 @@ var LeaferUI = function(exports) {
             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);
             }
@@ -3087,7 +3097,7 @@ var LeaferUI = function(exports) {
         arcTo(data, x1, y1, x2, y2, radius, lastX, lastY) {
             if (!isUndefined(lastX)) {
                 const d = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2);
-                radius = min$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);
         },
@@ -3280,7 +3290,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 {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");
     let radius, radiusX, radiusY;
     const tempPointBounds = {};
@@ -3356,7 +3366,7 @@ var LeaferUI = function(exports) {
 
                   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;
@@ -3374,7 +3384,7 @@ var LeaferUI = function(exports) {
 
                   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;
@@ -3391,7 +3401,7 @@ var LeaferUI = function(exports) {
 
                   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;
@@ -3411,6 +3421,7 @@ var LeaferUI = function(exports) {
         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) {
@@ -3808,7 +3819,9 @@ var LeaferUI = function(exports) {
     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));
@@ -4338,7 +4351,7 @@ var LeaferUI = function(exports) {
             EventCreator.register(target);
         };
     }
-    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;
     const LeafHelper = {
         updateAllMatrix(leaf, checkAutoLayout, waitAutoLayout) {
@@ -4434,7 +4447,7 @@ var LeaferUI = function(exports) {
                 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);
@@ -4453,7 +4466,7 @@ var LeaferUI = function(exports) {
         },
         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,
@@ -4465,18 +4478,18 @@ var LeaferUI = function(exports) {
             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);
         },
@@ -4514,7 +4527,7 @@ var LeaferUI = function(exports) {
             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);
         },
@@ -4652,9 +4665,52 @@ var LeaferUI = function(exports) {
                 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) {
             if (wait && wait.length) {
@@ -4667,7 +4723,7 @@ var LeaferUI = function(exports) {
         }
     };
     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";
     const worldContent = "_worldContentBounds", worldBox = "_worldBoxBounds", worldStroke = "_worldStrokeBounds";
     class LeafLayout {
@@ -4903,7 +4959,7 @@ var LeaferUI = function(exports) {
                 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;
@@ -5448,7 +5504,7 @@ var LeaferUI = function(exports) {
         }
     };
     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() {
             const {parent: parent, __layout: __layout, __world: __world, __scrollWorld: __scrollWorld, __: __} = this;
@@ -5467,8 +5523,8 @@ var LeaferUI = function(exports) {
                 local.e = data.x + data.offsetX;
                 local.f = data.y + data.offsetY;
                 if (data.around || data.origin) {
-                    toPoint$4(data.around || data.origin, layout.boxBounds, tempPoint$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;
@@ -5476,7 +5532,7 @@ 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$7} = BoundsHelper;
+    const {toOuterOf: toOuterOf$2, copyAndSpread: copyAndSpread$3, copy: copy$6} = BoundsHelper;
     const {toBounds: toBounds$1} = PathBounds;
     const LeafBounds = {
         __updateWorldBounds() {
@@ -5585,7 +5641,7 @@ var LeaferUI = function(exports) {
         },
         __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);
         }
     };
     const LeafRender = {
@@ -5681,7 +5737,7 @@ var LeaferUI = function(exports) {
     const {stintSet: stintSet$4} = DataHelper;
     const {toInnerPoint: toInnerPoint, toOuterPoint: toOuterPoint, multiplyParent: multiplyParent$1} = MatrixHelper;
     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;
     exports.Leaf = class Leaf {
         get tag() {
@@ -5998,14 +6054,14 @@ var LeaferUI = function(exports) {
             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) {
@@ -6118,10 +6174,10 @@ var LeaferUI = function(exports) {
         hit(_world, _hitRadius) {
             return true;
         }
-        __hitWorld(_point) {
+        __hitWorld(_point, _forceHitFill) {
             return true;
         }
-        __hit(_local) {
+        __hit(_local, _forceHitFill) {
             return true;
         }
         __hitFill(_inner) {
@@ -6470,7 +6526,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "1.12.0";
+    const version = "1.12.2";
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() {
             return true;
@@ -7090,6 +7146,8 @@ var LeaferUI = function(exports) {
         }
     }
     Renderer.clipSpread = 10;
+    const tempPoint$1 = {};
+    const {copyRadiusPoint: copyRadiusPoint$1} = PointHelper;
     const {hitRadiusPoint: hitRadiusPoint$1} = BoundsHelper;
     class Picker {
         constructor(target, selector) {
@@ -7215,15 +7273,15 @@ var LeaferUI = function(exports) {
             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);
@@ -7667,7 +7725,7 @@ var LeaferUI = function(exports) {
             return data;
         }
     }
-    const {max: max$3, add: add$1} = FourNumberHelper;
+    const {max: max$4, add: add$1} = FourNumberHelper;
     const UIBounds = {
         __updateStrokeSpread() {
             let spread = 0, boxSpread = 0;
@@ -7682,7 +7740,7 @@ var LeaferUI = function(exports) {
             }
             if (data.__useArrow) spread += strokeWidth * 5;
             if (box) {
-                spread = max$3(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
+                spread = max$4(spread, box.__layout.strokeSpread = box.__updateStrokeSpread());
                 boxSpread = Math.max(boxSpread, box.__layout.strokeBoxSpread);
             }
             this.__layout.strokeBoxSpread = boxSpread;
@@ -7692,15 +7750,15 @@ var LeaferUI = function(exports) {
             let spread = 0;
             const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = this.__, {strokeSpread: strokeSpread} = this.__layout, box = this.__box;
             if (shadow) spread = Effect.getShadowRenderSpread(this, shadow);
-            if (blur) spread = max$3(spread, blur);
+            if (blur) spread = max$4(spread, blur);
             if (filter) spread = add$1(spread, Filter.getSpread(filter));
             if (renderSpread) spread = add$1(spread, renderSpread);
             if (strokeSpread) spread = add$1(spread, strokeSpread);
             let shapeSpread = spread;
-            if (innerShadow) shapeSpread = max$3(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
-            if (backgroundBlur) shapeSpread = max$3(shapeSpread, backgroundBlur);
+            if (innerShadow) shapeSpread = max$4(shapeSpread, Effect.getInnerShadowSpread(this, innerShadow));
+            if (backgroundBlur) shapeSpread = max$4(shapeSpread, backgroundBlur);
             this.__layout.renderShapeSpread = shapeSpread;
-            return box ? max$3(box.__updateRenderSpread(), spread) : spread;
+            return box ? max$4(box.__updateRenderSpread(), spread) : spread;
         }
     };
     const {stintSet: stintSet$2} = DataHelper;
@@ -7754,7 +7812,7 @@ var LeaferUI = function(exports) {
                     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) {
@@ -7874,7 +7932,7 @@ var LeaferUI = function(exports) {
         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) {
@@ -7902,17 +7960,18 @@ var LeaferUI = function(exports) {
         }
         __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);
@@ -8099,6 +8158,9 @@ var LeaferUI = function(exports) {
         get layoutLocked() {
             return !this.layouter.running;
         }
+        get view() {
+            return this.canvas && this.canvas.view;
+        }
         get FPS() {
             return this.renderer ? this.renderer.FPS : 60;
         }
@@ -8150,7 +8212,6 @@ var LeaferUI = function(exports) {
             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);
@@ -8430,7 +8491,7 @@ var LeaferUI = function(exports) {
                             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(() => {
@@ -8582,7 +8643,6 @@ var LeaferUI = function(exports) {
                 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);
@@ -8590,16 +8650,16 @@ var LeaferUI = function(exports) {
                     }
                     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);
         }
     };
     __decorate([ dataProcessor(EllipseData) ], exports.Ellipse.prototype, "__", void 0);
@@ -9160,7 +9220,7 @@ var LeaferUI = function(exports) {
             EventCreator.changeName(oldName, newName);
         }
     }
-    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;
     const DragBoundsHelper = {
         limitMove(leaf, move) {
@@ -9198,8 +9258,8 @@ var LeaferUI = function(exports) {
             } 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) {
@@ -9211,44 +9271,44 @@ var LeaferUI = function(exports) {
             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;
@@ -9354,6 +9414,7 @@ var LeaferUI = function(exports) {
     exports.MoveEvent.BEFORE_MOVE = "move.before_move";
     exports.MoveEvent.START = "move.start";
     exports.MoveEvent.MOVE = "move";
+    exports.MoveEvent.DRAG_ANIMATE = "move.drag_animate";
     exports.MoveEvent.END = "move.end";
     exports.MoveEvent = __decorate([ registerUIEvent() ], exports.MoveEvent);
     exports.TouchEvent = class TouchEvent extends UIEvent {};
@@ -9421,6 +9482,7 @@ var LeaferUI = function(exports) {
                 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
             };
@@ -9452,6 +9514,7 @@ var LeaferUI = function(exports) {
     const {getDragEventData: getDragEventData, getDropEventData: getDropEventData, getSwipeEventData: getSwipeEventData} = InteractionHelper;
     class Dragger {
         constructor(interaction) {
+            this.dragDataList = [];
             this.interaction = interaction;
         }
         setDragData(data) {
@@ -9514,6 +9577,7 @@ var LeaferUI = function(exports) {
             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";
@@ -9564,9 +9628,9 @@ var LeaferUI = function(exports) {
             interaction.emit(exports.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) {
@@ -9608,11 +9672,13 @@ var LeaferUI = function(exports) {
         }
         dragReset() {
             exports.DragEvent.list = exports.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() {}
@@ -9997,6 +10063,9 @@ var LeaferUI = function(exports) {
                 this.pointerHover(hoverData);
             }
         }
+        stopDragAnimate() {
+            this.dragger.stopAnimate();
+        }
         updateDownData(data, options, merge) {
             const {downData: downData} = this;
             if (!data && downData) data = downData;
@@ -10175,28 +10244,27 @@ var LeaferUI = function(exports) {
     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;
     const inner = {}, worldRadiusPoint = {};
     const leaf$1 = exports.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, {
             target: this
         }) : 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) {
@@ -10207,7 +10275,7 @@ var LeaferUI = function(exports) {
             this.__updateHitCanvas();
             if (!layout.boundsChanged) layout.hitCanvasChanged = false;
         }
-        return this.__hit(inner);
+        return this.__hit(inner, forceHitFill);
     };
     leaf$1.__hitFill = function(inner) {
         const h = this.__hitCanvas;
@@ -10266,12 +10334,12 @@ var LeaferUI = function(exports) {
         this.__drawHitPath(h);
         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";
@@ -10938,10 +11006,12 @@ var LeaferUI = function(exports) {
     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);
+            });
         }
     }
     function createPattern(paint, ui, canvas, renderOptions) {
@@ -11165,7 +11235,7 @@ var LeaferUI = function(exports) {
         conicGradient: conicGradient,
         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;
     const offsetOutBounds$1 = {};
     function shadow$1(ui, current, shape) {
@@ -11206,10 +11276,10 @@ var LeaferUI = function(exports) {
         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 ];
     }
@@ -11996,7 +12066,11 @@ var LeaferUI = function(exports) {
                         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);
@@ -12011,6 +12085,7 @@ var LeaferUI = function(exports) {
         }
     }
     __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 ] : [];
@@ -12120,10 +12195,11 @@ var LeaferUI = function(exports) {
         }
         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) {
@@ -13449,7 +13525,7 @@ var LeaferUI = function(exports) {
             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 exports.ZoomEvent) {
-                around = target.getBoxPoint(e);
+                if (!around) around = target.getBoxPoint(e);
                 totalMove = e.totalScale;
             } else {
                 totalMove = e.getInnerTotal(target);
@@ -14706,7 +14782,11 @@ var LeaferUI = function(exports) {
         addViewportConfig(leafer.parentApp ? leafer.parentApp : leafer, mergeConfig);
         if (leafer.isApp || custom) return;
         leafer.__eventIds.push(leafer.on_(exports.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_(exports.MoveEvent.DRAG_ANIMATE, () => {
+            const move = leafer.getValidMove(0, 0);
+            if (move.x || move.y) leafer.interaction.stopDragAnimate();
         }), leafer.on_(exports.MoveEvent.END, e => {
             LeafHelper.animateMove(leafer.zoomLayer, leafer.getValidMove(e.moveX, e.moveY));
         }), leafer.on_(exports.ZoomEvent.BEFORE_ZOOM, e => {
@@ -14843,7 +14923,7 @@ var LeaferUI = function(exports) {
         }
     };
     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) {
             let {moveSpeed: moveSpeed} = config;
@@ -14853,8 +14933,8 @@ var LeaferUI = function(exports) {
                 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
@@ -14998,7 +15078,7 @@ var LeaferUI = function(exports) {
             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;
             }
         }
@@ -15092,21 +15172,51 @@ var LeaferUI = function(exports) {
         if (moving) this.move(getMoveEventData(gestureData.move, data));
     };
     const dragger = Dragger.prototype;
-    const {abs: abs$1} = 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;
+    const {abs: abs$1, min: min, max: max, hypot: hypot} = Math;
+    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(exports.MoveEvent.DRAG_ANIMATE, data);
+            };
+            this.animate(step);
         }
         return dragAnimate;
     };
@@ -15115,6 +15225,12 @@ var LeaferUI = function(exports) {
         if (animateWait) this.interaction.target.nextRender(animateWait, null, 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();
@@ -15179,7 +15295,6 @@ var LeaferUI = function(exports) {
     }
     Plugin.add("view");
     exports.Leafer.prototype.zoom = function(zoomType, optionsOrPadding, scroll, transition) {
-        this.killAnimate();
         let padding;
         if (isData(optionsOrPadding)) {
             padding = optionsOrPadding.padding;
@@ -15192,8 +15307,9 @@ var LeaferUI = function(exports) {
             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":
@@ -15205,16 +15321,16 @@ var LeaferUI = function(exports) {
                 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;
             }
@@ -16481,6 +16597,8 @@ var LeaferUI = function(exports) {
         }
         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;
@@ -16527,7 +16645,7 @@ var LeaferUI = function(exports) {
         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() {
@@ -16541,14 +16659,28 @@ var LeaferUI = function(exports) {
             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) {
@@ -16631,14 +16763,24 @@ var LeaferUI = function(exports) {
                 }
             }
         }
-        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) {
@@ -16679,21 +16821,24 @@ var LeaferUI = function(exports) {
         }
         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();
@@ -16797,6 +16942,7 @@ var LeaferUI = function(exports) {
     __decorate([ animateAttr(1) ], exports.Animate.prototype, "speed", void 0);
     __decorate([ animateAttr(true) ], exports.Animate.prototype, "autoplay", void 0);
     __decorate([ animateAttr() ], exports.Animate.prototype, "join", void 0);
+    __decorate([ animateAttr() ], exports.Animate.prototype, "jump", void 0);
     __decorate([ animateAttr() ], exports.Animate.prototype, "attrs", void 0);
     exports.Animate = __decorate([ useModule(LeafEventer) ], exports.Animate);
     exports.AnimateList = class AnimateList extends exports.Animate {
@@ -17026,7 +17172,7 @@ var LeaferUI = function(exports) {
     const rgbaMatch = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d*\.?\d+)/i;
     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;
     function colorToRGBA(color, opacity) {
         let RGBA;
@@ -17134,16 +17280,16 @@ var LeaferUI = function(exports) {
             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;
     function hue(p, q, t) {
@@ -17346,7 +17492,7 @@ var LeaferUI = function(exports) {
         }
     };
     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 = {};
     const HighCurveHelper = {
         transform(data, matrix) {
@@ -17481,7 +17627,7 @@ var LeaferUI = function(exports) {
         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;
@@ -17493,14 +17639,17 @@ var LeaferUI = function(exports) {
                     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;
@@ -17514,9 +17663,12 @@ var LeaferUI = function(exports) {
                     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;
@@ -18159,6 +18311,7 @@ var LeaferUI = function(exports) {
             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);
@@ -18704,7 +18857,7 @@ var LeaferUI = function(exports) {
     exports.surfaceType = surfaceType;
     exports.tempBounds = tempBounds$2;
     exports.tempMatrix = tempMatrix$2;
-    exports.tempPoint = tempPoint$3;
+    exports.tempPoint = tempPoint$4;
     exports.tryToNumber = tryToNumber;
     exports.useCanvas = useCanvas;
     exports.useModule = useModule;