@knpkv/confluence-to-markdown 0.5.0 → 0.6.0

package/src/serializers/ConfluenceSerializer.ts

@@ -1,737 +0,0 @@
-/**
- * Serializer for AST to Confluence storage format (HTML).
- *
- * @module
- */
-import * as Effect from "effect/Effect"
-import type { CodeBlock, Heading, Image, Paragraph, Table, ThematicBreak, UnsupportedBlock } from "../ast/BlockNode.js"
-import type { Document, DocumentNode } from "../ast/Document.js"
-import type { InlineNode } from "../ast/InlineNode.js"
-import type { SerializeError } from "../SchemaConverterError.js"
-
-/**
- * Serialize Document AST to Confluence storage format HTML.
- *
- * @example
- * ```typescript
- * import { serializeToConfluence } from "@knpkv/confluence-to-markdown/serializers/ConfluenceSerializer"
- * import { makeDocument, Heading, Text } from "@knpkv/confluence-to-markdown/ast"
- * import { Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const doc = makeDocument([
- *     new Heading({ level: 1, children: [new Text({ value: "Title" })] })
- *   ])
- *   const html = yield* serializeToConfluence(doc)
- *   console.log(html) // <h1>Title</h1>
- * })
- * ```
- *
- * @category Serializers
- */
-export const serializeToConfluence = (doc: Document): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    // 1-to-1 roundtrip: if rawConfluence is available, return it as-is
-    if (doc.rawConfluence !== undefined) {
-      return doc.rawConfluence
-    }
-
-    const parts: Array<string> = []
-    for (const node of doc.children) {
-      const serialized = yield* serializeDocumentNode(node)
-      parts.push(serialized)
-    }
-    const raw = parts.join("\n")
-    // Post-process to reconstruct layouts from markers
-    return reconstructLayouts(raw)
-  })
-
-/**
- * Reconstruct layouts from marker comments.
- *
- * Markers:
- * - <!--cf:layout-start-->
- * - <!--cf:section:index;type;breakoutMode;breakoutWidth;cellCount-->
- * - <!--cf:cell:sectionIndex;cellIndex-->
- * - <!--cf:section-end:index-->
- * - <!--cf:layout-end-->
- */
-const reconstructLayouts = (html: string): string => {
-  // Check if there are any layout markers
-  if (!html.includes("<!--cf:layout-start-->")) {
-    return html
-  }
-
-  let result = html
-
-  // Process each layout block
-  const layoutRegex = /<!--cf:layout-start-->([\s\S]*?)<!--cf:layout-end-->/g
-  result = result.replace(layoutRegex, (_, layoutContent: string) => {
-    // Parse sections from the content
-    const sections: Array<{
-      type: string
-      breakoutMode: string
-      breakoutWidth: string
-      cells: Array<string>
-    }> = []
-
-    // Find all section markers
-    const sectionRegex = /<!--cf:section:(\d+);([^;]*);([^;]*);([^;]*);(\d+)-->/g
-    let sectionMatch
-    const sectionMeta: Array<
-      { index: number; type: string; breakoutMode: string; breakoutWidth: string; cellCount: number }
-    > = []
-
-    while ((sectionMatch = sectionRegex.exec(layoutContent)) !== null) {
-      sectionMeta.push({
-        index: parseInt(sectionMatch[1] ?? "0"),
-        type: decodeURIComponent(sectionMatch[2] ?? "fixed-width"),
-        breakoutMode: decodeURIComponent(sectionMatch[3] ?? ""),
-        breakoutWidth: decodeURIComponent(sectionMatch[4] ?? ""),
-        cellCount: parseInt(sectionMatch[5] ?? "0")
-      })
-    }
-
-    // For each section, extract cell content
-    for (const meta of sectionMeta) {
-      const cells: Array<string> = []
-
-      for (let cellIndex = 0; cellIndex < meta.cellCount; cellIndex++) {
-        const cellStartMarker = `<!--cf:cell:${meta.index};${cellIndex}-->`
-        const nextCellMarker = `<!--cf:cell:${meta.index};${cellIndex + 1}-->`
-        const sectionEndMarker = `<!--cf:section-end:${meta.index}-->`
-        const nextSectionMarker = `<!--cf:section:${meta.index + 1};`
-
-        const cellStart = layoutContent.indexOf(cellStartMarker)
-        if (cellStart === -1) continue
-
-        const contentStart = cellStart + cellStartMarker.length
-
-        // Find where this cell ends - either next cell, section end, or next section
-        let cellEnd = layoutContent.length
-        const nextCell = layoutContent.indexOf(nextCellMarker, contentStart)
-        const secEnd = layoutContent.indexOf(sectionEndMarker, contentStart)
-        const nextSec = layoutContent.indexOf(nextSectionMarker, contentStart)
-
-        if (nextCell !== -1 && nextCell < cellEnd) cellEnd = nextCell
-        if (secEnd !== -1 && secEnd < cellEnd) cellEnd = secEnd
-        if (nextSec !== -1 && nextSec < cellEnd) cellEnd = nextSec
-
-        const cellContent = layoutContent.slice(contentStart, cellEnd).trim()
-        cells.push(cellContent)
-      }
-
-      sections.push({
-        type: meta.type,
-        breakoutMode: meta.breakoutMode,
-        breakoutWidth: meta.breakoutWidth,
-        cells
-      })
-    }
-
-    // Build the layout HTML
-    const sectionHtml = sections.map((section) => {
-      const typeAttr = ` ac:type="${escapeHtml(section.type)}"`
-      const breakoutModeAttr = section.breakoutMode ? ` ac:breakout-mode="${escapeHtml(section.breakoutMode)}"` : ""
-      const breakoutWidthAttr = section.breakoutWidth ? ` ac:breakout-width="${escapeHtml(section.breakoutWidth)}"` : ""
-      const cellsHtml = section.cells.map((c) => `<ac:layout-cell>${c}</ac:layout-cell>`).join("")
-      return `<ac:layout-section${typeAttr}${breakoutModeAttr}${breakoutWidthAttr}>${cellsHtml}</ac:layout-section>`
-    }).join("")
-
-    return `<ac:layout>${sectionHtml}</ac:layout>`
-  })
-
-  return result
-}
-
-/**
- * Serialize a document node to Confluence HTML.
- */
-const serializeDocumentNode = (node: DocumentNode): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    switch (node._tag) {
-      // Block nodes
-      case "Heading":
-        return yield* serializeHeading({ level: node.level, children: node.children })
-      case "Paragraph":
-        return yield* serializeParagraph({
-          children: node.children,
-          alignment: node.alignment,
-          indent: node.indent
-        })
-      case "CodeBlock":
-        return serializeCodeBlock({ code: node.code, language: node.language })
-      case "ThematicBreak":
-        return "<hr/>"
-      case "Image":
-        return serializeImage({
-          src: node.src,
-          attachment: node.attachment,
-          alt: node.alt,
-          title: node.title,
-          align: node.align,
-          width: node.width
-        })
-      case "Table":
-        return yield* serializeTable({ header: node.header, rows: node.rows })
-      case "List":
-        return yield* serializeList({
-          ordered: node.ordered,
-          start: node.start,
-          children: node.children as unknown as Array<ListItemType>
-        })
-      case "BlockQuote":
-        return yield* serializeBlockQuote({ children: node.children as unknown as Array<SimpleBlock> })
-      case "UnsupportedBlock": {
-        const raw = node.rawHtml || node.rawMarkdown || ""
-        // Check for comment-encoded decision list
-        const decisionMatch = raw.match(/<!--cf:decision:(.*)-->/)
-        if (decisionMatch) {
-          const itemsStr = decisionMatch[1] ?? ""
-          const items = itemsStr.split("|").map((item) => {
-            const parts = item.split(";")
-            return {
-              localId: decodeURIComponent(parts[0] ?? ""),
-              state: decodeURIComponent(parts[1] ?? ""),
-              content: decodeURIComponent(parts[2] ?? "")
-            }
-          })
-          const decisionItems = items.map((item) =>
-            `<ac:adf-node type="decision-item"><ac:adf-attribute key="local-id">${
-              escapeHtml(item.localId)
-            }</ac:adf-attribute><ac:adf-attribute key="state">${
-              escapeHtml(item.state)
-            }</ac:adf-attribute><ac:adf-content>${escapeHtml(item.content)}</ac:adf-content></ac:adf-node>`
-          ).join("")
-          const fallbackItems = items.map((item) => `<li>${escapeHtml(item.content)}</li>`).join("")
-          return `<ac:adf-extension><ac:adf-node type="decision-list">${decisionItems}</ac:adf-node><ac:adf-fallback><ul class="decision-list">${fallbackItems}</ul></ac:adf-fallback></ac:adf-extension>`
-        }
-        // Layout markers are passed through - reconstructLayouts will process them
-        return raw
-      }
-
-      // Macro nodes - serialize to Confluence macros
-      case "InfoPanel":
-        return yield* serializeInfoPanel({
-          panelType: node.panelType,
-          title: node.title,
-          children: node.children as unknown as Array<SimpleBlock>
-        })
-      case "ExpandMacro":
-        return yield* serializeExpandMacro({
-          title: node.title,
-          children: node.children as unknown as Array<SimpleBlock>
-        })
-      case "TocMacro":
-        return serializeTocMacro({ minLevel: node.minLevel, maxLevel: node.maxLevel })
-      case "CodeMacro":
-        return serializeCodeMacro({
-          language: node.language,
-          title: node.title,
-          code: node.code,
-          lineNumbers: node.lineNumbers,
-          collapse: node.collapse,
-          firstLine: node.firstLine
-        })
-      case "StatusMacro":
-        return serializeStatusMacro({ text: node.text, color: node.color })
-      case "TaskList":
-        return yield* serializeTaskList(node.children)
-
-      default:
-        return ""
-    }
-  })
-
-/**
- * Serialize heading.
- */
-const serializeHeading = (
-  node: { level: 1 | 2 | 3 | 4 | 5 | 6; children: ReadonlyArray<InlineNode> }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const content = yield* serializeInlineNodes(node.children)
-    return `<h${node.level}>${content}</h${node.level}>`
-  })
-
-/**
- * Serialize paragraph (with optional alignment and indent).
- */
-const serializeParagraph = (
-  node: {
-    children: ReadonlyArray<InlineNode>
-    alignment?: "left" | "center" | "right" | undefined
-    indent?: number | undefined
-  }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const content = yield* serializeInlineNodes(node.children)
-    const styles: Array<string> = []
-    if (node.alignment) {
-      styles.push(`text-align: ${node.alignment};`)
-    }
-    if (node.indent) {
-      styles.push(`margin-left: ${node.indent}px;`)
-    }
-    const styleAttr = styles.length > 0 ? ` style="${styles.join(" ")}"` : ""
-    return `<p${styleAttr}>${content}</p>`
-  })
-
-/**
- * Serialize code block as Confluence code macro.
- */
-const serializeCodeBlock = (node: { code: string; language?: string | undefined }): string => {
-  const lang = node.language ? `<ac:parameter ac:name="language">${escapeHtml(node.language)}</ac:parameter>` : ""
-  return `<ac:structured-macro ac:name="code">${lang}<ac:plain-text-body><![CDATA[${node.code}]]></ac:plain-text-body></ac:structured-macro>`
-}
-
-/**
- * Serialize image (supports both URL and Confluence attachments).
- */
-const serializeImage = (node: {
-  src?: string | undefined
-  attachment?: { filename: string; version?: number | undefined } | undefined
-  alt?: string | undefined
-  title?: string | undefined
-  align?: string | undefined
-  width?: number | undefined
-}): string => {
-  // Confluence attachment
-  if (node.attachment) {
-    const alignAttr = node.align ? ` ac:align="${node.align}"` : ""
-    const widthAttr = node.width ? ` ac:width="${node.width}"` : ""
-    const altAttr = node.alt ? ` ac:alt="${escapeHtml(node.alt)}"` : ""
-    const versionAttr = node.attachment.version ? ` ri:version-at-save="${node.attachment.version}"` : ""
-    return `<ac:image${alignAttr}${widthAttr}${altAttr}><ri:attachment ri:filename="${
-      escapeHtml(node.attachment.filename)
-    }"${versionAttr}/></ac:image>`
-  }
-
-  // URL-based image
-  const src = node.src ?? ""
-  const alt = node.alt ? ` alt="${escapeHtml(node.alt)}"` : ""
-  const title = node.title ? ` title="${escapeHtml(node.title)}"` : ""
-  return `<img src="${escapeHtml(src)}"${alt}${title}/>`
-}
-
-/**
- * Serialize table.
- */
-const serializeTable = (
-  node: {
-    header?:
-      | { cells: ReadonlyArray<{ isHeader?: boolean | undefined; children: ReadonlyArray<InlineNode> }> }
-      | undefined
-    rows: ReadonlyArray<
-      { cells: ReadonlyArray<{ isHeader?: boolean | undefined; children: ReadonlyArray<InlineNode> }> }
-    >
-  }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const parts: Array<string> = ["<table>"]
-
-    // Header
-    if (node.header) {
-      parts.push("<thead><tr>")
-      for (const cell of node.header.cells) {
-        const content = yield* serializeInlineNodes(cell.children)
-        parts.push(`<th>${content}</th>`)
-      }
-      parts.push("</tr></thead>")
-    }
-
-    // Body
-    if (node.rows.length > 0) {
-      parts.push("<tbody>")
-      for (const row of node.rows) {
-        parts.push("<tr>")
-        for (const cell of row.cells) {
-          const tag = cell.isHeader ? "th" : "td"
-          const content = yield* serializeInlineNodes(cell.children)
-          parts.push(`<${tag}>${content}</${tag}>`)
-        }
-        parts.push("</tr>")
-      }
-      parts.push("</tbody>")
-    }
-
-    parts.push("</table>")
-    return parts.join("")
-  })
-
-// Simple block type for list items (allows nested Lists for sub-bullets).
-type SimpleBlock =
-  | Heading
-  | Paragraph
-  | CodeBlock
-  | ThematicBreak
-  | Image
-  | Table
-  | UnsupportedBlock
-  | NestedList
-
-// Structural shape of a nested list inside a list item.
-type NestedList = {
-  readonly _tag: "List"
-  readonly ordered: boolean
-  readonly start?: number | undefined
-  readonly children: ReadonlyArray<ListItemType>
-}
-
-// List item type
-type ListItemType = {
-  readonly _tag: "ListItem"
-  readonly checked?: boolean | undefined
-  readonly children: ReadonlyArray<SimpleBlock>
-}
-
-/**
- * Serialize list.
- */
-const serializeList = (
-  node: { ordered: boolean; start?: number | undefined; children: ReadonlyArray<ListItemType> }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const tag = node.ordered ? "ol" : "ul"
-    const startAttr = node.ordered && node.start && node.start !== 1 ? ` start="${node.start}"` : ""
-    const parts: Array<string> = [`<${tag}${startAttr}>`]
-
-    for (const item of node.children) {
-      parts.push("<li>")
-      if (item.checked !== undefined) {
-        const checked = item.checked ? " checked" : ""
-        parts.push(`<input type="checkbox"${checked}/>`)
-      }
-      for (const child of item.children) {
-        parts.push(yield* serializeSimpleBlock(child))
-      }
-      parts.push("</li>")
-    }
-
-    parts.push(`</${tag}>`)
-    return parts.join("")
-  })
-
-/**
- * Serialize simple block.
- */
-const serializeSimpleBlock = (node: SimpleBlock): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    switch (node._tag) {
-      case "Heading":
-        return yield* serializeHeading(
-          node as unknown as { level: 1 | 2 | 3 | 4 | 5 | 6; children: ReadonlyArray<InlineNode> }
-        )
-      case "Paragraph":
-        return yield* serializeParagraph(node as unknown as { children: ReadonlyArray<InlineNode> })
-      case "CodeBlock":
-        return serializeCodeBlock(node as unknown as { code: string; language?: string | undefined })
-      case "ThematicBreak":
-        return "<hr/>"
-      case "Image":
-        return serializeImage(node as unknown as { src: string; alt?: string | undefined; title?: string | undefined })
-      case "Table":
-        return yield* serializeTable(
-          node as unknown as {
-            header?:
-              | { cells: ReadonlyArray<{ isHeader?: boolean | undefined; children: ReadonlyArray<InlineNode> }> }
-              | undefined
-            rows: ReadonlyArray<
-              { cells: ReadonlyArray<{ isHeader?: boolean | undefined; children: ReadonlyArray<InlineNode> }> }
-            >
-          }
-        )
-      case "UnsupportedBlock": {
-        const unsupported = node as unknown as { rawHtml?: string; rawMarkdown?: string }
-        return unsupported.rawHtml || unsupported.rawMarkdown || ""
-      }
-      case "List":
-        return yield* serializeList(node)
-      default:
-        return ""
-    }
-  })
-
-/**
- * Serialize block quote.
- */
-const serializeBlockQuote = (
-  node: { children: ReadonlyArray<SimpleBlock> }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const parts: Array<string> = ["<blockquote>"]
-    for (const child of node.children) {
-      parts.push(yield* serializeSimpleBlock(child as SimpleBlock))
-    }
-    parts.push("</blockquote>")
-    return parts.join("")
-  })
-
-/**
- * Serialize info panel as Confluence macro.
- */
-const serializeInfoPanel = (
-  node: { panelType: string; title?: string | undefined; children: ReadonlyArray<SimpleBlock> }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const titleParam = node.title
-      ? `<ac:parameter ac:name="title">${escapeHtml(node.title)}</ac:parameter>`
-      : ""
-
-    const parts: Array<string> = [
-      `<ac:structured-macro ac:name="${node.panelType}">`,
-      titleParam,
-      "<ac:rich-text-body>"
-    ]
-
-    for (const child of node.children) {
-      parts.push(yield* serializeSimpleBlock(child as SimpleBlock))
-    }
-
-    parts.push("</ac:rich-text-body>")
-    parts.push("</ac:structured-macro>")
-    return parts.join("")
-  })
-
-/**
- * Serialize expand macro as Confluence macro.
- */
-const serializeExpandMacro = (
-  node: { title?: string | undefined; children: ReadonlyArray<SimpleBlock> }
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const titleParam = node.title
-      ? `<ac:parameter ac:name="title">${escapeHtml(node.title)}</ac:parameter>`
-      : ""
-
-    const parts: Array<string> = [
-      `<ac:structured-macro ac:name="expand">`,
-      titleParam,
-      "<ac:rich-text-body>"
-    ]
-
-    for (const child of node.children) {
-      parts.push(yield* serializeSimpleBlock(child as SimpleBlock))
-    }
-
-    parts.push("</ac:rich-text-body>")
-    parts.push("</ac:structured-macro>")
-    return parts.join("")
-  })
-
-/**
- * Serialize TOC macro.
- */
-const serializeTocMacro = (node: { minLevel?: number | undefined; maxLevel?: number | undefined }): string => {
-  const params: Array<string> = []
-  if (node.minLevel) {
-    params.push(`<ac:parameter ac:name="minLevel">${node.minLevel}</ac:parameter>`)
-  }
-  if (node.maxLevel) {
-    params.push(`<ac:parameter ac:name="maxLevel">${node.maxLevel}</ac:parameter>`)
-  }
-  return `<ac:structured-macro ac:name="toc">${params.join("")}</ac:structured-macro>`
-}
-
-/**
- * Serialize code macro with full options.
- */
-const serializeCodeMacro = (
-  node: {
-    language?: string | undefined
-    title?: string | undefined
-    code: string
-    lineNumbers?: boolean | undefined
-    collapse?: boolean | undefined
-    firstLine?: number | undefined
-  }
-): string => {
-  const params: Array<string> = []
-  if (node.language) {
-    params.push(`<ac:parameter ac:name="language">${escapeHtml(node.language)}</ac:parameter>`)
-  }
-  if (node.title) {
-    params.push(`<ac:parameter ac:name="title">${escapeHtml(node.title)}</ac:parameter>`)
-  }
-  if (node.lineNumbers) {
-    params.push(`<ac:parameter ac:name="linenumbers">true</ac:parameter>`)
-  }
-  if (node.collapse) {
-    params.push(`<ac:parameter ac:name="collapse">true</ac:parameter>`)
-  }
-  if (node.firstLine) {
-    params.push(`<ac:parameter ac:name="firstline">${node.firstLine}</ac:parameter>`)
-  }
-
-  return `<ac:structured-macro ac:name="code">${
-    params.join("")
-  }<ac:plain-text-body><![CDATA[${node.code}]]></ac:plain-text-body></ac:structured-macro>`
-}
-
-/**
- * Serialize status macro.
- */
-const serializeStatusMacro = (node: { text: string; color: string }): string => {
-  return `<ac:structured-macro ac:name="status"><ac:parameter ac:name="colour">${
-    escapeHtml(node.color)
-  }</ac:parameter><ac:parameter ac:name="title">${escapeHtml(node.text)}</ac:parameter></ac:structured-macro>`
-}
-
-/**
- * Serialize task list to Confluence storage format.
- */
-const serializeTaskList = (
-  children: ReadonlyArray<{
-    _tag: "TaskItem"
-    id: string
-    uuid: string
-    status: "incomplete" | "complete"
-    body: ReadonlyArray<InlineNode>
-  }>
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const parts: Array<string> = [`<ac:task-list>`]
-
-    for (const item of children) {
-      const body = yield* serializeInlineNodes(item.body)
-      parts.push(
-        `<ac:task>` +
-          `<ac:task-id>${item.id}</ac:task-id>` +
-          `<ac:task-uuid>${item.uuid}</ac:task-uuid>` +
-          `<ac:task-status>${item.status}</ac:task-status>` +
-          `<ac:task-body><span class="placeholder-inline-tasks">${body}</span></ac:task-body>` +
-          `</ac:task>`
-      )
-    }
-
-    parts.push(`</ac:task-list>`)
-    return parts.join("\n")
-  })
-
-/**
- * Serialize inline nodes to HTML.
- */
-const serializeInlineNodes = (
-  nodes: ReadonlyArray<InlineNode>
-): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    const parts: Array<string> = []
-    for (const node of nodes) {
-      parts.push(yield* serializeInlineNode(node))
-    }
-    return parts.join("")
-  })
-
-/**
- * Serialize inline node to HTML.
- */
-const serializeInlineNode = (node: InlineNode): Effect.Effect<string, SerializeError> =>
-  Effect.gen(function*() {
-    switch (node._tag) {
-      case "Text":
-        return escapeHtml(node.value)
-      case "Strong": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<strong>${content}</strong>`
-      }
-      case "Emphasis": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<em>${content}</em>`
-      }
-      case "Underline": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<u>${content}</u>`
-      }
-      case "Strikethrough": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<del>${content}</del>`
-      }
-      case "Subscript": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<sub>${content}</sub>`
-      }
-      case "Superscript": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<sup>${content}</sup>`
-      }
-      case "InlineCode":
-        return `<code>${escapeHtml(node.value)}</code>`
-      case "Link": {
-        // Round-trip view-file macro: a Link with href="attachment:FILENAME"
-        // came from a Confluence ac:structured-macro name="view-file".
-        const attachmentMatch = node.href.match(/^attachment:(.+)$/)
-        if (attachmentMatch) {
-          const filename = attachmentMatch[1] ?? ""
-          return `<ac:structured-macro ac:name="view-file"><ac:parameter ac:name="name"><ri:attachment ri:filename="${
-            escapeHtml(filename)
-          }"/></ac:parameter></ac:structured-macro>`
-        }
-        const content = yield* serializeInlineNodes(node.children)
-        const title = node.title ? ` title="${escapeHtml(node.title)}"` : ""
-        return `<a href="${escapeHtml(node.href)}"${title}>${content}</a>`
-      }
-      case "LineBreak":
-        return "<br/>"
-      case "Emoticon":
-        return `<ac:emoticon ac:emoji-shortname="${escapeHtml(node.shortname)}" ac:emoji-id="${
-          escapeHtml(node.emojiId)
-        }" ac:emoji-fallback="${escapeHtml(node.fallback)}"/>`
-      case "UserMention":
-        return `<ac:link><ri:user ri:account-id="${escapeHtml(node.accountId)}"/></ac:link>`
-      case "DateTime":
-        return `<time datetime="${escapeHtml(node.datetime)}"/>`
-      case "ColoredText": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<span style="color: ${escapeHtml(node.color)};">${content}</span>`
-      }
-      case "Highlight": {
-        const content = yield* serializeInlineNodes(node.children)
-        return `<span style="background-color: ${escapeHtml(node.backgroundColor)};">${content}</span>`
-      }
-      case "UnsupportedInline": {
-        // Check for comment-encoded TOC and convert back to Confluence macro
-        const tocMatch = node.raw.match(/<!--cf:toc:([^;]*);([^;]*)-->/)
-        if (tocMatch) {
-          const minLevel = tocMatch[1]
-          const maxLevel = tocMatch[2]
-          let params = ""
-          if (minLevel) params += `<ac:parameter ac:name="minLevel">${minLevel}</ac:parameter>`
-          if (maxLevel) params += `<ac:parameter ac:name="maxLevel">${maxLevel}</ac:parameter>`
-          return `<ac:structured-macro ac:name="toc">${params}</ac:structured-macro>`
-        }
-        // Check for comment-encoded Status macro
-        const statusMatch = node.raw.match(/<!--cf:status:([^;]*);([^;]*)-->/)
-        if (statusMatch) {
-          const title = decodeURIComponent(statusMatch[1] ?? "")
-          const color = decodeURIComponent(statusMatch[2] ?? "")
-          let params = ""
-          if (title) params += `<ac:parameter ac:name="title">${escapeHtml(title)}</ac:parameter>`
-          if (color) params += `<ac:parameter ac:name="colour">${escapeHtml(color)}</ac:parameter>`
-          return `<ac:structured-macro ac:name="status">${params}</ac:structured-macro>`
-        }
-        // Check for comment-encoded Smart link (Jira, etc.)
-        const smartLinkMatch = node.raw.match(/<!--cf:smartlink:([^;]*);([^;]*);(.*)-->/)
-        if (smartLinkMatch) {
-          const href = decodeURIComponent(smartLinkMatch[1] ?? "")
-          const appearance = decodeURIComponent(smartLinkMatch[2] ?? "")
-          const datasource = decodeURIComponent(smartLinkMatch[3] ?? "")
-          return `<a href="${escapeHtml(href)}" data-card-appearance="${escapeHtml(appearance)}" data-datasource="${
-            escapeHtml(datasource)
-          }">${escapeHtml(href)}</a>`
-        }
-        return node.raw
-      }
-      default:
-        return ""
-    }
-  })
-
-/**
- * Escape HTML special characters.
- */
-const escapeHtml = (str: string): string =>
-  str
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")