@wonseok-han/confluence-sync 1.8.0 → 2.0.0

package/dist/conversion/footnotes.js

@@ -2,17 +2,79 @@ import MarkdownIt from 'markdown-it';
 import footnote from 'markdown-it-footnote';
 import { collectHeadings } from '../documents/anchors.js';
 import { mapMarkdownText, replaceGeneratedBlocks } from './pdf-pages.js';
+/** Registered rule names survive minification; Function.name does not. */
+function registeredRule(ruler, name) {
+    const before = ruler.getRules('');
+    ruler.disable(name);
+    const remaining = new Set(ruler.getRules(''));
+    ruler.enable(name);
+    const rule = before.find(fn => !remaining.has(fn));
+    if (!rule)
+        throw new Error(`각주 파서 규칙을 찾을 수 없습니다: ${name}`);
+    return rule;
+}
+/** Use the parser's balanced inline-note rule, preserving code and escaped examples. */
+function extractInlineNotes(source) {
+    const md = new MarkdownIt({ html: true }).use(footnote);
+    const rule = registeredRule(md.inline.ruler, 'footnote_inline');
+    const definitions = [], labels = new Set();
+    let edits = [], depth = 0, serial = 0;
+    md.inline.ruler.at('footnote_inline', (state, silent) => {
+        const start = state.pos;
+        depth++;
+        let ok;
+        try {
+            ok = rule(state, silent);
+        }
+        finally {
+            depth--;
+        }
+        if (ok && !silent && depth === 0) {
+            let label;
+            do {
+                label = `csync-inline-${++serial}`;
+            } while (source.includes(`[^${label}]`));
+            labels.add(label);
+            definitions.push(`[^${label}]: ${state.src.slice(start + 2, state.pos - 1).replace(/\n/g, '\n    ')}`);
+            edits.push({ start, end: state.pos, text: `[^${label}]` });
+        }
+        return ok;
+    });
+    const lines = source.split('\n'), offsets = [0];
+    for (const line of lines)
+        offsets.push(offsets[offsets.length - 1] + line.length + 1);
+    const spans = new MarkdownIt({ html: true }).parse(source, {}).filter(t => ['fence', 'code_block', 'html_block'].includes(t.type) && t.map)
+        .map(t => [offsets[t.map[0]], Math.min(offsets[t.map[1]], source.length)]);
+    const prose = (part) => {
+        edits = [];
+        md.inline.parse(part, md, {}, []);
+        for (const edit of edits.sort((a, b) => b.start - a.start))
+            part = part.slice(0, edit.start) + edit.text + part.slice(edit.end);
+        return part;
+    };
+    let cursor = 0, text = '';
+    for (const [start, end] of spans) {
+        if (start < cursor)
+            continue;
+        text += prose(source.slice(cursor, start)) + source.slice(start, end);
+        cursor = end;
+    }
+    text += prose(source.slice(cursor));
+    return { text: definitions.length ? text.trimEnd() + '\n\n' + definitions.join('\n\n') + '\n' : source, labels };
+}
 /** 각주 확장을 일반 제목 앵커 + 위첨자 Markdown 링크로 내보낸다. */
 export function footnotesToLinks(source) {
-    if (!source.includes('[^'))
+    if (!source.includes('[^') && !source.includes('^['))
         return source;
+    const inline = extractInlineNotes(source);
+    source = inline.text;
     const md = new MarkdownIt({ html: true }).use(footnote);
     const definitions = [];
     const lines = source.split('\n');
     const offsets = [0];
     for (const line of lines)
         offsets.push(offsets[offsets.length - 1] + line.length + 1);
-    const defRule = md.block.ruler.getRules('').find((r) => r.name === 'footnote_def');
+    const defRule = registeredRule(md.block.ruler, 'footnote_def');
     md.block.ruler.at('footnote_def', (state, start, end, silent) => {
         const ok = defRule(state, start, end, silent);
         if (ok && !silent) {
@@ -33,7 +95,7 @@ export function footnotesToLinks(source) {
     const labels = new Set(definitions.map((d) => d.label));
     const notes = new Map();
     const edits = [];
-    const refRule = md.inline.ruler.getRules('').find((r) => r.name === 'footnote_ref');
+    const refRule = registeredRule(md.inline.ruler, 'footnote_ref');
     let localEdits = [];
     md.inline.ruler.at('footnote_ref', (state, silent) => {
         const start = state.pos;
@@ -58,7 +120,7 @@ export function footnotesToLinks(source) {
         }
         return ok;
     });
-    // 인라인 각주(^[...])는 이 변환의 대상이 아니다.
+    // Inline notes have already been assigned collision-free definition labels.
     md.inline.ruler.disable('footnote_inline');
     const replaceRefs = (text) => {
         localEdits = [];
@@ -91,20 +153,61 @@ export function footnotesToLinks(source) {
     for (const e of edits.sort((a, b) => b.start - a.start))
         result = result.slice(0, e.start) + e.text + result.slice(e.end);
     const bodies = new Map(definitions.map((d) => [d.label, d.body]));
-    return result.trimEnd() + '\n\n' + [...notes].map(([label, note]) => `<!-- csync-footnote:v1 ${Buffer.from(JSON.stringify({ label, anchor: note.anchor })).toString('base64')} -->\n###### ${note.heading}\n\n${replaceRefs(bodies.get(label) ?? '')}\n<!-- /csync-footnote -->`).join('\n\n') + '\n';
+    return result.trimEnd() + '\n\n' + [...notes].map(([label, note]) => `<!-- csync-footnote:v1 ${Buffer.from(JSON.stringify({ label, anchor: note.anchor, ...(inline.labels.has(label) ? { inline: true } : {}) })).toString('base64')} -->\n###### ${note.heading}\n\n${replaceRefs(bodies.get(label) ?? '')}\n<!-- /csync-footnote -->`).join('\n\n') + '\n';
 }
 /** 생성 표식이 있는 각주만 복원한다. 설명의 사용자 수정은 유지한다. */
 export function linksToFootnotes(source) {
     const refs = new Map();
     const definitions = [];
-    const text = replaceGeneratedBlocks(source, /<!-- csync-footnote:v1 ([A-Za-z0-9+/=]+) -->\n#{1,6} [^\n]+\n\n([\s\S]*?)\n<!-- \/csync-footnote -->/g, (_all, encoded, body) => {
-        const { label, anchor } = JSON.parse(Buffer.from(encoded, 'base64').toString());
-        refs.set(anchor, label);
-        definitions.push(`[^${label}]: ${body.trimEnd().split('\n').join('\n    ')}`);
+    const inlined = new Set();
+    const parser = new MarkdownIt({ html: true }).use(footnote);
+    const text = replaceGeneratedBlocks(source, /<!-- csync-footnote:v1 ([A-Za-z0-9+/=]+) -->\n+#{1,6} [^\n]+\n\n([\s\S]*?)\n<!-- \/csync-footnote -->/g, (_all, encoded, body) => {
+        const data = decodeFootnote(encoded);
+        if (!data)
+            return _all;
+        const { label, anchor } = data;
+        refs.set(anchor, { label, body: body.trimEnd(), inline: data.inline === true });
+        if (!data.inline)
+            definitions.push(`[^${label}]: ${body.trimEnd().split('\n').join('\n    ')}`);
         return '';
     });
     if (!refs.size)
         return source;
-    const replace = (s) => mapMarkdownText(s, p => p.replace(/<sup>\[\d+\]\(#([^\s)]+)\)<\/sup>/g, (all, anchor) => refs.has(decodeURIComponent(anchor)) ? `[^${refs.get(decodeURIComponent(anchor))}]` : all));
-    return replace(text).trimEnd() + '\n\n' + definitions.map(replace).join('\n\n') + '\n';
+    const replace = (s) => mapMarkdownText(s, p => p.replace(/<sup>\[\d+\]\(#([^\s)]+)\)<\/sup>/g, (all, anchor) => {
+        const note = refs.get(safeDecode(anchor));
+        if (!note)
+            return all;
+        if (note.inline && !/\n\s*\n/.test(note.body)) {
+            const candidate = `^[${note.body}]`, tokens = [];
+            parser.inline.parse(candidate, parser, {}, tokens);
+            if (tokens.length === 1 && tokens[0].type === 'footnote_ref') {
+                inlined.add(safeDecode(anchor));
+                return candidate;
+            }
+        }
+        return `[^${note.label}]`;
+    }));
+    const main = replace(text).trimEnd();
+    // A remotely removed inline reference must not discard the remaining note text.
+    for (const [anchor, note] of refs)
+        if (note.inline && !inlined.has(anchor))
+            definitions.push(`[^${note.label}]: ${note.body.split('\n').join('\n    ')}`);
+    const notes = definitions.map(replace).join('\n\n');
+    return main + (notes ? '\n\n' + notes : '') + '\n';
+}
+export function decodeFootnote(encoded) {
+    if (encoded.length > 8000)
+        return;
+    try {
+        const data = JSON.parse(Buffer.from(encoded, 'base64').toString('utf8'));
+        if (data && typeof data.label === 'string' && /^[^\s\[\]\r\n]+$/.test(data.label) && typeof data.anchor === 'string' && /^[\p{L}\p{N}_-]+$/u.test(data.anchor) && (data.inline === undefined || typeof data.inline === 'boolean'))
+            return data;
+    }
+    catch { /* Preserve malformed metadata rather than consuming unrelated content. */ }
+}
+function safeDecode(value) { try {
+    return decodeURIComponent(value);
 }
+catch {
+    return value;
+} }

package/dist/conversion/markdown.js

@@ -0,0 +1,26 @@
+/** Shared Obsidian → Markdown preparation for convert and publishing. */
+import { relative, dirname, resolve } from 'node:path';
+import { vaultResolver } from '../documents/catalog.js';
+import { resolveWikilinks } from '../documents/obsidian.js';
+import { attachmentMapper } from './attachments.js';
+import { footnotesToLinks } from './footnotes.js';
+import { extractPdfPages, mapMarkdownText } from './pdf-pages.js';
+export async function prepareMarkdown(text, file, base, vault, output, dryRun, attachments = attachmentMapper(file, base), restoreAssets = true) {
+    const slash = (path) => path.split('\\').join('/');
+    const rel = slash(relative(base, file)), lookup = vaultResolver(rel, vault);
+    text = attachments.rewrite(text);
+    text = resolveWikilinks(text, (target, embed) => {
+        const imported = resolve(base, target);
+        if (attachments.copies.has(slash(relative(base, imported))))
+            return slash(relative(dirname(file), imported));
+        return lookup(target, embed);
+    });
+    text = footnotesToLinks(attachments.rewrite(text));
+    mapMarkdownText(text, part => {
+        if (/\[\[[^\]\n]*\.pdf#page=[^\]\n]*\]\]/i.test(part))
+            throw new Error(`PDF 위키링크를 해석하지 못했습니다 (${rel}). --base에 PDF가 포함되는지 확인하세요.`);
+        return part;
+    });
+    const pdf = await extractPdfPages(text, file, base, output, dryRun, attachments.source, restoreAssets);
+    return { ...pdf, copies: attachments.copies };
+}

package/dist/conversion/pdf-pages.js

@@ -1,25 +1,27 @@
+import { documentAttachmentDir } from './asset-paths.js';
 import { createHash } from 'node:crypto';
 import { readFileSync, existsSync, realpathSync } from 'node:fs';
 import { resolve, relative, dirname } from 'node:path';
 import { renderPdfPages } from './pdf-renderer.js';
 import MarkdownIt from 'markdown-it';
 import { collectHeadings } from '../documents/anchors.js';
+import { isConfluenceWebPath } from '../confluence/links.js';
 const encode = (value) => Buffer.from(JSON.stringify(value)).toString('base64');
 const decode = (value) => JSON.parse(Buffer.from(value, 'base64').toString());
 const parser = new MarkdownIt({ html: true });
 /** 소스 위치를 유지하면서 코드·HTML 블록을 제외한 일반 텍스트를 처리한다. */
-export function mapMarkdownText(text, fn) {
+export function mapMarkdownText(text, fn, htmlFn) {
     const lines = text.split('\n'), offsets = [0];
     for (const line of lines)
         offsets.push(offsets[offsets.length - 1] + line.length + 1);
     const spans = parser.parse(text, {}).filter(t => ['fence', 'code_block', 'html_block'].includes(t.type) && t.map)
-        .map(t => [offsets[t.map[0]], Math.min(offsets[t.map[1]], text.length)]);
+        .map(t => [offsets[t.map[0]], Math.min(offsets[t.map[1]], text.length), t.type === 'html_block' ? 1 : 0]);
     let cursor = 0, result = '';
     const prose = (s) => protectInline(s, fn);
-    for (const [start, end] of spans) {
+    for (const [start, end, html] of spans) {
         if (start < cursor)
             continue;
-        result += prose(text.slice(cursor, start)) + text.slice(start, end);
+        result += prose(text.slice(cursor, start)) + (html && htmlFn ? htmlFn(text.slice(start, end)) : text.slice(start, end));
         cursor = end;
     }
     return result + prose(text.slice(cursor));
@@ -76,7 +78,7 @@ function requireLocal(abs, base) {
     if (rel === '..' || rel.startsWith('../') || rel.startsWith('..\\'))
         throw new Error(`PDF는 --base 안에 있어야 합니다: ${abs}`);
 }
-export async function extractPdfPages(text, file, base, output, dryRun, source = p => p) {
+export async function extractPdfPages(text, file, base, output, dryRun, source = p => p, restoreAssets = true) {
     const assets = new Set(), headings = new Set(collectHeadings(text).map(h => h.slug));
     const pages = new Map();
     const hashes = new Map();
@@ -93,7 +95,7 @@ export async function extractPdfPages(text, file, base, output, dryRun, source =
         catch {
             return all;
         }
-        if (/^[a-z][a-z\d+.-]*:/i.test(dest))
+        if (/^[a-z][a-z\d+.-]*:/i.test(dest) || isConfluenceWebPath(dest))
             return all;
         const m = dest.match(/^(.*\.pdf)#page=(\d+)$/i);
         if (!m)
@@ -124,7 +126,7 @@ export async function extractPdfPages(text, file, base, output, dryRun, source =
                 anchor = `${initialAnchor}-${suffix}`;
             }
             headings.add(anchor);
-            const assetRel = `attachments/pdf-pages/pdfjs-${key}.png`;
+            const assetRel = `${documentAttachmentDir(file, base)}/pdfjs-${key}.png`;
             const target = resolve(output, assetRel);
             jobs.push({ file: abs, page, target });
             const outputFile = resolve(output, relative(base, file));
@@ -141,7 +143,7 @@ export async function extractPdfPages(text, file, base, output, dryRun, source =
     const withInlineImages = replaceGeneratedBlocks(text, /<!-- csync-footnote:v1 [A-Za-z0-9+/=]+ -->\n[\s\S]*?<!-- \/csync-footnote -->/g, block => convertLinks(block, true));
     const converted = convertLinks(withInlineImages, false);
     if (!pages.size)
-        return { text, assets: restorePdfReferences(text, file, base).assets, pages: 0 };
+        return { text, assets: restoreAssets ? restorePdfReferences(text, file, base).assets : [], pages: 0 };
     await renderPdfPages(jobs, dryRun);
     const gallery = [...pages.values()].filter(p => p.gallery).map(p => `### ${p.heading}\n\n![${p.heading}](<${p.image}>)`).join('\n\n');
     return { text: converted.trimEnd() + (gallery ? `\n\n<!-- csync-pdf-pages:v1 -->\n${gallery}\n<!-- /csync-pdf-pages -->\n` : '\n'), assets: [...assets], pages: pages.size };

package/dist/documents/anchors.js

@@ -9,6 +9,7 @@
  * 대신 링크 대상이 되는 헤딩 앞에 **Anchor 매크로로 이름을 직접 심고**, 링크는 그 이름을 가리킨다.
  * 이름은 마크다운 슬러그를 그대로 쓰므로 왕복도 정확해진다 — 양쪽 다 우리가 정한 값이다.
  */
+import { rewriteTableLinks } from './tables.js';
 const FENCE = /^\s*(?:```|~~~)/;
 /**
  * `[[대상]]` · `[[대상|별칭]]` · `[[대상#헤딩]]` · `[[#헤딩]]` · `![[임베드]]`
@@ -170,6 +171,14 @@ export function collectLinkAnchors(md) {
             out.push({ dest: w.target, fragment: w.fragment, wiki: true }); // dest 가 비면 같은 문서
         }
     }
+    rewriteTableLinks(md, href => {
+        const d = decodeAnchor(href);
+        const i = d.indexOf('#');
+        if (i >= 0 && i < d.length - 1 && !/^[a-z][a-z\d+.-]*:|^\/\//i.test(d)) {
+            out.push({ dest: d.slice(0, i), fragment: d.slice(i + 1), wiki: false });
+        }
+        return href;
+    });
     return out;
 }
 /** Anchor 매크로 — 링크 대상 헤딩 바로 앞에 심어 이름을 고정한다. */

package/dist/documents/callout-roundtrip.js

@@ -0,0 +1,75 @@
+/** Recover panel structure using rendered bodies and storage-only callout metadata. */
+import { createDocument } from '@mixmark-io/domino';
+import { calloutMarker, calloutStyle, inferCallout } from './callouts.js';
+const direct = (el, name) => Array.from(el.children).find(child => child.nodeName.toLowerCase() === name);
+function metadata(panel) {
+    const body = direct(panel, 'ac:rich-text-body');
+    const anchor = body && direct(body, 'ac:structured-macro');
+    if (anchor?.getAttribute('ac:name') !== 'anchor')
+        return;
+    const value = direct(anchor, 'ac:parameter')?.textContent ?? '';
+    if (!value.startsWith(calloutMarker) || value.length > 2000)
+        return;
+    try {
+        const data = JSON.parse(Buffer.from(value.slice(calloutMarker.length), 'base64url').toString('utf8'));
+        if (typeof data.type === 'string' && /^[a-z\d_-]+$/i.test(data.type) && ['', '+', '-'].includes(data.fold) && typeof data.explicit === 'boolean')
+            return data;
+    }
+    catch { /* Older or edited metadata is handled as an ordinary panel. */ }
+}
+function panelParts(panel) {
+    const children = Array.from(panel.children);
+    return { header: children.find(el => el.classList.contains('panelHeader')), body: children.find(el => el.classList.contains('panelContent')) };
+}
+export function restoreCalloutPanels(html, storage) {
+    const doc = createDocument(html);
+    for (const el of Array.from(doc.querySelectorAll('[data-csync-callout]')))
+        el.removeAttribute('data-csync-callout');
+    const panels = Array.from(doc.querySelectorAll('div.panel')).filter(panel => !!panelParts(panel).body);
+    // Storage is XML; protect code CDATA before parsing its macro hierarchy as HTML.
+    const safeStorage = storage?.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, (_all, text) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'));
+    const stored = safeStorage ? Array.from(createDocument(safeStorage).querySelectorAll('*')).filter(el => el.nodeName.toLowerCase() === 'ac:structured-macro' && el.getAttribute('ac:name') === 'panel') : [];
+    // Never shift metadata onto another panel if export_view omitted or added a panel.
+    const aligned = panels.length === stored.length;
+    panels.forEach((panel, i) => {
+        const { header, body } = panelParts(panel);
+        const title = header?.textContent?.trim() ?? '';
+        const source = aligned ? stored[i] : undefined;
+        const parameter = (name) => source && Array.from(source.children).find(el => el.nodeName.toLowerCase() === 'ac:parameter' && el.getAttribute('ac:name') === name)?.textContent?.trim();
+        const data = source && parameter('title') === title ? metadata(source) : undefined;
+        const background = parameter('bgColor') ?? '';
+        panel.setAttribute('data-csync-callout', JSON.stringify({ type: data?.type ?? inferCallout(title, background), fold: data?.fold ?? '', explicit: data?.explicit ?? true, title }));
+        // Our invisible anchor is metadata, never a Markdown link target or body text.
+        for (const anchor of Array.from(body.querySelectorAll('[id], [name]'))) {
+            if ((anchor.getAttribute('id') ?? '').includes(calloutMarker) || (anchor.getAttribute('name') ?? '').includes(calloutMarker))
+                anchor.remove();
+        }
+        for (const anchor of Array.from(body.querySelectorAll('*'))) {
+            if (anchor.nodeName.toLowerCase() === 'ac:structured-macro' && anchor.getAttribute('ac:name') === 'anchor' && direct(anchor, 'ac:parameter')?.textContent?.startsWith(calloutMarker))
+                anchor.remove();
+        }
+    });
+    return doc.body.innerHTML;
+}
+export function installPanelRule(td, obsidian) {
+    // Keep the header in the DOM until conversion so title-only panels are not blank.
+    td.addRule('confluencePanelTitle', {
+        filter: node => {
+            const el = node;
+            return !!el.classList?.contains('panelHeader') && !!el.parentElement?.hasAttribute('data-csync-callout');
+        },
+        replacement: () => '',
+    });
+    td.addRule('confluencePanel', {
+        filter: node => node.hasAttribute?.('data-csync-callout') ?? false,
+        replacement: (content, node) => {
+            const { type, fold, explicit, title } = JSON.parse(node.getAttribute('data-csync-callout'));
+            const textTitle = String(title).replace(/[\r\n]+/g, ' ').trim();
+            const quote = (text) => text.split('\n').map(line => line ? `> ${line}` : '>').join('\n');
+            const head = obsidian
+                ? `[!${type}]${fold}${textTitle && (explicit || textTitle !== calloutStyle(type).title) ? ` ${textTitle}` : ''}`
+                : textTitle ? `**${td.escape(textTitle)}**` : '';
+            return `\n\n${quote([head, content.trim()].filter(Boolean).join(obsidian ? '\n' : '\n\n'))}\n\n`;
+        },
+    });
+}

package/dist/documents/callouts.js

@@ -0,0 +1,74 @@
+import { anchorMacro } from './anchors.js';
+export const calloutMarker = 'csync-callout-v1-';
+const styles = {
+    note: { title: '노트', color: '#526078', background: '#f4f5f7' },
+    abstract: { title: '요약', color: '#006b76', background: '#e6fcff' },
+    info: { title: '안내', color: '#0747a6', background: '#deebff' },
+    todo: { title: '할 일', color: '#0747a6', background: '#deebff' },
+    tip: { title: '팁', color: '#006b76', background: '#e6fcff' },
+    success: { title: '성공', color: '#006644', background: '#e3fcef' },
+    question: { title: '질문', color: '#974f0c', background: '#fff0b3' },
+    warning: { title: '주의', color: '#974f0c', background: '#fff0b3' },
+    failure: { title: '실패', color: '#ae2a19', background: '#ffebe6' },
+    danger: { title: '위험', color: '#ae2a19', background: '#ffebe6' },
+    bug: { title: '버그', color: '#ae2a19', background: '#ffebe6' },
+    example: { title: '예시', color: '#403294', background: '#eae6ff' },
+    quote: { title: '인용', color: '#526078', background: '#f4f5f7' },
+};
+const aliases = { summary: 'abstract', tldr: 'abstract', hint: 'tip', important: 'tip', check: 'success', done: 'success', help: 'question', faq: 'question', caution: 'warning', attention: 'warning', fail: 'failure', missing: 'failure', error: 'danger', cite: 'quote' };
+export function calloutStyle(raw) {
+    const type = Object.hasOwn(aliases, raw.toLowerCase()) ? aliases[raw.toLowerCase()] : raw.toLowerCase();
+    return Object.hasOwn(styles, type) ? styles[type] : styles.note;
+}
+export function inferCallout(title, background) {
+    return Object.entries(styles).find(([, style]) => style.title === title && style.background === background.toLowerCase())?.[0] ?? 'note';
+}
+const escape = (value) => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+/** Transform actual quote tokens, leaving code examples and ordinary quotes untouched. */
+export function installCallouts(md, format) {
+    md.core.ruler.after('inline', 'obsidian_callouts', state => {
+        // Compatibility rendering is read-only and only used to verify older baselines.
+        if (state.env?.legacyCallouts === true)
+            return;
+        const tokens = state.tokens;
+        let serial = 0;
+        for (let i = 0; i < tokens.length; i++) {
+            if (tokens[i].type !== 'blockquote_open' || tokens[i + 1]?.type !== 'paragraph_open' || tokens[i + 2]?.type !== 'inline' || tokens[i + 3]?.type !== 'paragraph_close')
+                continue;
+            const inline = tokens[i + 2], newline = inline.content.indexOf('\n');
+            const header = newline < 0 ? inline.content : inline.content.slice(0, newline);
+            const match = header.match(/^\[!([a-z\d_-]+)\]([+-]?)(?:[ \t]+(.*))?[ \t]*$/i);
+            if (!match)
+                continue;
+            let end = i + 1, depth = 1;
+            for (; end < tokens.length; end++) {
+                if (tokens[end].type === 'blockquote_open')
+                    depth++;
+                if (tokens[end].type === 'blockquote_close' && --depth === 0)
+                    break;
+            }
+            if (end === tokens.length)
+                continue;
+            const style = calloutStyle(match[1]);
+            const marker = format === 'html' || state.env?.legacyCallouts === 'panels' ? '' : anchorMacro(calloutMarker + Buffer.from(JSON.stringify({ type: match[1], fold: match[2], explicit: !!match[3]?.trim(), index: serial++ })).toString('base64url'));
+            tokens[i].type = 'callout_open';
+            tokens[i].meta = { ...style, title: match[3]?.trim() || style.title, marker };
+            tokens[end].type = 'callout_close';
+            if (newline < 0)
+                tokens.splice(i + 1, 3);
+            else {
+                inline.content = inline.content.slice(newline + 1);
+                inline.children = [];
+                state.md.inline.parse(inline.content, state.md, state.env, inline.children);
+            }
+        }
+    });
+    md.renderer.rules.callout_open = (tokens, idx) => {
+        const { title, color, background, marker } = tokens[idx].meta;
+        if (format === 'html')
+            return `<blockquote style="background-color:${background};color:${color}"><p><strong>${escape(title)}</strong></p>\n`;
+        const parameter = (name, value) => `<ac:parameter ac:name="${name}">${escape(value)}</ac:parameter>`;
+        return '<ac:structured-macro ac:name="panel">' + parameter('title', title) + parameter('borderColor', color) + parameter('titleColor', color) + parameter('titleBGColor', background) + parameter('bgColor', background) + '<ac:rich-text-body>\n' + marker;
+    };
+    md.renderer.rules.callout_close = () => format === 'html' ? '</blockquote>\n' : '</ac:rich-text-body></ac:structured-macro>\n';
+}

package/dist/documents/catalog.js

@@ -168,7 +168,7 @@ export function buildFolderIndex(rels) {
 const parentDirOf = (dir) => (dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : '');
 /**
  * dir 의 직계 자식을 담는 "컨테이너"의 mapping 키.
- * - 루트('') → null (CONFLUENCE_PARENT_ID)
+ * - 루트('') → null (저장된 원격 스코프)
  * - README 가 있는 폴더 → 그 README 페이지 키
  * - README 가 없는 폴더 → 폴더 노드 키(`<dir>/`, 끝에 슬래시로 구분)
  */
@@ -226,7 +226,7 @@ export function resolveSelection(rels, positionals, baseDir) {
             console.error(`  ⚠ base 밖 경로 무시: ${p}`);
             continue;
         }
-        const matched = rels.filter((r) => r === relToBase || r.startsWith(relToBase + '/'));
+        const matched = rels.filter((r) => !relToBase || r === relToBase || r.startsWith(relToBase + '/'));
         if (matched.length === 0)
             console.error(`  ⚠ 매칭되는 문서 없음: ${p}`);
         matched.forEach((m) => set.add(m));

package/dist/documents/footnote-roundtrip.js

@@ -0,0 +1,96 @@
+/** Footnote restoration metadata uses native invisible Confluence anchors. */
+import { createDocument } from '@mixmark-io/domino';
+import { anchorMacro, matchConfluenceAnchor } from './anchors.js';
+import { decodeFootnote } from '../conversion/footnotes.js';
+const prefix = 'csync-footnote-v1-';
+const startComment = (encoded) => `<!-- csync-footnote:v1 ${encoded} -->`;
+const endComment = '<!-- /csync-footnote -->';
+const markerName = (encoded, end) => prefix + (end ? 'end-' : 'start-') + Buffer.from(encoded, 'base64').toString('base64url');
+/** CDATA code examples and unrelated comments are never rewritten. */
+export function footnotesToStorage(storage) {
+    let current;
+    return storage.replace(/<!\[CDATA\[[\s\S]*?\]\]>|<!-- csync-footnote:v1 ([A-Za-z0-9+/=]+) -->|<!-- \/csync-footnote -->/g, (whole, encoded) => {
+        if (encoded) {
+            if (!decodeFootnote(encoded))
+                return whole;
+            current = encoded;
+            return anchorMacro(markerName(encoded, false));
+        }
+        if (whole === endComment && current) {
+            const end = anchorMacro(markerName(current, true));
+            current = undefined;
+            return end;
+        }
+        return whole;
+    });
+}
+/** Keep pre-metadata document hashes stable; the visible body is still hashed. */
+export function footnoteStorageComments(storage) {
+    return storage.replace(/<!\[CDATA\[[\s\S]*?\]\]>|<ac:structured-macro ac:name="anchor"><ac:parameter ac:name="">csync-footnote-v1-(start|end)-([A-Za-z0-9_-]+)<\/ac:parameter><\/ac:structured-macro>/g, (whole, kind, encoded) => {
+        if (!kind || !encoded)
+            return whole;
+        const base64 = Buffer.from(encoded, 'base64url').toString('base64');
+        return decodeFootnote(base64) ? kind === 'start' ? startComment(base64) : endComment : whole;
+    });
+}
+export function restoreFootnoteAnchors(html, storage, pageId) {
+    const doc = createDocument(html);
+    for (const node of Array.from(doc.querySelectorAll('[data-csync-footnote]')))
+        node.removeAttribute('data-csync-footnote');
+    if (!storage?.includes(prefix))
+        return doc.body.innerHTML;
+    const names = new Map();
+    // Only accept markers paired in storage, not look-alike anchors in the rendered body.
+    const starts = new Set(), ends = new Set();
+    for (const match of storage.matchAll(/<ac:structured-macro\b[^>]*ac:name="anchor"[^>]*>\s*<ac:parameter\b[^>]*ac:name=""[^>]*>csync-footnote-v1-(start|end)-([A-Za-z0-9_-]+)<\/ac:parameter>\s*<\/ac:structured-macro>/g)) {
+        const encoded = Buffer.from(match[2], 'base64url').toString('base64');
+        if (decodeFootnote(encoded))
+            (match[1] === 'start' ? starts : ends).add(encoded);
+    }
+    for (const encoded of starts)
+        if (ends.has(encoded)) {
+            names.set(markerName(encoded, false), { encoded, end: false });
+            names.set(markerName(encoded, true), { encoded, end: true });
+        }
+    if (!names.size)
+        return doc.body.innerHTML;
+    const found = new Map();
+    for (const node of Array.from(doc.querySelectorAll('[id], [name]'))) {
+        const id = node.getAttribute('id') ?? node.getAttribute('name') ?? '';
+        const entry = [...names].find(([name]) => id.endsWith(name));
+        if (entry) {
+            const nodes = found.get(entry[0]) ?? [];
+            nodes.push(node);
+            found.set(entry[0], nodes);
+        }
+    }
+    const active = [...starts].filter(encoded => found.get(markerName(encoded, false))?.length === 1 && found.get(markerName(encoded, true))?.length === 1);
+    const headings = active.map(encoded => { const meta = decodeFootnote(encoded); return { text: meta.anchor, slug: meta.anchor, level: 6 }; });
+    for (const link of Array.from(doc.querySelectorAll('sup a[href]'))) {
+        const href = link.getAttribute('href');
+        const target = href.match(/\/pages\/(\d+)/)?.[1] ?? href.match(/[?&]pageId=(\d+)/)?.[1];
+        if (!href.startsWith('#') && (!pageId || target !== pageId))
+            continue;
+        const fragment = href.split('#').slice(1).join('#');
+        const match = matchConfluenceAnchor(fragment, headings, '');
+        if (match)
+            link.setAttribute('href', `#${match.slug}`);
+    }
+    for (const encoded of active)
+        for (const end of [false, true]) {
+            const node = found.get(markerName(encoded, end))[0];
+            node.setAttribute('data-csync-footnote', JSON.stringify({ encoded, end }));
+            node.textContent = 'csync-footnote-marker';
+        }
+    return doc.body.innerHTML;
+}
+export function installFootnoteRules(td) {
+    td.addRule('confluenceFootnoteMetadata', {
+        filter: node => !!node.hasAttribute?.('data-csync-footnote'),
+        replacement: (_content, node) => {
+            const { encoded, end } = JSON.parse(node.getAttribute('data-csync-footnote'));
+            return `\n\n${end ? endComment : startComment(encoded)}\n\n`;
+        },
+    });
+    td.addRule('superscript', { filter: 'sup', replacement: content => `<sup>${content}</sup>` });
+}