@leafer-draw/worker 2.1.5 → 2.1.7

package/dist/worker.module.js

@@ -292,7 +292,7 @@ const FourNumberHelper = {
         return to;
     },
     setTemp(top, right, bottom, left) {
-        return set$2(tempFour, top, right, bottom, left);
+        return set$3(tempFour, top, right, bottom, left);
     },
     toTempAB(a, b, change) {
         tempTo = change ? isNumber(a) ? b : a : [];
@@ -332,22 +332,22 @@ const FourNumberHelper = {
     max(t, other, change) {
         if (isNumber(t) && isNumber(other)) return max$4(t, other);
         toTempAB(t, other, change);
-        return set$2(tempTo, max$4(tempA[0], tempB[0]), max$4(tempA[1], tempB[1]), max$4(tempA[2], tempB[2]), max$4(tempA[3], tempB[3]));
+        return set$3(tempTo, max$4(tempA[0], tempB[0]), max$4(tempA[1], tempB[1]), max$4(tempA[2], tempB[2]), max$4(tempA[3], tempB[3]));
     },
     add(t, other, change) {
         if (isNumber(t) && isNumber(other)) return t + other;
         toTempAB(t, other, change);
-        return set$2(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
+        return set$3(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
     },
     swapAndScale(t, scaleX, scaleY, change) {
         if (isNumber(t)) return scaleX === scaleY ? t * scaleX : [ t * scaleY, t * scaleX ];
         const to = change ? t : [];
         const [top, right, bottom, left] = t.length === 4 ? t : get$5(t);
-        return set$2(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
+        return set$3(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
     }
 };
 
-const {set: set$2, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
+const {set: set$3, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
 
 const {round: round$3, pow: pow$1, max: max$3, floor: floor$2, PI: PI$3} = Math;
 
@@ -472,7 +472,7 @@ const {sin: sin$5, cos: cos$5, acos: acos, sqrt: sqrt$3} = Math;
 
 const {float: float$2} = MathHelper;
 
-const tempPoint$3 = {};
+const tempPoint$4 = {};
 
 function getWorld() {
     return Object.assign(Object.assign(Object.assign({}, getMatrixData()), getBoundsData()), {
@@ -531,8 +531,8 @@ const MatrixHelper = {
         to.f = t.f * pixelRatio;
     },
     scaleOfOuter(t, origin, scaleX, scaleY) {
-        M$6.toInnerPoint(t, origin, tempPoint$3);
-        M$6.scaleOfInner(t, tempPoint$3, scaleX, scaleY);
+        M$6.toInnerPoint(t, origin, tempPoint$4);
+        M$6.scaleOfInner(t, tempPoint$4, scaleX, scaleY);
     },
     scaleOfInner(t, origin, scaleX, scaleY = scaleX) {
         M$6.translateInner(t, origin.x, origin.y);
@@ -550,8 +550,8 @@ const MatrixHelper = {
         t.d = c * sinR + d * cosR;
     },
     rotateOfOuter(t, origin, rotation) {
-        M$6.toInnerPoint(t, origin, tempPoint$3);
-        M$6.rotateOfInner(t, tempPoint$3, rotation);
+        M$6.toInnerPoint(t, origin, tempPoint$4);
+        M$6.rotateOfInner(t, tempPoint$4, rotation);
     },
     rotateOfInner(t, origin, rotation) {
         M$6.translateInner(t, origin.x, origin.y);
@@ -572,8 +572,8 @@ const MatrixHelper = {
         }
     },
     skewOfOuter(t, origin, skewX, skewY) {
-        M$6.toInnerPoint(t, origin, tempPoint$3);
-        M$6.skewOfInner(t, tempPoint$3, skewX, skewY);
+        M$6.toInnerPoint(t, origin, tempPoint$4);
+        M$6.skewOfInner(t, tempPoint$4, skewX, skewY);
     },
     skewOfInner(t, origin, skewX, skewY = 0) {
         M$6.translateInner(t, origin.x, origin.y);
@@ -774,7 +774,7 @@ const {float: float$1} = MathHelper;
 
 const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
 
-const {sin: sin$4, cos: cos$4, abs: abs$4, sqrt: sqrt$2, atan2: atan2$2, min: min$1, round: round$2} = Math;
+const {sin: sin$4, cos: cos$4, abs: abs$5, sqrt: sqrt$2, atan2: atan2$2, min: min$1, round: round$2} = Math;
 
 const PointHelper = {
     defaultPoint: getPointData(),
@@ -811,15 +811,15 @@ const PointHelper = {
         t.x += (t.x - origin.x) * (scaleX - 1);
         t.y += (t.y - origin.y) * (scaleY - 1);
     },
-    rotate(t, rotation, origin) {
+    rotate(t, rotation, origin, radiusX = 1, radiusY = 1) {
         if (!origin) origin = P$5.defaultPoint;
         rotation *= OneRadian;
         const cosR = cos$4(rotation);
         const sinR = sin$4(rotation);
-        const rx = t.x - origin.x;
-        const ry = t.y - origin.y;
-        t.x = origin.x + rx * cosR - ry * sinR;
-        t.y = origin.y + rx * sinR + ry * cosR;
+        const rx = (t.x - origin.x) / radiusX;
+        const ry = (t.y - origin.y) / radiusY;
+        t.x = origin.x + (rx * cosR - ry * sinR) * radiusX;
+        t.y = origin.y + (rx * sinR + ry * cosR) * radiusY;
     },
     tempToInnerOf(t, matrix) {
         const {tempPoint: temp} = P$5;
@@ -872,15 +872,15 @@ const PointHelper = {
         return getDistanceFrom(t.x, t.y, point.x, point.y);
     },
     getDistanceFrom(x1, y1, x2, y2) {
-        const x = abs$4(x2 - x1);
-        const y = abs$4(y2 - y1);
+        const x = abs$5(x2 - x1);
+        const y = abs$5(y2 - y1);
         return sqrt$2(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
         return min$1(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
     },
-    getAngle(t, to) {
-        return getAtan2(t, to) / OneRadian;
+    getAngle(t, to, radiusX, radiusY) {
+        return getAtan2(t, to, radiusX, radiusY) / OneRadian;
     },
     getRotation(t, origin, to, toOrigin) {
         if (!toOrigin) toOrigin = origin;
@@ -894,8 +894,8 @@ const PointHelper = {
         const d = toY - toOriginY;
         return Math.atan2(a * d - b * c, a * c + b * d);
     },
-    getAtan2(t, to) {
-        return atan2$2(to.y - t.y, to.x - t.x);
+    getAtan2(t, to, radiusX = 1, radiusY = 1) {
+        return atan2$2((to.y - t.y) / radiusY, (to.x - t.x) / radiusX);
     },
     getDistancePoint(t, to, distance, changeTo, fromTo) {
         const r = getAtan2(t, to);
@@ -995,7 +995,7 @@ class Point {
     }
 }
 
-const tempPoint$2 = new Point;
+const tempPoint$3 = new Point;
 
 class Matrix {
     constructor(a, b, c, d, e, f) {
@@ -2702,15 +2702,15 @@ const RectHelper = {
     }
 };
 
-const {sin: sin$3, cos: cos$3, hypot: hypot, atan2: atan2$1, ceil: ceil, abs: abs$3, PI: PI$2, sqrt: sqrt$1, pow: pow} = Math;
+const {sin: sin$3, cos: cos$3, hypot: hypot, atan2: atan2$1, ceil: ceil, abs: abs$4, PI: PI$2, sqrt: sqrt$1, pow: pow} = Math;
 
 const {setPoint: setPoint$1, addPoint: addPoint$1} = TwoPointBoundsHelper;
 
-const {set: set$1, toNumberPoints: toNumberPoints} = PointHelper;
+const {set: set$2, toNumberPoints: toNumberPoints} = PointHelper;
 
 const {M: M$5, L: L$6, C: C$4, Q: Q$4, Z: Z$5} = PathCommandMap;
 
-const tempPoint$1 = {};
+const tempPoint$2 = {};
 
 const BezierHelper = {
     points(data, originPoints, curve, close) {
@@ -2779,14 +2779,14 @@ const BezierHelper = {
         const lenCB = hypot(CBx, CBy);
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
-        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$3(totalRadian - PI$2) < 1e-12) {
+        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$4(totalRadian - PI$2) < 1e-12) {
             if (data) data.push(L$6, x1, y1);
             if (setPointBounds) {
                 setPoint$1(setPointBounds, fromX, fromY);
                 addPoint$1(setPointBounds, x1, y1);
             }
-            if (setStartPoint) set$1(setStartPoint, fromX, fromY);
-            if (setEndPoint) set$1(setEndPoint, x1, y1);
+            if (setStartPoint) set$2(setStartPoint, fromX, fromY);
+            if (setEndPoint) set$2(setEndPoint, x1, y1);
             return;
         }
         const anticlockwise = BAx * CBy - CBx * BAy < 0;
@@ -2812,7 +2812,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(abs$3(totalRadian / PI_2));
+        const parts = ceil(abs$4(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$3(partRadian / 4);
         const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin$3(partRadian / 2);
@@ -2826,7 +2826,7 @@ const BezierHelper = {
         let fromX = cx + x, fromY = cy + y;
         if (data) data.push(data.length ? L$6 : M$5, fromX, fromY);
         if (setPointBounds) setPoint$1(setPointBounds, fromX, fromY);
-        if (setStartPoint) set$1(setStartPoint, fromX, fromY);
+        if (setStartPoint) set$2(setStartPoint, fromX, fromY);
         for (let i = 0; i < parts; i++) {
             endCos = cos$3(endRadian);
             endSin = sin$3(endRadian);
@@ -2845,7 +2845,7 @@ const BezierHelper = {
             startRadian = endRadian;
             endRadian += partRadian;
         }
-        if (setEndPoint) set$1(setEndPoint, cx + x, cy + y);
+        if (setEndPoint) set$2(setEndPoint, cx + x, cy + y);
     },
     quadraticCurveTo(data, fromX, fromY, x1, y1, toX, toY) {
         data.push(C$4, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
@@ -2881,8 +2881,8 @@ const BezierHelper = {
         addMode ? addPoint$1(pointBounds, fromX, fromY) : setPoint$1(pointBounds, fromX, fromY);
         addPoint$1(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$1);
-            addPoint$1(pointBounds, tempPoint$1.x, tempPoint$1.y);
+            getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint$2);
+            addPoint$1(pointBounds, tempPoint$2.x, tempPoint$2.y);
         }
     },
     getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, setPoint) {
@@ -3321,7 +3321,7 @@ const {M: M$3, L: L$4, C: C$2, Q: Q$2, Z: Z$3, N: N$2, D: D$2, X: X$2, G: G$2, F
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
-const {tan: tan, min: min, abs: abs$2} = Math;
+const {tan: tan, min: min, abs: abs$3} = Math;
 
 const startPoint = {};
 
@@ -3381,7 +3381,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(radius, min(r, r * abs$2(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
+            radius = min(radius, min(r, r * abs$3(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
         data.push(U$2, x1, y1, x2, y2, radius);
     },
@@ -3722,7 +3722,7 @@ const {arcTo: arcTo} = PathCommandDataHelper;
 
 const PathCorner = {
     smooth(data, cornerRadius, _cornerSmoothing) {
-        let command, lastCommand, commandLen;
+        let command, lastCommand, commandLen, startXIndex, startYIndex, smoothLen;
         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, three = len === 9;
@@ -3731,6 +3731,11 @@ const PathCorner = {
             command = data[i];
             switch (command) {
               case M:
+                smoothLen = smooth.length;
+                if (smoothLen && lastCommand !== Z) {
+                    smooth[startXIndex] = startX;
+                    smooth[startYIndex] = startY;
+                }
                 startX = lastX = data[i + 1];
                 startY = lastY = data[i + 2];
                 i += 3;
@@ -3741,6 +3746,8 @@ const PathCorner = {
                 } else {
                     smooth.push(M, startX, startY);
                 }
+                startXIndex = smoothLen + 1;
+                startYIndex = smoothLen + 2;
                 break;
 
               case L$1:
@@ -3779,8 +3786,8 @@ const PathCorner = {
             lastCommand = command;
         }
         if (command !== Z) {
-            smooth[1] = startX;
-            smooth[2] = startY;
+            smooth[startXIndex] = startX;
+            smooth[startYIndex] = startY;
         }
         return smooth;
     }
@@ -6031,7 +6038,7 @@ const LeafDataProxy = {
 
 const {setLayout: setLayout, multiplyParent: multiplyParent$2, translateInner: translateInner, defaultWorld: defaultWorld} = MatrixHelper;
 
-const {toPoint: toPoint$3, tempPoint: tempPoint} = AroundHelper;
+const {toPoint: toPoint$3, tempPoint: tempPoint$1} = AroundHelper;
 
 const LeafMatrix = {
     __updateWorldMatrix() {
@@ -6052,8 +6059,8 @@ const LeafMatrix = {
             local.e = data.x + data.offsetX;
             local.f = data.y + data.offsetY;
             if (data.around || data.origin) {
-                toPoint$3(data.around || data.origin, layout.boxBounds, tempPoint);
-                translateInner(local, -tempPoint.x, -tempPoint.y, !data.around);
+                toPoint$3(data.around || data.origin, layout.boxBounds, tempPoint$1);
+                translateInner(local, -tempPoint$1.x, -tempPoint$1.y, !data.around);
             }
         }
         this.__layout.matrixChanged = undefined;
@@ -6976,7 +6983,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.1.5";
+const version = "2.1.7";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -8342,6 +8349,7 @@ let UI = UI_1 = class UI extends Leaf {
         this.set(keyframe);
         return Plugin.need("animate");
     }
+    killAnimate(_type, _nextStyle) {}
     export(_filename, _options) {
         return Plugin.need("export");
     }
@@ -9101,32 +9109,53 @@ __decorate([ affectRenderBoundsType("hide") ], Frame.prototype, "overflow", void
 
 Frame = __decorate([ registerUI() ], Frame);
 
-const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse} = PathCommandDataHelper;
+const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse} = PathCommandDataHelper, {tempPoint: tempPoint, set: set$1, rotate: rotate$2} = PointHelper, {abs: abs$2} = Math, tempCenter = {};
 
 let Ellipse = class Ellipse extends UI {
     get __tag() {
         return "Ellipse";
     }
     __updatePath() {
-        const data = this.__, {width: width, height: height, innerRadius: innerRadius, startAngle: startAngle, endAngle: endAngle} = data;
+        const data = this.__, {width: width, height: height, innerRadius: innerRadius, startAngle: startAngle, endAngle: endAngle, closed: closed} = data;
         const rx = width / 2, ry = height / 2;
         const path = data.path = [];
-        let open;
+        let open, hasAngle, closedAngle;
+        if (startAngle || endAngle) hasAngle = true;
+        if (hasAngle) closedAngle = abs$2(endAngle - startAngle) === 360;
         if (innerRadius) {
-            if (startAngle || endAngle) {
-                if (innerRadius < 1) ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle, false); else open = true;
-                ellipse(path, rx, ry, rx, ry, 0, endAngle, startAngle, true);
+            const drawInnerEllipse = innerRadius < 1 || closed;
+            let outerStartAngle = startAngle, outerEndAngle = endAngle, outerAnticlockwise;
+            if (hasAngle) {
+                if (drawInnerEllipse) {
+                    ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle);
+                    if (closedAngle) {
+                        set$1(tempPoint, width, ry);
+                        set$1(tempCenter, rx, ry);
+                        rotate$2(tempPoint, endAngle, tempCenter, rx, ry);
+                        moveTo$3(path, tempPoint.x, tempPoint.y);
+                    }
+                    outerStartAngle = endAngle;
+                    outerEndAngle = startAngle;
+                    outerAnticlockwise = true;
+                } else {
+                    if (!closedAngle) open = true;
+                }
             } else {
-                if (innerRadius < 1) {
+                if (drawInnerEllipse) {
                     ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius);
+                    closePath$2(path);
                     moveTo$3(path, width, ry);
+                    outerStartAngle = 360;
+                    outerAnticlockwise = true;
+                } else {
+                    outerEndAngle = 360;
                 }
-                ellipse(path, rx, ry, rx, ry, 0, 360, 0, true);
             }
+            ellipse(path, rx, ry, rx, ry, 0, outerStartAngle, outerEndAngle, outerAnticlockwise);
         } else {
-            if (startAngle || endAngle) {
-                moveTo$3(path, rx, ry);
-                ellipse(path, rx, ry, rx, ry, 0, startAngle, endAngle, false);
+            if (hasAngle) {
+                if (!closedAngle) moveTo$3(path, rx, ry);
+                ellipse(path, rx, ry, rx, ry, 0, startAngle, endAngle);
             } else {
                 ellipse(path, rx, ry, rx, ry);
             }
@@ -9993,6 +10022,7 @@ function checkSizeAndCreateData(ui, attrName, paint, image, leafPaint, boxBounds
         if (data.__autoSide) {
             ui.forceUpdate("width");
             LeafHelper.updateBounds(ui);
+            ui.__layout.boundsChanged = true;
             if (ui.__proxyData) {
                 ui.setProxyAttr("width", data.width);
                 ui.setProxyAttr("height", data.height);
@@ -10000,7 +10030,7 @@ function checkSizeAndCreateData(ui, attrName, paint, image, leafPaint, boxBounds
             needUpdate = false;
         }
     }
-    if (paint.mode === "brush") PaintImage.brush(leafPaint, ui, attrName);
+    if (paint.mode === "brush") PaintImage.brush(ui, attrName, leafPaint);
     if (!leafPaint.data) {
         PaintImage.createData(leafPaint, image, paint, boxBounds);
         const {transform: transform} = leafPaint.data, {opacity: opacity} = paint;
@@ -10095,8 +10125,9 @@ function getPatternData(paint, box, image) {
         break;
 
       case "repeat":
-      case "brush":
         if (!sameBox || scaleX || rotation || skew) PaintImage.repeatMode(data, box, width, height, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew, align, paint.freeTransform);
+
+      case "brush":
         if (!repeat) data.repeat = "repeat";
         const count = isObject(repeat);
         if (gap || count) data.gap = getGapData(gap, count && repeat, tempImage.width, tempImage.height, box);
@@ -10107,7 +10138,7 @@ function getPatternData(paint, box, image) {
       default:
         if (scaleX) PaintImage.fillOrFitMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation);
     }
-    if (!data.transform) {
+    if (!data.transform && mode !== "brush") {
         if (box.x || box.y) translate$1(data.transform = get$3(), box.x, box.y);
     }
     if (scaleX) {
@@ -10236,8 +10267,9 @@ function createPattern(paint, ui, canvas, renderOptions) {
     let {scaleX: scaleX, scaleY: scaleY} = PaintImage.getImageRenderScaleData(paint, ui, canvas, renderOptions), id = paint.film ? paint.nowIndex : scaleX + "-" + scaleY;
     if (paint.patternId !== id && !ui.destroyed) {
         if (!(Platform.image.isLarge(paint.image, scaleX, scaleY) && !paint.data.repeat)) {
-            const {image: image, brush: brush, data: data} = paint, {opacity: opacity} = paint.originPaint, {transform: transform, gap: gap} = data, fixScale = PaintImage.getPatternFixScale(paint, scaleX, scaleY);
-            let imageMatrix, xGap, yGap, {width: width, height: height} = image;
+            const {image: image, brush: brush, data: data} = paint, {transform: transform, gap: gap} = data, fixScale = PaintImage.getPatternFixScale(paint, scaleX, scaleY);
+            let imageMatrix, xGap, yGap, {width: width, height: height} = image, {opacity: opacity} = paint.originPaint;
+            if (brush || opacity === 1) opacity = undefined;
             if (fixScale) scaleX *= fixScale, scaleY *= fixScale;
             width *= scaleX;
             height *= scaleY;
@@ -11264,4 +11296,4 @@ Object.assign(Effect, EffectModule);
 
 useCanvas();
 
-export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, DataHelper, Debug, Direction4, Direction9, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, FourNumberHelper, Frame, FrameData, Group, GroupData, Image, ImageData, ImageEvent, ImageManager, IncrementId, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferFilm, LeaferImage, LeaferVideo, Line, LineData, MathHelper, Matrix, MatrixHelper, MyImage, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Plugin, Point, PointHelper, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Run, Star, StarData, State, StringNumberMap, TaskItem, TaskProcessor, Text, TextConvert, TextData, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIRender, UnitConvert, UnitConvertHelper, WaitHelper, WatchEvent, Watcher, affectRenderBoundsType, affectStrokeBoundsType, 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, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, scrollType, sortType, strokeType, surfaceType, tempBounds$2 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$2 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };
+export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, DataHelper, Debug, Direction4, Direction9, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, FourNumberHelper, Frame, FrameData, Group, GroupData, Image, ImageData, ImageEvent, ImageManager, IncrementId, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferFilm, LeaferImage, LeaferVideo, Line, LineData, MathHelper, Matrix, MatrixHelper, MyImage, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathCommandNodeHelper, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNodeHandleType, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Plugin, Point, PointHelper, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Run, Star, StarData, State, StringNumberMap, TaskItem, TaskProcessor, Text, TextConvert, TextData, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIRender, UnitConvert, UnitConvertHelper, WaitHelper, WatchEvent, Watcher, affectRenderBoundsType, affectStrokeBoundsType, 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, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, scrollType, sortType, strokeType, surfaceType, tempBounds$2 as tempBounds, tempMatrix$2 as tempMatrix, tempPoint$3 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };