codoc-cli 0.1.2

package/dist/services/conversion/confluenceToMarkdown/preprocess/macro-converters.js

@@ -0,0 +1,68 @@
+import { escapeAttr, escapeXml } from "../../shared/xml-escaping.js";
+import { macroParam, macroRegex } from "../../shared/read-storage-format.js";
+import { preserveAsSentinel } from "../../shared/preserved-macros.js";
+import { JIRA_KEY_PATTERN } from "../../shared/jira.js";
+//#region src/services/conversion/confluenceToMarkdown/preprocess/macro-converters.ts
+const JIRA_BROWSE_KEY_RE = new RegExp(`/browse/(${JIRA_KEY_PATTERN})`, "i");
+const STATUS_COLOURS = {
+	grey: {
+		bg: "#DFE1E6",
+		fg: "#42526E"
+	},
+	red: {
+		bg: "#FFEBE6",
+		fg: "#BF2600"
+	},
+	yellow: {
+		bg: "#FFF0B3",
+		fg: "#172B4D"
+	},
+	green: {
+		bg: "#E3FCEF",
+		fg: "#006644"
+	},
+	blue: {
+		bg: "#DEEBFF",
+		fg: "#0747A6"
+	},
+	purple: {
+		bg: "#EAE6FF",
+		fg: "#403294"
+	}
+};
+function statusStyle(colour) {
+	const c = STATUS_COLOURS[colour.trim().toLowerCase()] ?? STATUS_COLOURS.grey;
+	return `background-color:${c.bg};color:${c.fg};padding:2px 6px;border-radius:3px;font-weight:bold`;
+}
+function convertStatusMacros(html) {
+	return html.replace(/<ac:structured-macro[^>]*ac:name="status"[^>]*>([\s\S]*?)<\/ac:structured-macro>/g, (_, inner) => {
+		const title = macroParam(inner, "title") ?? "";
+		const colour = macroParam(inner, "colou?r") ?? "Grey";
+		return `<span data-confluence-status="${escapeAttr(colour)}" style="${statusStyle(colour)}">${escapeXml(title)}</span>`;
+	});
+}
+function preserveDrawioMacros(html) {
+	html = html.replace(/<ac:adf-extension[\s\S]*?<\/ac:adf-extension>/g, (m) => preserveAsSentinel(m));
+	html = html.replace(macroRegex("drawio"), (m) => preserveAsSentinel(m));
+	return html;
+}
+function convertJiraElements(html, jiraBase) {
+	html = html.replace(/<a\s[^>]*?href="([^"]+)"[^>]*?data-card-appearance="block"[^>]*?>[\s\S]*?<\/a>|<a\s[^>]*?data-card-appearance="block"[^>]*?href="([^"]+)"[^>]*?>[\s\S]*?<\/a>/g, (_, url1, url2) => `<a href="${url1 || url2}">Tableau Jira</a>`);
+	html = html.replace(/<a([^>]*)data-card-appearance="inline"([^>]*)>[\s\S]*?<\/a>/gi, (_, before, after) => {
+		const url = (before + after).match(/href="([^"]+)"/)?.[1] ?? "";
+		return `<a href="${url}">${url.match(JIRA_BROWSE_KEY_RE)?.[1] ?? url}</a>`;
+	});
+	html = html.replace(/<ac:structured-macro[^>]*ac:name="jira"[^>]*>([\s\S]*?)<\/ac:structured-macro>/g, (_, inner) => {
+		const key = macroParam(inner, "key") ?? "";
+		if (!key) return "";
+		return `<a href="${jiraBase ? `${jiraBase}/browse/${key}` : `#${key}`}">${key}</a>`;
+	});
+	return html;
+}
+function richMacroToBlockquote(type, inner) {
+	const title = macroParam(inner, "title") ?? "";
+	const body = inner.match(/<ac:rich-text-body>([\s\S]*?)<\/ac:rich-text-body>/)?.[1] ?? "";
+	return `<blockquote data-macro-type="${type}"${title ? ` data-macro-title="${title.replace(/"/g, "&quot;")}"` : ""}>${body}</blockquote>`;
+}
+//#endregion
+export { convertJiraElements, convertStatusMacros, preserveDrawioMacros, richMacroToBlockquote };

package/dist/services/conversion/confluenceToMarkdown/preprocess/preprocess.js

@@ -0,0 +1,113 @@
+import { escapeXml } from "../../shared/xml-escaping.js";
+import { EMBEDDED_ATTACHMENT_PATTERNS, renderAttachmentTag } from "../../shared/image-attachments.js";
+import { findDivEnd, macroParam } from "../../shared/read-storage-format.js";
+import { RICH_BODY_MACRO_TYPES_PATTERN } from "../../shared/macro-types.js";
+import { preserveAsSentinel } from "../../shared/preserved-macros.js";
+import { convertJiraElements, convertStatusMacros, preserveDrawioMacros, richMacroToBlockquote } from "./macro-converters.js";
+//#region src/services/conversion/confluenceToMarkdown/preprocess/preprocess.ts
+function convertTaskLists(html) {
+	const convertInnermostLevel = (h) => h.replace(/<ac:task-list[^>]*>((?:(?!<ac:task-list)[\s\S])*?)<\/ac:task-list>/g, (_, content) => {
+		const entries = [];
+		const taskRe = /<ac:task[^>]*>([\s\S]*?)<\/ac:task>/g;
+		let m;
+		while ((m = taskRe.exec(content)) !== null) {
+			const inner = m[1];
+			const status = inner.match(/<ac:task-status>(\w+)<\/ac:task-status>/)?.[1] ?? "incomplete";
+			const body = (inner.match(/<ac:task-body>([\s\S]*?)<\/ac:task-body>/)?.[1] ?? "").replace(/<(?!\/?div\b)[^>]+>/g, "").trim();
+			entries.push({
+				pos: m.index,
+				kind: "task",
+				status,
+				body
+			});
+		}
+		let searchStart = 0;
+		while (true) {
+			const idx = content.indexOf("<div data-ac-task-list", searchStart);
+			if (idx === -1) break;
+			const closeEnd = findDivEnd(content, idx);
+			entries.push({
+				pos: idx,
+				kind: "sub",
+				html: content.slice(idx, closeEnd)
+			});
+			searchStart = closeEnd;
+		}
+		entries.sort((a, b) => a.pos - b.pos);
+		const items = [];
+		for (let i = 0; i < entries.length; i++) {
+			const e = entries[i];
+			if (e.kind !== "task") continue;
+			let subHtml = "";
+			if (i + 1 < entries.length && entries[i + 1].kind === "sub") {
+				subHtml = entries[i + 1].html;
+				i++;
+			}
+			items.push(`<div data-ac-task="1" data-status="${e.status}">${e.body}${subHtml}</div>`);
+		}
+		return `<div data-ac-task-list="1">\n${items.join("\n")}\n</div>`;
+	});
+	let prev = "";
+	let cur = html;
+	while (prev !== cur) {
+		prev = cur;
+		cur = convertInnermostLevel(cur);
+	}
+	return cur;
+}
+function stripGeneratedBanner(html) {
+	html = html.replace(/<ac:structured-macro[^>]*ac:name="info"[^>]*>[\s\S]*?Généré le[\s\S]*?<\/ac:structured-macro>/g, "");
+	return html.replace(/<ac:structured-macro[^>]*ac:name="toc"[^>]*\/>|<ac:structured-macro[^>]*ac:name="toc"[^>]*>[\s\S]*?<\/ac:structured-macro>/g, "");
+}
+function convertTimeElements(html) {
+	html = html.replace(/<time[^>]*datetime="([^"]+)"[^>]*>[\s\S]*?<\/time>/g, (_, dt) => `📅 ${dt}`);
+	html = html.replace(/<time[^>]*datetime="([^"]+)"[^>]*\/>/g, (_, dt) => `📅 ${dt}`);
+	html = html.replace(/<time[^>]*>[\s\S]*?<\/time>/g, "");
+	return html.replace(/<time[^>]*\/>/g, "");
+}
+const RICH_BODY_MACRO_RE = new RegExp(`<ac:structured-macro[^>]*ac:name="(${RICH_BODY_MACRO_TYPES_PATTERN})"[^>]*>([\\s\\S]*?)<\\/ac:structured-macro>`, "g");
+function convertRichBodyMacros(html) {
+	return html.replace(RICH_BODY_MACRO_RE, (_, type, inner) => richMacroToBlockquote(type, inner));
+}
+function convertCodeMacros(html) {
+	return html.replace(/<ac:structured-macro[^>]*ac:name="code"[^>]*>([\s\S]*?)<\/ac:structured-macro>/g, (_, inner) => {
+		const lang = macroParam(inner, "language") ?? "";
+		const unescaped = (inner.match(/<!\[CDATA\[([\s\S]*?)\]\]>/)?.[1] ?? "").replace(/\]\]>\s*<!\[CDATA\[>/g, "]]>");
+		return `<pre><code${lang ? ` class="language-${lang}"` : ""}>${escapeXml(unescaped)}</code></pre>`;
+	});
+}
+function convertImages(html, imgRelPath) {
+	for (const pattern of EMBEDDED_ATTACHMENT_PATTERNS) html = html.replace(pattern, (_, rawFilename) => renderAttachmentTag(rawFilename, imgRelPath));
+	return html.replace(/<ac:image[^>]*>[\s\S]*?<ri:url[^>]*ri:value="([^"]+)"[^>]*\/>[\s\S]*?<\/ac:image>/g, (_, url) => `<img src="${url}" alt="">`);
+}
+function collapseSingleParagraphCells(html) {
+	return html.replace(/<(th|td)([^>]*)>\s*<p[^>]*>([\s\S]*?)<\/p>\s*<\/(th|td)>/gi, (match, open, attrs, content, close) => open.toLowerCase() === close.toLowerCase() ? `<${open}${attrs}>${content}</${close}>` : match);
+}
+function preserveUnknownMacros(html) {
+	return html.replace(/<ac:structured-macro[\s\S]*?<\/ac:structured-macro>/g, (m) => preserveAsSentinel(m));
+}
+function stripFinalArtifacts(html) {
+	html = html.replace(/\s+(?:local-id|ac:local-id|data-table-width|data-layout|data-card-appearance|data-datasource)="[^"]*"/g, "");
+	html = html.replace(/<hr[^>]+>/g, "<hr/>");
+	html = html.replace(/<\/?ac:[a-z-]+(?:\s[^>]*)?\/?>/g, "");
+	return html.replace(/<\/?ri:[a-z-]+(?:\s[^>]*)?\/?>/g, "");
+}
+function preprocessStorage(xml, imgRelPath, baseUrl) {
+	const jiraBase = baseUrl ? baseUrl.replace(/\/wiki\/?$/, "").replace(/\/$/, "") : "";
+	return [
+		stripGeneratedBanner,
+		convertTaskLists,
+		preserveDrawioMacros,
+		(html) => convertJiraElements(html, jiraBase),
+		convertTimeElements,
+		convertRichBodyMacros,
+		convertStatusMacros,
+		convertCodeMacros,
+		(html) => convertImages(html, imgRelPath),
+		collapseSingleParagraphCells,
+		preserveUnknownMacros,
+		stripFinalArtifacts
+	].reduce((html, step) => step(html), xml);
+}
+//#endregion
+export { convertTaskLists, preprocessStorage };

package/dist/services/conversion/confluenceToMarkdown/turndown.js

@@ -0,0 +1,71 @@
+import "../shared/preserved-macros.js";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+//#region src/services/conversion/confluenceToMarkdown/turndown.ts
+let cached;
+/** Instance mémoïsée : TurndownService + ses règles n'ont pas d'état entre deux `.turndown()`. */
+function buildTurndown() {
+	if (cached) return cached;
+	const td = new TurndownService({
+		headingStyle: "atx",
+		codeBlockStyle: "fenced",
+		bulletListMarker: "-",
+		hr: "---",
+		fence: "```"
+	});
+	td.use(gfm);
+	td.addRule("underline", {
+		filter: ["u"],
+		replacement: (content) => `<u>${content}</u>`
+	});
+	td.addRule("video", {
+		filter: ["video"],
+		replacement: (_content, node) => `<video src="${node.getAttribute("src") ?? ""}" controls></video>`
+	});
+	td.addRule("color-span", {
+		filter: (node) => node.nodeName === "SPAN" && /\bcolor\b/.test(node.getAttribute("style") ?? ""),
+		replacement: (content, node) => `<span style="${node.getAttribute("style") ?? ""}">${content}</span>`
+	});
+	td.addRule("confluence-status", {
+		filter: (node) => node.nodeName === "SPAN" && !!node.getAttribute("data-confluence-status"),
+		replacement: (content, node) => {
+			return `<span data-confluence-status="${node.getAttribute("data-confluence-status") ?? "Grey"}" style="${node.getAttribute("style") ?? ""}">${content}</span>`;
+		}
+	});
+	td.addRule("confluence-task-list", {
+		filter: (node) => node.nodeName === "DIV" && !!node.getAttribute("data-ac-task-list"),
+		replacement: (content) => `\n\n${content.trim()}\n\n`
+	});
+	td.addRule("confluence-task-item", {
+		filter: (node) => node.nodeName === "DIV" && !!node.getAttribute("data-ac-task"),
+		replacement: (content, node) => {
+			const checkbox = node.getAttribute("data-status") === "complete" ? "[x]" : "[ ]";
+			const trimmed = content.replace(/^\n+|\n+$/g, "");
+			const nestedIdx = trimmed.search(/\n\n-\s+\[/);
+			if (nestedIdx === -1) return `\n- ${checkbox} ${trimmed}`;
+			return `\n- ${checkbox} ${trimmed.slice(0, nestedIdx).trim()}${"\n" + trimmed.slice(nestedIdx).trimStart().replace(/^/gm, "  ")}`;
+		}
+	});
+	td.addRule("confluence-macro-blockquote", {
+		filter: (node) => node.nodeName === "BLOCKQUOTE" && !!node.getAttribute("data-macro-type"),
+		replacement: (content, node) => {
+			const type = node.getAttribute("data-macro-type") ?? "";
+			const title = node.getAttribute("data-macro-title") ?? "";
+			return `\n\n> ${title ? `[${type} ${title}]` : `[${type}]`}\n>\n${content.replace(/^\n+|\n+$/g, "").replace(/^/gm, "> ")}\n\n`;
+		}
+	});
+	td.addRule("confluence-preserved-macro", {
+		filter: (node) => node.nodeName === "DIV" && !!node.getAttribute("data-confluence-macro-preserved"),
+		replacement: (_content, node) => {
+			return `\n\n<div data-confluence-macro="${Buffer.from(node.textContent ?? "", "utf-8").toString("base64")}"></div>\n\n`;
+		}
+	});
+	td.addRule("empty-wrapper", {
+		filter: (node) => ["DIV", "SPAN"].includes(node.nodeName) && !node.getAttribute("data-type") && node.textContent.trim() === "",
+		replacement: () => ""
+	});
+	cached = td;
+	return td;
+}
+//#endregion
+export { buildTurndown };

package/dist/services/conversion/markdownToConfluence/conversion-state.js

@@ -0,0 +1,18 @@
+//#region src/services/conversion/markdownToConfluence/conversion-state.ts
+let convCtx = {};
+let taskIdCounter = 0;
+function beginConversion(options) {
+	convCtx = options;
+	taskIdCounter = 0;
+}
+function endConversion() {
+	convCtx = {};
+}
+function conversionOptions() {
+	return convCtx;
+}
+function nextTaskId() {
+	return ++taskIdCounter;
+}
+//#endregion
+export { beginConversion, conversionOptions, endConversion, nextTaskId };

package/dist/services/conversion/markdownToConfluence/diagrams/mermaid-diagrams.js

@@ -0,0 +1,56 @@
+import { escapeXml } from "../../shared/xml-escaping.js";
+import { preserveAsSentinel } from "../../shared/preserved-macros.js";
+import { structuredMacro } from "../../shared/confluence-macro-builder.js";
+import { toGitlabFileUrl } from "../../shared/gitlab-url.js";
+import { mermaidToDrawio } from "./mermaid-to-drawio.js";
+//#region src/services/conversion/markdownToConfluence/diagrams/mermaid-diagrams.ts
+/** Macro draw.io référençant `filename` - diagramName ET attachment doivent porter le nom exact, sinon « fichier introuvable ». */
+function buildDrawioMacro(filename, cfg) {
+	const params = [
+		["diagramName", escapeXml(filename)],
+		["attachment", escapeXml(filename)],
+		["pageSize", "false"]
+	];
+	if (cfg.width) params.push(["width", String(cfg.width)]);
+	return structuredMacro(cfg.macroName, {
+		schemaVersion: true,
+		params
+	});
+}
+/** Blocs ```mermaid → macro draw.io (sentinelle) dans le markdown + fichiers .drawio à uploader. */
+function manageMermaidsInMarkdownFile(markdown, diagramBaseName, cfg, sourceFile, gitlab) {
+	const matches = [...markdown.matchAll(/```mermaid\r?\n([\s\S]*?)```/g)];
+	if (!matches.length) return {
+		markdown,
+		attachments: []
+	};
+	const attachments = [];
+	const parts = [];
+	let last = 0;
+	for (let i = 0; i < matches.length; i++) {
+		const m = matches[i];
+		const diagramName = matches.length === 1 ? diagramBaseName : `${diagramBaseName}-${i + 1}`;
+		const filename = `${diagramName}.drawio`;
+		const mermaidSrc = m[1].replace(/<a href='([^']*)'>/g, (_full, href) => `<a href='${toGitlabFileUrl(href, sourceFile, gitlab)}'>`);
+		const content = mermaidToDrawio(mermaidSrc, diagramName, {
+			edgeStyle: cfg.edgeStyle,
+			edgeAnchor: cfg.edgeAnchor,
+			colWidth: cfg.colWidth,
+			rowStep: cfg.rowStep
+		});
+		attachments.push({
+			filename,
+			content
+		});
+		const sentinel = preserveAsSentinel(buildDrawioMacro(filename, cfg));
+		parts.push(markdown.slice(last, m.index), `\n\n${sentinel}\n\n`);
+		last = m.index + m[0].length;
+	}
+	parts.push(markdown.slice(last));
+	return {
+		markdown: parts.join(""),
+		attachments
+	};
+}
+//#endregion
+export { manageMermaidsInMarkdownFile };

package/dist/services/conversion/markdownToConfluence/diagrams/mermaid-to-drawio.js

@@ -0,0 +1,331 @@
+import { escapeAttr } from "../../shared/xml-escaping.js";
+//#region src/services/conversion/markdownToConfluence/diagrams/mermaid-to-drawio.ts
+const RE_DIRECTION = /^(?:graph|flowchart)\s+(LR|RL|TB|TD|BT)/;
+const RE_SUBGRAPH = /^subgraph\s+(\w+)(?:\["([^"]*)"\])?/;
+const RE_NODE_STADIUM = /^(\w+)\(\["([\s\S]*)"\]\)$/;
+const RE_NODE_RECT = /^(\w+)\["([\s\S]*)"\]$/;
+const RE_EDGE = /^(\w+)\s*-->\s*(\w+)$/;
+const RE_CLICK = /^click\s+(\w+)\s+href\s+"([^"]+)"/;
+const RE_STYLE = /^style\s+(\w+)\s+(.+)$/;
+const RE_CLASS_DEF = /^classDef\s+(\w+)\s+(.+)$/;
+const RE_CLASS = /^class\s+([\w,\s]+)\s+(\w+)\s*;?$/;
+/** Extrait `fill` et `stroke` d'une chaîne de directive style (`fill:#xxx,stroke:#yyy,…`). */
+function parseFillStroke(directive) {
+	return {
+		fill: directive.match(/fill:\s*([^,;]+)/)?.[1]?.trim(),
+		stroke: directive.match(/stroke:\s*([^,;]+)/)?.[1]?.trim()
+	};
+}
+function parseMermaid(mermaid) {
+	const groups = [];
+	const nodes = [];
+	const edges = [];
+	const links = /* @__PURE__ */ new Map();
+	const styles = /* @__PURE__ */ new Map();
+	const classDefs = /* @__PURE__ */ new Map();
+	const nodeClasses = /* @__PURE__ */ new Map();
+	const nodeById = /* @__PURE__ */ new Map();
+	let direction = "LR";
+	let currentGroup = -1;
+	for (const raw of mermaid.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("```") || line.startsWith("%%")) continue;
+		if (line.startsWith("direction ")) continue;
+		const dir = line.match(RE_DIRECTION);
+		if (dir) {
+			direction = dir[1];
+			continue;
+		}
+		if (line.startsWith("graph ") || line.startsWith("flowchart ")) continue;
+		const sg = line.match(RE_SUBGRAPH);
+		if (sg) {
+			currentGroup = groups.length;
+			groups.push({
+				id: sg[1],
+				title: sg[2] ?? sg[1]
+			});
+			continue;
+		}
+		if (line === "end") {
+			currentGroup = -1;
+			continue;
+		}
+		const click = line.match(RE_CLICK);
+		if (click) {
+			links.set(click[1], click[2]);
+			continue;
+		}
+		const cdef = line.match(RE_CLASS_DEF);
+		if (cdef) {
+			classDefs.set(cdef[1], parseFillStroke(cdef[2]));
+			continue;
+		}
+		const cls = line.match(RE_CLASS);
+		if (cls) {
+			const className = cls[2];
+			for (const id of cls[1].split(",").map((s) => s.trim()).filter(Boolean)) nodeClasses.set(id, className);
+			continue;
+		}
+		const st = line.match(RE_STYLE);
+		if (st) {
+			styles.set(st[1], parseFillStroke(st[2]));
+			continue;
+		}
+		const edge = line.match(RE_EDGE);
+		if (edge) {
+			edges.push([edge[1], edge[2]]);
+			continue;
+		}
+		const stadium = line.match(RE_NODE_STADIUM);
+		const rect = stadium ? null : line.match(RE_NODE_RECT);
+		const m = stadium ?? rect;
+		if (m) {
+			const node = {
+				id: m[1],
+				label: m[2],
+				shape: stadium ? "stadium" : "rect",
+				group: currentGroup
+			};
+			nodes.push(node);
+			nodeById.set(node.id, node);
+		}
+	}
+	for (const [id, url] of links) {
+		const n = nodeById.get(id);
+		if (n) n.link = url;
+	}
+	for (const n of nodes) {
+		const inline = styles.get(n.id);
+		const className = nodeClasses.get(n.id);
+		const fromClass = className ? classDefs.get(className) : void 0;
+		n.fill = inline?.fill ?? fromClass?.fill;
+		n.stroke = inline?.stroke ?? fromClass?.stroke;
+	}
+	const known = new Set(nodes.map((n) => n.id));
+	return {
+		groups,
+		nodes,
+		edges: edges.filter(([a, b]) => known.has(a) && known.has(b)),
+		direction
+	};
+}
+const DEFAULT_LAYOUT = {
+	colWidth: 480,
+	rowStep: 110,
+	nodeWidth: 280,
+	nodeHeight: 60,
+	edgeStyle: "curved",
+	edgeAnchor: "side"
+};
+const TITLE_HEIGHT = 30;
+const MARGIN = 40;
+/** Listes d'adjacence (parents / enfants) du graphe, restreintes aux nœuds connus. */
+function buildAdjacency(nodes, edges) {
+	const idSet = new Set(nodes.map((n) => n.id));
+	const preds = new Map(nodes.map((n) => [n.id, []]));
+	const succs = new Map(nodes.map((n) => [n.id, []]));
+	for (const [from, to] of edges) {
+		if (!idSet.has(from) || !idSet.has(to)) continue;
+		succs.get(from).push(to);
+		preds.get(to).push(from);
+	}
+	return {
+		preds,
+		succs
+	};
+}
+/** Retire les clés `undefined` pour qu'elles n'écrasent pas les valeurs de DEFAULT_LAYOUT au merge. */
+function cleanLayout(layout) {
+	return Object.fromEntries(Object.entries(layout).filter(([, v]) => v !== void 0));
+}
+/** Niveau de chaque nœud = max(niveaux parents)+1 (0 si racine). Cycles détectés par DFS et ignorés pour garder la cascade gauche→droite. */
+function assignLevels(nodes, preds, succs) {
+	const backEdges = /* @__PURE__ */ new Set();
+	const state = /* @__PURE__ */ new Map();
+	const visit = (u) => {
+		state.set(u, 0);
+		for (const v of succs.get(u) ?? []) {
+			const s = state.get(v);
+			if (s === 0) backEdges.add(`${u}->${v}`);
+			else if (s === void 0) visit(v);
+		}
+		state.set(u, 1);
+	};
+	const isRoot = (id) => (preds.get(id)?.length ?? 0) === 0;
+	for (const n of nodes) if (isRoot(n.id) && !state.has(n.id)) visit(n.id);
+	for (const n of nodes) if (!state.has(n.id)) visit(n.id);
+	const level = /* @__PURE__ */ new Map();
+	const levelOf = (id) => {
+		const cached = level.get(id);
+		if (cached !== void 0) return cached;
+		let maxParent = -1;
+		for (const p of preds.get(id) ?? []) {
+			if (backEdges.has(`${p}->${id}`)) continue;
+			maxParent = Math.max(maxParent, levelOf(p));
+		}
+		const lv = maxParent + 1;
+		level.set(id, lv);
+		return lv;
+	};
+	for (const n of nodes) levelOf(n.id);
+	return level;
+}
+/** Ordonne verticalement chaque colonne pour limiter les croisements (méthode barycentrique, 2 passes aller-retour). */
+function orderColumns(columns, preds, succs, level) {
+	const maxLevel = columns.length - 1;
+	const order = /* @__PURE__ */ new Map();
+	columns.forEach((col) => col.forEach((id, i) => order.set(id, i)));
+	const barycenter = (id, neighbors, atLevel) => {
+		const ns = neighbors.filter((n) => level.get(n) === atLevel);
+		return ns.length ? ns.reduce((s, n) => s + order.get(n), 0) / ns.length : order.get(id);
+	};
+	const sortColumn = (l, adjacency, atLevel) => {
+		columns[l].sort((a, b) => barycenter(a, adjacency.get(a), atLevel) - barycenter(b, adjacency.get(b), atLevel));
+		columns[l].forEach((id, i) => order.set(id, i));
+	};
+	for (let pass = 0; pass < 2; pass++) {
+		for (let l = 1; l <= maxLevel; l++) sortColumn(l, preds, l - 1);
+		for (let l = maxLevel - 1; l >= 0; l--) sortColumn(l, succs, l + 1);
+	}
+}
+/** Mode subgraphs : une colonne par subgraph, cases empilées dans l'ordre. */
+function columnPositions(nodes, lo) {
+	const positions = /* @__PURE__ */ new Map();
+	const rowInGroup = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const gi = node.group >= 0 ? node.group : 0;
+		const row = rowInGroup.get(gi) ?? 0;
+		rowInGroup.set(gi, row + 1);
+		positions.set(node.id, {
+			x: MARGIN + gi * lo.colWidth,
+			y: 70 + row * lo.rowStep
+		});
+	}
+	return positions;
+}
+/** Mode cascade : placement par niveaux (parents à gauche, enfants à droite en LR). */
+function levelPositions(nodes, edges, direction, lo) {
+	if (!nodes.length) return /* @__PURE__ */ new Map();
+	const { preds, succs } = buildAdjacency(nodes, edges);
+	const level = assignLevels(nodes, preds, succs);
+	const maxLevel = Math.max(0, ...level.values());
+	const columns = Array.from({ length: maxLevel + 1 }, () => []);
+	for (const n of nodes) columns[level.get(n.id)].push(n.id);
+	orderColumns(columns, preds, succs, level);
+	const horizontal = direction === "LR" || direction === "RL";
+	const reverse = direction === "RL" || direction === "BT";
+	const mainStep = horizontal ? lo.colWidth : lo.rowStep;
+	const crossStep = horizontal ? lo.rowStep : lo.colWidth;
+	const crossCenter = horizontal ? 400 : 600;
+	const positions = /* @__PURE__ */ new Map();
+	for (let l = 0; l <= maxLevel; l++) {
+		const col = columns[l];
+		const span = (col.length - 1) * crossStep;
+		const mainIdx = reverse ? maxLevel - l : l;
+		col.forEach((id, i) => {
+			const main = MARGIN + mainIdx * mainStep;
+			const cross = crossCenter + i * crossStep - span / 2;
+			positions.set(id, horizontal ? {
+				x: main,
+				y: cross
+			} : {
+				x: cross,
+				y: main
+			});
+		});
+	}
+	return positions;
+}
+/** Tracé (routage) de la flèche selon le style choisi. */
+function edgeRouting(kind) {
+	const arrow = "html=1;endArrow=block;orthogonalLoop=1;jettySize=auto;";
+	switch (kind) {
+		case "straight": return arrow;
+		case "orthogonal": return `edgeStyle=orthogonalEdgeStyle;rounded=1;${arrow}`;
+		default: return `edgeStyle=orthogonalEdgeStyle;curved=1;${arrow}`;
+	}
+}
+/** Points d'ancrage sortie/entrée : "auto" = flottant, "side" = côtés alignés au flux (inversé en RL/BT). */
+function edgeAnchorStyle(anchor, direction) {
+	if (anchor !== "side") return "";
+	const horizontal = direction === "LR" || direction === "RL";
+	const reverse = direction === "RL" || direction === "BT";
+	let exit;
+	let entry;
+	if (horizontal) {
+		exit = reverse ? [0, .5] : [1, .5];
+		entry = reverse ? [1, .5] : [0, .5];
+	} else {
+		exit = reverse ? [.5, 0] : [.5, 1];
+		entry = reverse ? [.5, 1] : [.5, 0];
+	}
+	return `exitX=${exit[0]};exitY=${exit[1]};exitPerimeter=0;entryX=${entry[0]};entryY=${entry[1]};entryPerimeter=0;`;
+}
+function styleFor(node) {
+	const base = "whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontSize=11;";
+	const rounded = node.shape === "stadium" ? "rounded=1;arcSize=50;" : "rounded=0;";
+	if (node.fill) return `${rounded}${base}fillColor=${node.fill};strokeColor=${node.stroke ?? "#666666"};`;
+	return `${rounded}${base}`;
+}
+function nodeCell(node, pos, lo) {
+	const geo = `<mxGeometry x="${pos.x}" y="${pos.y}" width="${lo.nodeWidth}" height="${lo.nodeHeight}" as="geometry" />`;
+	const style = styleFor(node);
+	const label = escapeAttr(node.label);
+	if (node.link) return [
+		`        <UserObject label="${label}" link="${escapeAttr(node.link)}" id="${node.id}">`,
+		`          <mxCell style="${style}" vertex="1" parent="1">`,
+		`            ${geo}`,
+		`          </mxCell>`,
+		`        </UserObject>`
+	].join("\n");
+	return [
+		`        <mxCell id="${node.id}" value="${label}" style="${style}" vertex="1" parent="1">`,
+		`          ${geo}`,
+		`        </mxCell>`
+	].join("\n");
+}
+function titleCell(group, gi, lo) {
+	return [
+		`        <mxCell id="title_${group.id}" value="${escapeAttr(group.title)}" style="text;html=1;fontStyle=1;fontSize=14;align=center;verticalAlign=middle;" vertex="1" parent="1">`,
+		`          <mxGeometry x="${MARGIN + gi * lo.colWidth}" y="0" width="${lo.nodeWidth}" height="${TITLE_HEIGHT}" as="geometry" />`,
+		`        </mxCell>`
+	].join("\n");
+}
+function edgeCell(source, target, i, style) {
+	return [
+		`        <mxCell id="e${i}" style="${style}" edge="1" parent="1" source="${source}" target="${target}">`,
+		`          <mxGeometry relative="1" as="geometry" />`,
+		`        </mxCell>`
+	].join("\n");
+}
+function mermaidToDrawio(mermaid, diagramName = "diagram", layout = {}) {
+	const lo = {
+		...DEFAULT_LAYOUT,
+		...cleanLayout(layout)
+	};
+	const { groups, nodes, edges, direction } = parseMermaid(mermaid);
+	const positions = groups.length ? columnPositions(nodes, lo) : levelPositions(nodes, edges, direction, lo);
+	const cells = [];
+	if (groups.length) groups.forEach((g, gi) => cells.push(titleCell(g, gi, lo)));
+	for (const node of nodes) cells.push(nodeCell(node, positions.get(node.id) ?? {
+		x: MARGIN,
+		y: MARGIN
+	}, lo));
+	const edgeStyle = edgeRouting(lo.edgeStyle) + edgeAnchorStyle(lo.edgeAnchor, direction);
+	edges.forEach(([a, b], i) => cells.push(edgeCell(a, b, i, edgeStyle)));
+	return [
+		`<mxfile host="app.diagrams.net" type="device">`,
+		`  <diagram id="${escapeAttr(diagramName)}" name="${escapeAttr(diagramName)}">`,
+		`    <mxGraphModel dx="1200" dy="800" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="826" math="0" shadow="0">`,
+		`      <root>`,
+		`        <mxCell id="0" />`,
+		`        <mxCell id="1" parent="0" />`,
+		cells.join("\n"),
+		`      </root>`,
+		`    </mxGraphModel>`,
+		`  </diagram>`,
+		`</mxfile>`
+	].join("\n");
+}
+//#endregion
+export { mermaidToDrawio };