@plait/draw 0.51.1 → 0.51.3

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, ThemeColorMode, Point, RectangleClient, getElementById, createG, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, depthFirstRecursion, getIsRecursionFunc, idCreator, catmullRomFitting, PlaitBoard, findElements, createMask, createRect, getSelectedElements, distanceBetweenPointAndSegments, isPolylineHitRectangle, setStrokeLinecap, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, Direction, Path, PlaitNode, toViewBoxPoint, toHostPoint, isSelectionMoving, RgbaToHEX, PlaitElement, preventTouchMove, createClipboardContext, WritableClipboardType, addClipboardContext, getRectangleByElements, getHitElementByPoint, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER } from '@plait/core';
-import { removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, isSourceAndTargetIntersect, getPoints, getPointByVector, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getRectangleResizeHandleRefs, RESIZE_HANDLE_DIAMETER, getMemorizedLatest, memorizeLatest, getPointOnPolyline, TRANSPARENT, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByVector, getOppositeDirection, getDirectionFactor, getDirectionByPointOfRectangle, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, normalizeShapePoints, getFirstTextEditor, PRIMARY_COLOR, CommonPluginElement, ActiveGenerator, WithTextPluginKey, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, getDirectionFactorByVectorComponent, isCornerHandle, getFirstTextManage, withResize, drawHandle, getIndexByResizeHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, isResizingByCondition, getRatioByPoint, ImageGenerator, ResizeHandle } from '@plait/common';
+import { ACTIVE_STROKE_WIDTH, ThemeColorMode, Point, RectangleClient, getElementById, createG, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, depthFirstRecursion, getIsRecursionFunc, idCreator, catmullRomFitting, PlaitBoard, findElements, createMask, createRect, getSelectedElements, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPolylineHitRectangle, setStrokeLinecap, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, Direction, Path, PlaitNode, toViewBoxPoint, toHostPoint, isSelectionMoving, RgbaToHEX, PlaitElement, preventTouchMove, createClipboardContext, WritableClipboardType, addClipboardContext, getRectangleByElements, getHitElementByPoint, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, getRectangleByGroup, getElementsInGroup, isSelectedElementOrGroup, PlaitGroupElement } from '@plait/core';
+import { removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, isSourceAndTargetIntersect, getPoints, getPointByVector, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getRectangleResizeHandleRefs, RESIZE_HANDLE_DIAMETER, getMemorizedLatest, memorizeLatest, getPointOnPolyline, rotatePoints, TRANSPARENT, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByVector, getOppositeDirection, getDirectionFactor, getDirectionByPointOfRectangle, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, normalizeShapePoints, getFirstTextEditor, PRIMARY_COLOR, CommonPluginElement, ActiveGenerator, WithTextPluginKey, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, getDirectionFactorByDirectionComponent, isCornerHandle, getFirstTextManage, withResize, drawHandle, getIndexByResizeHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, isResizingByCondition, getRatioByPoint, ImageGenerator, ResizeHandle } from '@plait/common';
 import { Alignment, buildText, DEFAULT_FONT_SIZE, getTextSize, AlignEditor, TextManage } from '@plait/text';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import * as i0 from '@angular/core';
@@ -720,7 +720,7 @@ const getHitOutlineGeometry = (board, point, offset = 0) => {
             let client = RectangleClient.getRectangleByPoints(node.points);
             client = RectangleClient.getOutlineRectangle(client, offset);
             const shape = getShape(node);
-            const isHit = getEngine(shape).isHit(client, point);
+            const isHit = getEngine(shape).isInsidePoint(client, point);
             if (isHit) {
                 geometry = node;
             }
@@ -1133,43 +1133,59 @@ const isTextExceedingBounds = (geometry) => {
 const isHitLineText = (board, element, point) => {
     return getHitLineTextIndex(board, element, point) !== -1;
 };
-const isHitPolyLine = (pathPoints, point, strokeWidth, expand = 0) => {
+const isHitPolyLine = (pathPoints, point) => {
     const distance = distanceBetweenPointAndSegments(pathPoints, point);
-    return distance <= strokeWidth + expand;
+    return distance <= HIT_DISTANCE_BUFFER;
+};
+const isHitLine = (board, element, point) => {
+    const points = getLinePoints(board, element);
+    const isHitText = isHitLineText(board, element, point);
+    return isHitText || isHitPolyLine(points, point);
 };
 const isRectangleHitDrawElement = (board, element, selection) => {
     const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
     if (PlaitDrawElement.isGeometry(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
+        const centerPoint = RectangleClient.getCenterPoint(client);
+        let rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), centerPoint, element.angle);
         if (isTextExceedingBounds(element)) {
             const textClient = getTextRectangle(element);
-            return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);
+            rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(textClient), centerPoint, element.angle);
         }
-        return RectangleClient.isHit(rangeRectangle, client);
+        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
     }
     if (PlaitDrawElement.isImage(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
-        return RectangleClient.isHit(rangeRectangle, client);
+        const rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), RectangleClient.getCenterPoint(client), element.angle);
+        return isPolylineHitRectangle(rotatedCornerPoints, client);
     }
     if (PlaitDrawElement.isLine(element)) {
         const points = getLinePoints(board, element);
-        const strokeWidth = getStrokeWidthByElement(element);
-        const isHitText = isHitLineText(board, element, selection.focus);
-        const isHit = isHitPolyLine(points, selection.focus, strokeWidth, 3) || isHitText;
-        const isContainPolyLinePoint = points.some(point => {
-            return RectangleClient.isHit(rangeRectangle, RectangleClient.getRectangleByPoints([point, point]));
-        });
-        const isIntersect = Point.isEquals(selection.anchor, selection.focus) ? isHit : isPolylineHitRectangle(points, rangeRectangle);
-        return isContainPolyLinePoint || isIntersect;
+        return isPolylineHitRectangle(points, rangeRectangle);
     }
     return null;
 };
 const isHitDrawElement = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         const fill = getFillByElement(board, element);
+        const engine = getEngine(getShape(element));
+        const nearestPoint = engine.getNearestPoint(rectangle, point);
+        const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);
+        const isHitEdge = distance <= HIT_DISTANCE_BUFFER;
+        if (isHitEdge) {
+            return isHitEdge;
+        }
         // when shape equals text, fill is not allowed
         if (fill !== DefaultGeometryStyle.fill && fill !== TRANSPARENT && !PlaitDrawElement.isText(element)) {
-            return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });
+            const isHitInside = engine.isInsidePoint(rectangle, point);
+            if (isHitInside) {
+                return isHitInside;
+            }
         }
         else {
             // if shape equals text, only check text rectangle
@@ -1178,18 +1194,48 @@ const isHitDrawElement = (board, element, point) => {
                 let isHitText = RectangleClient.isPointInRectangle(textClient, point);
                 return isHitText;
             }
-            const strokeWidth = getStrokeWidthByElement(element);
-            const engine = getEngine(getShape(element));
-            const corners = engine.getCornerPoints(RectangleClient.getRectangleByPoints(element.points));
-            const isHit = isHitPolyLine(corners, point, strokeWidth, 3);
-            const textClient = getTextRectangle(element);
-            let isHitText = RectangleClient.isPointInRectangle(textClient, point);
-            return isHit || isHitText;
+            // check textRectangle of element
+            const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
+            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);
+            if (isHitTextRectangle) {
+                return isHitTextRectangle;
+            }
         }
     }
-    if (PlaitDrawElement.isImage(element) || PlaitDrawElement.isLine(element)) {
+    if (PlaitDrawElement.isImage(element)) {
         return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });
     }
+    if (PlaitDrawElement.isLine(element)) {
+        return isHitLine(board, element, point);
+    }
+    return null;
+};
+const isHitElementInside = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
+    if (PlaitDrawElement.isGeometry(element)) {
+        const engine = getEngine(getShape(element));
+        const isHitInside = engine.isInsidePoint(rectangle, point);
+        if (isHitInside) {
+            return isHitInside;
+        }
+        if (engine.getTextRectangle) {
+            const textClient = engine.getTextRectangle(element);
+            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);
+            if (isHitTextRectangle) {
+                return isHitTextRectangle;
+            }
+        }
+    }
+    if (PlaitDrawElement.isImage(element)) {
+        return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });
+    }
+    if (PlaitDrawElement.isLine(element)) {
+        return isHitLine(board, element, point);
+    }
     return null;
 };
 
@@ -1231,7 +1277,7 @@ const CommentEngine = {
         setStrokeLinecap(polygon, 'round');
         return polygon;
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         const parallelogramPoints = getCommentPoints(rectangle);
         return isPointInPolygon(point, parallelogramPoints);
     },
@@ -1284,7 +1330,7 @@ function createPolygonEngine(options) {
             setStrokeLinecap(polygon, 'round');
             return polygon;
         },
-        isHit(rectangle, point) {
+        isInsidePoint(rectangle, point) {
             const points = getPoints(rectangle);
             return isPointInPolygon(point, points);
         },
@@ -1377,7 +1423,7 @@ const EllipseEngine = {
         const rs = PlaitBoard.getRoughSVG(board);
         return rs.ellipse(centerPoint[0], centerPoint[1], rectangle.width, rectangle.height, { ...options, fillStyle: 'solid' });
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
         return isPointInEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);
     },
@@ -1620,7 +1666,7 @@ const RectangleEngine = {
     draw(board, rectangle, options) {
         return drawRectangle(board, rectangle, { ...options, fillStyle: 'solid' });
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         const rangeRectangle = RectangleClient.getRectangleByPoints([point, point]);
         return RectangleClient.isHit(rectangle, rangeRectangle);
     },
@@ -1670,7 +1716,7 @@ const RoundRectangleEngine = {
     draw(board, rectangle, options) {
         return drawRoundRectangle(PlaitBoard.getRoughSVG(board), rectangle.x, rectangle.y, rectangle.x + rectangle.width, rectangle.y + rectangle.height, { ...options, fillStyle: 'solid' }, false, getRoundRectangleRadius(rectangle));
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         return isPointInRoundRectangle(point, rectangle, getRoundRectangleRadius(rectangle));
     },
     getCornerPoints(rectangle) {
@@ -1743,7 +1789,7 @@ const RoundCommentEngine = {
         const point11 = [x1 + rectangle.width / 2, y2];
         return rs.path(`M${point2[0]} ${point2[1]} A ${radius} ${radius}, 0, 0, 1, ${point3[0]} ${point3[1]} L ${point4[0]} ${point4[1]} A ${radius} ${radius}, 0, 0, 1, ${point5[0]} ${point5[1]} L    ${point11[0]} ${point11[1]}  ${point10[0]} ${point10[1]}   ${point9[0]} ${point9[1]}   ${point6[0]} ${point6[1]} A ${radius} ${radius}, 0, 0, 1, ${point7[0]} ${point7[1]} L ${point8[0]} ${point8[1]} A ${radius} ${radius}, 0, 0, 1, ${point1[0]} ${point1[1]} Z`, { ...options, fillStyle: 'solid' });
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         const points = [
             [rectangle.x + rectangle.width / 4, rectangle.y + (rectangle.height * 3) / 4],
             [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height],
@@ -1911,7 +1957,7 @@ const TerminalEngine = {
     draw(board, rectangle, options) {
         return drawRoundRectangle(PlaitBoard.getRoughSVG(board), rectangle.x, rectangle.y, rectangle.x + rectangle.width, rectangle.y + rectangle.height, { ...options, fillStyle: 'solid' }, false, getStartEndRadius(rectangle));
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         return isPointInRoundRectangle(point, rectangle, getStartEndRadius(rectangle));
     },
     getCornerPoints(rectangle) {
@@ -2086,7 +2132,7 @@ const DelayEngine = {
         setStrokeLinecap(shape, 'round');
         return shape;
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         //split shape to rectangle and a half ellipse
         const rangeRectangle = RectangleClient.getRectangleByPoints([point, point]);
         const isInRectangle = RectangleClient.isHit({
@@ -2130,7 +2176,7 @@ const StoredDataEngine = {
         setStrokeLinecap(shape, 'round');
         return shape;
     },
-    isHit(rectangle, point) {
+    isInsidePoint(rectangle, point) {
         //split shape to rectangle and a half ellipse
         const rangeRectangle = RectangleClient.getRectangleByPoints([point, point]);
         const isInRectangle = RectangleClient.isHit({
@@ -3055,10 +3101,14 @@ class GeometryComponent extends CommonPluginElement {
     drawText() {
         this.textManage.draw(this.element.text);
         this.g.append(this.textManage.g);
+        const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
+        this.textManage.updateAngle(centerPoint, this.element.angle);
     }
     updateText() {
         this.textManage.updateText(this.element.text);
         this.textManage.updateRectangle();
+        const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
+        this.textManage.updateAngle(centerPoint, this.element.angle);
     }
     initializeTextManage() {
         const plugins = (this.board.getPluginOptions(WithTextPluginKey) || {}).textPlugins;
@@ -4066,7 +4116,7 @@ function getResizeAlignRef(board, resizeRef, resizeState, resizeOriginPointAndHa
         activeRectangle,
         originPoint,
         handlePoint,
-        directionFactors: [getDirectionFactorByVectorComponent(x), getDirectionFactorByVectorComponent(y)],
+        directionFactors: [getDirectionFactorByDirectionComponent(x), getDirectionFactorByDirectionComponent(y)],
         isAspectRatio,
         isFromCorner
     });
@@ -4737,8 +4787,68 @@ const withLineTextMove = (board) => {
     return board;
 };
 
+class GroupGenerator extends Generator {
+    canDraw(element) {
+        return true;
+    }
+    draw(element, partialSelected) {
+        const options = {
+            stroke: '',
+            strokeWidth: ACTIVE_STROKE_WIDTH,
+            strokeLineDash: [5]
+        };
+        if (partialSelected) {
+            options.stroke = '#999';
+        }
+        const rectangle = getRectangleByGroup(this.board, element, true);
+        return drawRectangle(this.board, rectangle, options);
+    }
+}
+
+class GroupComponent extends CommonPluginElement {
+    constructor(viewContainerRef, cdr) {
+        super(cdr);
+        this.viewContainerRef = viewContainerRef;
+        this.cdr = cdr;
+    }
+    initializeGenerator() {
+        this.activeGenerator = new ActiveGenerator(this.board, {
+            getRectangle: (element) => {
+                return getRectangleByGroup(this.board, element);
+            },
+            getStrokeWidth: () => 0,
+            getStrokeOpacity: () => 0,
+            hasResizeHandle: () => {
+                return !isSelectionMoving(this.board);
+            }
+        });
+        this.groupGenerator = new GroupGenerator(this.board);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.initializeGenerator();
+    }
+    onContextChanged(value, previous) {
+        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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: GroupComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.8", 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: "16.2.8", ngImport: i0, type: GroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-group',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; } });
+
 const withDraw = (board) => {
-    const { drawElement, getRectangle, isRectangleHit, isHit, isMovable, isAlign, getRelatedFragment } = board;
+    const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment } = board;
     board.drawElement = (context) => {
         if (PlaitDrawElement.isGeometry(context.element)) {
             return GeometryComponent;
@@ -4749,6 +4859,9 @@ const withDraw = (board) => {
         else if (PlaitDrawElement.isImage(context.element)) {
             return ImageComponent;
         }
+        else if (PlaitGroupElement.isGroup(context.element)) {
+            return GroupComponent;
+        }
         return drawElement(context);
     };
     board.getRectangle = (element) => {
@@ -4767,6 +4880,9 @@ const withDraw = (board) => {
         if (PlaitDrawElement.isImage(element)) {
             return RectangleClient.getRectangleByPoints(element.points);
         }
+        if (PlaitGroupElement.isGroup(element)) {
+            return getRectangleByGroup(board, element);
+        }
         return getRectangle(element);
     };
     board.isRectangleHit = (element, selection) => {
@@ -4783,6 +4899,13 @@ const withDraw = (board) => {
         }
         return isHit(element, point);
     };
+    board.isInsidePoint = (element, point) => {
+        const result = isHitElementInside(board, element, point);
+        if (result !== null) {
+            return result;
+        }
+        return isInsidePoint(element, point);
+    };
     board.isMovable = (element) => {
         if (PlaitDrawElement.isGeometry(element)) {
             return true;
@@ -4832,5 +4955,5 @@ const withDraw = (board) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultBasicShapeProperty, DefaultConnectorProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultGeometryActiveStyle, DefaultGeometryStyle, DefaultManualInputProperty, DefaultMergeProperty, DefaultTextProperty, DrawThemeColors, DrawTransforms, FlowchartSymbols, GeometryComponent, GeometryThreshold, LineComponent, LineHandleKey, LineMarkerType, LineShape, MemorizeKey, PlaitDrawElement, PlaitGeometry, PlaitLine, Q2C, REACTION_MARGIN, ShapeDefaultSpace, StrokeStyle, WithLineAutoCompletePluginKey, alignElbowSegment, alignPoints, createDefaultFlowchart, createDefaultGeometry, createGeometryElement, createLineElement, createTextElement, drawBoundMask, drawGeometry, drawLine, drawLineArrow, getAutoCompletePoints, getBasicPointers, getCenterPointsOnPolygon, getConnectionByNearestPoint, getConnectionPoint, getCurvePoints, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultTextPoints, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryPointers, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineHandleRefPair, getLineMemorizedLatest, getLinePointers, getLinePoints, getLineTextRectangle, getLines, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedLineElements, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTextRectangle, getTextShapeProperty, getVectorByConnection, handleLineCreating, hasIllegalElbowPoint, insertElement, isHitDrawElement, isHitLineText, isHitPolyLine, isRectangleHitDrawElement, isTextExceedingBounds, isUpdatedHandleIndex, memorizeLatestShape, memorizeLatestText, withDraw, withLineAutoComplete };
+export { BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultBasicShapeProperty, DefaultConnectorProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultGeometryActiveStyle, DefaultGeometryStyle, DefaultManualInputProperty, DefaultMergeProperty, DefaultTextProperty, DrawThemeColors, DrawTransforms, FlowchartSymbols, GeometryComponent, GeometryThreshold, LineComponent, LineHandleKey, LineMarkerType, LineShape, MemorizeKey, PlaitDrawElement, PlaitGeometry, PlaitLine, Q2C, REACTION_MARGIN, ShapeDefaultSpace, StrokeStyle, WithLineAutoCompletePluginKey, alignElbowSegment, alignPoints, createDefaultFlowchart, createDefaultGeometry, createGeometryElement, createLineElement, createTextElement, drawBoundMask, drawGeometry, drawLine, drawLineArrow, getAutoCompletePoints, getBasicPointers, getCenterPointsOnPolygon, getConnectionByNearestPoint, getConnectionPoint, getCurvePoints, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultTextPoints, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryPointers, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineHandleRefPair, getLineMemorizedLatest, getLinePointers, getLinePoints, getLineTextRectangle, getLines, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedLineElements, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTextRectangle, getTextShapeProperty, getVectorByConnection, handleLineCreating, hasIllegalElbowPoint, insertElement, isHitDrawElement, isHitElementInside, isHitLine, isHitLineText, isHitPolyLine, isRectangleHitDrawElement, isTextExceedingBounds, isUpdatedHandleIndex, memorizeLatestShape, memorizeLatestText, withDraw, withLineAutoComplete };
 //# sourceMappingURL=plait-draw.mjs.map