@leafer/miniapp 1.6.7 → 1.7.0

package/dist/miniapp.module.js

@@ -43,7 +43,7 @@ const IncrementId = {
 };
 const I$2 = IncrementId;
 
-const { round: round$6, pow: pow$2, PI: PI$5 } = Math;
+const { round: round$6, pow: pow$2, PI: PI$4 } = Math;
 const MathHelper = {
     within(value, min, max) {
         if (typeof min === 'object')
@@ -139,9 +139,9 @@ const MathHelper = {
 function randInt(num) {
     return Math.round(Math.random() * num);
 }
-const OneRadian = PI$5 / 180;
-const PI2 = PI$5 * 2;
-const PI_2 = PI$5 / 2;
+const OneRadian = PI$4 / 180;
+const PI2 = PI$4 * 2;
+const PI_2 = PI$4 / 2;
 function getPointData() { return { x: 0, y: 0 }; }
 function getBoundsData() { return { x: 0, y: 0, width: 0, height: 0 }; }
 function getMatrixData() { return { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }; }
@@ -436,7 +436,7 @@ const MatrixHelper = {
 const M$a = MatrixHelper;
 
 const { toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3 } = MatrixHelper;
-const { sin: sin$5, cos: cos$5, abs: abs$7, sqrt: sqrt$4, atan2: atan2$2, min: min$1, round: round$5, PI: PI$4 } = Math;
+const { sin: sin$5, cos: cos$5, abs: abs$7, sqrt: sqrt$4, atan2: atan2$2, min: min$1, round: round$5 } = Math;
 const PointHelper = {
     defaultPoint: getPointData(),
     tempPoint: {},
@@ -549,10 +549,11 @@ const PointHelper = {
     getRadianFrom(fromX, fromY, originX, originY, toX, toY, toOriginX, toOriginY) {
         if (toOriginX === undefined)
             toOriginX = originX, toOriginY = originY;
-        let fromAngle = atan2$2(fromY - originY, fromX - originX);
-        let toAngle = atan2$2(toY - toOriginY, toX - toOriginX);
-        const radian = toAngle - fromAngle;
-        return radian < -PI$4 ? radian + PI2 : radian;
+        const a = fromX - originX;
+        const b = fromY - originY;
+        const c = toX - toOriginX;
+        const d = toY - toOriginY;
+        return Math.atan2(a * d - b * c, a * c + b * d);
     },
     getAtan2(t, to) {
         return atan2$2(to.y - t.y, to.x - t.x);
@@ -3339,7 +3340,7 @@ const { getCenterX, getCenterY } = PointHelper;
 const { arcTo } = PathCommandDataHelper;
 const PathCorner = {
     smooth(data, cornerRadius, _cornerSmoothing) {
-        let command, commandLen;
+        let command, lastCommand, commandLen;
         let i = 0, x = 0, y = 0, startX = 0, startY = 0, secondX = 0, secondY = 0, lastX = 0, lastY = 0;
         const len = data.length;
         const smooth = [];
@@ -3377,8 +3378,10 @@ const PathCorner = {
                     lastY = y;
                     break;
                 case Z$3:
-                    arcTo(smooth, startX, startY, secondX, secondY, cornerRadius, lastX, lastY);
-                    smooth.push(Z$3);
+                    if (lastCommand !== Z$3) {
+                        arcTo(smooth, startX, startY, secondX, secondY, cornerRadius, lastX, lastY);
+                        smooth.push(Z$3);
+                    }
                     i += 1;
                     break;
                 default:
@@ -3387,6 +3390,7 @@ const PathCorner = {
                         smooth.push(data[i + j]);
                     i += commandLen;
             }
+            lastCommand = command;
         }
         if (command !== Z$3) {
             smooth[1] = startX;
@@ -3883,12 +3887,12 @@ class LeaferImage {
         try {
             if (transform && pattern.setTransform) {
                 pattern.setTransform(transform);
-                transform = null;
+                transform = undefined;
             }
         }
         catch (_a) { }
         if (paint)
-            paint.transform = transform;
+            DataHelper.stintSet(paint, 'transform', transform);
         return pattern;
     }
     destroy() {
@@ -3993,10 +3997,14 @@ function pathInputType(defaultValue) {
     }));
 }
 const pathType = boundsType;
-function affectStrokeBoundsType(defaultValue) {
+function affectStrokeBoundsType(defaultValue, useStroke) {
     return decorateLeafAttr(defaultValue, (key) => attr({
         set(value) {
-            this.__setAttr(key, value) && doStrokeType(this);
+            if (this.__setAttr(key, value)) {
+                doStrokeType(this);
+                if (useStroke)
+                    this.__.__useStroke = true;
+            }
         }
     }));
 }
@@ -5422,6 +5430,8 @@ const LeafBounds = {
 
 const LeafRender = {
     __render(canvas, options) {
+        if (options.shape)
+            return this.__renderShape(canvas, options);
         if (this.__worldOpacity) {
             const data = this.__;
             canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
@@ -5431,12 +5441,10 @@ const LeafRender = {
                     return this.__renderEraser(canvas, options);
                 const tempCanvas = canvas.getSameCanvas(true, true);
                 this.__draw(tempCanvas, options, canvas);
-                if (this.__worldFlipped) {
+                if (this.__worldFlipped)
                     canvas.copyWorldByReset(tempCanvas, this.__nowWorld, null, data.__blendMode, true);
-                }
-                else {
+                else
                     canvas.copyWorldToInner(tempCanvas, this.__nowWorld, this.__layout.renderBounds, data.__blendMode);
-                }
                 tempCanvas.recycle(this.__nowWorld);
             }
             else {
@@ -5446,6 +5454,12 @@ const LeafRender = {
                 Debug.drawBounds(this, canvas, options);
         }
     },
+    __renderShape(canvas, options) {
+        if (this.__worldOpacity) {
+            canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
+            this.__drawShape(canvas, options);
+        }
+    },
     __clip(canvas, options) {
         if (this.__worldOpacity) {
             canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
@@ -5865,7 +5879,8 @@ let Leaf = class Leaf {
     __drawFast(_canvas, _options) { }
     __draw(_canvas, _options, _originCanvas) { }
     __clip(_canvas, _options) { }
-    __renderShape(_canvas, _options, _ignoreFill, _ignoreStroke) { }
+    __renderShape(_canvas, _options) { }
+    __drawShape(_canvas, _options) { }
     __updateWorldOpacity() { }
     __updateChange() { }
     __drawPath(_canvas) { }
@@ -6233,7 +6248,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.6.7";
+const version = "1.7.0";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() { return false; }
@@ -7289,13 +7304,9 @@ class UIData extends LeafData {
         else
             return strokeWidth;
     }
-    get __hasStroke() { return this.stroke && this.strokeWidth; }
-    get __hasHalf() { const t = this; return (t.stroke && t.strokeAlign === 'center' && t.strokeWidth % 2) || undefined; }
     get __hasMultiPaint() {
         const t = this;
-        if ((t.__isFills && t.fill.length > 1) || (t.__isStrokes && t.stroke.length > 1) || t.__useEffect)
-            return true;
-        return t.fill && this.__hasStroke;
+        return (t.fill && this.__useStroke) || (t.__isFills && t.fill.length > 1) || (t.__isStrokes && t.stroke.length > 1) || t.__useEffect;
     }
     get __clipAfterFill() { const t = this; return (t.cornerRadius || t.innerShadow || t.__pathInputed); }
     get __hasSurface() { const t = this; return (t.fill || t.stroke); }
@@ -7586,15 +7597,18 @@ const { stintSet: stintSet$1 } = DataHelper;
 const UIRender = {
     __updateChange() {
         const data = this.__;
+        if (data.__useStroke) {
+            const useStroke = data.__useStroke = !!(data.stroke && data.strokeWidth);
+            stintSet$1(this.__world, 'half', useStroke && data.strokeAlign === 'center' && data.strokeWidth % 2);
+            stintSet$1(data, '__fillAfterStroke', useStroke && data.strokeAlign === 'outside' && data.fill && !data.__isTransparentFill);
+        }
         if (data.__useEffect) {
             const { shadow, fill, stroke } = data, otherEffect = data.innerShadow || data.blur || data.backgroundBlur || data.filter;
             stintSet$1(data, '__isFastShadow', shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !(shadow[0].box && data.__isTransparentFill) && fill && !(fill instanceof Array && fill.length > 1) && (this.useFastShadow || !stroke || (stroke && data.strokeAlign === 'inside')));
             data.__useEffect = !!(shadow || otherEffect);
         }
-        stintSet$1(this.__world, 'half', data.__hasHalf);
-        stintSet$1(data, '__fillAfterStroke', data.stroke && data.strokeAlign === 'outside' && data.fill && !data.__isTransparentFill);
         data.__checkSingle();
-        stintSet$1(data, '__complex', data.__isFills || data.__isStrokes || data.cornerRadius || data.__useEffect);
+        stintSet$1(data, '__complex', (data.__isFills || data.__isStrokes || data.cornerRadius || data.__useEffect));
     },
     __drawFast(canvas, options) {
         drawFast(this, canvas, options);
@@ -7652,18 +7666,15 @@ const UIRender = {
                 this.__drawFast(canvas, options);
         }
     },
-    __renderShape(canvas, options, ignoreFill, ignoreStroke) {
-        if (this.__worldOpacity) {
-            canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
-            const { fill, stroke } = this.__;
-            this.__drawRenderPath(canvas);
-            if (fill && !ignoreFill)
-                this.__.__isAlphaPixelFill ? Paint.fills(fill, this, canvas) : Paint.fill('#000000', this, canvas);
-            if (this.__.__isCanvas)
-                this.__drawAfterFill(canvas, options);
-            if (stroke && !ignoreStroke)
-                this.__.__isAlphaPixelStroke ? Paint.strokes(stroke, this, canvas) : Paint.stroke('#000000', this, canvas);
-        }
+    __drawShape(canvas, options) {
+        this.__drawRenderPath(canvas);
+        const data = this.__, { fill, stroke } = data;
+        if (fill && !options.ignoreFill)
+            data.__isAlphaPixelFill ? Paint.fills(fill, this, canvas) : Paint.fill('#000000', this, canvas);
+        if (data.__isCanvas)
+            this.__drawAfterFill(canvas, options);
+        if (stroke && !options.ignoreStroke)
+            data.__isAlphaPixelStroke ? Paint.strokes(stroke, this, canvas) : Paint.stroke('#000000', this, canvas);
     },
     __drawAfterFill(canvas, options) {
         if (this.__.__clipAfterFill) {
@@ -7788,12 +7799,14 @@ let UI = UI_1 = class UI extends Leaf {
         }
     }
     __updateRenderPath() {
-        if (this.__.path) {
-            const data = this.__;
+        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);
         }
+        else
+            data.__pathForRender && (data.__pathForRender = undefined);
     }
     __drawRenderPath(canvas) {
         canvas.beginPath();
@@ -8004,13 +8017,13 @@ __decorate([
     surfaceType()
 ], UI.prototype, "fill", void 0);
 __decorate([
-    strokeType()
+    strokeType(undefined, true)
 ], UI.prototype, "stroke", void 0);
 __decorate([
     strokeType('inside')
 ], UI.prototype, "strokeAlign", void 0);
 __decorate([
-    strokeType(1)
+    strokeType(1, true)
 ], UI.prototype, "strokeWidth", void 0);
 __decorate([
     strokeType(false)
@@ -8437,7 +8450,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
             list.push(item);
         this.requestRender();
     }
-    zoom(_zoomType, _padding, _fixedScale, _transition) {
+    zoom(_zoomType, _optionsOrPadding, _scroll, _transition) {
         return Plugin.need('view');
     }
     getValidMove(moveX, moveY) { return { x: moveX, y: moveY }; }
@@ -8482,7 +8495,7 @@ let Leafer = Leafer_1 = class Leafer extends Group {
                 Leafer_1.list.remove(this);
                 try {
                     this.stop();
-                    this.emitEvent(new LeaferEvent(LeaferEvent.END, this));
+                    this.emitLeafer(LeaferEvent.END);
                     this.__removeListenEvents();
                     this.__controllers.forEach(item => !(this.parent && item === this.interaction) && item.destroy());
                     this.__controllers.length = 0;
@@ -8610,7 +8623,7 @@ let Box = class Box extends Group {
     }
     __drawContent(canvas, options) {
         this.__renderGroup(canvas, options);
-        if (this.__.__hasStroke) {
+        if (this.__.__useStroke) {
             canvas.setWorld(this.__nowWorld);
             this.__drawRenderPath(canvas);
         }
@@ -8830,8 +8843,8 @@ let Polygon = class Polygon extends UI {
             for (let i = 1; i < sides; i++) {
                 lineTo$1(path, rx + rx * sin$2((i * 2 * PI$2) / sides), ry - ry * cos$2((i * 2 * PI$2) / sides));
             }
+            closePath$1(path);
         }
-        closePath$1(path);
     }
     __updateRenderPath() { }
     __updateBoxBounds() { }
@@ -9069,6 +9082,11 @@ let Text = class Text extends UI {
             return;
         super.__draw(canvas, options, originCanvas);
     }
+    __drawShape(canvas, options) {
+        if (options.shape)
+            this.__box && this.__box.__drawShape(canvas, options);
+        super.__drawShape(canvas, options);
+    }
     destroy() {
         if (this.boxStyle)
             this.boxStyle = null;
@@ -9890,6 +9908,7 @@ const config$1 = {
         delta: { x: 80 / 4, y: 8.0 },
     },
     pointer: {
+        type: 'pointer',
         snap: true,
         hitRadius: 5,
         tapTime: 120,
@@ -10433,7 +10452,7 @@ ui$5.__updateHitCanvas = function () {
         h.resize({ width, height, pixelRatio: 1 });
         h.clear();
         ImageManager.patternLocked = true;
-        this.__renderShape(h, { matrix: matrix$2.setWith(this.__world).scaleWith(1 / scale).invertWith().translate(-x, -y) }, !isHitPixelFill, !isHitPixelStroke);
+        this.__renderShape(h, { matrix: matrix$2.setWith(this.__world).scaleWith(1 / scale).invertWith().translate(-x, -y), ignoreFill: !isHitPixelFill, ignoreStroke: !isHitPixelStroke });
         ImageManager.patternLocked = false;
         h.resetTransform();
         data.__isHitPixel = true;
@@ -10942,7 +10961,7 @@ const PaintModule = {
 };
 
 let origin$1 = {};
-const { get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, scale: scaleHelper, rotate: rotate$2 } = MatrixHelper;
+const { get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, scale: scaleHelper, rotate: rotate$2, skew: skewHelper } = MatrixHelper;
 function fillOrFitMode(data, box, x, y, scaleX, scaleY, rotation) {
     const transform = get$3();
     translate$1(transform, box.x + x, box.y + y);
@@ -10951,13 +10970,15 @@ 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) {
+function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew) {
     const transform = get$3();
-    translate$1(transform, box.x + x, box.y + y);
-    if (scaleX)
-        scaleHelper(transform, scaleX, scaleY);
     if (rotation)
         rotate$2(transform, rotation);
+    if (skew)
+        skewHelper(transform, skew.x, skew.y);
+    if (scaleX)
+        scaleHelper(transform, scaleX, scaleY);
+    translate$1(transform, box.x + x, box.y + y);
     data.transform = transform;
 }
 function repeatMode(data, box, width, height, x, y, scaleX, scaleY, rotation, align) {
@@ -10994,11 +11015,13 @@ const tempBox = new Bounds();
 const tempScaleData = {};
 const tempImage = {};
 function createData(leafPaint, image, paint, box) {
-    const { changeful, sync } = paint;
+    const { changeful, sync, editing } = paint;
     if (changeful)
         leafPaint.changeful = changeful;
     if (sync)
         leafPaint.sync = sync;
+    if (editing)
+        leafPaint.editing = editing;
     leafPaint.data = getPatternData(paint, box, image);
 }
 function getPatternData(paint, box, image) {
@@ -11007,7 +11030,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, repeat, filters } = paint;
+    const { opacity, mode, align, offset, scale, size, rotation, skew, repeat, filters } = paint;
     const sameBox = box.width === width && box.height === height;
     const data = { mode };
     const swapSize = align !== 'center' && (rotation || 0) % 180 === 90;
@@ -11041,8 +11064,8 @@ function getPatternData(paint, box, image) {
             break;
         case 'normal':
         case 'clip':
-            if (tempImage.x || tempImage.y || scaleX || rotation)
-                clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation);
+            if (tempImage.x || tempImage.y || scaleX || rotation || skew)
+                clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew);
             break;
         case 'repeat':
             if (!sameBox || scaleX || rotation)
@@ -11119,11 +11142,11 @@ function image(ui, attrName, paint, boxBounds, firstUse) {
                 }
                 onLoadSuccess(ui, event);
             }
-            leafPaint.loadId = null;
+            leafPaint.loadId = undefined;
         }, (error) => {
             ignoreRender(ui, false);
             onLoadError(ui, event, error);
-            leafPaint.loadId = null;
+            leafPaint.loadId = undefined;
         });
         if (ui.placeholderColor) {
             if (!ui.placeholderDelay)
@@ -11189,6 +11212,8 @@ function createPattern(ui, paint, pixelRatio) {
         const { image, data } = paint;
         let imageScale, imageMatrix, { width, height, scaleX: sx, scaleY: sy, transform, repeat } = data;
         if (sx) {
+            sx = abs$4(sx);
+            sy = abs$4(sy);
             imageMatrix = get$1();
             copy$4(imageMatrix, transform);
             scale$2(imageMatrix, 1 / sx, 1 / sy);
@@ -12189,41 +12214,10 @@ class EditorEvent extends Event {
 }
 EditorEvent.BEFORE_SELECT = 'editor.before_select';
 EditorEvent.SELECT = 'editor.select';
+EditorEvent.AFTER_SELECT = 'editor.after_select';
 EditorEvent.BEFORE_HOVER = 'editor.before_hover';
 EditorEvent.HOVER = 'editor.hover';
 
-class EditorMoveEvent extends EditorEvent {
-    constructor(type, data) {
-        super(type, data);
-    }
-}
-EditorMoveEvent.BEFORE_MOVE = 'editor.before_move';
-EditorMoveEvent.MOVE = 'editor.move';
-
-class EditorScaleEvent extends EditorEvent {
-    constructor(type, data) {
-        super(type, data);
-    }
-}
-EditorScaleEvent.BEFORE_SCALE = 'editor.before_scale';
-EditorScaleEvent.SCALE = 'editor.scale';
-
-class EditorRotateEvent extends EditorEvent {
-    constructor(type, data) {
-        super(type, data);
-    }
-}
-EditorRotateEvent.BEFORE_ROTATE = 'editor.before_rotate';
-EditorRotateEvent.ROTATE = 'editor.rotate';
-
-class EditorSkewEvent extends EditorEvent {
-    constructor(type, data) {
-        super(type, data);
-    }
-}
-EditorSkewEvent.BEFORE_SKEW = 'editor.before_skew';
-EditorSkewEvent.SKEW = 'editor.skew';
-
 function targetAttr(fn) {
     return (target, key) => {
         const privateKey = '_' + key;
@@ -12634,16 +12628,16 @@ const { topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bo
 const { toPoint } = AroundHelper;
 const { within: within$2 } = MathHelper;
 const EditDataHelper = {
-    getScaleData(element, startBounds, direction, totalMove, lockRatio, around, flipable, scaleMode) {
+    getScaleData(target, startBounds, direction, totalMove, lockRatio, around, flipable, scaleMode) {
         let align, origin = {}, scaleX = 1, scaleY = 1;
-        const { boxBounds, widthRange, heightRange, dragBounds, worldBoxBounds } = element;
+        const { boxBounds, widthRange, heightRange, dragBounds, worldBoxBounds } = target;
         const { width, height } = startBounds;
         if (around) {
             totalMove.x *= 2;
             totalMove.y *= 2;
         }
-        const originChangedScaleX = element.scaleX / startBounds.scaleX;
-        const originChangedScaleY = element.scaleY / startBounds.scaleY;
+        const originChangedScaleX = target.scaleX / startBounds.scaleX;
+        const originChangedScaleY = target.scaleY / startBounds.scaleY;
         const signX = originChangedScaleX < 0 ? -1 : 1;
         const signY = originChangedScaleY < 0 ? -1 : 1;
         const changedScaleX = scaleMode ? originChangedScaleX : signX * boxBounds.width / width;
@@ -12719,7 +12713,7 @@ const EditDataHelper = {
         if (useScaleY)
             scaleY /= changedScaleY;
         if (!flipable) {
-            const { worldTransform } = element;
+            const { worldTransform } = target;
             if (scaleX < 0)
                 scaleX = 1 / boxBounds.width / worldTransform.scaleX;
             if (scaleY < 0)
@@ -12727,9 +12721,9 @@ const EditDataHelper = {
         }
         toPoint(around || align, boxBounds, origin, true);
         if (dragBounds) {
-            const allowBounds = dragBounds === 'parent' ? element.parent.boxBounds : dragBounds;
-            const localBounds = new Bounds(element.__localBoxBounds);
-            localBounds.scaleOf(element.getLocalPointByInner(origin), scaleX, scaleY);
+            const allowBounds = dragBounds === 'parent' ? target.parent.boxBounds : dragBounds;
+            const localBounds = new Bounds(target.__localBoxBounds);
+            localBounds.scaleOf(target.getLocalPointByInner(origin), scaleX, scaleY);
             if (!BoundsHelper.includes(allowBounds, localBounds)) {
                 const realBounds = localBounds.getIntersect(allowBounds);
                 const fitScaleX = realBounds.width / localBounds.width, fitScaleY = realBounds.height / localBounds.height;
@@ -12740,11 +12734,11 @@ const EditDataHelper = {
             }
         }
         if (useScaleX && widthRange) {
-            const nowWidth = boxBounds.width * element.scaleX;
+            const nowWidth = boxBounds.width * target.scaleX;
             scaleX = within$2(nowWidth * scaleX, widthRange) / nowWidth;
         }
         if (useScaleY && heightRange) {
-            const nowHeight = boxBounds.height * element.scaleY;
+            const nowHeight = boxBounds.height * target.scaleY;
             scaleY = within$2(nowHeight * scaleY, heightRange) / nowHeight;
         }
         if (useScaleX && Math.abs(scaleX * worldBoxBounds.width) < 1)
@@ -12755,7 +12749,7 @@ const EditDataHelper = {
             scaleY = scaleX = Math.min(scaleX, scaleY);
         return { origin, scaleX, scaleY, direction, lockRatio, around };
     },
-    getRotateData(bounds, direction, current, last, around) {
+    getRotateData(target, direction, current, last, around) {
         let align, origin = {};
         switch (direction) {
             case topLeft$1:
@@ -12773,8 +12767,8 @@ const EditDataHelper = {
             default:
                 align = 'center';
         }
-        toPoint(around || align, bounds, origin, true);
-        return { origin, rotation: PointHelper.getRotation(last, origin, current) };
+        toPoint(around || align, target.boxBounds, origin, true);
+        return { origin, rotation: PointHelper.getRotation(last, target.getWorldPointByBox(origin), current) };
     },
     getSkewData(bounds, direction, move, around) {
         let align, origin = {}, skewX = 0, skewY = 0;
@@ -12871,9 +12865,9 @@ const EditDataHelper = {
 };
 
 const cacheCursors = {};
-function updateCursor(editor, e) {
-    const { editBox } = editor, point = editBox.enterPoint;
-    if (!point || !editor.editing || !editBox.visible)
+function updateCursor(editBox, e) {
+    const { enterPoint: point } = editBox;
+    if (!point || !editBox.editor.editing || !editBox.visible)
         return;
     if (point.name === 'circle')
         return;
@@ -12882,9 +12876,8 @@ function updateCursor(editor, e) {
             point.cursor = 'pointer';
         return;
     }
-    let { rotation } = editBox;
-    const { resizeCursor, rotateCursor, skewCursor, resizeable, rotateable, skewable } = editor.mergeConfig;
-    const { pointType } = point, { flippedX, flippedY } = editBox;
+    let { rotation, flippedX, flippedY } = editBox;
+    const { pointType } = point, { resizeCursor, rotateCursor, skewCursor, resizeable, rotateable, skewable } = editBox.mergeConfig;
     let showResize = pointType.includes('resize');
     if (showResize && rotateable && (e.metaKey || e.ctrlKey || !resizeable))
         showResize = false;
@@ -12901,9 +12894,9 @@ function updateCursor(editor, e) {
         cacheCursors[key] = point.cursor = { url: toDataURL(url, rotation), x, y };
     }
 }
-function updateMoveCursor(editor) {
-    const { moveCursor, moveable } = editor.mergeConfig;
-    editor.editBox.rect.cursor = moveable ? moveCursor : undefined;
+function updateMoveCursor(editBox) {
+    const { moveCursor, moveable } = editBox.mergeConfig;
+    editBox.rect.cursor = moveable ? moveCursor : undefined;
 }
 function toDataURL(svg, rotation) {
     return '"data:image/svg+xml,' + encodeURIComponent(svg.replace('{{rotation}}', rotation.toString())) + '"';
@@ -12918,6 +12911,15 @@ class EditPoint extends Box {
 
 const fourDirection = ['top', 'right', 'bottom', 'left'], editConfig = undefined;
 class EditBox extends Group {
+    get mergeConfig() {
+        const { config } = this, { mergeConfig } = this.editor;
+        return this.mergedConfig = config ? Object.assign(Object.assign({}, mergeConfig), config) : mergeConfig;
+    }
+    get target() { return this._target || this.editor.element; }
+    set target(target) { this._target = target; }
+    get single() { return !!this._target || this.editor.single; }
+    get transformTool() { return this._transformTool || this.editor; }
+    set transformTool(tool) { this._transformTool = tool; }
     get flipped() { return this.flippedX || this.flippedY; }
     get flippedX() { return this.scaleX < 0; }
     get flippedY() { return this.scaleY < 0; }
@@ -12960,8 +12962,7 @@ class EditBox extends Group {
         this.add(view);
     }
     load() {
-        const { mergeConfig, element, single } = this.editor;
-        const { rect, circle, resizePoints } = this;
+        const { target, mergeConfig, single, rect, circle, resizePoints } = this;
         const { stroke, strokeWidth } = mergeConfig;
         const pointsStyle = this.getPointsStyle();
         const middlePointsStyle = this.getMiddlePointsStyle();
@@ -12974,18 +12975,26 @@ class EditBox extends Group {
         }
         circle.set(this.getPointStyle(mergeConfig.circle || mergeConfig.rotatePoint || pointsStyle[0]));
         rect.set(Object.assign({ stroke, strokeWidth, editConfig }, (mergeConfig.rect || {})));
-        rect.hittable = !single;
-        rect.syncEventer = single && this.editor;
-        if (single) {
-            element.syncEventer = rect;
-            this.app.interaction.bottomList = [{ target: rect, proxy: element }];
+        const syncEventer = single && this.transformTool.editTool;
+        rect.hittable = !syncEventer;
+        rect.syncEventer = syncEventer && this.editor;
+        if (syncEventer) {
+            target.syncEventer = rect;
+            this.app.interaction.bottomList = [{ target: rect, proxy: target }];
         }
+        updateMoveCursor(this);
     }
-    update(bounds) {
-        const { rect, circle, buttons, resizePoints, rotatePoints, resizeLines, editor } = this;
-        const { mergeConfig, element, multiple, editMask } = editor;
+    update() {
+        const { editor } = this;
+        const { x, y, scaleX, scaleY, rotation, skewX, skewY, width, height } = this.target.getLayoutBounds('box', editor, true);
+        this.set({ x, y, scaleX, scaleY, rotation, skewX, skewY });
+        this.updateBounds({ x: 0, y: 0, width, height });
+    }
+    updateBounds(bounds) {
+        const { editMask } = this.editor;
+        const { mergeConfig, single, rect, circle, buttons, resizePoints, rotatePoints, resizeLines } = this;
         const { middlePoint, resizeable, rotateable, hideOnSmall, editBox, mask } = mergeConfig;
-        this.visible = !element.locked;
+        this.visible = !this.target.locked;
         editMask.visible = mask ? true : 0;
         if (this.view.worldOpacity) {
             const { width, height } = bounds;
@@ -13019,25 +13028,25 @@ class EditBox extends Group {
             }
             circle.visible = showPoints && rotateable && !!(mergeConfig.circle || mergeConfig.rotatePoint);
             if (circle.visible)
-                this.layoutCircle(mergeConfig);
+                this.layoutCircle();
             if (rect.path)
                 rect.path = null;
-            rect.set(Object.assign(Object.assign({}, bounds), { visible: multiple ? true : editBox }));
+            rect.set(Object.assign(Object.assign({}, bounds), { visible: single ? editBox : true }));
             buttons.visible = showPoints && buttons.children.length > 0 || 0;
             if (buttons.visible)
-                this.layoutButtons(mergeConfig);
+                this.layoutButtons();
         }
         else
             rect.set(bounds);
     }
-    layoutCircle(config) {
-        const { circleDirection, circleMargin, buttonsMargin, buttonsDirection, middlePoint } = config;
+    layoutCircle() {
+        const { circleDirection, circleMargin, buttonsMargin, buttonsDirection, middlePoint } = this.mergedConfig;
         const direction = fourDirection.indexOf(circleDirection || ((this.buttons.children.length && buttonsDirection === 'bottom') ? 'top' : 'bottom'));
         this.setButtonPosition(this.circle, direction, circleMargin || buttonsMargin, !!middlePoint);
     }
-    layoutButtons(config) {
+    layoutButtons() {
         const { buttons } = this;
-        const { buttonsDirection, buttonsFixed, buttonsMargin, middlePoint } = config;
+        const { buttonsDirection, buttonsFixed, buttonsMargin, middlePoint } = this.mergedConfig;
         const { flippedX, flippedY } = this;
         let index = fourDirection.indexOf(buttonsDirection);
         if ((index % 2 && flippedX) || ((index + 1) % 2 && flippedY)) {
@@ -13070,16 +13079,16 @@ class EditBox extends Group {
         this.visible = false;
     }
     getPointStyle(userStyle) {
-        const { stroke, strokeWidth, pointFill, pointSize, pointRadius } = this.editor.mergeConfig;
+        const { stroke, strokeWidth, pointFill, pointSize, pointRadius } = this.mergedConfig;
         const defaultStyle = { fill: pointFill, stroke, strokeWidth, around: 'center', strokeAlign: 'center', width: pointSize, height: pointSize, cornerRadius: pointRadius, offsetX: 0, offsetY: 0, editConfig };
         return userStyle ? Object.assign(defaultStyle, userStyle) : defaultStyle;
     }
     getPointsStyle() {
-        const { point } = this.editor.mergeConfig;
+        const { point } = this.mergedConfig;
         return point instanceof Array ? point : [point];
     }
     getMiddlePointsStyle() {
-        const { middlePoint } = this.editor.mergeConfig;
+        const { middlePoint } = this.mergedConfig;
         return middlePoint instanceof Array ? middlePoint : (middlePoint ? [middlePoint] : this.getPointsStyle());
     }
     onSelect(e) {
@@ -13092,16 +13101,16 @@ class EditBox extends Group {
     onDragStart(e) {
         this.dragging = true;
         const point = this.dragPoint = e.current, { pointType } = point;
-        const { editor, dragStartData } = this, { element } = editor;
+        const { editor, dragStartData } = this, { target } = this;
         if (point.name === 'rect') {
             this.moving = true;
-            editor.opacity = editor.mergeConfig.hideOnMove ? 0 : 1;
+            editor.opacity = this.mergeConfig.hideOnMove ? 0 : 1;
         }
         dragStartData.x = e.x;
         dragStartData.y = e.y;
-        dragStartData.point = { x: element.x, y: element.y };
-        dragStartData.bounds = Object.assign({}, element.getLayoutBounds('box', 'local'));
-        dragStartData.rotation = element.rotation;
+        dragStartData.point = { x: target.x, y: target.y };
+        dragStartData.bounds = Object.assign({}, target.getLayoutBounds('box', 'local'));
+        dragStartData.rotation = target.rotation;
         if (pointType && pointType.includes('resize'))
             ResizeEvent.resizingKeys = editor.leafList.keys;
     }
@@ -13116,22 +13125,31 @@ class EditBox extends Group {
             ResizeEvent.resizingKeys = null;
     }
     onDrag(e) {
-        const { editor } = this;
-        const { pointType } = this.enterPoint = e.current;
-        if (pointType.includes('rotate') || e.metaKey || e.ctrlKey || !editor.mergeConfig.resizeable) {
-            editor.onRotate(e);
-            if (pointType === 'resize-rotate')
-                editor.onScale(e);
-        }
-        else if (pointType === 'resize')
-            editor.onScale(e);
-        if (pointType === 'skew')
-            editor.onSkew(e);
-        updateCursor(editor, e);
+        const { transformTool } = this, point = e.current;
+        if (point.name === 'rect') {
+            transformTool.onMove(e);
+            updateMoveCursor(this);
+        }
+        else {
+            const { pointType } = this.enterPoint = point;
+            if (pointType.includes('rotate') || e.metaKey || e.ctrlKey || !this.mergeConfig.resizeable) {
+                transformTool.onRotate(e);
+                if (pointType === 'resize-rotate')
+                    transformTool.onScale(e);
+            }
+            else if (pointType === 'resize')
+                transformTool.onScale(e);
+            if (pointType === 'skew')
+                transformTool.onSkew(e);
+            updateCursor(this, e);
+        }
+    }
+    onKey(e) {
+        updateCursor(this, e);
     }
     onArrow(e) {
         const { editor } = this;
-        if (editor.editing && editor.mergeConfig.keyEvent) {
+        if (editor.editing && this.mergeConfig.keyEvent) {
             let x = 0, y = 0;
             const distance = e.shiftKey ? 10 : 1;
             switch (e.code) {
@@ -13152,27 +13170,28 @@ class EditBox extends Group {
         }
     }
     onDoubleTap(e) {
-        if (this.editor.mergeConfig.openInner === 'double')
+        const { openInner, preventEditInner } = this.mergeConfig;
+        if (openInner === 'double' && !preventEditInner)
             this.openInner(e);
     }
     onLongPress(e) {
-        if (this.editor.mergeConfig.openInner === 'long')
+        const { openInner, preventEditInner } = this.mergeConfig;
+        if (openInner === 'long' && preventEditInner)
             this.openInner(e);
     }
     openInner(e) {
-        const { editor } = this;
-        if (editor.single) {
-            const { element } = editor;
-            if (element.locked)
+        const { editor, target } = this;
+        if (this.single) {
+            if (target.locked)
                 return;
-            if (element.isBranch && !element.editInner) {
-                if (element.textBox) {
-                    const { children } = element;
+            if (target.isBranch && !target.editInner) {
+                if (target.textBox) {
+                    const { children } = target;
                     const find = children.find(item => item.editable && item instanceof Text) || children.find(item => item instanceof Text);
                     if (find)
                         return editor.openInnerEditor(find);
                 }
-                editor.openGroup(element);
+                editor.openGroup(target);
                 editor.target = editor.selector.findDeepOne(e);
             }
             else {
@@ -13181,7 +13200,6 @@ class EditBox extends Group {
         }
     }
     listenPointEvents(point, type, direction) {
-        const { editor } = this;
         point.direction = direction;
         point.pointType = type;
         const events = [
@@ -13191,19 +13209,25 @@ class EditBox extends Group {
             [PointerEvent.LEAVE, () => { this.enterPoint = null; }],
         ];
         if (point.name !== 'circle')
-            events.push([PointerEvent.ENTER, (e) => { this.enterPoint = point, updateCursor(editor, e); }]);
+            events.push([PointerEvent.ENTER, (e) => { this.enterPoint = point, updateCursor(this, e); }]);
         this.__eventIds.push(point.on_(events));
     }
     __listenEvents() {
-        const { rect, editor } = this;
-        this.__eventIds.push(editor.on_(EditorEvent.SELECT, this.onSelect, this), rect.on_([
+        const { rect, editor, __eventIds: events } = this;
+        events.push(editor.on_(EditorEvent.SELECT, this.onSelect, this), rect.on_([
             [DragEvent.START, this.onDragStart, this],
-            [DragEvent.DRAG, editor.onMove, editor],
+            [DragEvent.DRAG, this.onDrag, this],
             [DragEvent.END, this.onDragEnd, this],
-            [PointerEvent.ENTER, () => updateMoveCursor(editor)],
+            [PointerEvent.ENTER, () => updateMoveCursor(this)],
             [PointerEvent.DOUBLE_TAP, this.onDoubleTap, this],
             [PointerEvent.LONG_PRESS, this.onLongPress, this]
         ]));
+        this.waitLeafer(() => {
+            events.push(editor.app.on_([
+                [[KeyEvent.HOLD, KeyEvent.UP], this.onKey, this],
+                [KeyEvent.DOWN, this.onArrow, this]
+            ]));
+        });
     }
     __removeListenEvents() {
         this.off_(this.__eventIds);
@@ -13234,11 +13258,12 @@ class EditMask extends UI {
             if (options.bounds && !options.bounds.hit(editor.editBox.rect.__world, options.matrix))
                 return;
             canvas.saveBlendMode('destination-out');
+            options = Object.assign(Object.assign({}, options), { shape: true });
             editor.list.forEach(item => {
-                item.__renderShape(canvas, options);
-                const { __box, parent } = item;
-                if ((item = __box) || ((item = parent) && parent.textBox))
-                    item.__renderShape(canvas, options);
+                item.__render(canvas, options);
+                const { parent } = item;
+                if (parent && parent.textBox)
+                    parent.__renderShape(canvas, options);
             });
             canvas.restoreBlendMode();
         }
@@ -13333,7 +13358,7 @@ const config = {
 const bounds$1 = new Bounds();
 function simulate(editor) {
     const { simulateTarget, list } = editor;
-    const { zoomLayer } = list[0].leafer.zoomLayer;
+    const { zoomLayer } = list[0].leafer;
     simulateTarget.safeChange(() => {
         bounds$1.setListWithFn(list, (leaf) => leaf.getBounds('box', 'page'));
         if (bounds$1.width === 0)
@@ -13355,15 +13380,14 @@ function onTarget(editor, oldValue) {
     else {
         editor.simulateTarget.remove();
         editor.leafList.reset();
-        editor.closeInnerEditor();
     }
-    editor.emitEvent(new EditorEvent(EditorEvent.SELECT, { editor, value: target, oldValue }));
+    editor.closeInnerEditor();
+    const data = { editor, value: target, oldValue };
+    editor.emitEvent(new EditorEvent(EditorEvent.SELECT, data));
     editor.checkOpenedGroups();
     if (editor.editing) {
         editor.waitLeafer(() => {
-            updateMoveCursor(editor);
             editor.updateEditTool();
-            editor.update();
             editor.listenTargetEvents();
         });
     }
@@ -13371,6 +13395,7 @@ function onTarget(editor, oldValue) {
         editor.updateEditTool();
         editor.removeTargetEvents();
     }
+    editor.emitEvent(new EditorEvent(EditorEvent.AFTER_SELECT, data));
 }
 function onHover(editor, oldValue) {
     editor.emitEvent(new EditorEvent(EditorEvent.HOVER, { editor, value: editor.hoverTarget, oldValue }));
@@ -13542,93 +13567,45 @@ class SimulateElement extends Rect {
     }
 }
 
-class Editor extends Group {
-    get list() { return this.leafList.list; }
-    get dragHoverExclude() { return [this.editBox.rect]; }
-    get editing() { return !!this.list.length; }
-    get groupOpening() { return !!this.openedGroupList.length; }
-    get multiple() { return this.list.length > 1; }
-    get single() { return this.list.length === 1; }
-    get dragging() { return this.editBox.dragging; }
-    get moving() { return this.editBox.moving; }
-    get dragPoint() { return this.editBox.dragPoint; }
-    get element() { return this.multiple ? this.simulateTarget : this.list[0]; }
-    get buttons() { return this.editBox.buttons; }
-    constructor(userConfig, data) {
-        super(data);
-        this.leafList = new LeafList();
-        this.openedGroupList = new LeafList();
-        this.simulateTarget = new SimulateElement(this);
-        this.editBox = new EditBox(this);
-        this.editToolList = {};
-        this.selector = new EditSelect(this);
-        this.editMask = new EditMask(this);
-        this.targetEventIds = [];
-        let mergedConfig = DataHelper.clone(config);
-        if (userConfig)
-            mergedConfig = DataHelper.default(userConfig, mergedConfig);
-        this.mergedConfig = this.config = mergedConfig;
-        this.addMany(this.editMask, this.selector, this.editBox);
-        if (!Plugin.has('resize'))
-            this.config.editSize = 'scale';
-    }
-    select(target) {
-        this.target = target;
-    }
-    cancel() {
-        this.target = null;
-    }
-    hasItem(item) {
-        return this.leafList.has(item);
-    }
-    addItem(item) {
-        if (!this.hasItem(item) && !item.locked)
-            this.leafList.add(item), this.target = this.leafList.list;
-    }
-    removeItem(item) {
-        if (this.hasItem(item))
-            this.leafList.remove(item), this.target = this.leafList.list;
-    }
-    shiftItem(item) {
-        this.hasItem(item) ? this.removeItem(item) : this.addItem(item);
-    }
-    update() {
-        if (this.editing) {
-            if (!this.element.parent)
-                return this.cancel();
-            if (this.innerEditing)
-                this.innerEditor.update();
-            this.editTool.update();
-            this.selector.update();
-        }
+class EditorMoveEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
     }
-    updateEditBox() {
-        if (this.multiple)
-            simulate(this);
-        this.update();
+}
+EditorMoveEvent.BEFORE_MOVE = 'editor.before_move';
+EditorMoveEvent.MOVE = 'editor.move';
+
+class EditorScaleEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
     }
-    updateEditTool() {
-        const tool = this.editTool;
-        if (tool) {
-            this.editBox.unload();
-            tool.unload();
-            this.editTool = null;
-        }
-        if (this.editing) {
-            const tag = this.single ? this.list[0].editOuter : 'EditTool';
-            this.editTool = this.editToolList[tag] = this.editToolList[tag] || EditToolCreator.get(tag, this);
-            this.editBox.load();
-            this.editTool.load();
-        }
+}
+EditorScaleEvent.BEFORE_SCALE = 'editor.before_scale';
+EditorScaleEvent.SCALE = 'editor.scale';
+
+class EditorRotateEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
     }
-    getEditSize(_ui) {
-        return this.mergeConfig.editSize;
+}
+EditorRotateEvent.BEFORE_ROTATE = 'editor.before_rotate';
+EditorRotateEvent.ROTATE = 'editor.rotate';
+
+class EditorSkewEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
     }
+}
+EditorSkewEvent.BEFORE_SKEW = 'editor.before_skew';
+EditorSkewEvent.SKEW = 'editor.skew';
+
+class TransformTool {
     onMove(e) {
+        const { target, mergeConfig, dragStartData } = this.editBox;
         if (e instanceof MoveEvent) {
             if (e.moveType !== 'drag') {
-                const { moveable, resizeable } = this.mergeConfig;
-                const move = e.getLocalMove(this.element);
+                const { moveable, resizeable } = mergeConfig;
+                const move = e.getLocalMove(target);
                 if (moveable === 'move')
                     e.stop(), this.move(move.x, move.y);
                 else if (resizeable === 'zoom')
@@ -13643,22 +13620,22 @@ class Editor extends Group {
                 else
                     total.x = 0;
             }
-            this.move(DragEvent.getValidMove(this.element, this.editBox.dragStartData.point, total));
+            this.move(DragEvent.getValidMove(target, dragStartData.point, total));
         }
     }
     onScale(e) {
-        const { element } = this;
-        let { around, lockRatio, resizeable, flipable, editSize } = this.mergeConfig;
+        const { target, mergeConfig, single, dragStartData } = this.editBox;
+        let { around, lockRatio, resizeable, flipable, editSize } = mergeConfig;
         if (e instanceof ZoomEvent) {
             if (resizeable === 'zoom')
-                e.stop(), this.scaleOf(element.getBoxPoint(e), e.scale, e.scale);
+                e.stop(), this.scaleOf(target.getBoxPoint(e), e.scale, e.scale);
         }
         else {
             const { direction } = e.current;
-            if (e.shiftKey || element.lockRatio)
+            if (e.shiftKey || target.lockRatio)
                 lockRatio = true;
-            const data = EditDataHelper.getScaleData(element, this.editBox.dragStartData.bounds, direction, e.getInnerTotal(element), lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, this.multiple || editSize === 'scale');
-            if (this.editTool.onScaleWithDrag) {
+            const data = EditDataHelper.getScaleData(target, dragStartData.bounds, direction, e.getInnerTotal(target), lockRatio, EditDataHelper.getAround(around, e.altKey), flipable, !single || editSize === 'scale');
+            if (this.editTool && this.editTool.onScaleWithDrag) {
                 data.drag = e;
                 this.scaleWithDrag(data);
             }
@@ -13668,38 +13645,38 @@ class Editor extends Group {
         }
     }
     onRotate(e) {
-        const { skewable, rotateable, around, rotateGap } = this.mergeConfig;
+        const { target, mergeConfig, dragStartData } = this.editBox;
+        const { skewable, rotateable, around, rotateGap } = mergeConfig;
         const { direction, name } = e.current;
         if (skewable && name === 'resize-line')
             return this.onSkew(e);
-        const { element } = this, { dragStartData } = this.editBox;
         let origin, rotation;
         if (e instanceof RotateEvent) {
             if (rotateable === 'rotate')
-                e.stop(), rotation = e.rotation, origin = element.getBoxPoint(e);
+                e.stop(), rotation = e.rotation, origin = target.getBoxPoint(e);
             else
                 return;
-            if (element.scaleX * element.scaleY < 0)
+            if (target.scaleX * target.scaleY < 0)
                 rotation = -rotation;
         }
         else {
-            const data = EditDataHelper.getRotateData(element.boxBounds, direction, e.getBoxPoint(element), element.getBoxPoint(dragStartData), e.shiftKey ? null : (element.around || element.origin || around || 'center'));
+            const data = EditDataHelper.getRotateData(target, direction, e, dragStartData, e.shiftKey ? null : (target.around || target.origin || around || 'center'));
             rotation = data.rotation;
             origin = data.origin;
         }
-        if (element.scaleX * element.scaleY < 0)
+        if (target.scaleX * target.scaleY < 0)
             rotation = -rotation;
         if (e instanceof DragEvent)
-            rotation = dragStartData.rotation + rotation - element.rotation;
-        rotation = MathHelper.float(MathHelper.getGapRotation(rotation, rotateGap, element.rotation), 2);
+            rotation = dragStartData.rotation + rotation - target.rotation;
+        rotation = MathHelper.float(MathHelper.getGapRotation(rotation, rotateGap, target.rotation), 2);
         if (!rotation)
             return;
         this.rotateOf(origin, rotation);
     }
     onSkew(e) {
-        const { element } = this;
-        const { around } = this.mergeConfig;
-        const { origin, skewX, skewY } = EditDataHelper.getSkewData(element.boxBounds, e.current.direction, e.getInnerMove(element), EditDataHelper.getAround(around, e.altKey));
+        const { target, mergeConfig } = this.editBox;
+        const { around } = mergeConfig;
+        const { origin, skewX, skewY } = EditDataHelper.getSkewData(target.boxBounds, e.current.direction, e.getInnerMove(target), EditDataHelper.getAround(around, e.altKey));
         if (!skewX && !skewY)
             return;
         this.skewOf(origin, skewX, skewY);
@@ -13709,7 +13686,8 @@ class Editor extends Group {
             return;
         if (typeof x === 'object')
             y = x.y, x = x.x;
-        const { element: target } = this, { beforeMove } = this.mergeConfig;
+        const { target, mergeConfig, single, editor } = this.editBox;
+        const { beforeMove } = mergeConfig;
         if (beforeMove) {
             const check = beforeMove({ target, x, y });
             if (typeof check === 'object')
@@ -13718,25 +13696,26 @@ class Editor extends Group {
                 return;
         }
         const world = target.getWorldPointByLocal({ x, y }, null, true);
-        if (this.multiple)
+        if (!single)
             target.safeChange(() => target.move(x, y));
-        const data = { target, editor: this, moveX: world.x, moveY: world.y };
+        const data = { target, editor, moveX: world.x, moveY: world.y };
         this.emitEvent(new EditorMoveEvent(EditorMoveEvent.BEFORE_MOVE, data));
         const event = new EditorMoveEvent(EditorMoveEvent.MOVE, data);
-        this.editTool.onMove(event);
+        this.doMove(event);
         this.emitEvent(event);
     }
     scaleWithDrag(data) {
         if (!this.checkTransform('resizeable'))
             return;
-        const { element: target } = this, { beforeScale } = this.mergeConfig;
+        const { target, mergeConfig, editor } = this.editBox;
+        const { beforeScale } = mergeConfig;
         if (beforeScale) {
             const { origin, scaleX, scaleY, drag } = data;
             const check = beforeScale({ target, drag, origin, scaleX, scaleY });
             if (check === false)
                 return;
         }
-        data = Object.assign(Object.assign({}, data), { target, editor: this, worldOrigin: target.getWorldPoint(data.origin) });
+        data = Object.assign(Object.assign({}, data), { target, editor, worldOrigin: target.getWorldPoint(data.origin) });
         this.emitEvent(new EditorScaleEvent(EditorScaleEvent.BEFORE_SCALE, data));
         const event = new EditorScaleEvent(EditorScaleEvent.SCALE, data);
         this.editTool.onScaleWithDrag(event);
@@ -13745,7 +13724,8 @@ class Editor extends Group {
     scaleOf(origin, scaleX, scaleY = scaleX, _resize) {
         if (!this.checkTransform('resizeable'))
             return;
-        const { element: target } = this, { beforeScale } = this.mergeConfig;
+        const { target, mergeConfig, single, editor } = this.editBox;
+        const { beforeScale } = mergeConfig;
         if (beforeScale) {
             const check = beforeScale({ target, origin, scaleX, scaleY });
             if (typeof check === 'object')
@@ -13754,29 +13734,30 @@ class Editor extends Group {
                 return;
         }
         const worldOrigin = this.getWorldOrigin(origin);
-        const transform = this.multiple && this.getChangedTransform(() => target.safeChange(() => target.scaleOf(origin, scaleX, scaleY)));
-        const data = { target, editor: this, worldOrigin, scaleX, scaleY, transform };
+        const transform = !single && this.getChangedTransform(() => target.safeChange(() => target.scaleOf(origin, scaleX, scaleY)));
+        const data = { target, editor, worldOrigin, scaleX, scaleY, transform };
         this.emitEvent(new EditorScaleEvent(EditorScaleEvent.BEFORE_SCALE, data));
         const event = new EditorScaleEvent(EditorScaleEvent.SCALE, data);
-        this.editTool.onScale(event);
+        this.doScale(event);
         this.emitEvent(event);
     }
     flip(axis) {
         if (!this.checkTransform('resizeable'))
             return;
-        const { element } = this;
+        const { target, single, editor } = this.editBox;
         const worldOrigin = this.getWorldOrigin('center');
-        const transform = this.multiple ? this.getChangedTransform(() => element.safeChange(() => element.flip(axis))) : new Matrix(LeafHelper.getFlipTransform(element, axis));
-        const data = { target: element, editor: this, worldOrigin, scaleX: axis === 'x' ? -1 : 1, scaleY: axis === 'y' ? -1 : 1, transform };
+        const transform = !single ? this.getChangedTransform(() => target.safeChange(() => target.flip(axis))) : new Matrix(LeafHelper.getFlipTransform(target, axis));
+        const data = { target, editor, worldOrigin, scaleX: axis === 'x' ? -1 : 1, scaleY: axis === 'y' ? -1 : 1, transform };
         this.emitEvent(new EditorScaleEvent(EditorScaleEvent.BEFORE_SCALE, data));
         const event = new EditorScaleEvent(EditorScaleEvent.SCALE, data);
-        this.editTool.onScale(event);
+        this.doScale(event);
         this.emitEvent(event);
     }
     rotateOf(origin, rotation) {
         if (!this.checkTransform('rotateable'))
             return;
-        const { element: target } = this, { beforeRotate } = this.mergeConfig;
+        const { target, mergeConfig, single, editor } = this.editBox;
+        const { beforeRotate } = mergeConfig;
         if (beforeRotate) {
             const check = beforeRotate({ target, origin, rotation });
             if (typeof check === 'number')
@@ -13785,17 +13766,18 @@ class Editor extends Group {
                 return;
         }
         const worldOrigin = this.getWorldOrigin(origin);
-        const transform = this.multiple && this.getChangedTransform(() => target.safeChange(() => target.rotateOf(origin, rotation)));
-        const data = { target, editor: this, worldOrigin, rotation, transform };
+        const transform = !single && this.getChangedTransform(() => target.safeChange(() => target.rotateOf(origin, rotation)));
+        const data = { target, editor, worldOrigin, rotation, transform };
         this.emitEvent(new EditorRotateEvent(EditorRotateEvent.BEFORE_ROTATE, data));
         const event = new EditorRotateEvent(EditorRotateEvent.ROTATE, data);
-        this.editTool.onRotate(event);
+        this.doRotate(event);
         this.emitEvent(event);
     }
     skewOf(origin, skewX, skewY = 0, _resize) {
         if (!this.checkTransform('skewable'))
             return;
-        const { element: target } = this, { beforeSkew } = this.mergeConfig;
+        const { target, mergeConfig, single, editor } = this.editBox;
+        const { beforeSkew } = mergeConfig;
         if (beforeSkew) {
             const check = beforeSkew({ target, origin, skewX, skewY });
             if (typeof check === 'object')
@@ -13804,25 +13786,142 @@ class Editor extends Group {
                 return;
         }
         const worldOrigin = this.getWorldOrigin(origin);
-        const transform = this.multiple && this.getChangedTransform(() => target.safeChange(() => target.skewOf(origin, skewX, skewY)));
-        const data = { target, editor: this, worldOrigin, skewX, skewY, transform };
+        const transform = !single && this.getChangedTransform(() => target.safeChange(() => target.skewOf(origin, skewX, skewY)));
+        const data = { target, editor, worldOrigin, skewX, skewY, transform };
         this.emitEvent(new EditorSkewEvent(EditorSkewEvent.BEFORE_SKEW, data));
         const event = new EditorSkewEvent(EditorSkewEvent.SKEW, data);
-        this.editTool.onSkew(event);
+        this.doSkew(event);
         this.emitEvent(event);
     }
-    checkTransform(type) { return this.element && !this.element.locked && this.mergeConfig[type]; }
+    doMove(event) {
+        this.editTool.onMove(event);
+    }
+    doScale(event) {
+        this.editTool.onScale(event);
+    }
+    doRotate(event) {
+        this.editTool.onRotate(event);
+    }
+    doSkew(event) {
+        this.editTool.onSkew(event);
+    }
+    checkTransform(type) {
+        const { target, mergeConfig } = this.editBox;
+        return target && !target.locked && mergeConfig[type];
+    }
     getWorldOrigin(origin) {
-        return this.element.getWorldPoint(LeafHelper.getInnerOrigin(this.element, origin));
+        const { target } = this.editBox;
+        return target.getWorldPoint(LeafHelper.getInnerOrigin(target, origin));
     }
     getChangedTransform(func) {
-        const { element } = this;
-        if (this.multiple && !element.canChange)
-            return element.changedTransform;
-        const oldMatrix = new Matrix(element.worldTransform);
+        const { target, single } = this.editBox;
+        if (!single && !target.canChange)
+            return target.changedTransform;
+        const oldMatrix = new Matrix(target.worldTransform);
         func();
-        return new Matrix(element.worldTransform).divide(oldMatrix);
+        return new Matrix(target.worldTransform).divide(oldMatrix);
     }
+    emitEvent(event, capture) {
+        this.editBox.editor.emitEvent(event, capture);
+    }
+}
+
+let Editor = class Editor extends Group {
+    get list() { return this.leafList.list; }
+    get dragHoverExclude() { return [this.editBox.rect]; }
+    get editing() { return !!this.list.length; }
+    get groupOpening() { return !!this.openedGroupList.length; }
+    get multiple() { return this.list.length > 1; }
+    get single() { return this.list.length === 1; }
+    get dragging() { return this.editBox.dragging; }
+    get moving() { return this.editBox.moving; }
+    get dragPoint() { return this.editBox.dragPoint; }
+    get element() { return this.multiple ? this.simulateTarget : this.list[0]; }
+    get buttons() { return this.editBox.buttons; }
+    constructor(userConfig, data) {
+        super(data);
+        this.leafList = new LeafList();
+        this.openedGroupList = new LeafList();
+        this.simulateTarget = new SimulateElement(this);
+        this.editBox = new EditBox(this);
+        this.editToolList = {};
+        this.selector = new EditSelect(this);
+        this.editMask = new EditMask(this);
+        this.targetEventIds = [];
+        let mergedConfig = DataHelper.clone(config);
+        if (userConfig)
+            mergedConfig = DataHelper.default(userConfig, mergedConfig);
+        this.mergedConfig = this.config = mergedConfig;
+        this.addMany(this.editMask, this.selector, this.editBox);
+        if (!Plugin.has('resize'))
+            this.config.editSize = 'scale';
+    }
+    select(target) {
+        this.target = target;
+    }
+    cancel() {
+        this.target = null;
+    }
+    hasItem(item) {
+        return this.leafList.has(item);
+    }
+    addItem(item) {
+        if (!this.hasItem(item) && !item.locked)
+            this.leafList.add(item), this.target = this.leafList.list;
+    }
+    removeItem(item) {
+        if (this.hasItem(item))
+            this.leafList.remove(item), this.target = this.leafList.list;
+    }
+    shiftItem(item) {
+        this.hasItem(item) ? this.removeItem(item) : this.addItem(item);
+    }
+    update() {
+        if (this.editing) {
+            if (!this.element.parent)
+                return this.cancel();
+            if (this.innerEditing)
+                this.innerEditor.update();
+            this.editTool.update();
+            this.selector.update();
+        }
+    }
+    updateEditBox() {
+        if (this.multiple)
+            simulate(this);
+        this.update();
+    }
+    updateEditTool() {
+        let tool = this.editTool;
+        if (tool) {
+            this.editBox.unload();
+            tool.unload();
+            this.editTool = null;
+        }
+        if (this.editing) {
+            const tag = this.element.editOuter || 'EditTool';
+            tool = this.editTool = this.editToolList[tag] = this.editToolList[tag] || EditToolCreator.get(tag, this);
+            this.editBox.load();
+            tool.load();
+            this.update();
+        }
+    }
+    getEditSize(_ui) {
+        return this.mergeConfig.editSize;
+    }
+    onMove(_e) { }
+    onScale(_e) { }
+    onRotate(_e) { }
+    onSkew(_e) { }
+    move(_x, _y = 0) { }
+    scaleWithDrag(_data) { }
+    scaleOf(_origin, scaleX, _scaleY = scaleX, _resize) { }
+    flip(_axis) { }
+    rotateOf(_origin, _rotation) { }
+    skewOf(_origin, _skewX, _skewY = 0, _resize) { }
+    checkTransform(_type) { return undefined; }
+    getWorldOrigin(_origin) { return undefined; }
+    getChangedTransform(_func) { return undefined; }
     group(userGroup) {
         if (this.multiple) {
             this.emitGroupEvent(EditorGroupEvent.BEFORE_GROUP);
@@ -13940,12 +14039,9 @@ class Editor extends Group {
         if (this.targetChanged)
             this.update();
     }
-    onKey(e) {
-        updateCursor(this, e);
-    }
     listenTargetEvents() {
         if (!this.targetEventIds.length) {
-            const { app, leafer, editBox, editMask } = this;
+            const { app, leafer, editMask } = this;
             this.targetEventIds = [
                 leafer.on_(RenderEvent.START, this.onRenderStart, this),
                 app.on_([
@@ -13953,8 +14049,6 @@ class Editor extends Group {
                     [MoveEvent.BEFORE_MOVE, this.onMove, this, true],
                     [ZoomEvent.BEFORE_ZOOM, this.onScale, this, true],
                     [RotateEvent.BEFORE_ROTATE, this.onRotate, this, true],
-                    [[KeyEvent.HOLD, KeyEvent.UP], this.onKey, this],
-                    [KeyEvent.DOWN, editBox.onArrow, editBox]
                 ])
             ];
             if (editMask.visible)
@@ -13979,7 +14073,7 @@ class Editor extends Group {
             super.destroy();
         }
     }
-}
+};
 __decorate([
     mergeConfigAttr()
 ], Editor.prototype, "mergeConfig", void 0);
@@ -13989,14 +14083,19 @@ __decorate([
 __decorate([
     targetAttr(onTarget)
 ], Editor.prototype, "target", void 0);
+Editor = __decorate([
+    useModule(TransformTool, ['editBox', 'editTool', 'emitEvent'])
+], Editor);
 
 class InnerEditor {
     static registerInnerEditor() {
         EditToolCreator.register(this);
     }
     get tag() { return 'InnerEditor'; }
+    get mode() { return 'focus'; }
     get editBox() { return this.editor.editBox; }
     constructor(editor) {
+        this.eventIds = [];
         this.editor = editor;
         this.create();
     }
@@ -14009,7 +14108,7 @@ class InnerEditor {
     load() {
         const { editor } = this;
         if (editor) {
-            if (editor.app)
+            if (editor.app && this.mode === 'focus')
                 editor.selector.hittable = editor.app.tree.hitChildren = false;
             this.onLoad();
         }
@@ -14020,7 +14119,7 @@ class InnerEditor {
     unload() {
         const { editor } = this;
         if (editor) {
-            if (editor.app)
+            if (editor.app && this.mode === 'focus')
                 editor.selector.hittable = editor.app.tree.hitChildren = true;
             this.onUnload();
         }
@@ -14094,10 +14193,7 @@ let EditTool = class EditTool extends InnerEditor {
         this.onLoad();
     }
     update() {
-        const { editor, editBox } = this;
-        const { x, y, scaleX, scaleY, rotation, skewX, skewY, width, height } = editor.element.getLayoutBounds('box', editor, true);
-        editBox.set({ x, y, scaleX, scaleY, rotation, skewX, skewY });
-        editBox.update({ x: 0, y: 0, width, height });
+        this.editBox.update();
         this.onUpdate();
     }
     unload() {
@@ -14838,8 +14934,16 @@ function getFixBounds(bounds, scaleBounds) {
 }
 
 Plugin.add('view');
-Leafer.prototype.zoom = function (zoomType, padding, fixed, transition) {
+Leafer.prototype.zoom = function (zoomType, optionsOrPadding, scroll, transition) {
     this.killAnimate();
+    let padding;
+    if (typeof optionsOrPadding === 'object' && !(optionsOrPadding instanceof Array)) {
+        padding = optionsOrPadding.padding;
+        scroll = optionsOrPadding.scroll;
+        transition = optionsOrPadding.transition;
+    }
+    else
+        padding = optionsOrPadding;
     const { zoomLayer } = this;
     const limitBounds = this.canvas.bounds.clone().shrink(padding !== undefined ? padding : 30), bounds = new Bounds();
     const center = { x: limitBounds.x + limitBounds.width / 2, y: limitBounds.y + limitBounds.height / 2 };
@@ -14886,7 +14990,7 @@ Leafer.prototype.zoom = function (zoomType, padding, fixed, transition) {
         }
         const { width, height } = bounds;
         let moveX = limitBounds.x - bounds.x, moveY = limitBounds.y - bounds.y;
-        if (fixed) {
+        if (scroll) {
             moveX += Math.max((limitBounds.width - width) / 2, 0);
             moveY += Math.max((limitBounds.height - height) / 2, 0);
         }
@@ -14899,6 +15003,10 @@ Leafer.prototype.zoom = function (zoomType, padding, fixed, transition) {
             data.scaleX *= changeScale;
             data.scaleY *= changeScale;
         }
+        if (scroll === 'x')
+            moveY = 0;
+        else if (scroll === 'y')
+            moveX = 0;
         PointHelper.move(data, moveX, moveY);
         bounds.move(moveX, moveY);
         zoomLayer.set(data, transition);
@@ -18096,4 +18204,4 @@ Object.assign(Filter, {
     }
 });
 
-export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isEmptyData, isNull, layoutProcessor, maskType, motionPathType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix, tempPoint$3 as tempPoint, useCanvas, useModule, version, visibleType, zoomLayerType };
+export { AlignHelper, Animate, AnimateEasing, AnimateEvent, AnimateList, Answer, App, AroundHelper, Arrow, ArrowData, AutoBounds, BezierHelper, Bounds, BoundsEvent, BoundsHelper, Box, BoxData, Branch, BranchHelper, BranchRender, Canvas, CanvasData, CanvasManager, ChildEvent, ColorConvert, Creator, Cursor, DataHelper, Debug, Direction4, Direction9, DragEvent, Dragger, DropEvent, EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, EditToolCreator, Editor, EditorEvent, EditorGroupEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, Effect, Ellipse, EllipseData, EllipseHelper, Event, EventCreator, Eventer, Export, FileHelper, Filter, Finder, Flow, Frame, FrameData, Group, GroupData, HighBezierHelper, HighCurveHelper, HitCanvasManager, Image, ImageData, ImageEvent, ImageManager, IncrementId, InnerEditor, InnerEditorEvent, Interaction, InteractionBase, InteractionHelper, KeyEvent, Keyboard, LayoutEvent, Layouter, Leaf, LeafBounds, LeafBoundsHelper, LeafData, LeafDataProxy, LeafEventer, LeafHelper, LeafLayout, LeafLevelList, LeafList, LeafMatrix, LeafRender, Leafer, LeaferCanvas, LeaferCanvasBase, LeaferData, LeaferEvent, LeaferImage, LeaferTypeCreator, Line, LineData, LineEditTool, MathHelper, Matrix, MatrixHelper, MoveEvent, MultiTouchHelper, MyDragEvent, MyImage, MyPointerEvent, NeedConvertToCanvasCommandMap, OneRadian, PI2, PI_2, Paint, PaintGradient, PaintImage, Path, PathArrow, PathArrowModule, PathBounds, PathCommandDataHelper, PathCommandMap, PathConvert, PathCorner, PathCreator, PathData, PathDrawer, PathHelper, PathMatrixHelper, PathNumberCommandLengthMap, PathNumberCommandMap, PathScaler, Pen, PenData, Picker, Platform, Plugin, Point, PointHelper, PointerButton, PointerEvent, Polygon, PolygonData, PropertyEvent, Rect, RectData, RectHelper, RectRender, RenderEvent, Renderer, ResizeEvent, Resource, Robot, RobotData, RotateEvent, Run, ScrollBar, SelectArea, Selector, Star, StarData, State, StringNumberMap, Stroker, SwipeEvent, TaskItem, TaskProcessor, Text, TextConvert, TextData, TransformTool, Transformer, Transition, TwoPointBoundsHelper, UI, UIBounds, UICreator, UIData, UIEvent, UIRender, UnitConvert, WaitHelper, WatchEvent, Watcher, WheelEventHelper, ZoomEvent, addViewport, addViewportConfig, affectRenderBoundsType, affectStrokeBoundsType, arrowType, attr, autoLayoutType, boundsType, canvasPatch, canvasSizeAttrs, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, effectType, emptyData, eraserType, getBoundsData, getDescriptor, getMatrixData, getPointData, hitType, isEmptyData, isNull, layoutProcessor, maskType, motionPathType, naturalBoundsType, opacityType, pathInputType, pathType, pen, positionType, registerEditTool, registerInnerEditor, registerUI, registerUIEvent, resizeType, rewrite, rewriteAble, rotationType, scaleResize, scaleResizeFontSize, scaleResizeGroup, scaleResizePath, scaleResizePoints, scaleType, sortType, stateStyleType, stateType, strokeType, surfaceType, tempBounds$1 as tempBounds, tempMatrix, tempPoint$3 as tempPoint, useCanvas, useModule, version, visibleType, zoomLayerType };