@leafer/worker 2.0.7 → 2.0.9

package/dist/worker.module.js

@@ -774,7 +774,7 @@ const {float: float$5} = 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$3, round: round$5} = Math;
+const {sin: sin$5, cos: cos$5, abs: abs$b, sqrt: sqrt$4, atan2: atan2$2, min: min$3, round: round$5} = Math;
 
 const PointHelper = {
     defaultPoint: getPointData(),
@@ -872,8 +872,8 @@ const PointHelper = {
         return getDistanceFrom(t.x, t.y, point.x, point.y);
     },
     getDistanceFrom(x1, y1, x2, y2) {
-        const x = abs$a(x2 - x1);
-        const y = abs$a(y2 - y1);
+        const x = abs$b(x2 - x1);
+        const y = abs$b(y2 - y1);
         return sqrt$4(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
@@ -2700,7 +2700,7 @@ const RectHelper = {
     }
 };
 
-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 {sin: sin$4, cos: cos$4, hypot: hypot$1, atan2: atan2$1, ceil: ceil$1, abs: abs$a, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
 
 const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
 
@@ -2777,7 +2777,7 @@ const BezierHelper = {
         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) {
+        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$a(totalRadian - PI$3) < 1e-12) {
             if (data) data.push(L$b, x1, y1);
             if (setPointBounds) {
                 setPoint$4(setPointBounds, fromX, fromY);
@@ -2810,7 +2810,7 @@ const BezierHelper = {
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2; else if (totalRadian > PI2) totalRadian -= PI2;
         if (anticlockwise) totalRadian -= PI2;
-        const parts = ceil$1(abs$9(totalRadian / PI_2));
+        const parts = ceil$1(abs$a(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$4(partRadian / 4);
         const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin$4(partRadian / 2);
@@ -3316,7 +3316,7 @@ const {M: M$9, L: L$9, C: C$7, Q: Q$5, Z: Z$7, N: N$4, D: D$5, X: X$4, G: G$4, F
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
-const {tan: tan, min: min$2, abs: abs$8} = Math;
+const {tan: tan, min: min$2, abs: abs$9} = Math;
 
 const startPoint = {};
 
@@ -3376,7 +3376,7 @@ const PathCommandDataHelper = {
     arcTo(data, x1, y1, x2, y2, radius, lastX, lastY, fullRadius) {
         if (!isUndefined(lastX)) {
             const r = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2) / (fullRadius ? 1 : 2);
-            radius = min$2(radius, min$2(r, r * abs$8(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
+            radius = min$2(radius, min$2(r, r * abs$9(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
         data.push(U$4, x1, y1, x2, y2, radius);
     },
@@ -7079,7 +7079,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.0.7";
+const version = "2.0.9";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -9470,11 +9470,16 @@ let Polygon = class Polygon extends UI {
         if (data.points) {
             drawPoints$1(path, data.points, data.curve, data.closed);
         } else {
-            const {width: width, height: height, sides: sides} = data;
+            const {width: width, height: height, sides: sides, startAngle: startAngle} = data;
             const rx = width / 2, ry = height / 2;
-            moveTo$2(path, rx, 0);
+            let startRadian = 0, radian;
+            if (startAngle) {
+                startRadian = startAngle * OneRadian;
+                moveTo$2(path, rx + rx * sin$2(startRadian), ry - ry * cos$2(startRadian));
+            } else moveTo$2(path, rx, 0);
             for (let i = 1; i < sides; i++) {
-                lineTo$2(path, rx + rx * sin$2(i * 2 * PI$2 / sides), ry - ry * cos$2(i * 2 * PI$2 / sides));
+                radian = i * 2 * PI$2 / sides + startRadian;
+                lineTo$2(path, rx + rx * sin$2(radian), ry - ry * cos$2(radian));
             }
             closePath$1(path);
         }
@@ -9485,6 +9490,8 @@ __decorate([ dataProcessor(PolygonData) ], Polygon.prototype, "__", void 0);
 
 __decorate([ pathType(3) ], Polygon.prototype, "sides", void 0);
 
+__decorate([ pathType(0) ], Polygon.prototype, "startAngle", void 0);
+
 __decorate([ pathType() ], Polygon.prototype, "points", void 0);
 
 __decorate([ pathType(0) ], Polygon.prototype, "curve", void 0);
@@ -9500,12 +9507,17 @@ let Star = class Star extends UI {
         return "Star";
     }
     __updatePath() {
-        const {width: width, height: height, corners: corners, innerRadius: innerRadius} = this.__;
+        const {width: width, height: height, corners: corners, innerRadius: innerRadius, startAngle: startAngle} = this.__;
         const rx = width / 2, ry = height / 2;
         const path = this.__.path = [];
-        moveTo$1(path, rx, 0);
+        let startRadian = 0, radian;
+        if (startAngle) {
+            startRadian = startAngle * OneRadian;
+            moveTo$1(path, rx + rx * sin$1(startRadian), ry - ry * cos$1(startRadian));
+        } else moveTo$1(path, rx, 0);
         for (let i = 1; i < corners * 2; i++) {
-            lineTo$1(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin$1(i * PI$1 / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos$1(i * PI$1 / corners));
+            radian = i * PI$1 / corners + startRadian;
+            lineTo$1(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin$1(radian), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos$1(radian));
         }
         closePath(path);
     }
@@ -9517,6 +9529,8 @@ __decorate([ pathType(5) ], Star.prototype, "corners", void 0);
 
 __decorate([ pathType(.382) ], Star.prototype, "innerRadius", void 0);
 
+__decorate([ pathType(0) ], Star.prototype, "startAngle", void 0);
+
 Star = __decorate([ registerUI() ], Star);
 
 const {moveTo: moveTo, lineTo: lineTo, drawPoints: drawPoints} = PathCommandDataHelper;
@@ -9875,7 +9889,8 @@ let Pen = class Pen extends Group {
         return this;
     }
     paint() {
-        if (!this.pathElement.__layout.boxChanged) this.pathElement.forceUpdate("path");
+        const {pathElement: pathElement} = this;
+        if (!pathElement.__layout.boxChanged) pathElement.forceUpdate("path");
     }
 };
 
@@ -10093,7 +10108,7 @@ class UIEvent extends Event {
     }
 }
 
-const {min: min$1, max: max$3, abs: abs$7} = Math, {float: float$3, sign: sign$2} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
+const {min: min$1, max: max$3, abs: abs$8} = Math, {float: float$3, sign: sign$2} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
 
 const tempContent = new Bounds, tempDragBounds = new Bounds;
 
@@ -10117,7 +10132,7 @@ const DragBoundsHelper = {
         return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
     },
     isInnerMode(content, dragBounds, dragBoundsType, sideType) {
-        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > dragBounds[sideType];
+        return dragBoundsType === "inner" || dragBoundsType === "auto" && float$3(content[sideType]) > float$3(dragBounds[sideType]);
     },
     getValidMove(content, dragBounds, dragBoundsType, move, change) {
         const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height;
@@ -10170,7 +10185,7 @@ const DragBoundsHelper = {
             bScale = originBottomScale && bSize > 0 ? 1 + bSize / (originBottomScale * tempContent.height) : 1;
             correctScaleY *= max$3(aScale, bScale);
             if (lockRatio) {
-                aScale = max$3(abs$7(correctScaleX), abs$7(correctScaleY));
+                aScale = max$3(abs$8(correctScaleX), abs$8(correctScaleY));
                 correctScaleX = sign$2(correctScaleX) * aScale;
                 correctScaleY = sign$2(correctScaleY) * aScale;
             }
@@ -11475,6 +11490,8 @@ function stroke(stroke, ui, canvas, renderOptions) {
     if (!data.__strokeWidth) return;
     if (data.__font) {
         Paint.strokeText(stroke, ui, canvas, renderOptions);
+    } else if (data.__pathForStroke) {
+        Paint.fillStroke(stroke, ui, canvas, renderOptions);
     } else {
         switch (data.strokeAlign) {
           case "center":
@@ -11771,12 +11788,12 @@ const PaintModule = {
 
 let cache$1, box$2 = new Bounds;
 
-const {isSame: isSame$1} = BoundsHelper;
+const {isSame: isSame$2} = BoundsHelper;
 
 function image(ui, attrName, paint, boxBounds, firstUse) {
     let leafPaint, event;
     const image = ImageManager.get(paint, paint.type);
-    if (cache$1 && paint === cache$1.paint && isSame$1(boxBounds, cache$1.boxBounds)) {
+    if (cache$1 && paint === cache$1.paint && isSame$2(boxBounds, cache$1.boxBounds)) {
         leafPaint = cache$1.leafPaint;
     } else {
         leafPaint = {
@@ -12067,7 +12084,7 @@ function layout$3(transform, box, x, y, scaleX, scaleY, rotation, skew) {
 
 const {get: get$1, scale: scale$2, copy: copy$4} = MatrixHelper;
 
-const {getFloorScale: getFloorScale} = MathHelper, {abs: abs$6} = Math;
+const {getFloorScale: getFloorScale} = MathHelper, {abs: abs$7} = Math;
 
 function createPatternTask(paint, ui, canvas, renderOptions) {
     if (!paint.patternTask) {
@@ -12091,8 +12108,8 @@ function createPattern(paint, ui, canvas, renderOptions) {
             width *= scaleX;
             height *= scaleY;
             if (gap) {
-                xGap = gap.x * scaleX / abs$6(data.scaleX || 1);
-                yGap = gap.y * scaleY / abs$6(data.scaleY || 1);
+                xGap = gap.x * scaleX / abs$7(data.scaleX || 1);
+                yGap = gap.y * scaleY / abs$7(data.scaleY || 1);
             }
             if (transform || scaleX !== 1 || scaleY !== 1) {
                 scaleX *= getFloorScale(width + (xGap || 0));
@@ -12329,7 +12346,7 @@ const PaintGradientModule = {
     getTransform: getTransform
 };
 
-const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$2, abs: abs$5} = Math;
+const {copy: copy$3, move: move$6, toOffsetOutBounds: toOffsetOutBounds$1} = BoundsHelper, {max: max$2, abs: abs$6} = Math;
 
 const tempBounds$1 = {}, tempMatrix = new Matrix;
 
@@ -12373,7 +12390,7 @@ function shadow$1(ui, current, shape) {
 function getShadowRenderSpread(_ui, shadow) {
     let top = 0, right = 0, bottom = 0, left = 0, x, y, spread, blur;
     shadow.forEach(item => {
-        x = item.x || 0, y = item.y || 0, blur = (item.blur || 0) * 1.5, spread = abs$5(item.spread || 0);
+        x = item.x || 0, y = item.y || 0, blur = (item.blur || 0) * 1.5, spread = abs$6(item.spread || 0);
         top = max$2(top, spread + blur - y);
         right = max$2(right, spread + blur + x);
         bottom = max$2(bottom, spread + blur + y);
@@ -13208,7 +13225,7 @@ function mergeConfigAttr() {
     };
 }
 
-const {abs: abs$4} = Math;
+const {abs: abs$5} = Math;
 
 const {copy: copy$2} = MatrixHelper;
 
@@ -13251,7 +13268,7 @@ class Stroker extends UI {
                 leaf = list[i];
                 const {worldTransform: worldTransform, worldRenderBounds: worldRenderBounds} = leaf;
                 if (worldRenderBounds.width && worldRenderBounds.height && (!bounds || bounds.hit(worldRenderBounds, options.matrix))) {
-                    const aScaleX = abs$4(worldTransform.scaleX), aScaleY = abs$4(worldTransform.scaleY);
+                    const aScaleX = abs$5(worldTransform.scaleX), aScaleY = abs$5(worldTransform.scaleY);
                     copy$2(matrix$1, worldTransform);
                     matrix$1.half = strokeWidth % 2;
                     canvas.setWorld(matrix$1, options.matrix);
@@ -13564,7 +13581,7 @@ class EditSelect extends Group {
 
 const {topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bottomRight: bottomRight, bottom: bottom$1, bottomLeft: bottomLeft, left: left$2} = Direction9;
 
-const {toPoint: toPoint} = AroundHelper, {within: within$3, sign: sign$1} = MathHelper, {abs: abs$3} = Math;
+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) {
@@ -13650,7 +13667,7 @@ const EditDataHelper = {
                         break;
 
                       default:
-                        lockScale = Math.sqrt(abs$3(scaleX * scaleY));
+                        lockScale = Math.sqrt(abs$4(scaleX * scaleY));
                         scaleX = sign$1(scaleX) * lockScale;
                         scaleY = sign$1(scaleY) * lockScale;
                     }
@@ -13683,10 +13700,10 @@ const EditDataHelper = {
             const nowHeight = boxBounds.height * target.scaleY;
             scaleY = within$3(nowHeight * scaleY, heightRange) / nowHeight;
         }
-        if (useScaleX && abs$3(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
-        if (useScaleY && abs$3(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
+        if (useScaleX && abs$4(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
+        if (useScaleY && abs$4(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
         if (lockRatio && scaleX !== scaleY) {
-            lockScale = Math.min(abs$3(scaleX), abs$3(scaleY));
+            lockScale = Math.min(abs$4(scaleX), abs$4(scaleY));
             scaleX = sign$1(scaleX) * lockScale;
             scaleY = sign$1(scaleY) * lockScale;
         }
@@ -15725,10 +15742,22 @@ function scaleResizeFontSize(leaf, scaleX, scaleY, direction) {
         }
     }
     leaf.fontSize *= fontScale;
-    const data = leaf.__, {padding: padding} = data;
+    const data = leaf.__, {padding: padding, lineHeight: lineHeight, letterSpacing: letterSpacing} = data;
     if (padding) leaf.padding = isArray(padding) ? padding.map(item => item * fontScale) : padding * fontScale;
     if (!data.__autoWidth) leaf.width *= fontScale;
     if (!data.__autoHeight) leaf.height *= fontScale;
+    if (isObject(lineHeight)) {
+        if (lineHeight.type === "px") data.lineHeight = {
+            type: "px",
+            value: lineHeight.value * fontScale
+        };
+    } else if (lineHeight) data.lineHeight = lineHeight * fontScale;
+    if (isObject(letterSpacing)) {
+        if (letterSpacing.type === "px") data.letterSpacing = {
+            type: "px",
+            value: letterSpacing.value * fontScale
+        };
+    } else if (letterSpacing) data.letterSpacing = letterSpacing * fontScale;
 }
 
 function scaleResizePath(leaf, scaleX, scaleY) {
@@ -16297,7 +16326,7 @@ const MultiTouchHelper = {
 
 const M$4 = MultiTouchHelper;
 
-const {abs: abs$2, max: max$1} = Math, {sign: sign, within: within$2} = MathHelper;
+const {abs: abs$3, max: max$1} = Math, {sign: sign, within: within$2} = MathHelper;
 
 const WheelEventHelper = {
     getMove(event, config) {
@@ -16307,7 +16336,7 @@ const WheelEventHelper = {
             deltaX = deltaY;
             deltaY = 0;
         }
-        const absX = abs$2(deltaX), absY = abs$2(deltaY);
+        const absX = abs$3(deltaX), absY = abs$3(deltaY);
         if (absX > 50) deltaX = max$1(50, absX / 3) * sign(deltaX);
         if (absY > 50) deltaY = max$1(50, absY / 3) * sign(deltaY);
         return {
@@ -16329,7 +16358,7 @@ const WheelEventHelper = {
         if (zoom) {
             zoomSpeed = within$2(zoomSpeed, 0, 1);
             const min = event.deltaY ? config.delta.y : config.delta.x;
-            const absScale = within$2(1 - abs$2(delta) / (min * 4) * zoomSpeed, .5, 2);
+            const absScale = within$2(1 - abs$3(delta) / (min * 4) * zoomSpeed, .5, 2);
             scale = delta > 0 ? absScale : 1 / absScale;
         }
         return scale;
@@ -16568,7 +16597,7 @@ interaction.multiTouch = function(data, list) {
 
 const dragger = Dragger.prototype;
 
-const {abs: abs$1, min: min, max: max, hypot: hypot} = Math;
+const {abs: abs$2, min: min, max: max, hypot: hypot} = Math;
 
 dragger.checkDragEndAnimate = function(data) {
     const {interaction: interaction} = this;
@@ -16597,7 +16626,7 @@ dragger.checkDragEndAnimate = function(data) {
             moveX *= boost;
             moveY *= boost;
         }
-        const maxAbs = max(abs$1(moveX), abs$1(moveY));
+        const maxAbs = max(abs$2(moveX), abs$2(moveY));
         if (maxAbs > maxMove) {
             s = maxMove / maxAbs;
             moveX *= s;
@@ -16607,7 +16636,7 @@ dragger.checkDragEndAnimate = function(data) {
             moveX *= inertia;
             moveY *= inertia;
             data = Object.assign({}, data);
-            if (abs$1(moveX) < stopMove && abs$1(moveY) < stopMove) return this.dragEndReal(data);
+            if (abs$2(moveX) < stopMove && abs$2(moveY) < stopMove) return this.dragEndReal(data);
             PointHelper.move(data, moveX, moveY);
             this.drag(data);
             this.animate(step);
@@ -17336,7 +17365,7 @@ function getArrowPath(ui, arrow, from, to, size, connectOffset, hasDashPattern)
 
 const {M: M$2, L: L$2, C: C$2, Q: Q, Z: Z$2, N: N, D: D, X: X, G: G, F: F, O: O, P: P, U: U} = PathCommandMap;
 
-const {copy: copy, copyFrom: copyFrom, getDistancePoint: getDistancePoint, isSame: isSame} = PointHelper;
+const {copy: copy, copyFrom: copyFrom, getDistancePoint: getDistancePoint, isSame: isSame$1} = PointHelper;
 
 const {stintSet: stintSet$1} = DataHelper;
 
@@ -17430,7 +17459,7 @@ const PathArrowModule = {
             }
             count++;
             if (count === 1 && command !== M$2) return;
-            if (count === 2 && useStartArrow) copy(second, command === L$2 ? now : isSame(old, first) ? last : old);
+            if (count === 2 && useStartArrow) copy(second, command === L$2 ? now : isSame$1(old, first) ? last : old);
             if (i === len) {
                 const path = uData.__pathForRender = clonePathForArrow ? [ ...data ] : data;
                 if (useStartArrow) {
@@ -17444,7 +17473,7 @@ const PathArrowModule = {
                     }
                 }
                 if (endArrow && endArrow !== "none") {
-                    if (isSame(last, now)) copy(last, old);
+                    if (isSame$1(last, now)) copy(last, old);
                     endArrowPath = getArrowPath(ui, endArrow, last, now, strokeWidth, connectPoint, !!dashPattern);
                     singleEndArrow = endArrowPath.fill || dashPattern;
                     if (!singleEndArrow) path.push(...endArrowPath.data);
@@ -18060,7 +18089,7 @@ box$1.__updateBoxBounds = function(secondLayout) {
     }
 };
 
-const {cos: cos, sin: sin, pow: pow, sqrt: sqrt$1, abs: abs, ceil: ceil, floor: floor, round: round$2, PI: PI} = Math;
+const {cos: cos, sin: sin, pow: pow, sqrt: sqrt$1, abs: abs$1, ceil: ceil, floor: floor, round: round$2, PI: PI} = Math;
 
 const PIx5 = PI * 5;
 
@@ -18098,7 +18127,7 @@ function cubicBezier(x1, y1, x2, y2) {
             o = 1 - v;
             x = bezier(v, x1, x2) - t;
             dx = 3 * o * o * x1 + 6 * o * v * (x2 - x1) + 3 * v * v * (1 - x2);
-            if (abs(dx) < 1e-6) break;
+            if (abs$1(dx) < 1e-6) break;
             v -= x / dx;
         }
         return cache[key] = bezier(v, y1, y2);
@@ -20957,7 +20986,7 @@ function getCorrectT(d, x, y, x1, y1, x2, y2, toX, toY) {
     return Math.max(0, Math.min(.5, t));
 }
 
-const {M: M, L: L, C: C, Z: Z} = PathCommandMap;
+const {M: M, L: L, C: C, Z: Z} = PathCommandMap, {abs: abs} = Math;
 
 const {getCenterX: getCenterX, getCenterY: getCenterY} = PointHelper;
 
@@ -20965,7 +20994,7 @@ const {arcTo: arcTo} = PathCommandDataHelper;
 
 PathCorner.smooth = function smooth(data, cornerRadius, _cornerSmoothing) {
     const radius = data.radius;
-    if (isNeedConvert(data)) data = PathConvert.toCanvasData(data, true);
+    if (isNeedConvert(data)) data = PathConvert.toCanvasData(data, true); else data = [ ...data ];
     let command, lastCommand, commandLen;
     let i = 0, countCommand = 0, x = 0, y = 0, startX = 0, startY = 0, startR = 0, secondX = 0, secondY = 0, lastX = 0, lastY = 0, r, x1, y1, x2, y2, toX, toY;
     if (isArray(cornerRadius)) cornerRadius = cornerRadius[0] || 0;
@@ -21051,6 +21080,9 @@ PathCorner.smooth = function smooth(data, cornerRadius, _cornerSmoothing) {
                 toX = startX, toY = startY;
                 setBeforeC(smooth, r, lastX, lastY, x1, y1, x2, y2, x, y, toX, toY, three);
                 break;
+
+              default:
+                smooth.push(C, x1, y1, x2, y2, x, y);
             }
             lastX = x;
             lastY = y;
@@ -21140,7 +21172,16 @@ function findEndPoint(data, i) {
 }
 
 function setAfterC(data, i, cornerRadius, lastX, lastY, fromX, fromY, x1, y1, x2, y2, toX, toY) {
-    const d = getTangentDistance(cornerRadius, fromX, fromY, lastX, lastY, x1, y1);
+    let targetX = x1, targetY = y1;
+    if (isSame(x1, fromX) && isSame(y1, fromY)) {
+        targetX = x2;
+        targetY = y2;
+        if (isSame(x2, fromX) && isSame(y2, fromY)) {
+            targetX = toX;
+            targetY = toY;
+        }
+    }
+    const d = getTangentDistance(cornerRadius, fromX, fromY, lastX, lastY, targetX, targetY);
     const t = getCorrectT(d, fromX, fromY, x1, y1, x2, y2, toX, toY);
     const two = BezierHelper.cut(t, fromX, fromY, x1, y1, x2, y2, toX, toY);
     const {left: left, right: right} = two;
@@ -21154,7 +21195,16 @@ function setAfterC(data, i, cornerRadius, lastX, lastY, fromX, fromY, x1, y1, x2
 }
 
 function setBeforeC(smooth, cornerRadius, fromX, fromY, x1, y1, x2, y2, toX, toY, nextX, nextY, three) {
-    const d = getTangentDistance(cornerRadius, toX, toY, x2, y2, nextX, nextY);
+    let targetX = x2, targetY = y2;
+    if (isSame(targetX, toX) && isSame(targetY, toY)) {
+        targetX = x1;
+        targetY = y1;
+        if (isSame(targetX, toX) && isSame(targetY, toY)) {
+            targetX = fromX;
+            targetY = fromY;
+        }
+    }
+    const d = getTangentDistance(cornerRadius, toX, toY, targetX, targetY, nextX, nextY);
     const t = getCorrectT(d, toX, toY, x2, y2, x1, y1, fromX, fromY);
     const {left: left, right: right} = BezierHelper.cut(1 - t, fromX, fromY, x1, y1, x2, y2, toX, toY);
     if (left && right) {
@@ -21165,6 +21215,10 @@ function setBeforeC(smooth, cornerRadius, fromX, fromY, x1, y1, x2, y2, toX, toY
     }
 }
 
+function isSame(a, b) {
+    return abs(a - b) < .01;
+}
+
 Plugin.add("corner");
 
 export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseBox, EllipseBoxData, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, FourNumberHelper, Frame, FrameData, Group, GroupData, HTMLText, HTMLTextData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageBox, ImageBoxData, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferFilm, LeaferImage, LeaferTypeCreator, LeaferVideo, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, MyTouchEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathBox, PathBoxData, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonBox, PolygonBoxData, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, Scroller, SelectArea, Selector, Star, StarBox, StarBoxData, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TextEditor, TouchEvent, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, UnitConvertHelper, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, dimType, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite$1 as isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, motionPathType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, scrollType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$3 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$4 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };