@plait/draw 0.63.0 → 0.64.0

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, ThemeColorMode, RectangleClient, getSelectedElements, idCreator, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, rotatePointsByElement, isPolylineHitRectangle, rotateAntiPointsByElement, distanceBetweenPointAndPoint, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, PlaitBoard, getIsRecursionFunc, createG, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, drawLinearPath, rotate, catmullRomFitting, setStrokeLinecap, findElements, createMask, createRect, PlaitElement, getElementById, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, setPathStrokeLinecap, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, getHitElementByPoint, preventTouchMove, WritableClipboardOperationType, createClipboardContext, WritableClipboardType, addClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, SELECTION_RECTANGLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
-import { DEFAULT_FILL, Alignment, WithTextPluginKey, ELEMENT_TO_TEXT_MANAGES, TextManage, getMemorizedLatest, memorizeLatest, RESIZE_HANDLE_DIAMETER, getPointOnPolyline, buildText, sortElementsByArea, isFilled, getTextEditorsByElement, Generator, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, canResize, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
+import { ACTIVE_STROKE_WIDTH, ThemeColorMode, RectangleClient, getSelectedElements, idCreator, catmullRomFitting, PlaitBoard, createG, drawLinearPath, setStrokeLinecap, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, rotatePointsByElement, isPolylineHitRectangle, rotateAntiPointsByElement, distanceBetweenPointAndPoint, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, rotate, findElements, createMask, createRect, PlaitElement, getElementById, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, setPathStrokeLinecap, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, getHitElementByPoint, preventTouchMove, WritableClipboardOperationType, createClipboardContext, WritableClipboardType, addClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, SELECTION_RECTANGLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
+import { DEFAULT_FILL, Alignment, WithTextPluginKey, ELEMENT_TO_TEXT_MANAGES, TextManage, getMemorizedLatest, memorizeLatest, getPointOnPolyline, buildText, Generator, sortElementsByArea, isFilled, getTextEditorsByElement, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, RESIZE_HANDLE_DIAMETER, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, canResize, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import { TEXT_DEFAULT_HEIGHT, DEFAULT_FONT_SIZE, AlignEditor } from '@plait/text-plugins';
 import { isKeyHotkey } from 'is-hotkey';
@@ -400,6 +400,9 @@ const getUMLPointers = () => {
 const getArrowLinePointers = () => {
     return Object.keys(ArrowLineShape);
 };
+const getVectorPenPointers = () => {
+    return Object.keys(VectorPenPointerType);
+};
 
 const DEFAULT_IMAGE_WIDTH = 1000;
 
@@ -866,52 +869,6 @@ const getMemorizedLatestShape = (board) => {
     return memorizedShape.get(board);
 };
 
-var ArrowLineResizeHandle;
-(function (ArrowLineResizeHandle) {
-    ArrowLineResizeHandle["source"] = "source";
-    ArrowLineResizeHandle["target"] = "target";
-    ArrowLineResizeHandle["addHandle"] = "addHandle";
-})(ArrowLineResizeHandle || (ArrowLineResizeHandle = {}));
-const getHitArrowLineResizeHandleRef = (board, element, point) => {
-    let dataPoints = PlaitArrowLine.getPoints(board, element);
-    const index = getHitPointIndex(dataPoints, point);
-    if (index !== -1) {
-        const handleIndex = index;
-        if (index === 0) {
-            return { handle: ArrowLineResizeHandle.source, handleIndex };
-        }
-        if (index === dataPoints.length - 1) {
-            return { handle: ArrowLineResizeHandle.target, handleIndex };
-        }
-        // elbow line, data points only verify source connection point and target connection point
-        if (element.shape !== ArrowLineShape.elbow) {
-            return { handleIndex };
-        }
-    }
-    const middlePoints = getMiddlePoints(board, element);
-    const indexOfMiddlePoints = getHitPointIndex(middlePoints, point);
-    if (indexOfMiddlePoints !== -1) {
-        return {
-            handle: ArrowLineResizeHandle.addHandle,
-            handleIndex: indexOfMiddlePoints
-        };
-    }
-    return undefined;
-};
-function getHitPointIndex(points, movingPoint) {
-    const rectangles = points.map(point => {
-        return {
-            x: point[0] - RESIZE_HANDLE_DIAMETER / 2,
-            y: point[1] - RESIZE_HANDLE_DIAMETER / 2,
-            width: RESIZE_HANDLE_DIAMETER,
-            height: RESIZE_HANDLE_DIAMETER
-        };
-    });
-    const rectangle = rectangles.find(rectangle => {
-        return RectangleClient.isHit(RectangleClient.getRectangleByPoints([movingPoint, movingPoint]), rectangle);
-    });
-    return rectangle ? rectangles.indexOf(rectangle) : -1;
-}
 const getHitArrowLineTextIndex = (board, element, point) => {
     const texts = element.texts;
     if (!texts.length)
@@ -983,6 +940,95 @@ const getHitMultipleGeometryText = (element, point) => {
     return hitText;
 };
 
+const DefaultLineStyle = {
+    strokeWidth: 2,
+    strokeColor: '#000'
+};
+const LINE_TEXT_SPACE = 4;
+const LINE_AUTO_COMPLETE_DIAMETER = 6;
+const LINE_AUTO_COMPLETE_OPACITY = 0.6;
+const LINE_AUTO_COMPLETE_HOVERED_OPACITY = 0.8;
+const LINE_AUTO_COMPLETE_HOVERED_DIAMETER = 10;
+const LINE_ALIGN_TOLERANCE = 3;
+const LINE_TEXT = '文本';
+
+class VectorLineShapeGenerator extends Generator {
+    canDraw(element) {
+        return true;
+    }
+    draw(element) {
+        let lineG;
+        lineG = drawVectorLine(this.board, element);
+        return lineG;
+    }
+}
+
+const isClosedVectorLine = (vectorLine) => {
+    const points = vectorLine.points;
+    const startPoint = points[0];
+    const endPoint = points[points.length - 1];
+    return startPoint[0] === endPoint[0] && startPoint[1] === endPoint[1];
+};
+const getVectorLinePoints = (board, element) => {
+    switch (element.shape) {
+        case VectorLineShape.straight: {
+            return element.points;
+        }
+        case VectorLineShape.curve: {
+            if (element.points.length === 2) {
+                return pointsOnBezierCurves(element.points);
+            }
+            else {
+                let dataPoints = element.points;
+                const points = catmullRomFitting(dataPoints);
+                return pointsOnBezierCurves(points);
+            }
+        }
+        default:
+            return null;
+    }
+};
+const createVectorLineElement = (shape, points, options) => {
+    return {
+        id: idCreator(),
+        type: 'vector-line',
+        shape,
+        opacity: 1,
+        points,
+        ...options
+    };
+};
+const vectorLineCreating = (board, lineShape, points, movingPoint, lineShapeG) => {
+    const lineGenerator = new VectorLineShapeGenerator(board);
+    const memorizedLatest = getLineMemorizedLatest();
+    const temporaryLineElement = createVectorLineElement(lineShape, [...points, movingPoint], {
+        strokeWidth: DefaultLineStyle.strokeWidth,
+        ...memorizedLatest
+    });
+    const otherPoint = points[points.length - 1];
+    temporaryLineElement.points[temporaryLineElement.points.length - 1] = alignPoints(otherPoint, movingPoint);
+    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);
+    PlaitBoard.getElementActiveHost(board).append(lineShapeG);
+    return temporaryLineElement;
+};
+const drawVectorLine = (board, element) => {
+    const strokeWidth = getStrokeWidthByElement(element);
+    const strokeColor = getStrokeColorByElement(board, element);
+    const strokeLineDash = getLineDashByElement(element);
+    const fill = getFillByElement(board, element);
+    const options = { stroke: strokeColor, strokeWidth, strokeLineDash, fill };
+    const lineG = createG();
+    let points = getVectorLinePoints(board, element);
+    const line = drawLinearPath(points, options);
+    const id = idCreator();
+    line.setAttribute('mask', `url(#${id})`);
+    if (element.strokeStyle === StrokeStyle.dotted) {
+        setStrokeLinecap(line, 'round');
+    }
+    lineG.appendChild(line);
+    return lineG;
+};
+
 const isTextExceedingBounds = (geometry) => {
     const client = RectangleClient.getRectangleByPoints(geometry.points);
     if (geometry.textHeight && geometry.textHeight > client.height) {
@@ -1002,6 +1048,10 @@ const isHitArrowLine = (board, element, point) => {
     const isHitText = isHitArrowLineText(board, element, point);
     return isHitText || isHitPolyLine(points, point);
 };
+const isHitVectorLine = (board, element, point) => {
+    const points = getVectorLinePoints(board, element);
+    return isHitPolyLine(points, point);
+};
 const isRectangleHitElementText = (element, rectangle) => {
     const engine = getEngine(element.shape);
     if (isMultipleTextGeometry(element)) {
@@ -1115,6 +1165,9 @@ const isHitDrawElement = (board, element, point) => {
     if (PlaitDrawElement.isArrowLine(element)) {
         return isHitArrowLine(board, element, point);
     }
+    if (PlaitDrawElement.isVectorLine(element)) {
+        return isHitVectorLine(board, element, point);
+    }
     return null;
 };
 const isHitEdgeOfShape = (board, element, point, hitDistanceBuffer) => {
@@ -1149,6 +1202,9 @@ const isHitElementInside = (board, element, point) => {
     if (PlaitDrawElement.isArrowLine(element)) {
         return isHitArrowLine(board, element, point);
     }
+    if (PlaitDrawElement.isVectorLine(element)) {
+        return isHitVectorLine(board, element, point);
+    }
     return null;
 };
 
@@ -1206,6 +1262,9 @@ const isDrawElementClosed = (element) => {
     if (PlaitDrawElement.isText(element) || PlaitDrawElement.isArrowLine(element) || PlaitDrawElement.isImage(element)) {
         return false;
     }
+    if (PlaitDrawElement.isVectorLine(element)) {
+        return isClosedVectorLine(element);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         return isGeometryClosed(element);
     }
@@ -1333,29 +1392,6 @@ const getStrokeStyleByElement = (element) => {
     return element.strokeStyle || StrokeStyle.solid;
 };
 
-const DefaultLineStyle = {
-    strokeWidth: 2,
-    strokeColor: '#000'
-};
-const LINE_TEXT_SPACE = 4;
-const LINE_AUTO_COMPLETE_DIAMETER = 6;
-const LINE_AUTO_COMPLETE_OPACITY = 0.6;
-const LINE_AUTO_COMPLETE_HOVERED_OPACITY = 0.8;
-const LINE_AUTO_COMPLETE_HOVERED_DIAMETER = 10;
-const LINE_ALIGN_TOLERANCE = 3;
-const LINE_TEXT = '文本';
-
-class ArrowLineShapeGenerator extends Generator {
-    canDraw(element, data) {
-        return true;
-    }
-    draw(element, data) {
-        let lineG;
-        lineG = drawArrowLine(this.board, element);
-        return lineG;
-    }
-}
-
 const debugKey$3 = 'debug:plait:line-mirror';
 const debugGenerator$3 = createDebugGenerator(debugKey$3);
 const alignPoints = (basePoint, movingPoint) => {
@@ -1780,6 +1816,17 @@ const drawHollowTriangleArrow = (source, target, options) => {
     return drawLinearPath([pointLeft, pointRight, target], { ...options, fill: 'white' }, true);
 };
 
+class ArrowLineShapeGenerator extends Generator {
+    canDraw(element) {
+        return true;
+    }
+    draw(element) {
+        let lineG;
+        lineG = drawArrowLine(this.board, element);
+        return lineG;
+    }
+}
+
 const createArrowLineElement = (shape, points, source, target, texts, options) => {
     return {
         id: idCreator(),
@@ -1845,59 +1892,6 @@ const getCurvePoints = (board, element) => {
         return pointsOnBezierCurves(points);
     }
 };
-function getMiddlePoints(board, element) {
-    const result = [];
-    const shape = element.shape;
-    const hideBuffer = 10;
-    if (shape === ArrowLineShape.straight) {
-        const points = PlaitArrowLine.getPoints(board, element);
-        for (let i = 0; i < points.length - 1; i++) {
-            const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
-            if (distance < hideBuffer)
-                continue;
-            result.push([(points[i][0] + points[i + 1][0]) / 2, (points[i][1] + points[i + 1][1]) / 2]);
-        }
-    }
-    if (shape === ArrowLineShape.curve) {
-        const points = PlaitArrowLine.getPoints(board, element);
-        const pointsOnBezier = getCurvePoints(board, element);
-        if (points.length === 2) {
-            const start = 0;
-            const endIndex = pointsOnBezier.length - 1;
-            const middleIndex = Math.round((start + endIndex) / 2);
-            result.push(pointsOnBezier[middleIndex]);
-        }
-        else {
-            for (let i = 0; i < points.length - 1; i++) {
-                const startIndex = pointsOnBezier.findIndex(point => point[0] === points[i][0] && point[1] === points[i][1]);
-                const endIndex = pointsOnBezier.findIndex(point => point[0] === points[i + 1][0] && point[1] === points[i + 1][1]);
-                const middleIndex = Math.round((startIndex + endIndex) / 2);
-                const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
-                if (distance < hideBuffer)
-                    continue;
-                result.push(pointsOnBezier[middleIndex]);
-            }
-        }
-    }
-    if (shape === ArrowLineShape.elbow) {
-        const renderPoints = getElbowPoints(board, element);
-        const options = getElbowLineRouteOptions(board, element);
-        if (!isUseDefaultOrthogonalRoute(element, options)) {
-            const [nextSourcePoint, nextTargetPoint] = getNextSourceAndTargetPoints(board, element);
-            for (let i = 0; i < renderPoints.length - 1; i++) {
-                if ((i == 0 && Point.isEquals(renderPoints[i + 1], nextSourcePoint)) ||
-                    (i === renderPoints.length - 2 && Point.isEquals(renderPoints[renderPoints.length - 2], nextTargetPoint))) {
-                    continue;
-                }
-                const [currentX, currentY] = renderPoints[i];
-                const [nextX, nextY] = renderPoints[i + 1];
-                const middlePoint = [(currentX + nextX) / 2, (currentY + nextY) / 2];
-                result.push(middlePoint);
-            }
-        }
-    }
-    return result;
-}
 const drawArrowLine = (board, element) => {
     const strokeWidth = getStrokeWidthByElement(element);
     const strokeColor = getStrokeColorByElement(board, element);
@@ -2455,6 +2449,10 @@ const getSelectedArrowLineElements = (board) => {
     const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isArrowLine(value));
     return selectedElements;
 };
+const getSelectedVectorLineElements = (board) => {
+    const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isVectorLine(value));
+    return selectedElements;
+};
 const getSelectedImageElements = (board) => {
     const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isImage(value));
     return selectedElements;
@@ -3004,6 +3002,17 @@ const setTableFill = (board, element, fill, path) => {
     Transforms.setNode(board, { cells: newCells }, path);
 };
 
+const setVectorLineShape = (board, newProperties) => {
+    const elements = getSelectedVectorLineElements(board);
+    elements.map(element => {
+        if (element.shape === newProperties.shape) {
+            return;
+        }
+        const path = PlaitBoard.findPath(board, element);
+        Transforms.setNode(board, { ...newProperties }, path);
+    });
+};
+
 const insertDrawByVector = (board, point, shape, vector) => {
     const swimlanePointers = getSwimlanePointers();
     const isSwimlanePointer = swimlanePointers.includes(shape);
@@ -3047,6 +3056,7 @@ const DrawTransforms = {
     removeArrowLineText,
     setArrowLineMark,
     setArrowLineShape,
+    setVectorLineShape,
     insertImage,
     connectArrowLineToDraw,
     switchGeometryShape,
@@ -3520,6 +3530,66 @@ function drawIsometricSnapLines(board, activePoints, snapRectangles, resizeSnapO
     return drawSolidLines(board, isometricLines);
 }
 
+function getMiddlePoints(board, element) {
+    const result = [];
+    const shape = element.shape;
+    const hideBuffer = 10;
+    if (shape === ArrowLineShape.straight) {
+        const points = PlaitDrawElement.isArrowLine(element)
+            ? PlaitArrowLine.getPoints(board, element)
+            : element.points;
+        for (let i = 0; i < points.length - 1; i++) {
+            const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
+            if (distance < hideBuffer)
+                continue;
+            result.push([(points[i][0] + points[i + 1][0]) / 2, (points[i][1] + points[i + 1][1]) / 2]);
+        }
+    }
+    if (shape === ArrowLineShape.curve) {
+        const points = PlaitDrawElement.isArrowLine(element)
+            ? PlaitArrowLine.getPoints(board, element)
+            : element.points;
+        const pointsOnBezier = PlaitDrawElement.isArrowLine(element)
+            ? getCurvePoints(board, element)
+            : getVectorLinePoints(board, element);
+        if (points.length === 2) {
+            const start = 0;
+            const endIndex = pointsOnBezier.length - 1;
+            const middleIndex = Math.round((start + endIndex) / 2);
+            result.push(pointsOnBezier[middleIndex]);
+        }
+        else {
+            for (let i = 0; i < points.length - 1; i++) {
+                const startIndex = pointsOnBezier.findIndex(point => point[0] === points[i][0] && point[1] === points[i][1]);
+                const endIndex = pointsOnBezier.findIndex(point => point[0] === points[i + 1][0] && point[1] === points[i + 1][1]);
+                const middleIndex = Math.round((startIndex + endIndex) / 2);
+                const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
+                if (distance < hideBuffer)
+                    continue;
+                result.push(pointsOnBezier[middleIndex]);
+            }
+        }
+    }
+    if (shape === ArrowLineShape.elbow) {
+        const renderPoints = getElbowPoints(board, element);
+        const options = getElbowLineRouteOptions(board, element);
+        if (!isUseDefaultOrthogonalRoute(element, options)) {
+            const [nextSourcePoint, nextTargetPoint] = getNextSourceAndTargetPoints(board, element);
+            for (let i = 0; i < renderPoints.length - 1; i++) {
+                if ((i == 0 && Point.isEquals(renderPoints[i + 1], nextSourcePoint)) ||
+                    (i === renderPoints.length - 2 && Point.isEquals(renderPoints[renderPoints.length - 2], nextTargetPoint))) {
+                    continue;
+                }
+                const [currentX, currentY] = renderPoints[i];
+                const [nextX, nextY] = renderPoints[i + 1];
+                const middlePoint = [(currentX + nextX) / 2, (currentY + nextY) / 2];
+                result.push(middlePoint);
+            }
+        }
+    }
+    return result;
+}
+
 const getCenterPointsOnPolygon = (points) => {
     const centerPoints = [];
     for (let i = 0; i < points.length; i++) {
@@ -6378,6 +6448,10 @@ var MemorizeKey;
     MemorizeKey["UML"] = "UML";
 })(MemorizeKey || (MemorizeKey = {}));
 
+var VectorPenPointerType;
+(function (VectorPenPointerType) {
+    VectorPenPointerType["vectorPen"] = "vectorPen";
+})(VectorPenPointerType || (VectorPenPointerType = {}));
 var VectorLineShape;
 (function (VectorLineShape) {
     VectorLineShape["straight"] = "straight";
@@ -6388,12 +6462,15 @@ const PlaitDrawElement = {
     isGeometry: (value) => {
         return value.type === 'geometry';
     },
-    // isLine: (value: any): value is PlaitArrowLine => {
-    //     return value.type === 'arrow-line' || value.type === 'line' || value.type === 'vector-line';
-    // },
     isArrowLine: (value) => {
         return value.type === 'arrow-line' || value.type === 'line';
     },
+    isVectorLine: (value) => {
+        return value.type === 'vector-line';
+    },
+    isLine: (value) => {
+        return PlaitDrawElement.isArrowLine(value) || PlaitDrawElement.isVectorLine(value);
+    },
     isText: (value) => {
         return value.type === 'geometry' && value.shape === BasicShapes.text;
     },
@@ -6405,7 +6482,7 @@ const PlaitDrawElement = {
     },
     isDrawElement: (value) => {
         if (PlaitDrawElement.isGeometry(value) ||
-            PlaitDrawElement.isArrowLine(value) ||
+            PlaitDrawElement.isLine(value) ||
             PlaitDrawElement.isImage(value) ||
             PlaitDrawElement.isTable(value) ||
             PlaitDrawElement.isSwimlane(value)) {
@@ -6656,7 +6733,54 @@ class GeometryComponent extends CommonElementFlavour {
     }
 }
 
-class ArrowLineActiveGenerator extends Generator {
+var LineResizeHandle;
+(function (LineResizeHandle) {
+    LineResizeHandle["source"] = "source";
+    LineResizeHandle["target"] = "target";
+    LineResizeHandle["addHandle"] = "addHandle";
+})(LineResizeHandle || (LineResizeHandle = {}));
+const getHitLineResizeHandleRef = (board, element, point) => {
+    let dataPoints = PlaitDrawElement.isArrowLine(element) ? PlaitArrowLine.getPoints(board, element) : element.points;
+    const index = getHitPointIndex(dataPoints, point);
+    if (index !== -1) {
+        const handleIndex = index;
+        if (index === 0) {
+            return { handle: LineResizeHandle.source, handleIndex };
+        }
+        if (index === dataPoints.length - 1) {
+            return { handle: LineResizeHandle.target, handleIndex };
+        }
+        // elbow line, data points only verify source connection point and target connection point
+        if (element.shape !== ArrowLineShape.elbow) {
+            return { handleIndex };
+        }
+    }
+    const middlePoints = getMiddlePoints(board, element);
+    const indexOfMiddlePoints = getHitPointIndex(middlePoints, point);
+    if (indexOfMiddlePoints !== -1) {
+        return {
+            handle: LineResizeHandle.addHandle,
+            handleIndex: indexOfMiddlePoints
+        };
+    }
+    return undefined;
+};
+function getHitPointIndex(points, movingPoint) {
+    const rectangles = points.map(point => {
+        return {
+            x: point[0] - RESIZE_HANDLE_DIAMETER / 2,
+            y: point[1] - RESIZE_HANDLE_DIAMETER / 2,
+            width: RESIZE_HANDLE_DIAMETER,
+            height: RESIZE_HANDLE_DIAMETER
+        };
+    });
+    const rectangle = rectangles.find(rectangle => {
+        return RectangleClient.isHit(RectangleClient.getRectangleByPoints([movingPoint, movingPoint]), rectangle);
+    });
+    return rectangle ? rectangles.indexOf(rectangle) : -1;
+}
+
+class LineActiveGenerator extends Generator {
     constructor() {
         super(...arguments);
         this.onlySelectedCurrentLine = false;
@@ -6676,7 +6800,7 @@ class ArrowLineActiveGenerator extends Generator {
         if (this.onlySelectedCurrentLine) {
             activeG.classList.add('active');
             activeG.classList.add('line-handle');
-            const points = PlaitArrowLine.getPoints(this.board, element);
+            const points = PlaitDrawElement.isArrowLine(element) ? PlaitArrowLine.getPoints(this.board, element) : element.points;
             let updatePoints = [...points];
             let elbowNextRenderPoints = [];
             if (element.shape === ArrowLineShape.elbow) {
@@ -6738,7 +6862,7 @@ class ArrowLineComponent extends CommonElementFlavour {
     }
     initializeGenerator() {
         this.shapeGenerator = new ArrowLineShapeGenerator(this.board);
-        this.activeGenerator = new ArrowLineActiveGenerator(this.board);
+        this.activeGenerator = new LineActiveGenerator(this.board);
         this.initializeTextManagesByElement();
     }
     initialize() {
@@ -6878,6 +7002,51 @@ class ArrowLineComponent extends CommonElementFlavour {
     }
 }
 
+class VectorLineComponent extends CommonElementFlavour {
+    constructor() {
+        super();
+    }
+    initializeGenerator() {
+        this.shapeGenerator = new VectorLineShapeGenerator(this.board);
+        this.activeGenerator = new LineActiveGenerator(this.board);
+    }
+    initialize() {
+        this.initializeGenerator();
+        this.shapeGenerator.processDrawing(this.element, this.getElementG());
+        const linePoints = getVectorLinePoints(this.board, this.element);
+        this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
+            selected: this.selected,
+            linePoints
+        });
+        super.initialize();
+    }
+    onContextChanged(value, previous) {
+        this.initializeWeakMap();
+        const isChangeTheme = this.board.operations.find(op => op.type === 'set_theme');
+        const linePoints = getVectorLinePoints(this.board, this.element);
+        if (value.element !== previous.element || isChangeTheme) {
+            this.shapeGenerator.processDrawing(this.element, this.getElementG());
+            this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
+                selected: this.selected,
+                linePoints
+            });
+        }
+        else {
+            const needUpdate = value.selected !== previous.selected || this.activeGenerator.needUpdate();
+            if (needUpdate) {
+                this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
+                    selected: this.selected,
+                    linePoints
+                });
+            }
+        }
+    }
+    destroy() {
+        super.destroy();
+        this.activeGenerator.destroy();
+    }
+}
+
 const withDrawHotkey = (board) => {
     const { keyDown, dblClick } = board;
     board.keyDown = (event) => {
@@ -7197,7 +7366,8 @@ const withDrawFragment = (baseBoard) => {
         const drawElements = getSelectedDrawElements(board);
         if (drawElements.length) {
             const geometryElements = drawElements.filter(value => PlaitDrawElement.isGeometry(value));
-            const lineElements = drawElements.filter(value => PlaitDrawElement.isArrowLine(value));
+            const arrowLineElements = drawElements.filter(value => PlaitDrawElement.isArrowLine(value));
+            const vectorLineElements = drawElements.filter(value => PlaitDrawElement.isVectorLine(value));
             const imageElements = drawElements.filter(value => PlaitDrawElement.isImage(value));
             const tableElements = drawElements.filter(value => PlaitDrawElement.isTable(value));
             const swimlaneElements = drawElements.filter(value => PlaitDrawElement.isSwimlane(value));
@@ -7206,14 +7376,15 @@ const withDrawFragment = (baseBoard) => {
                 ...getBoundedArrowLineElements(board, imageElements),
                 ...getBoundedArrowLineElements(board, tableElements),
                 ...getBoundedArrowLineElements(board, swimlaneElements)
-            ].filter(line => !lineElements.includes(line));
+            ].filter(line => !arrowLineElements.includes(line));
             data.push(...[
                 ...geometryElements,
-                ...lineElements,
+                ...arrowLineElements,
+                ...vectorLineElements,
                 ...imageElements,
                 ...tableElements,
                 ...swimlaneElements,
-                ...boundLineElements.filter(line => !lineElements.includes(line))
+                ...boundLineElements.filter(line => !arrowLineElements.includes(line))
             ]);
         }
         return getDeletedFragment(data);
@@ -7407,7 +7578,7 @@ const withArrowLineResize = (board) => {
             if (selectedLineElements.length > 0) {
                 let result = null;
                 selectedLineElements.forEach(value => {
-                    const handleRef = getHitArrowLineResizeHandleRef(board, value, point);
+                    const handleRef = getHitLineResizeHandleRef(board, value, point);
                     if (handleRef) {
                         result = {
                             element: value,
@@ -7422,8 +7593,8 @@ const withArrowLineResize = (board) => {
         },
         beforeResize: (resizeRef) => {
             if (resizeRef.element.shape === ArrowLineShape.elbow &&
-                resizeRef.handle !== ArrowLineResizeHandle.source &&
-                resizeRef.handle !== ArrowLineResizeHandle.target) {
+                resizeRef.handle !== LineResizeHandle.source &&
+                resizeRef.handle !== LineResizeHandle.target) {
                 const params = getElbowLineRouteOptions(board, resizeRef.element);
                 if (isUseDefaultOrthogonalRoute(resizeRef.element, params)) {
                     return;
@@ -7445,8 +7616,8 @@ const withArrowLineResize = (board) => {
             let target = { ...resizeRef.element.target };
             let handleIndex = resizeRef.handleIndex;
             const hitElement = getSnappingShape(board, resizeState.endPoint);
-            if (resizeRef.handle === ArrowLineResizeHandle.source || resizeRef.handle === ArrowLineResizeHandle.target) {
-                const object = resizeRef.handle === ArrowLineResizeHandle.source ? source : target;
+            if (resizeRef.handle === LineResizeHandle.source || resizeRef.handle === LineResizeHandle.target) {
+                const object = resizeRef.handle === LineResizeHandle.source ? source : target;
                 points[handleIndex] = resizeState.endPoint;
                 if (hitElement) {
                     object.connection = getHitConnection(board, resizeState.endPoint, hitElement);
@@ -7477,7 +7648,7 @@ const withArrowLineResize = (board) => {
                     }
                 }
                 else {
-                    if (resizeRef.handle === ArrowLineResizeHandle.addHandle) {
+                    if (resizeRef.handle === LineResizeHandle.addHandle) {
                         points.splice(handleIndex + 1, 0, resizeState.endPoint);
                     }
                     else {
@@ -7486,7 +7657,7 @@ const withArrowLineResize = (board) => {
                 }
             }
             if (!hitElement) {
-                handleIndex = resizeRef.handle === ArrowLineResizeHandle.addHandle ? handleIndex + 1 : handleIndex;
+                handleIndex = resizeRef.handle === LineResizeHandle.addHandle ? handleIndex + 1 : handleIndex;
                 const drawPoints = getArrowLinePoints(board, resizeRef.element);
                 const newPoints = [...points];
                 newPoints[0] = drawPoints[0];
@@ -7552,7 +7723,7 @@ const withArrowLineBoundReaction = (board) => {
         const movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
         const isLineResizing = isResizingByCondition(board, resizeRef => {
             const { element, handle } = resizeRef;
-            const isSourceOrTarget = handle === ArrowLineResizeHandle.target || handle === ArrowLineResizeHandle.source;
+            const isSourceOrTarget = handle === LineResizeHandle.target || handle === LineResizeHandle.source;
             return PlaitDrawElement.isArrowLine(element) && isSourceOrTarget;
         });
         if (isLinePointer || isLineResizing) {
@@ -8475,6 +8646,179 @@ const withSwimlane = (board) => {
     return withSwimlaneCreateByDrawing(withSwimlaneCreateByDrag(board));
 };
 
+const withVectorPenCreateByDraw = (board) => {
+    const { pointerDown, pointerMove, dblClick, globalKeyDown } = board;
+    let lineShapeG = null;
+    let temporaryElement = null;
+    let vectorPenRef;
+    const vectorLineComplete = () => {
+        if (vectorPenRef) {
+            clearSelectedElement(board);
+            if (vectorPenRef?.element) {
+                addSelectedElement(board, vectorPenRef?.element);
+            }
+        }
+        PlaitBoard.getBoardContainer(board).classList.remove(`vector-line-closed`);
+        lineShapeG?.remove();
+        lineShapeG = null;
+        vectorPenRef = null;
+        temporaryElement = null;
+    };
+    board.pointerDown = (event) => {
+        const penPointers = getVectorPenPointers();
+        const isVectorPenPointer = PlaitBoard.isInPointer(board, penPointers);
+        if (isVectorPenPointer && !vectorPenRef) {
+            vectorPenRef = { shape: VectorLineShape.straight };
+        }
+        if (!PlaitBoard.isReadonly(board) && vectorPenRef && isDrawingMode(board)) {
+            let point = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+            if (!temporaryElement) {
+                vectorPenRef = {
+                    ...vectorPenRef,
+                    start: point
+                };
+            }
+            else {
+                if (!vectorPenRef.element) {
+                    vectorPenRef.element = temporaryElement;
+                    Transforms.insertNode(board, vectorPenRef.element, [board.children.length]);
+                }
+                else {
+                    let points = vectorPenRef.element.points;
+                    const isClosed = distanceBetweenPointAndPoint(...point, ...vectorPenRef.start) <= LINE_HIT_GEOMETRY_BUFFER;
+                    if (isClosed) {
+                        point = vectorPenRef.start;
+                    }
+                    if (vectorPenRef.path) {
+                        const lastPoint = points[points.length - 1];
+                        const distance = distanceBetweenPointAndPoint(...point, ...lastPoint);
+                        if (distance > 2) {
+                            Transforms.setNode(board, { points: [...points, point] }, vectorPenRef.path);
+                        }
+                    }
+                    vectorPenRef.element = getElementById(board, vectorPenRef.element.id);
+                    if (isClosed) {
+                        vectorLineComplete();
+                    }
+                }
+                preventTouchMove(board, event, true);
+            }
+        }
+        pointerDown(event);
+    };
+    board.pointerMove = (event) => {
+        lineShapeG?.remove();
+        lineShapeG = createG();
+        let movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        const pointer = PlaitBoard.getPointer(board);
+        if (pointer !== VectorPenPointerType.vectorPen) {
+            vectorLineComplete();
+        }
+        if (vectorPenRef && vectorPenRef.start) {
+            let drawPoints = [vectorPenRef.start];
+            if (vectorPenRef.element) {
+                drawPoints = [vectorPenRef.start, ...vectorPenRef.element.points];
+                const path = PlaitBoard.findPath(board, vectorPenRef.element);
+                vectorPenRef.path = path;
+            }
+            const distance = distanceBetweenPointAndPoint(...movingPoint, ...vectorPenRef.start);
+            if (distance <= LINE_HIT_GEOMETRY_BUFFER) {
+                movingPoint = vectorPenRef.start;
+                PlaitBoard.getBoardContainer(board).classList.add(`vector-line-closed`);
+            }
+            else {
+                PlaitBoard.getBoardContainer(board).classList.remove(`vector-line-closed`);
+            }
+            temporaryElement = vectorLineCreating(board, vectorPenRef.shape, drawPoints, movingPoint, lineShapeG);
+        }
+        pointerMove(event);
+    };
+    board.dblClick = (event) => {
+        if (!PlaitBoard.isReadonly(board)) {
+            if (vectorPenRef) {
+                if (vectorPenRef.path) {
+                    Transforms.setNode(board, { points: vectorPenRef?.element?.points }, vectorPenRef.path);
+                }
+                vectorLineComplete();
+                BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+            }
+        }
+        dblClick(event);
+    };
+    board.globalKeyDown = (event) => {
+        if (!PlaitBoard.isReadonly(board)) {
+            const isEsc = isKeyHotkey('esc', event);
+            const isV = isKeyHotkey('v', event);
+            if ((isEsc || isV) && vectorPenRef) {
+                if (vectorPenRef.path) {
+                    Transforms.setNode(board, { points: vectorPenRef.element?.points }, vectorPenRef.path);
+                }
+                vectorLineComplete();
+                if (isV) {
+                    BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+                }
+            }
+        }
+        globalKeyDown(event);
+    };
+    return board;
+};
+
+const withVectorLineResize = (board) => {
+    const options = {
+        key: 'draw-vector-line',
+        canResize: () => {
+            return true;
+        },
+        hitTest: (point) => {
+            const selectedVectorLineElements = getSelectedVectorLineElements(board);
+            if (selectedVectorLineElements.length > 0) {
+                let result = null;
+                selectedVectorLineElements.forEach(value => {
+                    const handleRef = getHitLineResizeHandleRef(board, value, point);
+                    if (handleRef) {
+                        result = {
+                            element: value,
+                            handle: handleRef.handle,
+                            handleIndex: handleRef.handleIndex
+                        };
+                    }
+                });
+                return result;
+            }
+            return null;
+        },
+        onResize: (resizeRef, resizeState) => {
+            let points = [...resizeRef.element.points];
+            let handleIndex = resizeRef.handleIndex;
+            if (resizeRef.handle === LineResizeHandle.source || resizeRef.handle === LineResizeHandle.target) {
+                points[handleIndex] = resizeState.endPoint;
+                if (isClosedVectorLine(resizeRef.element)) {
+                    points[points.length - 1] = resizeState.endPoint;
+                }
+                else {
+                    const targetPoint = resizeRef.handle === LineResizeHandle.source ? points[points.length - 1] : points[0];
+                    const distance = distanceBetweenPointAndPoint(...resizeState.endPoint, ...targetPoint);
+                    if (distance <= LINE_HIT_GEOMETRY_BUFFER) {
+                        points[handleIndex] = targetPoint;
+                    }
+                }
+            }
+            else {
+                if (resizeRef.handle === LineResizeHandle.addHandle) {
+                    points.splice(handleIndex + 1, 0, resizeState.endPoint);
+                }
+                else {
+                    points[handleIndex] = resizeState.endPoint;
+                }
+            }
+            Transforms.setNode(board, { points }, resizeRef.path);
+        }
+    };
+    withResize(board, options);
+    return board;
+};
+
 const withDraw = (board) => {
     const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment, getHitElement } = board;
     board.drawElement = (context) => {
@@ -8487,6 +8831,9 @@ const withDraw = (board) => {
         else if (PlaitDrawElement.isArrowLine(context.element)) {
             return ArrowLineComponent;
         }
+        else if (PlaitDrawElement.isVectorLine(context.element)) {
+            return VectorLineComponent;
+        }
         else if (PlaitDrawElement.isImage(context.element)) {
             return ImageComponent;
         }
@@ -8505,6 +8852,11 @@ const withDraw = (board) => {
             const linePointsRectangle = RectangleClient.getRectangleByPoints(points);
             return RectangleClient.getBoundingRectangle([linePointsRectangle, ...lineTextRectangles]);
         }
+        if (PlaitDrawElement.isVectorLine(element)) {
+            const points = getVectorLinePoints(board, element);
+            const linePointsRectangle = RectangleClient.getRectangleByPoints(points);
+            return RectangleClient.getBoundingRectangle([linePointsRectangle]);
+        }
         if (PlaitDrawElement.isImage(element)) {
             return RectangleClient.getRectangleByPoints(element.points);
         }
@@ -8545,6 +8897,9 @@ const withDraw = (board) => {
         if (PlaitDrawElement.isImage(element)) {
             return true;
         }
+        if (PlaitDrawElement.isVectorLine(element)) {
+            return true;
+        }
         if (PlaitDrawElement.isArrowLine(element)) {
             const selectedElements = getSelectedElements(board);
             const isSelected = (boundId) => {
@@ -8580,12 +8935,12 @@ const withDraw = (board) => {
         });
         return getRelatedFragment([...elements, ...activeLines], originData);
     };
-    return withSwimlane(withTable(withDrawResize(withArrowLineAutoCompleteReaction(withArrowLineBoundReaction(withArrowLineResize(withArrowLineTextMove(withArrowLineText(withGeometryResize(withDrawRotate(withArrowLineCreateByDraw(withArrowLineAutoComplete(withGeometryCreateByDrag(withGeometryCreateByDrawing(withDrawFragment(withDrawHotkey(board))))))))))))))));
+    return withSwimlane(withTable(withDrawResize(withVectorPenCreateByDraw(withArrowLineAutoCompleteReaction(withArrowLineBoundReaction(withVectorLineResize(withArrowLineResize(withArrowLineTextMove(withArrowLineText(withGeometryResize(withDrawRotate(withArrowLineCreateByDraw(withArrowLineAutoComplete(withGeometryCreateByDrag(withGeometryCreateByDrawing(withDrawFragment(withDrawHotkey(board))))))))))))))))));
 };
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ArrowLineActiveGenerator, ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryCommonTextKeys, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, StrokeStyle, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineShape, WithArrowLineAutoCompletePluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getDrawHitElement, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, handleArrowLineCreating, hasIllegalElbowPoint, insertElement, isCellIncludeText, isDrawElementClosed, isDrawElementIncludeText, isDrawElementsIncludeText, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isSelfLoop, isSingleSelectElementByTable, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, withArrowLineAutoComplete, withDraw };
+export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryCommonTextKeys, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, StrokeStyle, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLineShape, VectorPenPointerType, WithArrowLineAutoCompletePluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, createVectorLineElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, drawVectorLine, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getDrawHitElement, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePoints, getVectorPenPointers, handleArrowLineCreating, hasIllegalElbowPoint, insertElement, isCellIncludeText, isClosedVectorLine, isDrawElementClosed, isDrawElementIncludeText, isDrawElementsIncludeText, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isSelfLoop, isSingleSelectElementByTable, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
 //# sourceMappingURL=plait-draw.mjs.map