leafer-ui 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/web.module.js

@@ -3,7 +3,7 @@ const Platform = {
         hitCanvasSize: 100,
         maxCacheSize: 2560 * 1600,
         maxPatternSize: 4096 * 2160,
-        suffix: 'leaf',
+        suffix: '',
         crossOrigin: 'anonymous'
     }
 };
@@ -33,24 +33,12 @@ const I$2 = IncrementId;
 const { round, pow: pow$1, PI: PI$4 } = Math;
 const MathHelper = {
     within(value, min, max) {
-        if (value < min)
+        if (min !== undefined && value < min)
             value = min;
-        if (value > max)
+        if (max !== undefined && value > max)
             value = max;
         return value;
     },
-    minus(value, isFourNumber) {
-        if (value instanceof Array) {
-            if (isFourNumber)
-                value = MathHelper.fourNumber(value, 0);
-            for (let i = 0; i < value.length; i++)
-                value[i] = -value[i];
-        }
-        else {
-            value = -value;
-        }
-        return value;
-    },
     fourNumber(num, maxValue) {
         let data;
         if (num instanceof Array) {
@@ -147,9 +135,11 @@ const MatrixHelper = {
         t.e += x;
         t.f += y;
     },
-    translateInner(t, x, y) {
+    translateInner(t, x, y, isMoveOrigin) {
         t.e += t.a * x + t.c * y;
         t.f += t.b * x + t.d * y;
+        if (isMoveOrigin)
+            t.e -= x, t.f -= y;
     },
     scale(t, scaleX, scaleY = scaleX) {
         t.a *= scaleX;
@@ -216,8 +206,10 @@ const MatrixHelper = {
         t.e = child.e * a + child.f * c + e;
         t.f = child.e * b + child.f * d + f;
     },
-    multiplyParent(t, parent, to, abcdChanged, childScaleData) {
-        const { e, f } = t;
+    multiplyParent(t, parent, to, abcdChanged, childScaleData, scrollData) {
+        let { e, f } = t;
+        if (scrollData)
+            e += scrollData.scrollX, f += scrollData.scrollY;
         to || (to = t);
         if (abcdChanged === undefined)
             abcdChanged = t.a !== 1 || t.b || t.c || t.d !== 1;
@@ -338,7 +330,7 @@ const MatrixHelper = {
         t.e = x;
         t.f = y;
         if (origin)
-            M$6.translateInner(t, -origin.x, -origin.y);
+            M$6.translateInner(t, -origin.x, -origin.y, true);
     },
     getLayout(t, origin, firstSkewY) {
         const { a, b, c, d, e, f } = t;
@@ -758,7 +750,7 @@ const { float, fourNumber } = MathHelper;
 const { floor, ceil: ceil$2 } = Math;
 let right$1, bottom$1, boundsRight, boundsBottom;
 const point = {};
-const toPoint$1 = {};
+const toPoint$5 = {};
 const BoundsHelper = {
     tempBounds: {},
     set(t, x = 0, y = 0, width = 0, height = 0) {
@@ -773,15 +765,17 @@ const BoundsHelper = {
         t.width = bounds.width;
         t.height = bounds.height;
     },
-    copyAndSpread(t, bounds, spreadX, spreadY) {
-        if (spreadX instanceof Array) {
-            const four = fourNumber(spreadX);
-            B.set(t, bounds.x - four[3], bounds.y - four[0], bounds.width + four[1] + four[3], bounds.height + four[2] + four[0]);
+    copyAndSpread(t, bounds, spread, isShrink) {
+        if (spread instanceof Array) {
+            const four = fourNumber(spread);
+            isShrink
+                ? B.set(t, bounds.x + four[3], bounds.y + four[0], bounds.width - four[1] - four[3], bounds.height - four[2] - four[0])
+                : B.set(t, bounds.x - four[3], bounds.y - four[0], bounds.width + four[1] + four[3], bounds.height + four[2] + four[0]);
         }
         else {
-            if (!spreadY)
-                spreadY = spreadX;
-            B.set(t, bounds.x - spreadX, bounds.y - spreadY, bounds.width + spreadX * 2, bounds.height + spreadY * 2);
+            if (isShrink)
+                spread = -spread;
+            B.set(t, bounds.x - spread, bounds.y - spread, bounds.width + spread * 2, bounds.height + spread * 2);
         }
     },
     minX(t) { return t.width > 0 ? t.x : t.x + t.width; },
@@ -858,17 +852,17 @@ const BoundsHelper = {
         else {
             point.x = t.x;
             point.y = t.y;
-            toOuterPoint$1(matrix, point, toPoint$1);
-            setPoint$3(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
+            toOuterPoint$1(matrix, point, toPoint$5);
+            setPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
             point.x = t.x + t.width;
-            toOuterPoint$1(matrix, point, toPoint$1);
-            addPoint$3(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
+            toOuterPoint$1(matrix, point, toPoint$5);
+            addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
             point.y = t.y + t.height;
-            toOuterPoint$1(matrix, point, toPoint$1);
-            addPoint$3(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
+            toOuterPoint$1(matrix, point, toPoint$5);
+            addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
             point.x = t.x;
-            toOuterPoint$1(matrix, point, toPoint$1);
-            addPoint$3(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
+            toOuterPoint$1(matrix, point, toPoint$5);
+            addPoint$3(tempPointBounds$1, toPoint$5.x, toPoint$5.y);
             toBounds$4(tempPointBounds$1, to);
         }
     },
@@ -881,13 +875,16 @@ const BoundsHelper = {
         const scale = Math.min(baseScale, Math.min(t.width / put.width, t.height / put.height));
         return new Matrix(scale, 0, 0, scale, -put.x * scale, -put.y * scale);
     },
-    getSpread(t, spreadX, spreadY) {
+    getSpread(t, spread) {
         const n = {};
-        B.copyAndSpread(n, t, spreadX, spreadY);
+        B.copyAndSpread(n, t, spread);
         return n;
     },
-    spread(t, spreadX, spreadY = spreadX) {
-        B.copyAndSpread(t, t, spreadX, spreadY);
+    spread(t, spread) {
+        B.copyAndSpread(t, t, spread);
+    },
+    shrink(t, shrink) {
+        B.copyAndSpread(t, t, shrink, true);
     },
     ceil(t) {
         const { x, y } = t;
@@ -1067,12 +1064,12 @@ class Bounds {
     getFitMatrix(put, baseScale) {
         return BoundsHelper.getFitMatrix(this, put, baseScale);
     }
-    spread(fourNumber, spreadY) {
-        BoundsHelper.spread(this, fourNumber, spreadY);
+    spread(fourNumber) {
+        BoundsHelper.spread(this, fourNumber);
         return this;
     }
     shrink(fourNumber) {
-        BoundsHelper.spread(this, MathHelper.minus(fourNumber, true));
+        BoundsHelper.shrink(this, fourNumber);
         return this;
     }
     ceil() {
@@ -1189,6 +1186,10 @@ var Direction9;
     Direction9[Direction9["bottomLeft"] = 6] = "bottomLeft";
     Direction9[Direction9["left"] = 7] = "left";
     Direction9[Direction9["center"] = 8] = "center";
+    Direction9[Direction9["top-left"] = 0] = "top-left";
+    Direction9[Direction9["top-right"] = 2] = "top-right";
+    Direction9[Direction9["bottom-right"] = 4] = "bottom-right";
+    Direction9[Direction9["bottom-left"] = 6] = "bottom-left";
 })(Direction9 || (Direction9 = {}));
 
 const directionData = [
@@ -1202,6 +1203,7 @@ const directionData = [
     { x: 0, y: 0.5 },
     { x: 0.5, y: 0.5 }
 ];
+directionData.forEach(item => item.type = 'percent');
 const AroundHelper = {
     directionData,
     tempPoint: {},
@@ -1209,15 +1211,19 @@ const AroundHelper = {
     toPoint(around, bounds, to, onlySize, pointBounds) {
         to || (to = {});
         const point = get$5(around);
-        to.x = point.x * bounds.width;
-        to.y = point.y * bounds.height;
-        if (pointBounds) {
-            to.x -= pointBounds.x;
-            to.y -= pointBounds.y;
-            if (point.x)
-                to.x -= (point.x === 1) ? pointBounds.width : (point.x === 0.5 ? point.x * pointBounds.width : 0);
-            if (point.y)
-                to.y -= (point.y === 1) ? pointBounds.height : (point.y === 0.5 ? point.y * pointBounds.height : 0);
+        to.x = point.x;
+        to.y = point.y;
+        if (point.type === 'percent') {
+            to.x *= bounds.width;
+            to.y *= bounds.height;
+            if (pointBounds) {
+                to.x -= pointBounds.x;
+                to.y -= pointBounds.y;
+                if (point.x)
+                    to.x -= (point.x === 1) ? pointBounds.width : (point.x === 0.5 ? point.x * pointBounds.width : 0);
+                if (point.y)
+                    to.y -= (point.y === 1) ? pointBounds.height : (point.y === 0.5 ? point.y * pointBounds.height : 0);
+            }
         }
         if (!onlySize) {
             to.x += bounds.x;
@@ -1229,6 +1235,13 @@ function get$5(around) {
     return typeof around === 'string' ? directionData[Direction9[around]] : around;
 }
 
+const { toPoint: toPoint$4 } = AroundHelper;
+const AlignHelper = {
+    toPoint(align, contentBounds, bounds, to, onlySize) {
+        toPoint$4(align, bounds, to, onlySize, contentBounds);
+    }
+};
+
 const StringNumberMap = {
     '0': 1,
     '1': 1,
@@ -1461,13 +1474,21 @@ const DataHelper = {
     },
     clone(data) {
         return JSON.parse(JSON.stringify(data));
+    },
+    toMap(list) {
+        const map = {};
+        for (let i = 0, len = list.length; i < len; i++)
+            map[list[i]] = true;
+        return map;
     }
 };
 const { assign } = DataHelper;
 
 class LeafData {
+    get __useNaturalRatio() { return true; }
+    get __isLinePath() { return this.path && this.path.length === 6; }
     get __blendMode() {
-        if (this.eraser)
+        if (this.eraser && this.eraser !== 'path')
             return 'destination-out';
         const { blendMode } = this;
         return blendMode === 'pass-through' ? null : blendMode;
@@ -1963,6 +1984,11 @@ class LeaferCanvasBase extends Canvas$1 {
     }
     updateViewSize() { }
     updateClientBounds() { }
+    getClientBounds(update) {
+        if (update)
+            this.updateClientBounds();
+        return this.clientBounds || this.bounds;
+    }
     startAutoLayout(_autoBounds, _listener) { }
     stopAutoLayout() { }
     setCursor(_cursor) { }
@@ -2097,7 +2123,7 @@ class LeaferCanvasBase extends Canvas$1 {
     }
     clear() {
         const { pixelRatio } = this;
-        this.clearRect(0, 0, this.width * pixelRatio, this.height * pixelRatio);
+        this.clearRect(0, 0, this.width * pixelRatio + 2, this.height * pixelRatio + 2);
     }
     isSameSize(size) {
         return this.width === size.width && this.height === size.height && this.pixelRatio === size.pixelRatio;
@@ -2214,7 +2240,7 @@ const RectHelper = {
 
 const { sin: sin$3, cos: cos$3, atan2: atan2$1, ceil: ceil$1, abs: abs$3, PI: PI$2, sqrt: sqrt$1, pow } = Math;
 const { setPoint: setPoint$2, addPoint: addPoint$2 } = TwoPointBoundsHelper;
-const { set: set$2 } = PointHelper;
+const { set } = PointHelper;
 const { M: M$5, L: L$6, C: C$5, Q: Q$4, Z: Z$5 } = PathCommandMap;
 const tempPoint$2 = {};
 const BezierHelper = {
@@ -2292,9 +2318,9 @@ const BezierHelper = {
                 addPoint$2(setPointBounds, x1, y1);
             }
             if (setStartPoint)
-                set$2(setStartPoint, fromX, fromY);
+                set(setStartPoint, fromX, fromY);
             if (setEndPoint)
-                set$2(setEndPoint, x1, y1);
+                set(setEndPoint, x1, y1);
             return;
         }
         const anticlockwise = BAx * CBy - CBx * BAy < 0;
@@ -2343,7 +2369,7 @@ const BezierHelper = {
         if (setPointBounds)
             setPoint$2(setPointBounds, fromX, fromY);
         if (setStartPoint)
-            set$2(setStartPoint, fromX, fromY);
+            set(setStartPoint, fromX, fromY);
         for (let i = 0; i < parts; i++) {
             endCos = cos$3(endRadian);
             endSin = sin$3(endRadian);
@@ -2365,7 +2391,7 @@ const BezierHelper = {
             endRadian += partRadian;
         }
         if (setEndPoint)
-            set$2(setEndPoint, cx + x, cy + y);
+            set(setEndPoint, cx + x, cy + y);
     },
     quadraticCurveTo(data, fromX, fromY, x1, y1, toX, toY) {
         data.push(C$5, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
@@ -2511,11 +2537,15 @@ const PathConvert = {
             char = pathString[i];
             if (StringNumberMap[char]) {
                 if (char === '.') {
-                    current.dot++;
-                    if (current.dot > 1) {
+                    if (current.dot) {
                         pushData(data, num);
                         num = '';
                     }
+                    current.dot++;
+                }
+                if (num === '0' && char !== '.') {
+                    pushData(data, num);
+                    num = '';
                 }
                 num += char;
             }
@@ -3605,7 +3635,9 @@ class LeaferImage {
     }
 }
 
-function defineKey(target, key, descriptor) {
+function defineKey(target, key, descriptor, noConfigurable) {
+    if (!noConfigurable)
+        descriptor.configurable = descriptor.enumerable = true;
     Object.defineProperty(target, key, descriptor);
 }
 function getDescriptor(object, name) {
@@ -3624,9 +3656,7 @@ function attr(partDescriptor) {
 function defineLeafAttr(target, key, defaultValue, partDescriptor) {
     const defaultDescriptor = {
         get() { return this.__getAttr(key); },
-        set(value) { this.__setAttr(key, value); },
-        configurable: true,
-        enumerable: true
+        set(value) { this.__setAttr(key, value); }
     };
     defineKey(target, key, Object.assign(defaultDescriptor, partDescriptor || {}));
     defineDataProcessor(target, key, defaultValue);
@@ -3637,35 +3667,33 @@ function dataType(defaultValue) {
 function positionType(defaultValue, checkFiniteNumber) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value, checkFiniteNumber);
-            this.__layout.matrixChanged || this.__layout.matrixChange();
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.matrixChanged || this.__layout.matrixChange());
         }
     }));
 }
 function autoLayoutType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.__layout.matrixChanged || this.__layout.matrixChange();
-            this.__hasAutoLayout = !!value;
-            if (!this.__local)
-                this.__layout.createLocal();
+            if (this.__setAttr(key, value)) {
+                this.__layout.matrixChanged || this.__layout.matrixChange();
+                this.__hasAutoLayout = !!value;
+                if (!this.__local)
+                    this.__layout.createLocal();
+            }
         }
     }));
 }
 function scaleType(defaultValue, checkFiniteNumber) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value, checkFiniteNumber);
-            this.__layout.scaleChanged || this.__layout.scaleChange();
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.scaleChanged || this.__layout.scaleChange());
         }
     }));
 }
 function rotationType(defaultValue, checkFiniteNumber) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value, checkFiniteNumber);
-            this.__layout.rotationChanged || this.__layout.rotationChange();
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.rotationChanged || this.__layout.rotationChange());
         }
     }));
 }
@@ -3679,9 +3707,7 @@ function boundsType(defaultValue, checkFiniteNumber) {
 function naturalBoundsType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            doBoundsType(this);
-            this.__.__removeNaturalSize();
+            this.__setAttr(key, value) && (doBoundsType(this), this.__.__removeNaturalSize());
         }
     }));
 }
@@ -3693,8 +3719,11 @@ function doBoundsType(leaf) {
 function pathInputType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            if (this.__.__pathInputed !== 2)
-                this.__.__pathInputed = value ? 1 : 0;
+            const data = this.__;
+            if (data.__pathInputed !== 2)
+                data.__pathInputed = value ? 1 : 0;
+            if (!value)
+                data.__pathForRender = undefined;
             this.__setAttr(key, value);
             doBoundsType(this);
         }
@@ -3725,54 +3754,66 @@ function affectRenderBoundsType(defaultValue) {
 function surfaceType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.__layout.surfaceChanged || this.__layout.surfaceChange();
+            this.__setAttr(key, value) && (this.__layout.surfaceChanged || this.__layout.surfaceChange());
         }
     }));
 }
 function opacityType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.__layout.opacityChanged || this.__layout.opacityChange();
+            this.__setAttr(key, value) && (this.__layout.opacityChanged || this.__layout.opacityChange());
+        }
+    }));
+}
+function visibleType(defaultValue) {
+    return decorateLeafAttr(defaultValue, (key) => attr({
+        set(value) {
+            const oldValue = this.visible;
+            if (this.__setAttr(key, value)) {
+                this.__layout.opacityChanged || this.__layout.opacityChange();
+                if (oldValue === 0 || value === 0)
+                    doBoundsType(this);
+            }
         }
     }));
 }
 function sortType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.__layout.surfaceChanged || this.__layout.surfaceChange();
-            this.waitParent(() => { this.parent.__layout.childrenSortChange(); });
+            if (this.__setAttr(key, value)) {
+                this.__layout.surfaceChanged || this.__layout.surfaceChange();
+                this.waitParent(() => { this.parent.__layout.childrenSortChange(); });
+            }
         }
     }));
 }
 function maskType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.__layout.boxChanged || this.__layout.boxChange();
-            this.waitParent(() => { this.parent.__updateMask(value); });
+            if (this.__setAttr(key, value)) {
+                this.__layout.boxChanged || this.__layout.boxChange();
+                this.waitParent(() => { this.parent.__updateMask(value); });
+            }
         }
     }));
 }
 function eraserType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            this.waitParent(() => { this.parent.__updateEraser(value); });
+            this.__setAttr(key, value) && this.waitParent(() => { this.parent.__updateEraser(value); });
         }
     }));
 }
 function hitType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            if (Debug.showHitView) {
-                this.__layout.surfaceChanged || this.__layout.surfaceChange();
+            if (this.__setAttr(key, value)) {
+                if (Debug.showHitView) {
+                    this.__layout.surfaceChanged || this.__layout.surfaceChange();
+                }
+                if (this.leafer)
+                    this.leafer.updateCursor();
             }
-            if (this.leafer)
-                this.leafer.updateCursor();
         }
     }));
 }
@@ -3813,9 +3854,7 @@ function defineDataProcessor(target, key, defaultValue) {
         },
         set(value) {
             this[computedKey] = value;
-        },
-        configurable: true,
-        enumerable: true
+        }
     };
     if (defaultValue === undefined) {
         property.get = function () { return this[computedKey]; };
@@ -3823,13 +3862,25 @@ function defineDataProcessor(target, key, defaultValue) {
     else if (key === 'width') {
         property.get = function () {
             const v = this[computedKey];
-            return v === undefined ? (this.__naturalWidth || defaultValue) : v;
+            if (v === undefined) {
+                const t = this;
+                return t._height && t.__naturalWidth && t.__useNaturalRatio ? t._height * t.__naturalWidth / t.__naturalHeight : t.__naturalWidth || defaultValue;
+            }
+            else {
+                return v;
+            }
         };
     }
     else if (key === 'height') {
         property.get = function () {
             const v = this[computedKey];
-            return v === undefined ? (this.__naturalHeight || defaultValue) : v;
+            if (v === undefined) {
+                const t = this;
+                return t._width && t.__naturalHeight && t.__useNaturalRatio ? t._width * t.__naturalHeight / t.__naturalWidth : t.__naturalHeight || defaultValue;
+            }
+            else {
+                return v;
+            }
         };
     }
     let descriptor, find = data;
@@ -3843,7 +3894,7 @@ function defineDataProcessor(target, key, defaultValue) {
         property.set = data[setMethodName];
         delete data[setMethodName];
     }
-    Object.defineProperty(data, key, property);
+    defineKey(data, key, property);
 }
 
 const debug$9 = new Debug('rewrite');
@@ -4044,13 +4095,6 @@ const LeafHelper = {
                 return true;
             p = p.parent;
         }
-    },
-    hasParentAutoLayout(p) {
-        while (p.parent) {
-            p = p.parent;
-            if (p.__hasAutoLayout)
-                return true;
-        }
     }
 };
 const L = LeafHelper;
@@ -4070,13 +4114,13 @@ const LeafBoundsHelper = {
         return target.__world;
     },
     localBoxBounds(target) {
-        return target.__.eraser ? null : (target.__local || target.__layout);
+        return target.__.eraser || target.__.visible === 0 ? null : (target.__local || target.__layout);
     },
     localStrokeBounds(target) {
-        return target.__.eraser ? null : target.__layout.localStrokeBounds;
+        return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localStrokeBounds;
     },
     localRenderBounds(target) {
-        return target.__.eraser ? null : target.__layout.localRenderBounds;
+        return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localRenderBounds;
     },
     maskLocalBoxBounds(target) {
         return target.__.mask ? target.__localBoxBounds : null;
@@ -4182,11 +4226,19 @@ const WaitHelper = {
 
 const { getRelativeWorld: getRelativeWorld$1 } = LeafHelper;
 const { toOuterOf: toOuterOf$2, getPoints, copy: copy$6 } = BoundsHelper;
+const localContent = '_localContentBounds';
+const worldContent = '_worldContentBounds', worldBox = '_worldBoxBounds', worldStroke = '_worldStrokeBounds';
 class LeafLayout {
+    get contentBounds() { return this._contentBounds || this.boxBounds; }
+    set contentBounds(bounds) { this._contentBounds = bounds; }
     get strokeBounds() { return this._strokeBounds || this.boxBounds; }
     get renderBounds() { return this._renderBounds || this.boxBounds; }
+    get localContentBounds() { toOuterOf$2(this.contentBounds, this.leaf.__localMatrix, this[localContent] || (this[localContent] = {})); return this[localContent]; }
     get localStrokeBounds() { return this._localStrokeBounds || this; }
     get localRenderBounds() { return this._localRenderBounds || this; }
+    get worldContentBounds() { toOuterOf$2(this.contentBounds, this.leaf.__world, this[worldContent] || (this[worldContent] = {})); return this[worldContent]; }
+    get worldBoxBounds() { toOuterOf$2(this.boxBounds, this.leaf.__world, this[worldBox] || (this[worldBox] = {})); return this[worldBox]; }
+    get worldStrokeBounds() { toOuterOf$2(this.strokeBounds, this.leaf.__world, this[worldStroke] || (this[worldStroke] = {})); return this[worldStroke]; }
     get a() { return 1; }
     get b() { return 0; }
     get c() { return 0; }
@@ -4269,7 +4321,6 @@ class LeafLayout {
             case 'content':
                 if (this.contentBounds)
                     return this.contentBounds;
-            case 'margin':
             case 'box':
                 return this.boxBounds;
             case 'stroke':
@@ -4282,8 +4333,9 @@ class LeafLayout {
                 return this.localRenderBounds;
             case 'stroke':
                 return this.localStrokeBounds;
-            case 'margin':
             case 'content':
+                if (this.contentBounds)
+                    return this.localContentBounds;
             case 'box':
                 return this.leaf.__localBoxBounds;
         }
@@ -4292,15 +4344,13 @@ class LeafLayout {
         switch (type) {
             case 'render':
                 return this.leaf.__world;
+            case 'stroke':
+                return this.worldStrokeBounds;
             case 'content':
                 if (this.contentBounds)
-                    return this.getWorldContentBounds();
-            case 'margin':
+                    return this.worldContentBounds;
             case 'box':
-                return this.getWorldBoxBounds();
-            case 'margin':
-            case 'stroke':
-                return this.getWorldStrokeBounds();
+                return this.worldBoxBounds;
         }
     }
     getLayoutBounds(type, relative = 'world', unscale) {
@@ -4363,20 +4413,24 @@ class LeafLayout {
             points.forEach(point => leaf.innerToWorld(point, null, false, relativeLeaf));
         return points;
     }
-    getWorldContentBounds() {
-        this._worldContentBounds || (this._worldContentBounds = {});
-        toOuterOf$2(this.contentBounds, this.leaf.__world, this._worldContentBounds);
-        return this._worldContentBounds;
+    shrinkContent() {
+        const { x, y, width, height } = this.boxBounds;
+        this._contentBounds = { x, y, width, height };
     }
-    getWorldBoxBounds() {
-        this._worldBoxBounds || (this._worldBoxBounds = {});
-        toOuterOf$2(this.boxBounds, this.leaf.__world, this._worldBoxBounds);
-        return this._worldBoxBounds;
+    spreadStroke() {
+        const { x, y, width, height } = this.strokeBounds;
+        this._strokeBounds = { x, y, width, height };
+        this._localStrokeBounds = { x, y, width, height };
+        if (!this.renderSpread)
+            this.spreadRenderCancel();
     }
-    getWorldStrokeBounds() {
-        this._worldStrokeBounds || (this._worldStrokeBounds = {});
-        toOuterOf$2(this.strokeBounds, this.leaf.__world, this._worldStrokeBounds);
-        return this._worldStrokeBounds;
+    spreadRender() {
+        const { x, y, width, height } = this.renderBounds;
+        this._renderBounds = { x, y, width, height };
+        this._localRenderBounds = { x, y, width, height };
+    }
+    shrinkContentCancel() {
+        this._contentBounds = undefined;
     }
     spreadStrokeCancel() {
         const same = this.renderBounds === this.strokeBounds;
@@ -4389,18 +4443,6 @@ class LeafLayout {
         this._renderBounds = this._strokeBounds;
         this._localRenderBounds = this._localStrokeBounds;
     }
-    spreadStroke() {
-        const { x, y, width, height } = this.strokeBounds;
-        this._strokeBounds = { x, y, width, height };
-        this._localStrokeBounds = { x, y, width, height };
-        if (!this.renderSpread)
-            this.spreadRenderCancel();
-    }
-    spreadRender() {
-        const { x, y, width, height } = this.renderBounds;
-        this._renderBounds = { x, y, width, height };
-        this._localRenderBounds = { x, y, width, height };
-    }
     boxChange() {
         this.boxChanged = true;
         this.localBoxChanged || this.localBoxChange();
@@ -4487,24 +4529,40 @@ const LeafEventer = {
         });
     },
     off(type, listener, options) {
-        let capture;
-        if (options)
-            capture = typeof options === 'boolean' ? options : options.capture;
-        let events, index;
-        const map = __getListenerMap(this, capture);
-        const typeList = typeof type === 'string' ? type.split(' ') : type;
-        typeList.forEach(type => {
-            if (type) {
-                events = map[type];
-                if (events) {
-                    index = events.findIndex(item => item.listener === listener);
-                    if (index > -1)
-                        events.splice(index, 1);
-                    if (!events.length)
-                        delete map[type];
-                }
+        if (type) {
+            const typeList = typeof type === 'string' ? type.split(' ') : type;
+            if (listener) {
+                let capture;
+                if (options)
+                    capture = typeof options === 'boolean' ? options : options.capture;
+                let events, index;
+                const map = __getListenerMap(this, capture);
+                typeList.forEach(type => {
+                    if (type) {
+                        events = map[type];
+                        if (events) {
+                            index = events.findIndex(item => item.listener === listener);
+                            if (index > -1)
+                                events.splice(index, 1);
+                            if (!events.length)
+                                delete map[type];
+                        }
+                    }
+                });
             }
-        });
+            else {
+                const { __bubbleMap: b, __captureMap: c } = this;
+                typeList.forEach(type => {
+                    if (b)
+                        delete b[type];
+                    if (c)
+                        delete c[type];
+                });
+            }
+        }
+        else {
+            this.__bubbleMap = this.__captureMap = undefined;
+        }
     },
     on_(type, listener, bind, options) {
         if (bind)
@@ -4768,10 +4826,10 @@ const LeafDataProxy = {
 };
 
 const { setLayout, multiplyParent: multiplyParent$1, translateInner, defaultWorld } = MatrixHelper;
-const { toPoint, tempPoint: tempPoint$1 } = AroundHelper;
+const { toPoint: toPoint$3, tempPoint: tempPoint$1 } = AroundHelper;
 const LeafMatrix = {
     __updateWorldMatrix() {
-        multiplyParent$1(this.__local || this.__layout, this.parent ? this.parent.__world : defaultWorld, this.__world, !!this.__layout.affectScaleOrRotation, this.__);
+        multiplyParent$1(this.__local || this.__layout, this.parent ? this.parent.__world : defaultWorld, this.__world, !!this.__layout.affectScaleOrRotation, this.__, this.parent && this.parent.__);
     },
     __updateLocalMatrix() {
         if (this.__local) {
@@ -4782,18 +4840,18 @@ const LeafMatrix = {
                     layout.scaleChanged = layout.rotationChanged = false;
                 }
             }
-            local.e = data.x;
-            local.f = data.y;
-            if (data.around) {
-                toPoint(data.around, layout.boxBounds, tempPoint$1);
-                translateInner(local, -tempPoint$1.x, -tempPoint$1.y);
+            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$1);
+                translateInner(local, -tempPoint$1.x, -tempPoint$1.y, data.origin);
             }
         }
         this.__layout.matrixChanged = false;
     }
 };
 
-const { updateMatrix: updateMatrix$1, updateAllMatrix: updateAllMatrix$2, hasParentAutoLayout } = LeafHelper;
+const { updateMatrix: updateMatrix$1, updateAllMatrix: updateAllMatrix$2 } = LeafHelper;
 const { updateBounds: updateBounds$1 } = BranchHelper;
 const { toOuterOf: toOuterOf$1, copyAndSpread: copyAndSpread$1, copy: copy$5 } = BoundsHelper;
 const { toBounds: toBounds$2 } = PathBounds;
@@ -4812,7 +4870,6 @@ const LeafBounds = {
                 this.__updatePath();
             this.__updateRenderPath();
             this.__updateBoxBounds();
-            layout.boxChanged = false;
             layout.resized = true;
         }
         if (layout.localBoxChanged) {
@@ -4826,12 +4883,12 @@ const LeafBounds = {
             if (this.parent)
                 this.parent.__layout.boxChange();
         }
+        layout.boxChanged = false;
         if (layout.strokeChanged) {
             layout.strokeSpread = this.__updateStrokeSpread();
             if (layout.strokeSpread) {
-                if (layout.strokeBounds === layout.boxBounds) {
+                if (layout.strokeBounds === layout.boxBounds)
                     layout.spreadStroke();
-                }
                 this.__updateStrokeBounds();
                 this.__updateLocalStrokeBounds();
             }
@@ -4839,7 +4896,7 @@ const LeafBounds = {
                 layout.spreadStrokeCancel();
             }
             layout.strokeChanged = false;
-            if (layout.renderSpread)
+            if (layout.renderSpread || layout.strokeSpread !== layout.strokeBoxSpread)
                 layout.renderChanged = true;
             if (this.parent)
                 this.parent.__layout.strokeChange();
@@ -4848,9 +4905,8 @@ const LeafBounds = {
         if (layout.renderChanged) {
             layout.renderSpread = this.__updateRenderSpread();
             if (layout.renderSpread) {
-                if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) {
+                if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds)
                     layout.spreadRender();
-                }
                 this.__updateRenderBounds();
                 this.__updateLocalRenderBounds();
             }
@@ -4890,10 +4946,15 @@ const LeafBounds = {
     __updateAutoLayout() {
         this.__layout.matrixChanged = true;
         if (this.isBranch) {
-            if (this.leafer)
+            if (this.leafer && this.leafer.ready)
                 this.leafer.layouter.addExtra(this);
-            if (hasParentAutoLayout(this)) {
-                updateMatrix$1(this);
+            if (this.__.flow) {
+                if (this.__layout.boxChanged)
+                    this.__updateFlowLayout();
+                updateAllMatrix$2(this);
+                updateBounds$1(this, this);
+                if (this.__.__autoSide)
+                    this.__updateBoxBounds();
             }
             else {
                 updateAllMatrix$2(this);
@@ -4910,12 +4971,13 @@ const LeafBounds = {
         data.__naturalHeight = layout.boxBounds.height;
     },
     __updateStrokeBounds() {
-        copyAndSpread$1(this.__layout.strokeBounds, this.__layout.boxBounds, this.__layout.strokeSpread);
+        const layout = this.__layout;
+        copyAndSpread$1(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread);
     },
     __updateRenderBounds() {
-        const { renderSpread, strokeBounds, renderBounds } = this.__layout;
-        renderSpread > 0 ? copyAndSpread$1(renderBounds, strokeBounds, renderSpread) : copy$5(renderBounds, strokeBounds);
-    },
+        const layout = this.__layout;
+        layout.renderSpread > 0 ? copyAndSpread$1(layout.renderBounds, layout.boxBounds, layout.renderSpread) : copy$5(layout.renderBounds, layout.strokeBounds);
+    }
 };
 
 const LeafRender = {
@@ -4924,6 +4986,8 @@ const LeafRender = {
             canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
             canvas.opacity = this.__.opacity;
             if (this.__.__single) {
+                if (this.__.eraser === 'path')
+                    return this.__renderEraser(canvas, options);
                 const tempCanvas = canvas.getSameCanvas(true, true);
                 this.__draw(tempCanvas, options);
                 if (this.__worldFlipped) {
@@ -4966,6 +5030,8 @@ const BranchRender = {
     __render(canvas, options) {
         if (this.__worldOpacity) {
             if (this.__.__single) {
+                if (this.__.eraser === 'path')
+                    return this.__renderEraser(canvas, options);
                 const tempCanvas = canvas.getSameCanvas(false, true);
                 this.__renderBranch(tempCanvas, options);
                 const nowWorld = this.__getNowWorld(options);
@@ -5031,7 +5097,7 @@ let Leaf = class Leaf {
     get __worldFlipped() { return this.__world.scaleX < 0 || this.__world.scaleY < 0; }
     get __onlyHitMask() { return this.__hasMask && !this.__.hitChildren; }
     get __ignoreHitWorld() { return (this.__hasMask || this.__hasEraser) && this.__.hitChildren; }
-    get pathInputed() { return !!this.__.__pathInputed; }
+    get pathInputed() { return this.__.__pathInputed; }
     constructor(data) {
         this.innerId = create(LEAF);
         this.reset(data);
@@ -5105,7 +5171,9 @@ let Leaf = class Leaf {
     setProxyAttr(_attrName, _newValue) { }
     getProxyAttr(_attrName) { return undefined; }
     find(_condition, _options) { return undefined; }
+    findTag(_tag) { return undefined; }
     findOne(_condition, _options) { return undefined; }
+    findId(_id) { return undefined; }
     focus(_value) { }
     forceUpdate(attrName) {
         if (attrName === undefined)
@@ -5127,9 +5195,11 @@ let Leaf = class Leaf {
     __updateLocalStrokeBounds() { }
     __updateLocalRenderBounds() { }
     __updateBoxBounds() { }
+    __updateContentBounds() { }
     __updateStrokeBounds() { }
     __updateRenderBounds() { }
     __updateAutoLayout() { }
+    __updateFlowLayout() { }
     __updateNaturalSize() { }
     __updateStrokeSpread() { return 0; }
     __updateRenderSpread() { return 0; }
@@ -5137,6 +5207,13 @@ let Leaf = class Leaf {
     __updateEraser(value) {
         this.__hasEraser = value ? true : this.children.some(item => item.__.eraser);
     }
+    __renderEraser(canvas, options) {
+        canvas.save();
+        this.__clip(canvas, options);
+        const { renderBounds: r } = this.__layout;
+        canvas.clearRect(r.x, r.y, r.width, r.height);
+        canvas.restore();
+    }
     __updateMask(value) {
         this.__hasMask = value ? true : this.children.some(item => item.__.mask);
     }
@@ -5317,8 +5394,8 @@ let Leaf = class Leaf {
     emit(_type, _event, _capture) { }
     emitEvent(_event, _capture) { }
     hasEvent(_type, _capture) { return false; }
-    static changeAttr(attrName, defaultValue) {
-        defineDataProcessor(this.prototype, attrName, defaultValue);
+    static changeAttr(attrName, defaultValue, fn) {
+        fn ? this.addAttr(attrName, defaultValue, fn) : defineDataProcessor(this.prototype, attrName, defaultValue);
     }
     static addAttr(attrName, defaultValue, fn) {
         if (!fn)
@@ -5632,6 +5709,9 @@ class LeafLevelList {
     }
 }
 
+const version = "1.0.0-rc.24";
+const inviteCode = {};
+
 const debug$7 = Debug.get('LeaferCanvas');
 class LeaferCanvas extends LeaferCanvasBase {
     init() {
@@ -5815,7 +5895,7 @@ function useCanvas(_canvasType, _power) {
                 }
                 img.onload = () => { resolve(img); };
                 img.onerror = (e) => { reject(e); };
-                if (!src.startsWith('data:') && !src.startsWith('blob:') && suffix)
+                if (suffix && !src.startsWith('data:') && !src.startsWith('blob:'))
                     src += (src.includes("?") ? "&" : "?") + suffix;
                 img.src = src;
             });
@@ -6305,7 +6385,7 @@ class Renderer {
             canvas.clear();
         }
         else {
-            bounds.spread(1 + 1 / this.canvas.pixelRatio).ceil();
+            bounds.spread(10 + 1 / this.canvas.pixelRatio).ceil();
             canvas.clearWorld(bounds, true);
             canvas.clipWorld(bounds, true);
         }
@@ -6377,8 +6457,11 @@ class Renderer {
             if (!bounds.includes(this.target.__world) || this.needFill || !e.samePixelRatio) {
                 this.addBlock(this.canvas.bounds);
                 this.target.forceUpdate('surface');
+                return;
             }
         }
+        this.addBlock(new Bounds(0, 0, 1, 1));
+        this.changed = true;
     }
     __onLayoutEnd(event) {
         if (event.data)
@@ -6551,6 +6634,7 @@ class Picker {
 }
 
 const { Yes, NoAndSkip, YesAndSkip } = Answer;
+const idCondition = {}, classNameCondition = {}, tagCondition = {};
 class Selector {
     constructor(target, userConfig) {
         this.config = {};
@@ -6560,7 +6644,8 @@ class Selector {
             id: (leaf, name) => leaf.id === name ? (this.idMap[name] = leaf, 1) : 0,
             innerId: (leaf, innerId) => leaf.innerId === innerId ? (this.innerIdMap[innerId] = leaf, 1) : 0,
             className: (leaf, name) => leaf.className === name ? 1 : 0,
-            tag: (leaf, name) => leaf.__tag === name ? 1 : 0
+            tag: (leaf, name) => leaf.__tag === name ? 1 : 0,
+            tags: (leaf, nameMap) => nameMap[leaf.__tag] ? 1 : 0
         };
         this.target = target;
         if (userConfig)
@@ -6576,12 +6661,25 @@ class Selector {
             case 'string':
                 switch (condition[0]) {
                     case '#':
-                        const leaf = this.getById(condition.substring(1), branch);
-                        return one ? leaf : (leaf ? [leaf] : []);
+                        idCondition.id = condition.substring(1), condition = idCondition;
+                        break;
                     case '.':
-                        return this.getByMethod(this.methods.className, branch, one, condition.substring(1));
+                        classNameCondition.className = condition.substring(1), condition = classNameCondition;
+                        break;
                     default:
-                        return this.getByMethod(this.methods.tag, branch, one, condition);
+                        tagCondition.tag = condition, condition = tagCondition;
+                }
+            case 'object':
+                if (condition.id !== undefined) {
+                    const leaf = this.getById(condition.id, branch);
+                    return one ? leaf : (leaf ? [leaf] : []);
+                }
+                else if (condition.tag) {
+                    const { tag } = condition, isArray = tag instanceof Array;
+                    return this.getByMethod(isArray ? this.methods.tags : this.methods.tag, branch, one, isArray ? DataHelper.toMap(tag) : tag);
+                }
+                else {
+                    return this.getByMethod(this.methods.className, branch, one, condition.className);
                 }
             case 'function':
                 return this.getByMethod(condition, branch, one, options);
@@ -6704,10 +6802,11 @@ function stateType(defaultValue) {
 function arrowType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value);
-            const data = this.__;
-            data.__useArrow = data.startArrow !== 'none' || data.endArrow !== 'none';
-            doStrokeType(this);
+            if (this.__setAttr(key, value)) {
+                const data = this.__;
+                data.__useArrow = data.startArrow !== 'none' || data.endArrow !== 'none';
+                doStrokeType(this);
+            }
         }
     }));
 }
@@ -6880,7 +6979,7 @@ class UIData extends LeafData {
 const UnitConvert = {
     number(value, percentRefer) {
         if (typeof value === 'object')
-            return value.type === 'percent' ? value.value / 100 * percentRefer : value.value;
+            return value.type === 'percent' ? value.value * percentRefer : value.value;
         return value;
     }
 };
@@ -6889,7 +6988,7 @@ class GroupData extends UIData {
 }
 
 class BoxData extends GroupData {
-    get __boxStroke() { return true; }
+    get __boxStroke() { return !this.__pathInputed; }
 }
 
 class LeaferData extends GroupData {
@@ -6902,11 +7001,11 @@ class LineData extends UIData {
 }
 
 class RectData extends UIData {
-    get __boxStroke() { return true; }
+    get __boxStroke() { return !this.__pathInputed; }
 }
 
 class EllipseData extends UIData {
-    get __boxStroke() { return true; }
+    get __boxStroke() { return !this.__pathInputed; }
 }
 
 class PolygonData extends UIData {
@@ -6933,6 +7032,7 @@ const fontWeightMap = {
     'black': 900
 };
 class TextData extends UIData {
+    get __useNaturalRatio() { return false; }
     setFontWeight(value) {
         if (typeof value === 'string') {
             this.__setInput('fontWeight', value);
@@ -6974,19 +7074,18 @@ class CanvasData extends RectData {
 const UIBounds = {
     __updateStrokeSpread() {
         let width = 0, boxWidth = 0;
-        const { stroke, hitStroke, strokeAlign, strokeWidth } = this.__;
-        if ((stroke || hitStroke === 'all') && strokeWidth && strokeAlign !== 'inside') {
+        const data = this.__, { strokeAlign, strokeWidth } = data;
+        if ((data.stroke || data.hitStroke === 'all') && strokeWidth && strokeAlign !== 'inside') {
             boxWidth = width = strokeAlign === 'center' ? strokeWidth / 2 : strokeWidth;
-            if (!this.__.__boxStroke) {
-                const { miterLimit, strokeCap } = this.__;
-                const miterLimitAddWidth = this.__tag !== 'Line' ? 1 / Math.sin(miterLimit * OneRadian / 2) * Math.sqrt(strokeWidth) - width : 0;
-                const storkeCapAddWidth = strokeCap === 'none' ? 0 : strokeWidth;
+            if (!data.__boxStroke) {
+                const miterLimitAddWidth = data.__isLinePath ? 0 : 10 * width;
+                const storkeCapAddWidth = data.strokeCap === 'none' ? 0 : strokeWidth;
                 width += Math.max(miterLimitAddWidth, storkeCapAddWidth);
             }
         }
-        this.__layout.strokeBoxSpread = boxWidth;
-        if (this.__.__useArrow)
+        if (data.__useArrow)
             width += strokeWidth * 5;
+        this.__layout.strokeBoxSpread = boxWidth;
         return width;
     },
     __updateRenderSpread() {
@@ -7006,7 +7105,7 @@ const UIBounds = {
         if (backgroundBlur)
             shapeWidth = Math.max(shapeWidth, backgroundBlur);
         this.__layout.renderShapeSpread = shapeWidth;
-        return width;
+        return width + (this.__layout.strokeSpread || 0);
     }
 };
 
@@ -7097,7 +7196,7 @@ function drawFast(ui, canvas, options) {
 
 const RectRender = {
     __drawFast(canvas, options) {
-        const { width, height, fill, stroke, __drawAfterFill } = this.__;
+        let { width, height, fill, stroke, __drawAfterFill } = this.__;
         if (fill) {
             canvas.fillStyle = fill;
             canvas.fillRect(0, 0, width, height);
@@ -7115,7 +7214,16 @@ const RectRender = {
                     canvas.strokeRect(0, 0, width, height);
                     break;
                 case 'inside':
-                    canvas.strokeRect(half, half, width - __strokeWidth, height - __strokeWidth);
+                    width -= __strokeWidth, height -= __strokeWidth;
+                    if (width < 0 || height < 0) {
+                        canvas.save();
+                        this.__clip(canvas, options);
+                        canvas.strokeRect(half, half, width, height);
+                        canvas.restore();
+                    }
+                    else {
+                        canvas.strokeRect(half, half, width, height);
+                    }
                     break;
                 case 'outside':
                     canvas.strokeRect(-half, -half, width + __strokeWidth, height + __strokeWidth);
@@ -7143,11 +7251,14 @@ let UI = UI_1 = class UI extends Leaf {
         return scaleX !== scaleY ? { x: scaleX, y: scaleY } : scaleX;
     }
     get pen() {
-        pen.set(this.path = this.__.path || []);
+        const { path } = this.__;
+        pen.set(this.path = path || []);
+        if (!path)
+            this.__drawPathByBox(pen);
         return pen;
     }
     get editConfig() { return undefined; }
-    get editOuter() { return 'EditTool'; }
+    get editOuter() { return this.__.__isLinePath ? 'LineEditTool' : 'EditTool'; }
     get editInner() { return 'PathEditor'; }
     constructor(data) {
         super(data);
@@ -7161,22 +7272,22 @@ let UI = UI_1 = class UI extends Leaf {
     }
     createProxyData() { return undefined; }
     find(_condition, _options) { return undefined; }
+    findTag(tag) { return this.find({ tag }); }
     findOne(_condition, _options) { return undefined; }
+    findId(id) { return this.findOne({ id }); }
     getPath(curve, pathForRender) {
         this.__layout.update();
         let path = pathForRender ? this.__.__pathForRender : this.__.path;
-        if (!path) {
-            const { width, height } = this.boxBounds;
-            if (width || height) {
-                pen.set(path = []);
-                this.__drawPathByBox(pen);
-            }
-        }
+        if (!path)
+            pen.set(path = []), this.__drawPathByBox(pen);
         return curve ? PathConvert.toCanvasData(path, true) : path;
     }
     getPathString(curve, pathForRender) {
         return PathConvert.stringify(this.getPath(curve, pathForRender));
     }
+    load() {
+        this.__.__computePaint();
+    }
     __onUpdateSize() {
         if (this.__.__input) {
             const data = this.__;
@@ -7262,7 +7373,7 @@ __decorate([
     opacityType(1)
 ], UI.prototype, "opacity", void 0);
 __decorate([
-    opacityType(true)
+    visibleType(true)
 ], UI.prototype, "visible", void 0);
 __decorate([
     stateType(false)
@@ -7279,9 +7390,6 @@ __decorate([
 __decorate([
     maskType(false)
 ], UI.prototype, "mask", void 0);
-__decorate([
-    surfaceType('pixel')
-], UI.prototype, "maskType", void 0);
 __decorate([
     eraserType(false)
 ], UI.prototype, "eraser", void 0);
@@ -7312,9 +7420,75 @@ __decorate([
 __decorate([
     rotationType(0, true)
 ], UI.prototype, "skewY", void 0);
+__decorate([
+    positionType(0, true)
+], UI.prototype, "offsetX", void 0);
+__decorate([
+    positionType(0, true)
+], UI.prototype, "offsetY", void 0);
+__decorate([
+    positionType(0, true)
+], UI.prototype, "scrollX", void 0);
+__decorate([
+    positionType(0, true)
+], UI.prototype, "scrollY", void 0);
+__decorate([
+    autoLayoutType()
+], UI.prototype, "origin", void 0);
 __decorate([
     autoLayoutType()
 ], UI.prototype, "around", void 0);
+__decorate([
+    dataType(false)
+], UI.prototype, "lazy", void 0);
+__decorate([
+    naturalBoundsType(1)
+], UI.prototype, "pixelRatio", void 0);
+__decorate([
+    pathInputType()
+], UI.prototype, "path", void 0);
+__decorate([
+    pathType()
+], UI.prototype, "windingRule", void 0);
+__decorate([
+    pathType(true)
+], UI.prototype, "closed", void 0);
+__decorate([
+    autoLayoutType(false)
+], UI.prototype, "flow", void 0);
+__decorate([
+    boundsType(0)
+], UI.prototype, "padding", void 0);
+__decorate([
+    boundsType(0)
+], UI.prototype, "gap", void 0);
+__decorate([
+    boundsType('top-left')
+], UI.prototype, "align", void 0);
+__decorate([
+    boundsType(false)
+], UI.prototype, "wrap", void 0);
+__decorate([
+    boundsType('box')
+], UI.prototype, "itemBox", void 0);
+__decorate([
+    boundsType(true)
+], UI.prototype, "inFlow", void 0);
+__decorate([
+    boundsType()
+], UI.prototype, "autoWidth", void 0);
+__decorate([
+    boundsType()
+], UI.prototype, "autoHeight", void 0);
+__decorate([
+    boundsType()
+], UI.prototype, "autoBox", void 0);
+__decorate([
+    boundsType()
+], UI.prototype, "widthRange", void 0);
+__decorate([
+    boundsType()
+], UI.prototype, "heightRange", void 0);
 __decorate([
     dataType(false)
 ], UI.prototype, "draggable", void 0);
@@ -7324,9 +7498,6 @@ __decorate([
 __decorate([
     dataType(false)
 ], UI.prototype, "editable", void 0);
-__decorate([
-    dataType('size')
-], UI.prototype, "editSize", void 0);
 __decorate([
     hitType(true)
 ], UI.prototype, "hittable", void 0);
@@ -7381,21 +7552,6 @@ __decorate([
 __decorate([
     strokeType(10)
 ], UI.prototype, "miterLimit", void 0);
-__decorate([
-    dataType(false)
-], UI.prototype, "lazy", void 0);
-__decorate([
-    naturalBoundsType(1)
-], UI.prototype, "pixelRatio", void 0);
-__decorate([
-    pathInputType()
-], UI.prototype, "path", void 0);
-__decorate([
-    pathType()
-], UI.prototype, "windingRule", void 0);
-__decorate([
-    pathType(true)
-], UI.prototype, "closed", void 0);
 __decorate([
     arrowType('none')
 ], UI.prototype, "startArrow", void 0);
@@ -7526,6 +7682,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
     get layoutLocked() { return !this.layouter.running; }
     get FPS() { return this.renderer ? this.renderer.FPS : 60; }
     get cursorPoint() { return (this.interaction && this.interaction.hoverData) || { x: this.width / 2, y: this.height / 2 }; }
+    get clientBounds() { return this.canvas && this.canvas.getClientBounds(); }
     constructor(userConfig, data) {
         super(data);
         this.config = {
@@ -7629,9 +7786,6 @@ let Leafer = Leafer_1 = class Leafer extends Group {
         const data = DataHelper.copyAttrs({}, size, canvasSizeAttrs);
         Object.keys(data).forEach(key => this[key] = data[key]);
     }
-    forceFullRender() {
-        this.forceRender();
-    }
     forceRender(bounds) {
         this.renderer.addBlock(bounds ? new Bounds(bounds) : this.canvas.bounds);
         if (this.viewReady)
@@ -7686,7 +7840,8 @@ let Leafer = Leafer_1 = class Leafer extends Group {
                 this.__changeFill(newValue);
             }
             else if (attrName === 'hittable') {
-                this.canvas.hittable = newValue;
+                if (!this.parent)
+                    this.canvas.hittable = newValue;
             }
         }
         return super.__setAttr(attrName, newValue);
@@ -7709,7 +7864,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
             this.canvas.backgroundColor = newValue;
         }
         else {
-            this.forceFullRender();
+            this.forceRender();
         }
     }
     __onCreated() {
@@ -7804,6 +7959,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
     zoom(_zoomType, _padding, _fixedScale) { return undefined; }
     getValidMove(moveX, moveY) { return { x: moveX, y: moveY }; }
     getValidScale(changeScale) { return changeScale; }
+    getWorldPointByClient(clientPoint, updateClient) {
+        return this.interaction && this.interaction.getLocal(clientPoint, updateClient);
+    }
     __checkUpdateLayout() {
         this.__layout.update();
     }
@@ -7886,8 +8044,8 @@ Rect = __decorate([
 
 const rect$1 = Rect.prototype;
 const group$1 = Group.prototype;
-const bounds$1 = {};
-const { copy: copy$3, add } = BoundsHelper;
+const childrenRenderBounds = {};
+const { copy: copy$3, add, includes: includes$1 } = BoundsHelper;
 let Box = class Box extends Group {
     get __tag() { return 'Box'; }
     get isBranchLeaf() { return true; }
@@ -7898,24 +8056,29 @@ let Box = class Box extends Group {
     __updateStrokeSpread() { return 0; }
     __updateRectRenderSpread() { return 0; }
     __updateRenderSpread() {
-        const width = this.__updateRectRenderSpread();
-        const hide = this.__.__drawAfterFill = this.__.overflow === 'hide';
-        return (width || hide) ? width : -1;
+        return this.__updateRectRenderSpread() || -1;
     }
     __updateRectBoxBounds() { }
     __updateBoxBounds() {
         const data = this.__;
-        if (data.__autoSide && this.children.length) {
-            if (this.leafer)
-                this.leafer.layouter.addExtra(this);
-            super.__updateBoxBounds();
-            if (!data.__autoSize) {
-                const b = this.__layout.boxBounds;
-                if (!data.__autoWidth)
-                    b.x = 0, b.width = data.width;
-                if (!data.__autoHeight)
-                    b.y = 0, b.height = data.height;
+        if (this.children.length) {
+            if (data.__autoSide) {
+                if (this.leafer && this.leafer.ready)
+                    this.leafer.layouter.addExtra(this);
+                super.__updateBoxBounds();
+                if (!data.__autoSize) {
+                    const b = this.__layout.boxBounds;
+                    if (!data.__autoWidth)
+                        b.x = 0, b.width = data.width;
+                    if (!data.__autoHeight)
+                        b.y = 0, b.height = data.height;
+                }
+            }
+            else {
+                this.__updateRectBoxBounds();
             }
+            if (data.flow)
+                this.__updateContentBounds();
         }
         else {
             this.__updateRectBoxBounds();
@@ -7923,13 +8086,20 @@ let Box = class Box extends Group {
     }
     __updateStrokeBounds() { }
     __updateRenderBounds() {
-        this.__updateRectRenderBounds();
-        if (!this.__.__drawAfterFill) {
-            const { renderBounds } = this.__layout;
-            copy$3(bounds$1, renderBounds);
+        let isOverflow;
+        const { renderBounds } = this.__layout;
+        if (this.children.length) {
             super.__updateRenderBounds();
-            add(renderBounds, bounds$1);
+            copy$3(childrenRenderBounds, renderBounds);
+            this.__updateRectRenderBounds();
+            isOverflow = !includes$1(renderBounds, childrenRenderBounds) || undefined;
+        }
+        else {
+            this.__updateRectRenderBounds();
         }
+        this.isOverflow !== isOverflow && (this.isOverflow = isOverflow);
+        if (isOverflow && !(this.__.__drawAfterFill = this.__.overflow === 'hide'))
+            add(renderBounds, childrenRenderBounds);
     }
     __updateRectRenderBounds() { }
     __updateRectChange() { }
@@ -7945,16 +8115,27 @@ let Box = class Box extends Group {
         }
         else {
             this.__renderRect(canvas, options);
-            this.__renderGroup(canvas, options);
+            if (this.children.length)
+                this.__renderGroup(canvas, options);
         }
     }
     __drawAfterFill(canvas, options) {
-        canvas.save();
-        canvas.clip();
-        this.__renderGroup(canvas, options);
-        canvas.restore();
-        if (this.__.stroke)
+        const { length } = this.children;
+        if (this.isOverflow) {
+            canvas.save();
+            canvas.clip();
+            if (length)
+                this.__renderGroup(canvas, options);
+            canvas.restore();
+        }
+        else {
+            if (length)
+                this.__renderGroup(canvas, options);
+        }
+        if (this.__.stroke && length) {
+            canvas.setWorld(this.__nowWorld);
             this.__drawRenderPath(canvas);
+        }
     }
 };
 __decorate([
@@ -8092,9 +8273,10 @@ let Line = class Line extends UI {
         super(data);
     }
     __updatePath() {
-        const path = this.__.path = [];
-        if (this.__.points) {
-            drawPoints$1(path, this.__.points, this.__.closed);
+        const data = this.__;
+        const path = data.path = [];
+        if (data.points) {
+            drawPoints$1(path, data.points, false, data.closed);
         }
         else {
             moveTo$2(path, 0, 0);
@@ -8329,7 +8511,7 @@ Canvas = __decorate([
     registerUI()
 ], Canvas);
 
-const { copyAndSpread, includes, spread, setList } = BoundsHelper;
+const { copyAndSpread, includes, isSame: isSame$1, spread, setList } = BoundsHelper;
 let Text = class Text extends UI {
     get __tag() { return 'Text'; }
     get editInner() { return 'TextEditor'; }
@@ -8402,7 +8584,7 @@ let Text = class Text extends UI {
         if (italic)
             b.width += fontSize * 0.16;
         const contentBounds = includes(b, bounds) ? b : bounds;
-        if (contentBounds !== layout.contentBounds) {
+        if (!isSame$1(contentBounds, layout.contentBounds)) {
             layout.contentBounds = contentBounds;
             layout.renderChanged = true;
             setList(data.__textBoxBounds = {}, [b, bounds]);
@@ -8430,9 +8612,6 @@ __decorate([
 __decorate([
     boundsType(0)
 ], Text.prototype, "height", void 0);
-__decorate([
-    boundsType(0)
-], Text.prototype, "padding", void 0);
 __decorate([
     surfaceType('#000000')
 ], Text.prototype, "fill", void 0);
@@ -8467,7 +8646,7 @@ __decorate([
     boundsType(0)
 ], Text.prototype, "letterSpacing", void 0);
 __decorate([
-    boundsType({ type: 'percent', value: 150 })
+    boundsType({ type: 'percent', value: 1.5 })
 ], Text.prototype, "lineHeight", void 0);
 __decorate([
     boundsType(0)
@@ -8561,8 +8740,6 @@ function penPathType() {
     };
 }
 
-const version = "1.0.0-rc.21";
-
 let App = class App extends Leafer {
     get __tag() { return 'App'; }
     get isApp() { return true; }
@@ -8655,8 +8832,10 @@ let App = class App extends Leafer {
             this.renderer.update();
     }
     __render(canvas, options) {
-        if (options.matrix)
-            canvas.setWorld(options.matrix);
+        if (options.matrix) {
+            const { a, b, c, d, e, f } = options.matrix;
+            canvas.setTransform(a, b, c, d, e, f);
+        }
         this.children.forEach(leafer => canvas.copyWorld(leafer.canvas));
     }
     __onResize(event) {
@@ -9660,8 +9839,8 @@ class InteractionBase {
     }
     tap(data) {
         const { pointer } = this.config;
-        const longTap = this.longTap(data);
-        if (!pointer.tapMore && longTap)
+        const hasLong = this.longTap(data);
+        if (!pointer.tapMore && hasLong)
             return;
         if (!this.waitTap)
             return;
@@ -9783,6 +9962,10 @@ class InteractionBase {
     setCursor(cursor) {
         this.cursor = cursor;
     }
+    getLocal(clientPoint, updateClient) {
+        const clientBounds = this.canvas.getClientBounds(updateClient);
+        return { x: clientPoint.clientX - clientBounds.x, y: clientPoint.clientY - clientBounds.y };
+    }
     emitTap(data) {
         this.emit(PointerEvent.TAP, data);
         this.emit(PointerEvent.CLICK, data);
@@ -9812,14 +9995,14 @@ class InteractionBase {
         }, this.config.pointer.longPressTime);
     }
     longTap(data) {
-        let longTap;
+        let hasLong;
         if (this.longPressed) {
             this.emit(PointerEvent.LONG_TAP, data);
-            if (pathHasEventType(data.path, PointerEvent.LONG_TAP))
-                longTap = true;
+            if (pathHasEventType(data.path, PointerEvent.LONG_TAP) || pathHasEventType(data.path, PointerEvent.LONG_PRESS))
+                hasLong = true;
         }
         this.longPressWaitCancel();
-        return longTap;
+        return hasLong;
     }
     longPressWaitCancel() {
         clearTimeout(this.longPressTimer);
@@ -10177,12 +10360,6 @@ class Interaction extends InteractionBase {
             this.windowEvents = {};
         }
     }
-    getLocal(p, updateClient) {
-        if (updateClient)
-            this.canvas.updateClientBounds();
-        const { clientBounds } = this.canvas;
-        return { x: p.clientX - clientBounds.x, y: p.clientY - clientBounds.y };
-    }
     getTouches(touches) {
         const list = [];
         for (let i = 0, len = touches.length; i < len; i++) {
@@ -10619,7 +10796,7 @@ function shape(ui, current, options) {
     }
     else {
         const { renderShapeSpread: spread } = ui.__layout;
-        const worldClipBounds = getIntersectData(spread ? getSpread(current.bounds, spread * scaleX, spread * scaleY) : current.bounds, nowWorld);
+        const worldClipBounds = getIntersectData(spread ? getSpread(current.bounds, scaleX === scaleY ? spread * scaleX : [spread * scaleY, spread * scaleX]) : current.bounds, nowWorld);
         fitMatrix = current.bounds.getFitMatrix(worldClipBounds);
         let { a: fitScaleX, d: fitScaleY } = fitMatrix;
         if (fitMatrix.a < 1) {
@@ -10719,10 +10896,10 @@ function clipMode(data, box, x, y, scaleX, scaleY, rotation) {
         rotate(transform, rotation);
     data.transform = transform;
 }
-function repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, around) {
+function repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, align) {
     const transform = get$4();
     if (rotation) {
-        if (around === 'center') {
+        if (align === 'center') {
             rotateOfOuter$2(transform, { x: width / 2, y: height / 2 }, rotation);
         }
         else {
@@ -10755,12 +10932,12 @@ function createData(leafPaint, image, paint, box) {
     let { width, height } = image;
     if (paint.padding)
         box = tempBox.set(box).shrink(paint.padding);
-    const { opacity, mode, around, offset, scale, size, rotation, blendMode, repeat } = paint;
+    const { opacity, mode, align, offset, scale, size, rotation, blendMode, repeat } = paint;
     const sameBox = box.width === width && box.height === height;
     if (blendMode)
         leafPaint.blendMode = blendMode;
     const data = leafPaint.data = { mode };
-    const swapSize = around !== 'center' && (rotation || 0) % 180 === 90;
+    const swapSize = align !== 'center' && (rotation || 0) % 180 === 90;
     const swapWidth = swapSize ? height : width, swapHeight = swapSize ? width : height;
     let x = 0, y = 0, scaleX, scaleY;
     if (!mode || mode === 'cover' || mode === 'fit') {
@@ -10778,11 +10955,11 @@ function createData(leafPaint, image, paint, box) {
         scaleX = typeof scale === 'number' ? scale : scale.x;
         scaleY = typeof scale === 'number' ? scale : scale.y;
     }
-    if (around) {
+    if (align) {
         const imageBounds = { x, y, width: swapWidth, height: swapHeight };
         if (scaleX)
             imageBounds.width *= scaleX, imageBounds.height *= scaleY;
-        AroundHelper.toPoint(around, box, tempPoint, true, imageBounds);
+        AlignHelper.toPoint(align, imageBounds, box, tempPoint, true);
         x += tempPoint.x, y += tempPoint.y;
     }
     if (offset)
@@ -10799,7 +10976,7 @@ function createData(leafPaint, image, paint, box) {
             break;
         case 'repeat':
             if (!sameBox || scaleX || rotation)
-                repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, around);
+                repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, align);
             if (!repeat)
                 data.repeat = 'repeat';
             break;
@@ -11070,13 +11247,14 @@ const PaintImageModule = {
     recycleImage
 };
 
-const defaultFrom$2 = { x: 0.5, y: 0 };
-const defaultTo$2 = { x: 0.5, y: 1 };
+const { toPoint: toPoint$2 } = AroundHelper;
+const realFrom$2 = {};
+const realTo$2 = {};
 function linearGradient(paint, box) {
     let { from, to, type, blendMode, opacity } = paint;
-    from || (from = defaultFrom$2);
-    to || (to = defaultTo$2);
-    const style = Platform.canvas.createLinearGradient(box.x + from.x * box.width, box.y + from.y * box.height, box.x + to.x * box.width, box.y + to.y * box.height);
+    toPoint$2(from || 'top', box, realFrom$2);
+    toPoint$2(to || 'bottom', box, realTo$2);
+    const style = Platform.canvas.createLinearGradient(realFrom$2.x, realFrom$2.y, realTo$2.x, realTo$2.y);
     applyStops(style, paint.stops, opacity);
     const data = { type, style };
     if (blendMode)
@@ -11087,23 +11265,25 @@ function applyStops(gradient, stops, opacity) {
     let stop;
     for (let i = 0, len = stops.length; i < len; i++) {
         stop = stops[i];
-        gradient.addColorStop(stop.offset, ColorConvert.string(stop.color, opacity));
+        if (typeof stop === 'string') {
+            gradient.addColorStop(i / (len - 1), ColorConvert.string(stop, opacity));
+        }
+        else {
+            gradient.addColorStop(stop.offset, ColorConvert.string(stop.color, opacity));
+        }
     }
 }
 
-const { set: set$1, getAngle: getAngle$1, getDistance: getDistance$1 } = PointHelper;
+const { getAngle: getAngle$1, getDistance: getDistance$1 } = PointHelper;
 const { get: get$1, rotateOfOuter: rotateOfOuter$1, scaleOfOuter: scaleOfOuter$1 } = MatrixHelper;
-const defaultFrom$1 = { x: 0.5, y: 0.5 };
-const defaultTo$1 = { x: 0.5, y: 1 };
+const { toPoint: toPoint$1 } = AroundHelper;
 const realFrom$1 = {};
 const realTo$1 = {};
 function radialGradient(paint, box) {
     let { from, to, type, opacity, blendMode, stretch } = paint;
-    from || (from = defaultFrom$1);
-    to || (to = defaultTo$1);
-    const { x, y, width, height } = box;
-    set$1(realFrom$1, x + from.x * width, y + from.y * height);
-    set$1(realTo$1, x + to.x * width, y + to.y * height);
+    toPoint$1(from || 'center', box, realFrom$1);
+    toPoint$1(to || 'bottom', box, realTo$1);
+    const { width, height } = box;
     let transform;
     if (width !== height || stretch) {
         transform = get$1();
@@ -11118,19 +11298,16 @@ function radialGradient(paint, box) {
     return data;
 }
 
-const { set, getAngle, getDistance } = PointHelper;
+const { getAngle, getDistance } = PointHelper;
 const { get, rotateOfOuter, scaleOfOuter } = MatrixHelper;
-const defaultFrom = { x: 0.5, y: 0.5 };
-const defaultTo = { x: 0.5, y: 1 };
+const { toPoint } = AroundHelper;
 const realFrom = {};
 const realTo = {};
 function conicGradient(paint, box) {
     let { from, to, type, opacity, blendMode, stretch } = paint;
-    from || (from = defaultFrom);
-    to || (to = defaultTo);
-    const { x, y, width, height } = box;
-    set(realFrom, x + from.x * width, y + from.y * height);
-    set(realTo, x + to.x * width, y + to.y * height);
+    toPoint(from || 'center', box, realFrom);
+    toPoint(to || 'bottom', box, realTo);
+    const { width, height } = box;
     const transform = get();
     const angle = getAngle(realFrom, realTo);
     if (Platform.conicGradientRotate90) {
@@ -11284,7 +11461,7 @@ Group.prototype.__renderMask = function (canvas, options) {
                 maskEnd(this, currentMask, canvas, contentCanvas, maskCanvas, maskOpacity);
                 maskCanvas = contentCanvas = null;
             }
-            if (child.__.maskType === 'path') {
+            if (child.__.mask === 'path') {
                 if (child.opacity < 1) {
                     currentMask = 'opacity-path';
                     maskOpacity = child.opacity;
@@ -11305,7 +11482,7 @@ Group.prototype.__renderMask = function (canvas, options) {
                     contentCanvas = getCanvas(canvas);
                 child.__render(maskCanvas, options);
             }
-            if (child.__.maskType !== 'clipping')
+            if (child.__.mask !== 'clipping')
                 continue;
         }
         if (excludeRenderBounds(child, options))
@@ -11606,11 +11783,11 @@ function layoutChar(drawData, style, width, _height) {
                     if (mode === WordMode) {
                         wordChar = { char: '', x: charX };
                         charX = toWordChar(word.data, charX, wordChar);
-                        if (wordChar.char !== ' ')
+                        if (row.isOverflow || wordChar.char !== ' ')
                             row.data.push(wordChar);
                     }
                     else {
-                        charX = toChar(word.data, charX, row.data);
+                        charX = toChar(word.data, charX, row.data, row.isOverflow);
                     }
                     if (!row.paraEnd && addWordWidth) {
                         charX += addWordWidth;
@@ -11637,9 +11814,9 @@ function toWordChar(data, charX, wordChar) {
     });
     return charX;
 }
-function toChar(data, charX, rowData) {
+function toChar(data, charX, rowData, isOverflow) {
     data.forEach(char => {
-        if (char.char !== ' ') {
+        if (isOverflow || char.char !== ' ') {
             char.x = charX;
             rowData.push(char);
         }
@@ -11671,12 +11848,14 @@ function layoutText(drawData, style) {
     for (let i = 0, len = rows.length; i < len; i++) {
         row = rows[i];
         row.x = x;
-        switch (textAlign) {
-            case 'center':
-                row.x += (width - row.width) / 2;
-                break;
-            case 'right':
-                row.x += width - row.width;
+        if (row.width < width || (row.width > width && !__clipText)) {
+            switch (textAlign) {
+                case 'center':
+                    row.x += (width - row.width) / 2;
+                    break;
+                case 'right':
+                    row.x += width - row.width;
+            }
         }
         if (row.paraStart && paraSpacing && i > 0)
             starY += paraSpacing;
@@ -11716,11 +11895,13 @@ function clipText(drawData, style) {
     const { rows, overflow } = drawData;
     let { textOverflow } = style;
     rows.splice(overflow);
-    if (textOverflow !== 'hide') {
-        if (textOverflow === 'ellipsis')
+    if (textOverflow && textOverflow !== 'show') {
+        if (textOverflow === 'hide')
+            textOverflow = '';
+        else if (textOverflow === 'ellipsis')
             textOverflow = '...';
         let char, charRight;
-        const ellipsisWidth = Platform.canvas.measureText(textOverflow).width;
+        const ellipsisWidth = textOverflow ? Platform.canvas.measureText(textOverflow).width : 0;
         const right = style.x + style.width - ellipsisWidth;
         const list = style.textWrap === 'none' ? rows : [rows[overflow - 1]];
         list.forEach(row => {
@@ -11888,8 +12069,12 @@ const ExportModule = {
                     let renderBounds, trimBounds, scaleX = 1, scaleY = 1;
                     const { worldTransform, isLeafer, isFrame } = leaf;
                     const { slice, trim, onCanvas } = options;
-                    const scale = options.scale || 1;
-                    const pixelRatio = options.pixelRatio || 1;
+                    let scale = options.scale || 1;
+                    let pixelRatio = options.pixelRatio || 1;
+                    if (leaf.isApp) {
+                        scale *= pixelRatio;
+                        pixelRatio = leaf.app.pixelRatio;
+                    }
                     const screenshot = options.screenshot || leaf.isApp;
                     const fill = (isLeafer && screenshot) ? (options.fill === undefined ? leaf.fill : options.fill) : options.fill;
                     const needFill = FileHelper.isOpaqueImage(filename) || fill, matrix = new Matrix();
@@ -12030,4 +12215,4 @@ window.addEventListener('unload', () => {
     ImageManager.destroy();
 });
 
-export { AnimateEvent, Answer, App, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragEvent, DropEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Export, FileHelper, Frame, FrameData, Group, GroupData, HitCanvasManager, Image$1 as Image, ImageData, ImageEvent, ImageManager, IncrementId, 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, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, RotateEvent, Run, Selector, Star, StarData, State, StringNumberMap, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, ZoomEvent, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, layoutProcessor, maskType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, sortType, stateType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix, tempPoint$3 as tempPoint, useCanvas, useModule, version, zoomLayerType };
+export { AlignHelper, AnimateEvent, Answer, App, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragEvent, DropEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Export, FileHelper, Frame, FrameData, Group, GroupData, HitCanvasManager, Image$1 as Image, ImageData, ImageEvent, ImageManager, IncrementId, 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, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, RotateEvent, Run, Selector, Star, StarData, State, StringNumberMap, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, ZoomEvent, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, inviteCode, layoutProcessor, maskType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, sortType, stateType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix, tempPoint$3 as tempPoint, useCanvas, useModule, version, visibleType, zoomLayerType };