@wonseok-han/confluence-sync 1.7.0 → 2.0.0

package/dist/documents/format.js

@@ -0,0 +1,116 @@
+/** Conservative source formatting: preserve code, HTML, frontmatter and link targets. */
+import MarkdownIt from 'markdown-it';
+import { splitFrontmatter } from './obsidian.js';
+import { relaxEscapes } from './html-to-markdown.js';
+const parser = new MarkdownIt({ html: true });
+const width = (s) => Array.from(s).reduce((n, c) => n + (/\p{Script=Hangul}|\p{Script=Han}/u.test(c) ? 2 : 1), 0);
+function cells(line) {
+    const result = [];
+    let part = '', slashes = 0, ticks = 0;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '`' && slashes % 2 === 0) {
+            let end = i;
+            while (line[end] === '`')
+                end++;
+            const size = end - i;
+            ticks = ticks === size ? 0 : ticks || size;
+            part += line.slice(i, end);
+            i = end - 1;
+            slashes = 0;
+            continue;
+        }
+        if (c === '|' && !ticks && slashes % 2 === 0) {
+            result.push(part.trim());
+            part = '';
+        }
+        else
+            part += c;
+        slashes = c === '\\' ? slashes + 1 : 0;
+    }
+    result.push(part.trim());
+    if (line.trimStart().startsWith('|'))
+        result.shift();
+    if (line.trimEnd().endsWith('|') && !result.at(-1))
+        result.pop();
+    return result;
+}
+export function formatDocument(source) {
+    const { body } = splitFrontmatter(source);
+    const frontmatter = source.slice(0, source.length - body.length);
+    const separator = frontmatter ? body.match(/^(?:[ \t]*\r?\n)*/)?.[0] ?? '' : '';
+    const prefix = frontmatter + separator;
+    const eol = source.includes('\r\n') ? '\r\n' : '\n';
+    const text = body.slice(separator.length).replace(/\r\n/g, '\n'), lines = text.split('\n'), tokens = parser.parse(text, {});
+    const protectedLines = new Set(), rawHtmlLines = new Set(), headings = new Set();
+    // Raw HTML tables can contain blank lines that end a Markdown HTML token.
+    let tableStart = -1, tableDepth = 0;
+    for (const tag of text.matchAll(/<\/?table\b(?:[^"'<>]|"[^"]*"|'[^']*')*>/gi)) {
+        if (!tag[0].startsWith('</')) {
+            if (tableDepth++ === 0)
+                tableStart = tag.index;
+        }
+        else if (tableDepth && --tableDepth === 0) {
+            const start = text.slice(0, tableStart).split('\n').length - 1;
+            const end = text.slice(0, tag.index + tag[0].length).split('\n').length;
+            for (let i = start; i < end; i++) {
+                protectedLines.add(i);
+                rawHtmlLines.add(i);
+            }
+        }
+    }
+    // Inline code may span lines; keep its entire source lines untouched.
+    for (const match of text.matchAll(/(`+)([\s\S]*?)(?<!`)\1(?!`)/g)) {
+        const start = text.slice(0, match.index).split('\n').length - 1;
+        const end = start + match[0].split('\n').length;
+        for (let i = start; i < end; i++)
+            protectedLines.add(i);
+    }
+    for (const token of tokens) {
+        if (!token.map)
+            continue;
+        const [start, end] = token.map;
+        if (['fence', 'code_block', 'html_block', 'table_open'].includes(token.type)) {
+            for (let i = start; i < end; i++)
+                protectedLines.add(i);
+        }
+        if (token.type === 'heading_open' && !protectedLines.has(start) && token.level === 0 && end === start + 1 && /^ {0,3}#{1,6}\s/.test(lines[start])) {
+            headings.add(start);
+            lines[start] = lines[start].replace(/^ {0,3}(#{1,6})[ \t]+(.*?)(?:[ \t]+#+[ \t]*)?$/, '$1 $2');
+        }
+        if (token.type === 'list_item_open' && !protectedLines.has(start))
+            lines[start] = lines[start].replace(/^(\s*)(?:[-+*](\s+)|(\d+)[.)](\s+))/, (_m, indent, space, number, orderedSpace) => indent + (number ? number + '.' + orderedSpace : '-' + space));
+        if (token.type === 'table_open' && !rawHtmlLines.has(start) && token.level === 0) {
+            const rows = lines.slice(start, end).map(cells), count = rows[0]?.length;
+            if (count && rows.every(row => row.length === count)) {
+                const sizes = Array.from({ length: count }, (_, i) => Math.max(3, ...rows.map(row => width(row[i]))));
+                const formatted = rows.map((row, r) => '| ' + row.map((cell, i) => r === 1
+                    ? (cell.startsWith(':') ? ':' : '') + '-'.repeat(Math.max(3, sizes[i] - Number(cell.startsWith(':')) - Number(cell.endsWith(':')))) + (cell.endsWith(':') ? ':' : '')
+                    : cell + ' '.repeat(sizes[i] - width(cell))).join(' | ') + ' |');
+                if (parser.render(formatted.join('\n')) === parser.render(lines.slice(start, end).join('\n')))
+                    lines.splice(start, end - start, ...formatted);
+            }
+        }
+    }
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (protectedLines.has(i)) {
+            out.push(lines[i]);
+            continue;
+        }
+        let line = lines[i].replace(/[\t ]+$/, m => / {2,}$/.test(m) && lines[i].trim() ? '  ' : '');
+        // Keep Markdown hard breaks; avoid link destinations, wiki targets and inline HTML.
+        if (!/[\[\]<>`]/.test(line) && !/^ {0,3}(?:>|[-+*]\s|\d+[.)]\s)/.test(line))
+            line = relaxEscapes(line);
+        if (!line.trim() && !out.at(-1)?.trim())
+            continue;
+        if (headings.has(i) && out.length && out.at(-1)?.trim())
+            out.push('');
+        out.push(line);
+        if (headings.has(i) && i + 1 < lines.length && lines[i + 1].trim())
+            out.push('');
+    }
+    while (out.length && !out.at(-1)?.trim())
+        out.pop();
+    return prefix + (out.length ? out.join(eol) + eol : '');
+}

package/dist/documents/html-tables.js

@@ -0,0 +1,30 @@
+import MarkdownIt from 'markdown-it';
+import { installCallouts } from './callouts.js';
+/** Keep a raw table in one token, including blank lines between its rows. */
+export function htmlTableMarkdown(format = 'html') {
+    const md = new MarkdownIt({ html: true, linkify: true, breaks: false });
+    md.block.ruler.before('html_block', 'html_table', (state, start, end, silent) => {
+        if (state.sCount[start] - state.blkIndent >= 4)
+            return false;
+        const source = state.getLines(start, end, state.blkIndent, false);
+        if (!/^ {0,3}<table(?:\s|>)/i.test(source))
+            return false;
+        let depth = 0;
+        for (const match of source.matchAll(/<\/?table\b(?:[^"'<>]|"[^"]*"|'[^']*')*>/gi)) {
+            depth += /^<\//.test(match[0]) ? -1 : 1;
+            if (depth)
+                continue;
+            if (silent)
+                return true;
+            const next = start + source.slice(0, match.index + match[0].length).split('\n').length;
+            const token = state.push('html_block', '', 0);
+            token.content = state.getLines(start, next, state.blkIndent, true);
+            token.map = [start, next];
+            state.line = next;
+            return true;
+        }
+        return false;
+    });
+    installCallouts(md, format);
+    return md;
+}

package/dist/documents/html-to-markdown.js

@@ -4,6 +4,12 @@
  * storage/export_view 는 무손실 역변환이 아니므로 근사 결과다.
  */
 import TurndownService from 'turndown';
+import { restoreFootnoteAnchors, installFootnoteRules } from './footnote-roundtrip.js';
+import { linksToFootnotes } from '../conversion/footnotes.js';
+import { mapMarkdownText } from '../conversion/pdf-pages.js';
+import { restoreCalloutPanels, installPanelRule } from './callout-roundtrip.js';
+import MarkdownIt from 'markdown-it';
+import { applyTableWidths, hasWidths, tableWidths, restoreTableWidths } from './tables.js';
 /** storage(XHTML)의 code 매크로들에서 language 파라미터를 문서 순서대로 추출(미지정은 ''). */
 export function codeLanguagesFromStorage(storage) {
     const out = [];
@@ -23,16 +29,9 @@ const linkDest = (p) => (/\s/.test(p) ? `<${p}>` : p);
  * 줄 맨 앞의 진짜 마커 이스케이프는 보존하고, 그 뒤(줄 중간)의 것만 되돌린다. 코드블록은 건드리지 않는다.
  */
 export function relaxEscapes(md) {
-    let inFence = false;
-    return md
+    return mapMarkdownText(md, prose => prose
         .split('\n')
         .map((line) => {
-        if (/^\s*```/.test(line)) {
-            inFence = !inFence;
-            return line;
-        }
-        if (inFence)
-            return line;
         // 들여쓰기 + (줄 맨 앞의 이스케이프된 마커) 까지는 그대로 두고 이후만 완화
         const head = line.match(/^\s*(?:\\[-+>#]|\d+\\\.)?/)?.[0] ?? '';
         const rest = line
@@ -40,14 +39,16 @@ export function relaxEscapes(md) {
             // 줄 중간의 - + . > 는 마커가 아니므로 이스케이프 불필요
             .replace(/\\([-+.>])/g, '$1')
             // 단어 내부 밑줄은 CommonMark 에서 강조가 아니다 (:11_eleven_square_blue: 같은 이모지 코드)
-            .replace(/(\w)\\_(?=\w)/g, '$1_')
+            .replace(/(?<=[\p{L}\p{N}\p{M}_])(?:\\_)+(?=[\p{L}\p{N}\p{M}_])/gu, run => run.replace(/\\/g, ''))
             // 링크가 아닌 대괄호 쌍(뒤에 ( 나 [ 가 오지 않음)은 이스케이프 불필요
             .replace(/\\\[([^[\]\n]*)\\\](?!\s*[([])/g, '[$1]');
         return head + rest;
     })
-        .join('\n');
+        .join('\n'));
 }
 export function htmlToMarkdown(html, opts = {}) {
+    html = restoreFootnoteAnchors(restoreCalloutPanels(restoreTableWidths(html, opts.storage), opts.storage), opts.storage, opts.pageId);
+    const cellRenderer = new MarkdownIt({ html: true });
     const td = new TurndownService({
         headingStyle: 'atx',
         codeBlockStyle: 'fenced',
@@ -55,6 +56,8 @@ export function htmlToMarkdown(html, opts = {}) {
         hr: '---',
         emDelimiter: '_',
     });
+    installPanelRule(td, opts.obsidian ?? false);
+    installFootnoteRules(td);
     // Confluence export_view 는 색상 텍스트용 인라인 <style> 을 본문(제목 안까지) 끼워 넣는다.
     // turndown 은 기본적으로 이런 요소의 텍스트를 그대로 뱉으므로 통째로 제거한다.
     td.remove(['style', 'script', 'noscript', 'head', 'meta', 'link']);
@@ -62,7 +65,7 @@ export function htmlToMarkdown(html, opts = {}) {
     // 그러나 단어 내부 밑줄은 CommonMark 에서 강조가 아니므로(:11_eleven_square_blue: 같은 이모지 코드)
     // 양쪽이 단어 문자인 경우만 이스케이프를 되돌린다.
     const baseEscape = td.escape.bind(td);
-    td.escape = (s) => baseEscape(s).replace(/(\w)\\_(?=\w)/g, '$1_');
+    td.escape = (s) => baseEscape(s).replace(/(?<=[\p{L}\p{N}\p{M}_])(?:\\_)+(?=[\p{L}\p{N}\p{M}_])/gu, run => run.replace(/\\/g, ''));
     // Confluence 는 리스트 항목 내용을 <li><p>…</p></li> 로 감싼다.
     // 기본 규칙대로면 문단으로 취급돼 항목마다 빈 줄이 생기므로(loose list),
     // li 안의 첫 문단은 빈 줄 없이 붙인다(두 번째 이후 문단은 기존대로 분리).
@@ -106,6 +109,10 @@ export function htmlToMarkdown(html, opts = {}) {
             const alt = el.getAttribute('alt') || '';
             const isAttachment = el.getAttribute('data-linked-resource-type') === 'attachment' ||
                 /\/download\/(attachments|thumbnails)\//.test(src);
+            // export_view may include a Confluence macro loading indicator, not a page attachment.
+            if (!isAttachment && /(?:^|\s)waiting-image(?:\s|$)/.test(el.getAttribute('class') || '')
+                && /\/images\/icons\/wait\.gif(?:[?#]|$)/i.test(src))
+                return '';
             if (!isAttachment && /^https?:\/\//i.test(src)) {
                 return `![${alt}](${linkDest(src)})`;
             }
@@ -113,7 +120,7 @@ export function htmlToMarkdown(html, opts = {}) {
             const name = alias || decodeURIComponent((src.split('?')[0].split('/').pop() || '').trim());
             if (name)
                 opts.onImage?.(name);
-            const dest = opts.assetPrefix ? `${opts.assetPrefix}/${name}` : name;
+            const dest = opts.attachmentDestination?.(name, src) ?? (opts.assetPrefix ? `${opts.assetPrefix}/${name}` : name);
             return `![${alt || name}](${linkDest(dest)})`;
         },
     });
@@ -121,6 +128,32 @@ export function htmlToMarkdown(html, opts = {}) {
     td.addRule('confTable', {
         filter: 'table',
         replacement: (_content, node) => {
+            const table = node;
+            const widths = tableWidths(table);
+            if (hasWidths(widths) || table.querySelector('th[colspan], td[colspan], th[rowspan], td[rowspan]')) {
+                // Reuse conversion rules for links/images, then encode the cells as HTML.
+                // Markdown inside a raw HTML block is not portable.
+                const copy = table.cloneNode(true);
+                for (const anchor of Array.from(copy.querySelectorAll('a[href]'))) {
+                    const href = anchor.getAttribute('href');
+                    if (!/\/download\/attachments\//.test(href))
+                        continue;
+                    const name = anchor.getAttribute('data-linked-resource-default-alias')
+                        || decodeURIComponent(href.split('?')[0].split('#')[0].split('/').pop() || '');
+                    if (!name)
+                        continue;
+                    opts.onImage?.(name);
+                    anchor.setAttribute('href', opts.attachmentDestination?.(name, href) ?? (opts.assetPrefix ? `${opts.assetPrefix}/${name}` : name));
+                }
+                for (const cell of Array.from(copy.querySelectorAll('th, td'))) {
+                    cell.innerHTML = cellRenderer.render(td.turndown(cell.innerHTML));
+                }
+                applyTableWidths(copy, widths);
+                copy.removeAttribute('data-table-width');
+                copy.removeAttribute('data-layout');
+                copy.removeAttribute('ac:local-id');
+                return `\n\n${copy.outerHTML}\n\n`;
+            }
             const cell = (c) => td.turndown(c.innerHTML || '').replace(/\n+/g, ' ').replace(/\|/g, '\\|').trim();
             const trs = Array.from(node.querySelectorAll('tr'));
             const matrix = trs.map((r) => Array.from(r.children).filter((c) => c.nodeName === 'TD' || c.nodeName === 'TH').map(cell));
@@ -135,5 +168,6 @@ export function htmlToMarkdown(html, opts = {}) {
             return `${out}\n`;
         },
     });
-    return relaxEscapes(td.turndown(html)).trim() + '\n';
+    const result = relaxEscapes(td.turndown(html)).trim() + '\n';
+    return opts.obsidian ? linksToFootnotes(result) : result;
 }

package/dist/documents/markdown.js

@@ -5,10 +5,15 @@
  * - 로컬 이미지 → 첨부 참조(ri:attachment), 외부 URL 이미지는 그대로
  * 모든 경로는 baseDir 기준 상대경로로 해석한다.
  */
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve, relative, dirname, basename } from 'node:path';
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, relative, dirname, basename, extname } from 'node:path';
 import { createHash } from 'node:crypto';
-import MarkdownIt from 'markdown-it';
+import { isConfluenceWebPath } from '../confluence/links.js';
+import { htmlTableMarkdown } from './html-tables.js';
+import Token from 'markdown-it/lib/token.mjs';
+import { footnotesToStorage, footnoteStorageComments } from './footnote-roundtrip.js';
+import { createDocument } from '@mixmark-io/domino';
+import { applyTableWidths, hasWidths, tableWidths } from './tables.js';
 import { resolveWikilinks } from './obsidian.js';
 import { decodeAnchor, anchorMacro } from './anchors.js';
 import { mermaidMacro } from './mermaid.js';
@@ -23,11 +28,11 @@ const decodePath = (s) => {
         return s;
     }
 };
-const md = new MarkdownIt({ html: true, linkify: true, breaks: false });
+const md = htmlTableMarkdown('storage');
 const emptyCtx = () => ({
     fileDir: '', titleIndex: {}, anchorIndex: {}, selfRel: '', selfTitle: '',
     anchorNames: new Set(), bodySlugs: [], headingSeq: 0, mermaidSeq: 0, anchorsPlaced: 0,
-    images: [], internalLinks: 0, anchorLinks: 0, deadAnchors: [], linkStack: [], linkedTitles: new Set(),
+    images: [], attachments: [], internalLinks: 0, anchorLinks: 0, deadAnchors: [], linkStack: [], linkedTitles: new Set(),
 });
 // 렌더 규칙은 md 인스턴스에 한 번만 등록되므로, 현재 변환 컨텍스트를 모듈 변수로 공유한다.
 let ctx = emptyCtx();
@@ -91,8 +96,29 @@ md.renderer.rules.fence = (tokens, idx) => {
     const code = `<ac:structured-macro ac:name="code">${langParam}<ac:plain-text-body><![CDATA[${safe}]]></ac:plain-text-body></ac:structured-macro>\n`;
     return code + (lang === 'mermaid' ? mermaidMacro(ctx.selfRel, ctx.mermaidSeq++) : '');
 };
+/** 페이지 첨부 이름은 유일해야 한다. 동일 경로는 한 번만 업로드한다. */
+function addAttachment(abs) {
+    const existing = ctx.attachments.find(a => a.abs === abs);
+    if (existing)
+        return existing.filename;
+    let filename = basename(abs);
+    if (ctx.attachments.some(a => a.filename === filename)) {
+        const ext = extname(filename), stem = basename(filename, ext);
+        const suffix = hashOf(relative(baseDir, abs).split('\\').join('/')).slice(0, 12);
+        filename = `${stem}-${suffix}${ext}`;
+        let n = 1;
+        while (ctx.attachments.some(a => a.filename === filename))
+            filename = `${stem}-${suffix}-${n++}${ext}`;
+    }
+    ctx.attachments.push({ filename, abs });
+    return filename;
+}
 md.renderer.rules.link_open = (tokens, idx, opts, _env, self) => {
     const originalHref = tokens[idx].attrGet('href') || '';
+    if (isConfluenceWebPath(originalHref)) {
+        ctx.linkStack.push(false);
+        return self.renderToken(tokens, idx, opts);
+    }
     const href = ctx.rewriteHref?.(originalHref) ?? originalHref;
     tokens[idx].attrSet('href', href);
     const t = resolveInternalLink(href);
@@ -109,6 +135,17 @@ md.renderer.rules.link_open = (tokens, idx, opts, _env, self) => {
         const page = t.title ? `<ri:page ri:content-title="${escapeXml(t.title)}" />` : '';
         return `<ac:link${anchor}>${page}<ac:link-body>`;
     }
+    // 일반 로컬 파일 링크도 첨부로 전환한다. 문서·외부 URL·없는 대상은 유지한다.
+    const path = href.split('#')[0];
+    if (path && !/^[a-z][a-z\d+.-]*:|^\/\//i.test(path) && !/\.md$/i.test(decodePath(path))) {
+        const abs = resolve(baseDir, ctx.fileDir, decodePath(path));
+        if (existsSync(abs) && statSync(abs).isFile()) {
+            const filename = addAttachment(abs);
+            ctx.linkStack.push(true);
+            const fragment = href.includes('#') ? ` ac:anchor="${escapeXml(decodePath(href.slice(href.indexOf('#') + 1)))}"` : '';
+            return `<ac:link${fragment}><ri:attachment ri:filename="${escapeXml(filename)}" /><ac:link-body>`;
+        }
+    }
     ctx.linkStack.push(false);
     return self.renderToken(tokens, idx, opts);
 };
@@ -128,10 +165,43 @@ md.renderer.rules.image = (tokens, idx) => {
     }
     // markdown-it 이 링크 경로를 퍼센트 인코딩하므로 디코드해서 실제 파일명/경로로 복원(한글·공백 대응)
     const abs = resolve(baseDir, ctx.fileDir, decodePath(src.split('#')[0]));
-    const filename = basename(abs);
+    const filename = addAttachment(abs);
     ctx.images.push({ filename, abs });
     return `<ac:image${widthAttr}><ri:attachment ri:filename="${escapeXml(filename)}" /></ac:image>`;
 };
+// Raw HTML tables share the normal link/image rules (including attachment collection).
+md.renderer.rules.html_block = (tokens, idx) => {
+    const html = tokens[idx].content;
+    if (!/<table[\s>]/i.test(html))
+        return html;
+    const doc = createDocument(html);
+    for (const table of Array.from(doc.querySelectorAll('table'))) {
+        const widths = tableWidths(table);
+        if (hasWidths(widths))
+            applyTableWidths(table, widths, true);
+    }
+    let output = doc.body.innerHTML;
+    for (const anchor of Array.from(doc.querySelectorAll('table a[href]'))) {
+        const token = new Token('link_open', 'a', 1);
+        token.attrs = Array.from(anchor.attributes).map(a => [a.name, a.value]);
+        const open = md.renderer.rules.link_open([token], 0, md.options, {}, md.renderer);
+        const close = md.renderer.rules.link_close([new Token('link_close', 'a', -1)], 0, md.options, {}, md.renderer);
+        output = output.replace(anchor.outerHTML, open + anchor.innerHTML + close);
+    }
+    for (const image of Array.from(doc.querySelectorAll('table img[src]'))) {
+        const token = new Token('image', 'img', 0);
+        token.attrs = Array.from(image.attributes).map(a => [a.name, a.value]);
+        const width = image.getAttribute('width') ?? image.getAttribute('style')?.match(/(?:^|;)\s*width:\s*(\d+(?:\.\d+)?)px/i)?.[1];
+        if (width && /^\d+$/.test(width))
+            token.attrSet('title', `width=${width}`);
+        output = output.replace(image.outerHTML, md.renderer.rules.image([token], 0, md.options, {}, md.renderer));
+    }
+    // Storage is XHTML; HTML's void elements need a closing slash.
+    for (const element of Array.from(doc.querySelectorAll('col, br, hr, img, input, wbr'))) {
+        output = output.split(element.outerHTML).join(element.outerHTML.slice(0, -1) + ' />');
+    }
+    return output + '\n';
+};
 /** 첫 H1(`# 제목`)을 제목으로 추출하고 본문에서 제거 */
 export function splitTitleAndBody(markdown, fallback) {
     const lines = markdown.split('\n');
@@ -159,10 +229,11 @@ export function toStorage(markdown, rel, titleIndex, base, opts = {}) {
         bodySlugs: opts.bodySlugs ?? [],
     };
     const src = opts.resolveLink ? resolveWikilinks(markdown, opts.resolveLink) : markdown;
-    const storage = md.render(src);
+    const storage = footnotesToStorage(md.render(src, { legacyCallouts: opts.legacyCallouts }));
     return {
         storage,
         images: ctx.images,
+        attachments: ctx.attachments,
         internalLinks: ctx.internalLinks,
         anchorLinks: ctx.anchorLinks,
         anchorsPlaced: ctx.anchorsPlaced,
@@ -171,13 +242,13 @@ export function toStorage(markdown, rel, titleIndex, base, opts = {}) {
     };
 }
 /**
- * 변경 감지용 문서 해시: 제목 + storage + 참조 로컬 이미지의 내용 해시.
- * 이미지 내용을 포함하므로, 같은 파일명으로 이미지만 교체해도 해시가 바뀌어 재동기화 대상이 된다.
- * 이미지가 없으면 hashOf(title + '\0' + storage) 와 동일(이미지 없는 문서는 기존 해시 유지).
+ * 변경 감지용 문서 해시: 제목 + storage + 참조 로컬 첨부의 내용 해시.
+ * 첨부 내용을 포함하므로, 같은 파일명으로 파일만 교체해도 해시가 바뀌어 재동기화 대상이 된다.
+ * 첨부가 없으면 hashOf(title + '\0' + storage) 와 동일(첨부 없는 문서는 기존 해시 유지).
  */
 export function docHash(title, r) {
-    const parts = [title, r.storage];
-    for (const img of r.images) {
+    const parts = [title, footnoteStorageComments(r.storage)];
+    for (const img of r.attachments) {
         let digest = 'missing';
         try {
             if (existsSync(img.abs))

package/dist/documents/obsidian.js

@@ -38,6 +38,9 @@ export function buildFrontmatter(data) {
 }
 /** 공백이 있으면 <...> 로 감싼다(markdown-it 이 목적지를 통째로 파싱하도록). */
 const dest = (p) => (/\s/.test(p) ? `<${p}>` : p);
+/** Wiki aliases display underscores literally; Markdown's escape must not leak. */
+export const wikilinkDisplayText = (text) => text.replace(/\\([\\_])/g, '$1');
+const markdownDisplayText = (text) => text.replace(/[\\_]/g, '\\$&');
 /**
  * 마크다운 본문에서 "산문" 부분에만 변환을 적용한다.
  * 코드블록(``` / ~~~)과 인라인 코드(`...`) 안은 그대로 둔다 — 링크처럼 생긴 예제 코드를
@@ -80,12 +83,12 @@ export function resolveWikilinks(md, resolve) {
         if (!w.target) {
             if (!slug)
                 return whole; // 블록 참조뿐 → 갈 곳이 없으므로 원문 보존
-            return `[${w.alias ?? w.fragment}](#${slug})`;
+            return `[${markdownDisplayText(w.alias ?? w.fragment ?? '')}](#${slug})`;
         }
         const found = resolve(w.target, w.embed);
         if (!found)
             return whole; // 해석 실패 → 원문 보존
-        const label = w.alias ?? w.target;
+        const label = markdownDisplayText(w.alias ?? w.target);
         if (w.embed)
             return `![${label}](${dest(found + (/\.pdf$/i.test(w.target) && slug ? `#${slug}` : ''))})`;
         return `[${label}](${dest(found + (slug ? `#${slug}` : ''))})`;
@@ -103,6 +106,6 @@ export function linksToWikilinks(md, toWikilink) {
         if (bang === '!')
             return whole; // 이미지는 표준 링크 유지
         const d = rawDest.replace(/^<(.*)>$/, '$1');
-        return toWikilink(d, label) ?? whole;
+        return toWikilink(d, wikilinkDisplayText(label)) ?? whole;
     }));
 }

package/dist/documents/tables.js

@@ -0,0 +1,89 @@
+import { createDocument } from '@mixmark-io/domino';
+import { htmlTableMarkdown } from './html-tables.js';
+/** Only explicit pixel widths are portable to Confluence storage. */
+export function pixelWidth(value) {
+    const match = value?.trim().match(/^(\d+(?:\.\d+)?)(?:px)?$/i);
+    const width = match ? Number(match[1]) : 0;
+    return Number.isFinite(width) && width > 0 ? width : undefined;
+}
+function styleWidth(el) {
+    const value = el.getAttribute('style')?.match(/(?:^|;)\s*width\s*:\s*([^;]+)/i)?.[1];
+    return pixelWidth(value ?? null);
+}
+export function tableWidths(table) {
+    const columns = Array.from(table.children)
+        .filter(el => el.tagName === 'COLGROUP')
+        .flatMap(group => Array.from(group.children).filter(el => el.tagName === 'COL'))
+        .map(col => styleWidth(col) ?? pixelWidth(col.getAttribute('width')));
+    const width = pixelWidth(table.getAttribute('data-table-width')) ?? styleWidth(table)
+        ?? pixelWidth(table.getAttribute('width'))
+        ?? (columns.length && columns.every(w => w !== undefined) ? columns.reduce((sum, w) => sum + w, 0) : undefined);
+    return { width, columns };
+}
+export function hasWidths(widths) {
+    return widths.width !== undefined || widths.columns.some(w => w !== undefined);
+}
+export function applyTableWidths(table, widths, storage = false) {
+    if (widths.width !== undefined) {
+        const style = (table.getAttribute('style') ?? '').split(';')
+            .map(s => s.trim()).filter(s => s && !/^(?:width|table-layout)\s*:/i.test(s)).join('; ');
+        table.setAttribute('style', `${style ? style + '; ' : ''}width: ${widths.width}px; table-layout: fixed;`);
+        if (storage) {
+            table.setAttribute('data-table-width', String(widths.width));
+            if (!table.hasAttribute('data-layout'))
+                table.setAttribute('data-layout', 'default');
+        }
+    }
+    if (widths.columns.length) {
+        for (const group of Array.from(table.children).filter(el => el.tagName === 'COLGROUP'))
+            group.remove();
+        const group = table.ownerDocument.createElement('colgroup');
+        for (const width of widths.columns) {
+            const col = table.ownerDocument.createElement('col');
+            if (width !== undefined)
+                col.setAttribute('style', `width: ${width}px;`);
+            group.appendChild(col);
+        }
+        table.insertBefore(group, table.firstChild);
+    }
+}
+/** Read layout from storage, while retaining export_view's rendered cell contents. */
+export function restoreTableWidths(html, storage) {
+    if (!storage)
+        return html;
+    const candidates = Array.from(createDocument(storage).querySelectorAll('table')).map(tableWidths);
+    if (!candidates.some(hasWidths))
+        return html;
+    const doc = createDocument(html);
+    const tables = Array.from(doc.querySelectorAll('table'));
+    // Macro-generated tables may change the count; avoid assigning unrelated metadata.
+    if (tables.length !== candidates.length)
+        return html;
+    tables.forEach((table, i) => { if (hasWidths(candidates[i]))
+        applyTableWidths(table, candidates[i]); });
+    return doc.body.innerHTML;
+}
+/** Rewrite real HTML table links, leaving fenced code examples intact. */
+export function rewriteTableLinks(markdown, rewrite) {
+    if (!/<table[\s>]/i.test(markdown))
+        return markdown;
+    const tokens = htmlTableMarkdown().parse(markdown, {});
+    const lines = markdown.split('\n');
+    for (const token of tokens.reverse()) {
+        if (token.type !== 'html_block' || !token.map || !/<table[\s>]/i.test(token.content))
+            continue;
+        const doc = createDocument(token.content);
+        let changed = false;
+        for (const anchor of Array.from(doc.querySelectorAll('table a[href]'))) {
+            const href = anchor.getAttribute('href');
+            const next = rewrite(href);
+            if (next !== href) {
+                anchor.setAttribute('href', next);
+                changed = true;
+            }
+        }
+        if (changed)
+            lines.splice(token.map[0], token.map[1] - token.map[0], doc.body.innerHTML.trimEnd());
+    }
+    return lines.join('\n');
+}

package/dist/runtime/network.js

@@ -0,0 +1,4 @@
+/** Network boundary shared by CLI and hosted Node execution. Browser builds bind
+ * this boundary to the same-origin Confluence gateway instead of replacing fetch globally.
+ */
+export const confluenceFetch = (input, init) => globalThis.fetch(input, init);

package/dist/shared/colors.js

@@ -1,12 +1,12 @@
 /**
  * 의존성 없는 ANSI 컬러 헬퍼.
  * 비활성 조건: NO_COLOR / TERM=dumb / --no-color / 출력이 TTY 가 아님(파이프·리다이렉트).
- * FORCE_COLOR 가 있으면 강제 활성.
+ * FORCE_COLOR=1은 파이프에서도 활성, FORCE_COLOR=0은 비활성. 명시적 비활성 조건이 우선한다.
  */
 const enabled = !process.env.NO_COLOR &&
     process.env.TERM !== 'dumb' &&
     !process.argv.includes('--no-color') &&
-    (process.env.FORCE_COLOR ? true : process.stdout.isTTY === true);
+    (process.env.FORCE_COLOR === '0' ? false : process.env.FORCE_COLOR ? true : process.stdout.isTTY === true);
 const wrap = (open, close) => (s) => enabled ? `\x1b[${open}m${s}\x1b[${close}m` : String(s);
 export const bold = wrap(1, 22);
 export const dim = wrap(2, 22);