@leafer/miniapp 2.1.10 → 2.2.0

package/dist/miniapp.module.js

@@ -817,6 +817,11 @@ const PointHelper = {
     toOuterOf(t, matrix, to) {
         toOuterPoint$4(matrix, t, to);
     },
+    toVertical(t, rotation, verticalDistance, to) {
+        const r = rotation * OneRadian;
+        t.x += -Math.sin(r) * verticalDistance;
+        t.y += Math.cos(r) * verticalDistance;
+    },
     getCenter(t, to) {
         return {
             x: t.x + (to.x - t.x) / 2,
@@ -1256,7 +1261,6 @@ const BoundsHelper = {
     },
     copyAndSpread(t, bounds, spread, isShrink, side) {
         const {x: x, y: y, width: width, height: height} = bounds;
-        if (!spread) spread = 0;
         if (isArray(spread)) {
             const four = fourNumber$1(spread);
             isShrink ? B.set(t, x + four[3], y + four[0], width - four[1] - four[3], height - four[2] - four[0]) : B.set(t, x - four[3], y - four[0], width + four[1] + four[3], height + four[2] + four[0]);
@@ -3577,7 +3581,8 @@ const PathDrawer = {
                 return;
             }
         }
-    }
+    },
+    drawPathByPoints(_drawer, _points, _closed) {}
 };
 
 const {M: M$7, L: L$7, C: C$5, Q: Q$3, Z: Z$5, 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;
@@ -6985,7 +6990,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.1.10";
+const version = "2.2.0";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -8688,8 +8693,9 @@ let UI = UI_1 = class UI extends Leaf {
         this.__drawPathByData(canvas, data.__pathForRender);
     }
     __drawPath(canvas) {
+        const data = this.__;
         canvas.beginPath();
-        this.__drawPathByData(canvas, this.__.path, true);
+        data.__usePointsMode ? PathDrawer.drawPathByPoints(canvas, data.points, data.closed) : this.__drawPathByData(canvas, data.path, true);
     }
     __drawPathByData(drawer, data, ignoreCornerRadius) {
         data ? PathDrawer.drawPathByData(drawer, data) : this.__drawPathByBox(drawer, ignoreCornerRadius);
@@ -9546,6 +9552,9 @@ let Polygon = class Polygon extends UI {
     get __tag() {
         return "Polygon";
     }
+    get isPointsMode() {
+        return this.points && !this.pathInputed;
+    }
     __updatePath() {
         const data = this.__;
         const path = data.path = [];
@@ -9623,6 +9632,9 @@ let Line = class Line extends UI {
     get __tag() {
         return "Line";
     }
+    get isPointsMode() {
+        return this.points && !this.pathInputed;
+    }
     get toPoint() {
         const {width: width, rotation: rotation} = this.__;
         const to = getPointData();
@@ -9781,7 +9793,7 @@ let Text = class Text extends UI {
         data.__font = `${italic ? "italic " : ""}${textCase === "small-caps" ? "small-caps " : ""}${fontWeight !== "normal" ? fontWeight + " " : ""}${fontSize || 12}px ${fontFamily || "caption"}`;
         stintSet$3(data, "__padding", padding && MathHelper.fourNumber(padding));
         stintSet$3(data, "__clipText", textOverflow !== "show" && !data.__autoSize);
-        stintSet$3(data, "__isCharMode", width || height || data.__letterSpacing || textCase !== "none");
+        stintSet$3(data, "__isCharMode", width || height || data.__letterSpacing || data.motionText || textCase !== "none");
         data.__textDrawData = TextConvert.getDrawData((data.__isPlacehold = data.placeholder && data.text === "") ? data.placeholder : data.text, this.__);
     }
     __updateBoxBounds() {
@@ -9806,7 +9818,7 @@ let Text = class Text extends UI {
             this.__updateNaturalSize();
         } else super.__updateBoxBounds();
         if (italic) b.width += fontSize * .16;
-        DataHelper.stintSet(this, "isOverflow", !includes(b, contentBounds));
+        DataHelper.stintSet(this, "isOverflow", !includes(b, contentBounds) && !data.motionText);
         if (this.isOverflow) setList(data.__textBoxBounds = {}, [ b, contentBounds ]), layout.renderChanged = true; else data.__textBoxBounds = b;
     }
     __updateRenderSpread() {
@@ -11409,8 +11421,10 @@ ui$5.__hit = function(inner, forceHitFill) {
     if (!needHitFillPath && !needHitStrokePath) return false;
     const radiusWidth = inner.radiusX * 2;
     let hitWidth = radiusWidth;
+    let {strokeAlign: strokeAlign} = data;
+    if (data.motionText) hitWidth += data.fontSize / 2, strokeAlign = "center";
     if (needHitStrokePath) {
-        switch (data.strokeAlign) {
+        switch (strokeAlign) {
           case "inside":
             hitWidth += strokeWidth * 2;
             if (!needHitFillPath && this.__hitFill(inner) && this.__hitStroke(inner, hitWidth)) return true;
@@ -11444,9 +11458,9 @@ rect.__hitFill = box$3.__hitFill = function(inner) {
 };
 
 Text.prototype.__drawHitPath = function(canvas) {
-    const {__lineHeight: __lineHeight, fontSize: fontSize, __baseLine: __baseLine, __letterSpacing: __letterSpacing, __textDrawData: data} = this.__;
+    const data = this.__, {__lineHeight: __lineHeight, fontSize: fontSize, __baseLine: __baseLine, __letterSpacing: __letterSpacing, __textDrawData: drawData} = data;
     canvas.beginPath();
-    if (__letterSpacing < 0) this.__drawPathByBox(canvas); else data.rows.forEach(row => canvas.rect(row.x, row.y - __baseLine, row.width, __lineHeight < fontSize ? fontSize : __lineHeight));
+    if (data.motionText) this.__drawPathByData(canvas, data.__pathForMotionText); else if (__letterSpacing < 0) this.__drawPathByBox(canvas); else drawData.rows.forEach(row => canvas.rect(row.x, row.y - __baseLine, row.width, __lineHeight < fontSize ? fontSize : __lineHeight));
 };
 
 Group.prototype.pick = function(hitPoint, options) {
@@ -11633,7 +11647,8 @@ function fillPathOrText(ui, canvas, renderOptions) {
     ui.__.__font ? Paint.fillText(ui, canvas, renderOptions) : ui.__.windingRule ? canvas.fill(ui.__.windingRule) : canvas.fill();
 }
 
-function fillText(ui, canvas, _renderOptions) {
+function fillText(ui, canvas, renderOptions) {
+    if (ui.motionText) return Paint.fillMotionText(ui, canvas, renderOptions);
     const data = ui.__, {rows: rows, decorationY: decorationY} = data.__textDrawData;
     if (data.__isPlacehold && data.placeholderColor) canvas.fillStyle = data.placeholderColor;
     let row;
@@ -12995,7 +13010,8 @@ const TextMode = 2;
 
 function layoutChar(drawData, style, width, _height) {
     const {rows: rows} = drawData;
-    const {textAlign: textAlign, paraIndent: paraIndent, __letterSpacing: __letterSpacing} = style;
+    const {textAlign: textAlign, paraIndent: paraIndent} = style;
+    const useLetter = style.__letterSpacing || style.motionText;
     const justifyLast = width && textAlign.includes("both");
     const justify = justifyLast || width && textAlign.includes("justify");
     const justifyLetter = justify && textAlign.includes("letter");
@@ -13008,8 +13024,8 @@ function layoutChar(drawData, style, width, _height) {
                 remainingWidth = width - row.width - indentWidth;
                 if (justifyLetter) addLetterWidth = remainingWidth / (row.words.reduce((total, item) => total + item.data.length, 0) - 1); else addWordWidth = wordsLength > 1 ? remainingWidth / (wordsLength - 1) : 0;
             }
-            mode = __letterSpacing || row.isOverflow || justifyLetter ? CharMode : addWordWidth ? WordMode : TextMode;
-            if (row.isOverflow && !__letterSpacing) row.textMode = true;
+            mode = useLetter || row.isOverflow || justifyLetter ? CharMode : addWordWidth ? WordMode : TextMode;
+            if (row.isOverflow && !useLetter) row.textMode = true;
             if (mode === TextMode) {
                 row.x += indentWidth;
                 toTextChar$1(row);
@@ -13210,6 +13226,7 @@ function getDrawData$1(content, style) {
     let width = style.__getInput("width") || 0;
     let height = style.__getInput("height") || 0;
     const {__padding: padding} = style;
+    if (style.motionText) width = height = 0;
     if (padding) {
         if (width) x = padding[left$3], width -= padding[right$3] + padding[left$3], !width && (width = .01); else if (!style.autoSizeAlign) x = padding[left$3];
         if (height) y = padding[top$2], height -= padding[top$2] + padding[bottom$2], !height && (height = .01); else if (!style.autoSizeAlign) y = padding[top$2];
@@ -13783,17 +13800,16 @@ const {topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bot
 const {toPoint: toPoint} = AroundHelper, {within: within$3, sign: sign$1} = MathHelper, {abs: abs$4} = Math;
 
 const EditDataHelper = {
-    getScaleData(target, startBounds, direction, totalMoveOrScale, lockRatio, around, flipable, scaleMode, boundsType) {
+    getScaleData(target, startBounds, direction, totalMoveOrScale, lockRatio, around, flipable, scaleMode) {
         let align, origin = {}, scaleX = 1, scaleY = 1, lockScale;
         const {widthRange: widthRange, heightRange: heightRange, dragBounds: dragBounds, worldTransform: worldTransform, boxBounds: boxBounds} = target;
         const {width: width, height: height} = startBounds, worldScaleX = abs$4(worldTransform.scaleX), worldScaleY = abs$4(worldTransform.scaleY);
-        const innerBounds = target.getBounds(boundsType, "inner");
         const originChangedScaleX = target.scaleX / startBounds.scaleX;
         const originChangedScaleY = target.scaleY / startBounds.scaleY;
         const signX = sign$1(originChangedScaleX);
         const signY = sign$1(originChangedScaleY);
-        const changedScaleX = scaleMode ? originChangedScaleX : signX * innerBounds.width / width;
-        const changedScaleY = scaleMode ? originChangedScaleY : signY * innerBounds.height / height;
+        const changedScaleX = scaleMode ? originChangedScaleX : signX * boxBounds.width / width;
+        const changedScaleY = scaleMode ? originChangedScaleY : signY * boxBounds.height / height;
         if (isNumber(totalMoveOrScale)) {
             scaleX = scaleY = Math.sqrt(totalMoveOrScale);
         } else {
@@ -13878,11 +13894,10 @@ const EditDataHelper = {
         if (useScaleX) scaleX /= changedScaleX;
         if (useScaleY) scaleY /= changedScaleY;
         if (!flipable) {
-            if (scaleX < 0) scaleX = 1 / innerBounds.width / worldScaleX;
-            if (scaleY < 0) scaleY = 1 / innerBounds.height / worldScaleY;
+            if (scaleX < 0) scaleX = 1 / boxBounds.width / worldScaleX;
+            if (scaleY < 0) scaleY = 1 / boxBounds.height / worldScaleY;
         }
-        toPoint(around || align, innerBounds, origin, true);
-        this.checkOrigin(target, origin, boundsType);
+        toPoint(around || align, boxBounds, origin, true);
         if (dragBounds) {
             const scaleData = {
                 x: scaleX,
@@ -13893,19 +13908,15 @@ const EditDataHelper = {
             scaleY = scaleData.y;
         }
         if (useScaleX && widthRange) {
-            const nowWidth = innerBounds.width * target.scaleX;
+            const nowWidth = boxBounds.width * target.scaleX;
             scaleX = within$3(nowWidth * scaleX, widthRange) / nowWidth;
         }
         if (useScaleY && heightRange) {
-            const nowHeight = innerBounds.height * target.scaleY;
+            const nowHeight = boxBounds.height * target.scaleY;
             scaleY = within$3(nowHeight * scaleY, heightRange) / nowHeight;
         }
-        let minWidth = 1, minHeight = 1;
-        if (boundsType !== "box") {
-            minWidth += (innerBounds.width - boxBounds.width) * worldScaleX;
-            minHeight += (innerBounds.height - boxBounds.height) * worldScaleY;
-        }
-        const worldWidth = worldScaleX * innerBounds.width, worldHeight = worldScaleY * innerBounds.height;
+        const minWidth = 1, minHeight = 1;
+        const worldWidth = worldScaleX * boxBounds.width, worldHeight = worldScaleY * boxBounds.height;
         if (useScaleX && abs$4(scaleX * worldWidth) < minWidth) scaleX = sign$1(scaleX) * minWidth / worldWidth;
         if (useScaleY && abs$4(scaleY * worldHeight) < minHeight) scaleY = sign$1(scaleY) * minHeight / worldHeight;
         if (lockRatio && scaleX !== scaleY) {
@@ -13924,7 +13935,7 @@ const EditDataHelper = {
             around: around
         };
     },
-    getRotateData(target, direction, current, last, around, boundsType) {
+    getRotateData(target, direction, current, last, around) {
         let align, origin = {};
         switch (direction) {
           case topLeft$1:
@@ -13946,14 +13957,13 @@ const EditDataHelper = {
           default:
             align = "center";
         }
-        toPoint(around || align, target.getBounds(boundsType, "inner"), origin, true);
-        this.checkOrigin(target, origin, boundsType);
+        toPoint(around || align, target.boxBounds, origin, true);
         return {
             origin: origin,
             rotation: PointHelper.getRotation(last, target.getWorldPointByBox(origin), current)
         };
     },
-    getSkewData(target, direction, move, around, boundsType) {
+    getSkewData(target, direction, move, around) {
         let align, origin = {}, skewX = 0, skewY = 0;
         let last;
         switch (direction) {
@@ -13996,12 +14006,10 @@ const EditDataHelper = {
             align = "left";
             skewY = 1;
         }
-        const innerBounds = target.getBounds(boundsType, "inner");
-        const {width: width, height: height} = innerBounds;
+        const {boxBounds: boxBounds} = target, {width: width, height: height} = boxBounds;
         last.x = last.x * width;
         last.y = last.y * height;
-        toPoint(around || align, innerBounds, origin, true);
-        this.checkOrigin(target, origin, boundsType);
+        toPoint(around || align, boxBounds, origin, true);
         const rotation = PointHelper.getRotation(last, origin, {
             x: last.x + (skewX ? move.x : 0),
             y: last.y + (skewY ? move.y : 0)
@@ -14013,13 +14021,6 @@ const EditDataHelper = {
             skewY: skewY
         };
     },
-    checkOrigin(target, origin, boundsType) {
-        if (boundsType !== "box") {
-            const {boxBounds: boxBounds} = target, innerBounds = target.getBounds(boundsType, "inner");
-            origin.x += innerBounds.x - boxBounds.x;
-            origin.y += innerBounds.y - boxBounds.y;
-        }
-    },
     getAround(around, altKey) {
         return altKey && !around ? "center" : around;
     },
@@ -14314,9 +14315,14 @@ class EditBox extends Group {
         if (this.app) this.rect.syncEventer = this.app.interaction.bottomList = null;
     }
     updateBounds(bounds) {
-        const {editor: editor, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, buttons: buttons, resizePoints: resizePoints, rotatePoints: rotatePoints, resizeLines: resizeLines} = this;
+        const {editor: editor, target: target, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, buttons: buttons, resizePoints: resizePoints, rotatePoints: rotatePoints, resizeLines: resizeLines} = this;
         const {editMask: editMask} = editor;
         const {middlePoint: middlePoint, resizeable: resizeable, rotateable: rotateable, hideOnSmall: hideOnSmall, editBox: editBox, editBoxType: editBoxType, mask: mask, dimOthers: dimOthers, bright: bright, spread: spread, hideRotatePoints: hideRotatePoints, hideResizeLines: hideResizeLines} = mergeConfig;
+        if (editBoxType === "stroke") {
+            const {scaleX: scaleX, scaleY: scaleY} = target.worldTransform, {strokeBoxSpread: strokeBoxSpread} = target.__layout;
+            strokeBoxSpread && BoundsHelper.spread(bounds, [ strokeBoxSpread * Math.abs(scaleY), strokeBoxSpread * Math.abs(scaleX) ]);
+        }
+        if (spread) BoundsHelper.spread(bounds, spread);
         editMask.visible = mask ? true : 0;
         if (!isUndefined(dimOthers) || !isUndefined(bright)) {
             editor.setDimOthers(dimOthers);
@@ -14325,8 +14331,6 @@ class EditBox extends Group {
         } else if (editor.hasDimOthers) {
             editor.cancelDimOthers();
         }
-        if (editBoxType === "stroke") BoundsHelper.spread(bounds, this.target.__layout.strokeBoxSpread);
-        if (spread) BoundsHelper.spread(bounds, spread);
         if (this.view.worldOpacity) {
             const {width: width, height: height} = bounds;
             const smallSize = isNumber(hideOnSmall) ? hideOnSmall : 10;
@@ -14463,7 +14467,7 @@ class EditBox extends Group {
         this.dragPoint = null;
     }
     onTransformStart(e) {
-        const {hideOnMove: hideOnMove, editBoxType: editBoxType} = this.mergedConfig;
+        const {hideOnMove: hideOnMove} = this.mergedConfig;
         if (this.moving || this.gesturing) this.editor.opacity = hideOnMove ? 0 : 1;
         if (this.resizing) ResizeEvent.resizingKeys = this.editor.leafList.keys;
         const {dragStartData: dragStartData, target: target} = this;
@@ -14474,7 +14478,7 @@ class EditBox extends Group {
             x: target.x,
             y: target.y
         };
-        dragStartData.bounds = Object.assign({}, target.getLayoutBounds(editBoxType, "local"));
+        dragStartData.bounds = Object.assign({}, target.getLayoutBounds("box", "local"));
         dragStartData.rotation = target.rotation;
     }
     onTransformEnd(e) {
@@ -14847,6 +14851,9 @@ function registerEditTool() {
 const registerInnerEditor = registerEditTool;
 
 const EditToolCreator = {
+    EditTool: "EditTool",
+    LineEditTool: "LineEditTool",
+    PointsEditTool: "PointsEditTool",
     list: {},
     register(EditTool, name) {
         const {tag: tag} = EditTool.prototype;
@@ -15038,7 +15045,7 @@ class TransformTool {
     }
     onScale(e) {
         const {target: target, mergeConfig: mergeConfig, single: single, dragStartData: dragStartData} = this.editBox;
-        let {around: around, lockRatio: lockRatio, flipable: flipable, editSize: editSize, editBoxType: editBoxType} = mergeConfig, totalMove;
+        let {around: around, lockRatio: lockRatio, flipable: flipable, editSize: editSize} = mergeConfig, totalMove;
         if (e instanceof ZoomEvent) {
             if (!around) around = target.getBoxPoint(e);
             totalMove = e.totalScale;
@@ -15047,7 +15054,7 @@ class TransformTool {
         }
         const {direction: direction} = e.current;
         if (e.shiftKey || target.lockRatio) lockRatio = true;
-        const data = EditDataHelper.getScaleData(target, dragStartData.bounds, direction, totalMove, lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, !single || editSize === "scale", editBoxType);
+        const data = EditDataHelper.getScaleData(target, dragStartData.bounds, direction, totalMove, lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, !single || editSize === "scale");
         const targetX = target.x, targetY = target.y;
         if (e instanceof DragEvent && this.editTool && this.editTool.onScaleWithDrag) {
             data.drag = e;
@@ -15059,7 +15066,7 @@ class TransformTool {
     }
     onRotate(e) {
         const {target: target, mergeConfig: mergeConfig, dragStartData: dragStartData} = this.editBox;
-        const {around: around, rotateAround: rotateAround, rotateGap: rotateGap, diagonalRotateKey: diagonalRotateKey, editBoxType: editBoxType} = mergeConfig;
+        const {around: around, rotateAround: rotateAround, rotateGap: rotateGap, diagonalRotateKey: diagonalRotateKey} = mergeConfig;
         const {direction: direction} = e.current;
         let origin, rotation;
         if (e instanceof RotateEvent) {
@@ -15067,7 +15074,7 @@ class TransformTool {
             origin = rotateAround ? AroundHelper.getPoint(rotateAround, target.boxBounds) : target.getBoxPoint(e);
         } else {
             const isDiagonalRotate = diagonalRotateKey ? e.isHoldKeys(diagonalRotateKey) : e.shiftKey;
-            const data = EditDataHelper.getRotateData(target, direction, e, dragStartData, isDiagonalRotate ? null : rotateAround || target.around || target.origin || around || "center", editBoxType);
+            const data = EditDataHelper.getRotateData(target, direction, e, dragStartData, isDiagonalRotate ? null : rotateAround || target.around || target.origin || around || "center");
             rotation = dragStartData.rotation + data.rotation - target.rotation;
             origin = data.origin;
         }
@@ -15079,8 +15086,8 @@ class TransformTool {
     }
     onSkew(e) {
         const {target: target, mergeConfig: mergeConfig} = this.editBox;
-        const {around: around, editBoxType: editBoxType} = mergeConfig;
-        const {origin: origin, skewX: skewX, skewY: skewY} = EditDataHelper.getSkewData(target, e.current.direction, e.getInnerMove(target), EditDataHelper.getAround(around, e.altKey), editBoxType);
+        const {around: around} = mergeConfig;
+        const {origin: origin, skewX: skewX, skewY: skewY} = EditDataHelper.getSkewData(target, e.current.direction, e.getInnerMove(target), EditDataHelper.getAround(around, e.altKey));
         if (!skewX && !skewY) return;
         this.skewOf(origin, skewX, skewY);
     }
@@ -15141,7 +15148,7 @@ class TransformTool {
     scaleOf(origin, scaleX, scaleY = scaleX, _resize) {
         if (!this.checkTransform("resizeable")) return;
         const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-        const {beforeScale: beforeScale, editBoxType: editBoxType} = mergeConfig;
+        const {beforeScale: beforeScale} = mergeConfig;
         if (beforeScale) {
             const check = beforeScale({
                 target: target,
@@ -15159,8 +15166,7 @@ class TransformTool {
             worldOrigin: worldOrigin,
             scaleX: scaleX,
             scaleY: scaleY,
-            transform: transform,
-            editBoxType: editBoxType
+            transform: transform
         };
         this.emitEvent(new EditorScaleEvent(EditorScaleEvent.BEFORE_SCALE, data));
         const event = new EditorScaleEvent(EditorScaleEvent.SCALE, data);
@@ -15188,7 +15194,7 @@ class TransformTool {
     rotateOf(origin, rotation) {
         if (!this.checkTransform("rotateable")) return;
         const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-        const {beforeRotate: beforeRotate, editBoxType: editBoxType} = mergeConfig;
+        const {beforeRotate: beforeRotate} = mergeConfig;
         if (beforeRotate) {
             const check = beforeRotate({
                 target: target,
@@ -15204,8 +15210,7 @@ class TransformTool {
             editor: editor,
             worldOrigin: worldOrigin,
             rotation: rotation,
-            transform: transform,
-            editBoxType: editBoxType
+            transform: transform
         };
         this.emitEvent(new EditorRotateEvent(EditorRotateEvent.BEFORE_ROTATE, data));
         const event = new EditorRotateEvent(EditorRotateEvent.ROTATE, data);
@@ -15215,7 +15220,7 @@ class TransformTool {
     skewOf(origin, skewX, skewY = 0, _resize) {
         if (!this.checkTransform("skewable")) return;
         const {target: target, mergeConfig: mergeConfig, single: single, editor: editor} = this.editBox;
-        const {beforeSkew: beforeSkew, editBoxType: editBoxType} = mergeConfig;
+        const {beforeSkew: beforeSkew} = mergeConfig;
         if (beforeSkew) {
             const check = beforeSkew({
                 target: target,
@@ -15233,8 +15238,7 @@ class TransformTool {
             worldOrigin: worldOrigin,
             skewX: skewX,
             skewY: skewY,
-            transform: transform,
-            editBoxType: editBoxType
+            transform: transform
         };
         this.emitEvent(new EditorSkewEvent(EditorSkewEvent.BEFORE_SKEW, data));
         const event = new EditorSkewEvent(EditorSkewEvent.SKEW, data);
@@ -15690,32 +15694,32 @@ let EditTool = class EditTool extends InnerEditor {
         app.unlockLayout();
     }
     onScale(e) {
-        const {scaleX: scaleX, scaleY: scaleY, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
+        const {scaleX: scaleX, scaleY: scaleY, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
         const {app: app, list: list} = editor;
         app.lockLayout();
         list.forEach(target => {
             const resize = editor.getEditSize(target) !== "scale";
-            if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.scaleOfWorld(worldOrigin, scaleX, scaleY, resize, false, editBoxType);
+            if (transform) target.transformWorld(transform, resize, false); else target.scaleOfWorld(worldOrigin, scaleX, scaleY, resize, false);
         });
         app.unlockLayout();
     }
     onRotate(e) {
-        const {rotation: rotation, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
+        const {rotation: rotation, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
         const {app: app, list: list} = editor;
         app.lockLayout();
         list.forEach(target => {
             const resize = editor.getEditSize(target) !== "scale";
-            if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.rotateOfWorld(worldOrigin, rotation);
+            if (transform) target.transformWorld(transform, resize, false); else target.rotateOfWorld(worldOrigin, rotation);
         });
         app.unlockLayout();
     }
     onSkew(e) {
-        const {skewX: skewX, skewY: skewY, transform: transform, worldOrigin: worldOrigin, editor: editor, editBoxType: editBoxType} = e;
+        const {skewX: skewX, skewY: skewY, transform: transform, worldOrigin: worldOrigin, editor: editor} = e;
         const {app: app, list: list} = editor;
         app.lockLayout();
         list.forEach(target => {
             const resize = editor.getEditSize(target) !== "scale";
-            if (transform) target.transformWorld(transform, resize, false, editBoxType); else target.skewOfWorld(worldOrigin, skewX, skewY, resize);
+            if (transform) target.transformWorld(transform, resize, false); else target.skewOfWorld(worldOrigin, skewX, skewY, resize);
         });
         app.unlockLayout();
     }
@@ -16115,8 +16119,10 @@ UI.addAttr("editConfig", undefined, dataType);
 
 UI.addAttr("editOuter", ui => {
     ui.updateLayout();
-    const name = (ui.tag === "Line" || ui.pathInputed ? "" : ui.points ? "Points" : ui.tag) + "EditTool";
-    return ui.__.__isLinePath ? "LineEditTool" : EditToolCreator.list[name] ? name : "EditTool";
+    const {EditTool: EditTool, LineEditTool: LineEditTool, PointsEditTool: PointsEditTool} = EditToolCreator;
+    const name = ui.pathInputed || ui.isPointsMode ? PointsEditTool : ui.tag + "EditTool";
+    const hasTool = EditToolCreator.list[name];
+    return ui.__.__isLinePath && !(name == PointsEditTool && hasTool) ? LineEditTool : hasTool ? name : EditTool;
 }, dataType);
 
 UI.addAttr("editInner", "PathEditor", dataType);
@@ -19115,7 +19121,7 @@ const HighCurveHelper = {
     },
     getMotionPathData(data) {
         let total = 0, distance, segments = [];
-        let i = 0, x = 0, y = 0, toX, toY, command;
+        let i = 0, x = 0, y = 0, toX, toY, command, closed;
         const len = data.length;
         while (i < len) {
             command = data[i];
@@ -19140,6 +19146,7 @@ const HighCurveHelper = {
                 break;
 
               case Z$1:
+                closed = true;
                 i += 1;
 
               default:
@@ -19151,13 +19158,16 @@ const HighCurveHelper = {
         return {
             total: total,
             segments: segments,
-            data: data
+            data: data,
+            closed: closed
         };
     },
-    getDistancePoint(distanceData, motionDistance, motionPrecision) {
-        const {segments: segments, data: data} = distanceData;
-        motionDistance = UnitConvert.number(motionDistance, distanceData.total);
-        let total = 0, distance, to = {};
+    getDistancePoint(distanceData, motionDistance, motionPrecision, offsetX) {
+        const {segments: segments, data: data, total: total} = distanceData;
+        motionDistance = UnitConvert.number(motionDistance, total);
+        if (offsetX) motionDistance += offsetX;
+        if (motionDistance > total) motionDistance = motionDistance % total;
+        let nowDistance = 0, distance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
         let x1, y1, x2, y2, t;
         const len = data.length;
@@ -19169,15 +19179,20 @@ const HighCurveHelper = {
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
-                if (total + distance >= motionDistance || !distanceData.total) {
-                    if (!i) x = toX, y = toY;
-                    tempFrom.x = x;
-                    tempFrom.y = y;
+                if (nowDistance + distance >= motionDistance || !distanceData.total) {
                     to.x = toX;
                     to.y = toY;
-                    PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
-                    to.rotation = PointHelper.getAngle(tempFrom, to);
-                    return to;
+                    if (i) {
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        PointHelper.getDistancePoint(tempFrom, to, motionDistance - nowDistance, true);
+                        to.rotation = PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    } else {
+                        const nextPoint = HighCurveHelper.getDistancePoint(distanceData, motionPrecision, motionPrecision, offsetX);
+                        to.rotation = nextPoint.rotation;
+                        return to;
+                    }
                 }
                 x = toX;
                 y = toY;
@@ -19188,9 +19203,9 @@ const HighCurveHelper = {
                 toX = data[i + 5];
                 toY = data[i + 6];
                 distance = segments[index];
-                if (total + distance >= motionDistance) {
+                if (nowDistance + distance >= motionDistance) {
                     x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
-                    t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
+                    t = HighBezierHelper.getT(motionDistance - nowDistance, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
                     BezierHelper.getPointAndSet(t, x, y, x1, y1, x2, y2, toX, toY, to);
                     to.rotation = HighBezierHelper.getRotation(t, x, y, x1, y1, x2, y2, toX, toY);
                     return to;
@@ -19207,7 +19222,7 @@ const HighCurveHelper = {
                 distance = 0;
             }
             index++;
-            total += distance;
+            nowDistance += distance;
         }
         return to;
     },
@@ -19306,26 +19321,57 @@ const {updateMatrix: updateMatrix, updateAllMatrix: updateAllMatrix} = LeafHelpe
 
 const {updateBounds: updateBounds} = BranchHelper;
 
+const {toVertical: toVertical} = PointHelper;
+
 UI.addAttr("motionPath", undefined, motionPathType);
 
 UI.addAttr("motionPrecision", 1, motionPathType);
 
 UI.addAttr("motion", undefined, motionPathType);
 
+UI.addAttr("motionVertical", "below", motionPathType);
+
 UI.addAttr("motionRotation", true, motionPathType);
 
+ui$2.getMotionPath = function() {
+    return getMotionPath(this);
+};
+
 ui$2.getMotionPathData = function() {
     return getMotionPathData(getMotionPath(this));
 };
 
-ui$2.getMotionPoint = function(motionDistance) {
-    const path = getMotionPath(this);
-    const data = getMotionPathData(path);
+ui$2.getMotionContentHeight = function() {
+    return this.__layout.boxBounds.height;
+};
+
+ui$2.getMotionPoint = function(motionDistance, motionVertical, pathElement, offsetX = 0, offsetY = 0) {
+    if (!pathElement) pathElement = getMotionPath(this);
+    const data = getMotionPathData(pathElement);
     if (!data.total) return {};
-    const point = HighCurveHelper.getDistancePoint(data, motionDistance, path.motionPrecision);
-    MatrixHelper.toOuterPoint(path.localTransform, point);
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance, pathElement.motionPrecision, offsetX);
     const {motionRotation: motionRotation} = this;
-    if (motionRotation === false) delete point.rotation; else if (isNumber(motionRotation)) point.rotation += motionRotation;
+    if (isNumber(motionRotation)) point.rotation += motionRotation;
+    let verticalType, verticalOffset;
+    if (isObject(motionVertical)) verticalType = motionVertical.type, verticalOffset = motionVertical.offset; else if (isNumber(motionVertical)) verticalOffset = motionVertical; else verticalType = motionVertical;
+    if (verticalType !== "below" || offsetY) {
+        const {rotation: rotation} = point, height = this.getMotionContentHeight();
+        if (verticalOffset) offsetY += verticalType === "above" ? -verticalOffset : verticalOffset;
+        switch (verticalType) {
+          case "above":
+            toVertical(point, rotation, -height + offsetY);
+            break;
+
+          case "center":
+            toVertical(point, rotation, -height / 2 + offsetY);
+            break;
+
+          case "below":
+          default:
+            toVertical(point, rotation, offsetY);
+        }
+    }
+    MatrixHelper.toOuterPoint(pathElement.localTransform, point);
     return point;
 };
 
@@ -19357,7 +19403,11 @@ function updateMotion(leaf) {
         const data = getMotionPathData(leaf);
         if (data.total) leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion, leaf.motionPrecision);
     } else {
-        leaf.set(leaf.getMotionPoint(motion));
+        if (leaf.motionText) leaf.__updateMotionText(); else {
+            const point = leaf.getMotionPoint(motion);
+            if (leaf.motionRotation === false) delete point.rotation;
+            leaf.set(point);
+        }
         if (!leaf.__hasAutoLayout) {
             if (leaf.isBranch) updateAllMatrix(leaf), updateBounds(leaf, leaf); else updateMatrix(leaf);
         }
@@ -19379,7 +19429,8 @@ function getMotionPath(leaf) {
 function getMotionPathData(leaf) {
     const data = leaf.__;
     if (data.__pathForMotion) return data.__pathForMotion;
-    return data.__pathForMotion = HighCurveHelper.getMotionPathData(leaf.getPath(true, true));
+    const path = data.__pathForMotion = HighCurveHelper.getMotionPathData(leaf.getPath(true, true));
+    return path;
 }
 
 function stateType(defaultValue, styleName) {