@xiangfa/mindmap 0.3.0

package/dist/esm/MindMap2.js

@@ -0,0 +1,713 @@
+import { runRenderOverlay as e } from "./plugins/runner.js";
+import { computeEdgePath as t, layoutMultiRoot as n } from "./utils/layout.js";
+import { buildExportSVG as r, buildExportSVGForPNG as i, exportToPNG as a } from "./utils/export.js";
+import { parseMarkdownMultiRoot as o, parseMarkdownWithFrontMatter as s, toMarkdownMultiRoot as c } from "./utils/markdown.js";
+import { detectLocale as ee, resolveMessages as te } from "./utils/i18n.js";
+import { addChildMulti as ne, addChildToSide as re, findSubtreeMulti as ie, generateId as ae, normalizeData as oe, regenerateIds as se, removeNodeMulti as ce } from "./utils/tree-ops.js";
+import { useTheme as le } from "./hooks/useTheme.js";
+import { usePanZoom as ue } from "./hooks/usePanZoom.js";
+import { useDrag as de } from "./hooks/useDrag.js";
+import { useNodeEdit as fe } from "./hooks/useNodeEdit.js";
+import { useNewNodeAnimation as pe } from "./hooks/useNewNodeAnimation.js";
+import { MindMapNode as me } from "./components/MindMapNode.js";
+import { MindMapControls as he } from "./components/MindMapControls.js";
+import { MindMapContextMenu as ge } from "./components/MindMapContextMenu.js";
+/* empty css        */
+import { forwardRef as l, useCallback as u, useEffect as d, useImperativeHandle as _e, useMemo as f, useRef as p, useState as m } from "react";
+import { Fragment as ve, jsx as h, jsxs as g } from "react/jsx-runtime";
+//#region src/components/MindMap/MindMap.tsx
+function ye(e, t) {
+	let n = URL.createObjectURL(e), r = document.createElement("a");
+	r.href = n, r.download = t, document.body.appendChild(r), r.click(), document.body.removeChild(r), URL.revokeObjectURL(n);
+}
+var _ = l(function({ data: l, markdown: _, defaultDirection: be = "both", theme: xe = "auto", locale: Se, messages: Ce, readonly: v = !1, toolbar: y = !0, onDataChange: we, onEvent: Te, plugins: Ee }, De) {
+	let Oe = p(null), b = p(null), x = Ee && Ee.length > 0 ? Ee : void 0, ke = f(() => {
+		if (l || _ === void 0) return null;
+		if (x) {
+			let e = s(_, x), t = e.frontMatter.direction, n = e.frontMatter.theme;
+			return {
+				roots: e.roots,
+				direction: t === "left" || t === "right" || t === "both" ? t : void 0,
+				theme: n === "light" || n === "dark" || n === "auto" ? n : void 0
+			};
+		}
+		return {
+			roots: o(_),
+			direction: void 0,
+			theme: void 0
+		};
+	}, []), [S, C] = m(() => l ? oe(l) : ke ? ke.roots : [{
+		id: "md-0",
+		text: "Root"
+	}]), [w, Ae] = m(() => ke?.direction ?? be), [T, E] = m({}), [D, O] = m(null), [k, je] = m(null), [Me, Ne] = m({}), Pe = p(null), [Fe, Ie] = m("view"), [Le, Re] = m(!1), [ze, A] = m(""), [Be, Ve] = m(null), [He, Ue] = m({}), [We, Ge] = m(null), [Ke, qe] = m(() => ke?.theme);
+	d(() => {
+		l && C(oe(l));
+	}, [l]), d(() => {
+		if (_ !== void 0) if (x) {
+			let { roots: e, frontMatter: t } = s(_, x);
+			if (C(e), t.direction) {
+				let e = t.direction;
+				(e === "left" || e === "right" || e === "both") && Ae(e);
+			}
+			if (t.theme) {
+				let e = t.theme;
+				(e === "light" || e === "dark" || e === "auto") && qe(e);
+			}
+		} else C(o(_));
+	}, [_, x]);
+	let j = u((e) => {
+		C((t) => {
+			let n = e(t);
+			return we?.(n), n;
+		});
+	}, [we]), Je = p(Te);
+	Je.current = Te;
+	let M = u((e) => {
+		Je.current?.(e);
+	}, []), N = le(Ke ?? xe), P = f(() => te(Se ?? ee(), Ce), [Se, Ce]), Ye = f(() => y === !1 ? { zoom: !1 } : y === !0 || y === void 0 ? { zoom: !0 } : { zoom: y.zoom ?? !0 }, [y]), { nodes: F, edges: I } = f(() => n(S, w, Me, T, x, v, He), [
+		S,
+		w,
+		Me,
+		T,
+		x,
+		v,
+		He
+	]);
+	d(() => {
+		let e = {}, t = !1;
+		for (let n of F) n.depth === 1 && !Me[n.id] && (e[n.id] = n.color, t = !0);
+		t && Ne((t) => ({
+			...t,
+			...e
+		}));
+	}, [F, Me]);
+	let L = f(() => {
+		let e = {};
+		for (let t of F) e[t.id] = t;
+		return e;
+	}, [F]), Xe = f(() => {
+		if (!We) return {};
+		let e = {}, t = [];
+		for (let e of F) e.parentId === We && t.push({
+			id: e.id,
+			depth: 1
+		});
+		for (; t.length > 0;) {
+			let { id: n, depth: r } = t.shift();
+			e[n] = r * 100;
+			for (let e of F) e.parentId === n && t.push({
+				id: e.id,
+				depth: r + 1
+			});
+		}
+		return e;
+	}, [We, F]), { pan: R, setPan: z, zoom: B, setZoom: V, animateTo: H, autoFit: Ze, zoomIn: Qe, zoomOut: $e, contentCenter: et, panToNode: tt } = ue(b, F), { draggingCanvas: nt, floatingNodeId: U, floatingPos: W, floatingSubtreeIds: G, didDragRef: K, handleCanvasMouseDown: rt, handleMouseMove: it, handleMouseUp: at, handleNodeMouseDown: ot } = de({
+		svgRef: b,
+		zoom: B,
+		pan: R,
+		setPan: z,
+		setZoom: V,
+		nodeMap: L,
+		nodes: F,
+		updateData: j,
+		direction: w,
+		splitIndices: T,
+		setSplitIndices: E,
+		mapData: S,
+		contentCenter: et
+	}), { editingId: st, editText: ct, setEditText: q, pendingEditId: J, setPendingEditId: Y, handleNodeDoubleClick: lt, commitEdit: ut, cancelEdit: dt } = fe({
+		nodeMap: L,
+		updateData: j,
+		onTextChange: (e, t, n) => {
+			M({
+				type: "nodeTextChange",
+				nodeId: e,
+				oldText: t,
+				newText: n
+			});
+		}
+	}), ft = pe(F), [X, pt] = m(!1);
+	d(() => {
+		if (U || J) return;
+		let e = Ze();
+		e ? X ? (V(e.zoom), z({
+			x: e.panX,
+			y: e.panY
+		})) : (V(e.zoom * .92), z({
+			x: e.panX,
+			y: e.panY
+		}), requestAnimationFrame(() => {
+			pt(!0), H(e.zoom, e.panX, e.panY);
+		})) : X || requestAnimationFrame(() => pt(!0));
+	}, [
+		F,
+		Ze,
+		U,
+		J,
+		V,
+		z,
+		X,
+		H
+	]), d(() => {
+		J && L[J] && tt(J);
+	}, [
+		J,
+		L,
+		tt
+	]);
+	let mt = u((e) => {
+		je(null), rt(e);
+	}, [rt]), ht = u((e, t) => {
+		e.stopPropagation(), K.current || (O(t), M({
+			type: "nodeSelect",
+			nodeId: t
+		}));
+	}, [K, M]), gt = u(() => {
+		K.current || (O(null), M({
+			type: "nodeSelect",
+			nodeId: null
+		}));
+	}, [K, M]), _t = u((e) => {
+		e.preventDefault(), e.stopPropagation();
+		let t = Oe.current;
+		if (!t) return;
+		let n = t.getBoundingClientRect();
+		je({
+			x: e.clientX - n.left,
+			y: e.clientY - n.top
+		});
+	}, []), Z = u(() => {
+		je(null);
+	}, []), vt = u((e) => {
+		if (!e) {
+			Ve(null);
+			return;
+		}
+		let t = L[e];
+		if (!t || !t.remark) {
+			Ve(null);
+			return;
+		}
+		let n = b.current;
+		if (!n) return;
+		let r = n.getBoundingClientRect(), i = (t.x + t.width / 2) * B + R.x, a = (t.y - t.height / 2) * B + R.y;
+		Ve({
+			nodeId: e,
+			text: t.remark,
+			x: Math.min(i, r.width - 300),
+			y: a - 8
+		});
+	}, [
+		L,
+		B,
+		R
+	]), yt = u((e, t, n) => {
+		if (e.stopPropagation(), v) return;
+		let r = ae(), i = {
+			id: r,
+			text: P.newNode
+		};
+		S.some((e) => e.id === t) && n && w === "both" ? j((e) => e.map((e) => {
+			if (e.id !== t) return e;
+			let r = e.children || [], a = T[t] ?? Math.ceil(r.length / 2), o = a, s = r.length - a, c = n;
+			n === "right" && o >= 3 * Math.max(s, 1) ? c = "left" : n === "left" && s >= 3 * Math.max(o, 1) && (c = "right");
+			let ee = re(e, i, c, a);
+			return E((e) => ({
+				...e,
+				[t]: ee.newSplitIndex
+			})), ee.data;
+		})) : j((e) => ne(e, t, i)), M({
+			type: "nodeAdd",
+			node: i,
+			parentId: t
+		}), Y(r), q("");
+	}, [
+		j,
+		S,
+		w,
+		T,
+		Y,
+		q,
+		P,
+		v,
+		M
+	]), bt = u(() => {
+		if (v) return;
+		let e = ae(), t = {
+			id: e,
+			text: P.newNode
+		};
+		j((e) => [...e, t]), M({
+			type: "nodeAdd",
+			node: t,
+			parentId: null
+		}), Y(e), q(""), Z();
+	}, [
+		j,
+		Z,
+		Y,
+		q,
+		P,
+		v,
+		M
+	]), xt = u(() => {
+		let e = r(F, I, {}, N, x);
+		ye(new Blob([e], { type: "image/svg+xml;charset=utf-8" }), "mindmap.svg"), Z();
+	}, [
+		F,
+		I,
+		N,
+		Z,
+		x
+	]), St = u(async () => {
+		ye(await a(i(F, I, { pngSafe: !0 }, N, x)), "mindmap.png"), Z();
+	}, [
+		F,
+		I,
+		N,
+		Z,
+		x
+	]), Ct = u(() => {
+		let e = c(S, x);
+		ye(new Blob([e], { type: "text/markdown;charset=utf-8" }), "mindmap.md"), Z();
+	}, [
+		S,
+		Z,
+		x
+	]), Q = u(() => {
+		let e = Ze();
+		e && H(e.zoom, e.panX, e.panY);
+	}, [Ze, H]), $ = u((e) => {
+		Ae(e), E({}), M({
+			type: "directionChange",
+			direction: e
+		});
+	}, [M]), wt = u(() => {
+		Ie((e) => {
+			if (e === "view") return A(c(S, x)), M({
+				type: "modeChange",
+				mode: "text"
+			}), "text";
+			{
+				let e = x ? s(ze, x).roots : o(ze);
+				return j(() => e), E({}), M({
+					type: "modeChange",
+					mode: "view"
+				}), "view";
+			}
+		});
+	}, [
+		S,
+		ze,
+		j,
+		x,
+		M
+	]), Tt = u(() => {
+		let e = Oe.current;
+		e && (document.fullscreenElement ? document.exitFullscreen() : e.requestFullscreen());
+	}, []);
+	d(() => {
+		let e = () => {
+			let e = !!document.fullscreenElement;
+			Re(e), M({
+				type: "fullscreenChange",
+				fullscreen: e
+			});
+		};
+		return document.addEventListener("fullscreenchange", e), () => document.removeEventListener("fullscreenchange", e);
+	}, [M]);
+	let Et = p(B);
+	d(() => {
+		B !== Et.current && (Et.current = B, M({
+			type: "zoomChange",
+			zoom: B
+		}));
+	}, [B, M]);
+	let Dt = u((e) => {
+		if (e.key === "Escape" && k) {
+			e.preventDefault(), Z();
+			return;
+		}
+		if (st) return;
+		let t = e.metaKey || e.ctrlKey;
+		if (e.shiftKey && !t) {
+			if (e.code === "Equal") {
+				e.preventDefault(), Qe();
+				return;
+			}
+			if (e.code === "Minus") {
+				e.preventDefault(), $e();
+				return;
+			}
+			if (e.code === "Digit0") {
+				e.preventDefault(), Q();
+				return;
+			}
+			if (e.code === "KeyL") {
+				e.preventDefault(), $("left");
+				return;
+			}
+			if (e.code === "KeyR") {
+				e.preventDefault(), $("right");
+				return;
+			}
+			if (e.code === "KeyM") {
+				e.preventDefault(), $("both");
+				return;
+			}
+		}
+		if (e.key === "Enter" && !t && D && !v) {
+			e.preventDefault();
+			let t = ae(), n = {
+				id: t,
+				text: P.newNode
+			};
+			S.some((e) => e.id === D) && w === "both" ? j((e) => e.map((e) => {
+				if (e.id !== D) return e;
+				let t = e.children || [], r = re(e, n, "right", T[D] ?? Math.ceil(t.length / 2));
+				return E((e) => ({
+					...e,
+					[D]: r.newSplitIndex
+				})), r.data;
+			})) : j((e) => ne(e, D, n)), Y(t), q(""), M({
+				type: "nodeAdd",
+				node: n,
+				parentId: D
+			});
+			return;
+		}
+		if ((e.key === "Delete" || e.key === "Backspace") && D && !v) {
+			if (e.preventDefault(), S.some((e) => e.id === D) && S.length <= 1) return;
+			M({
+				type: "nodeDelete",
+				nodeId: D
+			}), j((e) => ce(e, D)), O(null);
+			return;
+		}
+		if (t && e.key === "c" && D) {
+			e.preventDefault(), Pe.current = ie(S, D);
+			return;
+		}
+		if (t && e.key === "x" && D && !v) {
+			if (e.preventDefault(), Pe.current = ie(S, D), S.some((e) => e.id === D) && S.length <= 1) return;
+			M({
+				type: "nodeDelete",
+				nodeId: D
+			}), j((e) => ce(e, D)), O(null);
+			return;
+		}
+		if (t && e.key === "v" && D && Pe.current && !v) {
+			e.preventDefault();
+			let t = se(Pe.current);
+			j((e) => ne(e, D, t)), M({
+				type: "nodeAdd",
+				node: t,
+				parentId: D
+			});
+			return;
+		}
+	}, [
+		st,
+		D,
+		S,
+		w,
+		T,
+		j,
+		k,
+		Z,
+		Y,
+		q,
+		P,
+		Qe,
+		$e,
+		Q,
+		$,
+		v,
+		M
+	]);
+	_e(De, () => ({
+		exportToSVG() {
+			return r(F, I, {}, N, x);
+		},
+		async exportToPNG() {
+			return a(i(F, I, {}, N, x));
+		},
+		exportToOutline() {
+			return c(S, x);
+		},
+		getData() {
+			return S;
+		},
+		setData(e) {
+			C(oe(e)), E({});
+		},
+		setMarkdown(e) {
+			C(x ? s(e, x).roots : o(e)), E({});
+		},
+		fitView() {
+			Q();
+		},
+		setDirection(e) {
+			$(e);
+		}
+	}), [
+		F,
+		I,
+		S,
+		x,
+		Q,
+		$,
+		N
+	]), d(() => {
+		if (!k) return;
+		let e = () => Z();
+		return window.addEventListener("click", e), () => window.removeEventListener("click", e);
+	}, [k, Z]);
+	let Ot = u((e) => {
+		if (e.key !== "Tab") return;
+		e.preventDefault();
+		let t = e.currentTarget, { selectionStart: n, selectionEnd: r, value: i } = t;
+		if (e.shiftKey) {
+			let e = i.lastIndexOf("\n", n - 1) + 1;
+			if (n === r) {
+				let a = i.slice(e, r), o = a.match(/^ {1,2}/);
+				if (!o) return;
+				let s = o[0].length;
+				A(i.slice(0, e) + a.slice(s) + i.slice(r)), requestAnimationFrame(() => {
+					t.selectionStart = t.selectionEnd = Math.max(e, n - s);
+				});
+			} else {
+				let a = i.slice(e, r).split("\n"), o = 0, s = 0, c = a.map((e, t) => {
+					let n = e.match(/^ {1,2}/), r = n ? n[0].length : 0;
+					return o += r, t === 0 && (s = r), e.slice(r);
+				}).join("\n");
+				A(i.slice(0, e) + c + i.slice(r)), requestAnimationFrame(() => {
+					t.selectionStart = n - s, t.selectionEnd = r - o;
+				});
+			}
+		} else if (n === r) A(i.slice(0, n) + "  " + i.slice(r)), requestAnimationFrame(() => {
+			t.selectionStart = t.selectionEnd = n + 2;
+		});
+		else {
+			let e = i.lastIndexOf("\n", n - 1) + 1, a = i.slice(e, r).split("\n"), o = a.map((e) => "  " + e).join("\n");
+			A(i.slice(0, e) + o + i.slice(r)), requestAnimationFrame(() => {
+				t.selectionStart = n + 2, t.selectionEnd = r + a.length * 2;
+			});
+		}
+	}, []);
+	return /* @__PURE__ */ g("div", {
+		ref: Oe,
+		className: "mindmap-container",
+		children: [
+			Fe === "text" && /* @__PURE__ */ h("textarea", {
+				className: "mindmap-text-editor",
+				value: ze,
+				onChange: (e) => A(e.target.value),
+				onKeyDown: Ot,
+				readOnly: v,
+				style: {
+					background: N.canvas.bgColor,
+					color: N.node.textColor,
+					opacity: v ? .7 : 1
+				}
+			}),
+			/* @__PURE__ */ h("svg", {
+				ref: b,
+				className: `mindmap-svg ${nt ? "dragging-canvas" : ""} ${U ? "dragging-node" : ""}`,
+				style: {
+					background: N.canvas.bgColor,
+					display: Fe === "text" ? "none" : "block"
+				},
+				tabIndex: 0,
+				onMouseDown: mt,
+				onMouseMove: it,
+				onMouseUp: at,
+				onMouseLeave: at,
+				onClick: gt,
+				onKeyDown: Dt,
+				onContextMenu: _t,
+				children: /* @__PURE__ */ g("g", {
+					className: "mindmap-canvas",
+					transform: `translate(${R.x}, ${R.y}) scale(${B})`,
+					opacity: X ? 1 : 0,
+					style: { transition: X ? "opacity 0.4s ease-out" : "none" },
+					children: [
+						/* @__PURE__ */ g("g", {
+							className: "mindmap-edges",
+							children: [I.some((e) => e.isCrossLink) && /* @__PURE__ */ h("defs", { children: /* @__PURE__ */ h("marker", {
+								id: "mindmap-arrowhead",
+								markerWidth: "8",
+								markerHeight: "6",
+								refX: "8",
+								refY: "3",
+								orient: "auto",
+								children: /* @__PURE__ */ h("path", {
+									d: "M0,0 L8,3 L0,6",
+									fill: "none",
+									stroke: "currentColor",
+									strokeWidth: 1.5
+								})
+							}) }), I.map((e) => {
+								let t = Xe[e.toId], n = t !== void 0;
+								return /* @__PURE__ */ g("g", { children: [/* @__PURE__ */ h("path", {
+									d: e.path,
+									stroke: e.color,
+									strokeWidth: N.connection.strokeWidth,
+									strokeLinecap: "round",
+									strokeDasharray: n ? void 0 : e.strokeDasharray,
+									markerEnd: e.isCrossLink ? "url(#mindmap-arrowhead)" : void 0,
+									opacity: e.isCrossLink ? .7 : 1,
+									fill: "none",
+									className: [
+										"mindmap-edge",
+										e.isCrossLink ? "mindmap-edge-cross-link" : "",
+										n ? "mindmap-edge-expanding" : nt || G.has(e.fromId) || G.has(e.toId) ? "" : "mindmap-edge-animated"
+									].filter(Boolean).join(" "),
+									style: n ? { animationDelay: `${t}ms` } : void 0
+								}), e.label && (() => {
+									let t = L[e.fromId], n = L[e.toId];
+									return !t || !n ? null : /* @__PURE__ */ h("text", {
+										className: "mindmap-edge-label",
+										x: (t.x + n.x) / 2,
+										y: (t.y + n.y) / 2 - 6,
+										textAnchor: "middle",
+										fontSize: 11,
+										fill: e.color,
+										opacity: .8,
+										fontFamily: N.node.fontFamily,
+										style: { pointerEvents: "none" },
+										children: e.label
+									});
+								})()] }, e.key);
+							})]
+						}),
+						/* @__PURE__ */ h("g", {
+							className: "mindmap-nodes",
+							children: F.map((e) => {
+								let t = G.has(e.id), n = t || nt ? "" : "mindmap-node-animated";
+								return /* @__PURE__ */ h(me, {
+									node: e,
+									isEditing: st === e.id,
+									isPendingEdit: J === e.id,
+									isSelected: D === e.id,
+									isNew: ft.has(e.id),
+									isGhost: t,
+									animClass: n,
+									editText: ct,
+									theme: N,
+									direction: w,
+									onMouseDown: ot,
+									onClick: ht,
+									onDoubleClick: v ? () => {} : lt,
+									onEditChange: q,
+									onEditCommit: ut,
+									onEditCancel: dt,
+									onAddChild: yt,
+									onRemarkHover: vt,
+									onFoldToggle: x ? (e) => {
+										He[e] || (Ge(e), setTimeout(() => Ge(null), 800)), Ue((t) => ({
+											...t,
+											[e]: !t[e]
+										}));
+									} : void 0,
+									expandDelay: Xe[e.id],
+									readonly: v,
+									plugins: x
+								}, e.id);
+							})
+						}),
+						U && W && (() => {
+							let e = L[U];
+							if (!e) return null;
+							let n = W.x - e.x, r = W.y - e.y, i = e.parentId ? L[e.parentId] : null;
+							return /* @__PURE__ */ g(ve, { children: [i && /* @__PURE__ */ h("path", {
+								className: "mindmap-floating-edge",
+								d: t(i.x, i.y, i.width, W.x, W.y, e.width, e.side),
+								stroke: e.color,
+								strokeWidth: N.connection.strokeWidth,
+								strokeLinecap: "round",
+								fill: "none",
+								style: { pointerEvents: "none" }
+							}), /* @__PURE__ */ g("g", {
+								className: "mindmap-floating",
+								transform: `translate(${n}, ${r})`,
+								style: { pointerEvents: "none" },
+								children: [I.filter((e) => G.has(e.fromId) && G.has(e.toId)).map((e) => /* @__PURE__ */ h("path", {
+									className: "mindmap-floating-edge",
+									d: e.path,
+									stroke: e.color,
+									strokeWidth: N.connection.strokeWidth,
+									strokeLinecap: "round",
+									fill: "none"
+								}, `fl-${e.key}`)), F.filter((e) => G.has(e.id)).map((e) => /* @__PURE__ */ h(me, {
+									node: e,
+									isEditing: !1,
+									isPendingEdit: !1,
+									isSelected: !1,
+									isNew: !1,
+									animClass: "",
+									editText: "",
+									theme: N,
+									direction: w,
+									onMouseDown: () => {},
+									onClick: () => {},
+									onDoubleClick: () => {},
+									onEditChange: () => {},
+									onEditCommit: () => {},
+									onEditCancel: () => {},
+									onAddChild: () => {},
+									readonly: !0
+								}, `fl-${e.id}`))]
+							})] });
+						})(),
+						x && e(x, F, I, N).map((e, t) => /* @__PURE__ */ h("g", {
+							className: "mindmap-plugin-overlay",
+							children: e
+						}, `plugin-overlay-${t}`))
+					]
+				})
+			}),
+			/* @__PURE__ */ h(he, {
+				zoom: B,
+				theme: N,
+				messages: P,
+				showZoom: Ye.zoom,
+				mode: Fe,
+				isFullscreen: Le,
+				onZoomIn: Qe,
+				onZoomOut: $e,
+				onAutoFit: Q,
+				onModeToggle: wt,
+				onFullscreenToggle: Tt
+			}),
+			k && /* @__PURE__ */ h(ge, {
+				position: k,
+				theme: N,
+				messages: P,
+				direction: w,
+				readonly: v,
+				onNewRootNode: bt,
+				onExportSVG: xt,
+				onExportPNG: St,
+				onExportMarkdown: Ct,
+				onDirectionChange: $,
+				onClose: Z
+			}),
+			Be && /* @__PURE__ */ h("div", {
+				className: "mindmap-remark-tooltip",
+				style: {
+					left: Be.x,
+					top: Be.y,
+					transform: "translateY(-100%)",
+					background: N.contextMenu.bgColor,
+					color: N.contextMenu.textColor,
+					borderColor: N.contextMenu.borderColor,
+					border: `1px solid ${N.contextMenu.borderColor}`
+				},
+				children: Be.text
+			})
+		]
+	});
+});
+//#endregion
+export { _ as MindMap };