@leafer/core 1.6.2 → 1.6.3

package/lib/core.cjs

@@ -25,8 +25,6 @@ const Platform = {
     }
 };
 
-const Creator = {};
-
 const IncrementId = {
     RUNTIME: 'runtime',
     LEAF: 'leaf',
@@ -466,8 +464,10 @@ const PointHelper = {
         t.y = halfPixel ? round$2(t.y - 0.5) + 0.5 : round$2(t.y);
     },
     move(t, x, y) {
-        t.x += x;
-        t.y += y;
+        if (typeof x === 'object')
+            t.x += x.x, t.y += x.y;
+        else
+            t.x += x, t.y += y;
     },
     scale(t, scaleX, scaleY = scaleX) {
         if (t.x)
@@ -803,15 +803,87 @@ const TwoPointBoundsHelper = {
 };
 const { addPoint: addPoint$3 } = TwoPointBoundsHelper;
 
+exports.Direction4 = void 0;
+(function (Direction4) {
+    Direction4[Direction4["top"] = 0] = "top";
+    Direction4[Direction4["right"] = 1] = "right";
+    Direction4[Direction4["bottom"] = 2] = "bottom";
+    Direction4[Direction4["left"] = 3] = "left";
+})(exports.Direction4 || (exports.Direction4 = {}));
+exports.Direction9 = void 0;
+(function (Direction9) {
+    Direction9[Direction9["topLeft"] = 0] = "topLeft";
+    Direction9[Direction9["top"] = 1] = "top";
+    Direction9[Direction9["topRight"] = 2] = "topRight";
+    Direction9[Direction9["right"] = 3] = "right";
+    Direction9[Direction9["bottomRight"] = 4] = "bottomRight";
+    Direction9[Direction9["bottom"] = 5] = "bottom";
+    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 = [
+    { x: 0, y: 0 },
+    { x: 0.5, y: 0 },
+    { x: 1, y: 0 },
+    { x: 1, y: 0.5 },
+    { x: 1, y: 1 },
+    { x: 0.5, y: 1 },
+    { x: 0, y: 1 },
+    { x: 0, y: 0.5 },
+    { x: 0.5, y: 0.5 }
+];
+directionData.forEach(item => item.type = 'percent');
+const AroundHelper = {
+    directionData,
+    tempPoint: {},
+    get,
+    toPoint(around, box, to, onlyBoxSize, content, onlyContentSize) {
+        const point = get(around);
+        to.x = point.x;
+        to.y = point.y;
+        if (point.type === 'percent') {
+            to.x *= box.width;
+            to.y *= box.height;
+            if (content) {
+                if (!onlyContentSize)
+                    to.x -= content.x, to.y -= content.y;
+                if (point.x)
+                    to.x -= (point.x === 1) ? content.width : (point.x === 0.5 ? point.x * content.width : 0);
+                if (point.y)
+                    to.y -= (point.y === 1) ? content.height : (point.y === 0.5 ? point.y * content.height : 0);
+            }
+        }
+        if (!onlyBoxSize)
+            to.x += box.x, to.y += box.y;
+    }
+};
+function get(around) {
+    return typeof around === 'string' ? directionData[exports.Direction9[around]] : around;
+}
+
+const { toPoint: toPoint$2 } = AroundHelper;
+const AlignHelper = {
+    toPoint(align, content, box, to, onlyBoxSize, onlyContentSize) {
+        toPoint$2(align, box, to, onlyBoxSize, content, onlyContentSize);
+    }
+};
+
 const { tempPointBounds: tempPointBounds$1, setPoint: setPoint$2, addPoint: addPoint$2, toBounds: toBounds$2 } = TwoPointBoundsHelper;
 const { toOuterPoint: toOuterPoint$2 } = MatrixHelper;
 const { float, fourNumber } = MathHelper;
 const { floor, ceil: ceil$1 } = Math;
 let right, bottom, boundsRight, boundsBottom;
 const point = {};
-const toPoint$2 = {};
+const toPoint$1 = {};
+const tempBounds$1 = {};
 const BoundsHelper = {
-    tempBounds: {},
+    tempBounds: tempBounds$1,
     set(t, x = 0, y = 0, width = 0, height = 0) {
         t.x = x;
         t.y = y;
@@ -874,8 +946,8 @@ const BoundsHelper = {
         }
         B.move(to, -to.offsetX, -to.offsetY);
     },
-    scale(t, scaleX, scaleY = scaleX) {
-        PointHelper.scale(t, scaleX, scaleY);
+    scale(t, scaleX, scaleY = scaleX, onlySize) {
+        onlySize || PointHelper.scale(t, scaleX, scaleY);
         t.width *= scaleX;
         t.height *= scaleY;
     },
@@ -885,9 +957,9 @@ const BoundsHelper = {
         t.height *= scaleY;
     },
     tempToOuterOf(t, matrix) {
-        B.copy(B.tempBounds, t);
-        B.toOuterOf(B.tempBounds, matrix);
-        return B.tempBounds;
+        B.copy(tempBounds$1, t);
+        B.toOuterOf(tempBounds$1, matrix);
+        return tempBounds$1;
     },
     getOuterOf(t, matrix) {
         t = Object.assign({}, t);
@@ -918,17 +990,17 @@ const BoundsHelper = {
         else {
             point.x = t.x;
             point.y = t.y;
-            toOuterPoint$2(matrix, point, toPoint$2);
-            setPoint$2(tempPointBounds$1, toPoint$2.x, toPoint$2.y);
+            toOuterPoint$2(matrix, point, toPoint$1);
+            setPoint$2(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
             point.x = t.x + t.width;
-            toOuterPoint$2(matrix, point, toPoint$2);
-            addPoint$2(tempPointBounds$1, toPoint$2.x, toPoint$2.y);
+            toOuterPoint$2(matrix, point, toPoint$1);
+            addPoint$2(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
             point.y = t.y + t.height;
-            toOuterPoint$2(matrix, point, toPoint$2);
-            addPoint$2(tempPointBounds$1, toPoint$2.x, toPoint$2.y);
+            toOuterPoint$2(matrix, point, toPoint$1);
+            addPoint$2(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
             point.x = t.x;
-            toOuterPoint$2(matrix, point, toPoint$2);
-            addPoint$2(tempPointBounds$1, toPoint$2.x, toPoint$2.y);
+            toOuterPoint$2(matrix, point, toPoint$1);
+            addPoint$2(tempPointBounds$1, toPoint$1.x, toPoint$1.y);
             toBounds$2(tempPointBounds$1, to);
         }
     },
@@ -938,9 +1010,21 @@ const BoundsHelper = {
         B.scale(to, 1 / matrix.a, 1 / matrix.d);
     },
     getFitMatrix(t, put, baseScale = 1) {
-        const scale = Math.min(baseScale, Math.min(t.width / put.width, t.height / put.height));
+        const scale = Math.min(baseScale, B.getFitScale(t, put));
         return new Matrix(scale, 0, 0, scale, -put.x * scale, -put.y * scale);
     },
+    getFitScale(t, put, isCoverMode) {
+        const sw = t.width / put.width, sh = t.height / put.height;
+        return isCoverMode ? Math.max(sw, sh) : Math.min(sw, sh);
+    },
+    put(t, put, align = 'center', putScale = 1, changeSize = true, to) {
+        to || (to = put);
+        if (typeof putScale === 'string')
+            putScale = B.getFitScale(t, put, putScale === 'cover');
+        tempBounds$1.width = changeSize ? put.width *= putScale : put.width * putScale;
+        tempBounds$1.height = changeSize ? put.height *= putScale : put.height * putScale;
+        AlignHelper.toPoint(align, tempBounds$1, t, to, true, true);
+    },
     getSpread(t, spread, side) {
         const n = {};
         B.copyAndSpread(n, t, spread, false, side);
@@ -1114,8 +1198,8 @@ class Bounds {
         BoundsHelper.move(this, x, y);
         return this;
     }
-    scale(scaleX, scaleY) {
-        BoundsHelper.scale(this, scaleX, scaleY);
+    scale(scaleX, scaleY, onlySize) {
+        BoundsHelper.scale(this, scaleX, scaleY, onlySize);
         return this;
     }
     scaleOf(origin, scaleX, scaleY) {
@@ -1133,6 +1217,9 @@ class Bounds {
     getFitMatrix(put, baseScale) {
         return BoundsHelper.getFitMatrix(this, put, baseScale);
     }
+    put(put, align, putScale) {
+        BoundsHelper.put(this, put, align, putScale);
+    }
     spread(fourNumber, side) {
         BoundsHelper.spread(this, fourNumber, side);
         return this;
@@ -1241,79 +1328,6 @@ class AutoBounds {
     }
 }
 
-exports.Direction4 = void 0;
-(function (Direction4) {
-    Direction4[Direction4["top"] = 0] = "top";
-    Direction4[Direction4["right"] = 1] = "right";
-    Direction4[Direction4["bottom"] = 2] = "bottom";
-    Direction4[Direction4["left"] = 3] = "left";
-})(exports.Direction4 || (exports.Direction4 = {}));
-exports.Direction9 = void 0;
-(function (Direction9) {
-    Direction9[Direction9["topLeft"] = 0] = "topLeft";
-    Direction9[Direction9["top"] = 1] = "top";
-    Direction9[Direction9["topRight"] = 2] = "topRight";
-    Direction9[Direction9["right"] = 3] = "right";
-    Direction9[Direction9["bottomRight"] = 4] = "bottomRight";
-    Direction9[Direction9["bottom"] = 5] = "bottom";
-    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 = [
-    { x: 0, y: 0 },
-    { x: 0.5, y: 0 },
-    { x: 1, y: 0 },
-    { x: 1, y: 0.5 },
-    { x: 1, y: 1 },
-    { x: 0.5, y: 1 },
-    { x: 0, y: 1 },
-    { x: 0, y: 0.5 },
-    { x: 0.5, y: 0.5 }
-];
-directionData.forEach(item => item.type = 'percent');
-const AroundHelper = {
-    directionData,
-    tempPoint: {},
-    get,
-    toPoint(around, bounds, to, onlySize, pointBounds) {
-        const point = get(around);
-        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;
-            to.y += bounds.y;
-        }
-    }
-};
-function get(around) {
-    return typeof around === 'string' ? directionData[exports.Direction9[around]] : around;
-}
-
-const { toPoint: toPoint$1 } = AroundHelper;
-const AlignHelper = {
-    toPoint(align, contentBounds, bounds, to, onlySize) {
-        toPoint$1(align, bounds, to, onlySize, contentBounds);
-    }
-};
-
 const StringNumberMap = {
     '0': 1,
     '1': 1,
@@ -1444,11 +1458,17 @@ const Plugin = {
         return rs;
     },
     need(name) {
-        console.error('please install plugin: ' + (name.includes('-x') ? '' : '@leafer-in/') + name);
+        console.error('please install and import plugin: ' + (name.includes('-x') ? '' : '@leafer-in/') + name);
     }
 };
 setTimeout(() => check.forEach(name => Plugin.has(name, true)));
 
+const Creator = {
+    editor(_options) {
+        return Plugin.need('editor');
+    }
+};
+
 const debug$9 = Debug.get('UICreator');
 const UICreator = {
     list: {},
@@ -1586,6 +1606,10 @@ const DataHelper = {
         for (let i = 0, len = list.length; i < len; i++)
             map[list[i]] = true;
         return map;
+    },
+    stintSet(data, attrName, value) {
+        value || (value = undefined);
+        data[attrName] !== value && (data[attrName] = value);
     }
 };
 const { assign } = DataHelper;
@@ -2409,6 +2433,8 @@ const BezierHelper = {
                 cY = points[i + 3];
                 ba = sqrt$1(pow(bX - aX, 2) + pow(bY - aY, 2));
                 cb = sqrt$1(pow(cX - bX, 2) + pow(cY - bY, 2));
+                if (!ba && !cb)
+                    continue;
                 d = ba + cb;
                 ba = (t * ba) / d;
                 cb = (t * cb) / d;
@@ -3388,7 +3414,7 @@ function canvasPatch(drawer) {
 }
 
 const FileHelper = {
-    opacityTypes: ['png', 'webp', 'svg'],
+    alphaPixelTypes: ['png', 'webp', 'svg'],
     upperCaseTypeMap: {},
     mineType(type) {
         if (!type || type.startsWith('image'))
@@ -3415,7 +3441,7 @@ const FileHelper = {
     }
 };
 const F = FileHelper;
-F.opacityTypes.forEach(type => F.upperCaseTypeMap[type] = type.toUpperCase());
+F.alphaPixelTypes.forEach(type => F.upperCaseTypeMap[type] = type.toUpperCase());
 
 const debug$4 = Debug.get('TaskProcessor');
 class TaskItem {
@@ -3732,8 +3758,8 @@ const ImageManager = {
             list.length = 0;
         }
     },
-    hasOpacityPixel(config) {
-        return FileHelper.opacityTypes.some(item => I.isFormat(item, config));
+    hasAlphaPixel(config) {
+        return FileHelper.alphaPixelTypes.some(item => I.isFormat(item, config));
     },
     isFormat(format, config) {
         if (config.format === format)
@@ -3771,7 +3797,7 @@ class LeaferImage {
             this.setView(view.config ? view.view : view);
         }
         ImageManager.isFormat('svg', config) && (this.isSVG = true);
-        ImageManager.hasOpacityPixel(config) && (this.hasOpacityPixel = true);
+        ImageManager.hasAlphaPixel(config) && (this.hasAlphaPixel = true);
     }
     load(onSuccess, onError) {
         if (!this.loading) {
@@ -4459,7 +4485,7 @@ const LeafBoundsHelper = {
     }
 };
 
-const { updateBounds: updateBounds$1 } = LeafHelper;
+const { updateBounds: updateBounds$2 } = LeafHelper;
 const BranchHelper = {
     sort(a, b) {
         return (a.__.zIndex === b.__.zIndex) ? (a.__tempNumber - b.__tempNumber) : (a.__.zIndex - b.__.zIndex);
@@ -4521,11 +4547,11 @@ const BranchHelper = {
             branch = branchStack[i];
             children = branch.children;
             for (let j = 0, len = children.length; j < len; j++) {
-                updateBounds$1(children[j]);
+                updateBounds$2(children[j]);
             }
             if (exclude && exclude === branch)
                 continue;
-            updateBounds$1(branch);
+            updateBounds$2(branch);
         }
     }
 };
@@ -4543,7 +4569,7 @@ const WaitHelper = {
     }
 };
 
-const { getRelativeWorld: getRelativeWorld$1 } = LeafHelper;
+const { getRelativeWorld: getRelativeWorld$1, updateBounds: updateBounds$1 } = LeafHelper;
 const { toOuterOf: toOuterOf$2, getPoints, copy: copy$2 } = BoundsHelper;
 const localContent = '_localContentBounds';
 const worldContent = '_worldContentBounds', worldBox = '_worldBoxBounds', worldStroke = '_worldStrokeBounds';
@@ -4587,7 +4613,9 @@ class LeafLayout {
             this._localRenderBounds = local;
     }
     update() {
-        const { leafer } = this.leaf;
+        const { leaf } = this, { leafer } = leaf;
+        if (leaf.isApp)
+            return updateBounds$1(leaf);
         if (leafer) {
             if (leafer.ready)
                 leafer.watcher.changed && leafer.layouter.layout();
@@ -4595,7 +4623,7 @@ class LeafLayout {
                 leafer.start();
         }
         else {
-            let root = this.leaf;
+            let root = leaf;
             while (root.parent && !root.parent.leafer) {
                 root = root.parent;
             }
@@ -4817,7 +4845,7 @@ class LeafLayout {
     }
     childrenSortChange() {
         if (!this.childrenSortChanged) {
-            this.childrenSortChanged = true;
+            this.childrenSortChanged = this.affectChildrenSort = true;
             this.leaf.forceUpdate('surface');
         }
     }
@@ -4884,6 +4912,40 @@ ImageEvent.LOAD = 'image.load';
 ImageEvent.LOADED = 'image.loaded';
 ImageEvent.ERROR = 'image.error';
 
+class BoundsEvent extends Event {
+    static checkHas(leaf, type, mode) {
+        if (mode === 'on') {
+            type === WORLD ? leaf.__hasWorldEvent = true : leaf.__hasLocalEvent = true;
+        }
+        else {
+            leaf.__hasLocalEvent = leaf.hasEvent(RESIZE) || leaf.hasEvent(INNER) || leaf.hasEvent(LOCAL);
+            leaf.__hasWorldEvent = leaf.hasEvent(WORLD);
+        }
+    }
+    static emitLocal(leaf) {
+        if (leaf.leaferIsReady) {
+            const { resized } = leaf.__layout;
+            if (resized !== 'local') {
+                leaf.emit(RESIZE, leaf);
+                if (resized === 'inner')
+                    leaf.emit(INNER, leaf);
+            }
+            leaf.emit(LOCAL, leaf);
+        }
+    }
+    static emitWorld(leaf) {
+        if (leaf.leaferIsReady)
+            leaf.emit(WORLD, this);
+    }
+}
+BoundsEvent.RESIZE = 'bounds.resize';
+BoundsEvent.INNER = 'bounds.inner';
+BoundsEvent.LOCAL = 'bounds.local';
+BoundsEvent.WORLD = 'bounds.world';
+const { RESIZE, INNER, LOCAL, WORLD } = BoundsEvent;
+const boundsEventMap = {};
+[RESIZE, INNER, LOCAL, WORLD].forEach(key => boundsEventMap[key] = 1);
+
 class ResizeEvent extends Event {
     get bigger() {
         if (!this.old)
@@ -4980,9 +5042,12 @@ class Eventer {
     set event(map) { this.on(map); }
     on(type, listener, options) {
         if (!listener) {
-            let event, map = type;
-            for (let key in map)
-                event = map[key], event instanceof Array ? this.on(key, event[0], event[1]) : this.on(key, event);
+            let event;
+            if (type instanceof Array)
+                type.forEach(item => this.on(item[0], item[1], item[2]));
+            else
+                for (let key in type)
+                    (event = type[key]) instanceof Array ? this.on(key, event[0], event[1]) : this.on(key, event);
             return;
         }
         let capture, once;
@@ -5012,6 +5077,8 @@ class Eventer {
                 else {
                     map[type] = [item];
                 }
+                if (boundsEventMap[type])
+                    BoundsEvent.checkHas(this, type, 'on');
             }
         });
     }
@@ -5033,6 +5100,8 @@ class Eventer {
                                 events.splice(index, 1);
                             if (!events.length)
                                 delete map[type];
+                            if (boundsEventMap[type])
+                                BoundsEvent.checkHas(this, type, 'off');
                         }
                     }
                 });
@@ -5052,19 +5121,31 @@ class Eventer {
         }
     }
     on_(type, listener, bind, options) {
-        if (bind)
-            listener = listener.bind(bind);
-        this.on(type, listener, options);
+        if (!listener)
+            (type instanceof Array) && type.forEach(item => this.on(item[0], item[2] ? item[1] = item[1].bind(item[2]) : item[1], item[3]));
+        else
+            this.on(type, bind ? listener = listener.bind(bind) : listener, options);
         return { type, current: this, listener, options };
     }
     off_(id) {
         if (!id)
             return;
         const list = id instanceof Array ? id : [id];
-        list.forEach(item => item.current.off(item.type, item.listener, item.options));
+        list.forEach(item => {
+            if (!item.listener)
+                (item.type instanceof Array) && item.type.forEach(v => item.current.off(v[0], v[1], v[3]));
+            else
+                item.current.off(item.type, item.listener, item.options);
+        });
         list.length = 0;
     }
-    once(type, listener, capture) {
+    once(type, listener, captureOrBind, capture) {
+        if (!listener)
+            return (type instanceof Array) && type.forEach(item => this.once(item[0], item[1], item[2], item[3]));
+        if (typeof captureOrBind === 'object')
+            listener = listener.bind(captureOrBind);
+        else
+            capture = captureOrBind;
         this.on(type, listener, { once: true, capture });
     }
     emit(type, event, capture) {
@@ -5185,9 +5266,9 @@ const LeafMatrix = {
         if (this.__local) {
             const layout = this.__layout, local = this.__local, data = this.__;
             if (layout.affectScaleOrRotation) {
-                if (layout.scaleChanged || layout.rotationChanged) {
+                if ((layout.scaleChanged && (layout.resized = 'scale')) || layout.rotationChanged) {
                     setLayout(local, data, null, null, layout.affectRotation);
-                    layout.scaleChanged = layout.rotationChanged = false;
+                    layout.scaleChanged = layout.rotationChanged = undefined;
                 }
             }
             local.e = data.x + data.offsetX;
@@ -5197,7 +5278,7 @@ const LeafMatrix = {
                 translateInner(local, -tempPoint.x, -tempPoint.y, !data.around);
             }
         }
-        this.__layout.matrixChanged = false;
+        this.__layout.matrixChanged = undefined;
     }
 };
 
@@ -5207,11 +5288,17 @@ const { toOuterOf: toOuterOf$1, copyAndSpread, copy: copy$1 } = BoundsHelper;
 const { toBounds } = PathBounds;
 const LeafBounds = {
     __updateWorldBounds() {
-        toOuterOf$1(this.__layout.renderBounds, this.__world, this.__world);
-        if (this.__layout.resized) {
-            this.__onUpdateSize();
-            this.__layout.resized = false;
+        const layout = this.__layout;
+        toOuterOf$1(layout.renderBounds, this.__world, this.__world);
+        if (layout.resized) {
+            if (layout.resized === 'inner')
+                this.__onUpdateSize();
+            if (this.__hasLocalEvent)
+                BoundsEvent.emitLocal(this);
+            layout.resized = undefined;
         }
+        if (this.__hasWorldEvent)
+            BoundsEvent.emitWorld(this);
     },
     __updateLocalBounds() {
         const layout = this.__layout;
@@ -5220,12 +5307,12 @@ const LeafBounds = {
                 this.__updatePath();
             this.__updateRenderPath();
             this.__updateBoxBounds();
-            layout.resized = true;
+            layout.resized = 'inner';
         }
         if (layout.localBoxChanged) {
             if (this.__local)
                 this.__updateLocalBoxBounds();
-            layout.localBoxChanged = false;
+            layout.localBoxChanged = undefined;
             if (layout.strokeSpread)
                 layout.strokeChanged = true;
             if (layout.renderSpread)
@@ -5233,7 +5320,7 @@ const LeafBounds = {
             if (this.parent)
                 this.parent.__layout.boxChange();
         }
-        layout.boxChanged = false;
+        layout.boxChanged = undefined;
         if (layout.strokeChanged) {
             layout.strokeSpread = this.__updateStrokeSpread();
             if (layout.strokeSpread) {
@@ -5245,12 +5332,12 @@ const LeafBounds = {
             else {
                 layout.spreadStrokeCancel();
             }
-            layout.strokeChanged = false;
+            layout.strokeChanged = undefined;
             if (layout.renderSpread || layout.strokeSpread !== layout.strokeBoxSpread)
                 layout.renderChanged = true;
             if (this.parent)
                 this.parent.__layout.strokeChange();
-            layout.resized = true;
+            layout.resized = 'inner';
         }
         if (layout.renderChanged) {
             layout.renderSpread = this.__updateRenderSpread();
@@ -5263,11 +5350,12 @@ const LeafBounds = {
             else {
                 layout.spreadRenderCancel();
             }
-            layout.renderChanged = false;
+            layout.renderChanged = undefined;
             if (this.parent)
                 this.parent.__layout.renderChange();
         }
-        layout.boundsChanged = false;
+        layout.resized || (layout.resized = 'local');
+        layout.boundsChanged = undefined;
     },
     __updateLocalBoxBounds() {
         if (this.__hasMotionPath)
@@ -5807,7 +5895,7 @@ exports.Leaf = class Leaf {
     off(_type, _listener, _options) { }
     on_(_type, _listener, _bind, _options) { return undefined; }
     off_(_id) { }
-    once(_type, _listener, _capture) { }
+    once(_type, _listener, _captureOrBind, _capture) { }
     emit(_type, _event, _capture) { }
     emitEvent(_event, _capture) { }
     hasEvent(_type, _capture) { return false; }
@@ -6144,13 +6232,14 @@ class LeafLevelList {
     }
 }
 
-const version = "1.6.2";
+const version = "1.6.3";
 
 exports.AlignHelper = AlignHelper;
 exports.AroundHelper = AroundHelper;
 exports.AutoBounds = AutoBounds;
 exports.BezierHelper = BezierHelper;
 exports.Bounds = Bounds;
+exports.BoundsEvent = BoundsEvent;
 exports.BoundsHelper = BoundsHelper;
 exports.BranchHelper = BranchHelper;
 exports.BranchRender = BranchRender;