@plait/mind 0.2.2 → 0.3.1

package/esm2020/utils/dnd/detector.mjs

@@ -0,0 +1,268 @@
+import { MindElement, PlaitMind } from '../../interfaces/element';
+import { PlaitBoard, PlaitElement, depthFirstRecursion, Path } from '@plait/core';
+import { getRectangleByNode } from '../position/node';
+import { MindQueries } from '../../queries';
+import { getRootLayout, isMixedLayout } from '../layout';
+import { MindLayoutType, getNonAbstractChildren, isHorizontalLogicLayout, isIndentedLayout, isStandardLayout, isTopLayout, isVerticalLogicLayout } from '@plait/layouts';
+import { isBottomLayout, isRightLayout, isLeftLayout, AbstractNode } from '@plait/layouts';
+import { isChildElement } from '../mind';
+/**
+ *
+ * @param targetNode
+ * @param centerPoint
+ * @returns DetectResult[] | null
+ */
+export const directionCorrector = (board, node, detectResults) => {
+    if (!node.origin.isRoot && !AbstractNode.isAbstract(node.origin)) {
+        const parentLayout = MindQueries.getCorrectLayoutByElement(board, node?.parent.origin);
+        if (isStandardLayout(parentLayout)) {
+            const idx = node.parent.children.findIndex(x => x === node);
+            const isLeft = idx >= (node.parent.origin.rightNodeCount || 0);
+            return getAllowedDirection(detectResults, [isLeft ? 'right' : 'left']);
+        }
+        if (isLeftLayout(parentLayout)) {
+            return getAllowedDirection(detectResults, ['right']);
+        }
+        if (isRightLayout(parentLayout)) {
+            return getAllowedDirection(detectResults, ['left']);
+        }
+        if (parentLayout === MindLayoutType.upward) {
+            return getAllowedDirection(detectResults, ['bottom']);
+        }
+        if (parentLayout === MindLayoutType.downward) {
+            return getAllowedDirection(detectResults, ['top']);
+        }
+    }
+    else {
+        const layout = MindQueries.getCorrectLayoutByElement(board, node?.origin);
+        if (isStandardLayout(layout)) {
+            return getAllowedDirection(detectResults, ['top', 'bottom']);
+        }
+        if (layout === MindLayoutType.upward) {
+            return getAllowedDirection(detectResults, ['left', 'right', 'bottom']);
+        }
+        if (layout === MindLayoutType.downward) {
+            return getAllowedDirection(detectResults, ['left', 'right', 'top']);
+        }
+        if (isLeftLayout(layout)) {
+            return getAllowedDirection(detectResults, ['right', 'top', 'bottom']);
+        }
+        if (isRightLayout(layout)) {
+            return getAllowedDirection(detectResults, ['left', 'top', 'bottom']);
+        }
+    }
+    return null;
+};
+export const getAllowedDirection = (detectResults, illegalDirections) => {
+    const directions = detectResults;
+    illegalDirections.forEach(item => {
+        const bottomDirectionIndex = directions.findIndex(direction => direction === item);
+        if (bottomDirectionIndex !== -1) {
+            directions.splice(bottomDirectionIndex, 1);
+        }
+    });
+    return directions.length ? directions : null;
+};
+export const detectDropTarget = (board, detectPoint, dropTarget, activeElements) => {
+    let detectResult = null;
+    depthFirstRecursion(board, element => {
+        if (!MindElement.isMindElement(board, element) || detectResult) {
+            return;
+        }
+        const node = MindElement.getNode(element);
+        const directions = directionDetector(node, detectPoint);
+        if (directions) {
+            detectResult = directionCorrector(board, node, directions);
+        }
+        dropTarget = null;
+        const isValid = activeElements.every(element => isValidTarget(element, node.origin));
+        if (detectResult && isValid) {
+            dropTarget = { target: node.origin, detectResult: detectResult[0] };
+        }
+    }, node => {
+        if (PlaitBoard.isBoard(node) || board.isRecursion(node)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    });
+    return dropTarget;
+};
+export const directionDetector = (targetNode, centerPoint) => {
+    const { x, y, width, height } = getRectangleByNode(targetNode);
+    const yCenter = y + height / 2;
+    const xCenter = x + width / 2;
+    const top = targetNode.y;
+    const bottom = targetNode.y + targetNode.height;
+    const left = targetNode.x;
+    const right = targetNode.x + targetNode.width;
+    const direction = [];
+    // x 轴
+    if (centerPoint[1] > y && centerPoint[1] < y + height) {
+        if (centerPoint[0] > left && centerPoint[0] < xCenter) {
+            direction.push('left');
+        }
+        if (centerPoint[0] > xCenter && centerPoint[0] < right) {
+            direction.push('right');
+        }
+        // 重合区域，返回两个方向
+        if ((centerPoint[0] > x && centerPoint[0] < xCenter) || (centerPoint[0] > xCenter && centerPoint[0] < x + width)) {
+            if (centerPoint[1] < yCenter) {
+                direction.push('top');
+            }
+            else {
+                direction.push('bottom');
+            }
+        }
+        return direction.length ? direction : null;
+    }
+    // y 轴
+    if (centerPoint[0] > x && centerPoint[0] < x + width) {
+        if (centerPoint[1] > top && centerPoint[1] < yCenter) {
+            direction.push('top');
+        }
+        if (centerPoint[1] > yCenter && centerPoint[1] < bottom) {
+            direction.push('bottom');
+        }
+        if ((centerPoint[1] > y && centerPoint[1] < y + height) || (centerPoint[1] > yCenter && centerPoint[1] < y + height)) {
+            if (centerPoint[0] < xCenter) {
+                direction.push('left');
+            }
+            else {
+                direction.push('right');
+            }
+        }
+        return direction.length ? direction : null;
+    }
+    return null;
+};
+/* 根据布局调整 target 以及 direction */
+export const readjustmentDropTarget = (board, dropTarget) => {
+    const { target, detectResult } = dropTarget;
+    const newDropTarget = { target, detectResult };
+    const targetComponent = PlaitElement.getComponent(target);
+    if (targetComponent.node.children.length > 0 && dropTarget.detectResult) {
+        const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);
+        const parentLayout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin.isRoot ? targetComponent.node.origin : targetComponent.node.parent.origin);
+        const children = getNonAbstractChildren(targetComponent.node);
+        if (['right', 'left'].includes(dropTarget.detectResult)) {
+            if (!isMixedLayout(parentLayout, layout)) {
+                if (targetComponent.node.origin.isRoot) {
+                    const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);
+                    // 标准布局，根节点
+                    if (isStandardLayout(layout)) {
+                        const rightNodeCount = targetComponent.node.origin.rightNodeCount;
+                        if (detectResult === 'left') {
+                            // 作为左的第一个节点
+                            if (targetComponent.node.children.length === rightNodeCount) {
+                                return newDropTarget;
+                            }
+                        }
+                        else {
+                            // 作为右的第一个节点或最后一个节点
+                            if (rightNodeCount === 0) {
+                                newDropTarget.target = target;
+                            }
+                            else {
+                                newDropTarget.target = targetComponent.node.children[rightNodeCount - 1].origin;
+                                newDropTarget.detectResult = 'bottom';
+                            }
+                            return newDropTarget;
+                        }
+                    }
+                }
+                // 缩进布局探测到第一个子节点
+                if (isIndentedLayout(parentLayout)) {
+                    newDropTarget.target = targetComponent.node.children[0].origin;
+                    newDropTarget.detectResult = isTopLayout(parentLayout) ? 'bottom' : 'top';
+                    return newDropTarget;
+                }
+                // 上下布局的根节点只可以探测到上或者下，子节点的左右探测不处理，跳过。
+                if (isVerticalLogicLayout(parentLayout)) {
+                    return newDropTarget;
+                }
+                // 剩下是水平布局的默认情况：插入最后一个子节点的下方
+                const lastChildNodeIndex = children.length - 1;
+                newDropTarget.target = targetComponent.node.children[lastChildNodeIndex].origin;
+                newDropTarget.detectResult = 'bottom';
+            }
+            else {
+                // 处理左右布局下的混合布局
+                if ([MindLayoutType.left, MindLayoutType.right].includes(parentLayout)) {
+                    const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);
+                    if (isIndentedLayout(layout)) {
+                        newDropTarget.target = targetComponent.node.children[0].origin;
+                        newDropTarget.detectResult = isTopLayout(layout) ? 'bottom' : 'top';
+                        return newDropTarget;
+                    }
+                }
+            }
+        }
+        if (['top', 'bottom'].includes(dropTarget.detectResult)) {
+            // 缩进布局移动至第一个节点
+            if (targetComponent.node.origin.isRoot && isIndentedLayout(layout)) {
+                newDropTarget.target = targetComponent.node.children[0].origin;
+                newDropTarget.detectResult = isTopLayout(layout) ? 'bottom' : 'top';
+                return newDropTarget;
+            }
+            // 上下布局，插到右边
+            const parentLayout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin.isRoot ? targetComponent.node.origin : targetComponent.node.parent.origin);
+            if (isVerticalLogicLayout(parentLayout)) {
+                const lastChildNodeIndex = children.length - 1;
+                newDropTarget.target = targetComponent.node.children[lastChildNodeIndex].origin;
+                newDropTarget.detectResult = 'right';
+                return newDropTarget;
+            }
+        }
+        return newDropTarget;
+    }
+    return dropTarget;
+};
+export const isValidTarget = (origin, target) => {
+    return origin !== target && !isChildElement(origin, target);
+};
+export const getPathByDropTarget = (board, dropTarget) => {
+    let targetPath = PlaitBoard.findPath(board, dropTarget?.target);
+    const layout = PlaitMind.isMind(dropTarget?.target)
+        ? getRootLayout(dropTarget?.target)
+        : MindQueries.getCorrectLayoutByElement(board, MindElement.getParent(dropTarget?.target));
+    const children = getNonAbstractChildren(dropTarget.target);
+    // 上下布局：左右是兄弟节点，上下是子节点
+    if (isVerticalLogicLayout(layout)) {
+        if (dropTarget.detectResult === 'top' || dropTarget.detectResult === 'bottom') {
+            targetPath.push(children.length);
+        }
+        // 如果是左，位置不变，右则插入到下一个兄弟节点
+        if (dropTarget.detectResult === 'right') {
+            targetPath = Path.next(targetPath);
+        }
+    }
+    // 水平布局/标准布局：上下是兄弟节点，左右是子节点
+    if (isHorizontalLogicLayout(layout)) {
+        if (dropTarget.detectResult === 'right' || dropTarget.detectResult === 'left') {
+            targetPath.push(children.length);
+        }
+        // 如果是上，位置不变，下插入到下一个兄弟节点
+        if (dropTarget.detectResult === 'bottom') {
+            targetPath = Path.next(targetPath);
+        }
+    }
+    // 缩进布局：上下是兄弟节点，左右是子节点，但上（左上/右上），探测到上是子节点，下则位置不变，反之同理。
+    if (isIndentedLayout(layout)) {
+        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {
+            targetPath = Path.next(targetPath);
+        }
+        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {
+            targetPath = Path.next(targetPath);
+        }
+        if (isLeftLayout(layout) && dropTarget.detectResult === 'left') {
+            targetPath.push(children.length);
+        }
+        if (isRightLayout(layout) && dropTarget.detectResult === 'right') {
+            targetPath.push(children.length);
+        }
+    }
+    return targetPath;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detector.js","sourceRoot":"","sources":["../../../../../packages/mind/src/utils/dnd/detector.ts"],"names":[],"mappings":"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","sourcesContent":["import { MindElement, PlaitMind } from '../../interfaces/element';\nimport { PlaitBoard, PlaitElement, Point, depthFirstRecursion, Path, BoardTransforms, ELEMENT_TO_COMPONENT } from '@plait/core';\nimport { DetectResult, MindNode } from '../../interfaces/node';\nimport { getRectangleByNode } from '../position/node';\nimport { MindQueries } from '../../queries';\nimport { getRootLayout, isMixedLayout } from '../layout';\nimport {\n    MindLayoutType,\n    getNonAbstractChildren,\n    isHorizontalLogicLayout,\n    isIndentedLayout,\n    isStandardLayout,\n    isTopLayout,\n    isVerticalLogicLayout\n} from '@plait/layouts';\nimport { MindNodeComponent } from '../../node.component';\nimport { isBottomLayout, isRightLayout, isLeftLayout, AbstractNode } from '@plait/layouts';\nimport { isChildElement } from '../mind';\n\n/**\n *\n * @param targetNode\n * @param centerPoint\n * @returns DetectResult[] | null\n */\n\nexport const directionCorrector = (board: PlaitBoard, node: MindNode, detectResults: DetectResult[]): DetectResult[] | null => {\n    if (!node.origin.isRoot && !AbstractNode.isAbstract(node.origin)) {\n        const parentLayout = MindQueries.getCorrectLayoutByElement(board, node?.parent.origin as MindElement);\n        if (isStandardLayout(parentLayout)) {\n            const idx = node.parent.children.findIndex(x => x === node);\n            const isLeft = idx >= (node.parent.origin.rightNodeCount || 0);\n            return getAllowedDirection(detectResults, [isLeft ? 'right' : 'left']);\n        }\n\n        if (isLeftLayout(parentLayout)) {\n            return getAllowedDirection(detectResults, ['right']);\n        }\n\n        if (isRightLayout(parentLayout)) {\n            return getAllowedDirection(detectResults, ['left']);\n        }\n\n        if (parentLayout === MindLayoutType.upward) {\n            return getAllowedDirection(detectResults, ['bottom']);\n        }\n\n        if (parentLayout === MindLayoutType.downward) {\n            return getAllowedDirection(detectResults, ['top']);\n        }\n    } else {\n        const layout = MindQueries.getCorrectLayoutByElement(board, node?.origin as MindElement);\n        if (isStandardLayout(layout)) {\n            return getAllowedDirection(detectResults, ['top', 'bottom']);\n        }\n\n        if (layout === MindLayoutType.upward) {\n            return getAllowedDirection(detectResults, ['left', 'right', 'bottom']);\n        }\n\n        if (layout === MindLayoutType.downward) {\n            return getAllowedDirection(detectResults, ['left', 'right', 'top']);\n        }\n\n        if (isLeftLayout(layout)) {\n            return getAllowedDirection(detectResults, ['right', 'top', 'bottom']);\n        }\n\n        if (isRightLayout(layout)) {\n            return getAllowedDirection(detectResults, ['left', 'top', 'bottom']);\n        }\n    }\n\n    return null;\n};\n\nexport const getAllowedDirection = (detectResults: DetectResult[], illegalDirections: DetectResult[]): DetectResult[] | null => {\n    const directions = detectResults;\n    illegalDirections.forEach(item => {\n        const bottomDirectionIndex = directions.findIndex(direction => direction === item);\n        if (bottomDirectionIndex !== -1) {\n            directions.splice(bottomDirectionIndex, 1);\n        }\n    });\n    return directions.length ? directions : null;\n};\n\nexport const detectDropTarget = (\n    board: PlaitBoard,\n    detectPoint: Point,\n    dropTarget: { target: MindElement; detectResult: DetectResult } | null,\n    activeElements: MindElement[]\n) => {\n    let detectResult: DetectResult[] | null = null;\n    depthFirstRecursion(\n        (board as unknown) as MindElement,\n        element => {\n            if (!MindElement.isMindElement(board, element) || detectResult) {\n                return;\n            }\n            const node = MindElement.getNode(element);\n            const directions = directionDetector(node, detectPoint);\n            if (directions) {\n                detectResult = directionCorrector(board, node, directions);\n            }\n            dropTarget = null;\n            const isValid = activeElements.every(element => isValidTarget(element, node.origin));\n            if (detectResult && isValid) {\n                dropTarget = { target: node.origin, detectResult: detectResult[0] };\n            }\n        },\n        node => {\n            if (PlaitBoard.isBoard(node) || board.isRecursion(node)) {\n                return true;\n            } else {\n                return false;\n            }\n        }\n    );\n    return dropTarget;\n};\n\nexport const directionDetector = (targetNode: MindNode, centerPoint: Point): DetectResult[] | null => {\n    const { x, y, width, height } = getRectangleByNode(targetNode);\n    const yCenter = y + height / 2;\n    const xCenter = x + width / 2;\n\n    const top = targetNode.y;\n    const bottom = targetNode.y + targetNode.height;\n    const left = targetNode.x;\n    const right = targetNode.x + targetNode.width;\n    const direction: DetectResult[] = [];\n\n    // x 轴\n    if (centerPoint[1] > y && centerPoint[1] < y + height) {\n        if (centerPoint[0] > left && centerPoint[0] < xCenter) {\n            direction.push('left');\n        }\n        if (centerPoint[0] > xCenter && centerPoint[0] < right) {\n            direction.push('right');\n        }\n        // 重合区域，返回两个方向\n        if ((centerPoint[0] > x && centerPoint[0] < xCenter) || (centerPoint[0] > xCenter && centerPoint[0] < x + width)) {\n            if (centerPoint[1] < yCenter) {\n                direction.push('top');\n            } else {\n                direction.push('bottom');\n            }\n        }\n        return direction.length ? direction : null;\n    }\n\n    // y 轴\n    if (centerPoint[0] > x && centerPoint[0] < x + width) {\n        if (centerPoint[1] > top && centerPoint[1] < yCenter) {\n            direction.push('top');\n        }\n        if (centerPoint[1] > yCenter && centerPoint[1] < bottom) {\n            direction.push('bottom');\n        }\n        if ((centerPoint[1] > y && centerPoint[1] < y + height) || (centerPoint[1] > yCenter && centerPoint[1] < y + height)) {\n            if (centerPoint[0] < xCenter) {\n                direction.push('left');\n            } else {\n                direction.push('right');\n            }\n        }\n        return direction.length ? direction : null;\n    }\n\n    return null;\n};\n\n/* 根据布局调整 target 以及 direction */\nexport const readjustmentDropTarget = (\n    board: PlaitBoard,\n    dropTarget: {\n        target: MindElement;\n        detectResult: DetectResult;\n    }\n): { target: MindElement; detectResult: DetectResult } => {\n    const { target, detectResult } = dropTarget;\n    const newDropTarget = { target, detectResult };\n    const targetComponent = PlaitElement.getComponent(target) as MindNodeComponent;\n    if (targetComponent.node.children.length > 0 && dropTarget.detectResult) {\n        const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);\n        const parentLayout = MindQueries.getCorrectLayoutByElement(\n            board,\n            targetComponent.node.origin.isRoot ? targetComponent.node.origin : targetComponent.node.parent.origin\n        );\n        const children = getNonAbstractChildren(targetComponent.node);\n        if (['right', 'left'].includes(dropTarget.detectResult)) {\n            if (!isMixedLayout(parentLayout, layout)) {\n                if (targetComponent.node.origin.isRoot) {\n                    const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);\n                    // 标准布局，根节点\n                    if (isStandardLayout(layout)) {\n                        const rightNodeCount = targetComponent.node.origin.rightNodeCount as number;\n                        if (detectResult === 'left') {\n                            // 作为左的第一个节点\n                            if (targetComponent.node.children.length === rightNodeCount) {\n                                return newDropTarget;\n                            }\n                        } else {\n                            // 作为右的第一个节点或最后一个节点\n                            if (rightNodeCount === 0) {\n                                newDropTarget.target = target;\n                            } else {\n                                newDropTarget.target = targetComponent.node.children[rightNodeCount - 1].origin;\n                                newDropTarget.detectResult = 'bottom';\n                            }\n                            return newDropTarget;\n                        }\n                    }\n                }\n\n                // 缩进布局探测到第一个子节点\n                if (isIndentedLayout(parentLayout)) {\n                    newDropTarget.target = targetComponent.node.children[0].origin;\n                    newDropTarget.detectResult = isTopLayout(parentLayout) ? 'bottom' : 'top';\n                    return newDropTarget;\n                }\n                // 上下布局的根节点只可以探测到上或者下，子节点的左右探测不处理，跳过。\n                if (isVerticalLogicLayout(parentLayout)) {\n                    return newDropTarget;\n                }\n                // 剩下是水平布局的默认情况：插入最后一个子节点的下方\n                const lastChildNodeIndex = children.length - 1;\n                newDropTarget.target = targetComponent.node.children[lastChildNodeIndex].origin;\n                newDropTarget.detectResult = 'bottom';\n            } else {\n                // 处理左右布局下的混合布局\n                if ([MindLayoutType.left, MindLayoutType.right].includes(parentLayout)) {\n                    const layout = MindQueries.getCorrectLayoutByElement(board, targetComponent.node.origin);\n                    if (isIndentedLayout(layout)) {\n                        newDropTarget.target = targetComponent.node.children[0].origin;\n                        newDropTarget.detectResult = isTopLayout(layout) ? 'bottom' : 'top';\n                        return newDropTarget;\n                    }\n                }\n            }\n        }\n        if (['top', 'bottom'].includes(dropTarget.detectResult)) {\n            // 缩进布局移动至第一个节点\n            if (targetComponent.node.origin.isRoot && isIndentedLayout(layout)) {\n                newDropTarget.target = targetComponent.node.children[0].origin;\n                newDropTarget.detectResult = isTopLayout(layout) ? 'bottom' : 'top';\n                return newDropTarget;\n            }\n            // 上下布局，插到右边\n            const parentLayout = MindQueries.getCorrectLayoutByElement(\n                board,\n                targetComponent.node.origin.isRoot ? targetComponent.node.origin : targetComponent.node.parent.origin\n            );\n            if (isVerticalLogicLayout(parentLayout)) {\n                const lastChildNodeIndex = children.length - 1;\n                newDropTarget.target = targetComponent.node.children[lastChildNodeIndex].origin;\n                newDropTarget.detectResult = 'right';\n                return newDropTarget;\n            }\n        }\n        return newDropTarget;\n    }\n    return dropTarget;\n};\n\nexport const isValidTarget = (origin: MindElement, target: MindElement) => {\n    return origin !== target && !isChildElement(origin, target);\n};\n\nexport const getPathByDropTarget = (board: PlaitBoard, dropTarget: { target: MindElement; detectResult: DetectResult }) => {\n    let targetPath = PlaitBoard.findPath(board, dropTarget?.target);\n    const layout = PlaitMind.isMind(dropTarget?.target)\n        ? getRootLayout(dropTarget?.target)\n        : MindQueries.getCorrectLayoutByElement(board, MindElement.getParent(dropTarget?.target));\n    const children = getNonAbstractChildren(dropTarget.target);\n    // 上下布局：左右是兄弟节点，上下是子节点\n    if (isVerticalLogicLayout(layout)) {\n        if (dropTarget.detectResult === 'top' || dropTarget.detectResult === 'bottom') {\n            targetPath.push(children.length);\n        }\n        // 如果是左，位置不变，右则插入到下一个兄弟节点\n        if (dropTarget.detectResult === 'right') {\n            targetPath = Path.next(targetPath);\n        }\n    }\n    // 水平布局/标准布局：上下是兄弟节点，左右是子节点\n    if (isHorizontalLogicLayout(layout)) {\n        if (dropTarget.detectResult === 'right' || dropTarget.detectResult === 'left') {\n            targetPath.push(children.length);\n        }\n        // 如果是上，位置不变，下插入到下一个兄弟节点\n        if (dropTarget.detectResult === 'bottom') {\n            targetPath = Path.next(targetPath);\n        }\n    }\n\n    // 缩进布局：上下是兄弟节点，左右是子节点，但上（左上/右上），探测到上是子节点，下则位置不变，反之同理。\n    if (isIndentedLayout(layout)) {\n        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {\n            targetPath = Path.next(targetPath);\n        }\n        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {\n            targetPath = Path.next(targetPath);\n        }\n        if (isLeftLayout(layout) && dropTarget.detectResult === 'left') {\n            targetPath.push(children.length);\n        }\n        if (isRightLayout(layout) && dropTarget.detectResult === 'right') {\n            targetPath.push(children.length);\n        }\n    }\n    return targetPath;\n};\n"]}

package/esm2020/utils/dnd/draw.mjs

@@ -0,0 +1,161 @@
+import { drawRoundRectangleByNode } from '../../draw/node';
+import { updateForeignObject } from '@plait/richtext';
+import { BASE, PRIMARY_COLOR, STROKE_WIDTH } from '../../constants';
+import { MindElement, PlaitMind } from '../../interfaces';
+import { getRectangleByNode } from '../position/node';
+import { PlaitBoard, drawRoundRectangle, createG, Path, PlaitNode } from '@plait/core';
+import { MindQueries } from '../../queries';
+import { getNonAbstractChildren, isHorizontalLayout, isIndentedLayout, isStandardLayout, isTopLayout } from '@plait/layouts';
+import { drawIndentedLink } from '../../draw/indented-link';
+import { getTopicRectangleByNode } from '../position/topic';
+import { drawLogicLink } from '../../draw/link/logic-link';
+import { HorizontalPlacement, VerticalPlacement } from '../../interfaces/types';
+import { getLayoutDirection, getPointByPlacement, moveXOfPoint, moveYOfPoint, transformPlacement } from '../point-placement';
+import { getRootLayout } from '../layout';
+export const drawFakeDragNode = (board, activeComponent, offsetX, offsetY) => {
+    const dragFakeNodeG = createG();
+    dragFakeNodeG.classList.add('dragging', 'fake-node', 'plait-board-attached');
+    const fakeDraggingNode = {
+        ...activeComponent.node,
+        children: [],
+        x: activeComponent.node.x + offsetX,
+        y: activeComponent.node.y + offsetY
+    };
+    const textRectangle = getTopicRectangleByNode(board, activeComponent.node);
+    const fakeNodeG = drawRoundRectangleByNode(board, fakeDraggingNode);
+    const richtextG = activeComponent.richtextG?.cloneNode(true);
+    updateForeignObject(richtextG, textRectangle.width + BASE * 10, textRectangle.height, textRectangle.x + offsetX, textRectangle.y + offsetY);
+    dragFakeNodeG?.append(fakeNodeG);
+    dragFakeNodeG?.append(richtextG);
+    return dragFakeNodeG;
+};
+export const drawFakeDropNodeByPath = (board, target, path) => {
+    const fakeDropNodeG = createG();
+    const parent = PlaitNode.get(board, Path.parent(path));
+    const layout = MindQueries.getLayoutByElement(parent);
+    const isHorizontal = isHorizontalLayout(layout);
+    const { hasNextNode, hasPreviousNode } = getPreviousAndNextByPath(parent, target, path);
+    const width = 30;
+    const height = 12;
+    let fakeNode, centerPoint, basicNode, linkDirection;
+    if (!hasPreviousNode && !hasNextNode) {
+        const parentNode = MindElement.getNode(parent);
+        const parentRect = getRectangleByNode(parentNode);
+        linkDirection = getLayoutDirection(parentNode, isHorizontal);
+        basicNode = parentNode;
+        const placement = [HorizontalPlacement.right, VerticalPlacement.middle];
+        transformPlacement(placement, linkDirection);
+        const parentCenterPoint = getPointByPlacement(parentRect, placement);
+        if (isIndentedLayout(layout)) {
+            const placement = [
+                HorizontalPlacement.center,
+                isTopLayout(layout) ? VerticalPlacement.top : VerticalPlacement.bottom
+            ];
+            const parentCenterPoint = getPointByPlacement(parentRect, placement);
+            centerPoint = moveXOfPoint(parentCenterPoint, height, linkDirection);
+            centerPoint[1] = isTopLayout(layout) ? centerPoint[1] - height : centerPoint[1] + height;
+        }
+        else {
+            centerPoint = moveXOfPoint(parentCenterPoint, width, linkDirection);
+        }
+    }
+    else if (!hasPreviousNode && hasNextNode) {
+        const nextElement = PlaitNode.get(board, path);
+        basicNode = MindElement.getNode(nextElement);
+        const nextRect = getRectangleByNode(basicNode);
+        linkDirection = getLayoutDirection(basicNode, isHorizontal);
+        const placement = [HorizontalPlacement.left, VerticalPlacement.top];
+        transformPlacement(placement, linkDirection);
+        let offset = -height;
+        if (MindElement.isIndentedLayout(parent)) {
+            offset = isTopLayout(layout) ? offset / 2 + basicNode.height - basicNode.vGap : 0;
+        }
+        centerPoint = getPointByPlacement(nextRect, placement);
+        centerPoint = moveYOfPoint(centerPoint, offset, linkDirection);
+    }
+    else if (hasPreviousNode && !hasNextNode) {
+        const previousElement = PlaitNode.get(board, Path.previous(path));
+        basicNode = MindElement.getNode(previousElement);
+        const previousRect = getRectangleByNode(basicNode);
+        linkDirection = getLayoutDirection(basicNode, isHorizontal);
+        const placement = [HorizontalPlacement.left, VerticalPlacement.bottom];
+        transformPlacement(placement, linkDirection);
+        let offset = height;
+        if (MindElement.isIndentedLayout(parent)) {
+            offset = isTopLayout(layout) ? -offset - (basicNode.height - basicNode.vGap) : offset;
+        }
+        centerPoint = getPointByPlacement(previousRect, placement);
+        centerPoint = moveYOfPoint(centerPoint, offset, linkDirection);
+    }
+    else {
+        const previousElement = PlaitNode.get(board, Path.previous(path));
+        basicNode = MindElement.getNode(previousElement);
+        const previousRect = getRectangleByNode(basicNode);
+        const nextElement = PlaitNode.get(board, path);
+        const nextNode = MindElement.getNode(nextElement);
+        const nextRect = getRectangleByNode(nextNode);
+        const beginPlacement = [HorizontalPlacement.left, VerticalPlacement.bottom];
+        const endPlacement = [HorizontalPlacement.left, VerticalPlacement.top];
+        linkDirection = getLayoutDirection(basicNode, isHorizontal);
+        transformPlacement(beginPlacement, linkDirection);
+        transformPlacement(endPlacement, linkDirection);
+        const previousPoint = getPointByPlacement(previousRect, beginPlacement);
+        const nextPoint = getPointByPlacement(nextRect, endPlacement);
+        centerPoint = [(previousPoint[0] + nextPoint[0]) / 2, (previousPoint[1] + nextPoint[1]) / 2];
+    }
+    let cornerPoint = centerPoint, oppositePoint = centerPoint;
+    const offsetY = isHorizontal ? height : width;
+    const offsetX = isHorizontal ? width : height;
+    cornerPoint = moveYOfPoint(cornerPoint, -offsetY / 2, linkDirection);
+    oppositePoint = moveYOfPoint(oppositePoint, offsetY / 2, linkDirection);
+    oppositePoint = moveXOfPoint(oppositePoint, offsetX, linkDirection);
+    const x = Math.min(cornerPoint[0], oppositePoint[0]);
+    const y = Math.min(cornerPoint[1], oppositePoint[1]);
+    fakeNode = {
+        ...basicNode,
+        x,
+        y,
+        width,
+        height,
+        hGap: MindElement.isIndentedLayout(parent) ? BASE * 4 + (basicNode.origin.strokeWidth || STROKE_WIDTH) : 0,
+        vGap: MindElement.isIndentedLayout(parent) ? BASE : 0
+    };
+    const fakeRectangleG = drawRoundRectangle(PlaitBoard.getRoughSVG(board), fakeNode.x, fakeNode.y, fakeNode.x + width, fakeNode.y + height, {
+        stroke: PRIMARY_COLOR,
+        strokeWidth: 2,
+        fill: PRIMARY_COLOR,
+        fillStyle: 'solid'
+    });
+    const link = MindElement.isIndentedLayout(parent)
+        ? drawIndentedLink(board, MindElement.getNode(parent), fakeNode, PRIMARY_COLOR, false, STROKE_WIDTH)
+        : drawLogicLink(board, fakeNode, MindElement.getNode(parent), isHorizontal, PRIMARY_COLOR, STROKE_WIDTH);
+    fakeDropNodeG?.appendChild(link);
+    fakeDropNodeG?.appendChild(fakeRectangleG);
+    return fakeDropNodeG;
+};
+export const getPreviousAndNextByPath = (parent, target, path) => {
+    const children = getNonAbstractChildren(parent);
+    let hasPreviousNode = path[path.length - 1] !== 0;
+    let hasNextNode = path[path.length - 1] !== (children?.length || 0);
+    if (PlaitMind.isMind(parent) && isStandardLayout(getRootLayout(parent))) {
+        const dropStandardRightBottom = target === parent.children[parent.rightNodeCount - 1] && path[path.length - 1] === parent.rightNodeCount;
+        const dropStandardLeftTop = target === parent.children[parent.rightNodeCount] && path[path.length - 1] === parent.rightNodeCount;
+        if (dropStandardRightBottom) {
+            hasPreviousNode = true;
+            hasNextNode = false;
+        }
+        if (dropStandardLeftTop) {
+            hasPreviousNode = false;
+            hasNextNode = true;
+        }
+    }
+    if (parent.isCollapsed) {
+        hasNextNode = false;
+        hasPreviousNode = false;
+    }
+    return {
+        hasPreviousNode,
+        hasNextNode
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draw.js","sourceRoot":"","sources":["../../../../../packages/mind/src/utils/dnd/draw.ts"],"names":[],"mappings":"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","sourcesContent":["import { drawRoundRectangleByNode } from '../../draw/node';\nimport { updateForeignObject } from '@plait/richtext';\nimport { BASE, PRIMARY_COLOR, STROKE_WIDTH } from '../../constants';\nimport { LayoutDirection, MindElement, MindNode, PlaitMind } from '../../interfaces';\nimport { MindNodeComponent } from '../../node.component';\nimport { getRectangleByNode } from '../position/node';\nimport { PlaitBoard, Point, drawRoundRectangle, createG, Path, PlaitNode } from '@plait/core';\nimport { MindQueries } from '../../queries';\nimport {\n    getNonAbstractChildren,\n    isHorizontalLayout,\n    isIndentedLayout,\n    isStandardLayout,\n    isTopLayout,\n    MindLayoutType\n} from '@plait/layouts';\nimport { drawIndentedLink } from '../../draw/indented-link';\nimport { getTopicRectangleByNode } from '../position/topic';\nimport { drawLogicLink } from '../../draw/link/logic-link';\nimport { HorizontalPlacement, PointPlacement, VerticalPlacement } from '../../interfaces/types';\nimport { getLayoutDirection, getPointByPlacement, moveXOfPoint, moveYOfPoint, transformPlacement } from '../point-placement';\nimport { PlaitMindBoard } from '../../plugins/with-mind.board';\nimport { getRootLayout } from '../layout';\n\nexport const drawFakeDragNode = (board: PlaitBoard, activeComponent: MindNodeComponent, offsetX: number, offsetY: number) => {\n    const dragFakeNodeG = createG();\n    dragFakeNodeG.classList.add('dragging', 'fake-node', 'plait-board-attached');\n\n    const fakeDraggingNode: MindNode = {\n        ...activeComponent.node,\n        children: [],\n        x: activeComponent.node.x + offsetX,\n        y: activeComponent.node.y + offsetY\n    };\n    const textRectangle = getTopicRectangleByNode(board as PlaitMindBoard, activeComponent.node);\n    const fakeNodeG = drawRoundRectangleByNode(board, fakeDraggingNode);\n\n    const richtextG = activeComponent.richtextG?.cloneNode(true) as SVGGElement;\n    updateForeignObject(\n        richtextG,\n        textRectangle.width + BASE * 10,\n        textRectangle.height,\n        textRectangle.x + offsetX,\n        textRectangle.y + offsetY\n    );\n\n    dragFakeNodeG?.append(fakeNodeG);\n    dragFakeNodeG?.append(richtextG);\n    return dragFakeNodeG;\n};\n\nexport const drawFakeDropNodeByPath = (board: PlaitBoard, target: MindElement, path: Path) => {\n    const fakeDropNodeG = createG();\n    const parent = PlaitNode.get(board, Path.parent(path)) as MindElement;\n    const layout = MindQueries.getLayoutByElement(parent) as MindLayoutType;\n    const isHorizontal = isHorizontalLayout(layout);\n    const { hasNextNode, hasPreviousNode } = getPreviousAndNextByPath(parent, target, path);\n    const width = 30;\n    const height = 12;\n    let fakeNode: MindNode, centerPoint: Point, basicNode: MindNode, linkDirection: LayoutDirection;\n\n    if (!hasPreviousNode && !hasNextNode) {\n        const parentNode = MindElement.getNode(parent);\n        const parentRect = getRectangleByNode(parentNode);\n\n        linkDirection = getLayoutDirection(parentNode, isHorizontal);\n        basicNode = parentNode;\n\n        const placement: PointPlacement = [HorizontalPlacement.right, VerticalPlacement.middle];\n        transformPlacement(placement, linkDirection);\n        const parentCenterPoint = getPointByPlacement(parentRect, placement);\n\n        if (isIndentedLayout(layout)) {\n            const placement: PointPlacement = [\n                HorizontalPlacement.center,\n                isTopLayout(layout) ? VerticalPlacement.top : VerticalPlacement.bottom\n            ];\n            const parentCenterPoint = getPointByPlacement(parentRect, placement);\n\n            centerPoint = moveXOfPoint(parentCenterPoint, height, linkDirection);\n            centerPoint[1] = isTopLayout(layout) ? centerPoint[1] - height : centerPoint[1] + height;\n        } else {\n            centerPoint = moveXOfPoint(parentCenterPoint, width, linkDirection);\n        }\n    } else if (!hasPreviousNode && hasNextNode) {\n        const nextElement = PlaitNode.get(board, path) as MindElement;\n        basicNode = MindElement.getNode(nextElement);\n        const nextRect = getRectangleByNode(basicNode);\n        linkDirection = getLayoutDirection(basicNode, isHorizontal);\n\n        const placement: PointPlacement = [HorizontalPlacement.left, VerticalPlacement.top];\n\n        transformPlacement(placement, linkDirection);\n\n        let offset = -height;\n        if (MindElement.isIndentedLayout(parent)) {\n            offset = isTopLayout(layout) ? offset / 2 + basicNode.height - basicNode.vGap : 0;\n        }\n\n        centerPoint = getPointByPlacement(nextRect, placement);\n        centerPoint = moveYOfPoint(centerPoint, offset, linkDirection);\n    } else if (hasPreviousNode && !hasNextNode) {\n        const previousElement = PlaitNode.get(board, Path.previous(path)) as MindElement;\n        basicNode = MindElement.getNode(previousElement);\n        const previousRect = getRectangleByNode(basicNode);\n        linkDirection = getLayoutDirection(basicNode, isHorizontal);\n\n        const placement: PointPlacement = [HorizontalPlacement.left, VerticalPlacement.bottom];\n\n        transformPlacement(placement, linkDirection);\n\n        let offset = height;\n        if (MindElement.isIndentedLayout(parent)) {\n            offset = isTopLayout(layout) ? -offset - (basicNode.height - basicNode.vGap) : offset;\n        }\n        centerPoint = getPointByPlacement(previousRect, placement);\n        centerPoint = moveYOfPoint(centerPoint, offset, linkDirection);\n    } else {\n        const previousElement = PlaitNode.get(board, Path.previous(path)) as MindElement;\n        basicNode = MindElement.getNode(previousElement);\n        const previousRect = getRectangleByNode(basicNode);\n\n        const nextElement = PlaitNode.get(board, path) as MindElement;\n        const nextNode = MindElement.getNode(nextElement);\n        const nextRect = getRectangleByNode(nextNode);\n\n        const beginPlacement: PointPlacement = [HorizontalPlacement.left, VerticalPlacement.bottom];\n        const endPlacement: PointPlacement = [HorizontalPlacement.left, VerticalPlacement.top];\n        linkDirection = getLayoutDirection(basicNode, isHorizontal);\n\n        transformPlacement(beginPlacement, linkDirection);\n        transformPlacement(endPlacement, linkDirection);\n\n        const previousPoint = getPointByPlacement(previousRect, beginPlacement);\n        const nextPoint = getPointByPlacement(nextRect, endPlacement);\n\n        centerPoint = [(previousPoint[0] + nextPoint[0]) / 2, (previousPoint[1] + nextPoint[1]) / 2];\n    }\n\n    let cornerPoint = centerPoint,\n        oppositePoint = centerPoint;\n\n    const offsetY = isHorizontal ? height : width;\n    const offsetX = isHorizontal ? width : height;\n\n    cornerPoint = moveYOfPoint(cornerPoint, -offsetY / 2, linkDirection!);\n\n    oppositePoint = moveYOfPoint(oppositePoint, offsetY / 2, linkDirection!);\n    oppositePoint = moveXOfPoint(oppositePoint, offsetX, linkDirection!);\n\n    const x = Math.min(cornerPoint[0], oppositePoint[0]);\n    const y = Math.min(cornerPoint[1], oppositePoint[1]);\n\n    fakeNode = {\n        ...basicNode!,\n        x,\n        y,\n        width,\n        height,\n        hGap: MindElement.isIndentedLayout(parent) ? BASE * 4 + (basicNode.origin.strokeWidth || STROKE_WIDTH) : 0,\n        vGap: MindElement.isIndentedLayout(parent) ? BASE : 0\n    };\n\n    const fakeRectangleG = drawRoundRectangle(\n        PlaitBoard.getRoughSVG(board),\n        fakeNode!.x,\n        fakeNode!.y,\n        fakeNode!.x + width,\n        fakeNode!.y + height,\n        {\n            stroke: PRIMARY_COLOR,\n            strokeWidth: 2,\n            fill: PRIMARY_COLOR,\n            fillStyle: 'solid'\n        }\n    );\n    const link = MindElement.isIndentedLayout(parent)\n        ? drawIndentedLink(board, MindElement.getNode(parent), fakeNode!, PRIMARY_COLOR, false, STROKE_WIDTH)\n        : drawLogicLink(board, fakeNode!, MindElement.getNode(parent), isHorizontal, PRIMARY_COLOR, STROKE_WIDTH);\n\n    fakeDropNodeG?.appendChild(link);\n    fakeDropNodeG?.appendChild(fakeRectangleG);\n\n    return fakeDropNodeG;\n};\n\nexport const getPreviousAndNextByPath = (parent: MindElement, target: MindElement, path: Path) => {\n    const children = getNonAbstractChildren(parent);\n    let hasPreviousNode = path[path.length - 1] !== 0;\n    let hasNextNode = path[path.length - 1] !== (children?.length || 0);\n    if (PlaitMind.isMind(parent) && isStandardLayout(getRootLayout(parent))) {\n        const dropStandardRightBottom =\n            target === parent.children[parent.rightNodeCount! - 1] && path[path.length - 1] === parent.rightNodeCount;\n        const dropStandardLeftTop = target === parent.children[parent.rightNodeCount!] && path[path.length - 1] === parent.rightNodeCount;\n        if (dropStandardRightBottom) {\n            hasPreviousNode = true;\n            hasNextNode = false;\n        }\n        if (dropStandardLeftTop) {\n            hasPreviousNode = false;\n            hasNextNode = true;\n        }\n    }\n\n    if (parent.isCollapsed) {\n        hasNextNode = false;\n        hasPreviousNode = false;\n    }\n\n    return {\n        hasPreviousNode,\n        hasNextNode\n    };\n};\n"]}

package/esm2020/utils/index.mjs

@@ -1,13 +1,13 @@
-export * from './graph';
+export * from './position';
 export * from './weak-maps';
 export * from './mind';
 export * from './layout';
+export * from './node';
 export * from './node-style';
 export * from './is-virtual-key';
-export * from './draw-placeholder';
-export * from './direction-detector';
-export * from './direction-corrector';
-export * from './drop-target-corrector';
+export * from './dnd/common';
+export * from './dnd/detector';
+export * from './dnd/draw';
 export * from './abstract/common';
 export * from './abstract/resize';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ncmFwaCc7XG5leHBvcnQgKiBmcm9tICcuL3dlYWstbWFwcyc7XG5leHBvcnQgKiBmcm9tICcuL21pbmQnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlLXN0eWxlJztcbmV4cG9ydCAqIGZyb20gJy4vaXMtdmlydHVhbC1rZXknO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3LXBsYWNlaG9sZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aW9uLWRldGVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aW9uLWNvcnJlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL2Ryb3AtdGFyZ2V0LWNvcnJlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL2Fic3RyYWN0L2NvbW1vbic7XG5leHBvcnQgKiBmcm9tICcuL2Fic3RyYWN0L3Jlc2l6ZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wb3NpdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3dlYWstbWFwcyc7XG5leHBvcnQgKiBmcm9tICcuL21pbmQnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlJztcbmV4cG9ydCAqIGZyb20gJy4vbm9kZS1zdHlsZSc7XG5leHBvcnQgKiBmcm9tICcuL2lzLXZpcnR1YWwta2V5JztcbmV4cG9ydCAqIGZyb20gJy4vZG5kL2NvbW1vbic7XG5leHBvcnQgKiBmcm9tICcuL2RuZC9kZXRlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL2RuZC9kcmF3JztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QvY29tbW9uJztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QvcmVzaXplJztcbiJdfQ==