@plait/draw 0.86.0 → 0.87.0-next.0

package/fesm2022/plait-draw.mjs

@@ -1,7 +1,7 @@
 import { ACTIVE_STROKE_WIDTH, DEFAULT_COLOR, ThemeColorMode, PlaitElement, RectangleClient, getSelectedElements, idCreator, createDebugGenerator, Point, createG, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, catmullRomFitting, PlaitBoard, setStrokeLinecap, findElements, createMask, createRect, getNearestPointBetweenPointAndArc, setPathStrokeLinecap, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPointInPolygon, isLineHitRectangle, rotatePointsByAngle, rotateAntiPointsByElement, getEllipseArcCenter, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, getI18nValue, SELECTION_RECTANGLE_CLASS_NAME, toActivePointFromViewBoxPoint, toActiveRectangleFromViewBoxRectangle, drawRectangle, isSelectionMoving, rgbaToHEX, getElementById, rotatePointsByElement, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, getRectangleByElements, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, getNearestPointBetweenPointAndSegments, getEllipseTangentSlope, getVectorFromPointAndSlope, getNearestPointBetweenPointAndEllipse, isPointInEllipse, isPointInRoundRectangle, drawRoundRectangle, getCrossingPointsBetweenEllipseAndSegment, drawLine, getNearestPointBetweenPointAndDiscreteSegments, getNearestPointBetweenPointAndSegment, Path, getHitElementByPoint, WritableClipboardOperationType, WritableClipboardType, addOrCreateClipboardContext, setAngleForG, toActivePoint, temporaryDisableSelection, toScreenPointFromActivePoint, PRESS_AND_MOVE_BUFFER, CursorClass, isHorizontalDirection, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
-import { DEFAULT_FILL, Alignment, WithTextPluginKey, TextManage, getMemorizedLatest, memorizeLatest, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getPointByVectorComponent, getStrokeLineDash, StrokeStyle, getPointOnPolyline, buildText, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getFirstTextEditor, sortElementsByArea, isFilled, getTextEditorsByElement, RESIZE_HANDLE_DIAMETER, drawPrimaryHandle, drawFillPrimaryHandle, PRIMARY_COLOR, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_SIZE, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, isCornerHandle, getIndexByResizeHandle, withResize, getSymmetricHandleIndex, getResizeHandlePointByIndex, drawHandle, getDirectionFactorByDirectionComponent, buildClipboardData as buildClipboardData$1, insertClipboardData as insertClipboardData$1, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, CommonElementFlavour, createActiveGenerator, hasResizeHandle, ActiveGenerator, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, getDirectionByIndex, moveXOfPoint, getXDistanceBetweenPoint, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
-import { TEXT_DEFAULT_HEIGHT, DEFAULT_FONT_SIZE, AlignEditor } from '@plait/text-plugins';
+import { DEFAULT_FILL, Alignment, WithTextPluginKey, TextManage, getMemorizedLatest, memorizeLatest, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getElementSize, DEFAULT_FONT_FAMILY, getPointByVectorComponent, getStrokeLineDash, StrokeStyle, getPointOnPolyline, buildText, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getFirstTextEditor, sortElementsByArea, isFilled, getTextEditorsByElement, RESIZE_HANDLE_DIAMETER, drawPrimaryHandle, drawFillPrimaryHandle, PRIMARY_COLOR, measureElement, getFirstTextManage, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_SIZE, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, isCornerHandle, getIndexByResizeHandle, withResize, getSymmetricHandleIndex, getResizeHandlePointByIndex, drawHandle, getDirectionFactorByDirectionComponent, buildClipboardData as buildClipboardData$1, insertClipboardData as insertClipboardData$1, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, CommonElementFlavour, createActiveGenerator, hasResizeHandle, ActiveGenerator, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, getDirectionByIndex, moveXOfPoint, getXDistanceBetweenPoint, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
 import { pointsOnBezierCurves } from 'points-on-curve';
+import { DEFAULT_FONT_SIZE, AlignEditor } from '@plait/text-plugins';
 import { Editor, Node } from 'slate';
 import { isKeyHotkey } from 'is-hotkey';
 
@@ -545,7 +545,7 @@ class TextGenerator {
             removedTexts.forEach(item => {
                 const textManage = getTextManage(this.board, element, item);
                 const index = this.textManages.findIndex(value => value === textManage);
-                if (index > -1 && item.text && item.textHeight) {
+                if (index > -1 && item.text) {
                     this.textManages.splice(index, 1);
                 }
                 textManage?.destroy();
@@ -591,9 +591,9 @@ class TextGenerator {
     getRectangle(text) {
         const getRectangle = getEngine(this.shape).getTextRectangle;
         if (getRectangle) {
-            return getRectangle(this.element, text);
+            return getRectangle(this.board, this.element, text);
         }
-        return getTextRectangle(this.element);
+        return getTextRectangle$1(this.board, this.element);
     }
     getMaxWidth(text) {
         return this.options.getMaxWidth ? this.options.getMaxWidth() : this.getRectangle(text).width;
@@ -754,7 +754,7 @@ function updateCellIds(cells) {
     });
 }
 function isCellIncludeText(cell) {
-    return cell.text && cell.textHeight;
+    return cell.text;
 }
 function getCellsRectangle(board, element, cells) {
     const cellsWithPoints = getCellsWithPoints(board, element);
@@ -771,7 +771,6 @@ const createCell = (rowId, columnId, text = null) => {
         columnId
     };
     if (text !== null) {
-        cell['textHeight'] = TEXT_DEFAULT_HEIGHT;
         cell['text'] = {
             children: [{ text }],
             align: Alignment.center
@@ -823,7 +822,7 @@ const getMemorizeKey = (element) => {
 };
 const getLineMemorizedLatest = () => {
     const properties = getMemorizedLatest(MemorizeKey.arrowLine);
-    return { ...properties } || {};
+    return { ...properties };
 };
 const getMemorizedLatestByPointer = (pointer) => {
     let memorizeKey = '';
@@ -836,15 +835,15 @@ const getMemorizedLatestByPointer = (pointer) => {
     else {
         memorizeKey = MemorizeKey.flowchart;
     }
-    const properties = { ...getMemorizedLatest(memorizeKey) } || {};
-    const textProperties = { ...properties.text } || {};
+    const properties = { ...getMemorizedLatest(memorizeKey) };
+    const textProperties = { ...properties.text };
     delete properties.text;
     return { textProperties, geometryProperties: properties };
 };
 const memorizeLatestText = (element, operations) => {
     const memorizeKey = getMemorizeKey(element);
     let textMemory = getMemorizedLatest(memorizeKey)?.text || {};
-    const setNodeOperation = operations.find(operation => operation.type === 'set_node');
+    const setNodeOperation = operations.find((operation) => operation.type === 'set_node');
     if (setNodeOperation) {
         const { properties, newProperties } = setNodeOperation;
         for (const key in newProperties) {
@@ -1320,6 +1319,15 @@ class ArrowLineShapeGenerator extends Generator {
     }
 }
 
+const getTextSize = (board, text, maxWidth) => {
+    const textSize = getElementSize(board, text, { fontSize: DEFAULT_FONT_SIZE, fontFamily: DEFAULT_FONT_FAMILY }, maxWidth);
+    const normalizedTextSize = normalizeWidthAndHeight(textSize);
+    return normalizedTextSize;
+};
+const normalizeWidthAndHeight = (textSize) => {
+    return { ...textSize, width: textSize.width < MIN_TEXT_WIDTH ? MIN_TEXT_WIDTH : textSize.width };
+};
+
 const createArrowLineElement = (shape, points, source, target, texts, options) => {
     return {
         id: idCreator(),
@@ -1434,11 +1442,12 @@ const getArrowLineTextRectangle = (board, element, index) => {
     const text = element.texts[index];
     const elbowPoints = getArrowLinePoints(board, element);
     const point = getPointOnPolyline(elbowPoints, text.position);
+    const textSize = getTextSize(board, text.text);
     return {
-        x: point[0] - text.width / 2,
-        y: point[1] - text.height / 2,
-        width: text.width,
-        height: text.height
+        x: point[0] - textSize.width / 2,
+        y: point[1] - textSize.height / 2,
+        width: textSize.width,
+        height: textSize.height
     };
 };
 const getArrowLines = (board) => {
@@ -1518,13 +1527,14 @@ const getHitArrowLineTextIndex = (board, element, point) => {
     if (!texts.length)
         return -1;
     const points = getArrowLinePoints(board, element);
-    return texts.findIndex(text => {
+    return texts.findIndex((text) => {
         const center = getPointOnPolyline(points, text.position);
+        const textSize = getTextSize(board, text.text);
         const rectangle = {
-            x: center[0] - text.width / 2,
-            y: center[1] - text.height / 2,
-            width: text.width,
-            height: text.height
+            x: center[0] - textSize.width / 2,
+            y: center[1] - textSize.height / 2,
+            width: textSize.width,
+            height: textSize.height
         };
         return RectangleClient.isHit(rectangle, RectangleClient.getRectangleByPoints([point, point]));
     });
@@ -1557,27 +1567,24 @@ const buildDefaultTextsByShape = (shape) => {
     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 {
             id: textKey,
-            text: buildText(text?.text || '', alignment || text?.align || Alignment.center, textProperties),
-            textHeight: textHeight
+            text: buildText(text?.text || '', alignment || text?.align || Alignment.center, textProperties)
         };
     });
 };
-const getHitMultipleGeometryText = (element, point) => {
+const getHitMultipleGeometryText = (board, 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, { id: text.id });
+        hitText = element.texts.find((text) => {
+            const textRectangle = engine.getTextRectangle(board, element, { id: text.id });
             return RectangleClient.isHit(rectangle, textRectangle);
         });
     }
@@ -1811,28 +1818,22 @@ const CloudEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
         const width = originWidth / 1.5;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 6,
-            y: elementRectangle.y + elementRectangle.height / 6 + ((elementRectangle.height * 4) / 6 - height) / 2
+            y: elementRectangle.y + elementRectangle.height / 6 + ((elementRectangle.height * 4) / 6 - textSize.height) / 2
         };
     }
 };
 
-const isTextExceedingBounds = (geometry) => {
-    const client = RectangleClient.getRectangleByPoints(geometry.points);
-    if (geometry.textHeight && geometry.textHeight > client.height) {
-        return true;
-    }
-    return false;
-};
 const isHitArrowLineText = (board, element, point) => {
     return getHitArrowLineTextIndex(board, element, point) !== -1;
 };
@@ -1854,31 +1855,31 @@ const isHitVectorLine = (board, element, point) => {
         return isHitPolyLine(points, point);
     }
 };
-const isRectangleHitElementText = (element, rectangle) => {
+const isRectangleHitElementText = (board, element, rectangle) => {
     const engine = getEngine(element.shape);
     if (isMultipleTextGeometry(element)) {
         const texts = element.texts;
         return texts.some((item) => {
-            const textClient = engine.getTextRectangle(element, { id: item.id });
+            const textClient = engine.getTextRectangle(board, element, { id: item.id });
             return isRectangleHitRotatedPoints(rectangle, RectangleClient.getCornerPoints(textClient), element.angle);
         });
     }
     else {
-        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
+        const textClient = engine.getTextRectangle ? engine.getTextRectangle(board, element) : getTextRectangle$1(board, element);
         return isRectangleHitRotatedPoints(rectangle, RectangleClient.getCornerPoints(textClient), element.angle);
     }
 };
-const isHitElementText = (element, point) => {
+const isHitElementText = (board, element, point) => {
     const engine = getEngine(element.shape);
     if (isMultipleTextGeometry(element)) {
         const texts = element.texts;
         return texts.some((item) => {
-            const textClient = engine.getTextRectangle(element, { id: item.id });
+            const textClient = engine.getTextRectangle(board, element, { id: item.id });
             return RectangleClient.isPointInRectangle(textClient, point);
         });
     }
     else {
-        const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
+        const textClient = engine.getTextRectangle ? engine.getTextRectangle(board, element) : getTextRectangle$1(board, element);
         return RectangleClient.isPointInRectangle(textClient, point);
     }
 };
@@ -1896,7 +1897,7 @@ const isRectangleHitDrawElement = (board, element, selection) => {
         if (isHitElement) {
             return isHitElement;
         }
-        return !isEmptyTextElement(element) && isRectangleHitElementText(element, rangeRectangle);
+        return !isEmptyTextElement(element) && isRectangleHitElementText(board, element, rangeRectangle);
     }
     if (PlaitDrawElement.isImage(element)) {
         return isRectangleHitRotatedElement(board, rangeRectangle, element);
@@ -1991,13 +1992,13 @@ const isHitDrawElement = (board, element, point, isStrict = true) => {
         }
         const engine = getEngine(getElementShape(element));
         if (PlaitDrawElement.isText(element)) {
-            const textClient = getTextRectangle(element);
+            const textClient = getTextRectangle$1(board, element);
             return RectangleClient.isPointInRectangle(textClient, point);
         }
         if (!!isStrict && isEmptyTextElement(element) && !isFilledDrawElement(board, element)) {
             return false;
         }
-        const isHitText = isHitElementText(element, point);
+        const isHitText = isHitElementText(board, element, point);
         return isHitText || engine.isInsidePoint(rectangle, point);
     }
     if (PlaitDrawElement.isImage(element)) {
@@ -2031,7 +2032,7 @@ const isHitElementInside = (board, element, point) => {
             return isHitInside;
         }
         if (engine.getTextRectangle) {
-            const isHitText = isHitElementText(element, point);
+            const isHitText = isHitElementText(board, element, point);
             if (isHitText) {
                 return isHitText;
             }
@@ -2050,16 +2051,25 @@ const isHitElementInside = (board, element, point) => {
     return null;
 };
 
-const getTextRectangle = (element) => {
+const getTextRectangle$1 = (board, element) => {
+    const isAutoSize = PlaitDrawElement.isText(element) ? element.autoSize : false;
     const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
     const strokeWidth = getStrokeWidthByElement(element);
-    const height = element.textHeight;
     const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+    const textSize = getTextSize(board, element.text, isAutoSize ? GeometryThreshold.defaultTextMaxWidth : width);
+    if (isAutoSize) {
+        return {
+            height: textSize.height,
+            width: textSize.width,
+            x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
+        };
+    }
     return {
-        height,
+        height: textSize.height,
         width: width > 0 ? width : 0,
         x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-        y: elementRectangle.y + (elementRectangle.height - height) / 2
+        y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
     };
 };
 const getStrokeWidthByElement = (element) => {
@@ -2492,11 +2502,11 @@ class SingleTextGenerator extends TextGenerator {
         return this.textManages[0];
     }
     constructor(board, element, text, options) {
-        super(board, element, [{ id: element.id, text: text, textHeight: element.textHeight }], options);
+        super(board, element, [{ id: element.id, text: text }], options);
     }
     update(element, previousText, currentText, elementG) {
         if (!isMultipleTextGeometry(element)) {
-            super.update(element, [{ text: previousText, id: element.id, textHeight: element.textHeight }], [{ text: currentText, id: element.id, textHeight: element.textHeight }], elementG);
+            super.update(element, [{ text: previousText, id: element.id }], [{ text: currentText, id: element.id }], elementG);
         }
     }
 }
@@ -2596,13 +2606,8 @@ const createUMLClassOrInterfaceGeometryElement = (board, shape, points) => {
     };
 };
 const buildTableCellsForGeometry = (board, rows, columns, shape) => {
-    const memorizedLatest = getMemorizedLatestByPointer(shape);
     const cellCount = rows.length * columns.length;
     const defaultTexts = getDefaultGeometryProperty(shape)?.texts || [];
-    const textHeights = defaultTexts.map((textItem) => {
-        return getTextShapeProperty(board, textItem.text || getDefaultGeometryText(board), memorizedLatest.textProperties['font-size'])
-            .height;
-    });
     return new Array(cellCount).fill('').map((item, index) => {
         const rowIndex = Math.floor(index / columns.length);
         const columnIndex = index % columns.length;
@@ -2610,7 +2615,6 @@ const buildTableCellsForGeometry = (board, rows, columns, shape) => {
             id: idCreator(),
             rowId: rows[rowIndex].id,
             columnId: columns[columnIndex].id,
-            textHeight: textHeights[index],
             text: {
                 children: [
                     {
@@ -2634,23 +2638,19 @@ const createGeometryElement = (shape, points, text, options = {}, textProperties
 const createGeometryElementWithText = (shape, points, text, options = {}, textProperties = {}) => {
     let textOptions = {};
     let alignment = Alignment.center;
-    let textHeight = DefaultTextProperty.height;
     if (shape === BasicShapes.text) {
         textOptions = { autoSize: true };
         alignment = undefined;
     }
     textProperties = { ...textProperties };
     textProperties?.align && (alignment = textProperties?.align);
-    textProperties?.textHeight && (textHeight = textProperties?.textHeight);
     delete textProperties?.align;
-    delete textProperties?.textHeight;
     return {
         id: idCreator(),
         type: 'geometry',
         shape,
         angle: 0,
         opacity: 1,
-        textHeight,
         text: buildText(text, alignment, textProperties),
         points,
         ...textOptions,
@@ -2743,17 +2743,14 @@ const getDefaultTextPoints = (board, centerPoint, fontSize) => {
     const property = getTextShapeProperty(board, DefaultTextProperty.text, fontSize);
     return RectangleClient.getPoints(RectangleClient.getRectangleByCenterPoint(centerPoint, property.width, property.height));
 };
-const createTextElement = (board, points, text, textHeight) => {
+const createTextElement = (board, points, text) => {
     const memorizedLatest = getMemorizedLatestByPointer(BasicShapes.text);
-    textHeight = textHeight ? textHeight : RectangleClient.getRectangleByPoints(points).height;
     return createGeometryElement(BasicShapes.text, points, text, memorizedLatest.geometryProperties, {
-        ...memorizedLatest.textProperties,
-        textHeight
+        ...memorizedLatest.textProperties
     });
 };
 const createDefaultGeometry = (board, points, shape) => {
     const memorizedLatest = getMemorizedLatestByPointer(shape);
-    const textHeight = getTextShapeProperty(board, DefaultTextProperty.text, memorizedLatest.textProperties['font-size']).height;
     if (PlaitDrawElement.isUMLClassOrInterface({ shape })) {
         return createUMLClassOrInterfaceGeometryElement(board, shape, points);
     }
@@ -2767,7 +2764,7 @@ const createDefaultGeometry = (board, points, shape) => {
         return createGeometryElement(shape, points, '', {
             strokeWidth: DefaultBasicShapeProperty.strokeWidth,
             ...memorizedLatest.geometryProperties
-        }, { ...memorizedLatest.textProperties, textHeight });
+        }, { ...memorizedLatest.textProperties });
     }
 };
 const editText = (board, element, text) => {
@@ -2945,10 +2942,10 @@ const insertText = (board, point, text) => {
     const newElement = createTextElement(board, points, text);
     insertElement(board, newElement);
 };
-const resizeGeometry = (board, points, textHeight, path) => {
+const resizeGeometry = (board, points, path) => {
     const normalizePoints = normalizeShapePoints(points);
     const element = PlaitNode.get(board, path);
-    const newProperties = { points: normalizePoints, textHeight };
+    const newProperties = { points: normalizePoints, text: { ...element.text } };
     if (PlaitDrawElement.isText(element) && element.autoSize) {
         newProperties.autoSize = false;
     }
@@ -2957,7 +2954,7 @@ const resizeGeometry = (board, points, textHeight, path) => {
 const switchGeometryShape = (board, shape) => {
     const selectedElements = getSelectedElements(board);
     const refs = [];
-    selectedElements.forEach(item => {
+    selectedElements.forEach((item) => {
         if (PlaitDrawElement.isGeometry(item) && !PlaitDrawElement.isText(item)) {
             const path = PlaitBoard.findPath(board, item);
             Transforms.setNode(board, { shape }, path);
@@ -2965,15 +2962,15 @@ const switchGeometryShape = (board, shape) => {
         }
     });
     if (refs.length) {
-        refs.forEach(ref => {
+        refs.forEach((ref) => {
             DrawTransforms.resizeArrowLine(board, ref.property, ref.path);
         });
     }
 };
 
-const normalizePoints = (board, element, width, textHeight) => {
+const normalizePoints = (board, element, width, height) => {
     let points = element.points;
-    let autoSize = element.autoSize;
+    let autoSize = PlaitDrawElement.isText(element) ? element.autoSize : false;
     const defaultSpace = ShapeDefaultSpace.rectangleAndText;
     if (autoSize) {
         const newWidth = width < MIN_TEXT_WIDTH ? MIN_TEXT_WIDTH : width;
@@ -2981,7 +2978,7 @@ const normalizePoints = (board, element, width, textHeight) => {
         if (AlignEditor.isActive(editor, Alignment.right)) {
             points = [
                 [points[1][0] - (newWidth + defaultSpace * 2), points[0][1]],
-                [points[1][0], points[0][1] + textHeight]
+                [points[1][0], points[0][1] + height]
             ];
         }
         else if (AlignEditor.isActive(editor, Alignment.center)) {
@@ -2989,11 +2986,11 @@ const normalizePoints = (board, element, width, textHeight) => {
             const offset = (newWidth - oldWidth) / 2;
             points = [
                 [points[0][0] - offset - defaultSpace, points[0][1]],
-                [points[1][0] + offset + defaultSpace, points[0][1] + textHeight]
+                [points[1][0] + offset + defaultSpace, points[0][1] + height]
             ];
         }
         else {
-            points = [points[0], [points[0][0] + newWidth + defaultSpace * 2, points[0][1] + textHeight]];
+            points = [points[0], [points[0][0] + newWidth + defaultSpace * 2, points[0][1] + height]];
         }
         if (hasValidAngle(element)) {
             points = resetPointsAfterResize(RectangleClient.getRectangleByPoints(element.points), RectangleClient.getRectangleByPoints(points), RectangleClient.getCenterPoint(RectangleClient.getRectangleByPoints(element.points)), RectangleClient.getCenterPoint(RectangleClient.getRectangleByPoints(points)), element.angle);
@@ -3001,27 +2998,22 @@ const normalizePoints = (board, element, width, textHeight) => {
     }
     return { points };
 };
-const setText = (board, element, text, width, textHeight) => {
+const setText = (board, element, text, width, height) => {
     const newElement = {
         text,
-        textHeight,
-        ...normalizePoints(board, element, width, textHeight)
+        ...normalizePoints(board, element, width, height)
     };
-    const path = board.children.findIndex(child => child === element);
+    const path = board.children.findIndex((child) => child === element);
     Transforms.setNode(board, newElement, [path]);
 };
-const setTextSize = (board, element, textWidth, textHeight) => {
-    if (element.autoSize) {
+const setTextSize = (board, element, width, height) => {
+    const isAutoSize = PlaitDrawElement.isText(element) ? element.autoSize : false;
+    if (isAutoSize) {
         const newElement = {
-            textHeight,
-            ...normalizePoints(board, element, textWidth, textHeight)
+            ...normalizePoints(board, element, width, height)
         };
-        const isPointsEqual = Point.isEquals(element.points[0], newElement.points[0]) && Point.isEquals(element.points[1], newElement.points[1]);
-        const isTextHeightEqual = Math.round(textHeight) === Math.round(element.textHeight);
-        if (!isPointsEqual || !isTextHeightEqual) {
-            const path = board.children.findIndex(child => child === element);
-            Transforms.setNode(board, newElement, [path]);
-        }
+        const path = board.children.findIndex((child) => child === element);
+        Transforms.setNode(board, newElement, [path]);
     }
 };
 
@@ -3128,7 +3120,7 @@ function buildSwimlaneTable(element) {
                     rowspan: element.rows.length
                 };
             }
-            if (item.text && item.textHeight && !item.text.direction) {
+            if (item.text && !item.text.direction) {
                 item = {
                     ...item,
                     text: {
@@ -3385,8 +3377,7 @@ const createNewSwimlaneCells = (swimlane, newId, type) => {
             children: [{ text: swimlane.header ? 'Lane' : 'New Swimlane' }],
             align: Alignment.center,
             direction: type === 'row' ? undefined : 'vertical'
-        },
-        textHeight: 20
+        }
     };
     return cells;
 };
@@ -3417,7 +3408,7 @@ const setDrawTexts = (board, element, text) => {
 const setTableText = (board, path, cellId, text, textHeight) => {
     const table = PlaitNode.get(board, path);
     const cell = getCellWithPoints(board, table, cellId);
-    const cellIndex = table.cells.findIndex(item => item.id === cell.id);
+    const cellIndex = table.cells.findIndex((item) => item.id === cell.id);
     let rows = [...table.rows];
     let columns = [...table.columns];
     let cells = [...table.cells];
@@ -3425,7 +3416,7 @@ const setTableText = (board, path, cellId, text, textHeight) => {
     const { width: cellWidth, height: cellHeight } = RectangleClient.getRectangleByPoints(cell.points);
     const defaultSpace = ShapeDefaultSpace.rectangleAndText;
     if (PlaitTableElement.isVerticalText(cell)) {
-        const columnIdx = table.columns.findIndex(column => column.id === cell.columnId);
+        const columnIdx = table.columns.findIndex((column) => column.id === cell.columnId);
         if (textHeight > cellWidth) {
             const newColumnWidth = textHeight + defaultSpace * 2;
             const offset = newColumnWidth - cellWidth;
@@ -3435,9 +3426,9 @@ const setTableText = (board, path, cellId, text, textHeight) => {
         }
     }
     else {
-        const rowIdx = table.rows.findIndex(row => row.id === cell.rowId);
+        const rowIdx = table.rows.findIndex((row) => row.id === cell.rowId);
         const tableRow = table.rows[rowIdx];
-        const compareHeight = tableRow.height ?? Math.max(cellHeight, cell.textHeight || 0);
+        const compareHeight = tableRow.height ?? Math.max(cellHeight, textHeight || 0);
         if (textHeight > compareHeight) {
             const newRowHeight = textHeight + defaultSpace * 2;
             const offset = newRowHeight - compareHeight;
@@ -3448,7 +3439,6 @@ const setTableText = (board, path, cellId, text, textHeight) => {
     }
     cells[cellIndex] = {
         ...cells[cellIndex],
-        textHeight: textHeight,
         text
     };
     Transforms.setNode(board, { rows, columns, cells, points }, path);
@@ -3467,7 +3457,7 @@ const setTableFill = (board, element, fill, path) => {
     }
     else {
         newCells = element.cells.map(cell => {
-            if (cell.text && cell.textHeight) {
+            if (cell.text) {
                 return getNewCell(cell, fill);
             }
             return cell;
@@ -3691,14 +3681,7 @@ function withDrawResize(board) {
                     }
                 }
                 if (PlaitDrawElement.isGeometry(target)) {
-                    if (PlaitDrawElement.isGeometry(target) && isGeometryIncludeText(target)) {
-                        const { height: textHeight } = getFirstTextManage(target).getSize();
-                        DrawTransforms.resizeGeometry(board, points, textHeight, path);
-                    }
-                    else {
-                        points = normalizeShapePoints(points);
-                        Transforms.setNode(board, { points }, path);
-                    }
+                    DrawTransforms.resizeGeometry(board, points, path);
                 }
                 else if (PlaitDrawElement.isLine(target) ||
                     PlaitDrawElement.isCustomGeometryElement(board, target) ||
@@ -4105,16 +4088,17 @@ const CommentEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height * heightRatio$1 - height) / 2
+            y: elementRectangle.y + (elementRectangle.height * heightRatio$1 - textSize.height) / 2
         };
     }
 };
@@ -4205,8 +4189,8 @@ const CrossEngine = createPolygonEngine({
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = rectangle.width / 2;
         rectangle.x += width / 4;
@@ -4219,8 +4203,8 @@ const DiamondEngine = createPolygonEngine({
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         rectangle.width = rectangle.width / 2;
         rectangle.x += rectangle.width / 2;
         return rectangle;
@@ -4260,8 +4244,8 @@ function createEllipseEngine(createOptions) {
         getConnectorPoints(rectangle) {
             return RectangleClient.getEdgeCenterPoints(rectangle);
         },
-        getTextRectangle(element) {
-            const rectangle = getTextRectangle(element);
+        getTextRectangle: (board, element) => {
+            const rectangle = getTextRectangle$1(board, element);
             const width = rectangle.width;
             rectangle.width = (rectangle.width * 3) / 4;
             rectangle.x += width / 8;
@@ -4293,8 +4277,8 @@ const HexagonEngine = createPolygonEngine({
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 3) / 4;
         rectangle.x += width / 8;
@@ -4321,8 +4305,8 @@ const LeftArrowEngine = createPolygonEngine({
             [rectangle.x + rectangle.width, rectangle.y + rectangle.height / 2]
         ];
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = rectangle.width * (1 - 0.32);
         rectangle.x += width * 0.32;
@@ -4347,8 +4331,8 @@ const OctagonEngine = createPolygonEngine({
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 3) / 4;
         rectangle.x += width / 8;
@@ -4370,8 +4354,8 @@ const ParallelogramEngine = createPolygonEngine({
         const cornerPoints = getParallelogramPoints(rectangle);
         return getCenterPointsOnPolygon$1(cornerPoints);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = rectangle.width / 2;
         rectangle.x += width / 4;
@@ -4390,17 +4374,18 @@ const getPentagonPoints = (rectangle) => {
 };
 const PentagonEngine = createPolygonEngine({
     getPolygonPoints: getPentagonPoints,
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
         const width = (originWidth * 3) / 5;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 5,
-            y: elementRectangle.y + elementRectangle.height / 5 + ((elementRectangle.height * 4) / 5 - height) / 2
+            y: elementRectangle.y + elementRectangle.height / 5 + ((elementRectangle.height * 4) / 5 - textSize.height) / 2
         };
     }
 });
@@ -4420,9 +4405,9 @@ const PentagonArrowEngine = createPolygonEngine({
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
-        const rectangle = getTextRectangle(element);
+        const rectangle = getTextRectangle$1(board, element);
         const wider = elementRectangle.width > elementRectangle.height / 2 + 20;
         rectangle.width = wider ? elementRectangle.width - elementRectangle.height / 2 : rectangle.width;
         return rectangle;
@@ -4442,9 +4427,9 @@ const getProcessArrowPoints = (rectangle) => {
 };
 const ProcessArrowEngine = createPolygonEngine({
     getPolygonPoints: getProcessArrowPoints,
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
-        const rectangle = getTextRectangle(element);
+        const rectangle = getTextRectangle$1(board, element);
         const wider = elementRectangle.width > elementRectangle.height + 20;
         rectangle.width = wider ? elementRectangle.width - elementRectangle.height : rectangle.width;
         rectangle.x = wider ? elementRectangle.x + elementRectangle.height / 2 : rectangle.x;
@@ -4471,8 +4456,8 @@ const RightArrowEngine = createPolygonEngine({
             [rectangle.x + rectangle.width, rectangle.y + rectangle.height / 2]
         ];
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         rectangle.width = rectangle.width * 0.68;
         return rectangle;
     }
@@ -4609,16 +4594,17 @@ const RoundCommentEngine = {
             [rectangle.x, rectangle.y + rectangle.height / 2]
         ];
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height * heightRatio - height) / 2
+            y: elementRectangle.y + (elementRectangle.height * heightRatio - textSize.height) / 2
         };
     }
 };
@@ -4648,8 +4634,8 @@ const TrapezoidEngine = createPolygonEngine({
         const points = getTrapezoidPoints(rectangle);
         return getCenterPointsOnPolygon$1(points);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle(board, element) {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 3) / 4;
         rectangle.x += width / 8;
@@ -4671,17 +4657,18 @@ const TriangleEngine = createPolygonEngine({
         const lineCenterPoints = getCenterPointsOnPolygon$1(cornerPoints);
         return [...lineCenterPoints, ...cornerPoints];
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
         const width = (originWidth * 2) / 3;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 6,
-            y: elementRectangle.y + (elementRectangle.height * 3) / 5 + ((elementRectangle.height * 2) / 5 - height) / 2
+            y: elementRectangle.y + (elementRectangle.height * 3) / 5 + ((elementRectangle.height * 2) / 5 - textSize.height) / 2
         };
     }
 });
@@ -4730,17 +4717,18 @@ const StarEngine = createPolygonEngine({
         const points = getStarPoints(rectangle);
         return [points[1], points[3], points[5], points[7], points[9]];
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
         const width = originWidth / 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 4,
-            y: elementRectangle.y + (elementRectangle.height * 1) / 6 + ((elementRectangle.height * 4) / 5 - height) / 2
+            y: elementRectangle.y + (elementRectangle.height * 1) / 6 + ((elementRectangle.height * 4) / 5 - textSize.height) / 2
         };
     }
 });
@@ -4826,16 +4814,17 @@ const ManualInputEngine = createPolygonEngine({
         const cornerPoints = getManualInputPoints(rectangle);
         return getCenterPointsOnPolygon$1(cornerPoints);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + elementRectangle.height / 4 + ((elementRectangle.height * 3) / 4 - height) / 2
+            y: elementRectangle.y + elementRectangle.height / 4 + ((elementRectangle.height * 3) / 4 - textSize.height) / 2
         };
     }
 });
@@ -4855,8 +4844,8 @@ const PreparationEngine = createPolygonEngine({
     getConnectorPoints: (rectangle) => {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle(board, element) {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 2) / 3;
         rectangle.x += width / 6;
@@ -4878,8 +4867,8 @@ const ManualLoopEngine = createPolygonEngine({
         const cornerPoints = getManualLoopPoints(rectangle);
         return getCenterPointsOnPolygon$1(cornerPoints);
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle: (board, element) => {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 3) / 4;
         rectangle.x += width / 8;
@@ -4901,17 +4890,18 @@ const MergeEngine = createPolygonEngine({
         const lineCenterPoints = getCenterPointsOnPolygon$1(cornerPoints);
         return [...lineCenterPoints, ...cornerPoints];
     },
-    getTextRectangle(element) {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
         const width = (originWidth * 2) / 3;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 6,
-            y: elementRectangle.y + ((elementRectangle.height * 2) / 3 - height) / 2
+            y: elementRectangle.y + ((elementRectangle.height * 2) / 3 - textSize.height) / 2
         };
     }
 });
@@ -5025,8 +5015,8 @@ const StoredDataEngine = {
             [rectangle.x, rectangle.y + rectangle.height / 2]
         ];
     },
-    getTextRectangle(element) {
-        const rectangle = getTextRectangle(element);
+    getTextRectangle(board, element) {
+        const rectangle = getTextRectangle$1(board, element);
         const width = rectangle.width;
         rectangle.width = (rectangle.width * 3) / 4;
         rectangle.x += width / 8;
@@ -5062,16 +5052,17 @@ const PredefinedProcessEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2 - elementRectangle.width * 0.06 * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + elementRectangle.width * 0.06,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5090,16 +5081,17 @@ const OffPageEngine = createPolygonEngine({
     getConnectorPoints: (rectangle) => {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
             width: width > 0 ? width : 0,
-            height: height,
+            height: textSize.height,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - elementRectangle.height / 2 - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - elementRectangle.height / 2 - textSize.height) / 2
         };
     }
 });
@@ -5204,16 +5196,17 @@ const DocumentEngine = {
         }
         return getUnitVectorByPointAndPoint(connectionPoint, [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height]);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2 - elementRectangle.width * 0.06 * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + elementRectangle.width * 0.06,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5245,39 +5238,14 @@ const getMultiDocumentPoints = (rectangle) => {
 const MultiDocumentEngine = {
     draw(board, rectangle, options) {
         const rs = PlaitBoard.getRoughSVG(board);
-        const shape = rs.path(`M${rectangle.x} ${rectangle.y + rectangle.height - rectangle.height / 9} V${rectangle.y + 10} H${rectangle.x +
-            5} V${rectangle.y + 5} H${rectangle.x + 10} V${rectangle.y} H${rectangle.x + rectangle.width} V${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9 -
-            10 -
-            3} L${rectangle.x + rectangle.width - 5} ${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9 -
-            10 -
-            3 -
-            4} V${rectangle.y + rectangle.height - rectangle.height / 9 - 5 - 3}
-                 L${rectangle.x + rectangle.width - 10} ${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9 -
-            5 -
-            3 -
-            4} V${rectangle.y + rectangle.height - rectangle.height / 9}
+        const shape = rs.path(`M${rectangle.x} ${rectangle.y + rectangle.height - rectangle.height / 9} V${rectangle.y + 10} H${rectangle.x + 5} V${rectangle.y + 5} H${rectangle.x + 10} V${rectangle.y} H${rectangle.x + rectangle.width} V${rectangle.y + rectangle.height - rectangle.height / 9 - 10 - 3} L${rectangle.x + rectangle.width - 5} ${rectangle.y + rectangle.height - rectangle.height / 9 - 10 - 3 - 4} V${rectangle.y + rectangle.height - rectangle.height / 9 - 5 - 3}
+                 L${rectangle.x + rectangle.width - 10} ${rectangle.y + rectangle.height - rectangle.height / 9 - 5 - 3 - 4} V${rectangle.y + rectangle.height - rectangle.height / 9}
                 
-             Q${rectangle.x + rectangle.width - 10 - (rectangle.width - 10) / 4} ${rectangle.y +
-            rectangle.height -
-            (rectangle.height / 9) * 3}, ${rectangle.x + (rectangle.width - 10) / 2} ${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9} T${rectangle.x} ${rectangle.y + rectangle.height - rectangle.height / 9}
+             Q${rectangle.x + rectangle.width - 10 - (rectangle.width - 10) / 4} ${rectangle.y + rectangle.height - (rectangle.height / 9) * 3}, ${rectangle.x + (rectangle.width - 10) / 2} ${rectangle.y + rectangle.height - rectangle.height / 9} T${rectangle.x} ${rectangle.y + rectangle.height - rectangle.height / 9}
               
-                M${rectangle.x + 5} ${rectangle.y + 10} H${rectangle.x + rectangle.width - 10} V${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9} 
+                M${rectangle.x + 5} ${rectangle.y + 10} H${rectangle.x + rectangle.width - 10} V${rectangle.y + rectangle.height - rectangle.height / 9} 
                     
-                M${rectangle.x + 10} ${rectangle.y + 5} H${rectangle.x + rectangle.width - 5} V${rectangle.y +
-            rectangle.height -
-            rectangle.height / 9 -
-            10 -
-            3}
+                M${rectangle.x + 10} ${rectangle.y + 5} H${rectangle.x + rectangle.width - 5} V${rectangle.y + rectangle.height - rectangle.height / 9 - 10 - 3}
             `, { ...options, fillStyle: 'solid' });
         setStrokeLinecap(shape, 'round');
         return shape;
@@ -5315,7 +5283,7 @@ const MultiDocumentEngine = {
         let nearestDistance = distanceBetweenPointAndPoint(point[0], point[1], nearestPoint[0], nearestPoint[1]);
         crossingPoints
             .filter((v, index) => index > 0)
-            .forEach(crossingPoint => {
+            .forEach((crossingPoint) => {
             let distance = distanceBetweenPointAndPoint(point[0], point[1], crossingPoint[0], crossingPoint[1]);
             if (distance < nearestDistance) {
                 nearestDistance = distance;
@@ -5341,16 +5309,17 @@ const MultiDocumentEngine = {
         const factor = getDirectionFactor(direction);
         return [factor.x, factor.y];
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2 - elementRectangle.width * 0.06 * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width - 10 : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + elementRectangle.width * 0.06,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5421,16 +5390,17 @@ const DatabaseEngine = {
         const vector = getVectorFromPointAndSlope(point[0], point[1], slope);
         return vector;
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + elementRectangle.height * 0.3 + (elementRectangle.height - elementRectangle.height * 0.45 - height) / 2
+            y: elementRectangle.y + elementRectangle.height * 0.3 + (elementRectangle.height - elementRectangle.height * 0.45 - textSize.height) / 2
         };
     }
 };
@@ -5501,16 +5471,17 @@ const HardDiskEngine = {
         const vector = getVectorFromPointAndSlope(point[0], point[1], slope);
         return vector;
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - elementRectangle.width * 0.45 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + elementRectangle.width * 0.15 + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5543,16 +5514,17 @@ const InternalStorageEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - elementRectangle.width * 0.1 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + elementRectangle.width * 0.1 + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + elementRectangle.height * 0.1 + (elementRectangle.height - elementRectangle.height * 0.1 - height) / 2
+            y: elementRectangle.y + elementRectangle.height * 0.1 + (elementRectangle.height - elementRectangle.height * 0.1 - textSize.height) / 2
         };
     }
 };
@@ -5623,16 +5595,17 @@ const NoteCurlyLeftEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - elementRectangle.width * 0.09 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5706,16 +5679,17 @@ const NoteCurlyRightEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - elementRectangle.width * 0.09 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + elementRectangle.width * 0.09 + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5747,16 +5721,17 @@ const NoteSquareEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5819,16 +5794,17 @@ const DisplayEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - strokeWidth * 2 - elementRectangle.width * 0.25;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
             width: width > 0 ? width : 0,
-            height: height,
+            height: textSize.height,
             x: elementRectangle.x + strokeWidth + elementRectangle.width * 0.15,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -5844,7 +5820,7 @@ const TableEngine = {
                 const tableTopBorder = drawLine(rs, [x, y], [x + width, y], roughOptions);
                 const tableLeftBorder = drawLine(rs, [x, y], [x, y + height], roughOptions);
                 g.append(tableTopBorder, tableLeftBorder);
-                pointCells.forEach(cell => {
+                pointCells.forEach((cell) => {
                     const rectangle = RectangleClient.getRectangleByPoints(cell.points);
                     const { x, y, width, height } = rectangle;
                     const cellRectangle = drawRectangle(board, {
@@ -5878,16 +5854,16 @@ const TableEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element, options) {
+    getTextRectangle(board, element, options) {
         try {
             if (options && options.id) {
-                const cell = getCellWithPoints(options?.board, element, options.id);
+                const cell = getCellWithPoints(board, element, options.id);
                 if (cell) {
                     if (PlaitTableElement.isVerticalText(cell)) {
-                        return getVerticalTextRectangle(cell);
+                        return getVerticalTextRectangle(board, cell);
                     }
                     else {
-                        return getHorizontalTextRectangle(cell);
+                        return getHorizontalTextRectangle(board, cell);
                     }
                 }
             }
@@ -5903,30 +5879,50 @@ const TableEngine = {
         };
     }
 };
-function getVerticalTextRectangle(cell) {
+function getVerticalTextRectangle(board, cell) {
     const cellRectangle = RectangleClient.getRectangleByPoints(cell.points);
     const strokeWidth = getStrokeWidthByElement(cell);
-    const height = cell.textHeight || 0;
     const width = cellRectangle.height - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
-    return {
-        width: width > 0 ? width : 0,
-        height,
-        x: cellRectangle.x - width / 2 + cellRectangle.width / 2,
-        y: cellRectangle.y + (cellRectangle.height - height) / 2
-    };
+    return getTextRectangle(board, cell, width, cellRectangle);
 }
-function getHorizontalTextRectangle(cell) {
+function getHorizontalTextRectangle(board, cell) {
     const cellRectangle = RectangleClient.getRectangleByPoints(cell.points);
     const strokeWidth = getStrokeWidthByElement(cell);
-    const height = cell.textHeight || 0;
     const width = cellRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
-    return {
-        height,
-        width: width > 0 ? width : 0,
-        x: cellRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-        y: cellRectangle.y + (cellRectangle.height - height) / 2
-    };
+    return getTextRectangle(board, cell, width, cellRectangle);
+}
+function getTextRectangle(board, cell, width, cellRectangle) {
+    const text = cell.text;
+    if (text) {
+        const textSize = getTextSize(board, text, width);
+        return {
+            width: width > 0 ? width : 0,
+            height: textSize.height,
+            x: cellRectangle.x - width / 2 + cellRectangle.width / 2,
+            y: cellRectangle.y + (cellRectangle.height - textSize.height) / 2
+        };
+    }
+    else {
+        return {
+            width: 0,
+            height: 0,
+            x: cellRectangle.x,
+            y: cellRectangle.y
+        };
+    }
 }
+const getCellTextHeight = (board, cell, isVertical = false) => {
+    if (cell.text) {
+        const cellRectangle = RectangleClient.getRectangleByPoints(cell.points);
+        const strokeWidth = getStrokeWidthByElement(cell);
+        let width = cellRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        if (isVertical) {
+            width = cellRectangle.height - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        }
+        return getTextSize(board, cell.text, width).height;
+    }
+    return 0;
+};
 
 function generateActorPath(rectangle) {
     const centerX = rectangle.x + rectangle.width / 2;
@@ -6032,12 +6028,13 @@ const ActorEngine = {
         }
         return getUnitVectorByPointAndPoint(connectionPoint, [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height]);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
-        const height = element.textHeight;
         const width = elementRectangle.width + 40;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x - 20,
             y: elementRectangle.y + elementRectangle.height + 4
@@ -6070,16 +6067,17 @@ const ContainerEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle(board, element) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = 40 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -6158,26 +6156,28 @@ const PackageEngine = {
         }
         return getUnitVectorByPointAndPoint([rectangle.x + rectangle.width * 0.8, rectangle.y + 25], connectionPoint);
     },
-    getTextRectangle(element, options) {
+    getTextRectangle(board, element, options) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const textHeight = element.texts?.find(item => item.id === options?.id)?.textHeight;
-        if (options?.id === GeometryCommonTextKeys.name) {
+        const textInfo = element.texts?.find((item) => item.id === options?.id);
+        if (options?.id === GeometryCommonTextKeys.name && textInfo) {
             const width = elementRectangle.width * 0.7 - ShapeDefaultSpace.rectangleAndText - strokeWidth;
+            const textSize = getTextSize(board, textInfo.text, width);
             return {
-                height: textHeight,
+                height: textSize.height,
                 width: width > 0 ? width : 0,
                 x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-                y: elementRectangle.y + (25 - textHeight) / 2
+                y: elementRectangle.y + (25 - textSize.height) / 2
             };
         }
-        if (options?.id === GeometryCommonTextKeys.content) {
+        if (options?.id === GeometryCommonTextKeys.content && textInfo) {
             const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+            const textSize = getTextSize(board, textInfo.text, width);
             return {
-                height: textHeight,
+                height: textSize.height,
                 width: width > 0 ? width : 0,
                 x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-                y: elementRectangle.y + 25 + (elementRectangle.height - 25 - textHeight) / 2
+                y: elementRectangle.y + 25 + (elementRectangle.height - 25 - textSize.height) / 2
             };
         }
         return elementRectangle;
@@ -6218,23 +6218,25 @@ const CombinedFragmentEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element, options) {
+    getTextRectangle(board, element, options) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const textHeight = element.texts?.find(item => item.id === options?.id)?.textHeight;
-        if (options?.id === GeometryCommonTextKeys.name) {
+        const textInfo = element.texts?.find((item) => item.id === options?.id);
+        if (options?.id === GeometryCommonTextKeys.name && textInfo) {
             const width = elementRectangle.width / 3 - 8 - ShapeDefaultSpace.rectangleAndText - strokeWidth;
+            const textSize = getTextSize(board, textInfo.text, width);
             return {
-                height: textHeight,
+                height: textSize.height,
                 width: width > 0 ? width : 0,
                 x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-                y: elementRectangle.y + (25 - textHeight) / 2
+                y: elementRectangle.y + (25 - textSize.height) / 2
             };
         }
-        if (options?.id === GeometryCommonTextKeys.content) {
+        if (options?.id === GeometryCommonTextKeys.content && textInfo) {
             const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+            const textSize = getTextSize(board, textInfo.text, width);
             return {
-                height: textHeight,
+                height: textSize.height,
                 width: width > 0 ? width : 0,
                 x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
                 y: elementRectangle.y + 25 + ShapeDefaultSpace.rectangleAndText + strokeWidth
@@ -6323,16 +6325,17 @@ const ActiveClassEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2 - elementRectangle.width * 0.125 * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + elementRectangle.width * 0.125,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -6377,16 +6380,17 @@ const NoteEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle: (element) => {
+    getTextRectangle: (board, element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth - 15;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -6761,16 +6765,17 @@ const ComponentEngine = {
             [points.mainStart[0], rectangle.y + rectangle.height / 2]
         ];
     },
-    getTextRectangle(element) {
+    getTextRectangle(board, element) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - 24 - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + 24 + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -6815,17 +6820,18 @@ const ComponentBoxEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle(board, element) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const componentWidth = elementRectangle.width - 45 * 2 - 18 > 1 ? 45 : elementRectangle.width * 0.25;
         const width = elementRectangle.width - 18 - componentWidth - ShapeDefaultSpace.rectangleAndText - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -6858,16 +6864,17 @@ const TemplateEngine = {
     getConnectorPoints(rectangle) {
         return RectangleClient.getEdgeCenterPoints(rectangle);
     },
-    getTextRectangle(element) {
+    getTextRectangle(board, element) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
         const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const text = element.text;
+        const textSize = getTextSize(board, text, width);
         return {
-            height,
+            height: textSize.height,
             width: width > 0 ? width : 0,
             x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-            y: elementRectangle.y + (elementRectangle.height - height) / 2
+            y: elementRectangle.y + (elementRectangle.height - textSize.height) / 2
         };
     }
 };
@@ -7361,8 +7368,7 @@ class GeometryComponent extends CommonElementFlavour {
                 if (isMultipleTextGeometry(element)) {
                     DrawTransforms.setDrawTexts(this.board, element, {
                         id: text.id,
-                        text: textManageChangeData.newText,
-                        textHeight: textManageChangeData.height
+                        text: textManageChangeData.newText
                     });
                 }
                 else {
@@ -7383,12 +7389,12 @@ class GeometryComponent extends CommonElementFlavour {
             this.textGenerator = new SingleTextGenerator(this.board, this.element, this.element.text, {
                 onChange: onTextChange,
                 getMaxWidth: () => {
-                    let width = getTextRectangle(this.element).width;
+                    let width = getTextRectangle$1(this.board, this.element).width;
                     const getRectangle = getEngine(this.element.shape).getTextRectangle;
                     if (getRectangle) {
-                        width = getRectangle(this.element).width;
+                        width = getRectangle(this.board, this.element).width;
                     }
-                    return this.element?.autoSize ? GeometryThreshold.defaultTextMaxWidth : width;
+                    return PlaitDrawElement.isText(this.element) && this.element.autoSize ? GeometryThreshold.defaultTextMaxWidth : width;
                 }
             });
         }
@@ -7512,12 +7518,10 @@ class ArrowLineComponent extends CommonElementFlavour {
                 const path = PlaitBoard.findPath(this.board, this.element);
                 const node = PlaitNode.get(this.board, path);
                 const texts = [...node.texts];
-                const newWidth = textManageChangeData.width < MIN_TEXT_WIDTH ? MIN_TEXT_WIDTH : textManageChangeData.width;
+                // const newWidth = textManageChangeData.width < MIN_TEXT_WIDTH ? MIN_TEXT_WIDTH : textManageChangeData.width;
                 texts.splice(index, 1, {
                     text: textManageChangeData.newText ? textManageChangeData.newText : this.element.texts[index].text,
-                    position: this.element.texts[index].position,
-                    width: newWidth,
-                    height: textManageChangeData.height
+                    position: this.element.texts[index].position
                 });
                 DrawTransforms.setArrowLineTexts(this.board, this.element, texts);
                 textManageChangeData.operations && memorizeLatestText(this.element, textManageChangeData.operations);
@@ -7633,7 +7637,7 @@ const withDrawHotkey = (board) => {
             const hitElement = getHitElementByPoint(board, point, undefined, false);
             if (hitElement && PlaitDrawElement.isGeometry(hitElement) && isDrawElementIncludeText(hitElement)) {
                 if (isMultipleTextGeometry(hitElement)) {
-                    const hitText = getHitMultipleGeometryText(hitElement, point) ||
+                    const hitText = getHitMultipleGeometryText(board, hitElement, point) ||
                         hitElement.texts.find((item) => item.id.includes(GeometryCommonTextKeys.content)) ||
                         hitElement.texts[0];
                     editText(board, hitElement, hitText);
@@ -7683,7 +7687,7 @@ const withGeometryCreateByDrag = (board) => {
                 if (!fakeCreateTextRef) {
                     const textManage = new TextManage(board, {
                         getRectangle: () => {
-                            return getTextRectangle(temporaryElement);
+                            return getTextRectangle$1(board, temporaryElement);
                         }
                     });
                     textManage.draw(temporaryElement.text);
@@ -8167,16 +8171,10 @@ const withArrowLineText = (board) => {
                     const defaultLineText = getDefaultLineText(board);
                     const textMemory = getMemorizedLatest('arrow-line')?.text || {};
                     const textElement = buildText(defaultLineText, undefined, textMemory);
-                    const { width, height } = measureElement(board, textElement, {
-                        fontSize: DEFAULT_FONT_SIZE,
-                        fontFamily: DEFAULT_FONT_FAMILY
-                    });
                     const ratio = getRatioByPoint(points, point);
                     texts.push({
                         text: textElement,
-                        position: ratio,
-                        width,
-                        height
+                        position: ratio
                     });
                     DrawTransforms.setArrowLineTexts(board, hitTarget, texts);
                     setTimeout(() => {
@@ -8679,7 +8677,7 @@ class TableComponent extends CommonElementFlavour {
                 const textManage = getTextManageByCell(this.board, item);
                 if (textManage) {
                     const engine = getEngine(TableSymbols.table);
-                    const rectangle = engine.getTextRectangle(this.element, { id: item.id, board: this.board });
+                    const rectangle = engine.getTextRectangle(this.board, this.element, { id: item.id, board: this.board });
                     textManage.g.classList.add('vertical-cell-text');
                     setAngleForG(textManage.g, RectangleClient.getCenterPoint(rectangle), degreesToRadians(-90));
                 }
@@ -8693,7 +8691,6 @@ class TableComponent extends CommonElementFlavour {
             return {
                 id: item.id,
                 text: item.text,
-                textHeight: item.textHeight,
                 board: this.board
             };
         });
@@ -8713,17 +8710,17 @@ class TableComponent extends CommonElementFlavour {
                 if (PlaitTableElement.isVerticalText(cell)) {
                     const cellRectangle = RectangleClient.getRectangleByPoints(cell.points);
                     const strokeWidth = getStrokeWidthByElement(cell);
-                    const width = cell.textHeight || 0;
-                    const height = cellRectangle.height - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+                    const width = cellRectangle.height - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+                    const height = getCellTextHeight(this.board, cell, true);
                     return {
-                        width,
-                        height: height > 0 ? height : 0,
+                        width: height,
+                        height: width > 0 ? width : 0,
                         x: cellRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
-                        y: cellRectangle.y + (cellRectangle.height - height) / 2
+                        y: cellRectangle.y + (cellRectangle.height - width) / 2
                     };
                 }
                 else {
-                    return getHorizontalTextRectangle(cell);
+                    return getHorizontalTextRectangle(this.board, cell);
                 }
             }
         });
@@ -8946,9 +8943,9 @@ const withTable = (board) => {
             event.preventDefault();
             if (PlaitDrawElement.isElementByTable(targetElement)) {
                 const cells = getSelectedCells(targetElement);
-                let cell = targetElement.cells.find((item) => item.text && item.textHeight);
+                let cell = targetElement.cells.find((item) => item.text);
                 if (cells?.length) {
-                    cell = cells.find((item) => item.text && item.textHeight);
+                    cell = cells.find((item) => item.text);
                 }
                 if (cell) {
                     editCell(board, cell);
@@ -8965,7 +8962,7 @@ const withTable = (board) => {
             const hitElement = getHitElementByPoint(board, point);
             if (hitElement && PlaitDrawElement.isElementByTable(hitElement)) {
                 const hitCell = getHitCell(tableBoard, hitElement, point);
-                if (hitCell && hitCell.text && hitCell.textHeight) {
+                if (hitCell && hitCell.text) {
                     editCell(board, hitCell);
                     return;
                 }
@@ -8984,7 +8981,7 @@ const withTable = (board) => {
             const point = toViewBoxPoint(tableBoard, toHostPoint(tableBoard, event.x, event.y));
             const element = getSelectedTableElements(tableBoard)[0];
             const hitCell = getHitCell(tableBoard, element, point);
-            if (hitCell && hitCell.text && hitCell.textHeight) {
+            if (hitCell && hitCell.text) {
                 setSelectedCells(element, [hitCell]);
             }
         }
@@ -9390,5 +9387,5 @@ const withDraw = (board) => {
  * Generated bundle index. Do not edit.
  */
 
-export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BOARD_TO_PRE_COMMIT, 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, DefaultLineStyle, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawI18nKey, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryCommonTextKeys, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_ALIGN_TOLERANCE, LINE_AUTO_COMPLETE_DIAMETER, LINE_AUTO_COMPLETE_HOVERED_DIAMETER, LINE_AUTO_COMPLETE_HOVERED_OPACITY, LINE_AUTO_COMPLETE_OPACITY, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LINE_TEXT, LINE_TEXT_SPACE, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLinePointerType, VectorLineShape, WithArrowLineAutoCompletePluginKey, WithDrawPluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildClipboardData, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, 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, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultGeometryText, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectionFromConnectionPoint, getHitConnectorPoint, getHitDrawElement, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedCustomGeometryElements, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSolidElements, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getSwimlaneShapes, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePointers, getVectorLinePoints, handleArrowLineCreating, hasIllegalElbowPoint, insertClipboardData, insertElement, isCellIncludeText, isClosedCustomGeometry, isClosedDrawElement, isClosedPoints, isDrawElementIncludeText, isDrawElementsIncludeText, isEmptyTextElement, isFilledDrawElement, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isRectangleHitRotatedElement, isRectangleHitRotatedPoints, isSelfLoop, isSingleSelectLine, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneShape, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
+export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BOARD_TO_PRE_COMMIT, 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, DefaultLineStyle, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawI18nKey, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryCommonTextKeys, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_ALIGN_TOLERANCE, LINE_AUTO_COMPLETE_DIAMETER, LINE_AUTO_COMPLETE_HOVERED_DIAMETER, LINE_AUTO_COMPLETE_HOVERED_OPACITY, LINE_AUTO_COMPLETE_OPACITY, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LINE_TEXT, LINE_TEXT_SPACE, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLinePointerType, VectorLineShape, WithArrowLineAutoCompletePluginKey, WithDrawPluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildClipboardData, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, 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, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultGeometryText, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectionFromConnectionPoint, getHitConnectorPoint, getHitDrawElement, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedCustomGeometryElements, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSolidElements, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getSwimlaneShapes, getTextKey, getTextManage, getTextManageByCell, getTextRectangle$1 as getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePointers, getVectorLinePoints, handleArrowLineCreating, hasIllegalElbowPoint, insertClipboardData, insertElement, isCellIncludeText, isClosedCustomGeometry, isClosedDrawElement, isClosedPoints, isDrawElementIncludeText, isDrawElementsIncludeText, isEmptyTextElement, isFilledDrawElement, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isRectangleHitRotatedElement, isRectangleHitRotatedPoints, isSelfLoop, isSingleSelectLine, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneShape, isSwimlaneWithHeader, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
 //# sourceMappingURL=plait-draw.mjs.map