@leafer/miniapp 1.9.5 → 1.9.7

package/dist/miniapp.module.js

@@ -372,7 +372,7 @@ function getMatrixData() {
 
 const {sin: sin$6, cos: cos$6, acos: acos, sqrt: sqrt$5} = Math;
 
-const {float: float$2} = MathHelper;
+const {float: float$3} = MathHelper;
 
 const tempPoint$4 = {};
 
@@ -423,6 +423,15 @@ const MatrixHelper = {
         t.c *= scaleY;
         t.d *= scaleY;
     },
+    pixelScale(t, pixelRatio, to) {
+        to || (to = t);
+        to.a = t.a * pixelRatio;
+        to.b = t.b * pixelRatio;
+        to.c = t.c * pixelRatio;
+        to.d = t.d * pixelRatio;
+        to.e = t.e * pixelRatio;
+        to.f = t.f * pixelRatio;
+    },
     scaleOfOuter(t, origin, scaleX, scaleY) {
         M$a.toInnerPoint(t, origin, tempPoint$4);
         M$a.scaleOfInner(t, tempPoint$4, scaleX, scaleY);
@@ -614,12 +623,12 @@ const MatrixHelper = {
                 const cosR = c / scaleY;
                 rotation = PI_2 - (d > 0 ? acos(-cosR) : -acos(cosR));
             }
-            const cosR = float$2(cos$6(rotation));
+            const cosR = float$3(cos$6(rotation));
             const sinR = sin$6(rotation);
-            scaleX = float$2(scaleX), scaleY = float$2(scaleY);
-            skewX = cosR ? float$2((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
-            skewY = cosR ? float$2((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
-            rotation = float$2(rotation / OneRadian);
+            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);
         } else {
             scaleX = a;
             scaleY = d;
@@ -922,6 +931,10 @@ class Matrix {
         this.scaleY *= y || x;
         return this;
     }
+    pixelScale(pixelRatio) {
+        MatrixHelper.pixelScale(this, pixelRatio);
+        return this;
+    }
     scaleOfOuter(origin, x, y) {
         MatrixHelper.scaleOfOuter(this, origin, x, y);
         return this;
@@ -1141,7 +1154,7 @@ const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$5, addPoint: addPo
 
 const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
 
-const {float: float$1, fourNumber: fourNumber$1} = MathHelper;
+const {float: float$2, fourNumber: fourNumber$1} = MathHelper;
 
 const {floor: floor$3, ceil: ceil$3} = Math;
 
@@ -1324,10 +1337,10 @@ const BoundsHelper = {
         }
     },
     float(t, maxLength) {
-        t.x = float$1(t.x, maxLength);
-        t.y = float$1(t.y, maxLength);
-        t.width = float$1(t.width, maxLength);
-        t.height = float$1(t.height, 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);
     },
     add(t, bounds, isPoint) {
         right$4 = t.x + t.width;
@@ -2146,7 +2159,7 @@ __decorate([ contextMethod() ], Canvas$1.prototype, "measureText", null);
 
 __decorate([ contextMethod() ], Canvas$1.prototype, "strokeText", null);
 
-const {copy: copy$b, multiplyParent: multiplyParent$4} = MatrixHelper, {round: round$4} = Math, tempPixelBounds = new Bounds, tempPixelBounds2 = new Bounds;
+const {copy: copy$b, multiplyParent: multiplyParent$4, pixelScale: pixelScale} = MatrixHelper, {round: round$4} = Math, tempPixelBounds = new Bounds, tempPixelBounds2 = new Bounds;
 
 const minSize = {
     width: 1,
@@ -2247,12 +2260,7 @@ class LeaferCanvasBase extends Canvas$1 {
     setWorld(matrix, parentMatrix) {
         const {pixelRatio: pixelRatio, pixelSnap: pixelSnap} = this, w = this.worldTransform;
         if (parentMatrix) multiplyParent$4(matrix, parentMatrix, w);
-        w.a = matrix.a * pixelRatio;
-        w.b = matrix.b * pixelRatio;
-        w.c = matrix.c * pixelRatio;
-        w.d = matrix.d * pixelRatio;
-        w.e = matrix.e * pixelRatio;
-        w.f = matrix.f * pixelRatio;
+        pixelScale(matrix, pixelRatio, w);
         if (pixelSnap) {
             if (matrix.half && matrix.half * pixelRatio % 2) w.e = round$4(w.e - .5) + .5, w.f = round$4(w.f - .5) + .5; else w.e = round$4(w.e), 
             w.f = round$4(w.f);
@@ -4265,6 +4273,18 @@ function surfaceType(defaultValue) {
     }));
 }
 
+function dimType(defaultValue) {
+    return decorateLeafAttr(defaultValue, key => attr({
+        set(value) {
+            if (this.__setAttr(key, value)) {
+                const data = this.__;
+                DataHelper.stintSet(data, "__useDim", data.dim || data.bright || data.dimskip);
+                this.__layout.surfaceChange();
+            }
+        }
+    }));
+}
+
 function opacityType(defaultValue) {
     return decorateLeafAttr(defaultValue, key => attr({
         set(value) {
@@ -4309,7 +4329,7 @@ function sortType(defaultValue) {
     return decorateLeafAttr(defaultValue, key => attr({
         set(value) {
             if (this.__setAttr(key, value)) {
-                this.__layout.surfaceChanged || this.__layout.surfaceChange();
+                this.__layout.surfaceChange();
                 this.waitParent(() => {
                     this.parent.__layout.childrenSortChange();
                 });
@@ -4346,7 +4366,7 @@ function hitType(defaultValue) {
         set(value) {
             if (this.__setAttr(key, value)) {
                 this.__layout.hitCanvasChanged = true;
-                if (Debug.showBounds === "hit") this.__layout.surfaceChanged || this.__layout.surfaceChange();
+                if (Debug.showBounds === "hit") this.__layout.surfaceChange();
                 if (this.leafer) this.leafer.updateCursor();
             }
         }
@@ -5463,6 +5483,8 @@ LeaferEvent.RESTART = "leafer.restart";
 
 LeaferEvent.END = "leafer.end";
 
+LeaferEvent.UPDATE_MODE = "leafer.update_mode";
+
 LeaferEvent.TRANSFORM = "leafer.transform";
 
 LeaferEvent.MOVE = "leafer.move";
@@ -5859,6 +5881,7 @@ const LeafRender = {
         if (options.shape) return this.__renderShape(canvas, options);
         if (this.__worldOpacity) {
             const data = this.__;
+            if (data.bright && !options.topRendering) return options.topList.add(this);
             canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
             canvas.opacity = options.dimOpacity && !data.dimskip ? data.opacity * options.dimOpacity : data.opacity;
             if (this.__.__single) {
@@ -5907,7 +5930,9 @@ const BranchRender = {
         this.__nowWorld = this.__getNowWorld(options);
         if (this.__worldOpacity) {
             const data = this.__;
-            if (data.dim) options.dimOpacity = data.dim === true ? .2 : data.dim; else if (data.dimskip) options.dimOpacity && (options.dimOpacity = 0);
+            if (data.__useDim) {
+                if (data.dim) options.dimOpacity = data.dim === true ? .2 : data.dim; else if (data.bright && !options.topRendering) return options.topList.add(this); else if (data.dimskip) options.dimOpacity && (options.dimOpacity = 0);
+            }
             if (data.__single && !this.isBranchLeaf) {
                 if (data.eraser === "path") return this.__renderEraser(canvas, options);
                 const tempCanvas = canvas.getSameCanvas(false, true);
@@ -6749,7 +6774,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.5";
+const version = "1.9.7";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7456,7 +7481,7 @@ class Renderer {
         };
         if (this.needFill) canvas.fillWorld(bounds, this.config.fill);
         if (Debug.showRepaint) Debug.drawRepaint(canvas, bounds);
-        this.target.__render(canvas, options);
+        Platform.render(this.target, canvas, options);
         this.renderBounds = realBounds = realBounds || bounds;
         this.renderOptions = options;
         this.totalBounds.isEmpty() ? this.totalBounds = realBounds : this.totalBounds.add(realBounds);
@@ -7628,7 +7653,7 @@ class Picker {
             item = path.list[i];
             if (!item.__.hittable) break;
             hittablePath.addAt(item, 0);
-            if (!item.__.hitChildren) break;
+            if (!item.__.hitChildren || item.isLeafer && item.mode === "draw") break;
         }
         return hittablePath;
     }
@@ -7732,6 +7757,15 @@ Object.assign(Creator, {
 
 Platform.layout = Layouter.fullLayout;
 
+Platform.render = function(target, canvas, options) {
+    const topOptions = Object.assign(Object.assign({}, options), {
+        topRendering: true
+    });
+    options.topList = new LeafList;
+    target.__render(canvas, options);
+    if (options.topList.length) options.topList.forEach(item => item.__render(canvas, topOptions));
+};
+
 function effectType(defaultValue) {
     return decorateLeafAttr(defaultValue, key => attr({
         set(value) {
@@ -8085,8 +8119,6 @@ class TextData extends UIData {
             if (!boxStyle) box.parent = t, box.__world = t.__world, boxLayout.boxBounds = layout.boxBounds;
             box.set(value);
             if (boxLayout.strokeChanged) layout.strokeChange();
-            if (boxLayout.renderChanged) layout.renderChange();
-            box.__updateChange();
         } else if (box) {
             t.__box = box.parent = null;
             box.destroy();
@@ -8156,7 +8188,7 @@ const UIBounds = {
     __updateRenderSpread() {
         let width = 0;
         const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = this.__;
-        if (shadow) shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
+        if (shadow) width = Effect.getShadowSpread(this, shadow);
         if (blur) width = Math.max(width, blur);
         if (filter) width += Filter.getSpread(filter);
         if (renderSpread) width += renderSpread;
@@ -8169,36 +8201,69 @@ const UIBounds = {
     }
 };
 
+const {float: float$1} = MathHelper;
+
+const tempContent = new Bounds, tempMerge = new Bounds, tempIntersect = new Bounds;
+
 const DragBoundsHelper = {
+    limitMove(leaf, move) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, move, true);
+        D$2.axisMove(leaf, move);
+    },
+    limitScaleOf(leaf, origin, scale) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidScaleOf(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, true);
+    },
+    axisMove(leaf, move) {
+        const {draggable: draggable} = leaf;
+        if (draggable === "x") move.y = 0;
+        if (draggable === "y") move.x = 0;
+    },
+    getDragBounds(leaf) {
+        const {dragBounds: dragBounds} = leaf;
+        return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
+    },
+    isInnerMode(content, dragBounds, dragBoundsType, sideType) {
+        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > 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;
         const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
         if (!change) move = Object.assign({}, move);
-        const isBiggerWidth = content.width > dragBounds.width;
-        const isBiggerHeight = content.height > dragBounds.height;
-        if (isBiggerWidth && dragBoundsType !== "outer") {
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
             if (x > dragBounds.x) move.x += dragBounds.x - x; else if (right < boundsRight) move.x += boundsRight - right;
         } else {
             if (x < dragBounds.x) move.x += dragBounds.x - x; else if (right > boundsRight) move.x += boundsRight - right;
         }
-        if (isBiggerHeight && dragBoundsType !== "outer") {
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
             if (y > dragBounds.y) move.y += dragBounds.y - y; else if (bottom < boundsBottom) move.y += boundsBottom - bottom;
         } else {
             if (y < dragBounds.y) move.y += dragBounds.y - y; else if (bottom > boundsBottom) move.y += boundsBottom - bottom;
         }
-        move.x = MathHelper.float(move.x);
-        move.y = MathHelper.float(move.y);
+        move.x = float$1(move.x);
+        move.y = float$1(move.y);
         return move;
     },
-    axisMove(leaf, move) {
-        const {draggable: draggable} = leaf;
-        if (draggable === "x") move.y = 0;
-        if (draggable === "y") move.x = 0;
-    },
-    limitMove(leaf, move) {
-        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
-        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds, dragBoundsType, move, true);
-        D$2.axisMove(leaf, move);
+    getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, change) {
+        if (!change) scale = Object.assign({}, scale);
+        let fitScaleX, fitScaleY;
+        tempContent.set(content).scaleOf(origin, scale.x, scale.y).unsign();
+        tempMerge.set(tempContent).add(dragBounds);
+        tempIntersect.set(tempContent).intersect(dragBounds);
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+            fitScaleX = tempMerge.width / tempContent.width;
+        } else {
+            fitScaleX = tempIntersect.width / tempContent.width;
+        }
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
+            fitScaleY = tempMerge.height / tempContent.height;
+        } else {
+            fitScaleY = tempIntersect.height / tempContent.height;
+        }
+        scale.x = float$1(tempIntersect.width) ? scale.x * fitScaleX : 1;
+        scale.y = float$1(tempIntersect.height) ? scale.y * fitScaleY : 1;
+        return scale;
     }
 };
 
@@ -8216,7 +8281,7 @@ const UIRender = {
         }
         if (data.__useEffect) {
             const {shadow: shadow, fill: fill, stroke: stroke} = data, otherEffect = data.innerShadow || data.blur || data.backgroundBlur || data.filter;
-            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
+            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !Effect.isTransformShadow(shadow[0]) && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
             data.__useEffect = !!(shadow || otherEffect);
         }
         data.__checkSingle();
@@ -8476,9 +8541,9 @@ __decorate([ visibleType(true) ], UI.prototype, "visible", void 0);
 
 __decorate([ surfaceType(false) ], UI.prototype, "locked", void 0);
 
-__decorate([ surfaceType(false) ], UI.prototype, "dim", void 0);
+__decorate([ dimType(false) ], UI.prototype, "dim", void 0);
 
-__decorate([ surfaceType(false) ], UI.prototype, "dimskip", void 0);
+__decorate([ dimType(false) ], UI.prototype, "dimskip", void 0);
 
 __decorate([ sortType(0) ], UI.prototype, "zIndex", void 0);
 
@@ -8854,7 +8919,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
             } else if (attrName === "zIndex") {
                 this.canvas.zIndex = newValue;
                 setTimeout(() => this.parent && this.parent.__updateSortChildren());
-            }
+            } else if (attrName === "mode") this.emit(LeaferEvent.UPDATE_MODE, {
+                mode: newValue
+            });
         }
         return super.__setAttr(attrName, newValue);
     }
@@ -9037,6 +9104,8 @@ __decorate([ dataProcessor(LeaferData) ], Leafer.prototype, "__", void 0);
 
 __decorate([ boundsType() ], Leafer.prototype, "pixelRatio", void 0);
 
+__decorate([ dataType("normal") ], Leafer.prototype, "mode", void 0);
+
 Leafer = Leafer_1 = __decorate([ registerUI() ], Leafer);
 
 let Rect = class Rect extends UI {
@@ -9229,57 +9298,9 @@ __decorate([ pathType(0) ], Ellipse.prototype, "endAngle", void 0);
 
 Ellipse = __decorate([ registerUI() ], Ellipse);
 
-const {moveTo: moveTo$2, lineTo: lineTo$2, drawPoints: drawPoints$1} = PathCommandDataHelper;
-
-const {rotate: rotate$3, getAngle: getAngle$2, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
-
-let Line = class Line extends UI {
-    get __tag() {
-        return "Line";
-    }
-    get toPoint() {
-        const {width: width, rotation: rotation} = this.__;
-        const to = getPointData();
-        if (width) to.x = width;
-        if (rotation) rotate$3(to, rotation);
-        return to;
-    }
-    set toPoint(value) {
-        this.width = getDistance$3(defaultPoint, value);
-        this.rotation = getAngle$2(defaultPoint, value);
-        if (this.height) this.height = 0;
-    }
-    __updatePath() {
-        const data = this.__;
-        const path = data.path = [];
-        if (data.points) {
-            drawPoints$1(path, data.points, data.curve, data.closed);
-        } else {
-            moveTo$2(path, 0, 0);
-            lineTo$2(path, this.width, 0);
-        }
-    }
-};
-
-__decorate([ dataProcessor(LineData) ], Line.prototype, "__", void 0);
-
-__decorate([ affectStrokeBoundsType("center") ], Line.prototype, "strokeAlign", void 0);
-
-__decorate([ boundsType(0) ], Line.prototype, "height", void 0);
-
-__decorate([ pathType() ], Line.prototype, "points", void 0);
-
-__decorate([ pathType(0) ], Line.prototype, "curve", void 0);
-
-__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
-
-Line = __decorate([ registerUI() ], Line);
-
 const {sin: sin$2, cos: cos$2, PI: PI$2} = Math;
 
-const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath$1, drawPoints: drawPoints} = PathCommandDataHelper;
-
-const line = Line.prototype;
+const {moveTo: moveTo$2, lineTo: lineTo$2, closePath: closePath$1, drawPoints: drawPoints$1} = PathCommandDataHelper;
 
 let Polygon = class Polygon extends UI {
     get __tag() {
@@ -9289,19 +9310,17 @@ let Polygon = class Polygon extends UI {
         const data = this.__;
         const path = data.path = [];
         if (data.points) {
-            drawPoints(path, data.points, data.curve, true);
+            drawPoints$1(path, data.points, data.curve, true);
         } else {
             const {width: width, height: height, sides: sides} = data;
             const rx = width / 2, ry = height / 2;
-            moveTo$1(path, rx, 0);
+            moveTo$2(path, rx, 0);
             for (let i = 1; i < sides; i++) {
-                lineTo$1(path, rx + rx * sin$2(i * 2 * PI$2 / sides), ry - ry * cos$2(i * 2 * PI$2 / sides));
+                lineTo$2(path, rx + rx * sin$2(i * 2 * PI$2 / sides), ry - ry * cos$2(i * 2 * PI$2 / sides));
             }
             closePath$1(path);
         }
     }
-    __updateRenderPath() {}
-    __updateBoxBounds() {}
 };
 
 __decorate([ dataProcessor(PolygonData) ], Polygon.prototype, "__", void 0);
@@ -9312,15 +9331,11 @@ __decorate([ pathType() ], Polygon.prototype, "points", void 0);
 
 __decorate([ pathType(0) ], Polygon.prototype, "curve", void 0);
 
-__decorate([ rewrite(line.__updateRenderPath) ], Polygon.prototype, "__updateRenderPath", null);
-
-__decorate([ rewrite(line.__updateBoxBounds) ], Polygon.prototype, "__updateBoxBounds", null);
-
 Polygon = __decorate([ rewriteAble(), registerUI() ], Polygon);
 
 const {sin: sin$1, cos: cos$1, PI: PI$1} = Math;
 
-const {moveTo: moveTo, lineTo: lineTo, closePath: closePath} = PathCommandDataHelper;
+const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath} = PathCommandDataHelper;
 
 let Star = class Star extends UI {
     get __tag() {
@@ -9330,9 +9345,9 @@ let Star = class Star extends UI {
         const {width: width, height: height, corners: corners, innerRadius: innerRadius} = this.__;
         const rx = width / 2, ry = height / 2;
         const path = this.__.path = [];
-        moveTo(path, rx, 0);
+        moveTo$1(path, rx, 0);
         for (let i = 1; i < corners * 2; i++) {
-            lineTo(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));
+            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));
         }
         closePath(path);
     }
@@ -9346,6 +9361,52 @@ __decorate([ pathType(.382) ], Star.prototype, "innerRadius", void 0);
 
 Star = __decorate([ registerUI() ], Star);
 
+const {moveTo: moveTo, lineTo: lineTo, drawPoints: drawPoints} = PathCommandDataHelper;
+
+const {rotate: rotate$3, getAngle: getAngle$2, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
+
+let Line = class Line extends UI {
+    get __tag() {
+        return "Line";
+    }
+    get toPoint() {
+        const {width: width, rotation: rotation} = this.__;
+        const to = getPointData();
+        if (width) to.x = width;
+        if (rotation) rotate$3(to, rotation);
+        return to;
+    }
+    set toPoint(value) {
+        this.width = getDistance$3(defaultPoint, value);
+        this.rotation = getAngle$2(defaultPoint, value);
+        if (this.height) this.height = 0;
+    }
+    __updatePath() {
+        const data = this.__;
+        const path = data.path = [];
+        if (data.points) {
+            drawPoints(path, data.points, data.curve, data.closed);
+        } else {
+            moveTo(path, 0, 0);
+            lineTo(path, this.width, 0);
+        }
+    }
+};
+
+__decorate([ dataProcessor(LineData) ], Line.prototype, "__", void 0);
+
+__decorate([ affectStrokeBoundsType("center") ], Line.prototype, "strokeAlign", void 0);
+
+__decorate([ boundsType(0) ], Line.prototype, "height", void 0);
+
+__decorate([ pathType() ], Line.prototype, "points", void 0);
+
+__decorate([ pathType(0) ], Line.prototype, "curve", void 0);
+
+__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
+
+Line = __decorate([ registerUI() ], Line);
+
 let Image = class Image extends Rect {
     get __tag() {
         return "Image";
@@ -9493,10 +9554,6 @@ let Text = class Text extends UI {
         DataHelper.stintSet(this, "isOverflow", !includes(b, contentBounds));
         if (this.isOverflow) setList(data.__textBoxBounds = {}, [ b, contentBounds ]), layout.renderChanged = true; else data.__textBoxBounds = b;
     }
-    __onUpdateSize() {
-        if (this.__box) this.__box.__onUpdateSize();
-        super.__onUpdateSize();
-    }
     __updateRenderSpread() {
         let width = super.__updateRenderSpread();
         if (!width) width = this.isOverflow ? 1 : 0;
@@ -9507,6 +9564,11 @@ let Text = class Text extends UI {
         copyAndSpread$1(renderBounds, this.__.__textBoxBounds, renderSpread);
         if (this.__box) this.__box.__layout.renderBounds = renderBounds;
     }
+    __updateChange() {
+        super.__updateChange();
+        const box = this.__box;
+        if (box) box.__onUpdateSize(), box.__updateChange();
+    }
     __drawRenderPath(canvas) {
         canvas.font = this.__.__font;
     }
@@ -12096,12 +12158,18 @@ function shadow$1(ui, current, shape) {
             }
             worldCanvas ? other.copyWorld(worldCanvas, nowWorld, nowWorld, "destination-out") : other.copyWorld(shape.canvas, shapeBounds, bounds, "destination-out");
         }
-        LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
+        if (Effect.isTransformShadow(item)) Effect.renderTransformShadow(ui, current, other, copyBounds, item); else LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end) other.clearWorld(copyBounds);
     });
     other.recycle(copyBounds);
 }
 
+function getShadowSpread(_ui, shadow) {
+    let width = 0;
+    shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
+    return width;
+}
+
 function drawWorldShadow(canvas, outBounds, spreadScale, shape) {
     const {bounds: bounds, shapeBounds: shapeBounds} = shape;
     if (Platform.fullImageShadow) {
@@ -12179,7 +12247,11 @@ const EffectModule = {
     shadow: shadow$1,
     innerShadow: innerShadow,
     blur: blur,
-    backgroundBlur: backgroundBlur
+    backgroundBlur: backgroundBlur,
+    getShadowSpread: getShadowSpread,
+    isTransformShadow(_shadow) {
+        return undefined;
+    }
 };
 
 const {excludeRenderBounds: excludeRenderBounds} = LeafBoundsHelper;
@@ -12687,16 +12759,17 @@ function toTextChar(row) {
 }
 
 function decorationText(drawData, style) {
-    let type;
+    let type, offset = 0;
     const {fontSize: fontSize, textDecoration: textDecoration} = style;
     drawData.decorationHeight = fontSize / 11;
     if (isObject(textDecoration)) {
         type = textDecoration.type;
         if (textDecoration.color) drawData.decorationColor = ColorConvert.string(textDecoration.color);
+        if (textDecoration.offset) offset = Math.min(fontSize * .3, Math.max(textDecoration.offset, -fontSize * .15));
     } else type = textDecoration;
     switch (type) {
       case "under":
-        drawData.decorationY = [ fontSize * .15 ];
+        drawData.decorationY = [ fontSize * .15 + offset ];
         break;
 
       case "delete":
@@ -12704,7 +12777,7 @@ function decorationText(drawData, style) {
         break;
 
       case "under-delete":
-        drawData.decorationY = [ fontSize * .15, -fontSize * .35 ];
+        drawData.decorationY = [ fontSize * .15 + offset, -fontSize * .35 ];
     }
 }
 
@@ -12851,12 +12924,15 @@ function targetAttr(fn) {
             set(value) {
                 const old = this[privateKey];
                 if (old !== value) {
-                    if (this.config) {
+                    const t = this;
+                    if (t.config) {
                         const isSelect = key === "target";
                         if (isSelect) {
+                            t.setDimOthers(false);
+                            t.setBright(false);
                             if (isArray(value) && value.length > 1 && value[0].locked) value.splice(0, 1);
-                            if (this.single) this.element.syncEventer = null;
-                            const {beforeSelect: beforeSelect} = this.config;
+                            if (t.single) t.element.syncEventer = null;
+                            const {beforeSelect: beforeSelect} = t.config;
                             if (beforeSelect) {
                                 const check = beforeSelect({
                                     target: value
@@ -12866,7 +12942,7 @@ function targetAttr(fn) {
                         }
                         const type = isSelect ? EditorEvent.BEFORE_SELECT : EditorEvent.BEFORE_HOVER;
                         if (this.hasEvent(type)) this.emitEvent(new EditorEvent(type, {
-                            editor: this,
+                            editor: t,
                             value: value,
                             oldValue: old
                         }));
@@ -13049,7 +13125,7 @@ class EditSelect extends Group {
     }
     get running() {
         const {editor: editor} = this;
-        return this.hittable && editor.visible && editor.hittable && editor.mergeConfig.selector;
+        return this.hittable && editor.visible && editor.hittable && editor.mergeConfig.selector && this.app.mode === "normal";
     }
     get isMoveMode() {
         return this.app && this.app.interaction.moveMode;
@@ -13351,17 +13427,13 @@ const EditDataHelper = {
         }
         toPoint(around || align, boxBounds, origin, true);
         if (dragBounds) {
-            const allowBounds = dragBounds === "parent" ? target.parent.boxBounds : dragBounds;
-            const childBounds = new Bounds(target.__localBoxBounds);
-            if (BoundsHelper.includes(new Bounds(allowBounds).spread(.1), childBounds)) {
-                childBounds.scaleOf(target.getLocalPointByInner(origin), scaleX, scaleY);
-                if (!BoundsHelper.includes(allowBounds, childBounds)) {
-                    const realBounds = childBounds.getIntersect(allowBounds);
-                    const fitScaleX = realBounds.width / childBounds.width, fitScaleY = realBounds.height / childBounds.height;
-                    if (useScaleX) scaleX *= fitScaleX;
-                    if (useScaleY) scaleY *= fitScaleY;
-                }
-            }
+            const scaleData = {
+                x: scaleX,
+                y: scaleY
+            };
+            DragBoundsHelper.limitScaleOf(target, origin, scaleData);
+            scaleX = scaleData.x;
+            scaleY = scaleData.y;
         }
         if (useScaleX && widthRange) {
             const nowWidth = boxBounds.width * target.scaleX;
@@ -13541,13 +13613,18 @@ const cacheCursors = {};
 function updatePointCursor(editBox, e) {
     const {enterPoint: point, dragging: dragging, skewing: skewing, resizing: resizing, flippedX: flippedX, flippedY: flippedY} = editBox;
     if (!point || !editBox.editor.editing || !editBox.canUse) return;
+    if (point.name === "rect") return updateMoveCursor(editBox);
     if (point.name === "circle") return;
-    if (point.pointType === "button") {
+    let {rotation: rotation} = editBox;
+    const {pointType: pointType} = point, {moveCursor: moveCursor, resizeCursor: resizeCursor, rotateCursor: rotateCursor, skewCursor: skewCursor, moveable: moveable, resizeable: resizeable, rotateable: rotateable, skewable: skewable} = editBox.mergeConfig;
+    if (pointType === "move") {
+        point.cursor = moveCursor;
+        if (!moveable) point.visible = false;
+        return;
+    } else if (pointType === "button") {
         if (!point.cursor) point.cursor = "pointer";
         return;
     }
-    let {rotation: rotation} = editBox;
-    const {pointType: pointType} = point, {resizeCursor: resizeCursor, rotateCursor: rotateCursor, skewCursor: skewCursor, resizeable: resizeable, rotateable: rotateable, skewable: skewable} = editBox.mergeConfig;
     let showResize = pointType.includes("resize");
     if (showResize && rotateable && (editBox.isHoldRotateKey(e) || !resizeable)) showResize = false;
     const showSkew = skewable && !showResize && (point.name === "resize-line" || pointType === "skew");
@@ -13628,7 +13705,7 @@ class EditBox extends Group {
     constructor(editor) {
         super();
         this.view = new Group;
-        this.rect = new Box({
+        this.rect = new EditPoint({
             name: "rect",
             hitFill: "all",
             hitStroke: "none",
@@ -13690,12 +13767,13 @@ class EditBox extends Group {
             this.listenPointEvents(resizePoint, "resize", i);
         }
         this.listenPointEvents(circle, "rotate", 2);
+        this.listenPointEvents(rect, "move", 8);
         view.addMany(...rotatePoints, rect, circle, buttons, ...resizeLines, ...resizePoints);
         this.add(view);
     }
     load() {
-        const {target: target, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, resizePoints: resizePoints} = this;
-        const {stroke: stroke, strokeWidth: strokeWidth} = mergeConfig;
+        const {target: target, mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, resizePoints: resizePoints, resizeLines: resizeLines} = this;
+        const {stroke: stroke, strokeWidth: strokeWidth, resizeLine: resizeLine} = mergeConfig;
         const pointsStyle = this.getPointsStyle();
         const middlePointsStyle = this.getMiddlePointsStyle();
         this.visible = !target.locked;
@@ -13704,6 +13782,10 @@ class EditBox extends Group {
             resizeP = resizePoints[i];
             resizeP.set(this.getPointStyle(i % 2 ? middlePointsStyle[(i - 1) / 2 % middlePointsStyle.length] : pointsStyle[i / 2 % pointsStyle.length]));
             resizeP.rotation = (i - (i % 2 ? 1 : 0)) / 2 * 90;
+            if (i % 2) resizeLines[(i - 1) / 2].set(Object.assign({
+                pointType: "resize",
+                rotation: (i - 1) / 2 * 90
+            }, resizeLine || {}));
         }
         circle.set(this.getPointStyle(mergeConfig.circle || mergeConfig.rotatePoint || pointsStyle[0]));
         rect.set(Object.assign({
@@ -13748,10 +13830,12 @@ class EditBox extends Group {
         if (this.app) this.rect.syncEventer = this.app.interaction.bottomList = null;
     }
     updateBounds(bounds) {
-        const {editMask: editMask} = this.editor;
-        const {mergeConfig: mergeConfig, single: single, rect: rect, circle: circle, buttons: buttons, resizePoints: resizePoints, rotatePoints: rotatePoints, resizeLines: resizeLines} = this;
-        const {middlePoint: middlePoint, resizeable: resizeable, rotateable: rotateable, hideOnSmall: hideOnSmall, editBox: editBox, mask: mask, spread: spread, hideRotatePoints: hideRotatePoints, hideResizeLines: hideResizeLines} = mergeConfig;
+        const {editor: editor, 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, mask: mask, dimOthers: dimOthers, bright: bright, spread: spread, hideRotatePoints: hideRotatePoints, hideResizeLines: hideResizeLines} = mergeConfig;
         editMask.visible = mask ? true : 0;
+        editor.setDimOthers(dimOthers);
+        editor.setBright(!!dimOthers || bright);
         if (spread) BoundsHelper.spread(bounds, spread);
         if (this.view.worldOpacity) {
             const {width: width, height: height} = bounds;
@@ -13772,10 +13856,10 @@ class EditBox extends Group {
                     resizeL.visible = resizeP.visible && !hideResizeLines;
                     resizeP.visible = rotateP.visible = showPoints && !!middlePoint;
                     if ((i + 1) / 2 % 2) {
-                        resizeL.width = width;
+                        resizeL.width = width + resizeL.height;
                         if (hideOnSmall && resizeP.width * 2 > width) resizeP.visible = false;
                     } else {
-                        resizeL.height = height;
+                        resizeL.width = height + resizeL.height;
                         if (hideOnSmall && resizeP.width * 2 > height) resizeP.visible = false;
                     }
                 }
@@ -13852,7 +13936,7 @@ class EditBox extends Group {
         this.dragging = true;
         const point = this.dragPoint = e.current, {pointType: pointType} = point;
         const {editor: editor, dragStartData: dragStartData} = this, {target: target} = this, {moveable: moveable, resizeable: resizeable, rotateable: rotateable, skewable: skewable, hideOnMove: hideOnMove} = this.mergeConfig;
-        if (point.name === "rect") {
+        if (pointType === "move") {
             moveable && (this.moving = true);
             editor.opacity = hideOnMove ? 0 : 1;
         } else {
@@ -13877,23 +13961,22 @@ class EditBox extends Group {
         if (this.moving && this.mergeConfig.dragLimitAnimate && this.target.dragBounds) this.transformTool.onMove(e);
         this.dragPoint = null;
         this.resetDoing();
-        const {name: name, pointType: pointType} = e.current;
-        if (name === "rect") this.editor.opacity = 1;
+        const {pointType: pointType} = e.current;
+        if (pointType === "move") this.editor.opacity = 1;
         if (pointType && pointType.includes("resize")) ResizeEvent.resizingKeys = null;
     }
     onDrag(e) {
         const {transformTool: transformTool, moving: moving, resizing: resizing, rotating: rotating, skewing: skewing} = this;
         if (moving) {
             transformTool.onMove(e);
-            updateMoveCursor(this);
         } else if (resizing || rotating || skewing) {
             const point = e.current;
             if (point.pointType) this.enterPoint = point;
             if (rotating) transformTool.onRotate(e);
             if (resizing) transformTool.onScale(e);
             if (skewing) transformTool.onSkew(e);
-            updatePointCursor(this, e);
         }
+        updatePointCursor(this, e);
     }
     resetDoing() {
         if (this.canUse) this.dragging = this.gesturing = this.moving = this.resizing = this.rotating = this.skewing = false;
@@ -13989,17 +14072,15 @@ class EditBox extends Group {
     listenPointEvents(point, type, direction) {
         point.direction = direction;
         point.pointType = type;
-        const events = [ [ DragEvent.START, this.onDragStart, this ], [ DragEvent.DRAG, this.onDrag, this ], [ DragEvent.END, this.onDragEnd, this ], [ PointerEvent.LEAVE, () => {
-            this.enterPoint = null;
-        } ] ];
-        if (point.name !== "circle") events.push([ PointerEvent.ENTER, e => {
+        this.__eventIds.push(point.on_([ [ DragEvent.START, this.onDragStart, this ], [ DragEvent.DRAG, this.onDrag, this ], [ DragEvent.END, this.onDragEnd, this ], [ PointerEvent.ENTER, e => {
             this.enterPoint = point, updatePointCursor(this, e);
-        } ]);
-        this.__eventIds.push(point.on_(events));
+        } ], [ PointerEvent.LEAVE, () => {
+            this.enterPoint = null;
+        } ] ]));
     }
     __listenEvents() {
         const {rect: rect, editor: editor, __eventIds: events} = this;
-        events.push(rect.on_([ [ DragEvent.START, this.onDragStart, this ], [ DragEvent.DRAG, this.onDrag, this ], [ DragEvent.END, this.onDragEnd, this ], [ PointerEvent.ENTER, () => updateMoveCursor(this) ], [ PointerEvent.DOUBLE_TAP, this.onDoubleTap, this ], [ PointerEvent.LONG_PRESS, this.onLongPress, this ] ]));
+        events.push(rect.on_([ [ PointerEvent.DOUBLE_TAP, this.onDoubleTap, this ], [ PointerEvent.LONG_PRESS, this.onLongPress, this ] ]));
         this.waitLeafer(() => {
             events.push(editor.app.on_([ [ [ KeyEvent.HOLD, KeyEvent.UP ], this.onKey, this ], [ KeyEvent.DOWN, this.onArrow, this ], [ MoveEvent.BEFORE_MOVE, this.onMove, this, true ], [ ZoomEvent.BEFORE_ZOOM, this.onScale, this, true ], [ RotateEvent.BEFORE_ROTATE, this.onRotate, this, true ], [ MoveEvent.END, this.onMoveEnd, this ], [ ZoomEvent.END, this.resetDoing, this ], [ RotateEvent.END, this.resetDoing, this ] ]));
         });
@@ -14727,6 +14808,16 @@ let Editor = class Editor extends Group {
     shiftItem(item) {
         this.hasItem(item) ? this.removeItem(item) : this.addItem(item);
     }
+    setDimOthers(value, attrName = "dim", list) {
+        if (!list) {
+            const {dimTarget: dimTarget, targetLeafer: targetLeafer} = this;
+            list = dimTarget ? isArray(dimTarget) ? dimTarget : [ dimTarget ] : [ targetLeafer ];
+        }
+        if (list[0] && list[0][attrName] !== (value || false)) list.forEach(item => DataHelper.stintSet(item, attrName, value));
+    }
+    setBright(value) {
+        this.setDimOthers(value, "bright", this.list);
+    }
     update() {
         if (this.editing) {
             if (!this.element.parent) return this.cancel();
@@ -14922,7 +15013,9 @@ let Editor = class Editor extends Group {
     listenTargetEvents() {
         if (!this.targetEventIds.length) {
             const {app: app, leafer: leafer, targetLeafer: targetLeafer, editMask: editMask} = this;
-            this.targetEventIds = [ leafer.on_(RenderEvent.START, this.onRenderStart, this), targetLeafer && targetLeafer.on_(PropertyEvent.SCROLL, this.onChildScroll, this), app.on_(RenderEvent.CHILD_START, this.onAppRenderStart, this) ];
+            this.targetEventIds = [ leafer.on_(RenderEvent.START, this.onRenderStart, this), targetLeafer && targetLeafer.on_(PropertyEvent.SCROLL, this.onChildScroll, this), app.on_(RenderEvent.CHILD_START, this.onAppRenderStart, this), app.on_(LeaferEvent.UPDATE_MODE, data => {
+                if (data.mode && data.mode !== "normal") this.cancel();
+            }) ];
             if (editMask.visible) editMask.forceRender();
         }
     }
@@ -14947,10 +15040,10 @@ let Editor = class Editor extends Group {
 
 __decorate([ mergeConfigAttr() ], Editor.prototype, "mergeConfig", void 0);
 
-__decorate([ targetAttr(onHover) ], Editor.prototype, "hoverTarget", void 0);
-
 __decorate([ targetAttr(onTarget) ], Editor.prototype, "target", void 0);
 
+__decorate([ targetAttr(onHover) ], Editor.prototype, "hoverTarget", void 0);
+
 Editor = __decorate([ useModule(TransformTool, [ "editBox", "editTool", "emitEvent" ]) ], Editor);
 
 class InnerEditor {
@@ -19152,14 +19245,10 @@ const ExportModule = {
                     renderOptions.bounds = canvas.bounds;
                 }
                 canvas.save();
-                if (isFrame && !isUndefined(fill)) {
-                    const oldFill = leaf.get("fill");
-                    leaf.fill = "";
-                    leaf.__render(canvas, renderOptions);
-                    leaf.fill = oldFill;
-                } else {
-                    leaf.__render(canvas, renderOptions);
-                }
+                const igroneFill = isFrame && !isUndefined(fill), oldFill = leaf.get("fill");
+                if (igroneFill) leaf.fill = "";
+                Platform.render(leaf, canvas, renderOptions);
+                if (igroneFill) leaf.fill = oldFill;
                 canvas.restore();
                 if (sliceLeaf) sliceLeaf.__updateWorldOpacity();
                 if (trim) {
@@ -19202,6 +19291,8 @@ const ExportModule = {
                     renderBounds: renderBounds,
                     trimBounds: trimBounds
                 };
+                const app = leafer && leafer.app;
+                if (app && app.canvasManager) app.canvasManager.clearRecycled();
             }
         } catch (error) {
             result = {
@@ -19319,4 +19410,8 @@ Object.assign(Filter, {
     }
 });
 
-export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, 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$1 as tempBounds, tempMatrix$1 as tempMatrix, tempPoint$3 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };
+Plugin.add("bright");
+
+UI.addAttr("bright", false, dimType);
+
+export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, dimType, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite, 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$1 as tempBounds, tempMatrix$1 as tempMatrix, tempPoint$3 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };