@leafer/core 1.3.3 → 1.4.1

package/lib/core.esm.js

@@ -1374,7 +1374,7 @@ function getNameList(name) {
 }
 const D$4 = Debug;
 
-const debug$9 = Debug.get('RunTime');
+const debug$a = Debug.get('RunTime');
 const Run = {
     currentId: 0,
     currentName: '',
@@ -1383,24 +1383,24 @@ const Run = {
     nameToIdMap: {},
     start(name, microsecond) {
         const id = IncrementId.create(IncrementId.RUNTIME);
-        R.currentId = R.idMap[id] = microsecond ? performance.now() : Date.now();
-        R.currentName = R.nameMap[id] = name;
-        R.nameToIdMap[name] = id;
+        R$1.currentId = R$1.idMap[id] = microsecond ? performance.now() : Date.now();
+        R$1.currentName = R$1.nameMap[id] = name;
+        R$1.nameToIdMap[name] = id;
         return id;
     },
     end(id, microsecond) {
-        const time = R.idMap[id], name = R.nameMap[id];
+        const time = R$1.idMap[id], name = R$1.nameMap[id];
         const duration = microsecond ? (performance.now() - time) / 1000 : Date.now() - time;
-        R.idMap[id] = R.nameMap[id] = R.nameToIdMap[name] = undefined;
-        debug$9.log(name, duration, 'ms');
+        R$1.idMap[id] = R$1.nameMap[id] = R$1.nameToIdMap[name] = undefined;
+        debug$a.log(name, duration, 'ms');
     },
     endOfName(name, microsecond) {
-        const id = R.nameToIdMap[name];
+        const id = R$1.nameToIdMap[name];
         if (id !== undefined)
-            R.end(id, microsecond);
+            R$1.end(id, microsecond);
     }
 };
-const R = Run;
+const R$1 = Run;
 
 const check = [];
 const Plugin = {
@@ -1421,18 +1421,18 @@ const Plugin = {
 };
 setTimeout(() => check.forEach(name => Plugin.has(name, true)));
 
-const debug$8 = Debug.get('UICreator');
+const debug$9 = Debug.get('UICreator');
 const UICreator = {
     list: {},
     register(UI) {
         const { __tag: tag } = UI.prototype;
         if (list$1[tag])
-            debug$8.repeat(tag);
+            debug$9.repeat(tag);
         list$1[tag] = UI;
     },
     get(tag, data, x, y, width, height) {
         if (!list$1[tag])
-            debug$8.error('not register ' + tag);
+            debug$9.error('not register ' + tag);
         const ui = new list$1[tag](data);
         if (x !== undefined) {
             ui.x = x;
@@ -1448,7 +1448,7 @@ const UICreator = {
 };
 const { list: list$1 } = UICreator;
 
-const debug$7 = Debug.get('EventCreator');
+const debug$8 = Debug.get('EventCreator');
 const EventCreator = {
     nameList: {},
     register(Event) {
@@ -1456,7 +1456,7 @@ const EventCreator = {
         Object.keys(Event).forEach(key => {
             name = Event[key];
             if (typeof name === 'string')
-                nameList[name] && debug$7.repeat(name), nameList[name] = Event;
+                nameList[name] && debug$8.repeat(name), nameList[name] = Event;
         });
     },
     changeName(oldName, newName) {
@@ -1533,10 +1533,10 @@ const DataHelper = {
         Object.keys(merge).forEach(key => {
             var _a, _b;
             value = merge[key];
-            if ((value === null || value === undefined ? undefined : value.constructor) === Object && ((_a = t[key]) === null || _a === undefined ? undefined : _a.constructor) === Object)
+            if ((value === null || value === void 0 ? void 0 : value.constructor) === Object && ((_a = t[key]) === null || _a === void 0 ? void 0 : _a.constructor) === Object)
                 return assign(t[key], merge[key], exclude && exclude[key]);
             if (exclude && (key in exclude)) {
-                if (((_b = exclude[key]) === null || _b === undefined ? undefined : _b.constructor) === Object)
+                if (((_b = exclude[key]) === null || _b === void 0 ? void 0 : _b.constructor) === Object)
                     assign(t[key] = {}, merge[key], exclude[key]);
                 return;
             }
@@ -1660,7 +1660,7 @@ class LeafData {
         const t = this;
         if (t.blendMode === 'pass-through') {
             const leaf = this.__leaf;
-            if ((t.opacity < 1 && (leaf.isBranch || t.__hasMultiPaint)) || leaf.__hasEraser || t.eraser) {
+            if ((t.opacity < 1 && (leaf.isBranch || t.__hasMultiPaint)) || leaf.__hasEraser || t.eraser || t.filter) {
                 t.__single = true;
             }
             else if (t.__single) {
@@ -1773,7 +1773,7 @@ class Canvas {
     }
     setTransform(_a, _b, _c, _d, _e, _f) { }
     resetTransform() { }
-    getTransform() { return undefined; }
+    getTransform() { return void 0; }
     save() { }
     restore() { }
     transform(a, b, c, d, e, f) {
@@ -1830,12 +1830,12 @@ class Canvas {
     ellipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) { }
     rect(_x, _y, _width, _height) { }
     roundRect(_x, _y, _width, _height, _radius) { }
-    createConicGradient(_startAngle, _x, _y) { return undefined; }
-    createLinearGradient(_x0, _y0, _x1, _y1) { return undefined; }
-    createPattern(_image, _repetition) { return undefined; }
-    createRadialGradient(_x0, _y0, _r0, _x1, _y1, _r1) { return undefined; }
+    createConicGradient(_startAngle, _x, _y) { return void 0; }
+    createLinearGradient(_x0, _y0, _x1, _y1) { return void 0; }
+    createPattern(_image, _repetition) { return void 0; }
+    createRadialGradient(_x0, _y0, _r0, _x1, _y1, _r1) { return void 0; }
     fillText(_text, _x, _y, _maxWidth) { }
-    measureText(_text) { return undefined; }
+    measureText(_text) { return void 0; }
     strokeText(_text, _x, _y, _maxWidth) { }
     destroy() {
         this.context = null;
@@ -1843,79 +1843,79 @@ class Canvas {
 }
 __decorate([
     contextAttr('imageSmoothingEnabled')
-], Canvas.prototype, "smooth", undefined);
+], Canvas.prototype, "smooth", void 0);
 __decorate([
     contextAttr('imageSmoothingQuality')
-], Canvas.prototype, "smoothLevel", undefined);
+], Canvas.prototype, "smoothLevel", void 0);
 __decorate([
     contextAttr('globalAlpha')
-], Canvas.prototype, "opacity", undefined);
+], Canvas.prototype, "opacity", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fillStyle", undefined);
+], Canvas.prototype, "fillStyle", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "strokeStyle", undefined);
+], Canvas.prototype, "strokeStyle", void 0);
 __decorate([
     contextAttr('lineWidth')
-], Canvas.prototype, "strokeWidth", undefined);
+], Canvas.prototype, "strokeWidth", void 0);
 __decorate([
     contextAttr('lineCap')
-], Canvas.prototype, "strokeCap", undefined);
+], Canvas.prototype, "strokeCap", void 0);
 __decorate([
     contextAttr('lineJoin')
-], Canvas.prototype, "strokeJoin", undefined);
+], Canvas.prototype, "strokeJoin", void 0);
 __decorate([
     contextAttr('lineDashOffset')
-], Canvas.prototype, "dashOffset", undefined);
+], Canvas.prototype, "dashOffset", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "miterLimit", undefined);
+], Canvas.prototype, "miterLimit", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowBlur", undefined);
+], Canvas.prototype, "shadowBlur", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowColor", undefined);
+], Canvas.prototype, "shadowColor", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowOffsetX", undefined);
+], Canvas.prototype, "shadowOffsetX", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowOffsetY", undefined);
+], Canvas.prototype, "shadowOffsetY", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "filter", undefined);
+], Canvas.prototype, "filter", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "font", undefined);
+], Canvas.prototype, "font", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontKerning", undefined);
+], Canvas.prototype, "fontKerning", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontStretch", undefined);
+], Canvas.prototype, "fontStretch", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontVariantCaps", undefined);
+], Canvas.prototype, "fontVariantCaps", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textAlign", undefined);
+], Canvas.prototype, "textAlign", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textBaseline", undefined);
+], Canvas.prototype, "textBaseline", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textRendering", undefined);
+], Canvas.prototype, "textRendering", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "wordSpacing", undefined);
+], Canvas.prototype, "wordSpacing", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "letterSpacing", undefined);
+], Canvas.prototype, "letterSpacing", void 0);
 __decorate([
     contextAttr()
-], Canvas.prototype, "direction", undefined);
+], Canvas.prototype, "direction", void 0);
 __decorate([
     contextMethod()
 ], Canvas.prototype, "setTransform", null);
@@ -2612,7 +2612,7 @@ const EllipseHelper = {
 const { M: M$4, m, L: L$5, l, H, h, V, v, C: C$4, c, S, s, Q: Q$3, q, T, t, A, a, Z: Z$4, z, N: N$3, D: D$3, X: X$3, G: G$3, F: F$4, O: O$3, P: P$3, U: U$3 } = PathCommandMap;
 const { rect: rect$1, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$3, quadraticCurveTo: quadraticCurveTo$1 } = BezierHelper;
 const { ellipticalArc } = EllipseHelper;
-const debug$6 = Debug.get('PathConvert');
+const debug$7 = Debug.get('PathConvert');
 const setEndPoint$1 = {};
 const PathConvert = {
     current: { dot: 0 },
@@ -2853,7 +2853,7 @@ const PathConvert = {
                     i += 6;
                     break;
                 default:
-                    debug$6.error(`command: ${command} [index:${i}]`, old);
+                    debug$7.error(`command: ${command} [index:${i}]`, old);
                     return data;
             }
             lastCommand = command;
@@ -2962,12 +2962,10 @@ const PathCommandDataHelper = {
     },
     arcTo(data, x1, y1, x2, y2, radius, lastX, lastY) {
         if (lastX !== undefined) {
-            const maxRadius = tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2) * (getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2) / 2);
-            data.push(U$2, x1, y1, x2, y2, min(radius, abs(maxRadius)));
-        }
-        else {
-            data.push(U$2, x1, y1, x2, y2, radius);
+            const d = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2);
+            radius = min(radius, min(d / 2, d / 2 * abs(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
+        data.push(U$2, x1, y1, x2, y2, radius);
     },
     drawEllipse(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
         BezierHelper.ellipse(null, x, y, radiusX, radiusY, rotation === undefined ? 0 : rotation, startAngle === undefined ? 0 : startAngle, endAngle === undefined ? 360 : endAngle, anticlockwise, null, null, startPoint);
@@ -3078,7 +3076,7 @@ class PathCreator {
 }
 
 const { M: M$2, L: L$3, C: C$2, Q: Q$1, Z: Z$2, N: N$1, D: D$1, X: X$1, G: G$1, F: F$2, O: O$1, P: P$1, U: U$1 } = PathCommandMap;
-const debug$5 = Debug.get('PathDrawer');
+const debug$6 = Debug.get('PathDrawer');
 const PathDrawer = {
     drawPathByData(drawer, data) {
         if (!data)
@@ -3141,7 +3139,7 @@ const PathDrawer = {
                     i += 6;
                     break;
                 default:
-                    debug$5.error(`command: ${command} [index:${i}]`, data);
+                    debug$6.error(`command: ${command} [index:${i}]`, data);
                     return;
             }
         }
@@ -3151,7 +3149,7 @@ const PathDrawer = {
 const { M: M$1, L: L$2, C: C$1, Q, Z: Z$1, N, D, X, G, F: F$1, O, P, U } = PathCommandMap;
 const { toTwoPointBounds, toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc, ellipse } = BezierHelper;
 const { addPointBounds, copy: copy$4, addPoint, setPoint, addBounds, toBounds: toBounds$1 } = TwoPointBoundsHelper;
-const debug$4 = Debug.get('PathBounds');
+const debug$5 = Debug.get('PathBounds');
 let radius, radiusX, radiusY;
 const tempPointBounds = {};
 const setPointBounds = {};
@@ -3259,7 +3257,7 @@ const PathBounds = {
                     i += 6;
                     break;
                 default:
-                    debug$4.error(`command: ${command} [index:${i}]`, data);
+                    debug$5.error(`command: ${command} [index:${i}]`, data);
                     return;
             }
         }
@@ -3375,7 +3373,7 @@ const FileHelper = {
 const F = FileHelper;
 F.opacityTypes.forEach(type => F.upperCaseTypeMap[type] = type.toUpperCase());
 
-const debug$3 = Debug.get('TaskProcessor');
+const debug$4 = Debug.get('TaskProcessor');
 class TaskItem {
     constructor(task) {
         this.parallel = true;
@@ -3384,13 +3382,13 @@ class TaskItem {
         this.task = task;
     }
     run() {
-        return __awaiter(this, undefined, undefined, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.task && !this.isComplete && this.parent.running)
                     yield this.task();
             }
             catch (error) {
-                debug$3.error(error);
+                debug$4.error(error);
             }
         });
     }
@@ -3623,18 +3621,52 @@ class TaskProcessor {
     }
 }
 
-const ImageManager = {
+const debug$3 = Debug.get('Resource');
+const Resource = {
+    tasker: new TaskProcessor(),
     map: {},
+    get isComplete() { return R.tasker.isComplete; },
+    set(key, value) {
+        if (R.map[key])
+            debug$3.repeat(key);
+        R.map[key] = value;
+    },
+    get(key) {
+        return R.map[key];
+    },
+    remove(key) {
+        delete R.map[key];
+    },
+    loadImage(key, format) {
+        return new Promise((resolve, reject) => {
+            const image = this.setImage(key, key, format);
+            image.load(() => resolve(image), (e) => reject(e));
+        });
+    },
+    setImage(key, value, format) {
+        let config;
+        if (typeof value === 'string')
+            config = { url: value };
+        else if (!value.url)
+            config = { url: key, view: value };
+        if (config)
+            format && (config.format = format), value = Creator.image(config);
+        R.set(key, value);
+        return value;
+    },
+    destroy() {
+        R.map = {};
+    }
+};
+const R = Resource;
+
+const ImageManager = {
     recycledList: [],
-    tasker: new TaskProcessor(),
     patternTasker: new TaskProcessor(),
-    get isComplete() { return I.tasker.isComplete; },
     get(config) {
-        let image = I.map[config.url];
-        if (!image) {
-            image = Creator.image(config);
-            I.map[config.url] = image;
-        }
+        let image = Resource.get(config.url);
+        if (!image)
+            Resource.set(config.url, image = Creator.image(config));
         image.use++;
         return image;
     },
@@ -3648,7 +3680,7 @@ const ImageManager = {
         if (list.length > 100) {
             list.forEach(image => {
                 if (!image.use && image.url) {
-                    delete I.map[image.url];
+                    Resource.remove(image.url);
                     image.destroy();
                 }
             });
@@ -3675,7 +3707,6 @@ const ImageManager = {
         return false;
     },
     destroy() {
-        I.map = {};
         I.recycledList = [];
     }
 };
@@ -3689,21 +3720,19 @@ class LeaferImage {
         this.use = 0;
         this.waitComplete = [];
         this.innerId = create$1(IMAGE);
-        this.config = config || { url: '' };
-        this.isSVG = ImageManager.isFormat('svg', config);
-        this.hasOpacityPixel = ImageManager.hasOpacityPixel(config);
+        this.config = config || (config = { url: '' });
+        if (config.view) {
+            const { view } = config;
+            this.setView(view.config ? view.view : view);
+        }
+        ImageManager.isFormat('svg', config) && (this.isSVG = true);
+        ImageManager.hasOpacityPixel(config) && (this.hasOpacityPixel = true);
     }
     load(onSuccess, onError) {
         if (!this.loading) {
             this.loading = true;
-            ImageManager.tasker.add(() => __awaiter(this, undefined, undefined, function* () {
-                return yield Platform.origin.loadImage(this.url).then((img) => {
-                    this.ready = true;
-                    this.width = img.naturalWidth || img.width;
-                    this.height = img.naturalHeight || img.height;
-                    this.view = img;
-                    this.onComplete(true);
-                }).catch((e) => {
+            Resource.tasker.add(() => __awaiter(this, void 0, void 0, function* () {
+                return yield Platform.origin.loadImage(this.url).then(img => this.setView(img)).catch((e) => {
                     this.error = e;
                     this.onComplete(false);
                 });
@@ -3721,6 +3750,13 @@ class LeaferImage {
         }
         l[index] = l[index + 1] = undefined;
     }
+    setView(img) {
+        this.ready = true;
+        this.width = img.naturalWidth || img.width;
+        this.height = img.naturalHeight || img.height;
+        this.view = img;
+        this.onComplete(true);
+    }
     onComplete(isSuccess) {
         let odd;
         this.waitComplete.forEach((item, index) => {
@@ -3739,6 +3775,9 @@ class LeaferImage {
         this.waitComplete.length = 0;
         this.loading = false;
     }
+    getFull(_filters) {
+        return this.view;
+    }
     getCanvas(width, height, opacity, _filters) {
         width || (width = this.width);
         height || (height = this.height);
@@ -3821,10 +3860,10 @@ function autoLayoutType(defaultValue) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
             if (this.__setAttr(key, value)) {
-                this.__layout.matrixChanged || this.__layout.matrixChange();
                 this.__hasAutoLayout = !!(this.origin || this.around || this.flow);
                 if (!this.__local)
                     this.__layout.createLocal();
+                doBoundsType(this);
             }
         }
     }));
@@ -4207,55 +4246,62 @@ const LeafHelper = {
         y += t.y;
         transition ? t.animate({ x, y }, transition) : (t.x = x, t.y = y);
     },
-    zoomOfWorld(t, origin, scaleX, scaleY, resize) {
-        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize);
+    zoomOfWorld(t, origin, scaleX, scaleY, resize, transition) {
+        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
     },
-    zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize) {
-        copy$3(matrix, t.__localMatrix);
+    zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition) {
+        const o = t.__localMatrix;
+        if (typeof scaleY !== 'number') {
+            if (scaleY)
+                transition = scaleY;
+            scaleY = scaleX;
+        }
+        copy$3(matrix, o);
         scaleOfOuter(matrix, origin, scaleX, scaleY);
         if (t.origin || t.around) {
-            L.setTransform(t, matrix, resize);
+            L.setTransform(t, matrix, resize, transition);
         }
         else {
-            moveByMatrix(t, matrix);
-            t.scaleResize(scaleX, scaleY, resize !== true);
+            const x = t.x + matrix.e - o.e, y = t.y + matrix.f - o.f;
+            if (transition && !resize)
+                t.animate({ x, y, scaleX: t.scaleX * scaleX, scaleY: t.scaleY * scaleY }, transition);
+            else
+                t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true);
         }
     },
-    rotateOfWorld(t, origin, angle) {
-        L.rotateOfLocal(t, getTempLocal(t, origin), angle);
+    rotateOfWorld(t, origin, angle, transition) {
+        L.rotateOfLocal(t, getTempLocal(t, origin), angle, transition);
     },
-    rotateOfLocal(t, origin, angle) {
-        copy$3(matrix, t.__localMatrix);
+    rotateOfLocal(t, origin, angle, transition) {
+        const o = t.__localMatrix;
+        copy$3(matrix, o);
         rotateOfOuter(matrix, origin, angle);
-        if (t.origin || t.around) {
-            L.setTransform(t, matrix);
-        }
-        else {
-            moveByMatrix(t, matrix);
-            t.rotation = MathHelper.formatRotation(t.rotation + angle);
-        }
+        if (t.origin || t.around)
+            L.setTransform(t, matrix, false, transition);
+        else
+            t.set({ x: t.x + matrix.e - o.e, y: t.y + matrix.f - o.f, rotation: MathHelper.formatRotation(t.rotation + angle) }, transition);
     },
-    skewOfWorld(t, origin, skewX, skewY, resize) {
-        L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize);
+    skewOfWorld(t, origin, skewX, skewY, resize, transition) {
+        L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize, transition);
     },
-    skewOfLocal(t, origin, skewX, skewY = 0, resize) {
+    skewOfLocal(t, origin, skewX, skewY = 0, resize, transition) {
         copy$3(matrix, t.__localMatrix);
         skewOfOuter(matrix, origin, skewX, skewY);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, resize, transition);
     },
-    transformWorld(t, transform, resize) {
+    transformWorld(t, transform, resize, transition) {
         copy$3(matrix, t.worldTransform);
         multiplyParent$2(matrix, transform);
         if (t.parent)
             divideParent(matrix, t.parent.worldTransform);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, resize, transition);
     },
-    transform(t, transform, resize) {
+    transform(t, transform, resize, transition) {
         copy$3(matrix, t.localTransform);
         multiplyParent$2(matrix, transform);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, resize, transition);
     },
-    setTransform(t, transform, resize) {
+    setTransform(t, transform, resize, transition) {
         const data = t.__, originPoint = data.origin && L.getInnerOrigin(t, data.origin);
         const layout = getLayout(transform, originPoint, data.around && L.getInnerOrigin(t, data.around));
         if (resize) {
@@ -4270,7 +4316,7 @@ const LeafHelper = {
             t.scaleResize(scaleX, scaleY, false);
         }
         else
-            t.set(layout);
+            t.set(layout, transition);
     },
     getFlipTransform(t, axis) {
         const m = getMatrixData();
@@ -4307,11 +4353,6 @@ const LeafHelper = {
 };
 const L = LeafHelper;
 const { updateAllMatrix: updateAllMatrix$1, updateMatrix: updateMatrix$1, updateAllWorldOpacity, updateAllChange } = L;
-function moveByMatrix(t, matrix) {
-    const { e, f } = t.__localMatrix;
-    t.x += matrix.e - e;
-    t.y += matrix.f - f;
-}
 function getTempLocal(t, world) {
     t.__layout.update();
     return t.parent ? PointHelper.tempToInnerOf(world, t.parent.__world) : world;
@@ -5217,7 +5258,7 @@ const LeafRender = {
                 if (this.__.eraser === 'path')
                     return this.__renderEraser(canvas, options);
                 const tempCanvas = canvas.getSameCanvas(true, true);
-                this.__draw(tempCanvas, options);
+                this.__draw(tempCanvas, options, canvas);
                 if (this.__worldFlipped) {
                     canvas.copyWorldByReset(tempCanvas, this.__nowWorld, null, this.__.__blendMode, true);
                 }
@@ -5585,11 +5626,11 @@ let Leaf = class Leaf {
         const layer = this.leafer ? this.leafer.zoomLayer : this;
         return layer.getWorldPoint(page, relative, distance, change);
     }
-    setTransform(matrix, resize) {
-        setTransform(this, matrix, resize);
+    setTransform(matrix, resize, transition) {
+        setTransform(this, matrix, resize, transition);
     }
-    transform(matrix, resize) {
-        transform(this, matrix, resize);
+    transform(matrix, resize, transition) {
+        transform(this, matrix, resize, transition);
     }
     move(x, y, transition) {
         moveLocal(this, x, y, transition);
@@ -5597,32 +5638,32 @@ let Leaf = class Leaf {
     moveInner(x, y, transition) {
         moveWorld(this, x, y, true, transition);
     }
-    scaleOf(origin, scaleX, scaleY, resize) {
-        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize);
+    scaleOf(origin, scaleX, scaleY, resize, transition) {
+        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition);
     }
-    rotateOf(origin, rotation) {
-        rotateOfLocal(this, getLocalOrigin(this, origin), rotation);
+    rotateOf(origin, rotation, transition) {
+        rotateOfLocal(this, getLocalOrigin(this, origin), rotation, transition);
     }
-    skewOf(origin, skewX, skewY, resize) {
-        skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize);
+    skewOf(origin, skewX, skewY, resize, transition) {
+        skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize, transition);
     }
-    transformWorld(worldTransform, resize) {
-        transformWorld(this, worldTransform, resize);
+    transformWorld(worldTransform, resize, transition) {
+        transformWorld(this, worldTransform, resize, transition);
     }
     moveWorld(x, y, transition) {
         moveWorld(this, x, y, false, transition);
     }
-    scaleOfWorld(worldOrigin, scaleX, scaleY, resize) {
-        zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize);
+    scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition) {
+        zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition);
     }
     rotateOfWorld(worldOrigin, rotation) {
         rotateOfWorld(this, worldOrigin, rotation);
     }
-    skewOfWorld(worldOrigin, skewX, skewY, resize) {
-        skewOfWorld(this, worldOrigin, skewX, skewY, resize);
+    skewOfWorld(worldOrigin, skewX, skewY, resize, transition) {
+        skewOfWorld(this, worldOrigin, skewX, skewY, resize, transition);
     }
-    flip(axis) {
-        transform(this, getFlipTransform(this, axis));
+    flip(axis, transition) {
+        transform(this, getFlipTransform(this, axis), false, transition);
     }
     scaleResize(scaleX, scaleY = scaleX, _noResize) {
         this.scaleX *= scaleX;
@@ -6010,6 +6051,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.3.3";
+const version = "1.4.1";
 
-export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsHelper, Branch, BranchHelper, BranchRender, CanvasManager, ChildEvent, Creator, DataHelper, Debug, Direction4, Direction9, EllipseHelper, Event, EventCreator, Eventer, FileHelper, ImageEvent, ImageManager, IncrementId, LayoutEvent, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, LeaferCanvasBase, LeaferEvent, LeaferImage, MathHelper, Matrix, MatrixHelper, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Platform, Plugin, Point, PointHelper, PropertyEvent, RectHelper, RenderEvent, ResizeEvent, Run, StringNumberMap, TaskItem, TaskProcessor, TwoPointBoundsHelper, UICreator, WaitHelper, WatchEvent, affectRenderBoundsType, affectStrokeBoundsType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isNull, layoutProcessor, maskType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, rewrite, rewriteAble, rotationType, scaleType, sortType, strokeType, surfaceType, tempBounds, tempMatrix, tempPoint$2 as tempPoint, useModule, version, visibleType };
+export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsHelper, Branch, BranchHelper, BranchRender, CanvasManager, ChildEvent, Creator, DataHelper, Debug, Direction4, Direction9, EllipseHelper, Event, EventCreator, Eventer, FileHelper, ImageEvent, ImageManager, IncrementId, LayoutEvent, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, LeaferCanvasBase, LeaferEvent, LeaferImage, MathHelper, Matrix, MatrixHelper, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Platform, Plugin, Point, PointHelper, PropertyEvent, RectHelper, RenderEvent, ResizeEvent, Resource, Run, StringNumberMap, TaskItem, TaskProcessor, TwoPointBoundsHelper, UICreator, WaitHelper, WatchEvent, affectRenderBoundsType, affectStrokeBoundsType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isNull, layoutProcessor, maskType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, rewrite, rewriteAble, rotationType, scaleType, sortType, strokeType, surfaceType, tempBounds, tempMatrix, tempPoint$2 as tempPoint, useModule, version, visibleType };
+//# sourceMappingURL=core.esm.js.map