@plait/draw 0.58.0 → 0.59.0

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, ThemeColorMode, RectangleClient, idCreator, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, rotateAntiPointsByElement, depthFirstRecursion, PlaitBoard, getIsRecursionFunc, createG, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, catmullRomFitting, setStrokeLinecap, findElements, createMask, createRect, PlaitElement, getSelectedElements, getElementById, rotatePointsByElement, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPolylineHitRectangle, Path, Direction, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, 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 as drawLine$1, 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 } from '@plait/core';
-import { WithTextPluginKey, ELEMENT_TO_TEXT_MANAGES, getMemorizedLatest, memorizeLatest, getTextEditors, Generator, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, getPointOnPolyline, RESIZE_HANDLE_DIAMETER, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, TRANSPARENT, getDirectionByVector, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, 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, 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, getSelectedElements, getElementById, Path, Direction, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, 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 as drawLine$1, 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 } from '@plait/core';
+import { WithTextPluginKey, ELEMENT_TO_TEXT_MANAGES, getMemorizedLatest, memorizeLatest, RESIZE_HANDLE_DIAMETER, getPointOnPolyline, TRANSPARENT, getTextEditorsByElement, Generator, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, getDirectionByVector, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, 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 { Alignment, TextManage, buildText, DEFAULT_FONT_SIZE, getTextSize, AlignEditor } from '@plait/text';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import { isKeyHotkey } from 'is-hotkey';
@@ -272,12 +272,13 @@ const MultipleTextGeometryTextKeys = {
 };
 const DefaultSwimlanePropertyMap = {
     [SwimlaneSymbols.swimlaneHorizontal]: DefaultSwimlaneHorizontalProperty,
-    [SwimlaneSymbols.swimlaneVertical]: DefaultSwimlaneVerticalProperty,
+    [SwimlaneSymbols.swimlaneVertical]: DefaultSwimlaneVerticalProperty
 };
 const LINE_HIT_GEOMETRY_BUFFER = 10;
 const LINE_SNAPPING_BUFFER = 6;
 const LINE_SNAPPING_CONNECTOR_BUFFER = 8;
 const GEOMETRY_WITHOUT_TEXT = [FlowchartSymbols.or, FlowchartSymbols.summingJunction];
+const GEOMETRY_WITH_MULTIPLE_TEXT = [UMLSymbols.package, UMLSymbols.combinedFragment];
 
 const getGeometryPointers = () => {
     return [...Object.keys(BasicShapes), ...Object.keys(FlowchartSymbols), ...Object.keys(UMLSymbols)];
@@ -364,23 +365,15 @@ class TextGenerator {
         const textPlugins = (this.board.getPluginOptions(WithTextPluginKey) || {}).textPlugins;
         this.textManages = this.texts.map(text => {
             const textManage = this.createTextManage(text, textPlugins);
-            setTextManage(this.getTextKey(text), textManage);
+            setTextManage(getTextKey(this.element, text), textManage);
             return textManage;
         });
         ELEMENT_TO_TEXT_MANAGES.set(this.element, this.textManages);
     }
-    getTextKey(text) {
-        if (isMultipleTextGeometry(this.element)) {
-            return `${this.element.id}-${text.key}`;
-        }
-        else {
-            return text.key;
-        }
-    }
     draw(elementG) {
         const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
         this.texts.forEach(drawShapeText => {
-            const textManage = getTextManage(this.getTextKey(drawShapeText));
+            const textManage = getTextManage(getTextKey(this.element, drawShapeText));
             if (drawShapeText.text && textManage) {
                 textManage.draw(drawShapeText.text);
                 elementG.append(textManage.g);
@@ -409,7 +402,7 @@ class TextGenerator {
         }
         currentDrawShapeTexts.forEach(drawShapeText => {
             if (drawShapeText.text) {
-                let textManage = getTextManage(this.getTextKey(drawShapeText));
+                let textManage = getTextManage(getTextKey(this.element, drawShapeText));
                 if (!textManage) {
                     textManage = this.createTextManage(drawShapeText, textPlugins);
                     setTextManage(drawShapeText.key, textManage);
@@ -682,6 +675,268 @@ const getMemorizedLatestShape = (board) => {
     return memorizedShape.get(board);
 };
 
+var LineResizeHandle;
+(function (LineResizeHandle) {
+    LineResizeHandle["source"] = "source";
+    LineResizeHandle["target"] = "target";
+    LineResizeHandle["addHandle"] = "addHandle";
+})(LineResizeHandle || (LineResizeHandle = {}));
+const getHitLineResizeHandleRef = (board, element, point) => {
+    let dataPoints = PlaitLine.getPoints(board, element);
+    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 !== LineShape.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;
+}
+const getHitLineTextIndex = (board, element, point) => {
+    const texts = element.texts;
+    if (!texts.length)
+        return -1;
+    const points = getLinePoints(board, element);
+    return texts.findIndex(text => {
+        const center = getPointOnPolyline(points, text.position);
+        const rectangle = {
+            x: center[0] - text.width / 2,
+            y: center[1] - text.height / 2,
+            width: text.width,
+            height: text.height
+        };
+        return RectangleClient.isHit(rectangle, RectangleClient.getRectangleByPoints([point, point]));
+    });
+};
+
+const isMultipleTextShape = (shape) => {
+    return GEOMETRY_WITH_MULTIPLE_TEXT.includes(shape);
+};
+const isMultipleTextGeometry = (geometry) => {
+    return PlaitDrawElement.isGeometry(geometry) && isMultipleTextShape(geometry.shape);
+};
+const getMultipleTextGeometryTextKeys = (shape) => {
+    return MultipleTextGeometryTextKeys[shape];
+};
+const createMultipleTextGeometryElement = (shape, points, options = {}) => {
+    const id = idCreator();
+    const drawShapeTexts = buildDefaultTextsByShape(shape, id);
+    return {
+        id,
+        type: 'geometry',
+        shape,
+        angle: 0,
+        opacity: 1,
+        texts: drawShapeTexts,
+        points,
+        ...options
+    };
+};
+const buildDefaultTextsByShape = (shape, elementId) => {
+    const memorizedLatest = getMemorizedLatestByPointer(shape);
+    const textProperties = { ...memorizedLatest.textProperties };
+    const alignment = textProperties?.align;
+    const textHeight = textProperties?.textHeight || DefaultTextProperty.height;
+    delete textProperties?.align;
+    delete textProperties?.textHeight;
+    const defaultTexts = getDefaultGeometryProperty(shape)?.texts || [];
+    const textKeys = getMultipleTextGeometryTextKeys(shape);
+    return (textKeys || []).map((textKey) => {
+        const text = defaultTexts?.find((item) => item?.key === textKey);
+        return {
+            key: textKey,
+            text: buildText(text?.text || '', alignment || text?.align || Alignment.center, textProperties),
+            textHeight: textHeight
+        };
+    });
+};
+const getHitMultipleGeometryText = (element, point) => {
+    const engine = getEngine(element.shape);
+    const rectangle = RectangleClient.getRectangleByPoints([point, point]);
+    let hitText;
+    if (engine.getTextRectangle) {
+        hitText = element.texts.find(text => {
+            const textRectangle = engine.getTextRectangle(element, { key: text.key });
+            return RectangleClient.isHit(rectangle, textRectangle);
+        });
+    }
+    return hitText;
+};
+
+const isTextExceedingBounds = (geometry) => {
+    const client = RectangleClient.getRectangleByPoints(geometry.points);
+    if (geometry.textHeight && geometry.textHeight > client.height) {
+        return true;
+    }
+    return false;
+};
+const isHitLineText = (board, element, point) => {
+    return getHitLineTextIndex(board, element, point) !== -1;
+};
+const isHitPolyLine = (pathPoints, point) => {
+    const distance = distanceBetweenPointAndSegments(pathPoints, point);
+    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 isHitElementText = (element, point) => {
+    const engine = getEngine(element.shape);
+    if (isMultipleTextGeometry(element)) {
+        const texts = element.texts;
+        return texts.some(item => {
+            const textClient = engine.getTextRectangle(element, { key: item.key });
+            return RectangleClient.isPointInRectangle(textClient, point);
+        });
+    }
+    else {
+        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
+        return RectangleClient.isPointInRectangle(textClient, point);
+    }
+};
+const isRectangleHitElementText = (element, rectangle) => {
+    const engine = getEngine(element.shape);
+    if (isMultipleTextGeometry(element)) {
+        const texts = element.texts;
+        return texts.some(item => {
+            const textClient = engine.getTextRectangle(element, { key: item.key });
+            const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
+            return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
+        });
+    }
+    else {
+        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
+        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
+        return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
+    }
+};
+const isRectangleHitDrawElement = (board, element, selection) => {
+    const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
+    if (PlaitDrawElement.isGeometry(element)) {
+        const client = RectangleClient.getRectangleByPoints(element.points);
+        let rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
+        const isHitElement = isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
+        if (isHitElement) {
+            return isHitElement;
+        }
+        return isRectangleHitElementText(element, rangeRectangle);
+    }
+    if (PlaitDrawElement.isImage(element)) {
+        const client = RectangleClient.getRectangleByPoints(element.points);
+        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
+        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
+    }
+    if (PlaitDrawElement.isLine(element)) {
+        const points = getLinePoints(board, element);
+        return isPolylineHitRectangle(points, rangeRectangle);
+    }
+    return null;
+};
+const isHitDrawElement = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    point = rotateAntiPointsByElement(point, element) || point;
+    if (PlaitDrawElement.isGeometry(element)) {
+        const fill = getFillByElement(board, element);
+        if (isHitEdgeOfShape(board, element, point, HIT_DISTANCE_BUFFER)) {
+            return true;
+        }
+        const engine = getEngine(getElementShape(element));
+        // when shape equals text, fill is not allowed
+        if (fill !== DefaultDrawStyle.fill && fill !== TRANSPARENT && !PlaitDrawElement.isText(element)) {
+            const isHitInside = engine.isInsidePoint(rectangle, point);
+            if (isHitInside) {
+                return isHitInside;
+            }
+        }
+        else {
+            // if shape equals text, only check text rectangle
+            if (PlaitDrawElement.isText(element)) {
+                const textClient = getTextRectangle(element);
+                let isHitText = RectangleClient.isPointInRectangle(textClient, point);
+                return isHitText;
+            }
+            // check textRectangle of element
+            const isHitText = isHitElementText(element, point);
+            if (isHitText) {
+                return isHitText;
+            }
+        }
+    }
+    if (PlaitDrawElement.isImage(element)) {
+        const client = RectangleClient.getRectangleByPoints(element.points);
+        return RectangleClient.isPointInRectangle(client, point);
+    }
+    if (PlaitDrawElement.isLine(element)) {
+        return isHitLine(board, element, point);
+    }
+    return null;
+};
+const isHitEdgeOfShape = (board, element, point, hitDistanceBuffer) => {
+    const nearestPoint = getNearestPoint(element, point);
+    const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);
+    return distance <= hitDistanceBuffer;
+};
+const isInsideOfShape = (board, element, point, hitDistanceBuffer) => {
+    const client = RectangleClient.inflate(RectangleClient.getRectangleByPoints(element.points), hitDistanceBuffer);
+    return getEngine(getElementShape(element)).isInsidePoint(client, point);
+};
+const isHitElementInside = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    point = rotateAntiPointsByElement(point, element) || point;
+    if (PlaitDrawElement.isGeometry(element)) {
+        const engine = getEngine(getElementShape(element));
+        const isHitInside = engine.isInsidePoint(rectangle, point);
+        if (isHitInside) {
+            return isHitInside;
+        }
+        if (engine.getTextRectangle) {
+            const isHitText = isHitElementText(element, point);
+            if (isHitText) {
+                return isHitText;
+            }
+        }
+    }
+    if (PlaitDrawElement.isImage(element)) {
+        const client = RectangleClient.getRectangleByPoints(element.points);
+        return RectangleClient.isPointInRectangle(client, point);
+    }
+    if (PlaitDrawElement.isLine(element)) {
+        return isHitLine(board, element, point);
+    }
+    return null;
+};
+
 const getTextRectangle = (element) => {
     const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
     const strokeWidth = getStrokeWidthByElement(element);
@@ -708,25 +963,28 @@ const insertElement = (board, element) => {
     addSelectedElement(board, element);
     BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
 };
+const isDrawElementIncludeText = (element) => {
+    if (PlaitDrawElement.isText(element)) {
+        return true;
+    }
+    if (PlaitDrawElement.isImage(element)) {
+        return false;
+    }
+    if (PlaitDrawElement.isGeometry(element)) {
+        return isGeometryIncludeText(element);
+    }
+    if (PlaitDrawElement.isLine(element)) {
+        const editors = getTextEditorsByElement(element);
+        return editors.length > 0;
+    }
+    if (PlaitDrawElement.isTable(element)) {
+        return element.cells.some(cell => isCellIncludeText(cell));
+    }
+    return true;
+};
 const isDrawElementsIncludeText = (elements) => {
     return elements.some(item => {
-        if (PlaitDrawElement.isText(item)) {
-            return true;
-        }
-        if (PlaitDrawElement.isImage(item)) {
-            return false;
-        }
-        if (PlaitDrawElement.isGeometry(item)) {
-            return isGeometryIncludeText(item);
-        }
-        if (PlaitDrawElement.isLine(item)) {
-            const editors = getTextEditors(item);
-            return editors.length > 0;
-        }
-        if (PlaitDrawElement.isTable(item)) {
-            return item.cells.some(cell => isCellIncludeText(cell));
-        }
-        return true;
+        return isDrawElementIncludeText(item);
     });
 };
 const getSnappingShape = (board, point) => {
@@ -802,6 +1060,28 @@ const drawBoundReaction = (board, element, roughOptions = { hasMask: true, hasCo
     }
     return g;
 };
+const getTextKey = (element, text) => {
+    if (isMultipleTextGeometry(element)) {
+        return `${element.id}-${text.key}`;
+    }
+    else {
+        return text.key;
+    }
+};
+const getGeometryAlign = (element) => {
+    if (isMultipleTextGeometry(element)) {
+        const drawShapeText = element.texts.find(item => item.key.includes(MultipleTextGeometryCommonTextKeys.content));
+        return drawShapeText?.text.align || Alignment.center;
+    }
+    if (isSingleTextGeometry(element)) {
+        return element.text?.align || Alignment.center;
+    }
+    if (PlaitDrawElement.isTable(element)) {
+        const firstTextCell = element.cells.find(item => item.text);
+        return firstTextCell?.text?.align || Alignment.center;
+    }
+    return Alignment.center;
+};
 
 const getStrokeColorByElement = (board, element) => {
     const defaultColor = getDrawDefaultStrokeColor(board.theme.themeColorMode);
@@ -1476,99 +1756,45 @@ const handleLineCreating = (board, lineShape, sourcePoint, movingPoint, sourceEl
     const memorizedLatest = getLineMemorizedLatest();
     let sourceMarker, targetMarker;
     sourceMarker = memorizedLatest.source;
-    targetMarker = memorizedLatest.target;
-    sourceMarker && delete memorizedLatest.source;
-    targetMarker && delete memorizedLatest.target;
-    const temporaryLineElement = createLineElement(lineShape, [sourcePoint, movingPoint], { marker: sourceMarker || LineMarkerType.none, connection: sourceConnection, boundId: sourceElement?.id }, { marker: targetMarker || LineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId }, [], {
-        strokeWidth: DefaultLineStyle.strokeWidth,
-        ...memorizedLatest
-    });
-    const linePoints = getLinePoints(board, temporaryLineElement);
-    const otherPoint = linePoints[0];
-    temporaryLineElement.points[1] = alignPoints(otherPoint, movingPoint);
-    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);
-    PlaitBoard.getElementActiveHost(board).append(lineShapeG);
-    return temporaryLineElement;
-};
-function drawMask(board, element, id) {
-    const mask = createMask();
-    mask.setAttribute('id', id);
-    const points = getLinePoints(board, element);
-    let rectangle = RectangleClient.getRectangleByPoints(points);
-    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);
-    const maskFillRect = createRect(rectangle, {
-        fill: 'white'
-    });
-    mask.appendChild(maskFillRect);
-    const texts = element.texts;
-    texts.forEach((text, index) => {
-        let textRectangle = getLineTextRectangle(board, element, index);
-        textRectangle = RectangleClient.inflate(textRectangle, LINE_TEXT_SPACE * 2);
-        const rect = createRect(textRectangle, {
-            fill: 'black'
-        });
-        mask.appendChild(rect);
-    });
-    // open line
-    const maskTargetFillRect = createRect(rectangle);
-    maskTargetFillRect.setAttribute('opacity', '0');
-    maskTargetFillRect.setAttribute('fill', 'none');
-    return { mask, maskTargetFillRect };
-}
-
-const isMultipleTextShape = (shape) => {
-    return [UMLSymbols.package, UMLSymbols.combinedFragment].includes(shape);
-};
-const isMultipleTextGeometry = (geometry) => {
-    return !!geometry.texts;
-};
-const getMultipleTextGeometryTextKeys = (shape) => {
-    return MultipleTextGeometryTextKeys[shape];
-};
-const createMultipleTextGeometryElement = (shape, points, options = {}) => {
-    const id = idCreator();
-    const drawShapeTexts = buildDefaultTextsByShape(shape, id);
-    return {
-        id,
-        type: 'geometry',
-        shape,
-        angle: 0,
-        opacity: 1,
-        texts: drawShapeTexts,
-        points,
-        ...options
-    };
-};
-const buildDefaultTextsByShape = (shape, elementId) => {
-    const memorizedLatest = getMemorizedLatestByPointer(shape);
-    const textProperties = { ...memorizedLatest.textProperties };
-    const alignment = textProperties?.align;
-    const textHeight = textProperties?.textHeight || DefaultTextProperty.height;
-    delete textProperties?.align;
-    delete textProperties?.textHeight;
-    const defaultTexts = getDefaultGeometryProperty(shape)?.texts || [];
-    const textKeys = getMultipleTextGeometryTextKeys(shape);
-    return (textKeys || []).map((textKey) => {
-        const text = defaultTexts?.find((item) => item?.key === textKey);
-        return {
-            key: textKey,
-            text: buildText(text?.text || '', alignment || text?.align || Alignment.center, textProperties),
-            textHeight: textHeight
-        };
+    targetMarker = memorizedLatest.target;
+    sourceMarker && delete memorizedLatest.source;
+    targetMarker && delete memorizedLatest.target;
+    const temporaryLineElement = createLineElement(lineShape, [sourcePoint, movingPoint], { marker: sourceMarker || LineMarkerType.none, connection: sourceConnection, boundId: sourceElement?.id }, { marker: targetMarker || LineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId }, [], {
+        strokeWidth: DefaultLineStyle.strokeWidth,
+        ...memorizedLatest
     });
+    const linePoints = getLinePoints(board, temporaryLineElement);
+    const otherPoint = linePoints[0];
+    temporaryLineElement.points[1] = alignPoints(otherPoint, movingPoint);
+    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);
+    PlaitBoard.getElementActiveHost(board).append(lineShapeG);
+    return temporaryLineElement;
 };
-const getHitText = (element, point) => {
-    const engine = getEngine(element.shape);
-    const rectangle = RectangleClient.getRectangleByPoints([point, point]);
-    let hitText;
-    if (engine.getTextRectangle) {
-        hitText = element.texts.find(text => {
-            const textRectangle = engine.getTextRectangle(element, { key: text.key });
-            return RectangleClient.isHit(rectangle, textRectangle);
+function drawMask(board, element, id) {
+    const mask = createMask();
+    mask.setAttribute('id', id);
+    const points = getLinePoints(board, element);
+    let rectangle = RectangleClient.getRectangleByPoints(points);
+    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);
+    const maskFillRect = createRect(rectangle, {
+        fill: 'white'
+    });
+    mask.appendChild(maskFillRect);
+    const texts = element.texts;
+    texts.forEach((text, index) => {
+        let textRectangle = getLineTextRectangle(board, element, index);
+        textRectangle = RectangleClient.inflate(textRectangle, LINE_TEXT_SPACE * 2);
+        const rect = createRect(textRectangle, {
+            fill: 'black'
         });
-    }
-    return hitText;
-};
+        mask.appendChild(rect);
+    });
+    // open line
+    const maskTargetFillRect = createRect(rectangle);
+    maskTargetFillRect.setAttribute('opacity', '0');
+    maskTargetFillRect.setAttribute('fill', 'none');
+    return { mask, maskTargetFillRect };
+}
 
 const createGeometryElement = (shape, points, text, options = {}, textProperties = {}) => {
     if (GEOMETRY_WITHOUT_TEXT.includes(shape)) {
@@ -1785,7 +2011,13 @@ const rerenderGeometryActive = (board, element) => {
     activeGenerator.processDrawing(element, PlaitBoard.getElementActiveHost(board), { selected });
 };
 const isGeometryIncludeText = (element) => {
-    return PlaitDrawElement.isGeometry(element) && element.text && element.textHeight && !GEOMETRY_WITHOUT_TEXT.includes(element.shape);
+    return isSingleTextGeometry(element) || isMultipleTextGeometry(element);
+};
+const isSingleTextShape = (shape) => {
+    return !GEOMETRY_WITHOUT_TEXT.includes(shape) && !isMultipleTextShape(shape);
+};
+const isSingleTextGeometry = (element) => {
+    return PlaitDrawElement.isGeometry(element) && isSingleTextShape(element.shape);
 };
 
 const isSelfLoop = (element) => {
@@ -1924,214 +2156,6 @@ const getSelectedTableElements = (board, elements) => {
     return selectedElements.filter(value => PlaitTableElement.isTable(value));
 };
 
-var LineResizeHandle;
-(function (LineResizeHandle) {
-    LineResizeHandle["source"] = "source";
-    LineResizeHandle["target"] = "target";
-    LineResizeHandle["addHandle"] = "addHandle";
-})(LineResizeHandle || (LineResizeHandle = {}));
-const getHitLineResizeHandleRef = (board, element, point) => {
-    let dataPoints = PlaitLine.getPoints(board, element);
-    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 !== LineShape.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;
-}
-const getHitLineTextIndex = (board, element, point) => {
-    const texts = element.texts;
-    if (!texts.length)
-        return -1;
-    const points = getLinePoints(board, element);
-    return texts.findIndex(text => {
-        const center = getPointOnPolyline(points, text.position);
-        const rectangle = {
-            x: center[0] - text.width / 2,
-            y: center[1] - text.height / 2,
-            width: text.width,
-            height: text.height
-        };
-        return RectangleClient.isHit(rectangle, RectangleClient.getRectangleByPoints([point, point]));
-    });
-};
-
-const isTextExceedingBounds = (geometry) => {
-    const client = RectangleClient.getRectangleByPoints(geometry.points);
-    if (geometry.textHeight && geometry.textHeight > client.height) {
-        return true;
-    }
-    return false;
-};
-const isHitLineText = (board, element, point) => {
-    return getHitLineTextIndex(board, element, point) !== -1;
-};
-const isHitPolyLine = (pathPoints, point) => {
-    const distance = distanceBetweenPointAndSegments(pathPoints, point);
-    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 isHitElementText = (element, point) => {
-    const engine = getEngine(element.shape);
-    if (isMultipleTextGeometry(element)) {
-        const texts = element.texts;
-        return texts.some(item => {
-            const textClient = engine.getTextRectangle(element, { key: item.key });
-            return RectangleClient.isPointInRectangle(textClient, point);
-        });
-    }
-    else {
-        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
-        return RectangleClient.isPointInRectangle(textClient, point);
-    }
-};
-const isRectangleHitElementText = (element, rectangle) => {
-    const engine = getEngine(element.shape);
-    if (isMultipleTextGeometry(element)) {
-        const texts = element.texts;
-        return texts.some(item => {
-            const textClient = engine.getTextRectangle(element, { key: item.key });
-            const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
-            return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
-        });
-    }
-    else {
-        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
-        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
-        return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
-    }
-};
-const isRectangleHitDrawElement = (board, element, selection) => {
-    const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
-    if (PlaitDrawElement.isGeometry(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        let rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
-        const isHitElement = isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
-        if (isHitElement) {
-            return isHitElement;
-        }
-        return isRectangleHitElementText(element, rangeRectangle);
-    }
-    if (PlaitDrawElement.isImage(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
-        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
-    }
-    if (PlaitDrawElement.isLine(element)) {
-        const points = getLinePoints(board, element);
-        return isPolylineHitRectangle(points, rangeRectangle);
-    }
-    return null;
-};
-const isHitDrawElement = (board, element, point) => {
-    const rectangle = board.getRectangle(element);
-    point = rotateAntiPointsByElement(point, element) || point;
-    if (PlaitDrawElement.isGeometry(element)) {
-        const fill = getFillByElement(board, element);
-        if (isHitEdgeOfShape(board, element, point, HIT_DISTANCE_BUFFER)) {
-            return true;
-        }
-        const engine = getEngine(getElementShape(element));
-        // when shape equals text, fill is not allowed
-        if (fill !== DefaultDrawStyle.fill && fill !== TRANSPARENT && !PlaitDrawElement.isText(element)) {
-            const isHitInside = engine.isInsidePoint(rectangle, point);
-            if (isHitInside) {
-                return isHitInside;
-            }
-        }
-        else {
-            // if shape equals text, only check text rectangle
-            if (PlaitDrawElement.isText(element)) {
-                const textClient = getTextRectangle(element);
-                let isHitText = RectangleClient.isPointInRectangle(textClient, point);
-                return isHitText;
-            }
-            // check textRectangle of element
-            const isHitText = isHitElementText(element, point);
-            if (isHitText) {
-                return isHitText;
-            }
-        }
-    }
-    if (PlaitDrawElement.isImage(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        return RectangleClient.isPointInRectangle(client, point);
-    }
-    if (PlaitDrawElement.isLine(element)) {
-        return isHitLine(board, element, point);
-    }
-    return null;
-};
-const isHitEdgeOfShape = (board, element, point, hitDistanceBuffer) => {
-    const nearestPoint = getNearestPoint(element, point);
-    const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);
-    return distance <= hitDistanceBuffer;
-};
-const isInsideOfShape = (board, element, point, hitDistanceBuffer) => {
-    const client = RectangleClient.inflate(RectangleClient.getRectangleByPoints(element.points), hitDistanceBuffer);
-    return getEngine(getElementShape(element)).isInsidePoint(client, point);
-};
-const isHitElementInside = (board, element, point) => {
-    const rectangle = board.getRectangle(element);
-    point = rotateAntiPointsByElement(point, element) || point;
-    if (PlaitDrawElement.isGeometry(element)) {
-        const engine = getEngine(getElementShape(element));
-        const isHitInside = engine.isInsidePoint(rectangle, point);
-        if (isHitInside) {
-            return isHitInside;
-        }
-        if (engine.getTextRectangle) {
-            const isHitText = isHitElementText(element, point);
-            if (isHitText) {
-                return isHitText;
-            }
-        }
-    }
-    if (PlaitDrawElement.isImage(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        return RectangleClient.isPointInRectangle(client, point);
-    }
-    if (PlaitDrawElement.isLine(element)) {
-        return isHitLine(board, element, point);
-    }
-    return null;
-};
-
 const resizeLine = (board, options, path) => {
     Transforms.setNode(board, options, path);
 };
@@ -5838,7 +5862,7 @@ const withDrawHotkey = (board) => {
             const hitElement = getHitElementByPoint(board, point);
             if (hitElement && PlaitDrawElement.isGeometry(hitElement)) {
                 if (isMultipleTextGeometry(hitElement)) {
-                    const hitText = getHitText(hitElement, point) ||
+                    const hitText = getHitMultipleGeometryText(hitElement, point) ||
                         hitElement.texts.find(item => item.key.includes(MultipleTextGeometryCommonTextKeys.content)) ||
                         hitElement.texts[0];
                     editText(board, hitElement, hitText);
@@ -6275,7 +6299,7 @@ const withGeometryResize = (board) => {
             snapG = resizeSnapRef.snapG;
             PlaitBoard.getElementActiveHost(board).append(snapG);
             let points = resizeSnapRef.activePoints;
-            if (PlaitDrawElement.isGeometry(resizeRef.element)) {
+            if (PlaitDrawElement.isGeometry(resizeRef.element) && isGeometryIncludeText(resizeRef.element)) {
                 const { height: textHeight } = getFirstTextManage(resizeRef.element).getSize();
                 DrawTransforms.resizeGeometry(board, points, textHeight, resizeRef.path);
             }
@@ -6942,7 +6966,9 @@ class TableComponent extends CommonElementFlavour {
         });
     }
     getDrawShapeTexts(cells) {
-        return cells.map(item => {
+        return cells
+            .filter(item => isCellIncludeText(item))
+            .map(item => {
             return {
                 key: item.id,
                 text: item.text,
@@ -7554,5 +7580,5 @@ const withDraw = (board) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicShapes, DEFAULT_IMAGE_WIDTH, DEFAULT_TEXT_HEIGHT, DefaultActorProperty, DefaultArrowProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_WITHOUT_TEXT, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LineActiveGenerator, LineAutoCompleteGenerator, LineComponent, LineHandleKey, LineMarkerType, LineShape, MemorizeKey, MultipleTextGeometryCommonTextKeys, MultipleTextGeometryTextKeys, PlaitDrawElement, PlaitGeometry, PlaitLine, Q2C, ShapeDefaultSpace, SingleTextGenerator, StrokeStyle, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, WithLineAutoCompletePluginKey, alignElbowSegment, alignPoints, buildDefaultTextsByShape, createDefaultFlowchart, createDefaultGeometry, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createLineElement, createMultipleTextGeometryElement, createTextElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawBoundReaction, drawGeometry, drawLine, drawLineArrow, drawShape, editText, getAutoCompletePoints, getBasicPointers, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryPointers, getHitConnection, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getHitShape, getHitText, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineHandleRefPair, getLineMemorizedLatest, getLinePointers, getLinePoints, getLineTextRectangle, getLines, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedLineElements, getSelectedTableElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlanePointers, getTextManage, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, handleLineCreating, hasIllegalElbowPoint, insertElement, isDrawElementsIncludeText, isGeometryIncludeText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitLine, isHitLineText, isHitPolyLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isSelfLoop, isSingleSelectSwimlane, isSingleSelectTable, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setTextManage, traverseDrawShapes, withDraw, withLineAutoComplete };
+export { BasicShapes, DEFAULT_IMAGE_WIDTH, DEFAULT_TEXT_HEIGHT, DefaultActorProperty, DefaultArrowProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, 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, LineAutoCompleteGenerator, LineComponent, LineHandleKey, LineMarkerType, LineShape, MemorizeKey, MultipleTextGeometryCommonTextKeys, MultipleTextGeometryTextKeys, PlaitDrawElement, PlaitGeometry, PlaitLine, Q2C, ShapeDefaultSpace, SingleTextGenerator, StrokeStyle, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, WithLineAutoCompletePluginKey, alignElbowSegment, alignPoints, buildDefaultTextsByShape, createDefaultFlowchart, createDefaultGeometry, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createLineElement, createMultipleTextGeometryElement, createTextElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawBoundReaction, drawGeometry, drawLine, drawLineArrow, drawShape, editText, getAutoCompletePoints, getBasicPointers, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitConnection, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineHandleRefPair, getLineMemorizedLatest, getLinePointers, getLinePoints, getLineTextRectangle, getLines, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedLineElements, getSelectedTableElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlanePointers, getTextKey, getTextManage, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, handleLineCreating, hasIllegalElbowPoint, insertElement, isDrawElementIncludeText, isDrawElementsIncludeText, isGeometryIncludeText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitLine, isHitLineText, isHitPolyLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isSelfLoop, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setTextManage, traverseDrawShapes, withDraw, withLineAutoComplete };
 //# sourceMappingURL=plait-draw.mjs.map