codoc-cli 0.1.2

package/dist/services/conversion/markdownToConfluence/index.js

@@ -0,0 +1,48 @@
+import { escapeXml } from "../shared/xml-escaping.js";
+import { structuredMacro } from "../shared/confluence-macro-builder.js";
+import { beginConversion, endConversion } from "./conversion-state.js";
+import { renderTokens } from "./render/blocks.js";
+import { manageMermaidsInMarkdownFile } from "./diagrams/mermaid-diagrams.js";
+import { buildConfluencePage } from "./render/page.js";
+import { marked } from "marked";
+//#region src/services/conversion/markdownToConfluence/index.ts
+/** 📅 YYYY-MM-DD → <time datetime="YYYY-MM-DD"/>. */
+function restoreSpecialElements(xml) {
+	return xml.replace(/📅\s*(\d{4}-\d{2}-\d{2})/g, (_, date) => `<time datetime="${date}"/>`);
+}
+function restoreStatusMacros(xml) {
+	return xml.replace(/<span[^>]*\sdata-confluence-status="([^"]*)"[^>]*>([\s\S]*?)<\/span>/gi, (_, colour, inner) => {
+		const title = inner.replace(/<[^>]+>/g, "").trim();
+		return structuredMacro("status", {
+			schemaVersion: true,
+			params: [["title", escapeXml(title)], ["colour", escapeXml(colour)]]
+		});
+	});
+}
+function cleanup(xml) {
+	return xml.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/<p>\s*<\/p>/g, "").trim();
+}
+function convertMarkdownToConfluence(markdown, options) {
+	beginConversion(options ?? {});
+	try {
+		const tokens = marked.lexer(markdown, { gfm: true });
+		return restoreSpecialElements(restoreStatusMacros(cleanup(renderTokens(tokens))));
+	} finally {
+		endConversion();
+	}
+}
+/** Sens publish : Markdown → page Confluence (Storage Format + pièces jointes). */
+function renderConfluencePage(markdown, options) {
+	const { markdown: processed, attachments } = manageMermaidsInMarkdownFile(markdown, options.diagramBaseName, options.drawio, options.sourceFile, options.gitlab);
+	const body = convertMarkdownToConfluence(processed, {
+		sourceFile: options.sourceFile,
+		jira: options.jira,
+		gitlab: options.gitlab
+	});
+	return {
+		xml: buildConfluencePage(body, options.generatedAt, options.generateSummary),
+		attachments
+	};
+}
+//#endregion
+export { convertMarkdownToConfluence, renderConfluencePage };

package/dist/services/conversion/markdownToConfluence/languages.js

@@ -0,0 +1,66 @@
+//#region src/services/conversion/markdownToConfluence/languages.ts
+const CONFLUENCE_LANGUAGES = /* @__PURE__ */ new Set([
+	"actionscript3",
+	"bash",
+	"csharp",
+	"coldfusion",
+	"cpp",
+	"css",
+	"delphi",
+	"diff",
+	"erlang",
+	"groovy",
+	"html",
+	"java",
+	"javafx",
+	"javascript",
+	"json",
+	"lua",
+	"none",
+	"perl",
+	"php",
+	"powershell",
+	"python",
+	"ruby",
+	"scala",
+	"sql",
+	"vbnet",
+	"xml",
+	"yaml"
+]);
+const LANGUAGE_MAP = {
+	ts: "javascript",
+	tsx: "javascript",
+	typescript: "javascript",
+	jsx: "javascript",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	sh: "bash",
+	shell: "bash",
+	zsh: "bash",
+	fish: "bash",
+	htm: "html",
+	svg: "xml",
+	yml: "yaml",
+	cs: "csharp",
+	"c#": "csharp",
+	vb: "vbnet",
+	"c++": "cpp",
+	c: "cpp",
+	jsonc: "json",
+	text: "none",
+	plaintext: "none",
+	txt: "none",
+	console: "bash",
+	terminal: "bash"
+};
+/** Normalise un langage Markdown vers un langage supporté par la macro code (sinon "none"). */
+function confluenceLanguage(lang) {
+	if (!lang) return "none";
+	const normalized = lang.trim().toLowerCase();
+	const mapped = LANGUAGE_MAP[normalized] ?? normalized;
+	return CONFLUENCE_LANGUAGES.has(mapped) ? mapped : "none";
+}
+//#endregion
+export { confluenceLanguage };

package/dist/services/conversion/markdownToConfluence/links.js

@@ -0,0 +1,40 @@
+import { escapeAttr, escapeXml } from "../shared/xml-escaping.js";
+import { JIRA_KEY_RE } from "../shared/jira.js";
+import { structuredMacro } from "../shared/confluence-macro-builder.js";
+import { conversionOptions } from "./conversion-state.js";
+import { toGitlabFileUrl } from "../shared/gitlab-url.js";
+//#region src/services/conversion/markdownToConfluence/links.ts
+function resolveHref(href, title) {
+	if (/^https?:\/\/|^mailto:|^#/.test(href)) return href;
+	const sourceFile = conversionOptions().sourceFile;
+	if (!sourceFile) return href;
+	let withFragment = href;
+	if (!href.includes("#") && title) {
+		const lineMatch = title.match(/^L(\d+)$/);
+		if (lineMatch) withFragment = `${href}#L${lineMatch[1]}`;
+	}
+	return toGitlabFileUrl(withFragment, sourceFile, conversionOptions().gitlab);
+}
+function buildJiraMacro(key, href) {
+	const jira = conversionOptions().jira;
+	if (!jira?.serverId && !jira?.server) return `<a href="${escapeAttr(href)}">${escapeXml(key)}</a>`;
+	const params = [["key", escapeXml(key)]];
+	if (jira.serverId) params.push(["serverId", escapeXml(jira.serverId)]);
+	if (jira.server) params.push(["server", escapeXml(jira.server)]);
+	return structuredMacro("jira", {
+		schemaVersion: true,
+		params
+	});
+}
+const USER_MENTION_SCHEME = "user:";
+function emitConfluenceLink(rawHref, detectText, labelHtml, title) {
+	if (detectText.includes("Tableau Jira")) return `<a href="${escapeAttr(resolveHref(rawHref, title))}" data-card-appearance="block"></a>`;
+	if (JIRA_KEY_RE.test(detectText.trim()) && /\/browse\//i.test(rawHref)) return buildJiraMacro(detectText.trim(), rawHref);
+	if (rawHref.toLowerCase().startsWith(USER_MENTION_SCHEME)) {
+		const accountId = rawHref.slice(5);
+		return `<ac:link><ri:user ri:account-id="${escapeAttr(accountId)}" /></ac:link>`;
+	}
+	return `<a href="${escapeAttr(resolveHref(rawHref, title))}">${labelHtml}</a>`;
+}
+//#endregion
+export { buildJiraMacro, emitConfluenceLink };

package/dist/services/conversion/markdownToConfluence/raw-html/raw-html.js

@@ -0,0 +1,86 @@
+import { escapeXml, unescapeXml } from "../../shared/xml-escaping.js";
+import { findDivEnd } from "../../shared/read-storage-format.js";
+import { RICH_BODY_MACRO_TYPES_PATTERN } from "../../shared/macro-types.js";
+import { JIRA_KEY_PATTERN } from "../../shared/jira.js";
+import { confluenceLanguage } from "../languages.js";
+import { buildJiraMacro } from "../links.js";
+import { taskListDivToXml } from "./task-lists.js";
+//#region src/services/conversion/markdownToConfluence/raw-html/raw-html.ts
+const RAW_JIRA_LINK_RE = new RegExp(`<a\\s+href="([^"]*/browse/(${JIRA_KEY_PATTERN})[^"]*)"[^>]*>([^<]*)</a>`, "gi");
+const RAW_BLOCKQUOTE_MACRO_RE = new RegExp(`<blockquote([^>]*)data-macro-type="(${RICH_BODY_MACRO_TYPES_PATTERN})"([^>]*)>([\\s\\S]*?)</blockquote>`, "gi");
+function expandTaskListDivs(html) {
+	if (!html.includes("data-ac-task-list")) return html;
+	const parts = [];
+	let pos = 0;
+	while (pos < html.length) {
+		const idx = html.indexOf("<div data-ac-task-list", pos);
+		if (idx === -1) {
+			parts.push(html.slice(pos));
+			break;
+		}
+		parts.push(html.slice(pos, idx));
+		const end = findDivEnd(html, idx);
+		parts.push(taskListDivToXml(html.slice(idx, end)));
+		pos = end;
+	}
+	return parts.join("");
+}
+function restorePreservedMacros(html) {
+	let s = html;
+	if (s.includes("data-confluence-macro=")) s = s.replace(/<div[^>]*\sdata-confluence-macro="([^"]*)"[^>]*>\s*<\/div>/gi, (_, b64) => Buffer.from(b64, "base64").toString("utf-8"));
+	if (s.includes("data-confluence-macro-preserved")) s = s.replace(/<div[^>]*data-confluence-macro-preserved[^>]*>([\s\S]*?)<\/div>/gi, (_, escaped) => unescapeXml(escaped));
+	return s;
+}
+const stripHtmlComments = (s) => s.replace(/<!--[\s\S]*?-->/g, "");
+function rawBlockquotesToMacros(s) {
+	return s.replace(RAW_BLOCKQUOTE_MACRO_RE, (fullMatch, _before, type, _after, content) => {
+		const title = fullMatch.match(/data-macro-title="([^"]*)"/i)?.[1]?.trim() ?? "";
+		const lines = [`<ac:structured-macro ac:name="${type}">`];
+		if (title) lines.push(`  <ac:parameter ac:name="title">${escapeXml(title)}</ac:parameter>`);
+		lines.push(`  <ac:rich-text-body>${content}</ac:rich-text-body>`);
+		lines.push(`</ac:structured-macro>`);
+		return lines.join("\n");
+	});
+}
+function rawJiraLinksToMacros(s) {
+	return s.replace(RAW_JIRA_LINK_RE, (full, url, key, text) => text.trim() === key ? buildJiraMacro(key, url) : full);
+}
+function rawLocalImagesToAttachments(s) {
+	return s.replace(/<img\s[^>]*src="(?!https?:\/\/)([^"]+)"[^>]*\/?>/gi, (_, src) => {
+		return `<ac:image><ri:attachment ri:filename="${src.split("/").pop() ?? src}" /></ac:image>`;
+	});
+}
+const rawExternalImagesToUrls = (s) => s.replace(/<img\s[^>]*src="(https?:\/\/[^"]+)"[^>]*\/?>/gi, (_, url) => `<ac:image><ri:url ri:value="${url}" /></ac:image>`);
+function rawCodeBlocksToMacros(s) {
+	return s.replace(/<pre><code(?:\s+class="language-([^"]+)")?>([\s\S]*?)<\/code><\/pre>/gi, (_, lang, code) => {
+		const cfLang = confluenceLanguage(lang);
+		const decoded = unescapeXml(code);
+		const lines = [`<ac:structured-macro ac:name="code">`];
+		if (cfLang && cfLang !== "none") lines.push(`  <ac:parameter ac:name="language">${cfLang}</ac:parameter>`);
+		lines.push(`  <ac:plain-text-body><![CDATA[${decoded}]]></ac:plain-text-body>`);
+		lines.push(`</ac:structured-macro>`);
+		return lines.join("\n");
+	});
+}
+const stripUnsupportedTags = (s) => s.replace(/<\/?(div|section|article|aside|header|footer|main|nav|details|summary|figure|figcaption|template|time|mark|ruby|rp|rt)[^>]*>/gi, "");
+const stripNonColorSpans = (s) => s.replace(/<span(?![^>]*\bcolor\b)[^>]*>([\s\S]*?)<\/span>/gi, "$1").replace(/<span(?![^>]*\bcolor\b)[^>]*>/gi, "");
+const stripProprietaryAttributes = (s) => s.replace(/\s+(?:local-id|ac:local-id|data-(?!(?:card-appearance|layout|confluence-status)\b)[\w-]+)="[^"]*"/gi, "");
+const RAW_HTML_STEPS = [
+	stripHtmlComments,
+	rawBlockquotesToMacros,
+	rawJiraLinksToMacros,
+	rawLocalImagesToAttachments,
+	rawExternalImagesToUrls,
+	rawCodeBlocksToMacros,
+	stripUnsupportedTags,
+	stripNonColorSpans,
+	stripProprietaryAttributes
+];
+function sanitizeRawHtml(html) {
+	let processed = expandTaskListDivs(html);
+	processed = restorePreservedMacros(processed);
+	for (const step of RAW_HTML_STEPS) processed = step(processed);
+	return processed.trim();
+}
+//#endregion
+export { sanitizeRawHtml };

package/dist/services/conversion/markdownToConfluence/raw-html/task-lists.js

@@ -0,0 +1,59 @@
+import { findDivEnd } from "../../shared/read-storage-format.js";
+import { nextTaskId } from "../conversion-state.js";
+//#region src/services/conversion/markdownToConfluence/raw-html/task-lists.ts
+function emitTask(id, status, body) {
+	return [
+		`<ac:task>`,
+		`  <ac:task-id>${id}</ac:task-id>`,
+		`  <ac:task-status>${status}</ac:task-status>`,
+		`  <ac:task-body><span class="placeholder-inline-tasks">${body}</span></ac:task-body>`,
+		`</ac:task>`
+	].join("\n");
+}
+function taskListDivToXml(html) {
+	const openEnd = html.indexOf(">");
+	if (openEnd === -1) return html;
+	const lastClose = html.lastIndexOf("</div>");
+	const inner = html.slice(openEnd + 1, lastClose < 0 ? html.length : lastClose);
+	const parts = [];
+	let pos = 0;
+	while (pos < inner.length) {
+		const divIdx = inner.indexOf("<div", pos);
+		if (divIdx === -1) break;
+		const tagEnd = inner.indexOf(">", divIdx);
+		if (tagEnd === -1) break;
+		const tag = inner.slice(divIdx, tagEnd + 1);
+		const end = findDivEnd(inner, divIdx);
+		if (tag.includes("data-ac-task-list")) parts.push(taskListDivToXml(inner.slice(divIdx, end)));
+		else if (tag.includes("data-ac-task")) parts.push(taskDivToXml(inner.slice(divIdx, end)));
+		pos = end;
+	}
+	return `<ac:task-list>\n${parts.join("\n")}\n</ac:task-list>`;
+}
+function taskDivToXml(html) {
+	const status = html.match(/data-status="(\w+)"/)?.[1] ?? "incomplete";
+	const openEnd = html.indexOf(">");
+	const lastClose = html.lastIndexOf("</div>");
+	const inner = html.slice(openEnd + 1, lastClose < 0 ? html.length : lastClose);
+	const taskId = nextTaskId();
+	let bodyText = "";
+	const subListsXml = [];
+	let pos = 0;
+	let textStart = 0;
+	while (pos < inner.length) {
+		const subIdx = inner.indexOf("<div data-ac-task-list", pos);
+		if (subIdx === -1) break;
+		const textBefore = inner.slice(textStart, subIdx).replace(/<[^>]+>/g, "").trim();
+		if (textBefore) bodyText += (bodyText ? " " : "") + textBefore;
+		const subEnd = findDivEnd(inner, subIdx);
+		subListsXml.push(taskListDivToXml(inner.slice(subIdx, subEnd)));
+		pos = subEnd;
+		textStart = subEnd;
+	}
+	const remaining = inner.slice(textStart).replace(/<[^>]+>/g, "").trim();
+	if (remaining) bodyText += (bodyText ? " " : "") + remaining;
+	const taskXml = emitTask(taskId, status, bodyText);
+	return subListsXml.length > 0 ? taskXml + "\n" + subListsXml.join("\n") : taskXml;
+}
+//#endregion
+export { emitTask, taskListDivToXml };

package/dist/services/conversion/markdownToConfluence/render/blocks.js

@@ -0,0 +1,171 @@
+import { log } from "../../../log/logger.js";
+import { escapeCdata, escapeXml } from "../../shared/xml-escaping.js";
+import { RICH_BODY_MACRO_TYPES_PATTERN } from "../../shared/macro-types.js";
+import { structuredMacro } from "../../shared/confluence-macro-builder.js";
+import { nextTaskId } from "../conversion-state.js";
+import { confluenceLanguage } from "../languages.js";
+import { emitConfluenceLink } from "../links.js";
+import { emitTask } from "../raw-html/task-lists.js";
+import { sanitizeRawHtml } from "../raw-html/raw-html.js";
+import { fromMarked, renderInline, renderInlineImage, renderInlineToken } from "./inline.js";
+import { marked } from "marked";
+//#region src/services/conversion/markdownToConfluence/render/blocks.ts
+const BLOCKQUOTE_MACRO_TYPE_RE = new RegExp(`^\\[(${RICH_BODY_MACRO_TYPES_PATTERN})(?: ([^\\n\\]]+))?\\]\\s*\\n?([\\s\\S]*)$`);
+function renderTokens(tokens) {
+	return tokens.map(renderBlock).filter(Boolean).join("\n");
+}
+function renderBlock(token) {
+	switch (token.type) {
+		case "space": return "";
+		case "text": {
+			const t = token;
+			return t.tokens?.length ? `<p>${renderInline(t.tokens)}</p>` : `<p>${fromMarked(t.text)}</p>`;
+		}
+		case "heading": return renderHeading(token);
+		case "paragraph": return renderParagraph(token);
+		case "list": return renderList(token);
+		case "code": return renderCode(token);
+		case "blockquote": return renderBlockquote(token);
+		case "table": return renderTable(token);
+		case "hr": return "<hr/>";
+		case "html": return sanitizeRawHtml(token.text);
+		default:
+			log.warning0(`Unsupported block token: ${token.type}`);
+			return "";
+	}
+}
+function renderHeading(token) {
+	return `<h${token.depth}>${renderInline(token.tokens).trim()}</h${token.depth}>`;
+}
+function renderParagraph(token) {
+	if (token.tokens.length === 1 && token.tokens[0].type === "image") return renderInlineToken(token.tokens[0]);
+	const content = renderInline(token.tokens).trim();
+	return content ? `<p>${content}</p>` : "";
+}
+function renderCode(token) {
+	return structuredMacro("code", {
+		params: [["language", confluenceLanguage(token.lang)], ["linenumbers", "true"]],
+		plainTextBody: escapeCdata(token.text)
+	});
+}
+/** Parse `[info]` / `[note]` / `[warning]` / `[tip]` / `[expand Titre]` en tête de blockquote. */
+function parseBlockquoteMacroHeader(paraText) {
+	const typeMatch = paraText.trim().match(BLOCKQUOTE_MACRO_TYPE_RE);
+	if (!typeMatch) return void 0;
+	return {
+		macroName: typeMatch[1],
+		title: typeMatch[2]?.trim() ?? "",
+		restOfFirstPara: typeMatch[3]?.trim() ?? ""
+	};
+}
+function renderBlockquote(token) {
+	const first = token.tokens[0];
+	const header = first?.type === "paragraph" ? parseBlockquoteMacroHeader(first.text ?? "") : void 0;
+	if (!header) return structuredMacro("info", { richTextBody: renderTokens(token.tokens) });
+	const { macroName, title, restOfFirstPara } = header;
+	const bodyTokens = restOfFirstPara ? [...marked.lexer(restOfFirstPara, { gfm: true }), ...token.tokens.slice(1)] : token.tokens.slice(1);
+	return structuredMacro(macroName, {
+		params: title ? [["title", escapeXml(title)]] : [],
+		richTextBody: renderTokens(bodyTokens)
+	});
+}
+function renderList(token) {
+	if (token.items.some((item) => item.task)) {
+		const output = [];
+		for (const item of token.items) {
+			const status = item.checked ? "complete" : "incomplete";
+			const taskId = nextTaskId();
+			const bodyTokens = [];
+			const subTaskLists = [];
+			for (const t of item.tokens) if (t.type === "list" && t.items.some((i) => i.task)) subTaskLists.push(t);
+			else bodyTokens.push(t);
+			output.push(emitTask(taskId, status, renderListItemInner(bodyTokens).trim()));
+			for (const sub of subTaskLists) output.push(renderList(sub));
+		}
+		return `<ac:task-list>\n${output.join("\n")}\n</ac:task-list>`;
+	}
+	const tag = token.ordered ? "ol" : "ul";
+	return `<${tag}${token.ordered && token.start && token.start !== 1 ? ` start="${token.start}"` : ""}>\n${token.items.map(renderListItem).join("\n")}\n</${tag}>`;
+}
+function renderListItem(item) {
+	const inner = renderListItemInner(item.tokens);
+	return `<li>${item.task ? `${item.checked ? "☑" : "☐"} ${inner}` : inner}</li>`;
+}
+function renderListItemInner(tokens) {
+	return tokens.map((t) => {
+		switch (t.type) {
+			case "paragraph": return renderInline(t.tokens);
+			case "text": {
+				const tt = t;
+				return tt.tokens?.length ? renderInline(tt.tokens) : renderInlineText(tt.text);
+			}
+			case "list": return renderList(t);
+			case "strong":
+			case "em":
+			case "codespan":
+			case "link":
+			case "image": return renderInlineToken(t);
+			default: return renderBlock(t);
+		}
+	}).join("");
+}
+function renderInlineText(text) {
+	let i = 0;
+	const parts = [];
+	while (i < text.length) {
+		if (text[i] === "!" && text[i + 1] === "[") {
+			const endAlt = text.indexOf("]", i + 2);
+			const startUrl = endAlt !== -1 ? text.indexOf("(", endAlt) : -1;
+			const endUrl = startUrl !== -1 ? text.indexOf(")", startUrl) : -1;
+			if (endAlt !== -1 && startUrl === endAlt + 1 && endUrl !== -1) {
+				const alt = text.slice(i + 2, endAlt);
+				const url = text.slice(startUrl + 1, endUrl);
+				parts.push(renderInlineImage({
+					type: "image",
+					href: url,
+					text: alt
+				}));
+				i = endUrl + 1;
+				continue;
+			}
+		}
+		if (text[i] === "[") {
+			const endLabel = text.indexOf("]", i + 1);
+			const startUrl = endLabel !== -1 ? text.indexOf("(", endLabel) : -1;
+			const endUrl = startUrl !== -1 ? text.indexOf(")", startUrl) : -1;
+			if (endLabel !== -1 && startUrl === endLabel + 1 && endUrl !== -1) {
+				const label = text.slice(i + 1, endLabel);
+				const rawUrl = text.slice(startUrl + 1, endUrl);
+				parts.push(emitConfluenceLink(rawUrl, label, escapeXml(label)));
+				i = endUrl + 1;
+				continue;
+			}
+		}
+		parts.push(escapeXml(text[i]));
+		i++;
+	}
+	return parts.join("");
+}
+function alignStyle(align) {
+	return align ? ` style="text-align: ${align};"` : "";
+}
+function renderTable(token) {
+	const parts = ["<table>\n<thead><tr>\n"];
+	for (let i = 0; i < token.header.length; i++) {
+		const align = alignStyle(token.align?.[i] ?? null);
+		parts.push(`<th${align}>${renderInline(token.header[i].tokens)}</th>\n`);
+	}
+	parts.push("</tr></thead>\n<tbody>\n");
+	for (const row of token.rows) {
+		parts.push("<tr>\n");
+		for (let i = 0; i < row.length; i++) {
+			const align = alignStyle(token.align?.[i] ?? null);
+			parts.push(`<td${align}>${renderInline(row[i].tokens)}</td>\n`);
+		}
+		parts.push("</tr>\n");
+	}
+	parts.push("</tbody>\n</table>");
+	return parts.join("");
+}
+//#endregion
+export { renderTokens };

package/dist/services/conversion/markdownToConfluence/render/inline.js

@@ -0,0 +1,44 @@
+import { log } from "../../../log/logger.js";
+import { escapeAttr, escapeXml } from "../../shared/xml-escaping.js";
+import { emitConfluenceLink } from "../links.js";
+import { sanitizeRawHtml } from "../raw-html/raw-html.js";
+//#region src/services/conversion/markdownToConfluence/render/inline.ts
+/** Décode les entités produites par marked puis ré-échappe pour le XML Confluence. */
+function fromMarked(text) {
+	const decoded = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;|&apos;/g, "'");
+	return escapeXml(decoded);
+}
+function renderInline(tokens) {
+	return tokens ? tokens.map(renderInlineToken).join("") : "";
+}
+function renderInlineToken(token) {
+	switch (token.type) {
+		case "text": {
+			const t = token;
+			return t.tokens?.length ? renderInline(t.tokens) : fromMarked(t.text);
+		}
+		case "escape": return fromMarked(token.text);
+		case "codespan": return `<code>${fromMarked(token.text)}</code>`;
+		case "html": return sanitizeRawHtml(token.text);
+		case "br": return "<br/>";
+		case "strong": return `<strong>${renderInline(token.tokens)}</strong>`;
+		case "em": return `<em>${renderInline(token.tokens)}</em>`;
+		case "del": return `<del>${renderInline(token.tokens)}</del>`;
+		case "link": return renderLink(token);
+		case "image": return renderInlineImage(token);
+		default:
+			log.warning0(`Unsupported inline token: ${token.type}`);
+			return "";
+	}
+}
+function renderLink(token) {
+	const labelHtml = token.tokens ? renderInline(token.tokens) : fromMarked(token.text);
+	return emitConfluenceLink(token.href, token.text, labelHtml, token.title);
+}
+function renderInlineImage(token) {
+	const href = token.href;
+	if (href.startsWith("http://") || href.startsWith("https://")) return `<ac:image><ri:url ri:value="${escapeAttr(href)}" /></ac:image>`;
+	return `<ac:image><ri:attachment ri:filename="${escapeAttr(href.split("/").pop() ?? href)}" /></ac:image>`;
+}
+//#endregion
+export { fromMarked, renderInline, renderInlineImage, renderInlineToken };

package/dist/services/conversion/markdownToConfluence/render/page.js

@@ -0,0 +1,31 @@
+import { escapeAttr } from "../../shared/xml-escaping.js";
+import { structuredMacro } from "../../shared/confluence-macro-builder.js";
+//#region src/services/conversion/markdownToConfluence/render/page.ts
+function stripColgroups(html) {
+	return html.replace(/<colgroup\b[^>]*>[\s\S]*?<\/colgroup>/gi, "");
+}
+/** Enveloppe le corps converti : bandeau « Généré le … » + sommaire (optionnel), puis le corps (colgroups retirés). */
+function buildConfluencePage(body, generatedAt, generateSummary = true) {
+	const info = structuredMacro("info", { richTextBody: `    <p><strong>Généré le :</strong> ${escapeAttr(generatedAt)}</p>` });
+	if (!generateSummary) return [
+		info,
+		"",
+		stripColgroups(body)
+	].join("\n");
+	return [
+		info,
+		"",
+		structuredMacro("toc", { params: [
+			["printable", "true"],
+			["style", "disc"],
+			["maxLevel", "3"],
+			["minLevel", "1"],
+			["type", "list"],
+			["outline", "false"]
+		] }),
+		"",
+		stripColgroups(body)
+	].join("\n");
+}
+//#endregion
+export { buildConfluencePage };

package/dist/services/conversion/shared/confluence-macro-builder.js

@@ -0,0 +1,11 @@
+//#region src/services/conversion/shared/confluence-macro-builder.ts
+function structuredMacro(name, opts = {}) {
+	const lines = [`<ac:structured-macro ac:name="${name}"${opts.schemaVersion ? " ac:schema-version=\"1\"" : ""}>`];
+	for (const [key, value] of opts.params ?? []) lines.push(`  <ac:parameter ac:name="${key}">${value}</ac:parameter>`);
+	if (opts.plainTextBody !== void 0) lines.push(`  <ac:plain-text-body><![CDATA[${opts.plainTextBody}]]></ac:plain-text-body>`);
+	if (opts.richTextBody !== void 0) lines.push(`  <ac:rich-text-body>`, opts.richTextBody, `  </ac:rich-text-body>`);
+	lines.push(`</ac:structured-macro>`);
+	return lines.join("\n");
+}
+//#endregion
+export { structuredMacro };

package/dist/services/conversion/shared/gitlab-url.js

@@ -0,0 +1,16 @@
+import path from "path";
+//#region src/services/conversion/shared/gitlab-url.ts
+function toGitlabFileUrl(href, sourceFile, gitlab) {
+	if (/^https?:\/\/|^mailto:|^#/.test(href)) return href;
+	const gitlabBase = (gitlab?.baseUrl ?? process.env.GITLAB_BASE_URL)?.replace(/\/$/, "");
+	if (!gitlabBase) return href;
+	const hashIdx = href.indexOf("#");
+	const fragment = hashIdx !== -1 ? href.slice(hashIdx) : "";
+	const filePart = hashIdx !== -1 ? href.slice(0, hashIdx) : href;
+	if (!filePart) return href;
+	const sourceDir = path.dirname(sourceFile).replace(/\\/g, "/");
+	const normalized = path.posix.normalize(path.posix.join(sourceDir, filePart));
+	return `${gitlabBase}/-/blob/${gitlab?.branch ?? "main"}/${normalized}${fragment}`;
+}
+//#endregion
+export { toGitlabFileUrl };

package/dist/services/conversion/shared/image-attachments.js

@@ -0,0 +1,57 @@
+import { unescapeXml } from "./xml-escaping.js";
+import { createHash } from "node:crypto";
+//#region src/services/conversion/shared/image-attachments.ts
+function decodeAttachmentFilename(rawFilename) {
+	return unescapeXml(rawFilename);
+}
+const EMBEDDED_ATTACHMENT_PATTERNS = [/<ac:image[^>]*>[\s\S]*?<ri:attachment[^>]*ri:filename="([^"]+)"[^>]*\/>[\s\S]*?<\/ac:image>/g, /<ac:structured-macro[^>]*ac:name="view-file"[^>]*>[\s\S]*?<ri:attachment[^>]*ri:filename="([^"]+)"[^>]*\/>[\s\S]*?<\/ac:structured-macro>/g];
+function embeddedAttachmentFilenames(storageXml) {
+	const raw = EMBEDDED_ATTACHMENT_PATTERNS.flatMap((pattern) => [...storageXml.matchAll(pattern)].map((m) => m[1]));
+	return [...new Set(raw.map(decodeAttachmentFilename))];
+}
+const CONTROL_CHARS = Array.from({ length: 32 }, (_, i) => String.fromCharCode(i)).join("");
+const ILLEGAL_FILENAME_CHARS = new RegExp(`[<>:"/\\\\|?*${CONTROL_CHARS}]`, "g");
+const MAX_FILENAME_LENGTH = 120;
+function sanitizeAttachmentFilename(filename) {
+	const safe = filename.replace(ILLEGAL_FILENAME_CHARS, "_");
+	if (safe.length <= MAX_FILENAME_LENGTH) return safe;
+	const hash = createHash("sha1").update(filename).digest("hex").slice(0, 8);
+	return `${safe.slice(0, MAX_FILENAME_LENGTH)}-${hash}`;
+}
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"svg",
+	"webp",
+	"bmp"
+]);
+const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+	"mp4",
+	"mov",
+	"webm",
+	"avi",
+	"mkv",
+	"m4v"
+]);
+function extensionOf(filename) {
+	return /\.([a-z0-9]+)$/i.exec(filename)?.[1]?.toLowerCase();
+}
+function classifyAttachment(filename) {
+	const ext = extensionOf(filename);
+	if (ext && IMAGE_EXTENSIONS.has(ext)) return "image";
+	if (ext && VIDEO_EXTENSIONS.has(ext)) return "video";
+	return "other";
+}
+function renderAttachmentTag(rawFilename, imgRelPath) {
+	const filename = decodeAttachmentFilename(rawFilename);
+	const localFilename = sanitizeAttachmentFilename(filename);
+	const href = imgRelPath ? `${imgRelPath}/${localFilename}` : localFilename;
+	const kind = classifyAttachment(filename);
+	if (kind === "video") return `<video src="${href}" controls>${filename}</video>`;
+	if (kind === "other") return `<a href="${href}">${filename}</a>`;
+	return `<img src="${href}" alt="${filename}">`;
+}
+//#endregion
+export { EMBEDDED_ATTACHMENT_PATTERNS, classifyAttachment, decodeAttachmentFilename, embeddedAttachmentFilenames, renderAttachmentTag, sanitizeAttachmentFilename };

package/dist/services/conversion/shared/jira.js

@@ -0,0 +1,7 @@
+//#region src/services/conversion/shared/jira.ts
+/** Motif (source, sans ancres ni flags) d'une clé de ticket Jira. */
+const JIRA_KEY_PATTERN = "[A-Z][A-Z0-9]*-\\d+";
+/** Clé de ticket Jira, ancrée sur toute la chaîne (ex. validation d'un texte détecté). */
+const JIRA_KEY_RE = new RegExp(`^${JIRA_KEY_PATTERN}$`);
+//#endregion
+export { JIRA_KEY_PATTERN, JIRA_KEY_RE };

package/dist/services/conversion/shared/macro-types.js

@@ -0,0 +1,12 @@
+//#region src/services/conversion/shared/macro-types.ts
+const RICH_BODY_MACRO_TYPES = [
+	"info",
+	"note",
+	"warning",
+	"tip",
+	"expand"
+];
+/** Fragment d'alternation regex correspondant, ex. "info|note|warning|tip|expand". */
+const RICH_BODY_MACRO_TYPES_PATTERN = RICH_BODY_MACRO_TYPES.join("|");
+//#endregion
+export { RICH_BODY_MACRO_TYPES, RICH_BODY_MACRO_TYPES_PATTERN };