@leafer-draw/worker 1.9.4 → 1.9.6

package/dist/worker.module.js

@@ -136,6 +136,9 @@ class LeafData {
         const {path: path} = this;
         return path && path.length === 6 && path[0] === 1;
     }
+    get __usePathBox() {
+        return this.__pathInputed;
+    }
     get __blendMode() {
         if (this.eraser && this.eraser !== "path") return "destination-out";
         const {blendMode: blendMode} = this;
@@ -369,7 +372,7 @@ function getMatrixData() {
 
 const {sin: sin$5, cos: cos$5, acos: acos, sqrt: sqrt$3} = Math;
 
-const {float: float$1} = MathHelper;
+const {float: float$2} = MathHelper;
 
 const tempPoint$3 = {};
 
@@ -611,12 +614,12 @@ const MatrixHelper = {
                 const cosR = c / scaleY;
                 rotation = PI_2 - (d > 0 ? acos(-cosR) : -acos(cosR));
             }
-            const cosR = float$1(cos$5(rotation));
+            const cosR = float$2(cos$5(rotation));
             const sinR = sin$5(rotation);
-            scaleX = float$1(scaleX), scaleY = float$1(scaleY);
-            skewX = cosR ? float$1((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
-            skewY = cosR ? float$1((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
-            rotation = float$1(rotation / OneRadian);
+            scaleX = float$2(scaleX), scaleY = float$2(scaleY);
+            skewX = cosR ? float$2((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
+            skewY = cosR ? float$2((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
+            rotation = float$2(rotation / OneRadian);
         } else {
             scaleX = a;
             scaleY = d;
@@ -1134,13 +1137,13 @@ const AlignHelper = {
     }
 };
 
-const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$2, addPoint: addPoint$2, toBounds: toBounds$3} = TwoPointBoundsHelper;
+const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$2, addPoint: addPoint$2, toBounds: toBounds$2} = TwoPointBoundsHelper;
 
 const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
 
-const {float: float, fourNumber: fourNumber} = MathHelper;
+const {float: float$1, fourNumber: fourNumber} = MathHelper;
 
-const {floor: floor$2, ceil: ceil$1} = Math;
+const {floor: floor$2, ceil: ceil$2} = Math;
 
 let right$1, bottom$1, boundsRight, boundsBottom;
 
@@ -1269,7 +1272,7 @@ const BoundsHelper = {
             point.x = t.x;
             toOuterPoint$2(matrix, point, toPoint$4);
             addPoint$2(tempPointBounds$1, toPoint$4.x, toPoint$4.y);
-            toBounds$3(tempPointBounds$1, to);
+            toBounds$2(tempPointBounds$1, to);
         }
     },
     toInnerOf(t, matrix, to) {
@@ -1307,8 +1310,8 @@ const BoundsHelper = {
         const {x: x, y: y} = t;
         t.x = floor$2(t.x);
         t.y = floor$2(t.y);
-        t.width = x > t.x ? ceil$1(t.width + x - t.x) : ceil$1(t.width);
-        t.height = y > t.y ? ceil$1(t.height + y - t.y) : ceil$1(t.height);
+        t.width = x > t.x ? ceil$2(t.width + x - t.x) : ceil$2(t.width);
+        t.height = y > t.y ? ceil$2(t.height + y - t.y) : ceil$2(t.height);
     },
     unsign(t) {
         if (t.width < 0) {
@@ -1321,10 +1324,10 @@ const BoundsHelper = {
         }
     },
     float(t, maxLength) {
-        t.x = float(t.x, maxLength);
-        t.y = float(t.y, maxLength);
-        t.width = float(t.width, maxLength);
-        t.height = float(t.height, maxLength);
+        t.x = float$1(t.x, maxLength);
+        t.y = float$1(t.y, maxLength);
+        t.width = float$1(t.width, maxLength);
+        t.height = float$1(t.height, maxLength);
     },
     add(t, bounds, isPoint) {
         right$1 = t.x + t.width;
@@ -1368,7 +1371,7 @@ const BoundsHelper = {
     },
     setPoints(t, points) {
         points.forEach((point, index) => index === 0 ? setPoint$2(tempPointBounds$1, point.x, point.y) : addPoint$2(tempPointBounds$1, point.x, point.y));
-        toBounds$3(tempPointBounds$1, t);
+        toBounds$2(tempPointBounds$1, t);
     },
     setPoint(t, point) {
         B.set(t, point.x, point.y);
@@ -2221,15 +2224,15 @@ class LeaferCanvasBase extends Canvas$1 {
         DataHelper.copyAttrs(s, size, canvasSizeAttrs);
         canvasSizeAttrs.forEach(key => s[key] || (s[key] = 1));
         this.bounds = new Bounds(0, 0, this.width, this.height);
-        if (this.context && !this.unreal) {
-            this.updateViewSize();
-            this.smooth = this.config.smooth;
-        }
+        this.updateViewSize();
         this.updateClientBounds();
-        if (this.context && !this.unreal && takeCanvas) {
-            this.clearWorld(takeCanvas.bounds);
-            this.copyWorld(takeCanvas);
-            takeCanvas.recycle();
+        if (this.context) {
+            this.smooth = this.config.smooth;
+            if (!this.unreal && takeCanvas) {
+                this.clearWorld(takeCanvas.bounds);
+                this.copyWorld(takeCanvas);
+                takeCanvas.recycle();
+            }
         }
     }
     updateViewSize() {}
@@ -2543,7 +2546,7 @@ const RectHelper = {
     }
 };
 
-const {sin: sin$3, cos: cos$3, atan2: atan2$1, ceil: ceil, abs: abs$2, PI: PI$2, sqrt: sqrt$1, pow: pow} = Math;
+const {sin: sin$3, cos: cos$3, hypot: hypot, atan2: atan2$1, ceil: ceil$1, abs: abs$2, PI: PI$2, sqrt: sqrt$1, pow: pow} = Math;
 
 const {setPoint: setPoint$1, addPoint: addPoint$1} = TwoPointBoundsHelper;
 
@@ -2614,9 +2617,11 @@ const BezierHelper = {
         const CBy = toY - y1;
         let startRadian = atan2$1(BAy, BAx);
         let endRadian = atan2$1(CBy, CBx);
+        const lenBA = hypot(BAx, BAy);
+        const lenCB = hypot(CBx, CBy);
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
-        if (totalRadian === PI$2 || abs$2(BAx + BAy) < 1e-12 || abs$2(CBx + CBy) < 1e-12) {
+        if (lenBA < 1e-12 || lenCB < 1e-12 || totalRadian < 1e-12 || abs$2(totalRadian - PI$2) < 1e-12) {
             if (data) data.push(L$6, x1, y1);
             if (setPointBounds) {
                 setPoint$1(setPointBounds, fromX, fromY);
@@ -2649,7 +2654,7 @@ const BezierHelper = {
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2; else if (totalRadian > PI2) totalRadian -= PI2;
         if (anticlockwise) totalRadian -= PI2;
-        const parts = ceil(abs$2(totalRadian / PI_2));
+        const parts = ceil$1(abs$2(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$3(partRadian / 4);
         const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin$3(partRadian / 2);
@@ -3208,11 +3213,7 @@ class PathCreator {
         this.set(path);
     }
     set(path) {
-        if (path) {
-            this.__path = isString(path) ? PathHelper.parse(path) : path;
-        } else {
-            this.__path = [];
-        }
+        this.__path = path ? isString(path) ? PathHelper.parse(path) : path : [];
         return this;
     }
     beginPath() {
@@ -3380,7 +3381,7 @@ const {M: M$1, L: L$2, C: C, Q: Q, Z: Z$1, N: N, D: D$1, X: X, G: G, F: F$1, O:
 
 const {toTwoPointBounds: toTwoPointBounds, toTwoPointBoundsByQuadraticCurve: toTwoPointBoundsByQuadraticCurve, arcTo: arcTo$1, arc: arc, ellipse: ellipse$1} = BezierHelper;
 
-const {addPointBounds: addPointBounds, copy: copy$6, addPoint: addPoint, setPoint: setPoint, addBounds: addBounds, toBounds: toBounds$2} = TwoPointBoundsHelper;
+const {addPointBounds: addPointBounds, copy: copy$6, addPoint: addPoint, setPoint: setPoint, addBounds: addBounds, toBounds: toBounds$1} = TwoPointBoundsHelper;
 
 const debug$9 = Debug.get("PathBounds");
 
@@ -3395,7 +3396,7 @@ const setEndPoint = {};
 const PathBounds = {
     toBounds(data, setBounds) {
         PathBounds.toTwoPointBounds(data, setPointBounds);
-        toBounds$2(setPointBounds, setBounds);
+        toBounds$1(setPointBounds, setBounds);
     },
     toTwoPointBounds(data, setPointBounds) {
         if (!data || !data.length) return setPoint(setPointBounds, 0, 0);
@@ -3582,14 +3583,18 @@ const PathCorner = {
     }
 };
 
-PathHelper.creator = new PathCreator;
+function path(path) {
+    return new PathCreator(path);
+}
+
+const pen = path();
+
+PathHelper.creator = path();
 
 PathHelper.parse = PathConvert.parse;
 
 PathHelper.convertToCanvasData = PathConvert.toCanvasData;
 
-const pen = new PathCreator;
-
 const {drawRoundRect: drawRoundRect} = RectHelper;
 
 function roundRect(drawer) {
@@ -3954,7 +3959,7 @@ const ImageManager = {
         return FileHelper.alphaPixelTypes.some(item => I.isFormat(item, config));
     },
     isFormat(format, config) {
-        if (config.format === format) return true;
+        if (config.format) return config.format === format;
         const {url: url} = config;
         if (url.startsWith("data:")) {
             if (url.startsWith("data:" + FileHelper.mineType(format))) return true;
@@ -4048,7 +4053,7 @@ class LeaferImage {
     getFull(_filters) {
         return this.view;
     }
-    getCanvas(width, height, opacity, _filters, xGap, yGap) {
+    getCanvas(width, height, opacity, _filters, xGap, yGap, smooth) {
         width || (width = this.width);
         height || (height = this.height);
         if (this.cache) {
@@ -4064,6 +4069,7 @@ class LeaferImage {
         const canvas = Platform.origin.createCanvas(max$1(floor$1(width + (xGap || 0)), 1), max$1(floor$1(height + (yGap || 0)), 1));
         const ctx = canvas.getContext("2d");
         if (opacity) ctx.globalAlpha = opacity;
+        ctx.imageSmoothingEnabled = smooth === false ? false : true;
         ctx.drawImage(this.view, 0, 0, width, height);
         this.cache = this.use > 1 ? {
             data: canvas,
@@ -4715,8 +4721,9 @@ const L = LeafHelper;
 
 const {updateAllMatrix: updateAllMatrix$3, updateMatrix: updateMatrix$2, updateAllWorldOpacity: updateAllWorldOpacity, updateAllChange: updateAllChange$1, updateChange: updateChange$1} = L;
 
-function getTempLocal(t, world) {
-    return t.parent ? PointHelper.tempToInnerOf(world, t.parent.scrollWorldTransform) : world;
+function getTempLocal(t, worldPoint) {
+    t.updateLayout();
+    return t.parent ? PointHelper.tempToInnerOf(worldPoint, t.parent.scrollWorldTransform) : worldPoint;
 }
 
 const LeafBoundsHelper = {
@@ -5456,6 +5463,8 @@ LeaferEvent.RESTART = "leafer.restart";
 
 LeaferEvent.END = "leafer.end";
 
+LeaferEvent.UPDATE_MODE = "leafer.update_mode";
+
 LeaferEvent.TRANSFORM = "leafer.transform";
 
 LeaferEvent.MOVE = "leafer.move";
@@ -5734,7 +5743,7 @@ const {updateBounds: updateBounds$1} = BranchHelper;
 
 const {toOuterOf: toOuterOf$1, copyAndSpread: copyAndSpread$1, copy: copy$3} = BoundsHelper;
 
-const {toBounds: toBounds$1} = PathBounds;
+const {toBounds: toBounds} = PathBounds;
 
 const LeafBounds = {
     __updateWorldBounds() {
@@ -5806,8 +5815,8 @@ const LeafBounds = {
     __updateBoxBounds(_secondLayout, _bounds) {
         const b = this.__layout.boxBounds;
         const data = this.__;
-        if (data.__pathInputed) {
-            toBounds$1(data.path, b);
+        if (data.__usePathBox) {
+            toBounds(data.path, b);
         } else {
             b.x = 0;
             b.y = 0;
@@ -6742,7 +6751,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.4";
+const version = "1.9.6";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7165,7 +7174,7 @@ class Renderer {
         this.times = 0;
         this.config = {
             usePartRender: true,
-            maxFPS: 60
+            maxFPS: 120
         };
         this.target = target;
         this.canvas = canvas;
@@ -7320,11 +7329,15 @@ class Renderer {
         if (this.requestTime || !target) return;
         if (target.parentApp) return target.parentApp.requestRender(false);
         const requestTime = this.requestTime = Date.now();
-        Platform.requestRender(() => {
-            this.FPS = Math.min(60, Math.ceil(1e3 / (Date.now() - requestTime)));
+        const render = () => {
+            const nowFPS = 1e3 / (Date.now() - requestTime);
+            const {maxFPS: maxFPS} = this.config;
+            if (maxFPS && nowFPS > maxFPS - .5) return Platform.requestRender(render);
+            this.FPS = Math.min(120, Math.ceil(nowFPS));
             this.requestTime = 0;
             this.checkRender();
-        });
+        };
+        Platform.requestRender(render);
     }
     __onResize(e) {
         if (this.canvas.unreal) return;
@@ -7367,7 +7380,8 @@ class Renderer {
         if (this.target) {
             this.stop();
             this.__removeListenEvents();
-            this.target = this.canvas = this.config = null;
+            this.config = {};
+            this.target = this.canvas = null;
         }
     }
 }
@@ -7675,7 +7689,11 @@ class LeaferData extends GroupData {
 
 class FrameData extends BoxData {}
 
-class LineData extends UIData {}
+class LineData extends UIData {
+    get __usePathBox() {
+        return this.points || this.__pathInputed;
+    }
+}
 
 class RectData extends UIData {
     get __boxStroke() {
@@ -7689,7 +7707,7 @@ class EllipseData extends UIData {
     }
 }
 
-class PolygonData extends UIData {}
+class PolygonData extends LineData {}
 
 class StarData extends UIData {}
 
@@ -7733,8 +7751,6 @@ class TextData extends UIData {
             if (!boxStyle) box.parent = t, box.__world = t.__world, boxLayout.boxBounds = layout.boxBounds;
             box.set(value);
             if (boxLayout.strokeChanged) layout.strokeChange();
-            if (boxLayout.renderChanged) layout.renderChange();
-            box.__updateChange();
         } else if (box) {
             t.__box = box.parent = null;
             box.destroy();
@@ -7804,7 +7820,7 @@ const UIBounds = {
     __updateRenderSpread() {
         let width = 0;
         const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = this.__;
-        if (shadow) shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
+        if (shadow) width = Effect.getShadowSpread(this, shadow);
         if (blur) width = Math.max(width, blur);
         if (filter) width += Filter.getSpread(filter);
         if (renderSpread) width += renderSpread;
@@ -7817,36 +7833,69 @@ const UIBounds = {
     }
 };
 
+const {float: float} = MathHelper;
+
+const tempContent = new Bounds, tempMerge = new Bounds, tempIntersect = new Bounds;
+
 const DragBoundsHelper = {
+    limitMove(leaf, move) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D.getValidMove(leaf.__localBoxBounds, D.getDragBounds(leaf), dragBoundsType, move, true);
+        D.axisMove(leaf, move);
+    },
+    limitScaleOf(leaf, origin, scale) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D.getValidScaleOf(leaf.__localBoxBounds, D.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, true);
+    },
+    axisMove(leaf, move) {
+        const {draggable: draggable} = leaf;
+        if (draggable === "x") move.y = 0;
+        if (draggable === "y") move.x = 0;
+    },
+    getDragBounds(leaf) {
+        const {dragBounds: dragBounds} = leaf;
+        return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
+    },
+    isInnerMode(content, dragBounds, dragBoundsType, sideType) {
+        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > dragBounds[sideType];
+    },
     getValidMove(content, dragBounds, dragBoundsType, move, change) {
         const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height;
         const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
         if (!change) move = Object.assign({}, move);
-        const isBiggerWidth = content.width > dragBounds.width;
-        const isBiggerHeight = content.height > dragBounds.height;
-        if (isBiggerWidth && dragBoundsType !== "outer") {
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
             if (x > dragBounds.x) move.x += dragBounds.x - x; else if (right < boundsRight) move.x += boundsRight - right;
         } else {
             if (x < dragBounds.x) move.x += dragBounds.x - x; else if (right > boundsRight) move.x += boundsRight - right;
         }
-        if (isBiggerHeight && dragBoundsType !== "outer") {
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
             if (y > dragBounds.y) move.y += dragBounds.y - y; else if (bottom < boundsBottom) move.y += boundsBottom - bottom;
         } else {
             if (y < dragBounds.y) move.y += dragBounds.y - y; else if (bottom > boundsBottom) move.y += boundsBottom - bottom;
         }
-        move.x = MathHelper.float(move.x);
-        move.y = MathHelper.float(move.y);
+        move.x = float(move.x);
+        move.y = float(move.y);
         return move;
     },
-    axisMove(leaf, move) {
-        const {draggable: draggable} = leaf;
-        if (draggable === "x") move.y = 0;
-        if (draggable === "y") move.x = 0;
-    },
-    limitMove(leaf, move) {
-        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
-        if (dragBounds) D.getValidMove(leaf.__localBoxBounds, dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds, dragBoundsType, move, true);
-        D.axisMove(leaf, move);
+    getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, change) {
+        if (!change) scale = Object.assign({}, scale);
+        let fitScaleX, fitScaleY;
+        tempContent.set(content).scaleOf(origin, scale.x, scale.y).unsign();
+        tempMerge.set(tempContent).add(dragBounds);
+        tempIntersect.set(tempContent).intersect(dragBounds);
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+            fitScaleX = tempMerge.width / tempContent.width;
+        } else {
+            fitScaleX = tempIntersect.width / tempContent.width;
+        }
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
+            fitScaleY = tempMerge.height / tempContent.height;
+        } else {
+            fitScaleY = tempIntersect.height / tempContent.height;
+        }
+        scale.x = float(tempIntersect.width) ? scale.x * fitScaleX : 1;
+        scale.y = float(tempIntersect.height) ? scale.y * fitScaleY : 1;
+        return scale;
     }
 };
 
@@ -7864,7 +7913,7 @@ const UIRender = {
         }
         if (data.__useEffect) {
             const {shadow: shadow, fill: fill, stroke: stroke} = data, otherEffect = data.innerShadow || data.blur || data.backgroundBlur || data.filter;
-            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
+            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !Effect.isTransformShadow(shadow[0]) && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
             data.__useEffect = !!(shadow || otherEffect);
         }
         data.__checkSingle();
@@ -7999,20 +8048,9 @@ let UI = UI_1 = class UI extends Leaf {
         if (!path) this.__drawPathByBox(pen);
         return pen;
     }
-    constructor(data) {
-        super(data);
-    }
     reset(_data) {}
-    set(data, transition) {
-        if (data) {
-            if (transition) {
-                if (transition === "temp") {
-                    this.lockNormalStyle = true;
-                    Object.assign(this, data);
-                    this.lockNormalStyle = false;
-                } else this.animate(data, transition);
-            } else Object.assign(this, data);
-        }
+    set(data, _transition) {
+        if (data) Object.assign(this, data);
     }
     get(name) {
         return isString(name) ? this.__.__getInput(name) : this.__.__getInputData(name);
@@ -8058,7 +8096,7 @@ let UI = UI_1 = class UI extends Leaf {
         const data = this.__;
         if (data.path) {
             data.__pathForRender = data.cornerRadius ? PathCorner.smooth(data.path, data.cornerRadius, data.cornerSmoothing) : data.path;
-            if (data.__useArrow) PathArrow.addArrows(this, !data.cornerRadius);
+            if (data.__useArrow) PathArrow.addArrows(this);
         } else data.__pathForRender && (data.__pathForRender = undefined);
     }
     __drawRenderPath(canvas) {
@@ -8082,7 +8120,8 @@ let UI = UI_1 = class UI extends Leaf {
     drawImagePlaceholder(canvas, _image) {
         Paint.fill(this.__.placeholderColor, this, canvas);
     }
-    animate(_keyframe, _options, _type, _isTemp) {
+    animate(keyframe, _options, _type, _isTemp) {
+        this.set(keyframe);
         return Plugin.need("animate");
     }
     killAnimate(_type, _nextStyle) {}
@@ -8271,9 +8310,6 @@ let Group = class Group extends UI {
     get isBranch() {
         return true;
     }
-    constructor(data) {
-        super(data);
-    }
     reset(data) {
         this.__setBranch();
         super.reset(data);
@@ -8398,7 +8434,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
         const canvas = this.canvas = Creator.canvas(config);
         this.__controllers.push(this.renderer = Creator.renderer(this, canvas, config), this.watcher = Creator.watcher(this, config), this.layouter = Creator.layouter(this, config));
         if (this.isApp) this.__setApp();
-        this.__checkAutoLayout(config, parentApp);
+        this.__checkAutoLayout();
         this.view = canvas.view;
         if (!parentApp) {
             this.selector = Creator.selector(this);
@@ -8497,7 +8533,8 @@ let Leafer = Leafer_1 = class Leafer extends Group {
         this.leafer = leafer;
         this.__level = 1;
     }
-    __checkAutoLayout(config, parentApp) {
+    __checkAutoLayout() {
+        const {config: config, parentApp: parentApp} = this;
         if (!parentApp) {
             if (!config.width || !config.height) this.autoLayout = new AutoBounds(config);
             this.canvas.startAutoLayout(this.autoLayout, this.__onResize.bind(this));
@@ -8514,7 +8551,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
             } else if (attrName === "zIndex") {
                 this.canvas.zIndex = newValue;
                 setTimeout(() => this.parent && this.parent.__updateSortChildren());
-            }
+            } else if (attrName === "mode") this.emit(LeaferEvent.UPDATE_MODE, {
+                mode: newValue
+            });
         }
         return super.__setAttr(attrName, newValue);
     }
@@ -8523,9 +8562,10 @@ let Leafer = Leafer_1 = class Leafer extends Group {
         return super.__getAttr(attrName);
     }
     __changeCanvasSize(attrName, newValue) {
-        const data = DataHelper.copyAttrs({}, this.canvas, canvasSizeAttrs);
-        data[attrName] = this.config[attrName] = newValue;
-        if (newValue) this.canvas.stopAutoLayout();
+        const {config: config, canvas: canvas} = this;
+        const data = DataHelper.copyAttrs({}, canvas, canvasSizeAttrs);
+        data[attrName] = config[attrName] = newValue;
+        config.width && config.height ? canvas.stopAutoLayout() : this.__checkAutoLayout();
         this.__doResize(data);
     }
     __changeFill(newValue) {
@@ -8672,9 +8712,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
                     if (!this.parent) {
                         if (this.selector) this.selector.destroy();
                         if (this.hitCanvasManager) this.hitCanvasManager.destroy();
-                        this.canvasManager.destroy();
+                        if (this.canvasManager) this.canvasManager.destroy();
                     }
-                    this.canvas.destroy();
+                    if (this.canvas) this.canvas.destroy();
                     this.config.view = this.view = this.parentApp = null;
                     if (this.userConfig) this.userConfig.view = null;
                     super.destroy();
@@ -8696,15 +8736,14 @@ __decorate([ dataProcessor(LeaferData) ], Leafer.prototype, "__", void 0);
 
 __decorate([ boundsType() ], Leafer.prototype, "pixelRatio", void 0);
 
+__decorate([ dataType("normal") ], Leafer.prototype, "mode", void 0);
+
 Leafer = Leafer_1 = __decorate([ registerUI() ], Leafer);
 
 let Rect = class Rect extends UI {
     get __tag() {
         return "Rect";
     }
-    constructor(data) {
-        super(data);
-    }
 };
 
 __decorate([ dataProcessor(RectData) ], Rect.prototype, "__", void 0);
@@ -8836,9 +8875,6 @@ let Frame = class Frame extends Box {
     get isFrame() {
         return true;
     }
-    constructor(data) {
-        super(data);
-    }
 };
 
 __decorate([ dataProcessor(FrameData) ], Frame.prototype, "__", void 0);
@@ -8855,9 +8891,6 @@ let Ellipse = class Ellipse extends UI {
     get __tag() {
         return "Ellipse";
     }
-    constructor(data) {
-        super(data);
-    }
     __updatePath() {
         const {width: width, height: height, innerRadius: innerRadius, startAngle: startAngle, endAngle: endAngle} = this.__;
         const rx = width / 2, ry = height / 2;
@@ -8897,98 +8930,29 @@ __decorate([ pathType(0) ], Ellipse.prototype, "endAngle", void 0);
 
 Ellipse = __decorate([ registerUI() ], Ellipse);
 
-const {moveTo: moveTo$2, lineTo: lineTo$2, drawPoints: drawPoints$1} = PathCommandDataHelper;
-
-const {rotate: rotate$1, getAngle: getAngle$1, getDistance: getDistance$2, defaultPoint: defaultPoint} = PointHelper;
-
-const {toBounds: toBounds} = PathBounds;
-
-let Line = class Line extends UI {
-    get __tag() {
-        return "Line";
-    }
-    get toPoint() {
-        const {width: width, rotation: rotation} = this.__;
-        const to = getPointData();
-        if (width) to.x = width;
-        if (rotation) rotate$1(to, rotation);
-        return to;
-    }
-    set toPoint(value) {
-        this.width = getDistance$2(defaultPoint, value);
-        this.rotation = getAngle$1(defaultPoint, value);
-        if (this.height) this.height = 0;
-    }
-    constructor(data) {
-        super(data);
-    }
-    __updatePath() {
-        const data = this.__;
-        const path = data.path = [];
-        if (data.points) {
-            drawPoints$1(path, data.points, false, data.closed);
-        } else {
-            moveTo$2(path, 0, 0);
-            lineTo$2(path, this.width, 0);
-        }
-    }
-    __updateRenderPath() {
-        const data = this.__;
-        if (!this.pathInputed && data.points && data.curve) {
-            drawPoints$1(data.__pathForRender = [], data.points, data.curve, data.closed);
-            if (data.__useArrow) PathArrow.addArrows(this, false);
-        } else super.__updateRenderPath();
-    }
-    __updateBoxBounds() {
-        if (this.points) {
-            toBounds(this.__.__pathForRender, this.__layout.boxBounds);
-        } else super.__updateBoxBounds();
-    }
-};
-
-__decorate([ dataProcessor(LineData) ], Line.prototype, "__", void 0);
-
-__decorate([ affectStrokeBoundsType("center") ], Line.prototype, "strokeAlign", void 0);
-
-__decorate([ boundsType(0) ], Line.prototype, "height", void 0);
-
-__decorate([ pathType() ], Line.prototype, "points", void 0);
-
-__decorate([ pathType(0) ], Line.prototype, "curve", void 0);
-
-__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
-
-Line = __decorate([ registerUI() ], Line);
-
 const {sin: sin$1, cos: cos$1, PI: PI$1} = Math;
 
-const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath$1, drawPoints: drawPoints} = PathCommandDataHelper;
-
-const line = Line.prototype;
+const {moveTo: moveTo$2, lineTo: lineTo$2, closePath: closePath$1, drawPoints: drawPoints$1} = PathCommandDataHelper;
 
 let Polygon = class Polygon extends UI {
     get __tag() {
         return "Polygon";
     }
-    constructor(data) {
-        super(data);
-    }
     __updatePath() {
-        const path = this.__.path = [];
-        if (this.__.points) {
-            drawPoints(path, this.__.points, false, true);
+        const data = this.__;
+        const path = data.path = [];
+        if (data.points) {
+            drawPoints$1(path, data.points, data.curve, true);
         } else {
-            const {width: width, height: height, sides: sides} = this.__;
+            const {width: width, height: height, sides: sides} = data;
             const rx = width / 2, ry = height / 2;
-            moveTo$1(path, rx, 0);
+            moveTo$2(path, rx, 0);
             for (let i = 1; i < sides; i++) {
-                lineTo$1(path, rx + rx * sin$1(i * 2 * PI$1 / sides), ry - ry * cos$1(i * 2 * PI$1 / sides));
+                lineTo$2(path, rx + rx * sin$1(i * 2 * PI$1 / sides), ry - ry * cos$1(i * 2 * PI$1 / sides));
             }
             closePath$1(path);
         }
     }
-    __updateRenderPath() {}
-    __updateBoxBounds() {}
 };
 
 __decorate([ dataProcessor(PolygonData) ], Polygon.prototype, "__", void 0);
@@ -8999,30 +8963,23 @@ __decorate([ pathType() ], Polygon.prototype, "points", void 0);
 
 __decorate([ pathType(0) ], Polygon.prototype, "curve", void 0);
 
-__decorate([ rewrite(line.__updateRenderPath) ], Polygon.prototype, "__updateRenderPath", null);
-
-__decorate([ rewrite(line.__updateBoxBounds) ], Polygon.prototype, "__updateBoxBounds", null);
-
 Polygon = __decorate([ rewriteAble(), registerUI() ], Polygon);
 
 const {sin: sin, cos: cos, PI: PI} = Math;
 
-const {moveTo: moveTo, lineTo: lineTo, closePath: closePath} = PathCommandDataHelper;
+const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath} = PathCommandDataHelper;
 
 let Star = class Star extends UI {
     get __tag() {
         return "Star";
     }
-    constructor(data) {
-        super(data);
-    }
     __updatePath() {
         const {width: width, height: height, corners: corners, innerRadius: innerRadius} = this.__;
         const rx = width / 2, ry = height / 2;
         const path = this.__.path = [];
-        moveTo(path, rx, 0);
+        moveTo$1(path, rx, 0);
         for (let i = 1; i < corners * 2; i++) {
-            lineTo(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin(i * PI / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos(i * PI / corners));
+            lineTo$1(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin(i * PI / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos(i * PI / corners));
         }
         closePath(path);
     }
@@ -9036,6 +8993,52 @@ __decorate([ pathType(.382) ], Star.prototype, "innerRadius", void 0);
 
 Star = __decorate([ registerUI() ], Star);
 
+const {moveTo: moveTo, lineTo: lineTo, drawPoints: drawPoints} = PathCommandDataHelper;
+
+const {rotate: rotate$1, getAngle: getAngle$1, getDistance: getDistance$2, defaultPoint: defaultPoint} = PointHelper;
+
+let Line = class Line extends UI {
+    get __tag() {
+        return "Line";
+    }
+    get toPoint() {
+        const {width: width, rotation: rotation} = this.__;
+        const to = getPointData();
+        if (width) to.x = width;
+        if (rotation) rotate$1(to, rotation);
+        return to;
+    }
+    set toPoint(value) {
+        this.width = getDistance$2(defaultPoint, value);
+        this.rotation = getAngle$1(defaultPoint, value);
+        if (this.height) this.height = 0;
+    }
+    __updatePath() {
+        const data = this.__;
+        const path = data.path = [];
+        if (data.points) {
+            drawPoints(path, data.points, data.curve, data.closed);
+        } else {
+            moveTo(path, 0, 0);
+            lineTo(path, this.width, 0);
+        }
+    }
+};
+
+__decorate([ dataProcessor(LineData) ], Line.prototype, "__", void 0);
+
+__decorate([ affectStrokeBoundsType("center") ], Line.prototype, "strokeAlign", void 0);
+
+__decorate([ boundsType(0) ], Line.prototype, "height", void 0);
+
+__decorate([ pathType() ], Line.prototype, "points", void 0);
+
+__decorate([ pathType(0) ], Line.prototype, "curve", void 0);
+
+__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
+
+Line = __decorate([ registerUI() ], Line);
+
 let Image = class Image extends Rect {
     get __tag() {
         return "Image";
@@ -9048,9 +9051,6 @@ let Image = class Image extends Rect {
         const {fill: fill} = this.__;
         return isArray(fill) && fill[0].image;
     }
-    constructor(data) {
-        super(data);
-    }
 };
 
 __decorate([ dataProcessor(ImageData) ], Image.prototype, "__", void 0);
@@ -9150,9 +9150,6 @@ let Text = class Text extends UI {
         this.updateLayout();
         return this.__.__textDrawData;
     }
-    constructor(data) {
-        super(data);
-    }
     __updateTextDrawData() {
         const data = this.__;
         const {lineHeight: lineHeight, letterSpacing: letterSpacing, fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight, italic: italic, textCase: textCase, textOverflow: textOverflow, padding: padding} = data;
@@ -9189,10 +9186,6 @@ let Text = class Text extends UI {
         DataHelper.stintSet(this, "isOverflow", !includes(b, contentBounds));
         if (this.isOverflow) setList(data.__textBoxBounds = {}, [ b, contentBounds ]), layout.renderChanged = true; else data.__textBoxBounds = b;
     }
-    __onUpdateSize() {
-        if (this.__box) this.__box.__onUpdateSize();
-        super.__onUpdateSize();
-    }
     __updateRenderSpread() {
         let width = super.__updateRenderSpread();
         if (!width) width = this.isOverflow ? 1 : 0;
@@ -9203,6 +9196,11 @@ let Text = class Text extends UI {
         copyAndSpread(renderBounds, this.__.__textBoxBounds, renderSpread);
         if (this.__box) this.__box.__layout.renderBounds = renderBounds;
     }
+    __updateChange() {
+        super.__updateChange();
+        const box = this.__box;
+        if (box) box.__onUpdateSize(), box.__updateChange();
+    }
     __drawRenderPath(canvas) {
         canvas.font = this.__.__font;
     }
@@ -9285,9 +9283,6 @@ let Path = class Path extends UI {
     get __tag() {
         return "Path";
     }
-    constructor(data) {
-        super(data);
-    }
 };
 
 __decorate([ dataProcessor(PathData) ], Path.prototype, "__", void 0);
@@ -9300,9 +9295,6 @@ let Pen = class Pen extends Group {
     get __tag() {
         return "Pen";
     }
-    constructor(data) {
-        super(data);
-    }
     setStyle(data) {
         const path = this.pathElement = new Path(data);
         this.pathStyle = data;
@@ -9998,7 +9990,7 @@ function ignoreRender(ui, value) {
 
 const {get: get$1, scale: scale, copy: copy$1} = MatrixHelper;
 
-const {floor: floor, max: max, abs: abs} = Math;
+const {floor: floor, ceil: ceil, max: max, abs: abs} = Math;
 
 function createPattern(ui, paint, pixelRatio) {
     let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true, paint.scaleFixed);
@@ -10008,8 +10000,6 @@ function createPattern(ui, paint, pixelRatio) {
         let imageScale, imageMatrix, {width: width, height: height, scaleX: sx, scaleY: sy, transform: transform, repeat: repeat, gap: gap} = data;
         scaleX *= pixelRatio;
         scaleY *= pixelRatio;
-        const xGap = gap && gap.x * scaleX;
-        const yGap = gap && gap.y * scaleY;
         if (sx) {
             sx = abs(sx);
             sy = abs(sy);
@@ -10026,7 +10016,10 @@ function createPattern(ui, paint, pixelRatio) {
             if (size > Platform.image.maxCacheSize) return false;
         }
         let maxSize = Platform.image.maxPatternSize;
-        if (!image.isSVG) {
+        if (image.isSVG) {
+            const ws = width / image.width;
+            if (ws > 1) imageScale = ws / ceil(ws);
+        } else {
             const imageSize = image.width * image.height;
             if (maxSize > imageSize) maxSize = imageSize;
         }
@@ -10041,18 +10034,20 @@ function createPattern(ui, paint, pixelRatio) {
             scaleX /= sx;
             scaleY /= sy;
         }
+        const xGap = gap && gap.x * scaleX;
+        const yGap = gap && gap.y * scaleY;
         if (transform || scaleX !== 1 || scaleY !== 1) {
+            const canvasWidth = width + (xGap || 0);
+            const canvasHeight = height + (yGap || 0);
+            scaleX /= canvasWidth / max(floor(canvasWidth), 1);
+            scaleY /= canvasHeight / max(floor(canvasHeight), 1);
             if (!imageMatrix) {
                 imageMatrix = get$1();
                 if (transform) copy$1(imageMatrix, transform);
             }
             scale(imageMatrix, 1 / scaleX, 1 / scaleY);
         }
-        if (imageMatrix) {
-            const canvasWidth = width + (xGap || 0), canvasHeight = height + (yGap || 0);
-            scale(imageMatrix, canvasWidth / max(floor(canvasWidth), 1), canvasHeight / max(floor(canvasHeight), 1));
-        }
-        const canvas = image.getCanvas(width, height, data.opacity, data.filters, xGap, yGap);
+        const canvas = image.getCanvas(width, height, data.opacity, data.filters, xGap, yGap, ui.leafer && ui.leafer.config.smooth);
         const pattern = image.getPattern(canvas, repeat || (Platform.origin.noRepeat || "no-repeat"), imageMatrix, paint);
         paint.style = pattern;
         paint.patternId = id;
@@ -10294,12 +10289,18 @@ function shadow(ui, current, shape) {
             }
             worldCanvas ? other.copyWorld(worldCanvas, nowWorld, nowWorld, "destination-out") : other.copyWorld(shape.canvas, shapeBounds, bounds, "destination-out");
         }
-        LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
+        if (Effect.isTransformShadow(item)) Effect.renderTransformShadow(ui, current, other, copyBounds, item); else LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end) other.clearWorld(copyBounds);
     });
     other.recycle(copyBounds);
 }
 
+function getShadowSpread(_ui, shadow) {
+    let width = 0;
+    shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
+    return width;
+}
+
 function drawWorldShadow(canvas, outBounds, spreadScale, shape) {
     const {bounds: bounds, shapeBounds: shapeBounds} = shape;
     if (Platform.fullImageShadow) {
@@ -10377,7 +10378,11 @@ const EffectModule = {
     shadow: shadow,
     innerShadow: innerShadow,
     blur: blur,
-    backgroundBlur: backgroundBlur
+    backgroundBlur: backgroundBlur,
+    getShadowSpread: getShadowSpread,
+    isTransformShadow(_shadow) {
+        return undefined;
+    }
 };
 
 const {excludeRenderBounds: excludeRenderBounds} = LeafBoundsHelper;
@@ -10885,16 +10890,17 @@ function toTextChar(row) {
 }
 
 function decorationText(drawData, style) {
-    let type;
+    let type, offset = 0;
     const {fontSize: fontSize, textDecoration: textDecoration} = style;
     drawData.decorationHeight = fontSize / 11;
     if (isObject(textDecoration)) {
         type = textDecoration.type;
         if (textDecoration.color) drawData.decorationColor = ColorConvert.string(textDecoration.color);
+        if (textDecoration.offset) offset = Math.min(fontSize * .3, Math.max(textDecoration.offset, -fontSize * .15));
     } else type = textDecoration;
     switch (type) {
       case "under":
-        drawData.decorationY = [ fontSize * .15 ];
+        drawData.decorationY = [ fontSize * .15 + offset ];
         break;
 
       case "delete":
@@ -10902,7 +10908,7 @@ function decorationText(drawData, style) {
         break;
 
       case "under-delete":
-        drawData.decorationY = [ fontSize * .15, -fontSize * .35 ];
+        drawData.decorationY = [ fontSize * .15 + offset, -fontSize * .35 ];
     }
 }
 
@@ -11000,4 +11006,4 @@ Object.assign(Effect, EffectModule);
 
 useCanvas();
 
-export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Frame, FrameData, Group, GroupData, Image, ImageData, ImageEvent, ImageManager, IncrementId, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, Line, LineData, MathHelper, Matrix, MatrixHelper, MyImage, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Plugin, Point, PointHelper, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Run, Star, StarData, State, StringNumberMap, TaskItem, TaskProcessor, Text, TextConvert, TextData, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, affectRenderBoundsType, affectStrokeBoundsType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, scrollType, sortType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix$1 as tempMatrix, tempPoint$2 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };
+export { AlignHelper, Answer, AroundHelper, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, DataHelper, Debug, Direction4, Direction9, DragBoundsHelper, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Frame, FrameData, Group, GroupData, Image, ImageData, ImageEvent, ImageManager, IncrementId, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, Line, LineData, MathHelper, Matrix, MatrixHelper, MyImage, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathNumberCommandLengthMap, PathNumberCommandMap, Pen, PenData, Platform, Plugin, Point, PointHelper, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Run, Star, StarData, State, StringNumberMap, TaskItem, TaskProcessor, Text, TextConvert, TextData, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, affectRenderBoundsType, affectStrokeBoundsType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, createAttr, createDescriptor, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, extraPropertyEventMap, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isArray, isData, isEmptyData, isFinite, isNull, isNumber, isObject, isString, isUndefined, layoutProcessor, leaferTransformAttrMap, maskType, naturalBoundsType, opacityType, path, pathInputType, pathType, pen, positionType, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleType, scrollType, sortType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix$1 as tempMatrix, tempPoint$2 as tempPoint, tryToNumber, useCanvas, useModule, version, visibleType, zoomLayerType };