@plait/mind 0.93.2 → 0.93.3

package/fesm2022/plait-mind.mjs

@@ -1,6 +1,6 @@
-import { DEFAULT_COLOR, DefaultThemeColor, ColorfulThemeColor, SoftThemeColor, RetroThemeColor, DarkThemeColor, StarryThemeColor, rgbaToHEX, PlaitElement, PlaitNode, Path, isNullOrUndefined, PlaitBoard, getSelectedElements, getI18nValue, idCreator, Transforms, clearSelectedElement, addSelectedElement, distanceBetweenPointAndRectangle, RectangleClient, setDragging, depthFirstRecursion, getIsRecursionFunc, drawRoundRectangle, drawLinearPath, drawBezierPath, setStrokeLinecap, createG, createForeignObject, updateForeignObject, getRectangleByElements, toActiveRectangleFromViewBoxRectangle, ACTIVE_STROKE_WIDTH, SELECTION_RECTANGLE_CLASS_NAME, NODE_TO_PARENT, removeSelectedElement, PlaitHistoryBoard, createText, isSelectionMoving, isDragging, isMovingElements, NODE_TO_INDEX, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, getHitElementByPoint, distanceBetweenPointAndPoint, CoreTransforms, toActivePointFromViewBoxPoint, BoardTransforms, throttleRAF, createDebugGenerator, getElementById, isTouchDevice, isSelectedElement, isContextmenu, temporaryDisableSelection, hotkeys, createClipboardContext, WritableClipboardType, Point, ResizeCursorClass, WritableClipboardOperationType, addOrCreateClipboardContext } from '@plait/core';
+import { DEFAULT_COLOR, DefaultThemeColor, ColorfulThemeColor, SoftThemeColor, RetroThemeColor, DarkThemeColor, StarryThemeColor, rgbaToHEX, PlaitElement, PlaitNode, Path, isNullOrUndefined, PlaitBoard, getSelectedElements, getI18nValue, idCreator, Transforms, clearSelectedElement, addSelectedElement, distanceBetweenPointAndRectangle, RectangleClient, Direction, isHorizontalDirection, depthFirstRecursion, getIsRecursionFunc, setDragging, drawRoundRectangle, drawLinearPath, drawBezierPath, setStrokeLinecap, createG, createForeignObject, updateForeignObject, getRectangleByElements, toActiveRectangleFromViewBoxRectangle, ACTIVE_STROKE_WIDTH, SELECTION_RECTANGLE_CLASS_NAME, NODE_TO_PARENT, removeSelectedElement, PlaitHistoryBoard, createText, isSelectionMoving, isDragging, isMovingElements, NODE_TO_INDEX, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, getHitElementByPoint, distanceBetweenPointAndPoint, CoreTransforms, toActivePointFromViewBoxPoint, BoardTransforms, throttleRAF, createDebugGenerator, getElementById, isTouchDevice, isSelectedElement, isContextmenu, temporaryDisableSelection, hotkeys, createClipboardContext, WritableClipboardType, Point, ResizeCursorClass, WritableClipboardOperationType, addOrCreateClipboardContext } from '@plait/core';
 import { MindLayoutType, AbstractNode, isIndentedLayout, isHorizontalLogicLayout, ConnectingPosition, isHorizontalLayout, getNonAbstractChildren, isStandardLayout, isLeftLayout, isRightLayout, isVerticalLogicLayout, isTopLayout, isBottomLayout, getCorrectStartEnd, getAbstractLayout, GlobalLayout } from '@plait/layouts';
-import { StrokeStyle, getFirstTextManage, buildText, getElementSize, DEFAULT_FONT_FAMILY, RESIZE_HANDLE_DIAMETER, getRectangleResizeHandleRefs, addElementOfFocusedImage, ImageGenerator, removeElementOfFocusedImage, getStrokeLineDash, getXDistanceBetweenPoint, moveXOfPoint, moveYOfPoint, Generator, PropertyTransforms, TRANSPARENT, measureElement, isResizing, CommonElementFlavour, WithTextPluginKey, TextManage, isDrawingMode, isDndMode, setCreationMode, BoardCreationMode, isExpandHotkey, isTabHotkey, isEnterHotkey, isVirtualKey, isDelete, isSpaceHotkey, getElementOfFocusedImage, acceptImageTypes, buildImage, withResize, getElementsText } from '@plait/common';
+import { StrokeStyle, getFirstTextManage, buildText, getElementSize, DEFAULT_FONT_FAMILY, RESIZE_HANDLE_DIAMETER, getRectangleResizeHandleRefs, getXDistanceBetweenPoint, addElementOfFocusedImage, ImageGenerator, removeElementOfFocusedImage, getStrokeLineDash, moveXOfPoint, moveYOfPoint, Generator, PropertyTransforms, TRANSPARENT, measureElement, isResizing, CommonElementFlavour, WithTextPluginKey, TextManage, isDrawingMode, isDndMode, setCreationMode, BoardCreationMode, isExpandHotkey, isTabHotkey, isEnterHotkey, isVirtualKey, isDelete, isSpaceHotkey, getElementOfFocusedImage, acceptImageTypes, buildImage, withResize, getElementsText } from '@plait/common';
 import { DEFAULT_FONT_SIZE, PlaitMarkEditor, MarkTypes, FontSizes } from '@plait/text-plugins';
 import { Node as Node$1, Path as Path$1 } from 'slate';
 import { pointsOnBezierCurves } from 'points-on-curve';
@@ -1050,6 +1050,263 @@ const getHitImageResizeHandleDirection = (board, element, point) => {
     return result;
 };
 
+var HorizontalPlacement;
+(function (HorizontalPlacement) {
+    HorizontalPlacement["left"] = "left";
+    HorizontalPlacement["center"] = "center";
+    HorizontalPlacement["right"] = "right";
+})(HorizontalPlacement || (HorizontalPlacement = {}));
+var VerticalPlacement;
+(function (VerticalPlacement) {
+    VerticalPlacement["top"] = "top";
+    VerticalPlacement["middle"] = "middle";
+    VerticalPlacement["bottom"] = "bottom";
+})(VerticalPlacement || (VerticalPlacement = {}));
+
+const getPointByPlacement = (client, placement) => {
+    let x = client.x;
+    let y = client.y;
+    if (placement[0] === HorizontalPlacement.center) {
+        x = client.x + client.width / 2;
+    }
+    if (placement[0] === HorizontalPlacement.right) {
+        x = client.x + client.width;
+    }
+    if (placement[1] === VerticalPlacement.middle) {
+        y = client.y + client.height / 2;
+    }
+    if (placement[1] === VerticalPlacement.bottom) {
+        y = client.y + client.height;
+    }
+    return [x, y];
+};
+const getYDistanceBetweenPoint = (point1, point2, isHorizontalLayout) => {
+    getXDistanceBetweenPoint(point1, point2, !isHorizontalLayout);
+};
+const getLayoutDirection = (node, isHorizontal) => {
+    if (isHorizontal) {
+        if (node.left) {
+            return LayoutDirection.left;
+        }
+        else {
+            return LayoutDirection.right;
+        }
+    }
+    else {
+        if (node.up) {
+            return LayoutDirection.top;
+        }
+        else {
+            return LayoutDirection.bottom;
+        }
+    }
+};
+const transformPlacement = (placement, direction) => {
+    // to left
+    if (direction === LayoutDirection.left) {
+        if (placement[0] === HorizontalPlacement.right) {
+            placement[0] = HorizontalPlacement.left;
+        }
+        else if (placement[0] === HorizontalPlacement.left) {
+            placement[0] = HorizontalPlacement.right;
+        }
+    }
+    // to bottom
+    if (direction === LayoutDirection.bottom || direction === LayoutDirection.top) {
+        let horizontal = HorizontalPlacement.center;
+        let vertical = VerticalPlacement.middle;
+        if (placement[1] === VerticalPlacement.top) {
+            horizontal = HorizontalPlacement.left;
+        }
+        if (placement[1] === VerticalPlacement.bottom) {
+            horizontal = HorizontalPlacement.right;
+        }
+        if (placement[0] === HorizontalPlacement.left) {
+            vertical = VerticalPlacement.top;
+        }
+        if (placement[0] === HorizontalPlacement.right) {
+            vertical = VerticalPlacement.bottom;
+        }
+        placement[0] = horizontal;
+        placement[1] = vertical;
+    }
+    // to up
+    if (direction === LayoutDirection.top) {
+        if (placement[1] === VerticalPlacement.bottom) {
+            placement[1] = VerticalPlacement.top;
+        }
+        else if (placement[1] === VerticalPlacement.top) {
+            placement[1] = VerticalPlacement.bottom;
+        }
+    }
+};
+
+const isLayoutRoot = (element) => {
+    return PlaitMind.isMind(element) || !!element.layout;
+};
+const resolveLayoutRelationDirection = (board, relation) => {
+    const layout = MindQueries.getCorrectLayoutByElement(board, relation.parent);
+    const parentNode = MindElement.getNode(relation.parent);
+    if (relation.type === 'sibling') {
+        // Siblings follow the cross axis and keep the parent's final mirrored orientation.
+        const isSiblingHorizontal = !isHorizontalLayout(layout);
+        const nextDirection = getLayoutDirection(parentNode, isSiblingHorizontal);
+        return relation.order === 'next' ? nextDirection : getLayoutReverseDirection(nextDirection);
+    }
+    if (isIndentedLayout(layout) && isLayoutRoot(relation.parent)) {
+        return getLayoutDirection(parentNode, false);
+    }
+    return getLayoutDirection(MindElement.getNode(relation.child), isHorizontalLayout(layout));
+};
+
+const DirectionToLayoutDirection = {
+    [Direction.left]: LayoutDirection.left,
+    [Direction.right]: LayoutDirection.right,
+    [Direction.top]: LayoutDirection.top,
+    [Direction.bottom]: LayoutDirection.bottom
+};
+const getMindElementCenter = (element) => {
+    return RectangleClient.getCenterPoint(getRectangleByNode(MindElement.getNode(element)));
+};
+const isInNavigationDirection = (direction, source, target) => {
+    const sourceCenter = getMindElementCenter(source);
+    const targetCenter = getMindElementCenter(target);
+    if (direction === Direction.left) {
+        return targetCenter[0] < sourceCenter[0];
+    }
+    if (direction === Direction.right) {
+        return targetCenter[0] > sourceCenter[0];
+    }
+    if (direction === Direction.top) {
+        return targetCenter[1] < sourceCenter[1];
+    }
+    return targetCenter[1] > sourceCenter[1];
+};
+const isInSameNavigationLane = (direction, source, target) => {
+    const sourceRectangle = getRectangleByNode(MindElement.getNode(source));
+    const targetRectangle = getRectangleByNode(MindElement.getNode(target));
+    if (isHorizontalDirection(direction)) {
+        return RectangleClient.isHitY(sourceRectangle, targetRectangle);
+    }
+    return RectangleClient.isHitX(sourceRectangle, targetRectangle);
+};
+const getDistanceInNavigationDirection = (direction, source, target) => {
+    const sourceCenter = getMindElementCenter(source);
+    const targetCenter = getMindElementCenter(target);
+    if (isHorizontalDirection(direction)) {
+        return Math.abs(targetCenter[0] - sourceCenter[0]);
+    }
+    return Math.abs(targetCenter[1] - sourceCenter[1]);
+};
+const getVisibleMindElements = (board, root) => {
+    const elements = [];
+    depthFirstRecursion(root, (node) => {
+        if (!AbstractNode.isAbstract(node)) {
+            elements.push(node);
+        }
+    }, getIsRecursionFunc(board));
+    return elements;
+};
+const getVisibleChildren = (board, element) => {
+    if (!getIsRecursionFunc(board)(element)) {
+        return [];
+    }
+    return element.children?.filter((child) => !AbstractNode.isAbstract(child)) || [];
+};
+const getVisibleParent = (element) => {
+    let parent = MindElement.findParent(element);
+    while (parent && AbstractNode.isAbstract(parent)) {
+        parent = MindElement.findParent(parent);
+    }
+    return parent;
+};
+const getLayoutNavigationCandidates = (board, source) => {
+    const candidates = [];
+    const parent = getVisibleParent(source);
+    if (parent) {
+        const incomingDirection = resolveLayoutRelationDirection(board, {
+            type: 'parent-child',
+            parent,
+            child: source
+        });
+        candidates.push({
+            element: parent,
+            relation: 'parent',
+            direction: getLayoutReverseDirection(incomingDirection)
+        });
+    }
+    getVisibleChildren(board, source).forEach((child) => {
+        candidates.push({
+            element: child,
+            relation: 'child',
+            direction: resolveLayoutRelationDirection(board, {
+                type: 'parent-child',
+                parent: source,
+                child
+            })
+        });
+    });
+    if (parent) {
+        const siblings = getVisibleChildren(board, parent);
+        const sourceIndex = siblings.indexOf(source);
+        if (sourceIndex !== -1) {
+            const previousSibling = siblings[sourceIndex - 1];
+            const nextSibling = siblings[sourceIndex + 1];
+            if (previousSibling) {
+                candidates.push({
+                    element: previousSibling,
+                    relation: 'previous-sibling',
+                    direction: resolveLayoutRelationDirection(board, {
+                        type: 'sibling',
+                        parent,
+                        order: 'previous'
+                    })
+                });
+            }
+            if (nextSibling) {
+                candidates.push({
+                    element: nextSibling,
+                    relation: 'next-sibling',
+                    direction: resolveLayoutRelationDirection(board, {
+                        type: 'sibling',
+                        parent,
+                        order: 'next'
+                    })
+                });
+            }
+        }
+    }
+    return candidates;
+};
+const resolveLayoutNavigationTarget = (candidates, direction, previousElement) => {
+    const matches = candidates.filter((candidate) => candidate.direction === direction);
+    const sibling = matches.find((candidate) => candidate.relation === 'previous-sibling' || candidate.relation === 'next-sibling');
+    if (sibling) {
+        return sibling.element;
+    }
+    const parent = matches.find((candidate) => candidate.relation === 'parent');
+    if (parent) {
+        return parent.element;
+    }
+    const children = matches.filter((candidate) => candidate.relation === 'child');
+    const rememberedChild = children.find((candidate) => candidate.element === previousElement);
+    return rememberedChild?.element || children[0]?.element;
+};
+const getNextMindElementByGeometry = (board, source, direction) => {
+    const root = MindElement.getRoot(board, source);
+    return getVisibleMindElements(board, root)
+        .filter((element) => element !== source &&
+        isInNavigationDirection(direction, source, element) &&
+        isInSameNavigationLane(direction, source, element))
+        .sort((a, b) => getDistanceInNavigationDirection(direction, source, a) - getDistanceInNavigationDirection(direction, source, b))[0];
+};
+const getNextMindElementByDirection = (board, source, direction, previousElement) => {
+    const layoutDirection = DirectionToLayoutDirection[direction];
+    const candidates = getLayoutNavigationCandidates(board, source);
+    const layoutTarget = resolveLayoutNavigationTarget(candidates, layoutDirection, previousElement);
+    return layoutTarget || getNextMindElementByGeometry(board, source, direction);
+};
+
 const adjustRootToNode = (board, node) => {
     const newNode = { ...node };
     delete newNode.rightNodeCount;
@@ -1352,97 +1609,6 @@ function drawRoundRectangleByElement(board, nodeRectangle, element) {
     return nodeG;
 }
 
-var HorizontalPlacement;
-(function (HorizontalPlacement) {
-    HorizontalPlacement["left"] = "left";
-    HorizontalPlacement["center"] = "center";
-    HorizontalPlacement["right"] = "right";
-})(HorizontalPlacement || (HorizontalPlacement = {}));
-var VerticalPlacement;
-(function (VerticalPlacement) {
-    VerticalPlacement["top"] = "top";
-    VerticalPlacement["middle"] = "middle";
-    VerticalPlacement["bottom"] = "bottom";
-})(VerticalPlacement || (VerticalPlacement = {}));
-
-const getPointByPlacement = (client, placement) => {
-    let x = client.x;
-    let y = client.y;
-    if (placement[0] === HorizontalPlacement.center) {
-        x = client.x + client.width / 2;
-    }
-    if (placement[0] === HorizontalPlacement.right) {
-        x = client.x + client.width;
-    }
-    if (placement[1] === VerticalPlacement.middle) {
-        y = client.y + client.height / 2;
-    }
-    if (placement[1] === VerticalPlacement.bottom) {
-        y = client.y + client.height;
-    }
-    return [x, y];
-};
-const getYDistanceBetweenPoint = (point1, point2, isHorizontalLayout) => {
-    getXDistanceBetweenPoint(point1, point2, !isHorizontalLayout);
-};
-const getLayoutDirection = (node, isHorizontal) => {
-    if (isHorizontal) {
-        if (node.left) {
-            return LayoutDirection.left;
-        }
-        else {
-            return LayoutDirection.right;
-        }
-    }
-    else {
-        if (node.up) {
-            return LayoutDirection.top;
-        }
-        else {
-            return LayoutDirection.bottom;
-        }
-    }
-};
-const transformPlacement = (placement, direction) => {
-    // to left
-    if (direction === LayoutDirection.left) {
-        if (placement[0] === HorizontalPlacement.right) {
-            placement[0] = HorizontalPlacement.left;
-        }
-        else if (placement[0] === HorizontalPlacement.left) {
-            placement[0] = HorizontalPlacement.right;
-        }
-    }
-    // to bottom
-    if (direction === LayoutDirection.bottom || direction === LayoutDirection.top) {
-        let horizontal = HorizontalPlacement.center;
-        let vertical = VerticalPlacement.middle;
-        if (placement[1] === VerticalPlacement.top) {
-            horizontal = HorizontalPlacement.left;
-        }
-        if (placement[1] === VerticalPlacement.bottom) {
-            horizontal = HorizontalPlacement.right;
-        }
-        if (placement[0] === HorizontalPlacement.left) {
-            vertical = VerticalPlacement.top;
-        }
-        if (placement[0] === HorizontalPlacement.right) {
-            vertical = VerticalPlacement.bottom;
-        }
-        placement[0] = horizontal;
-        placement[1] = vertical;
-    }
-    // to up
-    if (direction === LayoutDirection.top) {
-        if (placement[1] === VerticalPlacement.bottom) {
-            placement[1] = VerticalPlacement.top;
-        }
-        else if (placement[1] === VerticalPlacement.top) {
-            placement[1] = VerticalPlacement.bottom;
-        }
-    }
-};
-
 function drawIndentedLink(board, parent, child, needDrawUnderline = true, defaultStrokeColor = null, defaultStrokeWidth, defaultStrokeStyle) {
     const branchShape = getBranchShapeByMindElement(board, parent.origin);
     const branchWidth = defaultStrokeWidth || getBranchWidthByMindElement(board, child.origin);
@@ -3451,20 +3617,65 @@ const withCreateMind = (board) => {
     return newBoard;
 };
 
+const NAVIGATION_SELECTED_ELEMENT = new WeakMap();
+const getNavigationDirection = (event) => {
+    if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) {
+        return null;
+    }
+    switch (event.key) {
+        case 'ArrowLeft':
+            return Direction.left;
+        case 'ArrowRight':
+            return Direction.right;
+        case 'ArrowUp':
+            return Direction.top;
+        case 'ArrowDown':
+            return Direction.bottom;
+        default:
+            return null;
+    }
+};
+const selectMindElement = (board, element, previous) => {
+    NAVIGATION_SELECTED_ELEMENT.set(board, { selected: element, previous });
+    const center = getMindElementCenter(element);
+    Transforms.setSelection(board, { anchor: center, focus: center });
+};
 const withMindHotkey = (baseBoard) => {
     const board = baseBoard;
-    const { keyDown, globalKeyDown } = board;
+    const { keyDown, globalKeyDown, pointerDown } = board;
+    board.pointerDown = (event) => {
+        NAVIGATION_SELECTED_ELEMENT.delete(board);
+        pointerDown(event);
+    };
     board.keyDown = (event) => {
         const selectedElements = getSelectedElements(board);
         const isSingleSelection = selectedElements.length === 1;
         const isSingleMindElement = selectedElements.length === 1 && MindElement.isMindElement(board, selectedElements[0]);
         const targetElement = selectedElements[0];
+        let navigationSelectedElement = NAVIGATION_SELECTED_ELEMENT.get(board);
+        if (navigationSelectedElement && navigationSelectedElement.selected !== targetElement) {
+            NAVIGATION_SELECTED_ELEMENT.delete(board);
+            navigationSelectedElement = undefined;
+        }
         if (isExpandHotkey(event) && isSingleMindElement && !PlaitMind.isMind(targetElement)) {
             if (targetElement.children && targetElement.children.length > 0) {
                 Transforms.setNode(board, { isCollapsed: targetElement.isCollapsed ? false : true }, PlaitBoard.findPath(board, targetElement));
                 return;
             }
         }
+        const navigationDirection = getNavigationDirection(event);
+        if (navigationDirection &&
+            isSingleMindElement &&
+            !PlaitBoard.hasBeenTextEditing(board)) {
+            const nextElement = getNextMindElementByDirection(board, targetElement, navigationDirection, navigationSelectedElement?.previous);
+            if (nextElement) {
+                event.preventDefault();
+                selectMindElement(board, nextElement, targetElement);
+                return;
+            }
+            event.preventDefault();
+            return;
+        }
         if (!PlaitBoard.isReadonly(board)) {
             if (isTabHotkey(event) && isSingleMindElement) {
                 event.preventDefault();
@@ -4295,5 +4506,5 @@ class MindEmojiBaseComponent {
  * Generated bundle index. Do not edit.
  */
 
-export { ABSTRACT_HANDLE_COLOR, ABSTRACT_HANDLE_LENGTH, ABSTRACT_HANDLE_MASK_WIDTH, ABSTRACT_INCLUDED_OUTLINE_OFFSET, ABSTRACT_NODE_TEXT, AbstractHandlePosition, AbstractResizeState, BASE, BranchShape, DEFAULT_MIND_IMAGE_WIDTH, DefaultAbstractNodeStyle, DefaultNodeStyle, GRAY_COLOR, INHERIT_ATTRIBUTE_KEYS, LayoutDirection, LayoutDirectionsMap, MIND_CENTRAL_TEXT, MIND_ELEMENT_TO_NODE, MindColorfulThemeColor, MindDarkThemeColor, MindDefaultThemeColor, MindElement, MindElementShape, MindEmojiBaseComponent, MindI18nKey, MindNode, MindNodeComponent, MindPointerType, MindQueries, MindRetroThemeColor, MindSoftThemeColor, MindStarryThemeColor, MindThemeColor, MindThemeColors, MindTransforms, NODE_ADD_CIRCLE_COLOR, NODE_ADD_HOVER_COLOR, NODE_ADD_INNER_CROSS_COLOR, NODE_MORE_BRIDGE_DISTANCE, NODE_MORE_ICON_DIAMETER, NODE_MORE_LINE_DISTANCE, NODE_MORE_STROKE_WIDTH, NodeSpace, PRIMARY_COLOR, PlaitMind, PlaitMindComponent, RESIZE_HANDLE_BUFFER_DISTANCE, ROOT_TOPIC_FONT_SIZE, STROKE_WIDTH, TOPIC_DEFAULT_MAX_WORD_COUNT, TOPIC_FONT_SIZE, WithMindPluginKey, addActiveOnDragOrigin, addImageFocus, adjustAbstractToNode, adjustNodeToRoot, adjustRootToNode, canSetAbstract, copyNewNode, correctLayoutByDirection, createEmptyMind, createMindElement, deleteElementHandleAbstract, deleteElementsHandleRightNodeCount, detectDropTarget, directionCorrector, directionDetector, divideElementByParent, drawFakeDragNode, drawFakeDropNode, editTopic, findLastChild, findLocationLeftIndex, findNewChildNodePath, findNewRightChildNodePath, findNewSiblingNodePath, getAbstractBranchColor, getAbstractBranchWidth, getAbstractHandleRectangle, getAbstractNodeText, getAllowedDirection, getAvailableSubLayoutsByLayoutDirections, getBehindAbstracts, getBranchColorByMindElement, getBranchDirectionsByLayouts, getBranchShapeByMindElement, getBranchWidthByMindElement, getChildrenCount, getCorrespondingAbstract, getDefaultBranchColor, getDefaultBranchColorByIndex, getDefaultFontSizeForMindElement, getDefaultLayout, getDefaultMindNameText, getEmojiFontSize, getEmojiForeignRectangle, getEmojiRectangle, getEmojisWidthHeight, getFillByElement, getFirstLevelElement, getFontSizeByMindElement, getHitAbstractHandle, getHitImageResizeHandleDirection, getImageForeignRectangle, getInCorrectLayoutDirection, getLayoutDirection$1 as getLayoutDirection, getLayoutOptions, getLayoutReverseDirection, getLocationScope, getMindThemeColor, getNewNodeHeight, getNextBranchColor, getOverallAbstracts, getPathByDropTarget, getRectangleByElement, getRectangleByNode, getRectangleByResizingLocation, getRelativeStartEndByAbstractRef, getRootLayout, getSelectedMindElements, getShapeByElement, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTopicRectangleByElement, getTopicRectangleByNode, getValidAbstractRefs, handleTouchedAbstract, hasPreviousOrNextOfDropPath, insertElementHandleAbstract, insertElementHandleRightNodeCount, insertMindElement, isChildElement, isChildOfAbstract, isChildRight, isChildUp, isCorrectLayout, isDropStandardRight, isHitEmojis, isHitImage, isHitMindElement, isInRightBranchOfStandardLayout, isMixedLayout, isSetAbstract, isValidTarget, normalizeWidthAndHeight, removeActiveOnDragOrigin, removeImageFocus, separateChildren, setMindDragging, withEmoji, withMind, withMindExtend };
+export { ABSTRACT_HANDLE_COLOR, ABSTRACT_HANDLE_LENGTH, ABSTRACT_HANDLE_MASK_WIDTH, ABSTRACT_INCLUDED_OUTLINE_OFFSET, ABSTRACT_NODE_TEXT, AbstractHandlePosition, AbstractResizeState, BASE, BranchShape, DEFAULT_MIND_IMAGE_WIDTH, DefaultAbstractNodeStyle, DefaultNodeStyle, GRAY_COLOR, INHERIT_ATTRIBUTE_KEYS, LayoutDirection, LayoutDirectionsMap, MIND_CENTRAL_TEXT, MIND_ELEMENT_TO_NODE, MindColorfulThemeColor, MindDarkThemeColor, MindDefaultThemeColor, MindElement, MindElementShape, MindEmojiBaseComponent, MindI18nKey, MindNode, MindNodeComponent, MindPointerType, MindQueries, MindRetroThemeColor, MindSoftThemeColor, MindStarryThemeColor, MindThemeColor, MindThemeColors, MindTransforms, NODE_ADD_CIRCLE_COLOR, NODE_ADD_HOVER_COLOR, NODE_ADD_INNER_CROSS_COLOR, NODE_MORE_BRIDGE_DISTANCE, NODE_MORE_ICON_DIAMETER, NODE_MORE_LINE_DISTANCE, NODE_MORE_STROKE_WIDTH, NodeSpace, PRIMARY_COLOR, PlaitMind, PlaitMindComponent, RESIZE_HANDLE_BUFFER_DISTANCE, ROOT_TOPIC_FONT_SIZE, STROKE_WIDTH, TOPIC_DEFAULT_MAX_WORD_COUNT, TOPIC_FONT_SIZE, WithMindPluginKey, addActiveOnDragOrigin, addImageFocus, adjustAbstractToNode, adjustNodeToRoot, adjustRootToNode, canSetAbstract, copyNewNode, correctLayoutByDirection, createEmptyMind, createMindElement, deleteElementHandleAbstract, deleteElementsHandleRightNodeCount, detectDropTarget, directionCorrector, directionDetector, divideElementByParent, drawFakeDragNode, drawFakeDropNode, editTopic, findLastChild, findLocationLeftIndex, findNewChildNodePath, findNewRightChildNodePath, findNewSiblingNodePath, getAbstractBranchColor, getAbstractBranchWidth, getAbstractHandleRectangle, getAbstractNodeText, getAllowedDirection, getAvailableSubLayoutsByLayoutDirections, getBehindAbstracts, getBranchColorByMindElement, getBranchDirectionsByLayouts, getBranchShapeByMindElement, getBranchWidthByMindElement, getChildrenCount, getCorrespondingAbstract, getDefaultBranchColor, getDefaultBranchColorByIndex, getDefaultFontSizeForMindElement, getDefaultLayout, getDefaultMindNameText, getEmojiFontSize, getEmojiForeignRectangle, getEmojiRectangle, getEmojisWidthHeight, getFillByElement, getFirstLevelElement, getFontSizeByMindElement, getHitAbstractHandle, getHitImageResizeHandleDirection, getImageForeignRectangle, getInCorrectLayoutDirection, getLayoutDirection$1 as getLayoutDirection, getLayoutOptions, getLayoutReverseDirection, getLocationScope, getMindElementCenter, getMindThemeColor, getNewNodeHeight, getNextBranchColor, getNextMindElementByDirection, getOverallAbstracts, getPathByDropTarget, getRectangleByElement, getRectangleByNode, getRectangleByResizingLocation, getRelativeStartEndByAbstractRef, getRootLayout, getSelectedMindElements, getShapeByElement, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTopicRectangleByElement, getTopicRectangleByNode, getValidAbstractRefs, handleTouchedAbstract, hasPreviousOrNextOfDropPath, insertElementHandleAbstract, insertElementHandleRightNodeCount, insertMindElement, isChildElement, isChildOfAbstract, isChildRight, isChildUp, isCorrectLayout, isDropStandardRight, isHitEmojis, isHitImage, isHitMindElement, isInRightBranchOfStandardLayout, isMixedLayout, isSetAbstract, isValidTarget, normalizeWidthAndHeight, removeActiveOnDragOrigin, removeImageFocus, separateChildren, setMindDragging, withEmoji, withMind, withMindExtend };
 //# sourceMappingURL=plait-mind.mjs.map