@plait/common 0.51.1 → 0.51.3

package/fesm2022/plait-common.mjs

@@ -1,4 +1,4 @@
-import { setTransformRotate, drawCircle, PlaitBoard, createG, RectangleClient, drawRectangle, createForeignObject, updateForeignObject, ResizeCursorClass, setDragging, Direction, distanceBetweenPointAndPoint, Point, hotkeys, PlaitElement, PlaitContextService, getSelectedElements, Transforms, getRectangleByElements, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
+import { setAngleForG, RectangleClient, drawCircle, PlaitBoard, createG, drawRectangle, createForeignObject, updateForeignObject, ResizeCursorClass, setDragging, distanceBetweenPointAndPoint, Point, Direction, hotkeys, PlaitElement, PlaitContextService, rotate, getSelectedElements, Transforms, getRectangleByElements, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
 import { isKeyHotkey } from 'is-hotkey';
 import { PlaitMarkEditor, MarkTypes, AlignEditor } from '@plait/text';
 import { Node, Transforms as Transforms$1, Editor } from 'slate';
@@ -55,7 +55,7 @@ class Generator {
                 this.g = g;
                 const rect = this.board.getRectangle(element);
                 if (rect && element.angle) {
-                    setTransformRotate(g, rect, element.angle);
+                    setAngleForG(g, RectangleClient.getCenterPoint(rect), element.angle);
                 }
             }
             else {
@@ -303,12 +303,157 @@ const isCornerHandle = (board, handle) => {
     return !isEdgeHandle(board, handle);
 };
 
+function getUnitVectorByPointAndPoint(point1, point2) {
+    const deltaX = point2[0] - point1[0];
+    const deltaY = point2[1] - point1[1];
+    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    // Avoid division by zero if the points are the same
+    if (distance === 0) {
+        throw new Error('Points must not be the same for a unit vector calculation.');
+    }
+    // Calculate the unit vector components
+    const unitX = deltaX / distance;
+    const unitY = deltaY / distance;
+    return [unitX, unitY];
+}
+function getPointByVector(point, vector, component) {
+    const distance = Math.hypot(vector[0], vector[1]);
+    return [point[0] + (vector[0] / distance) * component, point[1] + (vector[1] / distance) * component];
+}
+function getPointByUnitVectorAndDirectionComponent(point, unitVector, directionComponent, isHorizontal) {
+    if (isHorizontal) {
+        return [point[0] + directionComponent, point[1] + (directionComponent / unitVector[0]) * unitVector[1]];
+    }
+    else {
+        return [point[0] + (directionComponent / unitVector[1]) * unitVector[0], point[1] + directionComponent];
+    }
+}
+function rotateVectorAnti90(vector) {
+    const x = vector[0];
+    const y = vector[1];
+    const rotatedX = y;
+    const rotatedY = -x;
+    return [rotatedX, rotatedY];
+}
+
+function isPointOnSegment(point, startPoint, endPoint) {
+    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);
+    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);
+    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
+    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
+}
+const getCrossingPointsBetweenPointAndSegment = (point, startPoint, endPoint) => {
+    const result = [];
+    const xRange = [Math.min(startPoint[0], endPoint[0]), Math.max(startPoint[0], endPoint[0])];
+    const yRange = [Math.min(startPoint[1], endPoint[1]), Math.max(startPoint[1], endPoint[1])];
+    const unitVector = getUnitVectorByPointAndPoint(startPoint, endPoint);
+    if (point[0] >= xRange[0] && point[0] <= xRange[1]) {
+        const crossingPoint = getPointByUnitVectorAndDirectionComponent(startPoint, unitVector, point[0] - startPoint[0], true);
+        result.push(crossingPoint);
+    }
+    else if (point[1] >= yRange[0] && point[1] <= yRange[1]) {
+        const crossingPoint = getPointByUnitVectorAndDirectionComponent(startPoint, unitVector, point[1] - startPoint[1], false);
+        result.push(crossingPoint);
+    }
+    return result;
+};
+
+function getPointOnPolyline(points, ratio) {
+    const totalLength = calculatePolylineLength(points);
+    const targetDistance = totalLength * ratio;
+    let accumulatedDistance = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[i + 1];
+        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);
+        if (accumulatedDistance + segmentLength >= targetDistance) {
+            const remainingDistance = targetDistance - accumulatedDistance;
+            const ratioInSegment = remainingDistance / segmentLength;
+            const targetX = x1 + (x2 - x1) * ratioInSegment;
+            const targetY = y1 + (y2 - y1) * ratioInSegment;
+            return [targetX, targetY];
+        }
+        accumulatedDistance += segmentLength;
+    }
+    return points[points.length - 1];
+}
+function calculatePolylineLength(points) {
+    let length = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[i + 1];
+        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);
+    }
+    return length;
+}
+function getRatioByPoint(points, point) {
+    const totalLength = calculatePolylineLength(points);
+    let distance = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const isOverlap = isPointOnSegment(point, points[i], points[i + 1]);
+        if (isOverlap) {
+            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);
+            return distance / totalLength;
+        }
+        else {
+            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);
+        }
+    }
+    throw new Error('Cannot get ratio by point');
+}
+const removeDuplicatePoints = (points) => {
+    const newArray = [];
+    points.forEach(point => {
+        const index = newArray.findIndex(otherPoint => {
+            return Point.isEquals(point, otherPoint);
+        });
+        if (index === -1)
+            newArray.push(point);
+    });
+    return newArray;
+};
+function simplifyOrthogonalPoints(points) {
+    if (points.length <= 2)
+        return points;
+    let simplifiedPoints = [points[0]];
+    for (let i = 1; i < points.length - 1; i++) {
+        const previous = points[i - 1];
+        const current = points[i];
+        const next = points[i + 1];
+        const isTurn = !(Point.isOverHorizontal([previous, current, next]) || Point.isOverVertical([previous, current, next]));
+        if (isTurn) {
+            simplifiedPoints.push(current);
+        }
+    }
+    simplifiedPoints.push(points[points.length - 1]);
+    return simplifiedPoints;
+}
+const getExtendPoint = (source, target, extendDistance) => {
+    const distance = distanceBetweenPointAndPoint(...source, ...target);
+    const isEqual = Point.isEquals(source, target);
+    const sin = isEqual ? 1 : (target[1] - source[1]) / distance;
+    const cos = isEqual ? 1 : (target[0] - source[0]) / distance;
+    return [source[0] + extendDistance * cos, source[1] + extendDistance * sin];
+};
+
 const handleDirectionFactors = {
     [Direction.left]: { x: -1, y: 0 },
     [Direction.right]: { x: 1, y: 0 },
     [Direction.top]: { x: 0, y: -1 },
     [Direction.bottom]: { x: 0, y: 1 }
 };
+function getOppositeDirection(direction) {
+    switch (direction) {
+        case Direction.left:
+            return Direction.right;
+        case Direction.right:
+            return Direction.left;
+        case Direction.top:
+            return Direction.bottom;
+        case Direction.bottom:
+            return Direction.top;
+    }
+}
 function getDirectionByPointOfRectangle(point) {
     if (point[0] === 0) {
         return Direction.left;
@@ -378,83 +523,18 @@ function getDirectionBetweenPointAndPoint(source, target) {
 function getDirectionFactor(direction) {
     return handleDirectionFactors[direction];
 }
-function getDirectionFactorByVectorComponent(vectorComponent) {
-    const directionFactor = vectorComponent === 0 ? vectorComponent : vectorComponent / Math.abs(vectorComponent);
+function getDirectionFactorByDirectionComponent(directionComponent) {
+    const directionFactor = directionComponent === 0 ? directionComponent : directionComponent / Math.abs(directionComponent);
     return directionFactor;
 }
 
-function getUnitVectorByPointAndPoint(point1, point2) {
-    const deltaX = point2[0] - point1[0];
-    const deltaY = point2[1] - point1[1];
-    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-    // Avoid division by zero if the points are the same
-    if (distance === 0) {
-        throw new Error('Points must not be the same for a unit vector calculation.');
-    }
-    // Calculate the unit vector components
-    const unitX = deltaX / distance;
-    const unitY = deltaY / distance;
-    return [unitX, unitY];
-}
-function getPointByVector(point, vector, component) {
-    const distance = Math.hypot(vector[0], vector[1]);
-    return [point[0] + (vector[0] / distance) * component, point[1] + (vector[1] / distance) * component];
-}
-function getPointByUnitVectorAndVectorComponent(point, unitVector, vectorComponent, isHorizontal) {
-    if (isHorizontal) {
-        return [point[0] + vectorComponent, point[1] + (vectorComponent / unitVector[0]) * unitVector[1]];
-    }
-    else {
-        return [point[0] + (vectorComponent / unitVector[1]) * unitVector[0], point[1] + vectorComponent];
-    }
-}
-function rotateVectorAnti90(vector) {
-    const x = vector[0];
-    const y = vector[1];
-    const rotatedX = y;
-    const rotatedY = -x;
-    return [rotatedX, rotatedY];
-}
-
-function isPointOnSegment(point, startPoint, endPoint) {
-    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);
-    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);
-    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
-    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
-}
-const getCrossingPointsBetweenPointAndSegment = (point, startPoint, endPoint) => {
-    const result = [];
-    const xRange = [Math.min(startPoint[0], endPoint[0]), Math.max(startPoint[0], endPoint[0])];
-    const yRange = [Math.min(startPoint[1], endPoint[1]), Math.max(startPoint[1], endPoint[1])];
-    const unitVector = getUnitVectorByPointAndPoint(startPoint, endPoint);
-    if (point[0] >= xRange[0] && point[0] <= xRange[1]) {
-        const crossingPoint = getPointByUnitVectorAndVectorComponent(startPoint, unitVector, point[0] - startPoint[0], true);
-        result.push(crossingPoint);
-    }
-    else if (point[1] >= yRange[0] && point[1] <= yRange[1]) {
-        const crossingPoint = getPointByUnitVectorAndVectorComponent(startPoint, unitVector, point[1] - startPoint[1], false);
-        result.push(crossingPoint);
-    }
-    return result;
-};
-
-function getOppositeDirection(direction) {
-    switch (direction) {
-        case Direction.left:
-            return Direction.right;
-        case Direction.right:
-            return Direction.left;
-        case Direction.top:
-            return Direction.bottom;
-        case Direction.bottom:
-            return Direction.top;
-    }
-}
+// Credits to xyflow
+// https://github.com/xyflow/xyflow/blob/main/packages/system/src/utils/edges/smoothstep-edge.ts
 const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
-    const sourceDir = getDirectionFactor(sourcePosition);
-    const targetDir = getDirectionFactor(targetPosition);
-    const sourceGapped = [source[0] + sourceDir.x * offset, source[1] + sourceDir.y * offset];
-    const targetGapped = [target[0] + targetDir.x * offset, target[1] + targetDir.y * offset];
+    const sourceDirectionFactors = getDirectionFactor(sourcePosition);
+    const targetDFs = getDirectionFactor(targetPosition);
+    const sourceGapped = [source[0] + sourceDirectionFactors.x * offset, source[1] + sourceDirectionFactors.y * offset];
+    const targetGapped = [target[0] + targetDFs.x * offset, target[1] + targetDFs.y * offset];
     const dir = getDirection(sourceGapped, sourcePosition, targetGapped);
     const dirAccessor = dir.x !== 0 ? 'x' : 'y';
     const currDir = dir[dirAccessor];
@@ -467,7 +547,7 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
         targetY: target[1]
     });
     // opposite handle positions, default case
-    if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {
+    if (sourceDirectionFactors[dirAccessor] * targetDFs[dirAccessor] === -1) {
         centerX = defaultCenterX;
         centerY = defaultCenterY;
         //    --->
@@ -484,7 +564,7 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
             [sourceGapped[0], centerY],
             [targetGapped[0], centerY]
         ];
-        if (sourceDir[dirAccessor] === currDir) {
+        if (sourceDirectionFactors[dirAccessor] === currDir) {
             points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;
         }
         else {
@@ -497,21 +577,21 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
         const targetSource = [[targetGapped[0], sourceGapped[1]]];
         // this handles edges with same handle positions
         if (dirAccessor === 'x') {
-            points = sourceDir.x === currDir ? targetSource : sourceTarget;
+            points = sourceDirectionFactors.x === currDir ? targetSource : sourceTarget;
         }
         else {
-            points = sourceDir.y === currDir ? sourceTarget : targetSource;
+            points = sourceDirectionFactors.y === currDir ? sourceTarget : targetSource;
         }
         // these are conditions for handling mixed handle positions like right -> bottom for example
         let flipSourceTarget;
         if (sourcePosition !== targetPosition) {
             const dirAccessorOpposite = dirAccessor === 'x' ? 1 : 0;
-            const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessor === 'x' ? 'y' : 'x'];
+            const isSameDir = sourceDirectionFactors[dirAccessor] === targetDFs[dirAccessor === 'x' ? 'y' : 'x'];
             const sourceGtTarget = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];
             const sourceLtTarget = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];
             flipSourceTarget =
-                (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTarget) || (isSameDir && sourceLtTarget))) ||
-                    (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTarget) || (isSameDir && sourceGtTarget)));
+                (sourceDirectionFactors[dirAccessor] === 1 && ((!isSameDir && sourceGtTarget) || (isSameDir && sourceLtTarget))) ||
+                    (sourceDirectionFactors[dirAccessor] !== 1 && ((!isSameDir && sourceLtTarget) || (isSameDir && sourceGtTarget)));
             if (flipSourceTarget) {
                 points = dirAccessor === 'x' ? sourceTarget : targetSource;
             }
@@ -532,83 +612,6 @@ function getEdgeCenter({ sourceX, sourceY, targetX, targetY }) {
     const centerY = targetY < sourceY ? targetY + yOffset : targetY - yOffset;
     return [centerX, centerY, xOffset, yOffset];
 }
-function getPointOnPolyline(points, ratio) {
-    const totalLength = calculatePolylineLength(points);
-    const targetDistance = totalLength * ratio;
-    let accumulatedDistance = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const [x1, y1] = points[i];
-        const [x2, y2] = points[i + 1];
-        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);
-        if (accumulatedDistance + segmentLength >= targetDistance) {
-            const remainingDistance = targetDistance - accumulatedDistance;
-            const ratioInSegment = remainingDistance / segmentLength;
-            const targetX = x1 + (x2 - x1) * ratioInSegment;
-            const targetY = y1 + (y2 - y1) * ratioInSegment;
-            return [targetX, targetY];
-        }
-        accumulatedDistance += segmentLength;
-    }
-    return points[points.length - 1];
-}
-function calculatePolylineLength(points) {
-    let length = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const [x1, y1] = points[i];
-        const [x2, y2] = points[i + 1];
-        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);
-    }
-    return length;
-}
-function getRatioByPoint(points, point) {
-    const totalLength = calculatePolylineLength(points);
-    let distance = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const isOverlap = isPointOnSegment(point, points[i], points[i + 1]);
-        if (isOverlap) {
-            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);
-            return distance / totalLength;
-        }
-        else {
-            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);
-        }
-    }
-    throw new Error('Cannot get ratio by point');
-}
-const removeDuplicatePoints = (points) => {
-    const newArray = [];
-    points.forEach(point => {
-        const index = newArray.findIndex(otherPoint => {
-            return Point.isEquals(point, otherPoint);
-        });
-        if (index === -1)
-            newArray.push(point);
-    });
-    return newArray;
-};
-function simplifyOrthogonalPoints(points) {
-    if (points.length <= 2)
-        return points;
-    let simplifiedPoints = [points[0]];
-    for (let i = 1; i < points.length - 1; i++) {
-        const previous = points[i - 1];
-        const current = points[i];
-        const next = points[i + 1];
-        const isTurn = !(Point.isOverHorizontal([previous, current, next]) || Point.isOverVertical([previous, current, next]));
-        if (isTurn) {
-            simplifiedPoints.push(current);
-        }
-    }
-    simplifiedPoints.push(points[points.length - 1]);
-    return simplifiedPoints;
-}
-const getExtendPoint = (source, target, extendDistance) => {
-    const distance = distanceBetweenPointAndPoint(...source, ...target);
-    const isEqual = Point.isEquals(source, target);
-    const sin = isEqual ? 1 : (target[1] - source[1]) / distance;
-    const cos = isEqual ? 1 : (target[0] - source[0]) / distance;
-    return [source[0] + extendDistance * cos, source[1] + extendDistance * sin];
-};
 
 function isVirtualKey(e) {
     const isMod = e.ctrlKey || e.metaKey;
@@ -1133,6 +1136,12 @@ const getMemorizedLatest = (memorizedKey) => {
     return map.get(memorizedKey);
 };
 
+const rotatePoints = (points, centerPoint, angle) => {
+    return points.map(point => {
+        return rotate(point[0], point[1], centerPoint[0], centerPoint[1], angle);
+    });
+};
+
 const setProperty = (board, properties, options) => {
     const selectedElements = getSelectedElements(board);
     selectedElements.forEach(element => {
@@ -1580,5 +1589,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.8", 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, getDirection, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByVectorComponent, getEdgeCenter, getElementOfFocusedImage, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByUnitVectorAndVectorComponent, getPointByVector, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, 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, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withResize };
+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, getPointByUnitVectorAndDirectionComponent, getPointByVector, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, 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, rotatePoints, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withResize };
 //# sourceMappingURL=plait-common.mjs.map