@leafer-draw/worker 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/worker.js

@@ -6,7 +6,7 @@ var LeaferUI = (function (exports) {
             hitCanvasSize: 100,
             maxCacheSize: 2560 * 1600,
             maxPatternSize: 4096 * 2160,
-            suffix: 'leaf',
+            suffix: '',
             crossOrigin: 'anonymous'
         }
     };
@@ -36,24 +36,12 @@ var LeaferUI = (function (exports) {
     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) {
@@ -150,9 +138,11 @@ var LeaferUI = (function (exports) {
             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;
@@ -219,8 +209,10 @@ var LeaferUI = (function (exports) {
             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;
@@ -341,7 +333,7 @@ var LeaferUI = (function (exports) {
             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;
@@ -761,7 +753,7 @@ var LeaferUI = (function (exports) {
     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) {
@@ -776,15 +768,17 @@ var LeaferUI = (function (exports) {
             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; },
@@ -861,17 +855,17 @@ var LeaferUI = (function (exports) {
             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);
             }
         },
@@ -884,13 +878,16 @@ var LeaferUI = (function (exports) {
             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;
@@ -1070,12 +1067,12 @@ var LeaferUI = (function (exports) {
         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() {
@@ -1192,6 +1189,10 @@ var LeaferUI = (function (exports) {
         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";
     })(exports.Direction9 || (exports.Direction9 = {}));
 
     const directionData = [
@@ -1205,6 +1206,7 @@ var LeaferUI = (function (exports) {
         { x: 0, y: 0.5 },
         { x: 0.5, y: 0.5 }
     ];
+    directionData.forEach(item => item.type = 'percent');
     const AroundHelper = {
         directionData,
         tempPoint: {},
@@ -1212,15 +1214,19 @@ var LeaferUI = (function (exports) {
         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;
@@ -1232,6 +1238,13 @@ var LeaferUI = (function (exports) {
         return typeof around === 'string' ? directionData[exports.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,
@@ -1464,13 +1477,21 @@ var LeaferUI = (function (exports) {
         },
         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;
@@ -1966,6 +1987,11 @@ var LeaferUI = (function (exports) {
         }
         updateViewSize() { }
         updateClientBounds() { }
+        getClientBounds(update) {
+            if (update)
+                this.updateClientBounds();
+            return this.clientBounds || this.bounds;
+        }
         startAutoLayout(_autoBounds, _listener) { }
         stopAutoLayout() { }
         setCursor(_cursor) { }
@@ -2100,7 +2126,7 @@ var LeaferUI = (function (exports) {
         }
         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;
@@ -2217,7 +2243,7 @@ var LeaferUI = (function (exports) {
 
     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 = {
@@ -2295,9 +2321,9 @@ var LeaferUI = (function (exports) {
                     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;
@@ -2346,7 +2372,7 @@ var LeaferUI = (function (exports) {
             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);
@@ -2368,7 +2394,7 @@ var LeaferUI = (function (exports) {
                 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);
@@ -2514,11 +2540,15 @@ var LeaferUI = (function (exports) {
                 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;
                 }
@@ -3608,7 +3638,9 @@ var LeaferUI = (function (exports) {
         }
     }
 
-    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) {
@@ -3627,9 +3659,7 @@ var LeaferUI = (function (exports) {
     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);
@@ -3640,35 +3670,33 @@ var LeaferUI = (function (exports) {
     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());
             }
         }));
     }
@@ -3682,9 +3710,7 @@ var LeaferUI = (function (exports) {
     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());
             }
         }));
     }
@@ -3696,8 +3722,11 @@ var LeaferUI = (function (exports) {
     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);
             }
@@ -3728,54 +3757,66 @@ var LeaferUI = (function (exports) {
     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();
             }
         }));
     }
@@ -3816,9 +3857,7 @@ var LeaferUI = (function (exports) {
             },
             set(value) {
                 this[computedKey] = value;
-            },
-            configurable: true,
-            enumerable: true
+            }
         };
         if (defaultValue === undefined) {
             property.get = function () { return this[computedKey]; };
@@ -3826,13 +3865,25 @@ var LeaferUI = (function (exports) {
         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;
@@ -3846,7 +3897,7 @@ var LeaferUI = (function (exports) {
             property.set = data[setMethodName];
             delete data[setMethodName];
         }
-        Object.defineProperty(data, key, property);
+        defineKey(data, key, property);
     }
 
     const debug$6 = new Debug('rewrite');
@@ -4047,13 +4098,6 @@ var LeaferUI = (function (exports) {
                     return true;
                 p = p.parent;
             }
-        },
-        hasParentAutoLayout(p) {
-            while (p.parent) {
-                p = p.parent;
-                if (p.__hasAutoLayout)
-                    return true;
-            }
         }
     };
     const L = LeafHelper;
@@ -4073,13 +4117,13 @@ var LeaferUI = (function (exports) {
             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;
@@ -4185,11 +4229,19 @@ var LeaferUI = (function (exports) {
 
     const { getRelativeWorld: getRelativeWorld$1 } = LeafHelper;
     const { toOuterOf: toOuterOf$2, getPoints, copy: copy$5 } = 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; }
@@ -4272,7 +4324,6 @@ var LeaferUI = (function (exports) {
                 case 'content':
                     if (this.contentBounds)
                         return this.contentBounds;
-                case 'margin':
                 case 'box':
                     return this.boxBounds;
                 case 'stroke':
@@ -4285,8 +4336,9 @@ var LeaferUI = (function (exports) {
                     return this.localRenderBounds;
                 case 'stroke':
                     return this.localStrokeBounds;
-                case 'margin':
                 case 'content':
+                    if (this.contentBounds)
+                        return this.localContentBounds;
                 case 'box':
                     return this.leaf.__localBoxBounds;
             }
@@ -4295,15 +4347,13 @@ var LeaferUI = (function (exports) {
             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) {
@@ -4366,20 +4416,24 @@ var LeaferUI = (function (exports) {
                 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 };
+        }
+        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();
         }
-        getWorldBoxBounds() {
-            this._worldBoxBounds || (this._worldBoxBounds = {});
-            toOuterOf$2(this.boxBounds, this.leaf.__world, this._worldBoxBounds);
-            return this._worldBoxBounds;
+        spreadRender() {
+            const { x, y, width, height } = this.renderBounds;
+            this._renderBounds = { x, y, width, height };
+            this._localRenderBounds = { x, y, width, height };
         }
-        getWorldStrokeBounds() {
-            this._worldStrokeBounds || (this._worldStrokeBounds = {});
-            toOuterOf$2(this.strokeBounds, this.leaf.__world, this._worldStrokeBounds);
-            return this._worldStrokeBounds;
+        shrinkContentCancel() {
+            this._contentBounds = undefined;
         }
         spreadStrokeCancel() {
             const same = this.renderBounds === this.strokeBounds;
@@ -4392,18 +4446,6 @@ var LeaferUI = (function (exports) {
             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();
@@ -4490,24 +4532,40 @@ var LeaferUI = (function (exports) {
             });
         },
         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)
@@ -4771,10 +4829,10 @@ var LeaferUI = (function (exports) {
     };
 
     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) {
@@ -4785,18 +4843,18 @@ var LeaferUI = (function (exports) {
                         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$4 } = BoundsHelper;
     const { toBounds: toBounds$2 } = PathBounds;
@@ -4815,7 +4873,6 @@ var LeaferUI = (function (exports) {
                     this.__updatePath();
                 this.__updateRenderPath();
                 this.__updateBoxBounds();
-                layout.boxChanged = false;
                 layout.resized = true;
             }
             if (layout.localBoxChanged) {
@@ -4829,12 +4886,12 @@ var LeaferUI = (function (exports) {
                 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();
                 }
@@ -4842,7 +4899,7 @@ var LeaferUI = (function (exports) {
                     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();
@@ -4851,9 +4908,8 @@ var LeaferUI = (function (exports) {
             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();
                 }
@@ -4893,10 +4949,15 @@ var LeaferUI = (function (exports) {
         __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);
@@ -4913,12 +4974,13 @@ var LeaferUI = (function (exports) {
             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$4(renderBounds, strokeBounds);
-        },
+            const layout = this.__layout;
+            layout.renderSpread > 0 ? copyAndSpread$1(layout.renderBounds, layout.boxBounds, layout.renderSpread) : copy$4(layout.renderBounds, layout.strokeBounds);
+        }
     };
 
     const LeafRender = {
@@ -4927,6 +4989,8 @@ var LeaferUI = (function (exports) {
                 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) {
@@ -4969,6 +5033,8 @@ var LeaferUI = (function (exports) {
         __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);
@@ -5034,7 +5100,7 @@ var LeaferUI = (function (exports) {
         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);
@@ -5108,7 +5174,9 @@ var LeaferUI = (function (exports) {
         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)
@@ -5130,9 +5198,11 @@ var LeaferUI = (function (exports) {
         __updateLocalStrokeBounds() { }
         __updateLocalRenderBounds() { }
         __updateBoxBounds() { }
+        __updateContentBounds() { }
         __updateStrokeBounds() { }
         __updateRenderBounds() { }
         __updateAutoLayout() { }
+        __updateFlowLayout() { }
         __updateNaturalSize() { }
         __updateStrokeSpread() { return 0; }
         __updateRenderSpread() { return 0; }
@@ -5140,6 +5210,13 @@ var LeaferUI = (function (exports) {
         __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);
         }
@@ -5320,8 +5397,8 @@ var LeaferUI = (function (exports) {
         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)
@@ -5635,6 +5712,9 @@ var LeaferUI = (function (exports) {
         }
     }
 
+    const version = "1.0.0-rc.24";
+    const inviteCode = {};
+
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() { return true; }
         init() {
@@ -6176,7 +6256,7 @@ var LeaferUI = (function (exports) {
                 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);
             }
@@ -6248,8 +6328,11 @@ var LeaferUI = (function (exports) {
                 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)
@@ -6323,10 +6406,11 @@ var LeaferUI = (function (exports) {
     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);
+                }
             }
         }));
     }
@@ -6499,7 +6583,7 @@ var LeaferUI = (function (exports) {
     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;
         }
     };
@@ -6508,7 +6592,7 @@ var LeaferUI = (function (exports) {
     }
 
     class BoxData extends GroupData {
-        get __boxStroke() { return true; }
+        get __boxStroke() { return !this.__pathInputed; }
     }
 
     class LeaferData extends GroupData {
@@ -6521,11 +6605,11 @@ var LeaferUI = (function (exports) {
     }
 
     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 {
@@ -6552,6 +6636,7 @@ var LeaferUI = (function (exports) {
         'black': 900
     };
     class TextData extends UIData {
+        get __useNaturalRatio() { return false; }
         setFontWeight(value) {
             if (typeof value === 'string') {
                 this.__setInput('fontWeight', value);
@@ -6593,19 +6678,18 @@ var LeaferUI = (function (exports) {
     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() {
@@ -6625,7 +6709,7 @@ var LeaferUI = (function (exports) {
             if (backgroundBlur)
                 shapeWidth = Math.max(shapeWidth, backgroundBlur);
             this.__layout.renderShapeSpread = shapeWidth;
-            return width;
+            return width + (this.__layout.strokeSpread || 0);
         }
     };
 
@@ -6716,7 +6800,7 @@ var LeaferUI = (function (exports) {
 
     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);
@@ -6734,7 +6818,16 @@ var LeaferUI = (function (exports) {
                         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);
@@ -6762,11 +6855,14 @@ var LeaferUI = (function (exports) {
             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);
@@ -6780,22 +6876,22 @@ var LeaferUI = (function (exports) {
         }
         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.__;
@@ -6881,7 +6977,7 @@ var LeaferUI = (function (exports) {
         opacityType(1)
     ], exports.UI.prototype, "opacity", void 0);
     __decorate([
-        opacityType(true)
+        visibleType(true)
     ], exports.UI.prototype, "visible", void 0);
     __decorate([
         stateType(false)
@@ -6898,9 +6994,6 @@ var LeaferUI = (function (exports) {
     __decorate([
         maskType(false)
     ], exports.UI.prototype, "mask", void 0);
-    __decorate([
-        surfaceType('pixel')
-    ], exports.UI.prototype, "maskType", void 0);
     __decorate([
         eraserType(false)
     ], exports.UI.prototype, "eraser", void 0);
@@ -6931,9 +7024,75 @@ var LeaferUI = (function (exports) {
     __decorate([
         rotationType(0, true)
     ], exports.UI.prototype, "skewY", void 0);
+    __decorate([
+        positionType(0, true)
+    ], exports.UI.prototype, "offsetX", void 0);
+    __decorate([
+        positionType(0, true)
+    ], exports.UI.prototype, "offsetY", void 0);
+    __decorate([
+        positionType(0, true)
+    ], exports.UI.prototype, "scrollX", void 0);
+    __decorate([
+        positionType(0, true)
+    ], exports.UI.prototype, "scrollY", void 0);
+    __decorate([
+        autoLayoutType()
+    ], exports.UI.prototype, "origin", void 0);
     __decorate([
         autoLayoutType()
     ], exports.UI.prototype, "around", void 0);
+    __decorate([
+        dataType(false)
+    ], exports.UI.prototype, "lazy", void 0);
+    __decorate([
+        naturalBoundsType(1)
+    ], exports.UI.prototype, "pixelRatio", void 0);
+    __decorate([
+        pathInputType()
+    ], exports.UI.prototype, "path", void 0);
+    __decorate([
+        pathType()
+    ], exports.UI.prototype, "windingRule", void 0);
+    __decorate([
+        pathType(true)
+    ], exports.UI.prototype, "closed", void 0);
+    __decorate([
+        autoLayoutType(false)
+    ], exports.UI.prototype, "flow", void 0);
+    __decorate([
+        boundsType(0)
+    ], exports.UI.prototype, "padding", void 0);
+    __decorate([
+        boundsType(0)
+    ], exports.UI.prototype, "gap", void 0);
+    __decorate([
+        boundsType('top-left')
+    ], exports.UI.prototype, "align", void 0);
+    __decorate([
+        boundsType(false)
+    ], exports.UI.prototype, "wrap", void 0);
+    __decorate([
+        boundsType('box')
+    ], exports.UI.prototype, "itemBox", void 0);
+    __decorate([
+        boundsType(true)
+    ], exports.UI.prototype, "inFlow", void 0);
+    __decorate([
+        boundsType()
+    ], exports.UI.prototype, "autoWidth", void 0);
+    __decorate([
+        boundsType()
+    ], exports.UI.prototype, "autoHeight", void 0);
+    __decorate([
+        boundsType()
+    ], exports.UI.prototype, "autoBox", void 0);
+    __decorate([
+        boundsType()
+    ], exports.UI.prototype, "widthRange", void 0);
+    __decorate([
+        boundsType()
+    ], exports.UI.prototype, "heightRange", void 0);
     __decorate([
         dataType(false)
     ], exports.UI.prototype, "draggable", void 0);
@@ -6943,9 +7102,6 @@ var LeaferUI = (function (exports) {
     __decorate([
         dataType(false)
     ], exports.UI.prototype, "editable", void 0);
-    __decorate([
-        dataType('size')
-    ], exports.UI.prototype, "editSize", void 0);
     __decorate([
         hitType(true)
     ], exports.UI.prototype, "hittable", void 0);
@@ -7000,21 +7156,6 @@ var LeaferUI = (function (exports) {
     __decorate([
         strokeType(10)
     ], exports.UI.prototype, "miterLimit", void 0);
-    __decorate([
-        dataType(false)
-    ], exports.UI.prototype, "lazy", void 0);
-    __decorate([
-        naturalBoundsType(1)
-    ], exports.UI.prototype, "pixelRatio", void 0);
-    __decorate([
-        pathInputType()
-    ], exports.UI.prototype, "path", void 0);
-    __decorate([
-        pathType()
-    ], exports.UI.prototype, "windingRule", void 0);
-    __decorate([
-        pathType(true)
-    ], exports.UI.prototype, "closed", void 0);
     __decorate([
         arrowType('none')
     ], exports.UI.prototype, "startArrow", void 0);
@@ -7145,6 +7286,7 @@ var LeaferUI = (function (exports) {
         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 = {
@@ -7248,9 +7390,6 @@ var LeaferUI = (function (exports) {
             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)
@@ -7305,7 +7444,8 @@ var LeaferUI = (function (exports) {
                     this.__changeFill(newValue);
                 }
                 else if (attrName === 'hittable') {
-                    this.canvas.hittable = newValue;
+                    if (!this.parent)
+                        this.canvas.hittable = newValue;
                 }
             }
             return super.__setAttr(attrName, newValue);
@@ -7328,7 +7468,7 @@ var LeaferUI = (function (exports) {
                 this.canvas.backgroundColor = newValue;
             }
             else {
-                this.forceFullRender();
+                this.forceRender();
             }
         }
         __onCreated() {
@@ -7423,6 +7563,9 @@ var LeaferUI = (function (exports) {
         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();
         }
@@ -7505,8 +7648,8 @@ var LeaferUI = (function (exports) {
 
     const rect = exports.Rect.prototype;
     const group = exports.Group.prototype;
-    const bounds$1 = {};
-    const { copy: copy$2, add } = BoundsHelper;
+    const childrenRenderBounds = {};
+    const { copy: copy$2, add, includes: includes$1 } = BoundsHelper;
     exports.Box = class Box extends exports.Group {
         get __tag() { return 'Box'; }
         get isBranchLeaf() { return true; }
@@ -7517,24 +7660,29 @@ var LeaferUI = (function (exports) {
         __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();
@@ -7542,13 +7690,20 @@ var LeaferUI = (function (exports) {
         }
         __updateStrokeBounds() { }
         __updateRenderBounds() {
-            this.__updateRectRenderBounds();
-            if (!this.__.__drawAfterFill) {
-                const { renderBounds } = this.__layout;
-                copy$2(bounds$1, renderBounds);
+            let isOverflow;
+            const { renderBounds } = this.__layout;
+            if (this.children.length) {
                 super.__updateRenderBounds();
-                add(renderBounds, bounds$1);
+                copy$2(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() { }
@@ -7564,16 +7719,27 @@ var LeaferUI = (function (exports) {
             }
             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([
@@ -7711,9 +7877,10 @@ var LeaferUI = (function (exports) {
             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);
@@ -7948,7 +8115,7 @@ var LeaferUI = (function (exports) {
         registerUI()
     ], exports.Canvas);
 
-    const { copyAndSpread, includes, spread, setList } = BoundsHelper;
+    const { copyAndSpread, includes, isSame: isSame$1, spread, setList } = BoundsHelper;
     exports.Text = class Text extends exports.UI {
         get __tag() { return 'Text'; }
         get editInner() { return 'TextEditor'; }
@@ -8021,7 +8188,7 @@ var LeaferUI = (function (exports) {
             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]);
@@ -8049,9 +8216,6 @@ var LeaferUI = (function (exports) {
     __decorate([
         boundsType(0)
     ], exports.Text.prototype, "height", void 0);
-    __decorate([
-        boundsType(0)
-    ], exports.Text.prototype, "padding", void 0);
     __decorate([
         surfaceType('#000000')
     ], exports.Text.prototype, "fill", void 0);
@@ -8086,7 +8250,7 @@ var LeaferUI = (function (exports) {
         boundsType(0)
     ], exports.Text.prototype, "letterSpacing", void 0);
     __decorate([
-        boundsType({ type: 'percent', value: 150 })
+        boundsType({ type: 'percent', value: 1.5 })
     ], exports.Text.prototype, "lineHeight", void 0);
     __decorate([
         boundsType(0)
@@ -8180,8 +8344,6 @@ var LeaferUI = (function (exports) {
         };
     }
 
-    const version = "1.0.0-rc.21";
-
     function fillText(ui, canvas) {
         let row;
         const { rows, decorationY, decorationHeight } = ui.__.__textDrawData;
@@ -8401,7 +8563,7 @@ var LeaferUI = (function (exports) {
         }
         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) {
@@ -8501,10 +8663,10 @@ var LeaferUI = (function (exports) {
             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 {
@@ -8537,12 +8699,12 @@ var LeaferUI = (function (exports) {
         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') {
@@ -8560,11 +8722,11 @@ var LeaferUI = (function (exports) {
             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)
@@ -8581,7 +8743,7 @@ var LeaferUI = (function (exports) {
                 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;
@@ -8852,13 +9014,14 @@ var LeaferUI = (function (exports) {
         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)
@@ -8869,23 +9032,25 @@ var LeaferUI = (function (exports) {
         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();
@@ -8900,19 +9065,16 @@ var LeaferUI = (function (exports) {
         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) {
@@ -9066,7 +9228,7 @@ var LeaferUI = (function (exports) {
                     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;
@@ -9087,7 +9249,7 @@ var LeaferUI = (function (exports) {
                         contentCanvas = getCanvas(canvas);
                     child.__render(maskCanvas, options);
                 }
-                if (child.__.maskType !== 'clipping')
+                if (child.__.mask !== 'clipping')
                     continue;
             }
             if (excludeRenderBounds(child, options))
@@ -9388,11 +9550,11 @@ var LeaferUI = (function (exports) {
                         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;
@@ -9419,9 +9581,9 @@ var LeaferUI = (function (exports) {
         });
         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);
             }
@@ -9453,12 +9615,14 @@ var LeaferUI = (function (exports) {
         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;
@@ -9498,11 +9662,13 @@ var LeaferUI = (function (exports) {
         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 => {
@@ -9670,8 +9836,12 @@ var LeaferUI = (function (exports) {
                         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();
@@ -9801,6 +9971,7 @@ var LeaferUI = (function (exports) {
 
     useCanvas();
 
+    exports.AlignHelper = AlignHelper;
     exports.AnimateEvent = AnimateEvent;
     exports.AroundHelper = AroundHelper;
     exports.AutoBounds = AutoBounds;
@@ -9925,6 +10096,7 @@ var LeaferUI = (function (exports) {
     exports.getMatrixData = getMatrixData;
     exports.getPointData = getPointData;
     exports.hitType = hitType;
+    exports.inviteCode = inviteCode;
     exports.layoutProcessor = layoutProcessor;
     exports.maskType = maskType;
     exports.naturalBoundsType = naturalBoundsType;
@@ -9950,6 +10122,7 @@ var LeaferUI = (function (exports) {
     exports.useCanvas = useCanvas;
     exports.useModule = useModule;
     exports.version = version;
+    exports.visibleType = visibleType;
     exports.zoomLayerType = zoomLayerType;
 
     return exports;