@leafer-ui/node 1.7.0 → 1.8.0

package/dist/node.cjs

@@ -868,9 +868,14 @@ function fills(fills, ui, canvas) {
             }
         }
         canvas.fillStyle = item.style;
-        if (item.transform) {
+        if (item.transform || item.scaleFixed) {
             canvas.save();
-            canvas.transform(item.transform);
+            if (item.transform)
+                canvas.transform(item.transform);
+            if (item.scaleFixed) {
+                const { scaleX, scaleY } = ui.getRenderScaleData(true);
+                canvas.scale(1 / scaleX, 1 / scaleY);
+            }
             if (item.blendMode)
                 canvas.blendMode = item.blendMode;
             fillPathOrText(ui, canvas);
@@ -906,8 +911,13 @@ function strokeText(stroke, ui, canvas) {
 }
 function drawCenter$1(stroke, strokeWidthScale, ui, canvas) {
     const data = ui.__;
-    canvas.setStroke(!data.__isStrokes && stroke, data.strokeWidth * strokeWidthScale, data);
-    data.__isStrokes ? drawStrokesStyle(stroke, true, ui, canvas) : drawTextStroke(ui, canvas);
+    if (typeof stroke === 'object') {
+        drawStrokesStyle(stroke, strokeWidthScale, true, ui, canvas);
+    }
+    else {
+        canvas.setStroke(stroke, data.__strokeWidth * strokeWidthScale, data);
+        drawTextStroke(ui, canvas);
+    }
 }
 function drawAlign(stroke, align, ui, canvas) {
     const out = canvas.getSameCanvas(true, true);
@@ -916,15 +926,9 @@ function drawAlign(stroke, align, ui, canvas) {
     out.blendMode = align === 'outside' ? 'destination-out' : 'destination-in';
     fillText(ui, out);
     out.blendMode = 'normal';
-    copyWorld(canvas, out, ui);
+    core.LeafHelper.copyCanvasByWorld(ui, canvas, out);
     out.recycle(ui.__nowWorld);
 }
-function copyWorld(canvas, out, ui) {
-    if (ui.__worldFlipped || core.Platform.fullImageShadow)
-        canvas.copyWorldByReset(out, ui.__nowWorld);
-    else
-        canvas.copyWorldToInner(out, ui.__nowWorld, ui.__layout.renderBounds);
-}
 function drawTextStroke(ui, canvas) {
     let row, data = ui.__.__textDrawData;
     const { rows, decorationY } = data;
@@ -940,14 +944,21 @@ function drawTextStroke(ui, canvas) {
         rows.forEach(row => decorationY.forEach(value => canvas.strokeRect(row.x, row.y + value, row.width, decorationHeight)));
     }
 }
-function drawStrokesStyle(strokes, isText, ui, canvas) {
+function drawStrokesStyle(strokes, strokeWidthScale, isText, ui, canvas) {
     let item;
+    const data = ui.__, { __hasMultiStrokeStyle } = data;
+    __hasMultiStrokeStyle || canvas.setStroke(undefined, data.__strokeWidth * strokeWidthScale, data);
     for (let i = 0, len = strokes.length; i < len; i++) {
         item = strokes[i];
         if (item.image && draw.PaintImage.checkImage(ui, canvas, item, false))
             continue;
         if (item.style) {
-            canvas.strokeStyle = item.style;
+            if (__hasMultiStrokeStyle) {
+                const { strokeStyle } = item;
+                strokeStyle ? canvas.setStroke(item.style, data.__getRealStrokeWidth(strokeStyle) * strokeWidthScale, data, strokeStyle) : canvas.setStroke(item.style, data.__strokeWidth * strokeWidthScale, data);
+            }
+            else
+                canvas.strokeStyle = item.style;
             if (item.blendMode) {
                 canvas.saveBlendMode(item.blendMode);
                 isText ? drawTextStroke(ui, canvas) : canvas.stroke();
@@ -986,8 +997,13 @@ function strokes(strokes, ui, canvas) {
 }
 function drawCenter(stroke, strokeWidthScale, ui, canvas) {
     const data = ui.__;
-    canvas.setStroke(!data.__isStrokes && stroke, data.__strokeWidth * strokeWidthScale, data);
-    data.__isStrokes ? drawStrokesStyle(stroke, false, ui, canvas) : canvas.stroke();
+    if (typeof stroke === 'object') {
+        drawStrokesStyle(stroke, strokeWidthScale, false, ui, canvas);
+    }
+    else {
+        canvas.setStroke(stroke, data.__strokeWidth * strokeWidthScale, data);
+        canvas.stroke();
+    }
     if (data.__useArrow)
         draw.Paint.strokeArrow(stroke, ui, canvas);
 }
@@ -1009,7 +1025,7 @@ function drawOutside(stroke, ui, canvas) {
         drawCenter(stroke, 2, ui, out);
         out.clipUI(data);
         out.clearWorld(renderBounds);
-        copyWorld(canvas, out, ui);
+        core.LeafHelper.copyCanvasByWorld(ui, canvas, out);
         out.recycle(ui.__nowWorld);
     }
 }
@@ -1064,8 +1080,16 @@ function compute(attrName, ui) {
     if (!(paints instanceof Array))
         paints = [paints];
     recycleMap = draw.PaintImage.recycleImage(attrName, data);
+    let maxChildStrokeWidth;
     for (let i = 0, len = paints.length, item; i < len; i++) {
-        (item = getLeafPaint(attrName, paints[i], ui)) && leafPaints.push(item);
+        if (item = getLeafPaint(attrName, paints[i], ui)) {
+            leafPaints.push(item);
+            if (item.strokeStyle) {
+                maxChildStrokeWidth || (maxChildStrokeWidth = 1);
+                if (item.strokeStyle.strokeWidth)
+                    maxChildStrokeWidth = Math.max(maxChildStrokeWidth, item.strokeStyle.strokeWidth);
+            }
+        }
     }
     data['_' + attrName] = leafPaints.length ? leafPaints : undefined;
     if (leafPaints.length) {
@@ -1082,6 +1106,7 @@ function compute(attrName, ui) {
     else {
         stintSet(data, '__isAlphaPixelStroke', isAlphaPixel);
         stintSet(data, '__isTransparentStroke', isTransparent);
+        stintSet(data, '__hasMultiStrokeStyle', maxChildStrokeWidth);
     }
 }
 function getLeafPaint(attrName, paint, ui) {
@@ -1113,6 +1138,11 @@ function getLeafPaint(attrName, paint, ui) {
     if (data) {
         if (typeof data.style === 'string' && hasTransparent$1(data.style))
             data.isTransparent = true;
+        if (paint.style) {
+            if (paint.style.strokeWidth === 0)
+                return undefined;
+            data.strokeStyle = paint.style;
+        }
         if (paint.blendMode)
             data.blendMode = paint.blendMode;
     }
@@ -1132,8 +1162,8 @@ const PaintModule = {
     shape
 };
 
-let origin = {};
-const { get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, scale: scaleHelper, rotate, skew: skewHelper } = core.MatrixHelper;
+let origin = {}, tempMatrix = core.getMatrixData();
+const { get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, multiplyParent, scale: scaleHelper, rotate, skew: skewHelper } = core.MatrixHelper;
 function fillOrFitMode(data, box, x, y, scaleX, scaleY, rotation) {
     const transform = get$3();
     translate$1(transform, box.x + x, box.y + y);
@@ -1142,7 +1172,7 @@ function fillOrFitMode(data, box, x, y, scaleX, scaleY, rotation) {
         rotateOfOuter$1(transform, { x: box.x + box.width / 2, y: box.y + box.height / 2 }, rotation);
     data.transform = transform;
 }
-function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew) {
+function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew, clipSize) {
     const transform = get$3();
     if (rotation)
         rotate(transform, rotation);
@@ -1151,6 +1181,10 @@ function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew) {
     if (scaleX)
         scaleHelper(transform, scaleX, scaleY);
     translate$1(transform, box.x + x, box.y + y);
+    if (clipSize) {
+        tempMatrix.a = box.width / clipSize.width, tempMatrix.d = box.height / clipSize.height;
+        multiplyParent(transform, tempMatrix);
+    }
     data.transform = transform;
 }
 function repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, align) {
@@ -1187,13 +1221,15 @@ const tempBox = new core.Bounds();
 const tempScaleData = {};
 const tempImage = {};
 function createData(leafPaint, image, paint, box) {
-    const { changeful, sync, editing } = paint;
+    const { changeful, sync, editing, scaleFixed } = paint;
     if (changeful)
         leafPaint.changeful = changeful;
     if (sync)
         leafPaint.sync = sync;
     if (editing)
         leafPaint.editing = editing;
+    if (scaleFixed)
+        leafPaint.scaleFixed = scaleFixed;
     leafPaint.data = getPatternData(paint, box, image);
 }
 function getPatternData(paint, box, image) {
@@ -1202,7 +1238,7 @@ function getPatternData(paint, box, image) {
     if (paint.mode === 'strench')
         paint.mode = 'stretch';
     let { width, height } = image;
-    const { opacity, mode, align, offset, scale, size, rotation, skew, repeat, filters } = paint;
+    const { opacity, mode, align, offset, scale, size, rotation, skew, clipSize, repeat, filters } = paint;
     const sameBox = box.width === width && box.height === height;
     const data = { mode };
     const swapSize = align !== 'center' && (rotation || 0) % 180 === 90;
@@ -1236,8 +1272,8 @@ function getPatternData(paint, box, image) {
             break;
         case 'normal':
         case 'clip':
-            if (tempImage.x || tempImage.y || scaleX || rotation || skew)
-                clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew);
+            if (tempImage.x || tempImage.y || scaleX || clipSize || rotation || skew)
+                clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew, paint.clipSize);
             break;
         case 'repeat':
             if (!sameBox || scaleX || rotation)
@@ -1374,18 +1410,16 @@ function ignoreRender(ui, value) {
 }
 
 const { get: get$1, scale, copy: copy$1 } = core.MatrixHelper;
-const { ceil, abs: abs$1 } = Math;
+const { ceil, abs } = Math;
 function createPattern(ui, paint, pixelRatio) {
-    let { scaleX, scaleY } = core.ImageManager.patternLocked ? ui.__world : ui.__nowWorld;
+    let { scaleX, scaleY } = ui.getRenderScaleData(true, paint.scaleFixed);
     const id = scaleX + '-' + scaleY + '-' + pixelRatio;
     if (paint.patternId !== id && !ui.destroyed) {
-        scaleX = abs$1(scaleX);
-        scaleY = abs$1(scaleY);
         const { image, data } = paint;
         let imageScale, imageMatrix, { width, height, scaleX: sx, scaleY: sy, transform, repeat } = data;
         if (sx) {
-            sx = abs$1(sx);
-            sy = abs$1(sy);
+            sx = abs(sx);
+            sy = abs(sy);
             imageMatrix = get$1();
             copy$1(imageMatrix, transform);
             scale(imageMatrix, 1 / sx, 1 / sy);
@@ -1438,9 +1472,8 @@ function createPattern(ui, paint, pixelRatio) {
     }
 }
 
-const { abs } = Math;
 function checkImage(ui, canvas, paint, allowDraw) {
-    const { scaleX, scaleY } = core.ImageManager.patternLocked ? ui.__world : ui.__nowWorld;
+    const { scaleX, scaleY } = ui.getRenderScaleData(true, paint.scaleFixed);
     const { pixelRatio } = canvas, { data } = paint;
     if (!data || (paint.patternId === scaleX + '-' + scaleY + '-' + pixelRatio && !draw.Export.running)) {
         return false;
@@ -1453,8 +1486,8 @@ function checkImage(ui, canvas, paint, allowDraw) {
             else {
                 if (!(paint.changeful || core.ResizeEvent.isResizing(ui) || draw.Export.running)) {
                     let { width, height } = data;
-                    width *= abs(scaleX) * pixelRatio;
-                    height *= abs(scaleY) * pixelRatio;
+                    width *= scaleX * pixelRatio;
+                    height *= scaleY * pixelRatio;
                     if (data.scaleX) {
                         width *= data.scaleX;
                         height *= data.scaleY;
@@ -1464,6 +1497,10 @@ function checkImage(ui, canvas, paint, allowDraw) {
             }
         }
         if (allowDraw) {
+            if (ui.__.__isFastShadow) {
+                canvas.fillStyle = paint.style || '#000';
+                canvas.fill();
+            }
             drawImage(ui, canvas, paint, data);
             return true;
         }
@@ -1652,10 +1689,7 @@ function shadow(ui, current, shape) {
             }
             worldCanvas ? other.copyWorld(worldCanvas, nowWorld, nowWorld, 'destination-out') : other.copyWorld(shape.canvas, shapeBounds, bounds, 'destination-out');
         }
-        if (ui.__worldFlipped)
-            current.copyWorldByReset(other, copyBounds, nowWorld, item.blendMode);
-        else
-            current.copyWorldToInner(other, copyBounds, __layout.renderBounds, item.blendMode);
+        core.LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end)
             other.clearWorld(copyBounds, true);
     });
@@ -1714,10 +1748,7 @@ function innerShadow(ui, current, shape) {
             copyBounds = bounds;
         }
         other.fillWorld(copyBounds, draw.ColorConvert.string(item.color), 'source-in');
-        if (ui.__worldFlipped)
-            current.copyWorldByReset(other, copyBounds, nowWorld, item.blendMode);
-        else
-            current.copyWorldToInner(other, copyBounds, __layout.renderBounds, item.blendMode);
+        core.LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end)
             other.clearWorld(copyBounds, true);
     });
@@ -1773,12 +1804,11 @@ draw.Group.prototype.__renderMask = function (canvas, options) {
                     contentCanvas = getCanvas(canvas);
                 child.__render(maskCanvas, options);
             }
-            if (!(mask === 'clipping' || mask === 'clipping-path'))
-                continue;
-        }
-        if (excludeRenderBounds(child, options))
+            if (mask === 'clipping' || mask === 'clipping-path')
+                excludeRenderBounds(child, options) || child.__render(canvas, options);
             continue;
-        child.__render(contentCanvas || canvas, options);
+        }
+        excludeRenderBounds(child, options) || child.__render(contentCanvas || canvas, options);
     }
     maskEnd(this, currentMask, canvas, contentCanvas, maskCanvas, maskOpacity);
 };
@@ -2372,123 +2402,131 @@ function getTrimBounds(canvas) {
         index++;
     }
     const bounds = new draw.Bounds();
-    toBounds(pointBounds, bounds);
-    return bounds.scale(1 / canvas.pixelRatio).ceil();
+    if (pointBounds) {
+        toBounds(pointBounds, bounds);
+        bounds.scale(1 / canvas.pixelRatio).ceil();
+    }
+    return bounds;
 }
 
 const ExportModule = {
     syncExport(leaf, filename, options) {
-        this.running = true;
+        draw.Export.running = true;
         let result;
-        const fileType = draw.FileHelper.fileType(filename);
-        const isDownload = filename.includes('.');
-        options = draw.FileHelper.getExportOptions(options);
-        const { toURL } = draw.Platform;
-        const { download } = draw.Platform.origin;
-        if (fileType === 'json') {
-            isDownload && download(toURL(JSON.stringify(leaf.toJSON(options.json)), 'text'), filename);
-            result = { data: isDownload ? true : leaf.toJSON(options.json) };
-        }
-        else if (fileType === 'svg') {
-            isDownload && download(toURL(leaf.toSVG(), 'svg'), filename);
-            result = { data: isDownload ? true : leaf.toSVG() };
-        }
-        else {
-            let renderBounds, trimBounds, scaleX = 1, scaleY = 1;
-            const { worldTransform, isLeafer, leafer, isFrame } = leaf;
-            const { slice, clip, trim, screenshot, padding, onCanvas } = options;
-            const smooth = options.smooth === undefined ? (leafer ? leafer.config.smooth : true) : options.smooth;
-            const contextSettings = options.contextSettings || (leafer ? leafer.config.contextSettings : undefined);
-            const fill = (isLeafer && screenshot) ? (options.fill === undefined ? leaf.fill : options.fill) : options.fill;
-            const needFill = draw.FileHelper.isOpaqueImage(filename) || fill, matrix = new draw.Matrix();
-            if (screenshot) {
-                renderBounds = screenshot === true ? (isLeafer ? leafer.canvas.bounds : leaf.worldRenderBounds) : screenshot;
-            }
-            else {
-                let relative = options.relative || (isLeafer ? 'inner' : 'local');
-                scaleX = worldTransform.scaleX;
-                scaleY = worldTransform.scaleY;
-                switch (relative) {
-                    case 'inner':
-                        matrix.set(worldTransform);
-                        break;
-                    case 'local':
-                        matrix.set(worldTransform).divide(leaf.localTransform);
-                        scaleX /= leaf.scaleX;
-                        scaleY /= leaf.scaleY;
-                        break;
-                    case 'world':
-                        scaleX = 1;
-                        scaleY = 1;
-                        break;
-                    case 'page':
-                        relative = leafer || leaf;
-                    default:
-                        matrix.set(worldTransform).divide(leaf.getTransform(relative));
-                        const l = relative.worldTransform;
-                        scaleX /= scaleX / l.scaleX;
-                        scaleY /= scaleY / l.scaleY;
-                }
-                renderBounds = leaf.getBounds('render', relative);
-            }
-            const scaleData = { scaleX: 1, scaleY: 1 };
-            draw.MathHelper.getScaleData(options.scale, options.size, renderBounds, scaleData);
-            let pixelRatio = options.pixelRatio || 1;
-            let { x, y, width, height } = new draw.Bounds(renderBounds).scale(scaleData.scaleX, scaleData.scaleY);
-            if (clip)
-                x += clip.x, y += clip.y, width = clip.width, height = clip.height;
-            const renderOptions = { exporting: true, matrix: matrix.scale(1 / scaleData.scaleX, 1 / scaleData.scaleY).invert().translate(-x, -y).withScale(1 / scaleX * scaleData.scaleX, 1 / scaleY * scaleData.scaleY) };
-            let canvas = draw.Creator.canvas({ width: Math.floor(width), height: Math.floor(height), pixelRatio, smooth, contextSettings });
-            let sliceLeaf;
-            if (slice) {
-                sliceLeaf = leaf;
-                sliceLeaf.__worldOpacity = 0;
-                leaf = leafer || leaf;
-                renderOptions.bounds = canvas.bounds;
+        try {
+            const fileType = draw.FileHelper.fileType(filename);
+            const isDownload = filename.includes('.');
+            options = draw.FileHelper.getExportOptions(options);
+            const { toURL } = draw.Platform;
+            const { download } = draw.Platform.origin;
+            if (fileType === 'json') {
+                isDownload && download(toURL(JSON.stringify(leaf.toJSON(options.json)), 'text'), filename);
+                result = { data: isDownload ? true : leaf.toJSON(options.json) };
             }
-            canvas.save();
-            if (isFrame && fill !== undefined) {
-                const oldFill = leaf.get('fill');
-                leaf.fill = '';
-                leaf.__render(canvas, renderOptions);
-                leaf.fill = oldFill;
+            else if (fileType === 'svg') {
+                isDownload && download(toURL(leaf.toSVG(), 'svg'), filename);
+                result = { data: isDownload ? true : leaf.toSVG() };
             }
             else {
-                leaf.__render(canvas, renderOptions);
-            }
-            canvas.restore();
-            if (sliceLeaf)
-                sliceLeaf.__updateWorldOpacity();
-            if (trim) {
-                trimBounds = getTrimBounds(canvas);
-                const old = canvas, { width, height } = trimBounds;
-                const config = { x: 0, y: 0, width, height, pixelRatio };
-                canvas = draw.Creator.canvas(config);
-                canvas.copyWorld(old, trimBounds, config);
-            }
-            if (padding) {
-                const [top, right, bottom, left] = draw.MathHelper.fourNumber(padding);
-                const old = canvas, { width, height } = old;
-                canvas = draw.Creator.canvas({ width: width + left + right, height: height + top + bottom, pixelRatio });
-                canvas.copyWorld(old, old.bounds, { x: left, y: top, width, height });
+                let renderBounds, trimBounds, scaleX = 1, scaleY = 1;
+                const { worldTransform, isLeafer, leafer, isFrame } = leaf;
+                const { slice, clip, trim, screenshot, padding, onCanvas } = options;
+                const smooth = options.smooth === undefined ? (leafer ? leafer.config.smooth : true) : options.smooth;
+                const contextSettings = options.contextSettings || (leafer ? leafer.config.contextSettings : undefined);
+                const fill = (isLeafer && screenshot) ? (options.fill === undefined ? leaf.fill : options.fill) : options.fill;
+                const needFill = draw.FileHelper.isOpaqueImage(filename) || fill, matrix = new draw.Matrix();
+                if (screenshot) {
+                    renderBounds = screenshot === true ? (isLeafer ? leafer.canvas.bounds : leaf.worldRenderBounds) : screenshot;
+                }
+                else {
+                    let relative = options.relative || (isLeafer ? 'inner' : 'local');
+                    scaleX = worldTransform.scaleX;
+                    scaleY = worldTransform.scaleY;
+                    switch (relative) {
+                        case 'inner':
+                            matrix.set(worldTransform);
+                            break;
+                        case 'local':
+                            matrix.set(worldTransform).divide(leaf.localTransform);
+                            scaleX /= leaf.scaleX;
+                            scaleY /= leaf.scaleY;
+                            break;
+                        case 'world':
+                            scaleX = 1;
+                            scaleY = 1;
+                            break;
+                        case 'page':
+                            relative = leafer || leaf;
+                        default:
+                            matrix.set(worldTransform).divide(leaf.getTransform(relative));
+                            const l = relative.worldTransform;
+                            scaleX /= scaleX / l.scaleX;
+                            scaleY /= scaleY / l.scaleY;
+                    }
+                    renderBounds = leaf.getBounds('render', relative);
+                }
+                const scaleData = { scaleX: 1, scaleY: 1 };
+                draw.MathHelper.getScaleData(options.scale, options.size, renderBounds, scaleData);
+                let pixelRatio = options.pixelRatio || 1;
+                let { x, y, width, height } = new draw.Bounds(renderBounds).scale(scaleData.scaleX, scaleData.scaleY);
+                if (clip)
+                    x += clip.x, y += clip.y, width = clip.width, height = clip.height;
+                const renderOptions = { exporting: true, matrix: matrix.scale(1 / scaleData.scaleX, 1 / scaleData.scaleY).invert().translate(-x, -y).withScale(1 / scaleX * scaleData.scaleX, 1 / scaleY * scaleData.scaleY) };
+                let canvas = draw.Creator.canvas({ width: Math.floor(width), height: Math.floor(height), pixelRatio, smooth, contextSettings });
+                let sliceLeaf;
+                if (slice) {
+                    sliceLeaf = leaf;
+                    sliceLeaf.__worldOpacity = 0;
+                    leaf = leafer || leaf;
+                    renderOptions.bounds = canvas.bounds;
+                }
+                canvas.save();
+                if (isFrame && fill !== undefined) {
+                    const oldFill = leaf.get('fill');
+                    leaf.fill = '';
+                    leaf.__render(canvas, renderOptions);
+                    leaf.fill = oldFill;
+                }
+                else {
+                    leaf.__render(canvas, renderOptions);
+                }
+                canvas.restore();
+                if (sliceLeaf)
+                    sliceLeaf.__updateWorldOpacity();
+                if (trim) {
+                    trimBounds = getTrimBounds(canvas);
+                    const old = canvas, { width, height } = trimBounds;
+                    const config = { x: 0, y: 0, width, height, pixelRatio };
+                    canvas = draw.Creator.canvas(config);
+                    canvas.copyWorld(old, trimBounds, config);
+                }
+                if (padding) {
+                    const [top, right, bottom, left] = draw.MathHelper.fourNumber(padding);
+                    const old = canvas, { width, height } = old;
+                    canvas = draw.Creator.canvas({ width: width + left + right, height: height + top + bottom, pixelRatio });
+                    canvas.copyWorld(old, old.bounds, { x: left, y: top, width, height });
+                }
+                if (needFill)
+                    canvas.fillWorld(canvas.bounds, fill || '#FFFFFF', 'destination-over');
+                if (onCanvas)
+                    onCanvas(canvas);
+                const data = filename === 'canvas' ? canvas : canvas.export(filename, options);
+                result = { data, width: canvas.pixelWidth, height: canvas.pixelHeight, renderBounds, trimBounds };
             }
-            if (needFill)
-                canvas.fillWorld(canvas.bounds, fill || '#FFFFFF', 'destination-over');
-            if (onCanvas)
-                onCanvas(canvas);
-            const data = filename === 'canvas' ? canvas : canvas.export(filename, options);
-            result = { data, width: canvas.pixelWidth, height: canvas.pixelHeight, renderBounds, trimBounds };
         }
-        this.running = false;
+        catch (error) {
+            result = { data: '', error };
+        }
+        draw.Export.running = false;
         return result;
     },
     export(leaf, filename, options) {
-        this.running = true;
+        draw.Export.running = true;
         return addTask((success) => new Promise((resolve) => {
             const getResult = () => __awaiter(this, void 0, void 0, function* () {
                 if (!draw.Resource.isComplete)
                     return draw.Platform.requestRender(getResult);
-                const result = ExportModule.syncExport(leaf, filename, options);
+                const result = draw.Export.syncExport(leaf, filename, options);
                 if (result.data instanceof Promise)
                     result.data = yield result.data;
                 success(result);