@plait/draw 0.70.0 → 0.72.0

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, DEFAULT_COLOR, ThemeColorMode, RectangleClient, getSelectedElements, idCreator, catmullRomFitting, PlaitBoard, createG, drawLinearPath, setStrokeLinecap, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPointInPolygon, rotatePointsByElement, isPolylineHitRectangle, rotateAntiPointsByElement, distanceBetweenPointAndPoint, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, rotate, findElements, createMask, createRect, PlaitElement, getElementById, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, setPathStrokeLinecap, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, SELECTION_RECTANGLE_CLASS_NAME, getHitElementByPoint, WritableClipboardOperationType, createClipboardContext, WritableClipboardType, addClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
-import { DEFAULT_FILL, Alignment, WithTextPluginKey, ELEMENT_TO_TEXT_MANAGES, TextManage, getMemorizedLatest, memorizeLatest, getPointOnPolyline, buildText, Generator, sortElementsByArea, isFilled, getTextEditorsByElement, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, RESIZE_HANDLE_DIAMETER, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, canResize, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
+import { ACTIVE_STROKE_WIDTH, DEFAULT_COLOR, ThemeColorMode, PlaitElement, RectangleClient, getSelectedElements, idCreator, catmullRomFitting, PlaitBoard, createG, drawLinearPath, setStrokeLinecap, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPointInPolygon, isPolylineHitRectangle, rotatePointsByAngle, rotateAntiPointsByElement, distanceBetweenPointAndPoint, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, rotate, findElements, createMask, createRect, getElementById, rotatePointsByElement, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, setPathStrokeLinecap, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, SELECTION_RECTANGLE_CLASS_NAME, getHitElementByPoint, WritableClipboardOperationType, WritableClipboardType, addOrCreateClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
+import { DEFAULT_FILL, Alignment, WithTextPluginKey, TextManage, getMemorizedLatest, memorizeLatest, getPointOnPolyline, buildText, Generator, getStrokeLineDash, StrokeStyle, sortElementsByArea, isFilled, getTextEditorsByElement, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, RESIZE_HANDLE_DIAMETER, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, getFirstTextEditor, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, buildClipboardData as buildClipboardData$1, insertClipboardData as insertClipboardData$1, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, canResize, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import { TEXT_DEFAULT_HEIGHT, DEFAULT_FONT_SIZE, AlignEditor } from '@plait/text-plugins';
 import { isKeyHotkey } from 'is-hotkey';
@@ -80,11 +80,11 @@ var UMLSymbols;
     UMLSymbols["providedInterface"] = "providedInterface";
     UMLSymbols["requiredInterface"] = "requiredInterface";
 })(UMLSymbols || (UMLSymbols = {}));
-var MultipleTextGeometryCommonTextKeys;
-(function (MultipleTextGeometryCommonTextKeys) {
-    MultipleTextGeometryCommonTextKeys["name"] = "name";
-    MultipleTextGeometryCommonTextKeys["content"] = "content";
-})(MultipleTextGeometryCommonTextKeys || (MultipleTextGeometryCommonTextKeys = {}));
+var GeometryCommonTextKeys;
+(function (GeometryCommonTextKeys) {
+    GeometryCommonTextKeys["name"] = "name";
+    GeometryCommonTextKeys["content"] = "content";
+})(GeometryCommonTextKeys || (GeometryCommonTextKeys = {}));
 const PlaitGeometry = {};
 
 var SwimlaneSymbols;
@@ -113,6 +113,8 @@ const PlaitTableElement = {
     }
 };
 
+const WithDrawPluginKey = 'plait-draw-plugin-key';
+
 const ShapeDefaultSpace = {
     rectangleAndText: 4
 };
@@ -213,12 +215,12 @@ const DefaultPackageProperty = {
     height: 150,
     texts: [
         {
-            key: MultipleTextGeometryCommonTextKeys.name,
+            id: GeometryCommonTextKeys.name,
             text: '包名',
             align: Alignment.left
         },
         {
-            key: MultipleTextGeometryCommonTextKeys.content,
+            id: GeometryCommonTextKeys.content,
             text: '',
             align: Alignment.left
         }
@@ -261,12 +263,12 @@ const DefaultCombinedFragmentProperty = {
     height: 280,
     texts: [
         {
-            key: MultipleTextGeometryCommonTextKeys.name,
+            id: GeometryCommonTextKeys.name,
             text: 'Opt | Alt | Loop',
             align: Alignment.left
         },
         {
-            key: MultipleTextGeometryCommonTextKeys.content,
+            id: GeometryCommonTextKeys.content,
             text: '[Condition]',
             align: Alignment.left
         }
@@ -356,8 +358,8 @@ const DefaultUMLPropertyMap = {
     [UMLSymbols.requiredInterface]: DefaultRequiredInterfaceProperty
 };
 const MultipleTextGeometryTextKeys = {
-    [UMLSymbols.package]: Object.keys(MultipleTextGeometryCommonTextKeys),
-    [UMLSymbols.combinedFragment]: Object.keys(MultipleTextGeometryCommonTextKeys)
+    [UMLSymbols.package]: Object.keys(GeometryCommonTextKeys),
+    [UMLSymbols.combinedFragment]: Object.keys(GeometryCommonTextKeys)
 };
 const LINE_HIT_GEOMETRY_BUFFER = 10;
 const LINE_SNAPPING_BUFFER = 6;
@@ -400,8 +402,8 @@ const getUMLPointers = () => {
 const getArrowLinePointers = () => {
     return Object.keys(ArrowLineShape);
 };
-const getVectorPenPointers = () => {
-    return Object.keys(VectorPenPointerType);
+const getVectorLinePointers = () => {
+    return Object.keys(VectorLinePointerType);
 };
 
 const DEFAULT_IMAGE_WIDTH = 1000;
@@ -469,14 +471,20 @@ const getElementShape = (value) => {
     return value.shape;
 };
 
+// TODO: 是否可以完全基于位置定位 TextManager，实现 line 和 多文本 geometry 统一
+// 一个元素有多个文本时，单纯通过位置无法获取 TextManage，因此这里单独通过 Map 保存关键字 key 和 TextManage 的对应关系
+// 1. 单文本元素 key 就是元素的 id
+// 2. 表格元素 key 是单元格的 id
+// 3. 符合 isMultipleTextGeometry 的元素，key 是元素 id + text.id （通常不是 id 而是文本位置的常量）
+// 4. arrow-line 和 vector-line 文本不依赖于 text.generator，基于 text 可以直接找到 TextManage
 const KEY_TO_TEXT_MANAGE = new WeakMap();
-const setTextManage = (board, key, textManage) => {
+const setTextManage = (board, element, text, textManage) => {
     const textManages = KEY_TO_TEXT_MANAGE.get(board);
-    return KEY_TO_TEXT_MANAGE.set(board, { ...textManages, [key]: textManage });
+    return KEY_TO_TEXT_MANAGE.set(board, { ...textManages, [getTextKey(element, text)]: textManage });
 };
-const getTextManage = (board, key) => {
+const getTextManage = (board, element, text) => {
     const textManages = KEY_TO_TEXT_MANAGE.get(board);
-    return textManages[key];
+    return textManages[getTextKey(element, text)];
 };
 const deleteTextManage = (board, key) => {
     const textManages = KEY_TO_TEXT_MANAGE.get(board);
@@ -498,15 +506,16 @@ class TextGenerator {
             .textPlugins;
         this.textManages = this.texts.map(text => {
             const textManage = this.createTextManage(text, textPlugins);
-            setTextManage(this.board, getTextKey(this.element, text), textManage);
+            setTextManage(this.board, this.element, text, textManage);
             return textManage;
         });
-        ELEMENT_TO_TEXT_MANAGES.set(this.element, this.textManages);
+        const ref = PlaitElement.getElementRef(this.element);
+        ref.initializeTextManage(this.textManages);
     }
     draw(elementG) {
         const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
         this.texts.forEach(drawShapeText => {
-            const textManage = getTextManage(this.board, getTextKey(this.element, drawShapeText));
+            const textManage = getTextManage(this.board, this.element, drawShapeText);
             if (drawShapeText.text && textManage) {
                 textManage.draw(drawShapeText.text);
                 elementG.append(textManage.g);
@@ -516,30 +525,29 @@ class TextGenerator {
     }
     update(element, previousDrawShapeTexts, currentDrawShapeTexts, elementG) {
         this.element = element;
-        ELEMENT_TO_TEXT_MANAGES.set(this.element, this.textManages);
         const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
         const textPlugins = (this.board.getPluginOptions(WithTextPluginKey) || {})
             .textPlugins;
         const removedTexts = previousDrawShapeTexts.filter(value => {
-            return !currentDrawShapeTexts.find(item => item.key === value.key);
+            return !currentDrawShapeTexts.find(item => item.id === value.id);
         });
         if (removedTexts.length) {
             removedTexts.forEach(item => {
-                const textManage = getTextManage(this.board, item.key);
+                const textManage = getTextManage(this.board, element, item);
                 const index = this.textManages.findIndex(value => value === textManage);
                 if (index > -1 && item.text && item.textHeight) {
                     this.textManages.splice(index, 1);
                 }
                 textManage?.destroy();
-                deleteTextManage(this.board, item.key);
+                deleteTextManage(this.board, item.id);
             });
         }
         currentDrawShapeTexts.forEach(drawShapeText => {
             if (drawShapeText.text) {
-                let textManage = getTextManage(this.board, getTextKey(this.element, drawShapeText));
+                let textManage = getTextManage(this.board, this.element, drawShapeText);
                 if (!textManage) {
                     textManage = this.createTextManage(drawShapeText, textPlugins);
-                    setTextManage(this.board, drawShapeText.key, textManage);
+                    setTextManage(this.board, element, drawShapeText, textManage);
                     textManage.draw(drawShapeText.text);
                     elementG.append(textManage.g);
                     this.textManages.push(textManage);
@@ -581,13 +589,11 @@ class TextGenerator {
         return this.options.getMaxWidth ? this.options.getMaxWidth() : this.getRectangle(text).width;
     }
     destroy() {
-        this.textManages.forEach(manage => {
-            manage.destroy();
-        });
+        const ref = PlaitElement.getElementRef(this.element);
+        ref.destroyTextManage();
         this.textManages = [];
-        ELEMENT_TO_TEXT_MANAGES.delete(this.element);
         this.texts.forEach(item => {
-            deleteTextManage(this.board, item.key);
+            deleteTextManage(this.board, item.id);
         });
     }
 }
@@ -708,7 +714,7 @@ function editCell(board, cell) {
     textManage && textManage.edit();
 }
 function getTextManageByCell(board, cell) {
-    return getTextManage(board, cell.id);
+    return getTextManage(board, undefined, cell);
 }
 const updateColumns = (table, columnId, width, offset) => {
     const columns = table.columns.map(item => (item.id === columnId ? { ...item, width } : item));
@@ -925,7 +931,7 @@ const buildDefaultTextsByShape = (shape) => {
     return (textKeys || []).map((textKey) => {
         const text = defaultTexts?.find((item) => item?.key === textKey);
         return {
-            key: textKey,
+            id: textKey,
             text: buildText(text?.text || '', alignment || text?.align || Alignment.center, textProperties),
             textHeight: textHeight
         };
@@ -937,7 +943,7 @@ const getHitMultipleGeometryText = (element, point) => {
     let hitText;
     if (engine.getTextRectangle) {
         hitText = element.texts.find(text => {
-            const textRectangle = engine.getTextRectangle(element, { key: text.key });
+            const textRectangle = engine.getTextRectangle(element, { id: text.id });
             return RectangleClient.isHit(rectangle, textRectangle);
         });
     }
@@ -967,12 +973,6 @@ class VectorLineShapeGenerator extends Generator {
     }
 }
 
-const isClosedVectorLine = (vectorLine) => {
-    const points = vectorLine.points;
-    const startPoint = points[0];
-    const endPoint = points[points.length - 1];
-    return startPoint[0] === endPoint[0] && startPoint[1] === endPoint[1];
-};
 const getVectorLinePoints = (board, element) => {
     switch (element.shape) {
         case VectorLineShape.straight: {
@@ -1018,7 +1018,8 @@ const vectorLineCreating = (board, lineShape, points, movingPoint, lineShapeG) =
 const drawVectorLine = (board, element) => {
     const strokeWidth = getStrokeWidthByElement(element);
     const strokeColor = getStrokeColorByElement(board, element);
-    const strokeLineDash = getLineDashByElement(element);
+    const strokeStyle = getStrokeStyleByElement(board, element);
+    const strokeLineDash = getStrokeLineDash(strokeStyle, strokeWidth);
     const fill = getFillByElement(board, element);
     const options = { stroke: strokeColor, strokeWidth, strokeLineDash, fill };
     const lineG = createG();
@@ -1054,7 +1055,7 @@ const isHitArrowLine = (board, element, point) => {
 };
 const isHitVectorLine = (board, element, point) => {
     const points = getVectorLinePoints(board, element);
-    if (isClosedVectorLine(element)) {
+    if (isClosedPoints(element.points)) {
         return isPointInPolygon(point, points) || isHitPolyLine(points, point);
     }
     else {
@@ -1066,15 +1067,13 @@ const isRectangleHitElementText = (element, rectangle) => {
     if (isMultipleTextGeometry(element)) {
         const texts = element.texts;
         return texts.some(item => {
-            const textClient = engine.getTextRectangle(element, { key: item.key });
-            const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
-            return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
+            const textClient = engine.getTextRectangle(element, { id: item.id });
+            return isRectangleHitRotatedPoints(rectangle, RectangleClient.getCornerPoints(textClient), element.angle);
         });
     }
     else {
         const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);
-        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(textClient), element) || RectangleClient.getCornerPoints(textClient);
-        return isPolylineHitRectangle(rotatedCornerPoints, rectangle);
+        return isRectangleHitRotatedPoints(rectangle, RectangleClient.getCornerPoints(textClient), element.angle);
     }
 };
 const isHitElementText = (element, point) => {
@@ -1082,7 +1081,7 @@ const isHitElementText = (element, point) => {
     if (isMultipleTextGeometry(element)) {
         const texts = element.texts;
         return texts.some(item => {
-            const textClient = engine.getTextRectangle(element, { key: item.key });
+            const textClient = engine.getTextRectangle(element, { id: item.id });
             return RectangleClient.isPointInRectangle(textClient, point);
         });
     }
@@ -1094,18 +1093,14 @@ const isHitElementText = (element, point) => {
 const isRectangleHitDrawElement = (board, element, selection) => {
     const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
     if (PlaitDrawElement.isGeometry(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        let rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
-        const isHitElement = isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
+        const isHitElement = isRectangleHitRotatedElement(board, rangeRectangle, element);
         if (isHitElement) {
             return isHitElement;
         }
         return isRectangleHitElementText(element, rangeRectangle);
     }
     if (PlaitDrawElement.isImage(element)) {
-        const client = RectangleClient.getRectangleByPoints(element.points);
-        const rotatedCornerPoints = rotatePointsByElement(RectangleClient.getCornerPoints(client), element) || RectangleClient.getCornerPoints(client);
-        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
+        return isRectangleHitRotatedElement(board, rangeRectangle, element);
     }
     if (PlaitDrawElement.isArrowLine(element)) {
         const points = getArrowLinePoints(board, element);
@@ -1117,7 +1112,15 @@ const isRectangleHitDrawElement = (board, element, selection) => {
     }
     return null;
 };
-const getDrawHitElement = (board, elements) => {
+const isRectangleHitRotatedElement = (board, rectangle, element) => {
+    const client = RectangleClient.getRectangleByPoints(element.points);
+    return isRectangleHitRotatedPoints(rectangle, RectangleClient.getCornerPoints(client), element.angle);
+};
+const isRectangleHitRotatedPoints = (rectangle, points, angle) => {
+    let rotatedPoints = rotatePointsByAngle(points, angle) || points;
+    return isPolylineHitRectangle(rotatedPoints, rectangle);
+};
+const getHitDrawElement = (board, elements) => {
     let firstFilledElement = getFirstFilledDrawElement(board, elements);
     let endIndex = elements.length;
     if (firstFilledElement) {
@@ -1135,7 +1138,7 @@ const getFirstFilledDrawElement = (board, elements) => {
     let filledElement = null;
     for (let i = 0; i < elements.length; i++) {
         const element = elements[i];
-        if (isDrawElementClosed(element)) {
+        if (isCustomGeometryClosed(board, element) || isDrawElementClosed(element)) {
             const fill = getFillByElement(board, element);
             if (isFilled(fill)) {
                 filledElement = element;
@@ -1276,13 +1279,16 @@ const isDrawElementClosed = (element) => {
         return false;
     }
     if (PlaitDrawElement.isVectorLine(element)) {
-        return isClosedVectorLine(element);
+        return isClosedPoints(element.points);
     }
     if (PlaitDrawElement.isGeometry(element)) {
         return isGeometryClosed(element);
     }
     return true;
 };
+const isCustomGeometryClosed = (board, value) => {
+    return PlaitDrawElement.isCustomGeometryElement(board, value) && isClosedPoints(value.points);
+};
 const getSnappingShape = (board, point) => {
     let hitElement = getHitShape(board, point);
     if (hitElement) {
@@ -1357,16 +1363,16 @@ const drawBoundReaction = (board, element, roughOptions = { hasMask: true, hasCo
     return g;
 };
 const getTextKey = (element, text) => {
-    if (isMultipleTextGeometry(element)) {
-        return `${element.id}-${text.key}`;
+    if (element && isMultipleTextGeometry(element)) {
+        return `${element.id}-${text.id}`;
     }
     else {
-        return text.key;
+        return text.id;
     }
 };
 const getGeometryAlign = (board, element) => {
     if (isMultipleTextGeometry(element)) {
-        const drawShapeText = element.texts.find(item => item.key.includes(MultipleTextGeometryCommonTextKeys.content));
+        const drawShapeText = element.texts.find(item => item.id.includes(GeometryCommonTextKeys.content));
         return drawShapeText?.text.align || Alignment.center;
     }
     if (isSingleTextGeometry(element)) {
@@ -1378,6 +1384,11 @@ const getGeometryAlign = (board, element) => {
     }
     return Alignment.center;
 };
+const isClosedPoints = (points) => {
+    const startPoint = points[0];
+    const endPoint = points[points.length - 1];
+    return startPoint[0] === endPoint[0] && startPoint[1] === endPoint[1];
+};
 
 const getStrokeColorByElement = (board, element) => {
     const defaultColor = getDrawDefaultStrokeColor(board.theme.themeColorMode);
@@ -1385,23 +1396,13 @@ const getStrokeColorByElement = (board, element) => {
     return strokeColor;
 };
 const getFillByElement = (board, element) => {
-    const defaultFill = PlaitDrawElement.isFlowchart(element) && isDrawElementClosed(element)
-        ? getFlowchartDefaultFill(board.theme.themeColorMode)
+    const defaultFill = isDrawElementClosed(element) || isCustomGeometryClosed(board, element)
+        ? getDefaultFill(board.theme.themeColorMode)
         : DefaultDrawStyle.fill;
     const fill = element.fill || defaultFill;
     return fill;
 };
-const getLineDashByElement = (element) => {
-    switch (element.strokeStyle) {
-        case StrokeStyle.dashed:
-            return [8, 8 + getStrokeWidthByElement(element)];
-        case StrokeStyle.dotted:
-            return [2, 4 + getStrokeWidthByElement(element)];
-        default:
-            return undefined;
-    }
-};
-const getStrokeStyleByElement = (element) => {
+const getStrokeStyleByElement = (board, element) => {
     return element.strokeStyle || StrokeStyle.solid;
 };
 
@@ -1908,7 +1909,8 @@ const getCurvePoints = (board, element) => {
 const drawArrowLine = (board, element) => {
     const strokeWidth = getStrokeWidthByElement(element);
     const strokeColor = getStrokeColorByElement(board, element);
-    const strokeLineDash = getLineDashByElement(element);
+    const strokeStyle = getStrokeStyleByElement(board, element);
+    const strokeLineDash = getStrokeLineDash(strokeStyle, strokeWidth);
     const options = { stroke: strokeColor, strokeWidth, strokeLineDash };
     const lineG = createG();
     let points = getArrowLinePoints(board, element);
@@ -2253,7 +2255,7 @@ const getHitIndexOfAutoCompletePoint = (movingPoint, points) => {
 const getDrawDefaultStrokeColor = (theme) => {
     return DrawThemeColors[theme].strokeColor;
 };
-const getFlowchartDefaultFill = (theme) => {
+const getDefaultFill = (theme) => {
     return DrawThemeColors[theme].fill;
 };
 const getTextShapeProperty = (board, text = DefaultTextProperty.text, fontSize) => {
@@ -2313,7 +2315,7 @@ const createDefaultGeometry = (board, points, shape) => {
     }
 };
 const editText = (board, element, text) => {
-    const textManage = text ? getTextManage(board, `${element.id}-${text.key}`) : getFirstTextManage(element);
+    const textManage = text ? getTextManage(board, element, text) : getFirstTextManage(element);
     if (textManage) {
         textManage.edit(() => {
             // delay to avoid blinking
@@ -2458,6 +2460,10 @@ const getSelectedGeometryElements = (board) => {
     const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isGeometry(value));
     return selectedElements;
 };
+const getSelectedCustomGeometryElements = (board) => {
+    const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isCustomGeometryElement(board, value));
+    return selectedElements;
+};
 const getSelectedArrowLineElements = (board) => {
     const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isArrowLine(value));
     return selectedElements;
@@ -2474,6 +2480,10 @@ const isSingleSelectSwimlane = (board) => {
     const selectedElements = getSelectedElements(board);
     return selectedElements && selectedElements.length === 1 && PlaitDrawElement.isSwimlane(selectedElements[0]);
 };
+const isSingleSelectArrowLine = (board) => {
+    const selectedElements = getSelectedElements(board);
+    return selectedElements && selectedElements.length === 1 && PlaitDrawElement.isArrowLine(selectedElements[0]);
+};
 const getSelectedSwimlane = (board) => {
     const selectedElements = getSelectedElements(board);
     return selectedElements.find(item => PlaitDrawElement.isSwimlane(item));
@@ -2932,9 +2942,9 @@ const updateSwimlane = (board, swimlane, newColumns, newRows, newCells, newPoint
     }, path);
 };
 
-const setDrawShapeText = (board, element, text) => {
+const setDrawTexts = (board, element, text) => {
     const newTexts = element.texts?.map(item => {
-        if (item.key === text.key) {
+        if (item.id === text.id) {
             return { ...item, ...text };
         }
         return item;
@@ -3064,7 +3074,7 @@ const insertDrawByVector = (board, point, shape, vector) => {
 
 const DrawTransforms = {
     setText,
-    setDrawShapeText,
+    setDrawTexts,
     insertGeometry,
     resizeGeometry,
     insertText,
@@ -3126,7 +3136,10 @@ function withDrawResize(board) {
     let resizeActivePoints = null;
     const canResize = () => {
         const elements = getSelectedElements(board);
-        return elements.length > 1 && elements.every(el => PlaitDrawElement.isDrawElement(el));
+        return (elements.length >= 1 &&
+            elements.every(el => (PlaitDrawElement.isDrawElement(el) || PlaitDrawElement.isCustomGeometryElement(board, el)) &&
+                !isSingleSelectArrowLine(board) &&
+                !isSingleSelectSwimlane(board)));
     };
     const options = {
         key: 'draw-elements',
@@ -3150,7 +3163,7 @@ function withDrawResize(board) {
             snapG?.remove();
             debugGenerator$2.isDebug() && debugGenerator$2.clear();
             const isFromCorner = isCornerHandle(board, resizeRef.handle);
-            const isAspectRatio = resizeState.isShift || isFromCorner;
+            const isAspectRatio = resizeState.isShift;
             const centerPoint = RectangleClient.getCenterPoint(resizeRef.rectangle);
             const handleIndex = getIndexByResizeHandle(resizeRef.handle);
             const { originPoint, handlePoint } = getResizeOriginPointAndHandlePoint(board, handleIndex, resizeRef.rectangle);
@@ -3220,7 +3233,7 @@ function withDrawResize(board) {
                     }
                 }
                 if (PlaitDrawElement.isGeometry(target)) {
-                    if (isGeometryIncludeText(target)) {
+                    if (PlaitDrawElement.isGeometry(target) && isGeometryIncludeText(target)) {
                         const { height: textHeight } = getFirstTextManage(target).getSize();
                         DrawTransforms.resizeGeometry(board, points, textHeight, path);
                     }
@@ -3229,7 +3242,9 @@ function withDrawResize(board) {
                         Transforms.setNode(board, { points }, path);
                     }
                 }
-                else if (PlaitDrawElement.isArrowLine(target)) {
+                else if (PlaitDrawElement.isLine(target) ||
+                    PlaitDrawElement.isCustomGeometryElement(board, target) ||
+                    PlaitDrawElement.isVectorLine(target)) {
                     Transforms.setNode(board, { points }, path);
                 }
                 else if (PlaitDrawElement.isImage(target)) {
@@ -3608,6 +3623,56 @@ function getMiddlePoints(board, element) {
     return result;
 }
 
+const buildClipboardData = (board, elements, startPoint) => {
+    return buildClipboardData$1(board, elements, startPoint, (element) => {
+        if (PlaitDrawElement.isArrowLine(element)) {
+            let source = { ...element.source };
+            let target = { ...element.target };
+            let points = [...element.points];
+            if (element.source.boundId) {
+                points[0] = getConnectionPoint(getElementById(board, element.source.boundId), element.source.connection);
+                if (!getElementById(board, element.source.boundId, elements)) {
+                    delete source.boundId;
+                    delete source.connection;
+                }
+            }
+            if (element.target.boundId) {
+                points[points.length - 1] = getConnectionPoint(getElementById(board, element.target.boundId), element.target.connection);
+                if (!getElementById(board, element.target.boundId, elements)) {
+                    delete target.boundId;
+                    delete target.connection;
+                }
+            }
+            points = points.map(point => [point[0] - startPoint[0], point[1] - startPoint[1]]);
+            return { ...element, points, source, target };
+        }
+        return undefined;
+    });
+};
+const insertClipboardData = (board, elements, startPoint) => {
+    insertClipboardData$1(board, elements, startPoint, (element, idsMap) => {
+        if (PlaitDrawElement.isArrowLine(element)) {
+            if (element.source.boundId) {
+                const boundElement = elements.find(item => [element.source.boundId, idsMap[element.source.boundId]].includes(item.id));
+                if (boundElement) {
+                    element.source.boundId = idsMap[element.source.boundId];
+                }
+            }
+            if (element.target.boundId) {
+                const boundElement = elements.find(item => [element.target.boundId, idsMap[element.target.boundId]].includes(item.id));
+                if (boundElement) {
+                    element.target.boundId = idsMap[element.target.boundId];
+                }
+            }
+        }
+        if (PlaitDrawElement.isElementByTable(element)) {
+            updateRowOrColumnIds(element, 'row');
+            updateRowOrColumnIds(element, 'column');
+            updateCellIds(element.cells);
+        }
+    });
+};
+
 const getCenterPointsOnPolygon = (points) => {
     const centerPoints = [];
     for (let i = 0; i < points.length; i++) {
@@ -5419,8 +5484,8 @@ const TableEngine = {
     },
     getTextRectangle(element, options) {
         try {
-            if (options && options.key) {
-                const cell = getCellWithPoints(options?.board, element, options.key);
+            if (options && options.id) {
+                const cell = getCellWithPoints(options?.board, element, options.id);
                 if (cell) {
                     if (PlaitTableElement.isVerticalText(cell)) {
                         return getVerticalTextRectangle(cell);
@@ -5651,8 +5716,8 @@ const PackageEngine = {
     getTextRectangle(element, options) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const textHeight = element.texts?.find(item => item.key === options?.key)?.textHeight;
-        if (options?.key === MultipleTextGeometryCommonTextKeys.name) {
+        const textHeight = element.texts?.find(item => item.id === options?.id)?.textHeight;
+        if (options?.id === GeometryCommonTextKeys.name) {
             const width = elementRectangle.width * 0.7 - ShapeDefaultSpace.rectangleAndText - strokeWidth;
             return {
                 height: textHeight,
@@ -5661,7 +5726,7 @@ const PackageEngine = {
                 y: elementRectangle.y + (25 - textHeight) / 2
             };
         }
-        if (options?.key === MultipleTextGeometryCommonTextKeys.content) {
+        if (options?.id === GeometryCommonTextKeys.content) {
             const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
             return {
                 height: textHeight,
@@ -5711,8 +5776,8 @@ const CombinedFragmentEngine = {
     getTextRectangle(element, options) {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
         const strokeWidth = getStrokeWidthByElement(element);
-        const textHeight = element.texts?.find(item => item.key === options?.key)?.textHeight;
-        if (options?.key === MultipleTextGeometryCommonTextKeys.name) {
+        const textHeight = element.texts?.find(item => item.id === options?.id)?.textHeight;
+        if (options?.id === GeometryCommonTextKeys.name) {
             const width = elementRectangle.width / 3 - 8 - ShapeDefaultSpace.rectangleAndText - strokeWidth;
             return {
                 height: textHeight,
@@ -5721,7 +5786,7 @@ const CombinedFragmentEngine = {
                 y: elementRectangle.y + (25 - textHeight) / 2
             };
         }
-        if (options?.key === MultipleTextGeometryCommonTextKeys.content) {
+        if (options?.id === GeometryCommonTextKeys.content) {
             const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
             return {
                 height: textHeight,
@@ -6451,12 +6516,6 @@ const PlaitArrowLine = {
     }
 };
 
-var StrokeStyle;
-(function (StrokeStyle) {
-    StrokeStyle["solid"] = "solid";
-    StrokeStyle["dashed"] = "dashed";
-    StrokeStyle["dotted"] = "dotted";
-})(StrokeStyle || (StrokeStyle = {}));
 var MemorizeKey;
 (function (MemorizeKey) {
     MemorizeKey["basicShape"] = "basicShape";
@@ -6466,10 +6525,10 @@ var MemorizeKey;
     MemorizeKey["UML"] = "UML";
 })(MemorizeKey || (MemorizeKey = {}));
 
-var VectorPenPointerType;
-(function (VectorPenPointerType) {
-    VectorPenPointerType["vectorPen"] = "vectorPen";
-})(VectorPenPointerType || (VectorPenPointerType = {}));
+var VectorLinePointerType;
+(function (VectorLinePointerType) {
+    VectorLinePointerType["vectorLine"] = "vectorLine";
+})(VectorLinePointerType || (VectorLinePointerType = {}));
 var VectorLineShape;
 (function (VectorLineShape) {
     VectorLineShape["straight"] = "straight";
@@ -6510,6 +6569,16 @@ const PlaitDrawElement = {
             return false;
         }
     },
+    isCustomGeometryElement: (board, value) => {
+        const options = board.getPluginOptions(WithDrawPluginKey);
+        const customGeometryTypes = options?.customGeometryTypes || [];
+        if (customGeometryTypes.includes(value.type)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
     isShapeElement: (value) => {
         return (PlaitDrawElement.isImage(value) ||
             PlaitDrawElement.isGeometry(value) ||
@@ -6555,10 +6624,11 @@ class GeometryShapeGenerator extends Generator {
         if (shape === BasicShapes.text) {
             return;
         }
+        const fill = getFillByElement(this.board, element);
         const strokeWidth = getStrokeWidthByElement(element);
         const strokeColor = getStrokeColorByElement(this.board, element);
-        const fill = getFillByElement(this.board, element);
-        const strokeLineDash = getLineDashByElement(element);
+        const strokeStyle = getStrokeStyleByElement(this.board, element);
+        const strokeLineDash = getStrokeLineDash(strokeStyle, strokeWidth);
         return drawGeometry(this.board, RectangleClient.inflate(rectangle, -strokeWidth), shape, {
             stroke: strokeColor,
             strokeWidth,
@@ -6615,11 +6685,11 @@ class SingleTextGenerator extends TextGenerator {
         return this.textManages[0];
     }
     constructor(board, element, text, options) {
-        super(board, element, [{ key: element.id, text: text, textHeight: element.textHeight }], options);
+        super(board, element, [{ id: element.id, text: text, textHeight: element.textHeight }], options);
     }
     update(element, previousText, currentText, elementG) {
         if (!isMultipleTextGeometry(element)) {
-            super.update(element, [{ text: previousText, key: element.id, textHeight: element.textHeight }], [{ text: currentText, key: element.id, textHeight: element.textHeight }], elementG);
+            super.update(element, [{ text: previousText, id: element.id, textHeight: element.textHeight }], [{ text: currentText, id: element.id, textHeight: element.textHeight }], elementG);
         }
     }
 }
@@ -6676,8 +6746,7 @@ class GeometryComponent extends CommonElementFlavour {
         this.textGenerator && this.textGenerator.draw(this.getElementG());
     }
     onContextChanged(value, previous) {
-        const isChangeTheme = this.board.operations.find(op => op.type === 'set_theme');
-        if (value.element !== previous.element || isChangeTheme) {
+        if (value.element !== previous.element || value.hasThemeChanged) {
             this.shapeGenerator.processDrawing(this.element, this.getElementG());
             this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });
             this.lineAutoCompleteGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
@@ -6708,8 +6777,8 @@ class GeometryComponent extends CommonElementFlavour {
         const onTextChange = (element, textManageChangeData, text) => {
             if (textManageChangeData.newText) {
                 if (isMultipleTextGeometry(element)) {
-                    DrawTransforms.setDrawShapeText(this.board, element, {
-                        key: text.key,
+                    DrawTransforms.setDrawTexts(this.board, element, {
+                        id: text.id,
                         text: textManageChangeData.newText,
                         textHeight: textManageChangeData.height
                     });
@@ -6880,7 +6949,7 @@ class ArrowLineComponent extends CommonElementFlavour {
     initializeGenerator() {
         this.shapeGenerator = new ArrowLineShapeGenerator(this.board);
         this.activeGenerator = new LineActiveGenerator(this.board);
-        this.initializeTextManagesByElement();
+        this.initializeTextManages();
     }
     initialize() {
         this.initializeGenerator();
@@ -6912,13 +6981,11 @@ class ArrowLineComponent extends CommonElementFlavour {
         return boundedElements;
     }
     onContextChanged(value, previous) {
-        this.initializeWeakMap();
         const boundedElements = this.getBoundedElements();
         const isBoundedElementsChanged = boundedElements.source !== this.boundedElements.source || boundedElements.target !== this.boundedElements.target;
         this.boundedElements = boundedElements;
-        const isChangeTheme = this.board.operations.find(op => op.type === 'set_theme');
         const linePoints = getArrowLinePoints(this.board, this.element);
-        if (value.element !== previous.element || isChangeTheme) {
+        if (value.element !== previous.element || value.hasThemeChanged) {
             this.shapeGenerator.processDrawing(this.element, this.getElementG());
             this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
                 selected: this.selected,
@@ -6946,19 +7013,21 @@ class ArrowLineComponent extends CommonElementFlavour {
             return;
         }
     }
-    initializeTextManagesByElement() {
+    initializeTextManages() {
         if (this.element.texts?.length) {
             const textManages = [];
             this.element.texts.forEach((text, index) => {
                 const manage = this.createTextManage(text, index);
                 textManages.push(manage);
             });
-            this.initializeTextManages(textManages);
+            this.getRef().initializeTextManage(textManages);
         }
     }
     drawText() {
         if (this.element.texts?.length) {
-            this.getTextManages().forEach((manage, index) => {
+            this.getRef()
+                .getTextManages()
+                .forEach((manage, index) => {
                 manage.draw(this.element.texts[index].text);
                 this.getElementG().append(manage.g);
             });
@@ -6992,7 +7061,7 @@ class ArrowLineComponent extends CommonElementFlavour {
             return;
         const previousTextsLength = previousTexts.length;
         const currentTextsLength = currentTexts.length;
-        const textManages = this.getTextManages();
+        const textManages = this.getRef().getTextManages();
         if (currentTextsLength === previousTextsLength) {
             for (let i = 0; i < previousTextsLength; i++) {
                 if (previousTexts[i].text !== currentTexts[i].text) {
@@ -7001,13 +7070,13 @@ class ArrowLineComponent extends CommonElementFlavour {
             }
         }
         else {
-            this.destroyTextManages();
-            this.initializeTextManagesByElement();
+            this.getRef().destroyTextManage();
+            this.initializeTextManages();
             this.drawText();
         }
     }
     updateTextRectangle() {
-        const textManages = this.getTextManages();
+        const textManages = this.getRef().getTextManages();
         textManages.forEach(manage => {
             manage.updateRectangle();
         });
@@ -7015,7 +7084,7 @@ class ArrowLineComponent extends CommonElementFlavour {
     destroy() {
         super.destroy();
         this.activeGenerator.destroy();
-        this.destroyTextManages();
+        this.getRef().destroyTextManage();
     }
 }
 
@@ -7038,10 +7107,8 @@ class VectorLineComponent extends CommonElementFlavour {
         super.initialize();
     }
     onContextChanged(value, previous) {
-        this.initializeWeakMap();
-        const isChangeTheme = this.board.operations.find(op => op.type === 'set_theme');
         const linePoints = getVectorLinePoints(this.board, this.element);
-        if (value.element !== previous.element || isChangeTheme) {
+        if (value.element !== previous.element || value.hasThemeChanged) {
             this.shapeGenerator.processDrawing(this.element, this.getElementG());
             this.activeGenerator.processDrawing(this.element, PlaitBoard.getElementActiveHost(this.board), {
                 selected: this.selected,
@@ -7090,7 +7157,7 @@ const withDrawHotkey = (board) => {
             if (hitElement && PlaitDrawElement.isGeometry(hitElement)) {
                 if (isMultipleTextGeometry(hitElement)) {
                     const hitText = getHitMultipleGeometryText(hitElement, point) ||
-                        hitElement.texts.find(item => item.key.includes(MultipleTextGeometryCommonTextKeys.content)) ||
+                        hitElement.texts.find(item => item.id.includes(GeometryCommonTextKeys.content)) ||
                         hitElement.texts[0];
                     editText(board, hitElement, hitText);
                 }
@@ -7110,13 +7177,14 @@ class TableGenerator extends Generator {
     }
     draw(element, data) {
         const rectangle = RectangleClient.getRectangleByPoints(element.points);
-        const strokeLineDash = getLineDashByElement(element);
         const strokeWidth = getStrokeWidthByElement(element);
         const strokeColor = getStrokeColorByElement(this.board, element);
+        const strokeStyle = getStrokeStyleByElement(this.board, element);
+        const strokeLineDash = getStrokeLineDash(strokeStyle, strokeWidth);
         return getEngine(TableSymbols.table).draw(this.board, rectangle, {
             strokeWidth,
             stroke: strokeColor,
-            strokeLineDash,
+            strokeLineDash
         }, {
             element: element
         });
@@ -7296,68 +7364,6 @@ const withGeometryCreateByDrawing = (board) => {
     return board;
 };
 
-const buildClipboardData = (board, elements, startPoint) => {
-    return elements.map(element => {
-        if (PlaitDrawElement.isShapeElement(element)) {
-            const points = element.points.map(point => [point[0] - startPoint[0], point[1] - startPoint[1]]);
-            return { ...element, points };
-        }
-        if (PlaitDrawElement.isArrowLine(element)) {
-            let source = { ...element.source };
-            let target = { ...element.target };
-            let points = [...element.points];
-            if (element.source.boundId) {
-                points[0] = getConnectionPoint(getElementById(board, element.source.boundId), element.source.connection);
-                if (!getElementById(board, element.source.boundId, elements)) {
-                    delete source.boundId;
-                    delete source.connection;
-                }
-            }
-            if (element.target.boundId) {
-                points[points.length - 1] = getConnectionPoint(getElementById(board, element.target.boundId), element.target.connection);
-                if (!getElementById(board, element.target.boundId, elements)) {
-                    delete target.boundId;
-                    delete target.connection;
-                }
-            }
-            points = points.map(point => [point[0] - startPoint[0], point[1] - startPoint[1]]);
-            return { ...element, points, source, target };
-        }
-        return element;
-    });
-};
-const insertClipboardData = (board, elements, startPoint) => {
-    const idsMap = {};
-    elements.forEach(element => {
-        idsMap[element.id] = idCreator();
-    });
-    elements.forEach(element => {
-        element.id = idsMap[element.id];
-        if (PlaitDrawElement.isArrowLine(element)) {
-            if (element.source.boundId) {
-                const boundElement = elements.find(item => [element.source.boundId, idsMap[element.source.boundId]].includes(item.id));
-                if (boundElement) {
-                    element.source.boundId = idsMap[element.source.boundId];
-                }
-            }
-            if (element.target.boundId) {
-                const boundElement = elements.find(item => [element.target.boundId, idsMap[element.target.boundId]].includes(item.id));
-                if (boundElement) {
-                    element.target.boundId = idsMap[element.target.boundId];
-                }
-            }
-        }
-        if (PlaitDrawElement.isElementByTable(element)) {
-            updateRowOrColumnIds(element, 'row');
-            updateRowOrColumnIds(element, 'column');
-            updateCellIds(element.cells);
-        }
-        element.points = element.points.map(point => [startPoint[0] + point[0], startPoint[1] + point[1]]);
-        Transforms.insertNode(board, element, [board.children.length]);
-    });
-    Transforms.addSelectionWithTemporaryElements(board, elements);
-};
-
 const withDrawFragment = (baseBoard) => {
     const board = baseBoard;
     const { getDeletedFragment, buildFragment, insertFragment } = board;
@@ -7400,16 +7406,12 @@ const withDrawFragment = (baseBoard) => {
             const selectedElements = [...targetDrawElements, ...boundLineElements];
             const elements = buildClipboardData(board, selectedElements, rectangle ? [rectangle.x, rectangle.y] : [0, 0]);
             const text = getElementsText(selectedElements);
-            if (!clipboardContext) {
-                clipboardContext = createClipboardContext(WritableClipboardType.elements, elements, text);
-            }
-            else {
-                clipboardContext = addClipboardContext(clipboardContext, {
-                    text,
-                    type: WritableClipboardType.elements,
-                    elements
-                });
-            }
+            const addition = {
+                text,
+                type: WritableClipboardType.elements,
+                elements: elements
+            };
+            clipboardContext = addOrCreateClipboardContext(clipboardContext, addition);
         }
         return buildFragment(clipboardContext, rectangle, operationType, originData);
     };
@@ -7498,67 +7500,6 @@ const withArrowLineCreateByDraw = (board) => {
     return board;
 };
 
-const withGeometryResize = (board) => {
-    let snapG;
-    const options = {
-        key: 'draw-geometry',
-        canResize: () => {
-            return true;
-        },
-        hitTest: (point) => {
-            const selectedElements = [...getSelectedGeometryElements(board), ...getSelectedImageElements(board)];
-            if (selectedElements.length !== 1 || getSelectedElements(board).length !== 1) {
-                return null;
-            }
-            const target = selectedElements[0];
-            if (canResize(board, target)) {
-                const rectangle = board.getRectangle(target);
-                const handleRef = getHitRectangleResizeHandleRef(board, rectangle, point, target.angle);
-                if (handleRef) {
-                    return {
-                        element: target,
-                        handle: handleRef.handle,
-                        cursorClass: handleRef.cursorClass,
-                        rectangle
-                    };
-                }
-            }
-            return null;
-        },
-        onResize: (resizeRef, resizeState) => {
-            resizeState.startPoint = rotateAntiPointsByElement(resizeState.startPoint, resizeRef.element) || resizeState.startPoint;
-            resizeState.endPoint = rotateAntiPointsByElement(resizeState.endPoint, resizeRef.element) || resizeState.endPoint;
-            snapG?.remove();
-            const isFromCorner = isCornerHandle(board, resizeRef.handle);
-            const isAspectRatio = resizeState.isShift || PlaitDrawElement.isImage(resizeRef.element);
-            const handleIndex = getIndexByResizeHandle(resizeRef.handle);
-            const { originPoint, handlePoint } = getResizeOriginPointAndHandlePoint(board, handleIndex, resizeRef.rectangle);
-            const resizeSnapRefOptions = getSnapResizingRefOptions(board, resizeRef, resizeState, {
-                originPoint,
-                handlePoint
-            }, isAspectRatio, isFromCorner);
-            const resizeSnapRef = getSnapResizingRef(board, [resizeRef.element], resizeSnapRefOptions);
-            snapG = resizeSnapRef.snapG;
-            PlaitBoard.getElementActiveHost(board).append(snapG);
-            let points = resizeSnapRef.activePoints;
-            if (PlaitDrawElement.isGeometry(resizeRef.element) && isGeometryIncludeText(resizeRef.element)) {
-                const { height: textHeight } = getFirstTextManage(resizeRef.element).getSize();
-                DrawTransforms.resizeGeometry(board, points, textHeight, resizeRef.path);
-            }
-            else {
-                points = normalizeShapePoints(points);
-                Transforms.setNode(board, { points }, resizeRef.path);
-            }
-        },
-        afterResize: (resizeRef) => {
-            snapG?.remove();
-            snapG = null;
-        }
-    };
-    withResize(board, options);
-    return board;
-};
-
 const withArrowLineResize = (board) => {
     let elbowLineIndex;
     let elbowLineDeleteCount;
@@ -7772,7 +7713,7 @@ const withArrowLineText = (board) => {
                 }
                 else {
                     const ratio = getRatioByPoint(points, point);
-                    const textMemory = getMemorizedLatest('line')?.text || {};
+                    const textMemory = getMemorizedLatest('arrow-line')?.text || {};
                     texts.push({
                         text: buildText(LINE_TEXT, undefined, textMemory),
                         position: ratio,
@@ -8022,7 +7963,8 @@ const withDrawRotate = (board) => {
     let needCustomActiveRectangle = false;
     const canRotate = () => {
         const elements = getSelectedElements(board);
-        return elements.length > 0 && elements.every(el => PlaitDrawElement.isGeometry(el) || PlaitDrawElement.isImage(el));
+        return (elements.length > 0 &&
+            elements.every(el => PlaitDrawElement.isDrawElement(el) || PlaitDrawElement.isCustomGeometryElement(board, el)));
     };
     board.pointerDown = (event) => {
         if (!canRotate() || PlaitBoard.isReadonly(board) || PlaitBoard.hasBeenTextEditing(board) || !isMainPointer(event)) {
@@ -8185,7 +8127,7 @@ class TableComponent extends CommonElementFlavour {
         const table = this.board.buildTable(this.element);
         table.cells.forEach(item => {
             if (PlaitTableElement.isVerticalText(item)) {
-                const textManage = getTextManage(this.board, item.id);
+                const textManage = getTextManageByCell(this.board, item);
                 if (textManage) {
                     const engine = getEngine(TableSymbols.table);
                     const rectangle = engine.getTextRectangle(this.element, { key: item.id, board: this.board });
@@ -8200,7 +8142,7 @@ class TableComponent extends CommonElementFlavour {
             .filter(item => isCellIncludeText(item))
             .map(item => {
             return {
-                key: item.id,
+                id: item.id,
                 text: item.text,
                 textHeight: item.textHeight,
                 board: this.board
@@ -8213,12 +8155,12 @@ class TableComponent extends CommonElementFlavour {
             onChange: (value, data, text) => {
                 const path = PlaitBoard.findPath(this.board, value);
                 if (data.newText) {
-                    DrawTransforms.setTableText(this.board, path, text.key, data.newText, data.height);
+                    DrawTransforms.setTableText(this.board, path, text.id, data.newText, data.height);
                 }
                 data.operations && memorizeLatestText(value, data.operations);
             },
             getRenderRectangle: (value, text) => {
-                const cell = getCellWithPoints(this.board, value, text.key);
+                const cell = getCellWithPoints(this.board, value, text.id);
                 if (PlaitTableElement.isVerticalText(cell)) {
                     const cellRectangle = RectangleClient.getRectangleByPoints(cell.points);
                     const strokeWidth = getStrokeWidthByElement(cell);
@@ -8239,8 +8181,7 @@ class TableComponent extends CommonElementFlavour {
         this.textGenerator.initialize();
     }
     onContextChanged(value, previous) {
-        const isChangeTheme = this.board.operations.find(op => op.type === 'set_theme');
-        if (value.element !== previous.element || isChangeTheme) {
+        if (value.element !== previous.element || value.hasThemeChanged) {
             const previousSelectedCells = getSelectedCells(previous.element);
             if (previousSelectedCells?.length) {
                 clearSelectedCells(previous.element);
@@ -8637,57 +8578,57 @@ const withSwimlane = (board) => {
     return withSwimlaneCreateByDrawing(withSwimlaneCreateByDrag(board));
 };
 
-const withVectorPenCreateByDraw = (board) => {
+const withVectorLineCreateByDraw = (board) => {
     const { pointerDown, pointerMove, dblClick, globalKeyDown } = board;
     let lineShapeG = null;
     let temporaryElement = null;
-    let vectorPenRef;
+    let vectorLineRef;
     const vectorLineComplete = () => {
-        if (vectorPenRef) {
+        if (vectorLineRef) {
             clearSelectedElement(board);
-            if (vectorPenRef?.element) {
-                addSelectedElement(board, vectorPenRef?.element);
+            if (vectorLineRef?.element) {
+                addSelectedElement(board, vectorLineRef?.element);
             }
         }
         PlaitBoard.getBoardContainer(board).classList.remove(`vector-line-closed`);
         lineShapeG?.remove();
         lineShapeG = null;
-        vectorPenRef = null;
+        vectorLineRef = null;
         temporaryElement = null;
     };
     board.pointerDown = (event) => {
-        const penPointers = getVectorPenPointers();
-        const isVectorPenPointer = PlaitBoard.isInPointer(board, penPointers);
-        if (isVectorPenPointer && !vectorPenRef) {
-            vectorPenRef = { shape: VectorLineShape.straight };
+        const penPointers = getVectorLinePointers();
+        const isVectorLinePointer = PlaitBoard.isInPointer(board, penPointers);
+        if (isVectorLinePointer && !vectorLineRef) {
+            vectorLineRef = { shape: VectorLineShape.straight };
         }
-        if (!PlaitBoard.isReadonly(board) && vectorPenRef && isDrawingMode(board)) {
+        if (!PlaitBoard.isReadonly(board) && vectorLineRef && isDrawingMode(board)) {
             let point = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
             if (!temporaryElement) {
-                vectorPenRef = {
-                    ...vectorPenRef,
+                vectorLineRef = {
+                    ...vectorLineRef,
                     start: point
                 };
             }
             else {
-                if (!vectorPenRef.element) {
-                    vectorPenRef.element = temporaryElement;
-                    Transforms.insertNode(board, vectorPenRef.element, [board.children.length]);
+                if (!vectorLineRef.element) {
+                    vectorLineRef.element = temporaryElement;
+                    Transforms.insertNode(board, vectorLineRef.element, [board.children.length]);
                 }
                 else {
-                    let points = vectorPenRef.element.points;
-                    const isClosed = distanceBetweenPointAndPoint(...point, ...vectorPenRef.start) <= LINE_HIT_GEOMETRY_BUFFER;
+                    let points = vectorLineRef.element.points;
+                    const isClosed = distanceBetweenPointAndPoint(...point, ...vectorLineRef.start) <= LINE_HIT_GEOMETRY_BUFFER;
                     if (isClosed) {
-                        point = vectorPenRef.start;
+                        point = vectorLineRef.start;
                     }
-                    if (vectorPenRef.path) {
+                    if (vectorLineRef.path) {
                         const lastPoint = points[points.length - 1];
                         const distance = distanceBetweenPointAndPoint(...point, ...lastPoint);
                         if (distance > 2) {
-                            Transforms.setNode(board, { points: [...points, point] }, vectorPenRef.path);
+                            Transforms.setNode(board, { points: [...points, point] }, vectorLineRef.path);
                         }
                     }
-                    vectorPenRef.element = getElementById(board, vectorPenRef.element.id);
+                    vectorLineRef.element = getElementById(board, vectorLineRef.element.id);
                     if (isClosed) {
                         vectorLineComplete();
                     }
@@ -8701,33 +8642,33 @@ const withVectorPenCreateByDraw = (board) => {
         lineShapeG = createG();
         let movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
         const pointer = PlaitBoard.getPointer(board);
-        if (pointer !== VectorPenPointerType.vectorPen) {
+        if (pointer !== VectorLinePointerType.vectorLine) {
             vectorLineComplete();
         }
-        if (vectorPenRef && vectorPenRef.start) {
-            let drawPoints = [vectorPenRef.start];
-            if (vectorPenRef.element) {
-                drawPoints = [vectorPenRef.start, ...vectorPenRef.element.points];
-                const path = PlaitBoard.findPath(board, vectorPenRef.element);
-                vectorPenRef.path = path;
+        if (vectorLineRef && vectorLineRef.start) {
+            let drawPoints = [vectorLineRef.start];
+            if (vectorLineRef.element) {
+                drawPoints = [vectorLineRef.start, ...vectorLineRef.element.points];
+                const path = PlaitBoard.findPath(board, vectorLineRef.element);
+                vectorLineRef.path = path;
             }
-            const distance = distanceBetweenPointAndPoint(...movingPoint, ...vectorPenRef.start);
+            const distance = distanceBetweenPointAndPoint(...movingPoint, ...vectorLineRef.start);
             if (distance <= LINE_HIT_GEOMETRY_BUFFER) {
-                movingPoint = vectorPenRef.start;
+                movingPoint = vectorLineRef.start;
                 PlaitBoard.getBoardContainer(board).classList.add(`vector-line-closed`);
             }
             else {
                 PlaitBoard.getBoardContainer(board).classList.remove(`vector-line-closed`);
             }
-            temporaryElement = vectorLineCreating(board, vectorPenRef.shape, drawPoints, movingPoint, lineShapeG);
+            temporaryElement = vectorLineCreating(board, vectorLineRef.shape, drawPoints, movingPoint, lineShapeG);
         }
         pointerMove(event);
     };
     board.dblClick = (event) => {
         if (!PlaitBoard.isReadonly(board)) {
-            if (vectorPenRef) {
-                if (vectorPenRef.path) {
-                    Transforms.setNode(board, { points: vectorPenRef?.element?.points }, vectorPenRef.path);
+            if (vectorLineRef) {
+                if (vectorLineRef.path) {
+                    Transforms.setNode(board, { points: vectorLineRef?.element?.points }, vectorLineRef.path);
                 }
                 vectorLineComplete();
                 BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
@@ -8739,9 +8680,9 @@ const withVectorPenCreateByDraw = (board) => {
         if (!PlaitBoard.isReadonly(board)) {
             const isEsc = isKeyHotkey('esc', event);
             const isV = isKeyHotkey('v', event);
-            if ((isEsc || isV) && vectorPenRef) {
-                if (vectorPenRef.path) {
-                    Transforms.setNode(board, { points: vectorPenRef.element?.points }, vectorPenRef.path);
+            if ((isEsc || isV) && vectorLineRef) {
+                if (vectorLineRef.path) {
+                    Transforms.setNode(board, { points: vectorLineRef.element?.points }, vectorLineRef.path);
                 }
                 vectorLineComplete();
                 if (isV) {
@@ -8783,7 +8724,7 @@ const withVectorLineResize = (board) => {
             let handleIndex = resizeRef.handleIndex;
             if (resizeRef.handle === LineResizeHandle.source || resizeRef.handle === LineResizeHandle.target) {
                 points[handleIndex] = resizeState.endPoint;
-                if (isClosedVectorLine(resizeRef.element)) {
+                if (isClosedPoints(resizeRef.element.points)) {
                     points[points.length - 1] = resizeState.endPoint;
                 }
                 else {
@@ -8810,7 +8751,7 @@ const withVectorLineResize = (board) => {
 };
 
 const withDraw = (board) => {
-    const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment, getHitElement } = board;
+    const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment, getOneHitElement } = board;
     board.drawElement = (context) => {
         if (PlaitDrawElement.isGeometry(context.element)) {
             if (PlaitDrawElement.isUML(context.element)) {
@@ -8866,12 +8807,12 @@ const withDraw = (board) => {
         }
         return isHit(element, point);
     };
-    board.getHitElement = elements => {
-        const isDrawElements = elements.every(item => PlaitDrawElement.isDrawElement(item));
-        if (isDrawElements) {
-            return getDrawHitElement(board, elements);
+    board.getOneHitElement = elements => {
+        const isAllDrawElements = elements.every(item => PlaitDrawElement.isDrawElement(item));
+        if (isAllDrawElements) {
+            return getHitDrawElement(board, elements);
         }
-        return getHitElement(elements);
+        return getOneHitElement(elements);
     };
     board.isInsidePoint = (element, point) => {
         const result = isHitElementInside(board, element, point);
@@ -8925,12 +8866,12 @@ const withDraw = (board) => {
         });
         return getRelatedFragment([...elements, ...activeLines], originData);
     };
-    return withSwimlane(withTable(withDrawResize(withVectorPenCreateByDraw(withArrowLineAutoCompleteReaction(withArrowLineBoundReaction(withVectorLineResize(withArrowLineResize(withArrowLineTextMove(withArrowLineText(withGeometryResize(withDrawRotate(withArrowLineCreateByDraw(withArrowLineAutoComplete(withGeometryCreateByDrag(withGeometryCreateByDrawing(withDrawFragment(withDrawHotkey(board))))))))))))))))));
+    return withSwimlane(withTable(withDrawResize(withVectorLineCreateByDraw(withArrowLineAutoCompleteReaction(withArrowLineBoundReaction(withVectorLineResize(withArrowLineResize(withArrowLineTextMove(withArrowLineText(withDrawRotate(withArrowLineCreateByDraw(withArrowLineAutoComplete(withGeometryCreateByDrag(withGeometryCreateByDrawing(withDrawFragment(withDrawHotkey(board)))))))))))))))));
 };
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryCommonTextKeys, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, StrokeStyle, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLineShape, VectorPenPointerType, WithArrowLineAutoCompletePluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, createVectorLineElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, drawVectorLine, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getDrawHitElement, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectorPoint, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineDashByElement, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePoints, getVectorPenPointers, handleArrowLineCreating, hasIllegalElbowPoint, insertElement, isCellIncludeText, isClosedVectorLine, isDrawElementClosed, isDrawElementIncludeText, isDrawElementsIncludeText, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isSelfLoop, isSingleSelectElementByTable, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
+export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryCommonTextKeys, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, 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, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, createVectorLineElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, drawVectorLine, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFill, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, 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, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePointers, getVectorLinePoints, handleArrowLineCreating, hasIllegalElbowPoint, insertClipboardData, insertElement, isCellIncludeText, isClosedPoints, isCustomGeometryClosed, isDrawElementClosed, isDrawElementIncludeText, isDrawElementsIncludeText, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isRectangleHitRotatedElement, isRectangleHitRotatedPoints, isSelfLoop, isSingleSelectArrowLine, isSingleSelectElementByTable, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
 //# sourceMappingURL=plait-draw.mjs.map