@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/docx/render.js

@@ -0,0 +1,941 @@
+import {escapeText} from "../../common/index.js"
+import {BIBLIOGRAPHY_HEADERS} from "../../schema/i18n.js"
+import {textContent} from "../tools/doc_content.js"
+import {xmlDOM} from "../tools/xml.js"
+
+export class DOCXExporterRender {
+    constructor(xml) {
+        this.xml = xml
+
+        this.filePath = false // "word/document.xml" or "word/document2.xml" in some cases
+        this.ctXML = false
+        this.text = false
+    }
+
+    init() {
+        return this.xml
+            .getXml("[Content_Types].xml")
+            .then(ctXML => {
+                this.ctXML = ctXML
+                const documentOverride = this.ctXML.query("Override", {
+                    ContentType:
+                        "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"
+                })
+                this.filePath = documentOverride
+                    .getAttribute("PartName")
+                    .slice(1)
+                return this.xml.getXml(this.filePath)
+            })
+            .then(xml => {
+                this.text = xml
+                // Ensure we support the three latest docx feature sets:
+                // wp14 (drawing 2010), w14 (word 2010), w15 (word 2012)
+                const documentEl = this.text.query("w:document")
+                if (!documentEl.getAttribute("xmlns:wp14")) {
+                    documentEl.setAttribute(
+                        "xmlns:wp14",
+                        "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing"
+                    )
+                }
+                if (!documentEl.getAttribute("xmlns:w14")) {
+                    documentEl.setAttribute(
+                        "xmlns:w14",
+                        "http://schemas.microsoft.com/office/word/2010/wordml"
+                    )
+                }
+                if (!documentEl.getAttribute("xmlns:w15")) {
+                    documentEl.setAttribute(
+                        "xmlns:w15",
+                        "http://schemas.microsoft.com/office/word/2012/wordml"
+                    )
+                }
+                const ignorable = [
+                    ...new Set(
+                        ["w14", "wp14", "w15"].concat(
+                            documentEl
+                                .getAttribute("mc:Ignorable", "")
+                                .split(" ")
+                                .filter(item => item.length)
+                        )
+                    )
+                ]
+                documentEl.setAttribute("mc:Ignorable", ignorable.join(" "))
+                return Promise.resolve()
+            })
+    }
+
+    parseStructuredTags(block, tag) {
+        let blockText = block.textContent
+        const tagName = tag.title
+
+        // Check for BEGIN...END loops (with optional limit)
+        const beginStartRegex = new RegExp(
+            `\\{BEGIN_${tagName}(?::limit=(\\d+))?\\}`
+        )
+        const beginStartMatch = blockText.match(beginStartRegex)
+
+        if (
+            beginStartMatch &&
+            tag.content &&
+            Array.isArray(tag.content) &&
+            tag.content.length > 0
+        ) {
+            const limit = beginStartMatch[1]
+                ? parseInt(beginStartMatch[1])
+                : null
+            const beginStart = beginStartMatch.index
+            const beginEnd = beginStart + beginStartMatch[0].length
+
+            // Find matching {END_tag}
+            const endTag = `{END_${tagName}}`
+            const endPos = blockText.indexOf(endTag, beginEnd)
+            if (endPos === -1) {
+                console.warn(`Missing ${endTag} for ${tagName}`)
+                return
+            }
+
+            const templateXml = blockText.slice(beginEnd, endPos)
+            const replacementXml = this.processLoop(
+                templateXml,
+                tag.content,
+                tagName,
+                limit
+            )
+
+            const beforeText = blockText.slice(0, beginStart)
+            const afterText = blockText.slice(endPos + endTag.length)
+            const fullReplacement = beforeText + replacementXml + afterText
+
+            block.innerXML = fullReplacement
+            return
+        }
+
+        // Check for IF...ELIF...ELSE...ENDIF conditionals
+        blockText = this.processConditionals(blockText, {
+            tagName,
+            count: tag.content ? tag.content.length : 0,
+            content: tag.content || []
+        })
+
+        if (blockText !== block.textContent) {
+            block.innerXML = blockText
+        }
+    }
+
+    processLoop(templateXml, items, tagName, limit = null) {
+        const effectiveItems = limit !== null ? items.slice(0, limit) : items
+        const results = []
+
+        effectiveItems.forEach((item, index) => {
+            const loopCtx = {
+                count: items.length,
+                index: index,
+                first: index === 0,
+                last: index === effectiveItems.length - 1,
+                item: item,
+                content: [item],
+                odd: index % 2 === 1,
+                even: index % 2 === 0
+            }
+
+            let itemXml = templateXml
+
+            // Replace field placeholders
+            if (typeof item === "string") {
+                itemXml = itemXml.replace(/%tag/g, escapeText(item))
+            } else {
+                itemXml = itemXml
+                    .replace(
+                        /\{?%firstname\}?/g,
+                        escapeText(item.firstname || "")
+                    )
+                    .replace(
+                        /\{?%lastname\}?/g,
+                        escapeText(item.lastname || "")
+                    )
+                    .replace(
+                        /\{?%institution\}?/g,
+                        escapeText(item.institution || "")
+                    )
+                    .replace(/\{?%email\}?/g, escapeText(item.email || ""))
+                    .replace(/\{?%id_type\}?/g, escapeText(item.id_type || ""))
+                    .replace(
+                        /\{?%id_value\}?/g,
+                        escapeText(item.id_value || "")
+                    )
+            }
+
+            // Handle conditionals inside the loop
+            itemXml = this.processConditionals(itemXml, {tagName, ...loopCtx})
+
+            // Handle special delimiters for DOCX
+            itemXml = itemXml.replace(/\\n/g, "<w:br/>")
+            itemXml = itemXml.replace(/\\p/g, "</w:p><w:p>")
+
+            results.push(itemXml)
+        })
+
+        return results.join("")
+    }
+
+    processConditionals(text, ctx) {
+        let result = text
+        let changed = true
+        while (changed) {
+            changed = false
+            const ifStart = result.indexOf("{IF(")
+            if (ifStart === -1) {
+                break
+            }
+
+            let depth = 1
+            let pos = ifStart + 4 // skip {IF(
+            // Find the closing ) of the IF expression
+            while (pos < result.length && result[pos] !== ")") {
+                pos++
+            }
+            if (pos >= result.length) {
+                break
+            }
+            pos++ // skip )
+
+            // Now scan for matching {ENDIF}
+            while (pos < result.length && depth > 0) {
+                if (result.substr(pos, 4) === "{IF(") {
+                    depth++
+                    pos += 4
+                } else if (result.substr(pos, 7) === "{ENDIF}") {
+                    depth--
+                    if (depth > 0) {
+                        pos += 7
+                    }
+                } else {
+                    pos++
+                }
+            }
+
+            if (depth === 0) {
+                const exprEnd = result.indexOf(")", ifStart + 4)
+                const ifExpr = result.slice(ifStart + 4, exprEnd)
+                // Skip the closing } of {IF(...)} if present
+                let innerStart = exprEnd + 1
+                if (result[innerStart] === "}") {
+                    innerStart++
+                }
+                const innerContent = result.slice(innerStart, pos)
+
+                const conditions = []
+                conditions.push({expr: ifExpr, content: ""})
+
+                const remaining = innerContent
+                let lastIndex = 0
+
+                const elifRegex = /\{ELIF\(([^)]+)\)\}/g
+                let elifMatch
+                while ((elifMatch = elifRegex.exec(remaining)) !== null) {
+                    conditions[conditions.length - 1].content = remaining.slice(
+                        lastIndex,
+                        elifMatch.index
+                    )
+                    conditions.push({expr: elifMatch[1], content: ""})
+                    lastIndex = elifMatch.index + elifMatch[0].length
+                }
+
+                const elseMatch = remaining.slice(lastIndex).match(/\{ELSE\}/)
+                if (elseMatch) {
+                    conditions[conditions.length - 1].content = remaining.slice(
+                        lastIndex,
+                        lastIndex + elseMatch.index
+                    )
+                    conditions.push({
+                        expr: null,
+                        content: remaining.slice(
+                            lastIndex + elseMatch.index + elseMatch[0].length
+                        )
+                    })
+                } else {
+                    conditions[conditions.length - 1].content =
+                        remaining.slice(lastIndex)
+                }
+
+                let replacement = ""
+                for (const cond of conditions) {
+                    if (
+                        cond.expr === null ||
+                        this.evaluateExpression(cond.expr, ctx)
+                    ) {
+                        replacement = cond.content
+                        break
+                    }
+                }
+
+                result =
+                    result.slice(0, ifStart) +
+                    replacement +
+                    result.slice(pos + 7)
+                changed = true
+            }
+        }
+        return result
+    }
+
+    evaluateExpression(expr, ctx) {
+        try {
+            // Allow explicit tag name references (e.g., authors.count -> ctx.count)
+            if (ctx.tagName) {
+                const safeTagName = ctx.tagName.replace(
+                    /[.*+?^${}()|[\]\\]/g,
+                    "\\$&"
+                )
+                expr = expr.replace(
+                    new RegExp(`\\b${safeTagName}\\b`, "g"),
+                    "ctx"
+                )
+            }
+
+            // Replace ctx.property accesses with literal values
+            const evalExpr = expr.replace(
+                /ctx\.(\w+)(?:\.(\w+))?(?:\[(\d+)\])?/g,
+                (_match, p1, p2, p3) => {
+                    let val = ctx[p1]
+                    if (p2 !== undefined && val !== undefined) {
+                        val = val[p2]
+                    }
+                    if (p3 !== undefined && val !== undefined) {
+                        val = val[parseInt(p3)]
+                    }
+                    return JSON.stringify(val)
+                }
+            )
+
+            // Remove string literals before character check
+            const safeExpr = evalExpr.replace(
+                /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g,
+                '""'
+            )
+
+            // Check for unknown identifiers
+            const bareIdRegex = /\b[a-zA-Z_]\w*\b/g
+            const allowed = ["true", "false", "null", "undefined"]
+            let m
+            while ((m = bareIdRegex.exec(safeExpr)) !== null) {
+                if (!allowed.includes(m[0])) {
+                    console.warn(
+                        "Unknown identifier in expression:",
+                        m[0],
+                        "expression:",
+                        expr
+                    )
+                    return false
+                }
+            }
+
+            // Check for unsafe characters
+            if (/[^ \t\n\r0-9a-zA-Z_\.\+\-*\/%==<>!&|()\[\]]/.test(safeExpr)) {
+                console.warn("Unsafe characters in expression:", expr)
+                return false
+            }
+
+            return new Function(`return (${evalExpr})`)()
+        } catch (e) {
+            console.warn("Error evaluating expression:", expr, e)
+            return false
+        }
+    }
+
+    processMultiBlockStructuredTags(blocks, tags) {
+        const tagMap = {}
+        tags.forEach(tag => {
+            if (tag.title) {
+                tagMap[tag.title] = tag
+            }
+        })
+
+        // Process from end to start to avoid index shifting issues
+        for (let i = blocks.length - 1; i >= 0; i--) {
+            const block = blocks[i]
+            const text = block.textContent
+
+            // Check for multi-block BEGIN...END loops
+            for (const tag of tags) {
+                if (!tag.title || !tag.content || !Array.isArray(tag.content)) {
+                    continue
+                }
+                const tagName = tag.title
+                const beginRegex = new RegExp(
+                    `\\{BEGIN_${tagName}(?::limit=(\\d+))?\\}`
+                )
+                const beginMatch = text.match(beginRegex)
+                if (!beginMatch) {
+                    continue
+                }
+
+                // Find matching END in a later block
+                let endIndex = -1
+                for (let j = i + 1; j < blocks.length; j++) {
+                    if (blocks[j].textContent.includes(`{END_${tagName}}`)) {
+                        endIndex = j
+                        break
+                    }
+                }
+
+                if (endIndex === -1 || endIndex === i) {
+                    continue
+                }
+
+                // Found multi-block loop - process it
+                const limit = beginMatch[1] ? parseInt(beginMatch[1]) : null
+                this._replaceMultiBlockLoop(blocks, i, endIndex, tag, limit)
+                // Adjust i since blocks array was modified
+                i = Math.min(i, blocks.length - 1)
+                break // Only process one loop per block per iteration
+            }
+        }
+
+        // Process multi-block conditionals from end to start
+        for (let i = blocks.length - 1; i >= 0; i--) {
+            const block = blocks[i]
+            const text = block.textContent
+            const ifMatch = text.match(/\{IF\(([^)]+)\)\}/)
+            if (!ifMatch) {
+                continue
+            }
+
+            // Find matching ENDIF in a later block
+            let endIndex = -1
+            for (let j = i + 1; j < blocks.length; j++) {
+                if (/\{ENDIF\}/.test(blocks[j].textContent)) {
+                    endIndex = j
+                    break
+                }
+            }
+
+            if (endIndex === -1 || endIndex === i) {
+                continue
+            }
+
+            this._replaceMultiBlockConditional(
+                blocks,
+                i,
+                endIndex,
+                ifMatch[1],
+                tagMap
+            )
+            i = Math.min(i, blocks.length - 1)
+        }
+    }
+
+    _replaceMultiBlockLoop(blocks, beginIndex, endIndex, tag, limit) {
+        const tagName = tag.title
+        const beginBlock = blocks[beginIndex]
+
+        // Concatenate all blocks from begin to end
+        let combinedXml = ""
+        for (let i = beginIndex; i <= endIndex; i++) {
+            combinedXml += blocks[i].toString()
+        }
+
+        // Find the BEGIN and END tags in the combined XML
+        const beginRegex = new RegExp(`\\{BEGIN_${tagName}(?::limit=\\d+)?\\}`)
+        const beginMatch = combinedXml.match(beginRegex)
+        const endTag = `{END_${tagName}}`
+        const endPos = combinedXml.indexOf(endTag)
+
+        if (!beginMatch || endPos === -1) {
+            return
+        }
+
+        const beforeXml = combinedXml.slice(0, beginMatch.index)
+        const templateXml = combinedXml.slice(
+            beginMatch.index + beginMatch[0].length,
+            endPos
+        )
+        const afterXml = combinedXml.slice(endPos + endTag.length)
+
+        // Decode &gt; so expressions like >= work in nested conditionals
+        const decodedTemplateXml = templateXml.replace(/&gt;/g, ">")
+        const replacementXml = this.processLoop(
+            decodedTemplateXml,
+            tag.content,
+            tagName,
+            limit
+        )
+        const fullReplacement = beforeXml + replacementXml + afterXml
+
+        // Parse replacement
+        const parent = beginBlock.parentElement
+        const dom = xmlDOM(`<root>${fullReplacement}</root>`)
+        const root = dom.query("root")
+        const newBlocks = root.children.filter(
+            child => child.tagName === "w:p" || child.tagName === "w:sectPr"
+        )
+
+        // Insert new blocks before begin block
+        for (let i = newBlocks.length - 1; i >= 0; i--) {
+            parent.insertBefore(newBlocks[i], beginBlock)
+        }
+
+        // Remove old blocks
+        for (let i = endIndex; i >= beginIndex; i--) {
+            parent.removeChild(blocks[i])
+        }
+
+        // Update blocks array
+        blocks.splice(beginIndex, endIndex - beginIndex + 1, ...newBlocks)
+    }
+
+    _replaceMultiBlockConditional(blocks, ifIndex, endIndex, expr, tagMap) {
+        const ifBlock = blocks[ifIndex]
+
+        // Concatenate all blocks from if to endif
+        let combinedXml = ""
+        for (let i = ifIndex; i <= endIndex; i++) {
+            combinedXml += blocks[i].toString()
+        }
+
+        // Determine which tag the expression references
+        let ctx = {count: 0, content: []}
+        for (const tagName in tagMap) {
+            const safeTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+            if (new RegExp(`\\b${safeTagName}\\b`).test(expr)) {
+                const tag = tagMap[tagName]
+                ctx = {
+                    tagName: tag.title,
+                    count: tag.content ? tag.content.length : 0,
+                    content: tag.content || []
+                }
+                break
+            }
+        }
+
+        // Decode &gt; so expressions like >= work in conditionals
+        const decodedXml = combinedXml.replace(/&gt;/g, ">")
+        // Process conditionals on the combined XML
+        const processedXml = this.processConditionals(decodedXml, ctx)
+
+        if (processedXml === combinedXml) {
+            return
+        }
+
+        // Parse and replace
+        const parent = ifBlock.parentElement
+        const dom = xmlDOM(`<root>${processedXml}</root>`)
+        const root = dom.query("root")
+        const newBlocks = root.children.filter(
+            child => child.tagName === "w:p" || child.tagName === "w:sectPr"
+        )
+
+        for (let i = newBlocks.length - 1; i >= 0; i--) {
+            parent.insertBefore(newBlocks[i], ifBlock)
+        }
+
+        for (let i = endIndex; i >= ifIndex; i--) {
+            parent.removeChild(blocks[i])
+        }
+
+        blocks.splice(ifIndex, endIndex - ifIndex + 1, ...newBlocks)
+    }
+
+    // Define the tags that are to be looked for in the document
+    getTagData(docContent, pmBib, settings) {
+        const tags = docContent.content.map(node => {
+            const tag = {}
+            switch (node.type) {
+                case "title":
+                    tag.title = "title"
+                    tag.content = textContent(node)
+                    break
+                case "heading_part":
+                    tag.title = node.attrs.id
+                    tag.content = textContent(node)
+                    break
+                case "table_part":
+                case "richtext_part":
+                    tag.title = `@${node.attrs.id}`
+                    tag.content = node.content
+                    break
+                case "contributors_part":
+                    tag.title = node.attrs.id
+                    // Return array of structured objects for format with delimiter support
+                    tag.content = node.content
+                        ? node.content.map(node => {
+                              const c = node.attrs
+                              return {
+                                  firstname: c.firstname || "",
+                                  lastname: c.lastname || "",
+                                  institution: c.institution || "",
+                                  email: c.email || "",
+                                  id_type: c.id_type || "",
+                                  id_value: c.id_value || ""
+                              }
+                          })
+                        : []
+                    break
+                case "tags_part":
+                    tag.title = node.attrs.id
+                    // Return array of tag strings for format with delimiter support
+                    tag.content = node.content
+                        ? node.content.map(node => node.attrs.tag)
+                        : []
+                    break
+            }
+            return tag
+        })
+
+        let bibliographyContent
+        if (pmBib && pmBib.content && pmBib.content.length > 0) {
+            // Add bibliography heading and mark first/last items
+            const firstPmBib = pmBib.content[0]
+            const lastPmBib = pmBib.content[pmBib.content.length - 1]
+            firstPmBib.attrs = firstPmBib.attrs || {}
+            firstPmBib.attrs.first = true
+            lastPmBib.attrs = lastPmBib.attrs || {}
+            lastPmBib.attrs.last = true
+            const bibliographyHeader =
+                settings.bibliography_header[settings.language] ||
+                BIBLIOGRAPHY_HEADERS[settings.language]
+            bibliographyContent = [
+                {
+                    type: "bibliography_heading",
+                    content: [{type: "text", text: bibliographyHeader}]
+                },
+                pmBib
+            ]
+        } else {
+            // No bibliography content, add a placeholder paragraph
+            bibliographyContent = [
+                {type: "paragraph", content: [{type: "text", text: " "}]}
+            ]
+        }
+
+        // Add bibliography content
+        tags.push({
+            title: "@bibliography", // The '@' triggers handling as block
+            content: bibliographyContent
+        })
+
+        tags.push({
+            title: "@copyright", // The '@' triggers handling as block
+            content:
+                settings.copyright && settings.copyright.holder
+                    ? [
+                          {
+                              type: "paragraph",
+                              content: [
+                                  {
+                                      type: "text",
+                                      text: `© ${settings.copyright.year ? settings.copyright.year : new Date().getFullYear()} ${settings.copyright.holder}`
+                                  }
+                              ]
+                          }
+                      ]
+                    : [
+                          {
+                              type: "paragraph",
+                              content: [{type: "text", text: " "}]
+                          }
+                      ]
+        })
+        tags.push({
+            title: "@licenses", // The '@' triggers handling as block
+            content:
+                settings.copyright && settings.copyright.licenses.length
+                    ? settings.copyright.licenses.map(license => ({
+                          type: "paragraph",
+                          content: [
+                              {
+                                  type: "text",
+                                  marks: [
+                                      {
+                                          type: "link",
+                                          attrs: {
+                                              href: license.url,
+                                              title: license.title
+                                          }
+                                      }
+                                  ],
+                                  text: license.title
+                              },
+                              {
+                                  type: "text",
+                                  text: license.start
+                                      ? ` (${license.start})`
+                                      : ""
+                              }
+                          ]
+                      }))
+                    : [
+                          {
+                              type: "paragraph",
+                              content: [{type: "text", text: " "}]
+                          }
+                      ]
+        })
+
+        return tags
+    }
+
+    // go through document.xml looking for tags and replace them with the given
+    // replacements.
+    render(docContent, pmBib, settings, richtext, citations) {
+        const tags = this.getTagData(docContent, pmBib, settings)
+
+        // Including global page definition at end
+        const blocks = this.text.queryAll(["w:p", "w:sectPr"])
+
+        // Process multi-block structured tags first (BEGIN...END across paragraphs)
+        this.processMultiBlockStructuredTags(blocks, tags)
+
+        const currentTags = []
+        blocks.forEach(block => {
+            // Assuming there is nothing outside of <w:t>...</w:t>
+            const text = block.textContent
+            tags.forEach(tag => {
+                const tagString = tag.title
+                const hasInlineTag =
+                    text.includes(`{${tagString}}`) ||
+                    text.includes(`{${tagString}:format=`)
+                const hasBeginTag = text.includes(`{BEGIN_${tagString}}`)
+                const hasIfTag =
+                    text.includes(`{IF(${tagString}.`) ||
+                    text.includes(`{IF(ctx.`)
+                if (hasInlineTag || hasBeginTag || hasIfTag) {
+                    currentTags.push(tag)
+                    tag.block = block
+                    // We don't worry about the same tag appearing twice in the document,
+                    // as that would make no sense.
+                }
+            })
+
+            // Parse structured tags (BEGIN...END and IF...ENDIF)
+            currentTags.forEach(tag => {
+                if (tag.block) {
+                    this.parseStructuredTags(tag.block, tag)
+                }
+            })
+
+            const pageSize = block.query("w:pgSz")
+            const pageMargins = block.query("w:pgMar")
+            const cols = block.query("w:cols")
+            if (pageSize && pageMargins) {
+                // Not sure if these all need to come together
+                let width =
+                    Number.parseInt(pageSize.getAttribute("w:w")) -
+                    Number.parseInt(pageMargins.getAttribute("w:right")) -
+                    Number.parseInt(pageMargins.getAttribute("w:left"))
+                const height =
+                    Number.parseInt(pageSize.getAttribute("w:h")) -
+                    Number.parseInt(pageMargins.getAttribute("w:bottom")) -
+                    Number.parseInt(pageMargins.getAttribute("w:top")) -
+                    Number.parseInt(pageMargins.getAttribute("w:header")) -
+                    Number.parseInt(pageMargins.getAttribute("w:footer"))
+
+                const colCount = cols
+                    ? Number.parseInt(cols.getAttribute("w:num"))
+                    : 1
+                if (colCount > 1) {
+                    const colSpace = Number.parseInt(
+                        cols.getAttribute("w:space")
+                    )
+                    width = width - colSpace * (colCount - 1)
+                    width = width / colCount
+                }
+                while (currentTags.length) {
+                    const tag = currentTags.pop()
+                    tag.dimensions = {
+                        width: width * 635, // convert to EMU
+                        height: height * 635 // convert to EMU
+                    }
+                }
+            }
+        })
+        tags.forEach(tag => {
+            if (!tag.title) {
+                return
+            } else if (tag.title[0] === "@") {
+                this.blockRender(tag, citations, richtext)
+            } else {
+                this.inlineRender(tag)
+            }
+        })
+    }
+
+    // Render Tags that only exchange inline content
+    inlineRender(tag) {
+        if (!tag.block) {
+            return
+        }
+        const blockText = tag.block.textContent
+        const tagString = `{${tag.title}}`
+
+        if (!blockText.includes(`{${tag.title}`)) {
+            // No inline tag present - structured tags only
+            return
+        }
+
+        // Check for format string with delimiter: {tag:format=%firstname|; }
+        const formatRegex = new RegExp(
+            `\\{${tag.title}:format=([^|]+)\\|?([^}]*)?\\}`
+        )
+        const formatMatch = blockText.match(formatRegex)
+
+        let fullText = ""
+
+        if (formatMatch && tag.content && Array.isArray(tag.content)) {
+            // Find format string and delimiter
+            const [, format, delimiter = "; "] = formatMatch
+
+            // Process each item with the format string
+            const formattedItems = tag.content
+                .map(item => {
+                    if (typeof item === "string") {
+                        // For tags (simple strings)
+                        return format.replace(/%tag/g, item)
+                    } else {
+                        // For contributors (objects)
+                        return format
+                            .replace(/%firstname/g, item.firstname || "")
+                            .replace(/%lastname/g, item.lastname || "")
+                            .replace(/%institution/g, item.institution || "")
+                            .replace(/%email/g, item.email || "")
+                            .replace(/%id_type/g, item.id_type || "")
+                            .replace(/%id_value/g, item.id_value || "")
+                    }
+                })
+                .filter(s => s.trim() !== "")
+
+            // Handle special delimiters
+            let delimiterText = delimiter
+            delimiterText = delimiterText.replace(/\\n/g, "\n")
+            delimiterText = delimiterText.replace(/\\p/g, "\n\n")
+
+            const replacement = formattedItems.join(delimiterText)
+            fullText = blockText.replace(formatRegex, replacement)
+        } else {
+            // Fall back to simple string replacement (backward compatible)
+            let contentStr = tag.content || ""
+            if (Array.isArray(contentStr)) {
+                if (contentStr.length === 0) {
+                    contentStr = ""
+                } else if (typeof contentStr[0] === "string") {
+                    contentStr = contentStr.join(", ")
+                } else {
+                    // Contributors - backward compatible formatting
+                    contentStr = contentStr
+                        .map(item => {
+                            const nameParts = []
+                            let affiliation = false
+                            if (item.firstname) {
+                                nameParts.push(item.firstname)
+                            }
+                            if (item.lastname) {
+                                nameParts.push(item.lastname)
+                            }
+                            if (item.institution) {
+                                if (nameParts.length) {
+                                    affiliation = item.institution
+                                } else {
+                                    nameParts.push(item.institution)
+                                }
+                            }
+                            const parts = [nameParts.join(" ")]
+                            if (affiliation) {
+                                parts.push(affiliation)
+                            }
+                            if (item.email) {
+                                parts.push(item.email)
+                            }
+                            if (item.id_type && item.id_value) {
+                                parts.push(`${item.id_type}: ${item.id_value}`)
+                            }
+                            return parts.join(", ")
+                        })
+                        .join("; ")
+                }
+            }
+            const texts = blockText.split(tagString)
+            fullText = texts[0] + contentStr + texts[1]
+        }
+
+        // Apply the replacement
+        const rs = tag.block.queryAll("w:r").reverse()
+        let lastR
+        // Remove all <w:r> with text in them (<w:t>).
+        // Exclude <w:r> used for other things, like page breaks.
+        rs.forEach(r => {
+            if (r.query("w:t")) {
+                if (lastR) {
+                    r.parentElement.removeChild(r)
+                } else {
+                    lastR = r
+                }
+            }
+        })
+        if (!lastR) {
+            // This should not be possible. Error.
+            return
+        }
+        if (fullText.length) {
+            if (fullText.includes("\n")) {
+                // Split on newlines and create <w:t> elements separated by <w:br/>
+                const parts = fullText.split("\n").map(part => escapeText(part))
+                lastR.innerXML = parts
+                    .map((part, index) => {
+                        const br = index > 0 ? "<w:br/>" : ""
+                        return `${br}<w:t xml:space="preserve">${part}</w:t>`
+                    })
+                    .join("")
+            } else {
+                let textAttr = ""
+                if (
+                    fullText[0] === " " ||
+                    fullText[fullText.length - 1] === " "
+                ) {
+                    textAttr += 'xml:space="preserve"'
+                }
+                lastR.innerXML = `<w:t ${textAttr}>${escapeText(fullText)}</w:t>`
+            }
+        } else {
+            lastR.parentElement.removeChild(lastR)
+        }
+    }
+
+    // Render tags that exchange paragraphs
+    blockRender(tag, citations, richtext) {
+        if (!tag.block) {
+            return
+        }
+        const pStyle = tag.block.query("w:pStyle")
+        const options = {
+            dimensions: tag.dimensions,
+            citationType: citations.citFm.citationType,
+            section: pStyle ? pStyle.getAttribute("w:val") : "Normal",
+            tag: tag.title.slice(1)
+        }
+        const outXML = tag.content
+            ? tag.content
+                  .map((content, i) =>
+                      richtext.run(content, options, tag.content[i + 1])
+                  )
+                  .join("")
+            : ""
+        if (!outXML.length) {
+            // If there is no content, we need to put in a space to prevent the
+            // tag from being removed.
+            tag.block.innerXML = '<w:r><w:t xml:space="preserve"> </w:t></w:r>'
+            return
+        }
+        const parentElement = tag.block.parentElement
+        const dom = xmlDOM(outXML)
+        const domPars = dom.node["#document"]?.slice() || [dom]
+        domPars.forEach(node => parentElement.insertBefore(node, tag.block))
+        // sectPr contains information about columns, etc. We need to move this
+        // to the last paragraph we will be adding.
+        const sectPr = tag.block.query("w:sectPr")
+        if (sectPr) {
+            const pPr = tag.block.previousSibling.query("w:pPr")
+            pPr.appendChild(sectPr)
+        }
+        parentElement.removeChild(tag.block)
+    }
+}