@plait/common 0.53.0 → 0.55.0

package/fesm2022/plait-common.mjs

@@ -1,4 +1,4 @@
-import { setAngleForG, RectangleClient, drawCircle, PlaitBoard, createG, drawRectangle, createForeignObject, updateForeignObject, ResizeCursorClass, RESIZE_CURSORS, setDragging, rotatePoints, distanceBetweenPointAndPoint, Point, Direction, hotkeys, PlaitElement, PlaitContextService, getSelectedElements, Transforms, getHighestSelectedElements, getRectangleByElements, PlaitGroupElement, getElementsInGroup, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, ACTIVE_STROKE_WIDTH, getRectangleByGroup, PlaitPluginElementComponent, isSelectionMoving, isSelectedElementOrGroup, Selection, getHitElementsBySelection, createGroupRectangleG, getSelectedGroups, getHighestSelectedGroups, getSelectedIsolatedElements, idCreator, GroupTransforms, getSelectedIsolatedElementsCanAddToGroup, getGroupByElement } from '@plait/core';
+import { PlaitGroupElement, getSelectionAngle, getElementsInGroup, setAngleForG, RectangleClient, drawCircle, PlaitBoard, RESIZE_HANDLE_CLASS_NAME, createG, setStrokeLinecap, drawRectangle, SELECTION_RECTANGLE_CLASS_NAME, createForeignObject, updateForeignObject, ResizeCursorClass, RESIZE_CURSORS, setDragging, rotatePoints, distanceBetweenPointAndPoint, Point, Direction, hotkeys, PlaitElement, PlaitContextService, createDebugGenerator, getSelectedElements, Transforms, getHighestSelectedElements, getRectangleByElements, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, ACTIVE_STROKE_WIDTH, getRectangleByGroup, PlaitPluginElementComponent, isSelectionMoving, isSelectedElementOrGroup, Selection, getHitElementsBySelection, createGroupRectangleG, getSelectedGroups, getHighestSelectedGroups, getSelectedIsolatedElements, idCreator, getSelectedIsolatedElementsCanAddToGroup, getGroupByElement } from '@plait/core';
 import { isKeyHotkey } from 'is-hotkey';
 import { PlaitMarkEditor, MarkTypes, AlignEditor } from '@plait/text';
 import { Node, Transforms as Transforms$1, Editor } from 'slate';
@@ -11,6 +11,8 @@ const RESIZE_HANDLE_DIAMETER = 9;
 const WithTextPluginKey = 'plait-text-plugin-key';
 const DEFAULT_ROUTE_MARGIN = 30;
 const TRANSPARENT = 'transparent';
+const ROTATE_HANDLE_DISTANCE_TO_ELEMENT = 20;
+const ROTATE_HANDLE_SIZE = 18;
 
 var MediaKeys;
 (function (MediaKeys) {
@@ -54,8 +56,17 @@ class Generator {
                 }
                 this.g = g;
                 const rect = this.board.getRectangle(element);
-                if (rect && element.angle) {
-                    setAngleForG(g, RectangleClient.getCenterPoint(rect), element.angle);
+                if (rect) {
+                    let angle;
+                    if (PlaitGroupElement.isGroup(element)) {
+                        angle = getSelectionAngle(getElementsInGroup(this.board, element, true));
+                    }
+                    else {
+                        angle = element.angle;
+                    }
+                    if (angle) {
+                        setAngleForG(g, RectangleClient.getCenterPoint(rect), angle);
+                    }
                 }
             }
             else {
@@ -85,7 +96,9 @@ function hasAfterDraw(value) {
 
 const drawHandle = (board, centerPoint) => {
     const options = { stroke: '#99999995', strokeWidth: 2, fill: '#FFF', fillStyle: 'solid' };
-    return drawCircle(PlaitBoard.getRoughSVG(board), centerPoint, RESIZE_HANDLE_DIAMETER, options);
+    const handleG = drawCircle(PlaitBoard.getRoughSVG(board), centerPoint, RESIZE_HANDLE_DIAMETER, options);
+    handleG.classList.add(RESIZE_HANDLE_CLASS_NAME);
+    return handleG;
 };
 function drawFillPrimaryHandle(board, point) {
     return drawCircle(PlaitBoard.getRoughSVG(board), point, RESIZE_HANDLE_DIAMETER, {
@@ -104,6 +117,26 @@ function drawPrimaryHandle(board, point) {
     });
 }
 
+const rotateHandleRadius = 6;
+const drawRotateHandle = (board, rectangle) => {
+    const options = { stroke: '#333', strokeWidth: 1, fillStyle: 'solid' };
+    const handleCenterPoint = [
+        rectangle.x - ROTATE_HANDLE_DISTANCE_TO_ELEMENT - ROTATE_HANDLE_SIZE / 2,
+        rectangle.y + rectangle.height + ROTATE_HANDLE_DISTANCE_TO_ELEMENT + ROTATE_HANDLE_SIZE / 2
+    ];
+    const rs = PlaitBoard.getRoughSVG(board);
+    const handleG = createG();
+    const line = rs.path(`M ${handleCenterPoint[0] + rotateHandleRadius} ${handleCenterPoint[1]} A ${rotateHandleRadius} ${rotateHandleRadius}, 0, 1, 0, ${handleCenterPoint[0]} ${handleCenterPoint[1] + rotateHandleRadius}`, options);
+    const arrow = rs.polygon([
+        [handleCenterPoint[0], handleCenterPoint[1] + rotateHandleRadius - 2],
+        [handleCenterPoint[0], handleCenterPoint[1] + rotateHandleRadius + 2],
+        [handleCenterPoint[0] + 4.5, handleCenterPoint[1] + rotateHandleRadius]
+    ], { ...options, fill: '#333' });
+    setStrokeLinecap(arrow, 'round');
+    handleG.append(line, arrow);
+    return handleG;
+};
+
 class ActiveGenerator extends Generator {
     constructor(board, options) {
         super(board, options);
@@ -129,6 +162,7 @@ class ActiveGenerator extends Generator {
             strokeWidth: delta
         });
         activeG.append(strokeG);
+        strokeG.classList.add(SELECTION_RECTANGLE_CLASS_NAME);
         strokeG.style.opacity = `${this.options.getStrokeOpacity()}`;
         if (this.options.hasResizeHandle()) {
             this.hasResizeHandle = true;
@@ -240,7 +274,7 @@ const getRotatedResizeCursorClassByAngle = (cursor, angle) => {
     }
     return cursor;
 };
-const getRectangleResizeHandleRefs = (rectangle, diameter, angle = 0) => {
+const getRectangleResizeHandleRefs = (rectangle, diameter) => {
     const corners = RectangleClient.getCornerPoints(rectangle);
     const refs = corners.map((corner, index) => {
         return {
@@ -251,7 +285,7 @@ const getRectangleResizeHandleRefs = (rectangle, diameter, angle = 0) => {
                 height: diameter
             },
             handle: getResizeHandleByIndex(index),
-            cursorClass: getRotatedResizeCursorClassByAngle(getResizeCursorClassByIndex(index), angle)
+            cursorClass: getResizeCursorClassByIndex(index)
         };
     });
     const rectangles = getResizeSideRectangles(corners, diameter / 2);
@@ -259,7 +293,7 @@ const getRectangleResizeHandleRefs = (rectangle, diameter, angle = 0) => {
         return {
             rectangle,
             handle: getResizeHandleByIndex(index + 4),
-            cursorClass: getRotatedResizeCursorClassByAngle(getResizeCursorClassByIndex(index + 4), angle)
+            cursorClass: getResizeCursorClassByIndex(index + 4)
         };
     }));
     return refs;
@@ -917,7 +951,8 @@ class PointGraph {
     }
 }
 
-const generateElbowLineRoute = (options) => {
+const debugGenerator = createDebugGenerator('debug:plait:elbow-line-routing');
+const generateElbowLineRoute = (options, board) => {
     const { nextSourcePoint, nextTargetPoint } = options;
     const points = getGraphPoints(options);
     const graph = createGraph(points);
@@ -935,15 +970,18 @@ const generateElbowLineRoute = (options) => {
     const isHitY = RectangleClient.isHitY(options.sourceOuterRectangle, options.targetOuterRectangle);
     const centerX = isHitX ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, true);
     const centerY = isHitY ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, false);
-    route = routeAdjust(route, { centerX, centerY, sourceRectangle: options.sourceRectangle, targetRectangle: options.targetRectangle });
+    route = routeAdjust(route, { centerX, centerY, sourceRectangle: options.sourceRectangle, targetRectangle: options.targetRectangle }, board);
     return route;
 };
-const routeAdjust = (path, options) => {
+const routeAdjust = (path, options, board) => {
     const { sourceRectangle, targetRectangle, centerX, centerY } = options;
+    if (board) {
+        debugGenerator.clear();
+    }
     if (centerX !== undefined) {
         const optionsX = getAdjustOptions(path, centerX, true);
         const resultX = optionsX.pointOfHit &&
-            adjust(path, { parallelPaths: optionsX.parallelPaths, pointOfHit: optionsX.pointOfHit, sourceRectangle, targetRectangle });
+            adjust(path, { parallelPaths: optionsX.parallelPaths, pointOfHit: optionsX.pointOfHit, sourceRectangle, targetRectangle }, board);
         if (resultX) {
             path = resultX;
         }
@@ -951,14 +989,14 @@ const routeAdjust = (path, options) => {
     if (centerY !== undefined) {
         const optionsY = getAdjustOptions(path, centerY, false);
         const resultY = optionsY.pointOfHit &&
-            adjust(path, { parallelPaths: optionsY.parallelPaths, pointOfHit: optionsY.pointOfHit, sourceRectangle, targetRectangle });
+            adjust(path, { parallelPaths: optionsY.parallelPaths, pointOfHit: optionsY.pointOfHit, sourceRectangle, targetRectangle }, board);
         if (resultY) {
             path = resultY;
         }
     }
     return path;
 };
-const adjust = (route, options) => {
+const adjust = (route, options, board) => {
     const { parallelPaths, pointOfHit, sourceRectangle, targetRectangle } = options;
     let result = null;
     parallelPaths.forEach(parallelPath => {
@@ -967,7 +1005,10 @@ const adjust = (route, options) => {
         // directly use getCornerPoints will bring the precision issue (eg: 263.6923375175286 - 57.130859375)
         const tempRect = RectangleClient.getRectangleByPoints(tempRectPoints);
         if (!RectangleClient.isHit(tempRect, sourceRectangle) && !RectangleClient.isHit(tempRect, targetRectangle)) {
-            const tempCorners = RectangleClient.getCornerPoints(tempRect);
+            const tempCorners = RectangleClient.getCornerPointsByPoints(tempRectPoints);
+            if (board) {
+                debugGenerator.drawRectangle(board, tempRect);
+            }
             const indexRangeInPath = [];
             const indexRangeInCorner = [];
             route.forEach((point, index) => {
@@ -982,7 +1023,11 @@ const adjust = (route, options) => {
             const removeLength = Math.abs(indexRangeInPath[0] - indexRangeInPath[indexRangeInPath.length - 1]) + 1;
             newPath.splice(indexRangeInPath[0] + 1, removeLength - 2, missCorner);
             const turnCount = simplifyOrthogonalPoints([...route]).length - 1;
-            const newTurnCount = simplifyOrthogonalPoints([...newPath]).length - 1;
+            const simplifyPoints = simplifyOrthogonalPoints([...newPath]);
+            // if (board) {
+            //     debugGenerator.drawLine(board, simplifyPoints);
+            // }
+            const newTurnCount = simplifyPoints.length - 1;
             if (newTurnCount <= turnCount) {
                 result = newPath;
             }
@@ -1168,6 +1213,21 @@ const getMemorizedLatest = (memorizedKey) => {
     return map.get(memorizedKey);
 };
 
+const IS_ROTATING = new WeakMap();
+const isRotating = (board) => {
+    return !!IS_ROTATING.get(board);
+};
+const addRotating = (board, rotateRef) => {
+    PlaitBoard.getBoardContainer(board).classList.add(`draw-elements-rotating`);
+    IS_ROTATING.set(board, rotateRef);
+    setDragging(board, true);
+};
+const removeRotating = (board) => {
+    PlaitBoard.getBoardContainer(board).classList.remove(`draw-elements-rotating`);
+    IS_ROTATING.delete(board);
+    setDragging(board, false);
+};
+
 const setProperty = (board, properties, options) => {
     const selectedElements = getSelectedElements(board);
     selectedElements.forEach(element => {
@@ -1546,9 +1606,8 @@ class CommonPluginElement extends PlaitPluginElementComponent {
 }
 
 class GroupComponent extends CommonPluginElement {
-    constructor(viewContainerRef, cdr) {
+    constructor(cdr) {
         super(cdr);
-        this.viewContainerRef = viewContainerRef;
         this.cdr = cdr;
     }
     initializeGenerator() {
@@ -1572,9 +1631,9 @@ class GroupComponent extends CommonPluginElement {
         const elementsInGroup = getElementsInGroup(this.board, value.element, false, true);
         const isPartialSelectGroup = elementsInGroup.some(item => isSelectedElementOrGroup(this.board, item)) &&
             !elementsInGroup.every(item => isSelectedElementOrGroup(this.board, item));
-        this.groupGenerator.processDrawing(value.element, this.g, isPartialSelectGroup);
+        this.groupGenerator.processDrawing(value.element, this.getElementG(), isPartialSelectGroup);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: GroupComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: GroupComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.4", type: GroupComponent, isStandalone: true, selector: "plait-group", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: GroupComponent, decorators: [{
@@ -1585,7 +1644,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImpor
                     changeDetection: ChangeDetectionStrategy.OnPush,
                     standalone: true
                 }]
-        }], ctorParameters: () => [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }] });
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
 
 function withGroup(board) {
     let groupRectangleG;
@@ -1616,50 +1675,53 @@ function withGroup(board) {
         groupRectangleG = null;
         globalPointerUp(event);
     };
-    board.getRelatedFragment = (elements) => {
-        const groups = getSelectedGroups(board);
-        return getRelatedFragment([...elements, ...groups]);
+    board.getRelatedFragment = (elements, originData) => {
+        const groups = getSelectedGroups(board, originData);
+        return getRelatedFragment([...elements, ...groups], originData);
     };
-    board.insertFragment = (data, clipboardData, targetPoint) => {
-        const elements = [];
+    board.insertFragment = (clipboardData, targetPoint) => {
+        let elements = [];
         if (clipboardData?.elements?.length) {
+            elements = new Array(clipboardData?.elements?.length);
             const groups = getHighestSelectedGroups(board, clipboardData?.elements);
             const selectedIsolatedElements = getSelectedIsolatedElements(board, clipboardData?.elements);
             selectedIsolatedElements.forEach(item => {
-                elements.push(!item.groupId ? item : updateGroupId(item, undefined));
+                const index = clipboardData.elements.map(element => element.id).indexOf(item.id);
+                elements.splice(index, 1, !item.groupId ? item : updateGroupId(item, undefined));
             });
             if (groups.length) {
                 groups.forEach(item => {
+                    const index = clipboardData.elements.map(element => element.id).indexOf(item.id);
                     const newGroup = { ...updateGroupId(item, undefined), id: idCreator() };
-                    elements.push(newGroup);
-                    elements.push(...updateElementsGroupId(item, clipboardData.elements, newGroup.id));
+                    elements.splice(index, 1, newGroup);
+                    updateElementsGroupId(item, clipboardData.elements, newGroup.id, elements);
                 });
             }
             clipboardData.elements = elements;
         }
-        insertFragment(data, clipboardData, targetPoint);
+        insertFragment(clipboardData, targetPoint);
         const groupElements = elements?.filter(value => PlaitGroupElement.isGroup(value));
         groupElements.forEach(element => {
             Transforms.insertNode(board, element, [board.children.length]);
         });
     };
     board.getDeletedFragment = (data) => {
+        removeGroups = getRemoveGroups(board);
         if (removeGroups && removeGroups.length) {
             data.push(...removeGroups);
         }
         return getDeletedFragment(data);
     };
-    board.deleteFragment = (data) => {
-        removeGroups = getRemoveGroups(board);
+    board.deleteFragment = (elements) => {
         if (removeGroups?.length) {
             updateSiblingElementGroupId(board, removeGroups);
         }
-        deleteFragment(data);
+        deleteFragment(elements);
         removeGroups = null;
     };
     board.getRectangle = (element) => {
         if (PlaitGroupElement.isGroup(element)) {
-            return getRectangleByGroup(board, element);
+            return getRectangleByGroup(board, element, true);
         }
         return getRectangle(element);
     };
@@ -1667,12 +1729,12 @@ function withGroup(board) {
         if (!PlaitBoard.isReadonly(board)) {
             if (isKeyHotkey('mod+g', event)) {
                 event.preventDefault();
-                GroupTransforms.addGroup(board);
+                Transforms.addGroup(board);
                 return;
             }
             if (isKeyHotkey('mod+shift+g', event)) {
                 event.preventDefault();
-                GroupTransforms.removeGroup(board);
+                Transforms.removeGroup(board);
                 return;
             }
         }
@@ -1686,18 +1748,18 @@ const updateGroupId = (element, groupId) => {
         groupId: groupId
     };
 };
-const updateElementsGroupId = (group, clipboardDataElements, newGroupId) => {
-    const elements = [];
+const updateElementsGroupId = (group, clipboardDataElements, newGroupId, elements) => {
     const elementsInGroup = clipboardDataElements.filter(item => item.groupId === group.id);
     if (elementsInGroup.length) {
         elementsInGroup.forEach(item => {
+            const index = clipboardDataElements.map(item => item.id).indexOf(item.id);
             if (PlaitGroupElement.isGroup(item)) {
                 const newGroup = { ...updateGroupId(item, newGroupId), id: idCreator() };
-                elements.push(newGroup);
-                elements.push(...updateElementsGroupId(item, clipboardDataElements, newGroup.id));
+                elements.splice(index, 1, newGroup);
+                updateElementsGroupId(item, clipboardDataElements, newGroup.id, elements);
             }
             else {
-                elements.push(updateGroupId(item, newGroupId));
+                elements.splice(index, 1, updateGroupId(item, newGroupId));
             }
         });
     }
@@ -1870,5 +1932,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AStar, ActiveGenerator, AlignTransform, BASE, BoardCreationMode, CommonPluginElement, DEFAULT_ROUTE_MARGIN, Generator, IS_RESIZING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ResizeHandle, TRANSPARENT, TextTransforms, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, buildImage, calculatePolylineLength, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByDirectionComponent, getElementOfFocusedImage, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByVectorComponent, getPointByVectorDirectionComponent, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getRotatedResizeCursorClassByAngle, getSourceAndTargetOuterRectangle, getSymmetricHandleIndex, getTextEditors, getTextManages, getTextMarksByElement, getUnitVectorByPointAndPoint, hasAfterDraw, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isPointOnSegment, isResizing, isResizingByCondition, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, memorizeLatest, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, resetPointsAfterResize, rotateVector, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withGroup, withResize };
+export { AStar, ActiveGenerator, AlignTransform, BASE, BoardCreationMode, CommonPluginElement, DEFAULT_ROUTE_MARGIN, Generator, IS_RESIZING, IS_ROTATING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, ResizeHandle, TRANSPARENT, TextTransforms, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, addRotating, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, buildImage, calculatePolylineLength, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, drawRotateHandle, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByDirectionComponent, getElementOfFocusedImage, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByVectorComponent, getPointByVectorDirectionComponent, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getRotatedResizeCursorClassByAngle, getSourceAndTargetOuterRectangle, getSymmetricHandleIndex, getTextEditors, getTextManages, getTextMarksByElement, getUnitVectorByPointAndPoint, hasAfterDraw, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isPointOnSegment, isResizing, isResizingByCondition, isRotating, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, memorizeLatest, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, removeRotating, resetPointsAfterResize, rotateVector, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withGroup, withResize };
 //# sourceMappingURL=plait-common.mjs.map