@leafer-in/editor 1.0.0-rc.2 → 1.0.0-rc.20

package/dist/editor.esm.js

@@ -1,4 +1,545 @@
-import { MatrixHelper, Bounds, Matrix, Event, Group, Rect, Polygon, DataHelper, RotateEvent, PointHelper, MathHelper, DragEvent, PointerEvent, RenderEvent, KeyEvent } from '@leafer-ui/core';
+import { PathCommandMap, Leaf, Path, Line, Polygon, MatrixHelper, Group, Box } from '@leafer-ui/draw';
+import { Event, defineKey, MatrixHelper as MatrixHelper$1, UI, Paint, Group as Group$1, Rect, Answer, Bounds, LeafList, PointerEvent, DragEvent, MoveEvent, ZoomEvent, PointHelper, AroundHelper, MathHelper, Box as Box$1, getPointData, Line as Line$1, Matrix, DataHelper, RotateEvent, RenderEvent, KeyEvent, Creator } from '@leafer-ui/core';
+
+const { M, L, C, Q, Z, N, D, X, G, F, O, P, U } = PathCommandMap;
+const PathScaler = {
+    scale(data, scaleX, scaleY) {
+        if (!data)
+            return;
+        let command;
+        let i = 0, len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                    scalePoints(data, scaleX, scaleY, i, 1);
+                    i += 3;
+                    break;
+                case L:
+                    scalePoints(data, scaleX, scaleY, i, 1);
+                    i += 3;
+                    break;
+                case C:
+                    scalePoints(data, scaleX, scaleY, i, 3);
+                    i += 7;
+                    break;
+                case Q:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case Z:
+                    i += 1;
+                    break;
+                case N:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case D:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 9;
+                    break;
+                case X:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 6;
+                    break;
+                case G:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 9;
+                    break;
+                case F:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case O:
+                    data[i] = G;
+                    data.splice(i + 4, 0, data[i + 3], 0);
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 7 + 2;
+                    len += 2;
+                    break;
+                case P:
+                    data[i] = F;
+                    data.splice(i + 4, 0, data[i + 3]);
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 4 + 1;
+                    len += 1;
+                    break;
+                case U:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 6;
+                    break;
+            }
+        }
+    },
+    scalePoints(data, scaleX, scaleY, start, pointCount) {
+        for (let i = pointCount ? start + 1 : 0, end = pointCount ? i + pointCount * 2 : data.length; i < end; i += 2) {
+            data[i] *= scaleX;
+            data[i + 1] *= scaleY;
+        }
+    }
+};
+const { scalePoints } = PathScaler;
+
+Leaf.prototype.scaleResize = function (scaleX, scaleY = scaleX, noResize) {
+    const data = this;
+    if (noResize) {
+        data.scaleX *= scaleX;
+        data.scaleY *= scaleY;
+    }
+    else {
+        if (scaleX < 0)
+            data.scaleX *= -1, scaleX = -scaleX;
+        if (scaleY < 0)
+            data.scaleY *= -1, scaleY = -scaleY;
+        this.__scaleResize(scaleX, scaleY);
+    }
+};
+function scaleResize(leaf, scaleX, scaleY) {
+    if (scaleX !== 1)
+        leaf.width *= scaleX;
+    if (scaleY !== 1)
+        leaf.height *= scaleY;
+}
+Leaf.prototype.__scaleResize = function (scaleX, scaleY) {
+    scaleResize(this, scaleX, scaleY);
+};
+Path.prototype.__scaleResize = function (scaleX, scaleY) {
+    PathScaler.scale(this.__.path, scaleX, scaleY);
+    this.path = this.__.path;
+};
+Line.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.points) {
+        PathScaler.scalePoints(this.__.points, scaleX, scaleY);
+        this.points = this.__.points;
+    }
+    else {
+        const point = this.toPoint;
+        point.x *= scaleX;
+        point.y *= scaleY;
+        this.toPoint = point;
+    }
+};
+Polygon.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.points) {
+        PathScaler.scalePoints(this.__.points, scaleX, scaleY);
+        this.points = this.__.points;
+    }
+    else {
+        scaleResize(this, scaleX, scaleY);
+    }
+};
+const matrix$1 = MatrixHelper.get();
+function groupScaleResize(group, scaleX, scaleY) {
+    const { children } = group;
+    for (let i = 0; i < children.length; i++) {
+        matrix$1.a = scaleX;
+        matrix$1.d = scaleY;
+        children[i].transform(matrix$1, true);
+    }
+}
+Group.prototype.__scaleResize = function (scaleX, scaleY) {
+    groupScaleResize(this, scaleX, scaleY);
+};
+Box.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.__.__autoSize && this.children.length) {
+        groupScaleResize(this, scaleX, scaleY);
+    }
+    else {
+        scaleResize(this, scaleX, scaleY);
+    }
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function toList(value) {
+    return value ? (value instanceof Array ? value : [value]) : [];
+}
+class EditorEvent extends Event {
+    get list() { return toList(this.value); }
+    get oldList() { return toList(this.oldValue); }
+    constructor(type, data) {
+        super(type);
+        if (data)
+            Object.assign(this, data);
+    }
+}
+EditorEvent.SELECT = 'editor.select';
+EditorEvent.HOVER = 'editor.hover';
+
+class EditorMoveEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
+    }
+}
+EditorMoveEvent.MOVE = 'editor.move';
+
+class EditorScaleEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
+    }
+}
+EditorScaleEvent.SCALE = 'editor.scale';
+
+class EditorRotateEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
+    }
+}
+EditorRotateEvent.ROTATE = 'editor.rotate';
+
+class EditorSkewEvent extends EditorEvent {
+    constructor(type, data) {
+        super(type, data);
+    }
+}
+EditorSkewEvent.SKEW = 'editor.skew';
+
+function targetAttr(fn) {
+    return (target, key) => {
+        const privateKey = '_' + key;
+        defineKey(target, key, {
+            get() { return this[privateKey]; },
+            set(value) {
+                const old = this[privateKey];
+                if (old !== value)
+                    this[privateKey] = value, fn(this, old);
+            }
+        });
+    };
+}
+
+const matrix = MatrixHelper$1.get();
+const { abs } = Math;
+const { copy, scale } = MatrixHelper$1;
+class Stroker extends UI {
+    constructor() {
+        super();
+        this.list = [];
+        this.hittable = false;
+        this.strokeAlign = 'center';
+    }
+    setTarget(target, style) {
+        const { stroke, strokeWidth } = style;
+        this.set({ stroke, strokeWidth });
+        this.target = target;
+    }
+    __draw(canvas, options) {
+        const { list } = this;
+        if (list.length) {
+            let leaf;
+            const { stroke, strokeWidth } = this.__;
+            const { bounds } = options;
+            for (let i = 0; i < list.length; i++) {
+                leaf = list[i];
+                if (bounds && bounds.hit(leaf.__world, options.matrix)) {
+                    let drewPath;
+                    if (leaf.__.editSize === 'scale') {
+                        const aScaleX = abs(leaf.__world.scaleX), aScaleY = abs(leaf.__world.scaleY);
+                        if (aScaleX !== aScaleY) {
+                            copy(matrix, leaf.__world);
+                            scale(matrix, 1 / aScaleX, 1 / aScaleY);
+                            canvas.setWorld(matrix, options.matrix);
+                            canvas.beginPath();
+                            this.__.strokeWidth = strokeWidth;
+                            const { x, y, width, height } = leaf.__layout.boxBounds;
+                            canvas.rect(x * aScaleX, y * aScaleY, width * aScaleX, height * aScaleY);
+                            drewPath = true;
+                        }
+                    }
+                    if (!drewPath) {
+                        canvas.setWorld(leaf.__world, options.matrix);
+                        canvas.beginPath();
+                        if (leaf.__.__useArrow) {
+                            leaf.__drawPath(canvas);
+                        }
+                        else {
+                            leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
+                        }
+                        this.__.strokeWidth = strokeWidth / abs(leaf.__world.scaleX);
+                    }
+                    typeof stroke === 'string' ? Paint.stroke(stroke, this, canvas) : Paint.strokes(stroke, this, canvas);
+                }
+            }
+            this.__.strokeWidth = strokeWidth;
+        }
+    }
+    destroy() {
+        this.target = null;
+        super.destroy();
+    }
+}
+__decorate([
+    targetAttr(onTarget$1)
+], Stroker.prototype, "target", void 0);
+function onTarget$1(stroker) {
+    const value = stroker.target;
+    stroker.list = value ? (value instanceof Array ? value : [value]) : [];
+    stroker.forceUpdate();
+}
+
+class SelectArea extends Group$1 {
+    constructor(data) {
+        super(data);
+        this.strokeArea = new Rect({ strokeAlign: 'center' });
+        this.fillArea = new Rect();
+        this.visible = this.hittable = false;
+        this.addMany(this.fillArea, this.strokeArea);
+    }
+    setStyle(style, userStyle) {
+        const { visible, stroke, strokeWidth } = style;
+        this.visible = visible;
+        this.strokeArea.reset(Object.assign({ stroke, strokeWidth }, (userStyle || {})));
+        this.fillArea.reset({ visible: userStyle ? false : true, fill: stroke, opacity: 0.2 });
+    }
+    setBounds(bounds) {
+        this.strokeArea.set(bounds);
+        this.fillArea.set(bounds);
+    }
+}
+
+const { No, Yes, NoAndSkip, YesAndSkip } = Answer;
+const EditSelectHelper = {
+    findOne(path) {
+        return path.list.find((leaf) => leaf.editable);
+    },
+    findBounds(leaf, bounds) {
+        if (leaf.__.hittable && leaf.__.visible && !leaf.__.locked && bounds.hit(leaf.__world)) {
+            if (leaf.__.editable) {
+                if (leaf.isBranch && !leaf.__.hitChildren) {
+                    return leaf.__.hitSelf ? YesAndSkip : NoAndSkip;
+                }
+                else if (leaf.isFrame) {
+                    return bounds.includes(leaf.__layout.boxBounds, leaf.__world) ? YesAndSkip : No;
+                }
+                else {
+                    if (bounds.hit(leaf.__layout.boxBounds, leaf.__world) && leaf.__.hitSelf)
+                        return Yes;
+                }
+            }
+            return No;
+        }
+        else {
+            return leaf.isBranch ? NoAndSkip : No;
+        }
+    }
+};
+
+const { findOne } = EditSelectHelper;
+class EditSelect extends Group$1 {
+    get dragging() { return !!this.originList; }
+    get running() { return this.editor.hittable && this.editor.config.selector; }
+    get isMoveMode() { return this.app && this.app.interaction.moveMode; }
+    constructor(editor) {
+        super();
+        this.hoverStroker = new Stroker();
+        this.targetStroker = new Stroker();
+        this.bounds = new Bounds();
+        this.selectArea = new SelectArea();
+        this.__eventIds = [];
+        this.editor = editor;
+        this.addMany(this.targetStroker, this.hoverStroker, this.selectArea);
+        this.__listenEvents();
+    }
+    onHover() {
+        const { editor } = this;
+        if (this.running && !this.dragging && !editor.dragging) {
+            const { stroke, strokeWidth, hover } = editor.config;
+            this.hoverStroker.setTarget(hover ? this.editor.hoverTarget : null, { stroke, strokeWidth });
+        }
+        else {
+            this.hoverStroker.target = null;
+        }
+    }
+    onSelect() {
+        if (this.running) {
+            const { config, list } = this.editor;
+            const { stroke, strokeWidth } = config;
+            this.targetStroker.setTarget(list, { stroke, strokeWidth: Math.max(1, strokeWidth / 2) });
+            this.hoverStroker.target = null;
+        }
+    }
+    update() {
+        if (this.running)
+            this.targetStroker.forceUpdate();
+    }
+    onPointerMove(e) {
+        const { app, editor } = this;
+        if (this.running && !this.isMoveMode && app.config.pointer.hover && !app.interaction.dragging) {
+            const find = e.shiftKey ? this.findDeepOne(e) : findOne(e.path);
+            editor.hoverTarget = editor.hasItem(find) ? null : find;
+        }
+        if (this.isMoveMode) {
+            editor.hoverTarget = null;
+        }
+    }
+    onBeforeDown(e) {
+        const { select } = this.editor.config;
+        if (select === 'press')
+            this.checkAndSelect(e, true);
+    }
+    onTap(e) {
+        const { editor } = this;
+        const { select, continuousSelect } = editor.config;
+        if (select === 'tap')
+            this.checkAndSelect(e);
+        if (this.running && (e.shiftKey || continuousSelect) && !e.middle && !this.lastDownLeaf) {
+            const find = this.findDeepOne(e);
+            if (find)
+                editor.shiftItem(find);
+            else if (!e.shiftKey && continuousSelect)
+                editor.target = null;
+        }
+        else if (this.isMoveMode) {
+            editor.target = null;
+        }
+        this.lastDownLeaf = null;
+    }
+    checkAndSelect(e, isDownType) {
+        if (this.running && !this.isMoveMode && !e.middle) {
+            const { editor } = this;
+            const find = this.lastDownLeaf = findOne(e.path);
+            if (find) {
+                if (e.shiftKey || editor.config.continuousSelect) {
+                    editor.shiftItem(find);
+                }
+                else {
+                    editor.target = find;
+                }
+                if (isDownType) {
+                    editor.updateLayout();
+                    if (!find.locked)
+                        this.app.interaction.updateDownData(e, { findList: [editor.editBox.rect] }, editor.config.dualEvent);
+                }
+            }
+            else if (this.allow(e.target)) {
+                if (!e.shiftKey)
+                    editor.target = null;
+            }
+        }
+    }
+    onDragStart(e) {
+        if (this.running && this.allowDrag(e)) {
+            const { editor } = this;
+            const { stroke, strokeWidth, area } = editor.config;
+            const { x, y } = e.getInner(this);
+            this.bounds.set(x, y);
+            this.selectArea.setStyle({ visible: true, stroke, strokeWidth, x, y }, area);
+            this.selectArea.setBounds(this.bounds.get());
+            this.originList = editor.leafList.clone();
+        }
+    }
+    onDrag(e) {
+        if (this.editor.dragging) {
+            this.onDragEnd();
+            return;
+        }
+        if (this.dragging) {
+            const { editor } = this;
+            const total = e.getInnerTotal(this);
+            const dragBounds = this.bounds.clone().unsign();
+            const list = new LeafList(editor.app.find(EditSelectHelper.findBounds, dragBounds));
+            this.bounds.width = total.x;
+            this.bounds.height = total.y;
+            this.selectArea.setBounds(dragBounds.get());
+            if (list.length) {
+                const selectList = [];
+                this.originList.forEach(item => { if (!list.has(item))
+                    selectList.push(item); });
+                list.forEach(item => { if (!this.originList.has(item))
+                    selectList.push(item); });
+                if (selectList.length !== editor.list.length || editor.list.some((child, index) => child !== selectList[index])) {
+                    editor.target = selectList;
+                }
+            }
+            else {
+                editor.target = this.originList.list;
+            }
+        }
+    }
+    onDragEnd() {
+        if (this.dragging)
+            this.originList = null, this.selectArea.visible = false;
+    }
+    onAutoMove(e) {
+        if (this.dragging) {
+            const { x, y } = e.getLocalMove(this);
+            this.bounds.x += x;
+            this.bounds.y += y;
+        }
+    }
+    allow(target) {
+        return target.leafer !== this.editor.leafer;
+    }
+    allowDrag(e) {
+        if (this.editor.config.boxSelect && !e.target.draggable) {
+            return (!this.editor.hasTarget && this.allow(e.target)) || (e.shiftKey && !findOne(e.path));
+        }
+        else {
+            return false;
+        }
+    }
+    findDeepOne(e) {
+        const options = { exclude: new LeafList(this.editor.editBox.rect) };
+        return findOne(e.target.leafer.interaction.findPath(e, options));
+    }
+    __listenEvents() {
+        const { editor } = this;
+        editor.waitLeafer(() => {
+            const { app } = editor;
+            app.selector.proxy = editor;
+            this.__eventIds = [
+                editor.on_(EditorEvent.HOVER, this.onHover, this),
+                editor.on_(EditorEvent.SELECT, this.onSelect, this),
+                app.on_(PointerEvent.MOVE, this.onPointerMove, this),
+                app.on_(PointerEvent.BEFORE_DOWN, this.onBeforeDown, this),
+                app.on_(PointerEvent.TAP, this.onTap, this),
+                app.on_(DragEvent.START, this.onDragStart, this),
+                app.on_(DragEvent.DRAG, this.onDrag, this),
+                app.on_(DragEvent.END, this.onDragEnd, this),
+                app.on_(MoveEvent.MOVE, this.onAutoMove, this),
+                app.on_([ZoomEvent.ZOOM, MoveEvent.MOVE], () => { this.editor.hoverTarget = null; }),
+            ];
+        });
+    }
+    __removeListenEvents() {
+        if (this.__eventIds) {
+            this.off_(this.__eventIds);
+            this.__eventIds.length = 0;
+        }
+    }
+    destroy() {
+        this.editor = this.originList = this.lastDownLeaf = null;
+        this.__removeListenEvents();
+        super.destroy();
+    }
+}
 
 var IDirection8;
 (function (IDirection8) {
@@ -12,257 +553,591 @@ var IDirection8;
     IDirection8[IDirection8["left"] = 7] = "left";
 })(IDirection8 || (IDirection8 = {}));
 
-const { scaleOfOuter, reset } = MatrixHelper;
-const { topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bottomRight: bottomRight$1, bottom: bottom$1, bottomLeft: bottomLeft$1, left: left$2 } = IDirection8;
-const matrix = {};
-function getResizeData(old, direction, move, lockRatio, around) {
-    if (around) {
-        move.x *= 2;
-        move.y *= 2;
-    }
-    let origin, scaleX = 1, scaleY = 1;
-    const { x, y, width, height } = old;
-    const topScale = (-move.y + height) / height;
-    const rightScale = (move.x + width) / width;
-    const bottomScale = (move.y + height) / height;
-    const leftScale = (-move.x + width) / width;
-    switch (direction) {
-        case top$1:
-            scaleY = topScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x: x + width / 2, y: y + height };
-            break;
-        case right$2:
-            scaleX = rightScale;
-            if (lockRatio)
-                scaleY = scaleX;
-            origin = { x, y: y + height / 2 };
-            break;
-        case bottom$1:
-            scaleY = bottomScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x: x + width / 2, y };
-            break;
-        case left$2:
-            scaleX = leftScale;
-            if (lockRatio)
-                scaleY = scaleX;
-            origin = { x: x + width, y: y + height / 2 };
-            break;
-        case topLeft$1:
-            scaleY = topScale;
-            scaleX = leftScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x: x + width, y: y + height };
-            break;
-        case topRight$1:
-            scaleY = topScale;
-            scaleX = rightScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x, y: y + height };
-            break;
-        case bottomRight$1:
-            scaleY = bottomScale;
-            scaleX = rightScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x, y };
-            break;
-        case bottomLeft$1:
-            scaleY = bottomScale;
-            scaleX = leftScale;
-            if (lockRatio)
-                scaleX = scaleY;
-            origin = { x: x + width, y };
-            break;
-    }
-    if (around) {
-        if (typeof around === 'object') {
-            origin = { x: x + width / around.x, y: y + height / around.y };
+const { topLeft, top, topRight, right: right$1, bottomRight, bottom, bottomLeft, left: left$1 } = IDirection8;
+const { toPoint } = AroundHelper;
+const EditDataHelper = {
+    getScaleData(bounds, direction, pointMove, lockRatio, around) {
+        let origin, scaleX = 1, scaleY = 1;
+        const { width, height } = bounds;
+        if (around) {
+            pointMove.x *= 2;
+            pointMove.y *= 2;
         }
-        else {
-            origin = { x: x + width / 2, y: y + height / 2 };
+        if (Math.abs(pointMove.x) === width)
+            pointMove.x += 0.1;
+        if (Math.abs(pointMove.y) === height)
+            pointMove.y += 0.1;
+        const topScale = (-pointMove.y + height) / height;
+        const rightScale = (pointMove.x + width) / width;
+        const bottomScale = (pointMove.y + height) / height;
+        const leftScale = (-pointMove.x + width) / width;
+        switch (direction) {
+            case top:
+                scaleY = topScale;
+                origin = { x: 0.5, y: 1 };
+                break;
+            case right$1:
+                scaleX = rightScale;
+                origin = { x: 0, y: 0.5 };
+                break;
+            case bottom:
+                scaleY = bottomScale;
+                origin = { x: 0.5, y: 0 };
+                break;
+            case left$1:
+                scaleX = leftScale;
+                origin = { x: 1, y: 0.5 };
+                break;
+            case topLeft:
+                scaleY = topScale;
+                scaleX = leftScale;
+                origin = { x: 1, y: 1 };
+                break;
+            case topRight:
+                scaleY = topScale;
+                scaleX = rightScale;
+                origin = { x: 0, y: 1 };
+                break;
+            case bottomRight:
+                scaleY = bottomScale;
+                scaleX = rightScale;
+                origin = { x: 0, y: 0 };
+                break;
+            case bottomLeft:
+                scaleY = bottomScale;
+                scaleX = leftScale;
+                origin = { x: 1, y: 0 };
+        }
+        if (lockRatio) {
+            const unlockSide = lockRatio === 'corner' && direction % 2;
+            if (!unlockSide) {
+                if (scaleY !== 1)
+                    scaleX = scaleY;
+                else
+                    scaleY = scaleX;
+            }
+        }
+        toPoint(around || origin, bounds, origin);
+        return { origin, scaleX, scaleY, direction, lockRatio, around };
+    },
+    getRotateData(bounds, direction, current, last, around) {
+        let origin;
+        switch (direction) {
+            case topLeft:
+                origin = { x: 1, y: 1 };
+                break;
+            case topRight:
+                origin = { x: 0, y: 1 };
+                break;
+            case bottomRight:
+                origin = { x: 0, y: 0 };
+                break;
+            case bottomLeft:
+                origin = { x: 1, y: 0 };
+                break;
+            default:
+                origin = { x: 0.5, y: 0.5 };
+        }
+        toPoint(around || origin, bounds, origin);
+        return { origin, rotation: PointHelper.getRotation(last, origin, current) };
+    },
+    getSkewData(bounds, direction, move, around) {
+        let origin, skewX = 0, skewY = 0;
+        let last;
+        switch (direction) {
+            case top:
+                last = { x: 0.5, y: 0 };
+                origin = { x: 0.5, y: 1 };
+                skewX = 1;
+                break;
+            case bottom:
+                last = { x: 0.5, y: 1 };
+                origin = { x: 0.5, y: 0 };
+                skewX = 1;
+                break;
+            case left$1:
+                last = { x: 0, y: 0.5 };
+                origin = { x: 1, y: 0.5 };
+                skewY = 1;
+                break;
+            case right$1:
+                last = { x: 1, y: 0.5 };
+                origin = { x: 0, y: 0.5 };
+                skewY = 1;
+        }
+        const { x, y, width, height } = bounds;
+        last.x = x + last.x * width;
+        last.y = y + last.y * height;
+        toPoint(around || origin, bounds, origin);
+        const rotation = PointHelper.getRotation(last, origin, { x: last.x + (skewX ? move.x : 0), y: last.y + (skewY ? move.y : 0) });
+        skewX ? skewX = -rotation : skewY = rotation;
+        return { origin, skewX, skewY };
+    },
+    getAround(around, altKey) {
+        return (altKey && !around) ? 'center' : around;
+    },
+    getRotateDirection(direction, rotation, totalDirection = 8) {
+        direction = (direction + Math.round(rotation / (360 / totalDirection))) % totalDirection;
+        if (direction < 0)
+            direction += totalDirection;
+        return direction;
+    },
+    getFlipDirection(direction, flipedX, flipedY) {
+        if (flipedX) {
+            switch (direction) {
+                case left$1:
+                    direction = right$1;
+                    break;
+                case topLeft:
+                    direction = topRight;
+                    break;
+                case bottomLeft:
+                    direction = bottomRight;
+                    break;
+                case right$1:
+                    direction = left$1;
+                    break;
+                case topRight:
+                    direction = topLeft;
+                    break;
+                case bottomRight:
+                    direction = bottomLeft;
+                    break;
+            }
+        }
+        if (flipedY) {
+            switch (direction) {
+                case top:
+                    direction = bottom;
+                    break;
+                case topLeft:
+                    direction = bottomLeft;
+                    break;
+                case topRight:
+                    direction = bottomRight;
+                    break;
+                case bottom:
+                    direction = top;
+                    break;
+                case bottomLeft:
+                    direction = topLeft;
+                    break;
+                case bottomRight:
+                    direction = topRight;
+                    break;
+            }
         }
+        return direction;
     }
-    reset(matrix);
-    scaleOfOuter(matrix, origin, scaleX, scaleY);
-    const bounds = { x: old.x + matrix.e, y: old.y + matrix.f, width: width * scaleX, height: height * scaleY };
-    return { bounds, old, origin, scaleX, scaleY, direction, lockRatio, around, };
-}
+};
 
-const { topLeft, top, topRight, right: right$1, bottomRight, bottom, bottomLeft, left: left$1 } = IDirection8;
+const cacheCursors = {};
 function updateCursor(editor, e) {
-    const point = editor.enterPoint;
-    if (!point || !editor.target || !editor.visible)
+    const { editBox } = editor, point = editBox.enterPoint;
+    if (!point || !editor.hasTarget || !editBox.visible)
         return;
-    let { rotation } = editor;
-    let { resizeCursor, rotateCursor, resizeable } = editor.config;
-    const mirror = editor.tool.getMirrorData(editor);
-    const { __direction, __isResizePoint } = point.__;
-    editor.enterPoint = point;
-    if (__isResizePoint && (e.metaKey || e.ctrlKey || !resizeable))
-        resizeCursor = rotateCursor;
-    if (mirror.x || mirror.y) {
-        mirrorCursors(resizeCursor = [...resizeCursor], mirror.x, mirror.y);
-        mirrorCursors(rotateCursor = [...rotateCursor], mirror.y, mirror.x);
-        if (mirror.x + mirror.y === 1)
-            rotation = -rotation;
+    if (point.name === 'circle')
+        return;
+    let { rotation } = editBox;
+    const { resizeCursor, rotateCursor, skewCursor, resizeable, rotateable, skewable } = editor.config;
+    const { pointType } = point, { flippedX, flippedY } = editBox;
+    let showResize = pointType === 'resize';
+    if (showResize && rotateable && (e.metaKey || e.ctrlKey || !resizeable))
+        showResize = false;
+    const showSkew = skewable && !showResize && point.name === 'resize-line';
+    const cursor = showSkew ? skewCursor : (showResize ? resizeCursor : rotateCursor);
+    rotation += (EditDataHelper.getFlipDirection(point.direction, flippedX, flippedY) + 1) * 45;
+    rotation = Math.round(MathHelper.formatRotation(rotation, true) / 2) * 2;
+    const { url, x, y } = cursor;
+    const key = url + rotation;
+    if (cacheCursors[key]) {
+        point.cursor = cacheCursors[key];
     }
-    let index = (__direction + Math.round(rotation / 45)) % 8;
-    if (index < 0)
-        index += 8;
-    point.cursor = __isResizePoint ? resizeCursor[index] : rotateCursor[index];
-}
-function mirrorCursors(mirror, mirrorX, mirrorY) {
-    if (mirrorX) {
-        const topCursor = mirror[top], topLeftCursor = mirror[topLeft], topRightCursor = mirror[topRight];
-        mirror[top] = mirror[bottom];
-        mirror[topLeft] = mirror[bottomLeft];
-        mirror[topRight] = mirror[bottomRight];
-        mirror[bottom] = topCursor;
-        mirror[bottomLeft] = topLeftCursor;
-        mirror[bottomRight] = topRightCursor;
-    }
-    if (mirrorY) {
-        const leftCursor = mirror[left$1], topLeftCursor = mirror[topLeft], bottomLeftCursor = mirror[bottomLeft];
-        mirror[left$1] = mirror[right$1];
-        mirror[topLeft] = mirror[topRight];
-        mirror[bottomLeft] = mirror[bottomRight];
-        mirror[right$1] = leftCursor;
-        mirror[topRight] = topLeftCursor;
-        mirror[bottomRight] = bottomLeftCursor;
+    else {
+        cacheCursors[key] = point.cursor = { url: toDataURL(url, rotation), x, y };
     }
 }
+function updateMoveCursor(editor) {
+    editor.editBox.rect.cursor = editor.config.moveCursor;
+}
+function toDataURL(svg, rotation) {
+    return '"data:image/svg+xml,' + encodeURIComponent(svg.replace('{{rotation}}', rotation.toString())) + '"';
+}
 
-const RectTool = {
-    name: 'RectTool',
-    getMirrorData(editor) {
-        const { scaleX, scaleY } = editor.target;
-        return {
-            x: scaleX < 0 ? 1 : 0,
-            y: scaleY < 0 ? 1 : 0
-        };
-    },
-    resize(e) {
-        const { target, bounds, resizeType, old } = e;
-        const { x, y, width, height } = bounds;
-        const point = { x: x - old.x, y: y - old.y };
-        target.innerToWorld(point, null, true, target.parent);
-        target.x += point.x;
-        target.y += point.y;
-        if (resizeType === 'scale') {
-            target.scaleX *= width / old.width;
-            target.scaleY *= height / old.height;
-        }
-        else {
-            if (width < 0) {
-                target.width = -width;
-                target.scaleX *= -1;
-            }
-            else {
-                if (target.width !== width)
-                    target.width = width;
-            }
-            if (height < 0) {
-                target.height = -height;
-                target.scaleY *= -1;
-            }
-            else {
-                if (target.height !== height)
-                    target.height = height;
+class EditPoint extends Box$1 {
+}
+
+const fourDirection = ['top', 'right', 'bottom', 'left'];
+class EditBox extends Group$1 {
+    get flipped() { return this.flippedX || this.flippedY; }
+    get flippedX() { return this.scaleX < 0; }
+    get flippedY() { return this.scaleY < 0; }
+    get flippedOne() { return this.scaleX * this.scaleY < 0; }
+    constructor(editor) {
+        super();
+        this.rect = new Box$1({ name: 'rect', hitFill: 'all', hitStroke: 'none', strokeAlign: 'center', hitRadius: 5 });
+        this.circle = new EditPoint({ name: 'circle', strokeAlign: 'center', around: 'center', cursor: 'crosshair', hitRadius: 5 });
+        this.buttons = new Group$1({ around: 'center', hitSelf: false });
+        this.resizePoints = [];
+        this.rotatePoints = [];
+        this.resizeLines = [];
+        this.__eventIds = [];
+        this.editor = editor;
+        this.visible = false;
+        this.create();
+        this.__listenEvents();
+    }
+    create() {
+        let rotatePoint, resizeLine, resizePoint;
+        const { resizePoints, rotatePoints, resizeLines, rect, circle, buttons } = this;
+        const arounds = [{ x: 1, y: 1 }, { x: 0.5, y: 1 }, { x: 0, y: 1 }, { x: 0, y: 0.5 }, { x: 0, y: 0 }, { x: 0.5, y: 0 }, { x: 1, y: 0 }, { x: 1, y: 0.5 }];
+        for (let i = 0; i < 8; i++) {
+            rotatePoint = new EditPoint({ name: 'rotate-point', around: arounds[i], width: 15, height: 15, hitFill: "all" });
+            rotatePoints.push(rotatePoint);
+            this.listenPointEvents(rotatePoint, 'rotate', i);
+            if (i % 2) {
+                resizeLine = new EditPoint({ name: 'resize-line', around: 'center', width: 10, height: 10, hitFill: "all" });
+                resizeLines.push(resizeLine);
+                this.listenPointEvents(resizeLine, 'resize', i);
             }
+            resizePoint = new EditPoint({ name: 'resize-point', around: 'center', strokeAlign: 'center', hitRadius: 5 });
+            resizePoints.push(resizePoint);
+            this.listenPointEvents(resizePoint, 'resize', i);
         }
-    },
-    rotate(e) {
-        const { target, rotation, origin } = e;
-        target.rotateOf(origin, rotation);
-    },
-    update(editor) {
-        const { target, config, rotatePoints, targetRect, rect, circle, resizeLines, resizePoints } = editor;
-        const { type, resizeable, rotateable, stroke, pointFill, pointSize, pointRadius } = config;
-        const defaultStyle = { fill: pointFill, stroke, width: pointSize, height: pointSize, cornerRadius: pointRadius };
-        const pointStyles = config.point instanceof Array ? config.point : [config.point || defaultStyle];
-        const box = new Bounds(target.boxBounds);
-        const w = target.worldTransform, pw = editor.parent.worldTransform;
-        const matrix = new Matrix(w);
-        matrix.divide(pw);
-        const worldX = matrix.e, worldY = matrix.f;
-        let { scaleX, scaleY, rotation, skewX, skewY } = w;
-        scaleX /= pw.scaleX, scaleY /= pw.scaleY, rotation -= pw.rotation, skewX -= pw.skewX, skewY -= pw.skewY;
-        const { x, y, width, height } = box.scale(scaleX, scaleY);
-        editor.set({ x: worldX, y: worldY, rotation, skewX, skewY });
-        targetRect.set({ x, y, width: box.width / scaleX, height: box.height / scaleY, scaleX, scaleY, visible: true });
-        const points = [
-            { x, y },
-            { x: x + width / 2, y },
-            { x: x + width, y },
-            { x: x + width, y: y + height / 2 },
-            { x: x + width, y: y + height },
-            { x: x + width / 2, y: y + height },
-            { x, y: y + height },
-            { x, y: y + height / 2 }
-        ];
-        const rectPoints = [];
-        let point, style, rotateP, resizeP, resizeL;
+        buttons.add(circle);
+        this.listenPointEvents(circle, 'rotate', 2);
+        this.addMany(...rotatePoints, rect, buttons, ...resizeLines, ...resizePoints);
+    }
+    update(bounds) {
+        const { config, list } = this.editor;
+        const { width, height } = bounds;
+        const { rect, circle, resizePoints, rotatePoints, resizeLines } = this;
+        const { middlePoint, resizeable, rotateable, stroke, strokeWidth, hideOnSmall } = config;
+        const pointsStyle = this.getPointsStyle();
+        const middlePointsStyle = this.getMiddlePointsStyle();
+        const smallSize = typeof hideOnSmall === 'number' ? hideOnSmall : 10;
+        const showPoints = !(hideOnSmall && width < smallSize && height < smallSize);
+        this.visible = list[0] && !list[0].locked;
+        let point = {}, style, rotateP, resizeP, resizeL;
         for (let i = 0; i < 8; i++) {
-            point = points[i];
-            style = pointStyles[i % pointStyles.length];
-            resizeP = resizePoints[i];
-            resizeL = resizeLines[Math.floor(i / 2)];
-            rotateP = rotatePoints[i];
+            AroundHelper.toPoint(AroundHelper.directionData[i], bounds, point);
+            style = this.getPointStyle((i % 2) ? middlePointsStyle[((i - 1) / 2) % middlePointsStyle.length] : pointsStyle[(i / 2) % pointsStyle.length]);
+            resizeP = resizePoints[i], rotateP = rotatePoints[i], resizeL = resizeLines[Math.floor(i / 2)];
             resizeP.set(style);
-            resizeP.x = rotateP.x = resizeL.x = point.x;
-            resizeP.y = rotateP.y = resizeL.y = point.y;
-            resizeP.visible = resizeL.visible = resizeable || rotateable;
-            rotateP.visible = rotateable && resizeable;
+            resizeP.set(point), rotateP.set(point), resizeL.set(point);
+            resizeP.visible = resizeL.visible = showPoints && (resizeable || rotateable);
+            rotateP.visible = showPoints && rotateable && resizeable && !config.rotatePoint;
             if (i % 2) {
+                resizeP.visible = rotateP.visible = showPoints && !!middlePoint;
                 if (((i + 1) / 2) % 2) {
-                    resizeL.width = Math.abs(width);
-                    rotateP.width = Math.max(10, Math.abs(width) - 30);
+                    resizeL.width = width;
+                    if (resizeP.width > width - 30)
+                        resizeP.visible = false;
                 }
                 else {
-                    resizeL.height = Math.abs(height);
-                    rotateP.height = Math.max(10, Math.abs(height) - 30);
+                    resizeL.height = height;
+                    resizeP.rotation = 90;
+                    if (resizeP.width > height - 30)
+                        resizeP.visible = false;
                 }
-                resizeP.rotation = 90;
-                resizeP.visible = type === 'mobile';
             }
             else {
-                rectPoints.push(point.x, point.y);
+                resizeP.rotation = (i / 2) * 90;
+            }
+        }
+        circle.visible = showPoints && rotateable && !!config.rotatePoint;
+        circle.set(this.getPointStyle(config.rotatePoint || pointsStyle[0]));
+        rect.set(Object.assign({ stroke, strokeWidth }, (config.rect || {})));
+        rect.set(Object.assign(Object.assign({}, bounds), { visible: true }));
+        rect.hittable = config.moveable;
+        this.buttons.visible = showPoints;
+        this.layoutButtons();
+    }
+    layoutButtons() {
+        const { buttons, resizePoints } = this;
+        const { buttonsDirection, buttonsFixed, buttonsMargin, middlePoint } = this.editor.config;
+        const { flippedX, flippedY } = this;
+        let index = fourDirection.indexOf(buttonsDirection);
+        if ((index % 2 && flippedX) || ((index + 1) % 2 && flippedY)) {
+            if (buttonsFixed)
+                index = (index + 2) % 4;
+        }
+        const direction = buttonsFixed ? EditDataHelper.getRotateDirection(index, this.flippedOne ? this.rotation : -this.rotation, 4) : index;
+        const point = resizePoints[direction * 2 + 1];
+        const useX = direction % 2;
+        const sign = (!direction || direction === 3) ? -1 : 1;
+        const useWidth = index % 2;
+        const margin = (buttonsMargin + (useWidth ? ((middlePoint ? point.width : 0) + buttons.boxBounds.width) : ((middlePoint ? point.height : 0) + buttons.boxBounds.height)) / 2) * sign;
+        if (useX) {
+            buttons.x = point.x + margin;
+            buttons.y = point.y;
+        }
+        else {
+            buttons.x = point.x;
+            buttons.y = point.y + margin;
+        }
+        if (buttonsFixed) {
+            buttons.rotation = (direction - index) * 90;
+            buttons.scaleX = flippedX ? -1 : 1;
+            buttons.scaleY = flippedY ? -1 : 1;
+        }
+    }
+    getPointStyle(userStyle) {
+        const { stroke, strokeWidth, pointFill, pointSize, pointRadius } = this.editor.config;
+        const defaultStyle = { fill: pointFill, stroke, strokeWidth, width: pointSize, height: pointSize, cornerRadius: pointRadius };
+        return userStyle ? Object.assign(defaultStyle, userStyle) : defaultStyle;
+    }
+    getPointsStyle() {
+        const { point } = this.editor.config;
+        return point instanceof Array ? point : [point];
+    }
+    getMiddlePointsStyle() {
+        const { middlePoint } = this.editor.config;
+        return middlePoint instanceof Array ? middlePoint : (middlePoint ? [middlePoint] : this.getPointsStyle());
+    }
+    onDragStart(e) {
+        this.dragging = true;
+        if (e.target.name === 'rect') {
+            this.moving = true;
+            this.editor.opacity = this.editor.config.hideOnMove ? 0 : 1;
+        }
+    }
+    onDragEnd(e) {
+        this.dragging = false;
+        this.moving = false;
+        if (e.target.name === 'rect')
+            this.editor.opacity = 1;
+    }
+    onDrag(e) {
+        const { editor } = this;
+        const point = this.enterPoint = e.current;
+        if (point.pointType === 'rotate' || e.metaKey || e.ctrlKey || !editor.config.resizeable) {
+            if (editor.config.rotateable)
+                editor.onRotate(e);
+        }
+        else {
+            editor.onScale(e);
+        }
+        updateCursor(editor, e);
+    }
+    onArrow(e) {
+        if (this.editor.hasTarget && this.editor.config.keyEvent) {
+            const move = { x: 0, y: 0 };
+            const distance = e.shiftKey ? 10 : 1;
+            switch (e.code) {
+                case 'ArrowDown':
+                    move.y = distance;
+                    break;
+                case 'ArrowUp':
+                    move.y = -distance;
+                    break;
+                case 'ArrowLeft':
+                    move.x = -distance;
+                    break;
+                case 'ArrowRight':
+                    move.x = distance;
             }
+            if (move.x || move.y)
+                this.editor.move(move.x, move.y);
         }
-        style = config.rotatePoint || style;
-        circle.set(style);
-        circle.x = x + width / 2;
-        if (!style.y)
-            circle.y = y - (10 + (resizeP.height + circle.height) / 2) * (this.getMirrorData(editor).y ? -1 : 1);
-        circle.visible = rotateable && type === 'mobile';
-        rect.set(config.rect || { stroke });
-        rect.points = rectPoints;
-        rect.visible = true;
     }
+    onDoubleClick() {
+        const { editor } = this;
+        if (editor.single && editor.element.isBranch) ;
+    }
+    listenPointEvents(point, type, direction) {
+        const { editor } = this;
+        point.direction = direction;
+        point.pointType = type;
+        point.on_(DragEvent.START, this.onDragStart, this);
+        point.on_(DragEvent.DRAG, this.onDrag, this);
+        point.on_(DragEvent.END, this.onDragEnd, this);
+        point.on_(PointerEvent.LEAVE, () => this.enterPoint = null);
+        if (point.name !== 'circle')
+            point.on_(PointerEvent.ENTER, (e) => { this.enterPoint = point, updateCursor(editor, e); });
+    }
+    __listenEvents() {
+        const { rect, editor } = this;
+        this.__eventIds = [
+            editor.on_(EditorEvent.SELECT, () => { this.visible = editor.hasTarget; }),
+            rect.on_(DragEvent.START, this.onDragStart, this),
+            rect.on_(DragEvent.DRAG, editor.onMove, editor),
+            rect.on_(DragEvent.END, this.onDragEnd, this),
+            rect.on_(PointerEvent.ENTER, () => updateMoveCursor(editor)),
+            rect.on_(PointerEvent.DOUBLE_CLICK, this.onDoubleClick, this)
+        ];
+    }
+    __removeListenEvents() {
+        this.off_(this.__eventIds);
+        this.__eventIds.length = 0;
+    }
+    destroy() {
+        this.editor = null;
+        this.__removeListenEvents();
+        super.destroy();
+    }
+}
+
+const filterStyle = `
+<feOffset dy="1"/>
+<feGaussianBlur stdDeviation="1.5"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
+<feBlend mode="normal" in="SourceGraphic" result="shape"/>`;
+const resizeSVG = `
+<svg width="24" height="24" xmlns="http://www.w3.org/2000/svg">
+<g filter="url(#f)">
+<g transform="rotate({{rotation}},12,12)">
+<path d="M7.5 8.0H8.5V5.9L6.8 7.2L7.5 8.0ZM3 11.4L2.3 10.6L1.3 11.4L2.3 12.2L3 11.4ZM7.5 10.4H6.5V11.4H7.5V10.4ZM16.5 10.4V11.4H17.5V10.4H16.5ZM16.5 8.0L17.1 7.2L15.5 5.9V8.0H16.5ZM21 11.4L21.6 12.2L22.6 11.4L21.6 10.6L21 11.4ZM16.5 14.9H15.5V16.9L17.1 15.7L16.5 14.9ZM16.5 12.4H17.5V11.4H16.5V12.4ZM7.5 12.4V11.4H6.5V12.4H7.5ZM7.5 14.9L6.8 15.7L8.5 16.9V14.9H7.5ZM6.8 7.2L2.3 10.6L3.6 12.2L8.1 8.7L6.8 7.2ZM8.5 10.4V8.0H6.5V10.4H8.5ZM16.5 9.4H7.5V11.4H16.5V9.4ZM17.5 10.4V8.0H15.5V10.4H17.5ZM15.8 8.7L20.3 12.2L21.6 10.6L17.1 7.2L15.8 8.7ZM20.3 10.6L15.8 14.1L17.1 15.7L21.6 12.2L20.3 10.6ZM17.5 14.9V12.4H15.5V14.9H17.5ZM7.5 13.4H16.5V11.4H7.5V13.4ZM8.5 14.9V12.4H6.5V14.9H8.5ZM2.3 12.2L6.8 15.7L8.1 14.1L3.6 10.6L2.3 12.2Z" fill="white"/>
+<path fill-rule="evenodd" d="M3 11.4L7.5 8.0V10.4H16.5V8.0L21 11.4L16.5 14.9V12.4H7.5V14.9L3 11.4Z" fill="black"/>
+</g>
+</g>
+<defs>
+<filter id="f" x="-1.6" y="3.9" width="27.2" height="16.9" filterUnits="userSpaceOnUse">
+${filterStyle}
+</filter>
+</defs>
+</svg>
+`;
+const rotateSVG = `
+<svg width="24" height="24" xmlns="http://www.w3.org/2000/svg">
+<g filter="url(#f)">
+<g transform="rotate(135,12,12),rotate({{rotation}},12,12)">
+<path d="M20.4 8H21.4L20.8 7.1L17.3 2.6L17 2.1L16.6 2.6L13.1 7.1L12.5 8H13.5H15.4C14.9 11.8 11.8 14.9 8 15.4V13.5V12.5L7.1 13.1L2.6 16.6L2.1 17L2.6 17.3L7.1 20.8L8 21.4V20.4V18.4C13.5 17.9 17.9 13.5 18.4 8H20.4Z" stroke="white"/>
+<path fill-rule="evenodd" d="M17 3L20.4 7.5H17.9C17.7 13.1 13.1 17.7 7.5 17.9V20.4L3 17L7.5 13.5V15.9C12.0 15.7 15.7 12.0 15.9 7.5H13.5L17 3Z" fill="black"/>
+</g>
+</g>
+<defs>
+<filter id="f" x="-1.6" y="-0.6" width="27.1" height="27.1" filterUnits="userSpaceOnUse">
+${filterStyle}
+</filter>
+</defs>
+</svg>
+`;
+const skewSVG = `
+<svg width="24" height="24" xmlns="http://www.w3.org/2000/svg">
+<g filter="url(#f)">
+<g transform="rotate(90,12,12),rotate({{rotation}},12,12)">
+<path d="M21 10.4L21 11.4L23.8 11.4L21.6 9.6L21 10.4ZM17 10.4V11.4L17 11.4L17 10.4ZM15.5 6L16.1 5.2L14.5 3.9V6H15.5ZM15.5 8.4V9.4H16.5V8.4H15.5ZM6 8.4V7.4H5V8.4H6ZM6 10.4H5V11.4H6V10.4ZM7 14.4V13.4L7 13.4L7 14.4ZM3 14.4L3 13.4L0.1 13.4L2.3 15.2L3 14.4ZM8.5 18.9L7.8 19.7L9.5 21.0V18.9H8.5ZM8.5 16.4V15.4H7.5V16.4H8.5ZM19 16.4V17.4H20V16.4H19ZM19 14.4H20V13.4H19V14.4ZM21 9.4L17 9.4L17 11.4L21 11.4L21 9.4ZM14.8 6.7L20.3 11.2L21.6 9.6L16.1 5.2L14.8 6.7ZM16.5 8.4V6H14.5V8.4H16.5ZM6 9.4H15.5V7.4H6V9.4ZM7 10.4V8.4H5V10.4H7ZM15.5 9.4H6V11.4H15.5V9.4ZM17 9.4H15.5V11.4H17V9.4ZM7 15.4H8.5V13.4H7V15.4ZM3 15.4L7 15.4L7 13.4L3 13.4L3 15.4ZM9.1 18.1L3.6 13.6L2.3 15.2L7.8 19.7L9.1 18.1ZM7.5 16.4V18.9H9.5V16.4H7.5ZM19 15.4H8.5V17.4H19V15.4ZM18 14.4V16.4H20V14.4H18ZM8.5 15.4H19V13.4H8.5V15.4Z" fill="white"/>
+<path fill-rule="evenodd" d="M17 10.4L21 10.4L15.5 6V8.4H6V10.4H15.5H17ZM8.5 14.4H7L3 14.4L8.5 18.9V16.4H19V14.4H8.5Z" fill="black"/>
+</g>
+</g>
+<defs>
+<filter x="-2.8" y="1.9" width="29.6" height="23.1" filterUnits="userSpaceOnUse" >
+${filterStyle}
+</filter>
+</defs>
+</svg>
+`;
+
+const config = {
+    editSize: 'auto',
+    keyEvent: true,
+    stroke: '#836DFF',
+    strokeWidth: 2,
+    pointFill: '#FFFFFF',
+    pointSize: 10,
+    pointRadius: 16,
+    rotateGap: 45,
+    buttonsDirection: 'bottom',
+    buttonsMargin: 12,
+    hideOnSmall: true,
+    moveCursor: 'move',
+    resizeCursor: { url: resizeSVG, x: 12, y: 12 },
+    rotateCursor: { url: rotateSVG, x: 12, y: 12 },
+    skewCursor: { url: skewSVG, x: 12, y: 12 },
+    selector: true,
+    hover: true,
+    select: 'press',
+    boxSelect: true,
+    moveable: true,
+    resizeable: true,
+    rotateable: true,
+    skewable: true
 };
 
+class EditTool {
+    constructor() {
+        this.tag = 'EditTool';
+    }
+    onMove(e) {
+        const { moveX, moveY, editor } = e;
+        const { app, list } = editor;
+        app.lockLayout();
+        list.forEach(target => {
+            target.moveWorld(moveX, moveY);
+        });
+        app.unlockLayout();
+    }
+    onScale(e) {
+        const { scaleX, scaleY, transform, worldOrigin, editor } = e;
+        const { app, list } = editor;
+        app.lockLayout();
+        list.forEach(target => {
+            const resize = editor.getEditSize(target) === 'size';
+            if (transform) {
+                target.transformWorld(transform, resize);
+            }
+            else {
+                target.scaleOfWorld(worldOrigin, scaleX, scaleY, resize);
+            }
+        });
+        app.unlockLayout();
+    }
+    onRotate(e) {
+        const { rotation, transform, worldOrigin, editor } = e;
+        const { app, list } = editor;
+        app.lockLayout();
+        list.forEach(target => {
+            const resize = editor.getEditSize(target) === 'size';
+            if (transform) {
+                target.transformWorld(transform, resize);
+            }
+            else {
+                target.rotateOfWorld(worldOrigin, rotation);
+            }
+        });
+        app.unlockLayout();
+    }
+    onSkew(e) {
+        const { skewX, skewY, transform, worldOrigin, editor } = e;
+        const { app, list } = editor;
+        app.lockLayout();
+        list.forEach(target => {
+            const resize = editor.getEditSize(target) === 'size';
+            if (transform) {
+                target.transformWorld(transform, resize);
+            }
+            else {
+                target.skewOfWorld(worldOrigin, skewX, skewY, resize);
+            }
+        });
+        app.unlockLayout();
+    }
+    update(editor) {
+        const { simulateTarget, element } = editor;
+        if (editor.multiple)
+            simulateTarget.parent.updateLayout();
+        const { x, y, scaleX, scaleY, rotation, skewX, skewY, width, height } = element.getLayoutBounds('box', editor, true);
+        editor.editBox.set({ x, y, scaleX, scaleY, rotation, skewX, skewY });
+        editor.editBox.update({ x: 0, y: 0, width, height });
+    }
+}
+EditTool.list = [];
+
 const { left, right } = IDirection8;
-const LineTool = {
-    name: 'LineTool',
-    getMirrorData(_editor) {
-        return {
-            x: 0,
-            y: 0
-        };
-    },
-    resize(e) {
-        const { direction, dragEvent, lockRatio, around } = e;
+class LineEditTool extends EditTool {
+    constructor() {
+        super(...arguments);
+        this.tag = 'LineEditTool';
+        this.scaleOfEvent = true;
+    }
+    onScaleWithDrag(e) {
+        const { drag, direction, lockRatio, around } = e;
         const target = e.target;
-        const fromPoint = { x: 0, y: 0 };
+        const fromPoint = getPointData();
         const { toPoint } = target;
         target.rotation = 0;
-        let { x, y } = dragEvent.getInnerMove(target);
+        let { x, y } = drag.getInnerMove(target);
         if (lockRatio) {
             if (Math.abs(x) > Math.abs(y)) {
                 y = 0;
@@ -293,218 +1168,363 @@ const LineTool = {
         target.y = fromPoint.y;
         target.getInnerPointByLocal(toPoint, null, null, true);
         target.toPoint = toPoint;
-    },
-    rotate(e) {
-        RectTool.rotate(e);
-    },
+    }
+    onSkew(_e) {
+    }
     update(editor) {
-        const { rotatePoints, circle, resizeLines, resizePoints } = editor;
-        RectTool.update(editor);
+        const { rotatePoints, resizeLines, resizePoints } = editor.editBox;
+        super.update(editor);
         for (let i = 0; i < 8; i++) {
             if (i < 4)
                 resizeLines[i].visible = false;
-            resizePoints[i].visible = rotatePoints[i].visible = i === left || i === right;
+            resizePoints[i].visible = rotatePoints[i].visible = (i === left || i === right);
         }
-        circle.visible = false;
     }
-};
+}
 
-class EditorResizeEvent extends Event {
-    constructor(type, data) {
-        super(type);
-        if (data)
-            Object.assign(this, data);
+function getEditTool(list) {
+    if (list.length === 1) {
+        const leaf = list[0];
+        if (leaf instanceof Line$1 && !leaf.points) {
+            return new LineEditTool();
+        }
+        else {
+            return new EditTool();
+        }
+    }
+    else {
+        return new EditTool();
     }
 }
-EditorResizeEvent.RESIZE = 'editor.resize';
 
-class EditorRotateEvent extends Event {
-    constructor(type, data) {
-        super(type);
-        if (data)
-            Object.assign(this, data);
+function simulate(editor) {
+    const { simulateTarget, leafList: targetList } = editor;
+    const { x, y, width, height } = new Bounds().setListWithFn(targetList.list, (leaf) => leaf.worldBoxBounds);
+    const parent = simulateTarget.parent = targetList.list[0].leafer.zoomLayer;
+    const { scaleX, scaleY, e: worldX, f: worldY } = parent.__world;
+    simulateTarget.reset({ x: (x - worldX) / scaleX, y: (y - worldY) / scaleY, width: width / scaleX, height: height / scaleY });
+}
+
+function onTarget(editor, oldValue) {
+    const { target } = editor;
+    if (target) {
+        editor.leafList = target instanceof LeafList ? target : new LeafList(target instanceof Array ? target : target);
+    }
+    else {
+        editor.leafList.reset();
+    }
+    editor.emitEvent(new EditorEvent(EditorEvent.SELECT, { editor, value: target, oldValue }));
+    if (editor.hasTarget) {
+        editor.waitLeafer(() => {
+            if (editor.multiple)
+                simulate(editor);
+            updateMoveCursor(editor);
+            editor.updateEditTool();
+            editor.update();
+            editor.listenTargetEvents();
+        });
+    }
+    else {
+        editor.removeTargetEvents();
     }
 }
-EditorRotateEvent.ROTATE = 'editor.rotate';
+function onHover(editor, oldValue) {
+    editor.emitEvent(new EditorEvent(EditorEvent.HOVER, { editor, value: editor.hoverTarget, oldValue }));
+}
 
-class Editor extends Group {
-    get target() { return this._target; }
-    set target(value) {
-        this.__removeTargetEvents();
-        this.visible = !!value;
-        this._target = value;
-        if (value)
-            this.onTarget();
+const order = (a, b) => a.parent.children.indexOf(a) - b.parent.children.indexOf(b);
+const reverseOrder = (a, b) => b.parent.children.indexOf(b) - a.parent.children.indexOf(a);
+const EditorHelper = {
+    group(list, element, userGroup) {
+        list.sort(reverseOrder);
+        const { app, parent } = list[0];
+        let group;
+        if (userGroup && userGroup.add) {
+            group = userGroup;
+        }
+        else {
+            group = new Group$1(userGroup);
+        }
+        parent.addAt(group, parent.children.indexOf(list[0]));
+        list.sort(order);
+        const matrx = new Matrix(element.worldTransform);
+        matrx.divideParent(parent.worldTransform);
+        group.setTransform(matrx);
+        group.editable = true;
+        group.hitChildren = false;
+        app.lockLayout();
+        list.forEach(child => child.dropTo(group));
+        app.unlockLayout();
+        return group;
+    },
+    ungroup(list) {
+        const { app } = list[0];
+        const ungroupList = [];
+        app.lockLayout();
+        list.forEach(leaf => {
+            if (leaf.isBranch) {
+                const { parent, children } = leaf;
+                while (children.length) {
+                    ungroupList.push(children[0]);
+                    children[0].dropTo(parent, parent.children.indexOf(leaf));
+                }
+                leaf.remove();
+            }
+            else {
+                ungroupList.push(leaf);
+            }
+        });
+        app.unlockLayout();
+        return ungroupList;
+    },
+    toTop(list) {
+        list.sort(order);
+        list.forEach(leaf => {
+            if (leaf.parent)
+                leaf.parent.add(leaf);
+        });
+    },
+    toBottom(list) {
+        list.sort(reverseOrder);
+        list.forEach(leaf => {
+            if (leaf.parent)
+                leaf.parent.addAt(leaf, 0);
+        });
     }
+};
+
+class Editor extends Group$1 {
+    get list() { return this.leafList.list; }
+    get hasTarget() { return !!this.list.length; }
+    get multiple() { return this.list.length > 1; }
+    get single() { return this.list.length === 1; }
+    get element() { return this.multiple ? this.simulateTarget : this.list[0]; }
+    get buttons() { return this.editBox.buttons; }
+    get dragging() { return this.editBox.dragging; }
     constructor(userConfig, data) {
         super(data);
-        this.config = {
-            type: 'pc',
-            stroke: '#836DFF',
-            pointFill: '#FFFFFF',
-            pointSize: 10,
-            pointRadius: 10,
-            rotateGap: 90,
-            hideOnMove: false,
-            moveCursor: 'move',
-            resizeType: 'auto',
-            resizeCursor: ['nwse-resize', 'ns-resize', 'nesw-resize', 'ew-resize', 'nwse-resize', 'ns-resize', 'nesw-resize', 'ew-resize'],
-            rotateCursor: ['ne-resize', 'e-resize', 'se-resize', 's-resize', 'sw-resize', 'w-resize', 'nw-resize', 'n-resize'],
-            resizeable: true,
-            rotateable: true
-        };
-        this.resizePoints = [];
-        this.rotatePoints = [];
-        this.resizeLines = [];
-        this.targetRect = new Rect({ hitFill: 'all', hitRadius: 5 });
-        this.rect = new Polygon({ hittable: false, strokeAlign: 'center' });
-        this.circle = new Rect({ around: 'center', hitRadius: 10 });
-        this.__eventIds = [];
-        this.__targetEventIds = [];
+        this.config = config;
+        this.leafList = new LeafList();
+        this.simulateTarget = new Rect({ visible: false });
+        this.editBox = new EditBox(this);
+        this.selector = new EditSelect(this);
+        this.targetEventIds = [];
         if (userConfig)
             this.config = DataHelper.default(userConfig, this.config);
-        this.init();
+        this.addMany(this.selector, this.editBox);
     }
-    init() {
-        let rotatePoint, resizeLine, resizePoint;
-        const { resizePoints, rotatePoints, resizeLines } = this;
-        for (let i = 0; i < 8; i++) {
-            rotatePoint = new Rect({ around: 'center', width: 30, height: 30, hitRadius: 10, hitFill: "all" });
-            rotatePoints.push(rotatePoint);
-            this.__listenPointEvents(rotatePoint, 'rotate', i);
-            if (i % 2) {
-                resizeLine = new Rect({ around: 'center', width: 10, height: 10, hitFill: "all" });
-                resizeLines.push(resizeLine);
-                this.__listenPointEvents(resizeLine, 'resize', i);
-            }
-            resizePoint = new Rect({ around: 'center', hitRadius: 5 });
-            resizePoints.push(resizePoint);
-            this.__listenPointEvents(resizePoint, 'resize', i);
-        }
-        this.__listenPointEvents(this.circle, 'rotate', 1);
-        this.addMany(...rotatePoints, this.targetRect, this.rect, this.circle, ...resizeLines, ...resizePoints);
-        this.__listenEvents();
+    hasItem(item) {
+        return this.leafList.has(item);
     }
-    onTarget() {
-        this.tool = this.getTool(this.target);
-        this.waitLeafer(() => {
-            this.update();
-            this.updateMoveCursor();
-            this.__listenTargetEvents();
-        });
+    addItem(item) {
+        if (!this.hasItem(item) && !item.locked)
+            this.leafList.add(item), this.target = this.leafList.list;
     }
-    getTool(value) {
-        return (value.tag === 'Line' && value.resizeable) ? LineTool : RectTool;
+    removeItem(item) {
+        if (this.hasItem(item))
+            this.leafList.remove(item), this.target = this.leafList.list;
     }
-    update() {
-        if (!this.target)
-            return;
-        this.tool.update(this);
+    shiftItem(item) {
+        this.hasItem(item) ? this.removeItem(item) : this.addItem(item);
     }
-    onDrag(e) {
-        const { resizeable, rotateable } = this.config;
-        if (e.metaKey || e.ctrlKey || !resizeable) {
-            if (rotateable)
-                this.onRotate(e);
-        }
-        else {
-            this.onResize(e);
+    update() {
+        if (this.hasTarget) {
+            if (this.editTool)
+                this.editTool.update(this);
+            this.selector.update();
         }
     }
+    updateEditTool() {
+        this.editTool = getEditTool(this.list);
+    }
+    getEditSize(ui) {
+        let { editSize } = this.config;
+        return editSize === 'auto' ? ui.editSize : editSize;
+    }
     onMove(e) {
-        const { target } = this;
-        const { x, y } = e.getLocalMove(target);
-        if (e.shiftKey) {
-            if (Math.abs(x) > Math.abs(y)) {
-                target.x += x;
-            }
-            else {
-                target.y += y;
-            }
+        const move = e.getLocalMove(this.element);
+        const { lockMove } = this.config;
+        if (lockMove === 'x')
+            move.y = 0;
+        else if (lockMove === 'y')
+            move.x = 0;
+        else if (e.shiftKey) {
+            if (Math.abs(move.x) > Math.abs(move.y))
+                move.y = 0;
+            else
+                move.x = 0;
+        }
+        this.move(move.x, move.y);
+    }
+    onScale(e) {
+        const { element } = this;
+        const { direction } = e.current;
+        let { around, lockRatio } = this.config;
+        if (e.shiftKey)
+            lockRatio = true;
+        const data = EditDataHelper.getScaleData(element.boxBounds, direction, e.getInnerMove(element), lockRatio, EditDataHelper.getAround(around, e.altKey));
+        if (this.editTool.onScaleWithDrag) {
+            data.drag = e;
+            this.scaleWithDrag(data);
         }
         else {
-            target.x += x;
-            target.y += y;
+            this.scaleOf(data.origin, data.scaleX, data.scaleY);
         }
     }
     onRotate(e) {
-        const { target } = this;
-        const { rotateGap } = this.config;
-        const { x, y, width, height } = target.boxBounds;
-        const origin = { x: x + width / 2, y: y + height / 2 };
-        let rotation;
+        const { skewable, around, rotateGap } = this.config;
+        const { direction, name } = e.current;
+        if (skewable && name === 'resize-line')
+            return this.onSkew(e);
+        const { element } = this;
+        let origin, rotation;
         if (e instanceof RotateEvent) {
-            rotation = e.rotation;
+            rotation = e.rotation, origin = element.getInnerPoint(e);
         }
         else {
-            const point = e;
-            const last = { x: point.x - e.moveX, y: point.y - e.moveY };
-            rotation = PointHelper.getChangeAngle(last, target.getWorldPoint(origin), point);
-        }
-        rotation = MathHelper.getGapRotation(target.rotation + rotation, rotateGap) - target.rotation;
-        const event = new EditorRotateEvent(EditorRotateEvent.ROTATE, { editor: this, target, origin, rotation });
-        this.tool.rotate(event);
-        target.emitEvent(event);
-    }
-    onResize(e) {
-        const { target } = this;
-        const { __direction } = e.current.__;
-        let { resizeType, around, lockRatio } = this.config;
-        if (e.shiftKey)
-            lockRatio = true;
-        if (e.altKey && !around)
-            around = 'center';
-        if (resizeType === 'auto')
-            resizeType = target.resizeable ? 'size' : 'scale';
-        const data = getResizeData(target.boxBounds, __direction, e.getInnerMove(this.targetRect), lockRatio, around);
-        const event = new EditorResizeEvent(EditorResizeEvent.RESIZE, Object.assign(Object.assign({}, data), { target, editor: this, dragEvent: e, resizeType }));
-        this.tool.resize(event);
-        target.emitEvent(event);
-    }
-    updateMoveCursor() {
-        this.targetRect.cursor = this.config.moveCursor;
+            const last = { x: e.x - e.moveX, y: e.y - e.moveY };
+            const data = EditDataHelper.getRotateData(element.boxBounds, direction, e.getInner(element), element.getInnerPoint(last), e.shiftKey ? null : (around || 'center'));
+            rotation = data.rotation;
+            origin = data.origin;
+        }
+        rotation = MathHelper.getGapRotation(rotation, rotateGap, element.rotation);
+        if (!rotation)
+            return;
+        if (element.scaleX * element.scaleY < 0)
+            rotation = -rotation;
+        this.rotateOf(origin, MathHelper.float(rotation, 2));
     }
-    __listenEvents() {
-        this.__eventIds = [
-            this.targetRect.on_(DragEvent.START, () => { this.opacity = this.config.hideOnMove ? 0 : 1; }),
-            this.targetRect.on_(DragEvent.DRAG, this.onMove, this),
-            this.targetRect.on_(DragEvent.END, () => { this.opacity = 1; }),
-            this.targetRect.on_(PointerEvent.ENTER, this.updateMoveCursor, this)
-        ];
+    onSkew(e) {
+        const { element } = this;
+        const { around } = this.config;
+        const { origin, skewX, skewY } = EditDataHelper.getSkewData(element.boxBounds, e.current.direction, e.getInnerMove(element), EditDataHelper.getAround(around, e.altKey));
+        if (!skewX && !skewY)
+            return;
+        this.skewOf(origin, skewX, skewY);
     }
-    __removeListenEvents() {
-        this.targetRect.off_(this.__eventIds);
-        this.__eventIds.length = 0;
+    move(x, y) {
+        if (!this.config.moveable)
+            return;
+        const { element } = this;
+        const world = element.getWorldPointByLocal({ x, y }, null, true);
+        const event = new EditorMoveEvent(EditorMoveEvent.MOVE, { target: element, editor: this, moveX: world.x, moveY: world.y });
+        this.editTool.onMove(event);
+        this.emitEvent(event);
+        if (this.multiple)
+            element.move(x, y);
     }
-    __listenPointEvents(point, type, direction) {
-        point.__.__direction = direction;
-        const resize = point.__.__isResizePoint = type === 'resize';
-        point.on_(DragEvent.DRAG, resize ? this.onDrag : this.onRotate, this);
-        point.on_(PointerEvent.LEAVE, () => this.enterPoint = null);
-        point.on_(PointerEvent.ENTER, (e) => { this.enterPoint = point; updateCursor(this, e); });
+    scaleWithDrag(data) {
+        const { element } = this;
+        const worldOrigin = element.getWorldPoint(data.origin);
+        const event = new EditorScaleEvent(EditorScaleEvent.SCALE, Object.assign(Object.assign({}, data), { target: element, editor: this, worldOrigin }));
+        this.editTool.onScaleWithDrag(event);
+        this.emitEvent(event);
+    }
+    scaleOf(origin, scaleX, scaleY = scaleX, _resize) {
+        const { element } = this;
+        const worldOrigin = element.getWorldPoint(origin);
+        let transform;
+        if (this.multiple) {
+            const oldMatrix = new Matrix(element.worldTransform);
+            element.scaleOf(origin, scaleX, scaleY);
+            transform = new Matrix(element.worldTransform).divide(oldMatrix);
+        }
+        const event = new EditorScaleEvent(EditorScaleEvent.SCALE, { target: element, editor: this, worldOrigin, scaleX, scaleY, transform });
+        this.editTool.onScale(event);
+        this.emitEvent(event);
+    }
+    rotateOf(origin, rotation) {
+        const { element } = this;
+        const worldOrigin = element.getWorldPoint(origin);
+        let transform;
+        if (this.multiple) {
+            const oldMatrix = new Matrix(element.worldTransform);
+            element.rotateOf(origin, rotation);
+            transform = new Matrix(element.worldTransform).divide(oldMatrix);
+        }
+        const event = new EditorRotateEvent(EditorRotateEvent.ROTATE, { target: element, editor: this, worldOrigin, rotation, transform });
+        this.editTool.onRotate(event);
+        this.emitEvent(event);
+    }
+    skewOf(origin, skewX, skewY = 0, _resize) {
+        const { element } = this;
+        const worldOrigin = element.getWorldPoint(origin);
+        let transform;
+        if (this.multiple) {
+            const oldMatrix = new Matrix(element.worldTransform);
+            element.skewOf(origin, skewX, skewY);
+            transform = new Matrix(element.worldTransform).divide(oldMatrix);
+        }
+        const event = new EditorSkewEvent(EditorSkewEvent.SKEW, {
+            target: element, editor: this, skewX, skewY, transform, worldOrigin
+        });
+        this.editTool.onSkew(event);
+        this.emitEvent(event);
+    }
+    group(userGroup) {
+        if (this.multiple)
+            this.target = EditorHelper.group(this.list, this.element, userGroup);
+        return this.target;
+    }
+    ungroup() {
+        if (this.list.length)
+            this.target = EditorHelper.ungroup(this.list);
+        return this.list;
     }
-    __listenTargetEvents() {
-        if (this.target) {
-            const { leafer } = this.target;
-            this.__targetEventIds = [
+    lock() {
+        this.list.forEach(leaf => leaf.locked = true);
+        this.update();
+    }
+    unlock() {
+        this.list.forEach(leaf => leaf.locked = false);
+        this.update();
+    }
+    toTop() {
+        if (this.list.length) {
+            EditorHelper.toTop(this.list);
+            this.leafList.update();
+        }
+    }
+    toBottom() {
+        if (this.list.length) {
+            EditorHelper.toBottom(this.list);
+            this.leafList.update();
+        }
+    }
+    listenTargetEvents() {
+        if (!this.targetEventIds.length) {
+            const { leafer } = this.list[0];
+            this.targetEventIds = [
                 leafer.on_(RenderEvent.START, this.update, this),
-                leafer.on_([KeyEvent.HOLD, KeyEvent.UP], (e) => { updateCursor(this, e); })
+                leafer.on_([KeyEvent.HOLD, KeyEvent.UP], (e) => { updateCursor(this, e); }),
+                leafer.on_(KeyEvent.DOWN, this.editBox.onArrow, this.editBox)
             ];
         }
     }
-    __removeTargetEvents() {
-        if (this.__targetEventIds.length) {
-            const { leafer } = this.target;
-            if (leafer)
-                leafer.off_(this.__targetEventIds);
-            this.__targetEventIds.length = 0;
+    removeTargetEvents() {
+        const { targetEventIds } = this;
+        if (targetEventIds.length) {
+            this.off_(targetEventIds);
+            targetEventIds.length = 0;
         }
     }
     destroy() {
-        this.__removeListenEvents();
-        this._target = null;
-        super.destroy();
+        if (!this.destroyed) {
+            this.simulateTarget.destroy();
+            this.target = this.hoverTarget = this.simulateTarget = null;
+            super.destroy();
+        }
     }
 }
+__decorate([
+    targetAttr(onHover)
+], Editor.prototype, "hoverTarget", void 0);
+__decorate([
+    targetAttr(onTarget)
+], Editor.prototype, "target", void 0);
+
+Creator.editor = function (options) {
+    return new Editor(options);
+};
 
-export { Editor, EditorResizeEvent, EditorRotateEvent, LineTool, RectTool };
+export { EditBox, EditDataHelper, EditPoint, EditSelect, EditSelectHelper, EditTool, Editor, EditorEvent, EditorHelper, EditorMoveEvent, EditorRotateEvent, EditorScaleEvent, EditorSkewEvent, LineEditTool, SelectArea, Stroker };