@dogsbay/adoc2md-modular 0.2.0-beta.48

package/dist/engine.js

@@ -0,0 +1,2075 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const ADMONS = JSON.parse('{"CAUTION":"\ud83d\udd25","IMPORTANT":"\u2757","NOTE":"\ud83d\udccc","TIP":"\ud83d\udca1","WARNING":"\u26a0\ufe0f"}');
+// Map AsciiDoc admonition types to lowercase for markdown formats (MkDocs, Docusaurus)
+const ADMON_TYPES = { NOTE: 'note', WARNING: 'warning', TIP: 'tip', IMPORTANT: 'important', CAUTION: 'caution' };
+const ATTRIBUTES = JSON.parse('{"empty":"","idprefix":"_","idseparator":"_","markdown-line-break":"\\\\","markdown-strikethrough":"~~",' +
+    '"nbsp":"&#160;","quotes":"<q> </q>","sp":" ","vbar":"|","zwsp":"&#8203;"}');
+const BREAKS = { "'''": '---', '***': '---', '---': '---', '<<<': undefined, 'toc::[]': undefined };
+const CONUMS = [...Array(19)].reduce((obj, _, i) => (obj[i + 1] = String.fromCharCode(0x2460 + i)) && obj, {});
+const DELIMS = { '----': 'v', '-----': 'v', '....': 'v', '====': 'c', '|===': 't', '--': 'c', '****': 'c', ____: 'c', '++++': 'p' };
+const LIST_MARKERS = [1, 2, 3, 4, 5, 6, 7, 8, 9, '*', '.', '<', '-'].reduce((obj, c) => (obj['' + c] = true) && obj, {});
+const NORMAL_SUBS = ['quotes', 'attributes', 'macros'];
+const SUBSTITUTORS = { quotes, attributes, macros, callouts };
+const TDIV = { '': '| --- ', '<': '| :-- ', '^': '| :-: ', '>': '| --: ' };
+const AttributeEntryRx = /^:(!)?([^:-][^:]*):(?:$| (.+))/;
+const AttributeRefRx = /(\\)?\{([\p{L}\d_][\p{L}\d_-]*)\}/gu;
+const AuthorInfoLineRx = /^(?:[\p{Alpha}\d_]+(?: +[\p{Alpha}\d_]+){0,2}(?: +<([^>]+)>)?(?:; |$))+$/u;
+const BlockAnchorRx = /^\[([\p{L}_][\p{Alpha}\d_\-:.]*)(?:, ?(.+))?\]$/u;
+const BlockImageMacroRx = /^image::([^\s[][^[]*)\[(.*)\]$/;
+const CellDelimiterRx = /(?:(?:^| +)(?:[<>^.]*[a-z]?)|)\| */;
+const ConumRx = /(^| )<([.1-9]|1\d)>(?=(?: <(?:[.1-9]|1\d)>)*$)/g;
+const DlistItemRx = /^(?!\/\/)(\S.*?)(:{2,4})(?: (.+))?\s*($)/;
+const ElementAttributeRx = /(?:^|, *)(?:(\w[\w-]*)=)?(?:("|')([^\2]+?)\2|([^,]+|))/g;
+const EmphasisSpanMetaRx = /(?<![\p{L}\d_\\])\[[^[\]]+\](?=_(?:\S|\S.*?\S)_(?![\p{L}\d_]))/gu;
+const InlineAnchorRx = /\[\[([\p{L}_][\p{Alpha}\d_\-:.]*)\]\]/u;
+const InlineImageMacroRx = /image:([^\s:`[\\][^[\\]*)\[(|.*?[^\\])\]/g;
+const InlineStemMacroRx = /stem:\[(.*?[^\\])\]/g;
+const LinkMacroRx = /(\\)?(?:(?:link:(?!:)|(https?:\/\/))([^\s[\\]+)(\[(|.*?[^\\])\^?\])|(https?:\/\/)([^\s[\]]+))/g;
+const ListItemRx = /^(\*+|\.+|<(?:[.1-9]|1\d)>|-|\d+\.) +(.+)/;
+const MarkedSpanRx = /(?<![\p{L}\d_\\])(?:\[((\.line-through)|[^[\]]+)\])?#(\S|\S.*?\S)#(?![\p{L}\d_])/gu;
+const PreprocessorDirectiveRx = /^\\?(?:(if)(n)?def|include)::([^[]+)\[(.+)?\]$/;
+const QuotedSpanRx = /("|')`(\S|\S.*?\S)`\1/g;
+const RevisionInfoLineRx = /^v(\d+(?:[-.]\w+)*)(?:, (\d+-\d+-\d+))?|(\d+-\d+-\d+)$/;
+const RewriteInternalXrefRx = /\[([^[]*?)\]\(#!([^)]+)\)/g;
+const StrongSpanRx = /(?<![\p{L}\d_\\])(?:\[[^[\]]+\])?(\*(?:\S|\S.*?\S)\*)(?![\p{L}\d_])/gu;
+const StyleShorthandMarkersRx = /([.#%])/;
+const XrefMacroRx = /(\\)?xref:(?![\s:`])(?:([^#[\\]+)(#[^\s[\\]*|\.adoc)|#([^\s[\\]+)|([^#[\\]+))\[(|.*?[^\\])\]/g;
+const XrefShorthandRx = /<<([^\s,>][^,>]*)(?:, ?([^>]+))?>>/g;
+/**
+ * Detects list type and depth from an AsciiDoc line.
+ *
+ * @param {string} line - AsciiDoc line to analyze
+ * @returns {{ type: 'ordered'|'unordered'|null, depth: number, indent: number }} List info
+ */
+function getAsciiDocListInfo(line) {
+    const trimmed = line.trim();
+    // Ordered list: ., .., ..., etc.
+    const orderedMatch = trimmed.match(/^(\.+) /);
+    if (orderedMatch) {
+        const depth = orderedMatch[1].length;
+        return { type: 'ordered', depth, indent: (depth - 1) * 4 };
+    }
+    // Unordered list: *, **, ***, etc.
+    const unorderedMatch = trimmed.match(/^(\*+) /);
+    if (unorderedMatch) {
+        const depth = unorderedMatch[1].length;
+        return { type: 'unordered', depth, indent: (depth - 1) * 4 };
+    }
+    return { type: null, depth: 0, indent: 0 };
+}
+/**
+ * Resolves AsciiDoc include directives by reading and inlining referenced files,
+ * or converts them to Nunjucks include syntax for template processing.
+ * Handles simple includes only: include::path[] with empty brackets.
+ * Skips commented includes and warns about complex includes with attributes.
+ *
+ * @param {string} content - AsciiDoc content
+ * @param {string} basePath - Base directory for resolving relative include paths
+ * @param {number} depth - Current recursion depth (for preventing infinite loops)
+ * @param {boolean} useNunjucks - If true, convert to Nunjucks syntax instead of inlining (default: true)
+ * @returns {string} Content with includes resolved or converted to Nunjucks
+ */
+function resolveIncludes(content, basePath, depth = 0, useNunjucks = true) {
+    const MAX_DEPTH = 5;
+    if (depth > MAX_DEPTH) {
+        console.warn(`Warning: Maximum include depth (${MAX_DEPTH}) exceeded`);
+        return content;
+    }
+    // Split content into lines to check for comments
+    const lines = content.split('\n');
+    let inBlockComment = false;
+    const processedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // Track block comment state
+        if (trimmedLine === '////') {
+            inBlockComment = !inBlockComment;
+            processedLines.push(line);
+            continue;
+        }
+        // Skip if in block comment or line comment
+        if (inBlockComment || trimmedLine.startsWith('//')) {
+            processedLines.push(line);
+            continue;
+        }
+        // Check for include directive
+        const includeMatch = trimmedLine.match(/^include::([^\[]+)\[([^\]]*)\]$/);
+        if (includeMatch) {
+            const includePath = includeMatch[1];
+            const attributes = includeMatch[2];
+            // Parse leveloffset from attributes
+            const { leveloffset, hasOtherAttributes } = parseLeveloffset(attributes);
+            // Warn about other unsupported attributes (tags, lines, etc.)
+            if (hasOtherAttributes) {
+                console.warn(`Warning: Include directive has unsupported attributes: include::${includePath}[${attributes}]`);
+                console.warn('  Only leveloffset is supported. Other attributes (tags, lines) will be ignored.');
+                console.warn('  Consider using asciidoctor preprocessing for complex includes.');
+            }
+            // If using Nunjucks syntax, convert the include to {% include %} format
+            if (useNunjucks) {
+                // Convert .adoc extension to .md for the include path
+                const mdPath = includePath.replace(/\.adoc$/, '.md');
+                // Smart indentation: check if snippet contains top-level list items
+                let indent = '';
+                const fullPath = path.resolve(basePath, includePath);
+                if (fs.existsSync(fullPath)) {
+                    try {
+                        const snippetContent = fs.readFileSync(fullPath, 'utf8');
+                        const snippetListInfo = getAsciiDocListInfo(snippetContent);
+                        // If snippet contains a top-level list item (depth 1), mark it for special handling
+                        // Otherwise, preserve the original indentation
+                        if (snippetListInfo.type && snippetListInfo.depth === 1) {
+                            // Depth-1 list item: will be added without indentation after blank line
+                            indent = '__NUNJUCKS_TOPLEVEL__';
+                        }
+                        else if (!snippetListInfo.type || snippetListInfo.depth > 1) {
+                            indent = line.match(/^(\s*)/)[1];
+                        }
+                        // snippetListInfo.depth === 1 gets special marker
+                    }
+                    catch (error) {
+                        // If we can't read the file, preserve original indentation
+                        indent = line.match(/^(\s*)/)[1];
+                    }
+                }
+                else {
+                    indent = line.match(/^(\s*)/)[1];
+                }
+                // Output Nunjucks include syntax with optional leveloffset wrapper
+                if (leveloffset) {
+                    // Minja format with leveloffset
+                    if (indent === '__NUNJUCKS_TOPLEVEL__') {
+                        processedLines.push(`__TOPLEVEL__{% leveloffset ${leveloffset} %}` +
+                            `{% include "./${mdPath}" %}` +
+                            `{% endleveloffset %}`);
+                    }
+                    else {
+                        processedLines.push(`${indent}{% leveloffset ${leveloffset} %}` +
+                            `{% include "./${mdPath}" %}` +
+                            `{% endleveloffset %}`);
+                    }
+                }
+                else {
+                    // Standard Nunjucks include (existing logic)
+                    if (indent === '__NUNJUCKS_TOPLEVEL__') {
+                        // Top-level list includes: use special prefix to prevent main converter from indenting
+                        // The __TOPLEVEL__ prefix will be removed in post-processing
+                        processedLines.push(`__TOPLEVEL__{% include "./${mdPath}" %}`);
+                    }
+                    else {
+                        processedLines.push(`${indent}{% include "./${mdPath}" %}`);
+                    }
+                }
+                continue;
+            }
+            // Otherwise, inline the content (legacy behavior)
+            const fullPath = path.resolve(basePath, includePath);
+            // Check if file exists
+            if (!fs.existsSync(fullPath)) {
+                console.warn(`Warning: Include file not found: ${includePath}`);
+                processedLines.push(`<!-- WARNING: Include not found: ${includePath} -->`);
+                continue;
+            }
+            // Read and process the included file
+            try {
+                const includeContent = fs.readFileSync(fullPath, 'utf8');
+                const includeBasePath = path.dirname(fullPath);
+                // Recursively resolve includes in the included file
+                const resolvedContent = resolveIncludes(includeContent, includeBasePath, depth + 1, useNunjucks);
+                // Add the resolved content (preserving the indentation of the include directive)
+                const indent = line.match(/^(\s*)/)[1];
+                const indentedContent = resolvedContent.split('\n').map((l, idx) => idx === 0 ? l : (l ? indent + l : l)).join('\n');
+                processedLines.push(indentedContent);
+            }
+            catch (error) {
+                console.warn(`Warning: Error reading include file ${includePath}: ${error.message}`);
+                processedLines.push(`<!-- WARNING: Error reading include: ${includePath} -->`);
+            }
+        }
+        else {
+            processedLines.push(line);
+        }
+    }
+    return processedLines.join('\n');
+}
+/**
+ * Parses the leveloffset attribute from an include directive's attribute string.
+ * Also detects if other unsupported attributes are present.
+ *
+ * @param {string} attributeString - The content inside brackets of include directive
+ * @returns {object} { leveloffset: string|null, hasOtherAttributes: boolean }
+ */
+function parseLeveloffset(attributeString) {
+    if (!attributeString || !attributeString.trim()) {
+        return { leveloffset: null, hasOtherAttributes: false };
+    }
+    // Split by comma to handle multiple attributes
+    const attrs = attributeString.split(',').map(a => a.trim());
+    let leveloffset = null;
+    let hasOtherAttributes = false;
+    for (const attr of attrs) {
+        if (attr.startsWith('leveloffset=')) {
+            leveloffset = attr.substring('leveloffset='.length).trim();
+        }
+        else if (attr) {
+            hasOtherAttributes = true;
+        }
+    }
+    return { leveloffset, hasOtherAttributes };
+}
+/**
+ * Converts AsciiDoc attribute assignments to Jinja2 set statements.
+ *
+ * @param {string} line - Line that may contain attribute assignment
+ * @param {boolean} stripRight - Whether to use right-strip (-%}) or not (%})
+ * @returns {string|null} - Jinja2 set statement or null if not an attribute assignment
+ */
+function convertAttributeAssignment(line, stripRight = true) {
+    const trimmed = line.trim();
+    const rightStrip = stripRight ? '-' : '';
+    // Match AsciiDoc attribute unset: :!name:
+    const unsetMatch = trimmed.match(/^:!([a-zA-Z0-9_-]+):$/);
+    if (unsetMatch) {
+        const [, name] = unsetMatch;
+        const varName = name.replace(/-/g, '_');
+        return `{%- set ${varName} = false ${rightStrip}%}`;
+    }
+    // Match AsciiDoc attribute assignment: :name: or :name: value
+    // Format: :attr-name: or :attr-name: value
+    const match = trimmed.match(/^:([a-zA-Z0-9_-]+):(?:\s+(.+))?$/);
+    if (!match) {
+        return null;
+    }
+    const [, name, value] = match;
+    // Convert attribute name to valid Jinja2 variable name
+    // Replace hyphens with underscores
+    const varName = name.replace(/-/g, '_');
+    if (value && value.trim()) {
+        // Attribute with value: :name: value
+        // Convert to: {% set name = "value" %}
+        let processedValue = value.trim();
+        // Expand attribute references in value: {attr} → {{ attr }}
+        processedValue = processedValue.replace(/\{([a-zA-Z0-9_-]+)\}/g, (_, attr) => {
+            return '{{ ' + attr.replace(/-/g, '_') + ' }}';
+        });
+        // Convert link macros: link:URL[text] → [text](URL)
+        // URL may contain {{ attr }} template variables (with spaces), so match those explicitly
+        processedValue = processedValue.replace(/link:((?:\{\{[^}]+\}\}|[^\s\[])+)\[([^\]]*)\]/g, '[$2]($1)');
+        // Expand UI macros in attribute values
+        // menu:Name[Item] → **Name → Item**
+        processedValue = processedValue.replace(/menu:([^\[]+)\[([^\]]+)\]/g, (_, menu, path) => {
+            const parts = path.split(' > ').map(s => s.trim());
+            let result = menu;
+            parts.forEach((part) => {
+                result += ' → ' + part;
+            });
+            return '**' + result + '**';
+        });
+        // btn:[text] → **[text]**
+        processedValue = processedValue.replace(/btn:\[([^\]]+)\]/g, '**[$1]**');
+        const quotedValue = `"${processedValue}"`;
+        return `{%- set ${varName} = ${quotedValue} ${rightStrip}%}`;
+    }
+    else {
+        // Boolean attribute: :name:
+        // Convert to: {% set name = true %}
+        return `{%- set ${varName} = true ${rightStrip}%}`;
+    }
+}
+/**
+ * Checks if a line is a template directive (conditional or attribute assignment).
+ * @param {string} line - Line to check
+ * @returns {boolean} True if line is a template directive
+ */
+function isTemplateDirective(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    // Check for conditional directives
+    if (trimmed.match(/^ifdef::/))
+        return true;
+    if (trimmed.match(/^ifndef::/))
+        return true;
+    if (trimmed.match(/^ifeval::/))
+        return true;
+    if (trimmed.match(/^endif::/))
+        return true;
+    // Check for attribute assignment or unset
+    if (trimmed.match(/^:!?[a-zA-Z0-9_-]+:/))
+        return true;
+    return false;
+}
+/**
+ * Checks if a line has non-whitespace content.
+ * @param {string} line - Line to check
+ * @returns {boolean} True if line has content
+ */
+function hasContentOnLine(line) {
+    return line && line.trim().length > 0;
+}
+/**
+ * Detects if opening tag should be inline (previous line has non-template content).
+ * @param {Array<string>} lines - All lines
+ * @param {number} currentIndex - Current line index
+ * @returns {boolean} True if should use inline (left-strip) for opening tag
+ */
+function isInlineOpeningContext(lines, currentIndex) {
+    if (currentIndex === 0)
+        return false;
+    const prevLine = lines[currentIndex - 1];
+    // Only inline if previous line has content AND is not a template directive
+    // This excludes nested conditionals and attribute assignments
+    return hasContentOnLine(prevLine) && !isTemplateDirective(prevLine);
+}
+/**
+ * Detects if closing tag should be inline (next line has non-template content).
+ * @param {Array<string>} lines - All lines
+ * @param {number} currentIndex - Current line index
+ * @returns {boolean} True if should use inline (left-strip) for closing tag
+ */
+function isInlineClosingContext(lines, currentIndex) {
+    // Only inline if next line exists and has content that's not a template directive
+    if (currentIndex + 1 < lines.length) {
+        const nextLine = lines[currentIndex + 1];
+        // Only inline if next line has content AND is not a template directive
+        // This excludes nested conditionals and attribute assignments
+        return hasContentOnLine(nextLine) && !isTemplateDirective(nextLine);
+    }
+    return false;
+}
+/**
+ * Checks if a table contains conditionals or other complex features requiring HTML output.
+ * Complex features include: conditionals (ifdef, ifndef, ifeval), colspan, rowspan.
+ *
+ * @param {Array<string>} tableLines - Lines within the table (between |=== markers)
+ * @returns {boolean} True if table needs HTML conversion
+ */
+function tableNeedsHtmlConversion(tableLines) {
+    for (const line of tableLines) {
+        const trimmed = line.trim();
+        // Check for conditionals
+        if (trimmed.match(/^ifdef::|^ifndef::|^ifeval::|^endif::/)) {
+            return true;
+        }
+        // Check for inline conditionals: ifdef::attr[content] or ifndef::attr[content]
+        if (trimmed.match(/ifdef::[^\[]+\[.+\]/) || trimmed.match(/ifndef::[^\[]+\[.+\]/)) {
+            return true;
+        }
+        // Check for AsciiDoc cells (a|) which can contain complex content like lists
+        if (trimmed.match(/^a\|/) || trimmed.match(/\|?\s*a\|/)) {
+            return true;
+        }
+        // Check for colspan (N+|) patterns
+        if (/^\d+\+\|/.test(trimmed)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Converts an AsciiDoc conditional to Jinja2 format for inline use in HTML.
+ * @param {string} directive - The conditional directive (ifdef, ifndef, etc.)
+ * @param {string} attrs - The attribute(s) being tested
+ * @returns {string} Jinja2 conditional string
+ */
+function conditionalToJinja2(directive, attrs) {
+    // Parse attributes with both OR (,) and AND (+) operators
+    const orGroups = attrs.split(',').map(group => {
+        const andAttrs = group.trim().split('+').map(a => a.trim().replace(/-/g, '_'));
+        return andAttrs.length === 1 ? andAttrs[0] : `(${andAttrs.join(' and ')})`;
+    });
+    if (directive === 'ifdef') {
+        const condition = orGroups.join(' or ');
+        return `{% if ${condition} %}`;
+    }
+    else if (directive === 'ifndef') {
+        if (orGroups.length === 1 && !orGroups[0].includes('(')) {
+            return `{% if not ${orGroups[0]} %}`;
+        }
+        else {
+            const condition = orGroups.join(' or ');
+            return `{% if not (${condition}) %}`;
+        }
+    }
+    return '';
+}
+/**
+ * Parses AsciiDoc table column spec to determine column count and alignments.
+ * @param {string} colSpec - Column specification (e.g., "2,2,2,2,2,2" or "3*")
+ * @returns {Object} { count: number, aligns: Array<string> }
+ */
+function parseTableColSpec(colSpec) {
+    if (!colSpec)
+        return { count: 0, aligns: [] };
+    // In AsciiDoc, a bare number (e.g., cols="3") means 3 equal-width columns
+    if (/^\d+$/.test(colSpec.trim())) {
+        const count = parseInt(colSpec.trim(), 10);
+        return { count, aligns: new Array(count).fill('') };
+    }
+    const cols = [];
+    const parts = colSpec.split(/,|;/);
+    for (const part of parts) {
+        const multiplierMatch = part.match(/^(\d+)\*(.*)$/);
+        if (multiplierMatch) {
+            const count = parseInt(multiplierMatch[1], 10);
+            const align = multiplierMatch[2] || '';
+            for (let i = 0; i < count; i++)
+                cols.push(align);
+        }
+        else {
+            cols.push(part);
+        }
+    }
+    // Determine alignment from column spec
+    const aligns = cols.map(c => {
+        if (c.includes('<'))
+            return 'left';
+        if (c.includes('>'))
+            return 'right';
+        if (c.includes('^'))
+            return 'center';
+        return '';
+    });
+    return { count: cols.length, aligns };
+}
+/**
+ * Converts an AsciiDoc table with conditionals to HTML format.
+ * This preserves conditionals inline within the HTML structure.
+ *
+ * @param {Array<string>} tableLines - Lines within the table (between |=== markers)
+ * @param {Object} options - Table options from block attributes
+ * @returns {string} HTML table with inline Jinja2 conditionals
+ */
+// Marker for HTML content that should pass through without processing
+const HTML_PASSTHROUGH_MARKER = '__HTML_PASSTHROUGH__';
+function convertTableToHtml(tableLines, options = {}) {
+    const { colSpec, hasHeader } = options;
+    const { count: specColCount, aligns } = parseTableColSpec(colSpec);
+    const result = [];
+    const M = HTML_PASSTHROUGH_MARKER; // Shorthand
+    result.push(M + '<table>');
+    let headerWritten = false;
+    let bodyStarted = false;
+    let currentRow = [];
+    let conditionalStack = [];
+    let isFirstRow = true;
+    // Column count: from colSpec, or inferred from first row
+    let columnCount = specColCount || 0;
+    // Helper to output current row
+    function outputRow() {
+        if (currentRow.length === 0)
+            return;
+        // Set column count from first row if not known
+        if (columnCount === 0)
+            columnCount = currentRow.length;
+        const isHeader = isFirstRow && (hasHeader !== false);
+        const tag = isHeader ? 'th' : 'td';
+        function renderCells(tag) {
+            for (const cell of currentRow) {
+                const colspanAttr = cell.colspan ? ` colspan="${cell.colspan}"` : '';
+                if (cell.cellWrapper) {
+                    result.push(M + `  ${cell.cellWrapper.open}<${tag}${colspanAttr}>${cell.content}</${tag}>${cell.cellWrapper.close}`);
+                }
+                else {
+                    result.push(M + `  <${tag}${colspanAttr}>${cell.content}</${tag}>`);
+                }
+            }
+        }
+        if (isHeader && !headerWritten) {
+            result.push(M + '<thead>');
+            result.push(M + '<tr>');
+            renderCells(tag);
+            result.push(M + '</tr>');
+            result.push(M + '</thead>');
+            headerWritten = true;
+        }
+        else {
+            if (!bodyStarted) {
+                result.push(M + '<tbody>');
+                bodyStarted = true;
+            }
+            result.push(M + '<tr>');
+            renderCells(tag);
+            result.push(M + '</tr>');
+        }
+        currentRow = [];
+        isFirstRow = false;
+    }
+    // Count effective columns, treating consecutive conditional cells as one column
+    function effectiveColumnCount() {
+        let count = 0;
+        let prevConditionalWrapper = null;
+        for (const cell of currentRow) {
+            if (cell.colspan) {
+                count += cell.colspan;
+                prevConditionalWrapper = null;
+            }
+            else if (cell.cellWrapper) {
+                // Same wrapper as previous = cells from one conditional block → count each
+                // Different wrapper from previous = alternatives for same column → count as one
+                if (prevConditionalWrapper === null || cell.cellWrapper.open === prevConditionalWrapper) {
+                    count++;
+                }
+                prevConditionalWrapper = cell.cellWrapper.open;
+            }
+            else {
+                count++;
+                prevConditionalWrapper = null;
+            }
+        }
+        return count;
+    }
+    // Check if current row is complete (has enough cells) and output if so
+    function checkRowComplete() {
+        if (columnCount > 0 && effectiveColumnCount() >= columnCount) {
+            outputRow();
+        }
+    }
+    // Helper: convert inline AsciiDoc markup in a string (for use inside HTML)
+    function convertInlineMarkup(text) {
+        let s = text;
+        // Convert attribute references
+        s = s.replace(/\{([a-zA-Z0-9_-]+)\}/g, (_, attr) => '{{ ' + attr.replace(/-/g, '_') + ' }}');
+        // Convert link macros: link:URL[text] → <a href="URL">text</a>
+        // URL may contain {{ attr }} template variables (with spaces) or regular URLs
+        s = s.replace(/link:((?:\{\{[^}]+\}\}|[^\s\[])+)\[([^\]]*)\]/g, '<a href="$1">$2</a>');
+        // Convert xref macros: xref:target[text] → <a href="#target">text</a>
+        s = s.replace(/xref:([^\[]*)\[([^\]]*)\]/g, '<a href="#$1">$2</a>');
+        // Convert monospace: `text` → <code>text</code> (also handle `+text+` passthrough)
+        s = s.replace(/`\+?([^`]+?)\+?`/g, '<code>$1</code>');
+        // Convert bold: *text* → <strong>text</strong>
+        s = s.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<strong>$1</strong>');
+        // Convert italic: _text_ → <em>text</em> (only at word boundaries)
+        s = s.replace(/(?<!\w)_([^_]+)_(?!\w)/g, '<em>$1</em>');
+        return s;
+    }
+    // Helper: escape HTML special characters for code blocks
+    function escapeHtml(text) {
+        return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    // Helper: convert AsciiDoc cell content lines to HTML
+    function convertCellContent(lines) {
+        let html = '';
+        let listType = null; // 'ul' or 'ol'
+        let inCodeBlock = false;
+        let codeLines = [];
+        let pendingAdmonition = null; // 'NOTE', 'WARNING', etc.
+        let inAdmonition = null;
+        let admonitionLines = [];
+        function closeList() {
+            if (listType) {
+                html += '</' + listType + '>';
+                listType = null;
+            }
+        }
+        function flushCodeBlock() {
+            if (codeLines.length > 0 || inCodeBlock) {
+                closeList();
+                html += '<pre>' + escapeHtml(codeLines.join('\n')).replace(/\n/g, '&#10;') + '</pre>';
+                codeLines = [];
+                inCodeBlock = false;
+            }
+        }
+        function flushAdmonition() {
+            if (inAdmonition) {
+                closeList();
+                const admonType = inAdmonition.charAt(0) + inAdmonition.slice(1).toLowerCase();
+                const content = admonitionLines.map(l => l === '' ? '<br><br>' : convertInlineMarkup(l)).join('');
+                html += '<dl><dt>' + admonType + '</dt><dd>' + content + '</dd></dl>';
+                inAdmonition = null;
+                admonitionLines = [];
+            }
+        }
+        for (const l of lines) {
+            const t = l.trim();
+            // Code block delimiter (----)
+            if (/^-{4,}\s*$/.test(t)) {
+                if (inCodeBlock) {
+                    flushCodeBlock();
+                }
+                else {
+                    closeList();
+                    inCodeBlock = true;
+                    codeLines = [];
+                }
+                continue;
+            }
+            // Code block content: accumulate verbatim
+            if (inCodeBlock) {
+                codeLines.push(t);
+                continue;
+            }
+            // Admonition header: [NOTE], [WARNING], etc.
+            const admonMatch = t.match(/^\[(NOTE|IMPORTANT|WARNING|CAUTION|TIP)\]\s*$/);
+            if (admonMatch) {
+                closeList();
+                pendingAdmonition = admonMatch[1];
+                continue;
+            }
+            // Admonition delimiter (====): opens or closes admonition block
+            if (/^={4,}\s*$/.test(t)) {
+                if (pendingAdmonition) {
+                    inAdmonition = pendingAdmonition;
+                    pendingAdmonition = null;
+                    admonitionLines = [];
+                    continue;
+                }
+                else if (inAdmonition) {
+                    flushAdmonition();
+                    continue;
+                }
+                // Standalone ==== without admonition context: treat as regular text
+            }
+            // If [NOTE] was seen but next line wasn't ====, emit [NOTE] as text
+            if (pendingAdmonition) {
+                html += convertInlineMarkup('[' + pendingAdmonition + ']');
+                pendingAdmonition = null;
+                // Fall through to process current line normally
+            }
+            // Admonition content: accumulate
+            if (inAdmonition) {
+                admonitionLines.push(t);
+                continue;
+            }
+            // Block attributes ([literal, ...], [source,yaml], etc.): strip
+            if (/^\[.*\]\s*$/.test(t)) {
+                continue;
+            }
+            // Blank line: paragraph break
+            if (t === '') {
+                closeList();
+                if (html)
+                    html += '<br><br>';
+                continue;
+            }
+            // Unordered list item (* item)
+            if (t.startsWith('* ')) {
+                if (listType !== 'ul') {
+                    closeList();
+                    html += '<ul>';
+                    listType = 'ul';
+                }
+                html += '<li>' + convertInlineMarkup(t.substring(2)) + '</li>';
+                continue;
+            }
+            // Unordered list item (- item)
+            if (t.startsWith('- ')) {
+                if (listType !== 'ul') {
+                    closeList();
+                    html += '<ul>';
+                    listType = 'ul';
+                }
+                html += '<li>' + convertInlineMarkup(t.substring(2)) + '</li>';
+                continue;
+            }
+            // Ordered list item (. item)
+            if (t.startsWith('. ') && !t.startsWith('.. ')) {
+                if (listType !== 'ol') {
+                    closeList();
+                    html += '<ol>';
+                    listType = 'ol';
+                }
+                html += '<li>' + convertInlineMarkup(t.substring(2)) + '</li>';
+                continue;
+            }
+            // Regular text
+            closeList();
+            html += convertInlineMarkup(t);
+        }
+        // Flush any unclosed blocks
+        if (inCodeBlock)
+            flushCodeBlock();
+        if (inAdmonition)
+            flushAdmonition();
+        closeList();
+        // Trim trailing <br> breaks from blank lines at end of cell
+        return html.replace(/(<br>)+$/, '');
+    }
+    // Helper: apply attribute reference conversion and inline conditionals to a cell string
+    function convertCellString(str) {
+        let s = str;
+        // Handle inline conditionals with pipe
+        s = s.replace(/ifdef::([^\[]+)\[\|((?:[^\]]|\]\^)*)\]/g, (_, attrs, content) => {
+            return '|__COND_CELL__' + conditionalToJinja2('ifdef', attrs) + '__COND_SEP__' + content + '__COND_END__';
+        });
+        s = s.replace(/ifndef::([^\[]+)\[\|((?:[^\]]|\]\^)*)\]/g, (_, attrs, content) => {
+            return '|__COND_CELL__' + conditionalToJinja2('ifndef', attrs) + '__COND_SEP__' + content + '__COND_END__';
+        });
+        // Handle inline conditionals without pipe
+        s = s.replace(/ifdef::([^\[]+)\[((?:[^\]]|\]\^)*)\]/g, (_, attrs, content) => {
+            return conditionalToJinja2('ifdef', attrs) + content + '{% endif %}';
+        });
+        s = s.replace(/ifndef::([^\[]+)\[((?:[^\]]|\]\^)*)\]/g, (_, attrs, content) => {
+            return conditionalToJinja2('ifndef', attrs) + content + '{% endif %}';
+        });
+        // Convert inline markup (attribute refs, links, xrefs) for HTML context
+        s = convertInlineMarkup(s);
+        return s;
+    }
+    // Helper: add a cell to currentRow with appropriate wrappers
+    function addCell(content, stackWrapper) {
+        const condCellMatch = content.match(/^__COND_CELL__(.+?)__COND_SEP__(.*)__COND_END__$/);
+        if (condCellMatch) {
+            const [, condOpen, innerContent] = condCellMatch;
+            if (stackWrapper) {
+                currentRow.push({ content: innerContent, cellWrapper: { open: stackWrapper.open + condOpen, close: '{% endif %}' + stackWrapper.close } });
+            }
+            else {
+                currentRow.push({ content: innerContent, cellWrapper: { open: condOpen, close: '{% endif %}' } });
+            }
+        }
+        else if (stackWrapper) {
+            currentRow.push({ content, cellWrapper: stackWrapper });
+        }
+        else {
+            currentRow.push({ content, cellWrapper: null });
+        }
+    }
+    let inAsciidocCell = false;
+    let asciidocCellLines = [];
+    let asciidocCellWrapper = null;
+    // Helper: flush collected a| cell content
+    function flushAsciidocCell() {
+        if (!inAsciidocCell)
+            return;
+        const content = convertCellContent(asciidocCellLines);
+        addCell(content, asciidocCellWrapper);
+        inAsciidocCell = false;
+        asciidocCellLines = [];
+        asciidocCellWrapper = null;
+    }
+    for (let i = 0; i < tableLines.length; i++) {
+        const line = tableLines[i];
+        const trimmed = line.trim();
+        // Empty line handling
+        if (!trimmed) {
+            if (inAsciidocCell) {
+                // Blank lines within a| cells are part of the cell content (paragraph breaks)
+                asciidocCellLines.push('');
+                continue;
+            }
+            checkRowComplete();
+            // If column count is unknown (first row not yet complete), use empty line as row boundary
+            if (columnCount === 0 && currentRow.length > 0) {
+                outputRow();
+            }
+            continue;
+        }
+        // Skip AsciiDoc comments (lines starting with //)
+        // Special case: when in a| cell, a comment ending with "| value" may contain
+        // a cell delimiter the author intended to preserve (common authoring mistake)
+        if (trimmed.startsWith('//')) {
+            if (inAsciidocCell) {
+                const commentText = trimmed.substring(2);
+                // Find last | in the comment that has non-empty text before it (not "// | cell | cell" patterns)
+                const lastPipeIdx = commentText.lastIndexOf('|');
+                if (lastPipeIdx > 0) {
+                    const beforePipe = commentText.substring(0, lastPipeIdx).trim();
+                    const afterPipe = commentText.substring(lastPipeIdx + 1).trim();
+                    // Only extract if: text before | is substantial, text after | is a short value,
+                    // and there's no other | before (which would indicate a full commented row)
+                    if (beforePipe.length > 0 && afterPipe.length > 0 && afterPipe.length <= 20
+                        && !beforePipe.includes('|')) {
+                        // End the a| cell and add the extracted cell value
+                        flushAsciidocCell();
+                        checkRowComplete();
+                        const sw = conditionalStack.length > 0
+                            ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                            : null;
+                        addCell(convertCellString(afterPipe), sw);
+                        checkRowComplete();
+                        continue;
+                    }
+                }
+            }
+            continue;
+        }
+        // Handle block conditionals (full line ifdef/ifndef/endif)
+        const blockIfdefMatch = trimmed.match(/^ifdef::([^\[]+)\[\]$/);
+        if (blockIfdefMatch) {
+            const jinja = conditionalToJinja2('ifdef', blockIfdefMatch[1]);
+            conditionalStack.push(jinja);
+            continue;
+        }
+        const blockIfndefMatch = trimmed.match(/^ifndef::([^\[]+)\[\]$/);
+        if (blockIfndefMatch) {
+            const jinja = conditionalToJinja2('ifndef', blockIfndefMatch[1]);
+            conditionalStack.push(jinja);
+            continue;
+        }
+        if (trimmed.match(/^endif::/)) {
+            if (conditionalStack.length > 0) {
+                conditionalStack.pop();
+            }
+            continue;
+        }
+        // If collecting a| cell content, check if this line starts a new cell or continues content
+        if (inAsciidocCell) {
+            if (trimmed.startsWith('|') || trimmed.startsWith('a|')) {
+                flushAsciidocCell();
+                checkRowComplete();
+                // Fall through to handle the new cell below
+            }
+            else {
+                // Check for inline a| cell boundary (e.g., "---- a| ----")
+                const inlineAIdx = trimmed.indexOf(' a|');
+                if (inlineAIdx >= 0) {
+                    // Content before ' a|' belongs to current cell
+                    const beforeContent = trimmed.substring(0, inlineAIdx).trim();
+                    if (beforeContent) {
+                        asciidocCellLines.push(beforeContent);
+                    }
+                    flushAsciidocCell();
+                    checkRowComplete();
+                    // Start new a| cell
+                    const stackWrapper = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    inAsciidocCell = true;
+                    asciidocCellLines = [];
+                    asciidocCellWrapper = stackWrapper;
+                    const afterContent = trimmed.substring(inlineAIdx + 3).trim();
+                    if (afterContent) {
+                        asciidocCellLines.push(afterContent);
+                    }
+                    continue;
+                }
+                // Check for inline | cell boundary (e.g., "...content.| Yes")
+                // Find last | that is NOT inside [] brackets
+                let pipeIdx = -1;
+                let bracketDepth = 0;
+                for (let c = trimmed.length - 1; c >= 0; c--) {
+                    if (trimmed[c] === ']')
+                        bracketDepth++;
+                    else if (trimmed[c] === '[')
+                        bracketDepth--;
+                    else if (trimmed[c] === '|' && bracketDepth === 0) {
+                        pipeIdx = c;
+                        break;
+                    }
+                }
+                if (pipeIdx > 0) {
+                    // Content before | belongs to current cell
+                    const beforeContent = trimmed.substring(0, pipeIdx).trim();
+                    if (beforeContent) {
+                        asciidocCellLines.push(beforeContent);
+                    }
+                    flushAsciidocCell();
+                    checkRowComplete();
+                    // Re-process the | and everything after it as a new cell line
+                    const cellPart = trimmed.substring(pipeIdx);
+                    // Fall through to the cell parsing below by updating trimmed/line
+                    // We can't easily re-enter the loop, so handle it directly
+                    const afterPipe = cellPart.substring(1).trim();
+                    const stackWrapper = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    if (afterPipe === '') {
+                        addCell('', stackWrapper);
+                    }
+                    else {
+                        const converted = convertCellString(afterPipe);
+                        addCell(converted, stackWrapper);
+                    }
+                    checkRowComplete();
+                    continue;
+                }
+                // Continuation of a| cell content (bullet lists, text, etc.)
+                asciidocCellLines.push(trimmed);
+                continue;
+            }
+        }
+        // Handle inline conditional cells (e.g., ifndef::ibm-z[|300])
+        // The | inside the brackets is a real AsciiDoc cell delimiter - the conditional
+        // provides a cell value. We parse the whole construct here to avoid the naive
+        // | split below from breaking it into separate parts.
+        const inlineCondCellMatch = trimmed.match(/^(ifdef|ifndef)::([^\[]+)\[\|(.*)\]$/);
+        if (inlineCondCellMatch) {
+            const [, directive, attrs, content] = inlineCondCellMatch;
+            const jinja = conditionalToJinja2(directive, attrs);
+            const converted = content.replace(/\{([a-zA-Z0-9_-]+)\}/g, (_, attr) => '{{ ' + attr.replace(/-/g, '_') + ' }}');
+            currentRow.push({ content: converted, cellWrapper: { open: jinja, close: '{% endif %}' } });
+            checkRowComplete();
+            continue;
+        }
+        // Handle colspan: N+| content → cell spanning N columns
+        const colspanMatch = trimmed.match(/^(\d+)\+\|\s*(.*)$/);
+        if (colspanMatch) {
+            const colspan = parseInt(colspanMatch[1], 10);
+            const content = convertCellString(colspanMatch[2]);
+            const stackWrapper = conditionalStack.length > 0
+                ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                : null;
+            currentRow.push({ content, cellWrapper: stackWrapper, colspan });
+            // A colspan cell hints at the total column count (e.g., 2+| in a 2-column table)
+            if (columnCount === 0)
+                columnCount = colspan;
+            checkRowComplete();
+            continue;
+        }
+        // Handle continuation lines (don't start with | or a|)
+        // In AsciiDoc tables, text before the first | on such lines continues the previous cell
+        if (!trimmed.startsWith('|') && !trimmed.startsWith('a|')) {
+            // Check for inline a| in continuation (e.g., "...text. a| - item" or "...text. a|")
+            const contAIdx = trimmed.indexOf(' a|');
+            if (contAIdx >= 0) {
+                const continuation = trimmed.substring(0, contAIdx).trim();
+                if (continuation && currentRow.length > 0) {
+                    currentRow[currentRow.length - 1].content += ' ' + convertCellString(continuation);
+                }
+                else if (continuation) {
+                    const sw = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    addCell(convertCellString(continuation), sw);
+                    checkRowComplete();
+                }
+                // Start a| cell collection
+                const stackWrapper = conditionalStack.length > 0
+                    ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                    : null;
+                inAsciidocCell = true;
+                asciidocCellLines = [];
+                asciidocCellWrapper = stackWrapper;
+                const afterContent = trimmed.substring(contAIdx + 3).trim();
+                if (afterContent) {
+                    asciidocCellLines.push(afterContent);
+                }
+                continue;
+            }
+            if (trimmed.includes('|')) {
+                // Line has | mid-line: first part continues previous cell, rest are new cells
+                const firstPipeIdx = trimmed.indexOf('|');
+                const continuation = trimmed.substring(0, firstPipeIdx).trim();
+                if (continuation && currentRow.length > 0) {
+                    currentRow[currentRow.length - 1].content += ' ' + convertCellString(continuation);
+                }
+                else if (continuation) {
+                    // No previous cell to append to - treat as new cell
+                    const stackWrapper = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    addCell(convertCellString(continuation), stackWrapper);
+                    checkRowComplete();
+                }
+                // Process rest of line (starting from |) as new cells by re-entering the cell parser
+                const remainingCells = trimmed.substring(firstPipeIdx);
+                let remContent = remainingCells.substring(1); // Remove leading |
+                if (remContent.trim() === '') {
+                    const sw = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    addCell('', sw);
+                    checkRowComplete();
+                }
+                else {
+                    const remParts = remContent.split('|');
+                    const sw = conditionalStack.length > 0
+                        ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                        : null;
+                    for (const rp of remParts) {
+                        const rpTrimmed = rp.trim();
+                        if (rpTrimmed === '')
+                            continue;
+                        addCell(convertCellString(rpTrimmed), sw);
+                        checkRowComplete();
+                    }
+                }
+                continue;
+            }
+            else {
+                // No | at all - pure continuation of previous cell
+                if (currentRow.length > 0) {
+                    currentRow[currentRow.length - 1].content += ' ' + convertCellString(trimmed);
+                }
+                continue;
+            }
+        }
+        // Handle table cells (lines starting with |, a|, or containing |)
+        if (trimmed.startsWith('|') || trimmed.startsWith('a|') || trimmed.includes('|')) {
+            // Parse cells from the line
+            let cellContent = trimmed;
+            let cellsAddedThisLine = 0;
+            // Remove leading | if present
+            if (cellContent.startsWith('|')) {
+                cellContent = cellContent.substring(1);
+            }
+            // Handle empty cell (line is just "|" or "| ")
+            if (cellContent.trim() === '') {
+                const stackWrapper = conditionalStack.length > 0
+                    ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                    : null;
+                addCell('', stackWrapper);
+                checkRowComplete();
+                continue;
+            }
+            const parts = cellContent.split('|');
+            const stackWrapper = conditionalStack.length > 0
+                ? { open: conditionalStack.join(''), close: '{% endif %}'.repeat(conditionalStack.length) }
+                : null;
+            for (let p = 0; p < parts.length; p++) {
+                const part = parts[p].trim();
+                if (part === '' || part === undefined)
+                    continue;
+                // Check if this part is 'a' prefix (from splitting "a| content" on |)
+                // Also handle inline "text a|" where part ends with ' a'
+                if ((part === 'a' || part.endsWith(' a')) && p + 1 < parts.length) {
+                    // If part has text before ' a', add it as a regular cell first
+                    if (part !== 'a') {
+                        const textContent = part.slice(0, -2).trim();
+                        if (textContent) {
+                            const converted = convertCellString(textContent);
+                            addCell(converted, stackWrapper);
+                            cellsAddedThisLine++;
+                            checkRowComplete();
+                        }
+                    }
+                    flushAsciidocCell();
+                    checkRowComplete();
+                    inAsciidocCell = true;
+                    asciidocCellLines = [];
+                    asciidocCellWrapper = stackWrapper;
+                    const restContent = parts[p + 1].trim();
+                    if (restContent) {
+                        asciidocCellLines.push(restContent);
+                    }
+                    cellsAddedThisLine++;
+                    p++; // Skip the next part since we consumed it
+                }
+                else if (trimmed.startsWith('a|') && p === 0) {
+                    // Line starts with a| (e.g., "a| \n* item1\n* item2")
+                    flushAsciidocCell();
+                    checkRowComplete();
+                    inAsciidocCell = true;
+                    asciidocCellLines = [];
+                    asciidocCellWrapper = stackWrapper;
+                    if (part.substring(1).trim()) {
+                        asciidocCellLines.push(part.substring(1).trim());
+                    }
+                    cellsAddedThisLine++;
+                }
+                else {
+                    // Regular cell
+                    const converted = convertCellString(part);
+                    addCell(converted, stackWrapper);
+                    cellsAddedThisLine++;
+                    checkRowComplete();
+                }
+            }
+            // If this line added multiple cells and we don't know column count yet,
+            // infer it from this line (e.g., "| Type | Description | Notes" = 3 columns)
+            if (columnCount === 0 && cellsAddedThisLine > 1) {
+                columnCount = cellsAddedThisLine;
+                checkRowComplete();
+            }
+        }
+    }
+    // Flush any remaining a| cell and row
+    flushAsciidocCell();
+    if (currentRow.length > 0) {
+        outputRow();
+    }
+    if (bodyStarted) {
+        result.push(M + '</tbody>');
+    }
+    result.push(M + '</table>');
+    return result.join('\n');
+}
+/**
+ * Preprocesses AsciiDoc content to convert complex tables to HTML.
+ * Complex tables include those with conditionals, colspan, rowspan, or nested content.
+ *
+ * @param {string} content - AsciiDoc content
+ * @returns {string} Content with complex tables converted to HTML
+ */
+function convertComplexTablesToHtml(content) {
+    const lines = content.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Check for table block attributes followed by table start
+        // AsciiDoc tables use |=== with 3 or more = signs
+        if (/^\|={3,}$/.test(trimmed) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            // Look for table start
+            let tableStart = i;
+            let blockAttrs = null;
+            if (trimmed.startsWith('[')) {
+                // This might be block attributes before a table
+                blockAttrs = trimmed;
+                // Look ahead for |===
+                if (i + 1 < lines.length) {
+                    const nextLine = lines[i + 1].trim();
+                    if (/^\|={3,}$/.test(nextLine)) {
+                        tableStart = i + 1;
+                        i++; // Skip to |===
+                    }
+                    else {
+                        // Not a table, preserve the line
+                        result.push(line);
+                        i++;
+                        continue;
+                    }
+                }
+                else {
+                    result.push(line);
+                    i++;
+                    continue;
+                }
+            }
+            // We're at a |=== line
+            if (!/^\|={3,}$/.test(lines[i].trim())) {
+                result.push(line);
+                i++;
+                continue;
+            }
+            // Find the end of the table
+            const tableLines = [];
+            i++; // Move past opening |===
+            while (i < lines.length && !/^\|={3,}$/.test(lines[i].trim())) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            // Check if this table needs HTML conversion
+            if (tableNeedsHtmlConversion(tableLines)) {
+                // Parse block attributes for table options
+                const options = {};
+                if (blockAttrs) {
+                    const colsMatch = blockAttrs.match(/cols="([^"]+)"/);
+                    if (colsMatch)
+                        options.colSpec = colsMatch[1];
+                    options.hasHeader = blockAttrs.includes('header') && !blockAttrs.includes('noheader');
+                }
+                // Convert to HTML
+                const htmlTable = convertTableToHtml(tableLines, options);
+                // Add block title if present (look back for .Title line)
+                if (result.length > 0 && result[result.length - 1].startsWith('.') &&
+                    !result[result.length - 1].startsWith('..')) {
+                    const title = result.pop().substring(1);
+                    result.push(`**${title}**`);
+                    result.push('');
+                }
+                result.push(htmlTable);
+                // CommonMark requires a blank line after an HTML block before markdown resumes
+                // Mark as passthrough so the main engine preserves it
+                result.push(HTML_PASSTHROUGH_MARKER);
+            }
+            else {
+                // Keep as-is (will be converted to markdown table later)
+                if (blockAttrs) {
+                    result.push(blockAttrs);
+                }
+                result.push('|===');
+                result.push(...tableLines);
+                result.push('|===');
+            }
+            i++; // Move past closing |===
+        }
+        else {
+            result.push(line);
+            i++;
+        }
+    }
+    return result.join('\n');
+}
+/**
+ * Converts AsciiDoc conditional directives to standard Jinja2 format.
+ * Handles ifdef, ifndef, ifeval, and endif directives.
+ * Also converts AsciiDoc attribute assignments (:attr:) to Jinja2 set statements.
+ * Intelligently manages whitespace stripping to preserve significant blank lines.
+ *
+ * @param {string} content - AsciiDoc content
+ * @returns {string} Content with conditionals converted to Jinja2 format
+ */
+function convertConditionals(content) {
+    const lines = content.split('\n');
+    const result = [];
+    const conditionalStack = []; // Track conditional nesting
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Handle ifdef directive - convert to: {% if name %} or {% if name1 or name2 %} or {% if name1 and name2 %}
+        const ifdefMatch = trimmed.match(/^ifdef::([^\[]+)\[\]$/);
+        if (ifdefMatch) {
+            const [, names] = ifdefMatch;
+            // Parse attributes with both OR (,) and AND (+) operators
+            // Examples: "attr1,attr2" → "attr1 or attr2"
+            //           "attr1+attr2" → "attr1 and attr2"
+            //           "attr1,attr2+attr3" → "attr1 or (attr2 and attr3)"
+            const orGroups = names.split(',').map(group => {
+                const andAttrs = group.trim().split('+').map(a => a.trim().replace(/-/g, '_'));
+                return andAttrs.length === 1 ? andAttrs[0] : `(${andAttrs.join(' and ')})`;
+            });
+            const condition = orGroups.join(' or ');
+            const leftStrip = isInlineOpeningContext(lines, i) ? '-' : '';
+            result.push(`{%${leftStrip} if ${condition} %}`);
+            conditionalStack.push('if');
+            continue;
+        }
+        // Handle ifndef directive - convert to: {% if not name %} or {% if not (name1 or name2) %}
+        const ifndefMatch = trimmed.match(/^ifndef::([^\[]+)\[\]$/);
+        if (ifndefMatch) {
+            const [, names] = ifndefMatch;
+            // Parse attributes with both OR (,) and AND (+) operators
+            const orGroups = names.split(',').map(group => {
+                const andAttrs = group.trim().split('+').map(a => a.trim().replace(/-/g, '_'));
+                return andAttrs.length === 1 ? andAttrs[0] : `(${andAttrs.join(' and ')})`;
+            });
+            const leftStrip = isInlineOpeningContext(lines, i) ? '-' : '';
+            if (orGroups.length === 1 && !orGroups[0].includes('(')) {
+                // Single attribute without AND, no parentheses needed
+                result.push(`{%${leftStrip} if not ${orGroups[0]} %}`);
+            }
+            else {
+                const condition = orGroups.join(' or ');
+                result.push(`{%${leftStrip} if not (${condition}) %}`);
+            }
+            conditionalStack.push('if');
+            continue;
+        }
+        // Handle ifeval directive - convert to: {% if expression %}
+        const ifevalMatch = trimmed.match(/^ifeval::\[(.+)\]$/);
+        if (ifevalMatch) {
+            const [, expression] = ifevalMatch;
+            // Parse and convert the expression to standard Jinja2 format
+            // Convert AsciiDoc attribute references {var} or "{ var}" to just var
+            const jinja2Expr = expression.replace(/"\{([a-zA-Z0-9_-]+)\}"/g, '$1');
+            const leftStrip = isInlineOpeningContext(lines, i) ? '-' : '';
+            result.push(`{%${leftStrip} if ${jinja2Expr} %}`);
+            conditionalStack.push('if');
+            continue;
+        }
+        // Handle endif directive (matches endif::[] or endif::name[] formats)
+        // Always output standard {% endif %} tag
+        if (trimmed.match(/^endif::/)) {
+            if (conditionalStack.length > 0) {
+                conditionalStack.pop();
+                const leftStrip = isInlineClosingContext(lines, i) ? '-' : '';
+                result.push(`{%${leftStrip} endif %}`);
+                continue;
+            }
+            // If no conditional on stack, preserve the line (shouldn't happen in valid AsciiDoc)
+            console.warn(`Warning: ${trimmed} without matching conditional directive`);
+            continue;
+        }
+        // Convert attribute assignments to Jinja2 set statements
+        // Look ahead to determine if we should strip whitespace on the right
+        let stripRight = true;
+        // Find the next non-empty line
+        for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine) {
+                // If next non-empty line is NOT a template directive, preserve whitespace
+                // Template directives don't produce output, so stripping before them is safe
+                // Regular content produces output, so we preserve whitespace before it
+                stripRight = isTemplateDirective(lines[j]);
+                break;
+            }
+        }
+        const jinja2Set = convertAttributeAssignment(line, stripRight);
+        if (jinja2Set) {
+            result.push(jinja2Set);
+            continue;
+        }
+        // Convert link macros that contain attribute references to markdown format
+        // Must happen before attribute references are expanded, since {attr} → {{ attr }}
+        // would break the URL pattern (spaces in URL)
+        let processedLine = line;
+        if (processedLine.includes('link:') && processedLine.includes('{')) {
+            processedLine = processedLine.replace(/link:([^\s\[]*\{[^}]+\}[^\s\[]*)\[([^\]]*)\]/g, (_, url, text) => {
+                return `[${text}](${url})`;
+            });
+        }
+        // Preserve all other lines as-is
+        result.push(processedLine);
+    }
+    // Auto-close unclosed conditionals at end of file with warning
+    if (conditionalStack.length > 0) {
+        console.warn(`Warning: ${conditionalStack.length} unclosed conditional directive(s) - auto-closing`);
+        // Add closing endif tags for each unclosed conditional
+        for (let i = 0; i < conditionalStack.length; i++) {
+            result.push('{% endif %}');
+        }
+    }
+    return result.join('\n');
+}
+/**
+ * Cleans up redundant AsciiDoc continuation markers (+) that appear before list items.
+ * These markers are often left over after include resolution and can cause formatting issues.
+ *
+ * Removes:
+ * - Standalone + on a line before a list item (. or *)
+ * - + with optional whitespace before list items
+ *
+ * @param {string} content - AsciiDoc content (after include resolution)
+ * @returns {string} Content with cleaned up continuation markers
+ */
+function cleanupContinuationMarkers(content) {
+    const lines = content.split('\n');
+    const cleaned = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Check if this is a standalone continuation marker
+        if (trimmed === '+') {
+            // Look ahead to see if the next non-empty line is a list item
+            let nextIdx = i + 1;
+            while (nextIdx < lines.length && lines[nextIdx].trim() === '') {
+                nextIdx++;
+            }
+            if (nextIdx < lines.length) {
+                const nextLine = lines[nextIdx].trim();
+                // Check if next line is a list item (. or numbered, or *, or definition list ::)
+                const isListItem = /^(\d+\.|\.|\*+|[^:]+::)\s/.test(nextLine);
+                if (isListItem) {
+                    // Skip this continuation marker - it's redundant before a list item
+                    continue;
+                }
+            }
+        }
+        cleaned.push(line);
+    }
+    return cleaned.join('\n');
+}
+export default function downdoc(asciidoc, { attributes: initialAttrs = {}, basePath = null, cleanupContinuation = true, nunjucksIncludes = true, dlistFormat = 'markdown', admonitionFormat = 'html' } = {}) {
+    // Resolve includes if basePath is provided
+    if (basePath) {
+        asciidoc = resolveIncludes(asciidoc, basePath, 0, nunjucksIncludes);
+    }
+    // Convert complex tables (with conditionals) to HTML format
+    // This must run before convertConditionals so table conditionals are handled inline
+    if (nunjucksIncludes) {
+        asciidoc = convertComplexTablesToHtml(asciidoc);
+    }
+    // Convert AsciiDoc conditionals to Minja format (always enabled with Nunjucks mode)
+    if (nunjucksIncludes) {
+        asciidoc = convertConditionals(asciidoc);
+    }
+    // Clean up continuation markers if enabled (default: true)
+    // Removes redundant + before list items in both inline and nunjucks modes
+    if (cleanupContinuation) {
+        asciidoc = cleanupContinuationMarkers(asciidoc);
+    }
+    const attrs = new Map(Object.entries(Object.assign({}, ATTRIBUTES, initialAttrs)));
+    const lines = asciidoc.split(attrs.delete('doctitle') ? '\n' : '\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    let inContainer, inHeader, inList, inPara, inTable, indent, inDlistHtml, inDlistPandoc, pandocDlistIndent;
+    inHeader = (inContainer = inPara = (indent = '') || false) || asciidoc[0] === '=' || !!~asciidoc.indexOf('\n= ');
+    inDlistHtml = false; // Track if we're inside an HTML definition list
+    inDlistPandoc = false; // Track if we're inside a Pandoc definition list
+    pandocDlistIndent = ''; // Indent prefix for content inside Pandoc definition list
+    let pandocDlistPendingColon = false; // Defer ':   ' prefix until first content block
+    let blockAttrs, blockTitle, chr0, grab, hardbreakNext, listStack, match, next, subs, style, verbatim, currentHeadingLevel;
+    const [containerStack, nrefs, refs, skipStack, undef] = [(listStack = []).slice(), new Map(), new Map(), [], () => { }];
+    return lines
+        .reduce((accum, line, idx) => {
+        while ((grab = match = next = style = subs = undefined) === undefined) {
+            if (skipStack.length && (match = skipStack[skipStack.length - 1] || (line === 'endif::[]' && line))) {
+                if (line === match)
+                    return undef(skipStack.pop()) || accum;
+                if (match === 'endif::[]' && line.startsWith('if') && /^ifn?def::.+\[\]$/.test(line))
+                    skipStack.push(match);
+                return accum;
+            }
+            // Handle Jinja template directives - pass through unchanged without affecting parser state
+            // These are generated by convertConditionals() and should not be treated as content
+            // IMPORTANT: Template directives should NEVER be indented, even in list context
+            const trimmedLine = line.trim();
+            if (trimmedLine.startsWith('{%') || trimmedLine.startsWith('{{')) {
+                inHeader = false; // Exit header mode when we encounter template directives
+                // Write any pending block title before the directive
+                blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                accum.push(trimmedLine); // No indentation for template directives
+                return accum;
+            }
+            // Handle HTML passthrough content - pass through unchanged
+            // This is used for complex tables that have been converted to HTML
+            if (trimmedLine.startsWith(HTML_PASSTHROUGH_MARKER)) {
+                inHeader = false;
+                blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                // Remove the marker and output the HTML
+                accum.push(trimmedLine.substring(HTML_PASSTHROUGH_MARKER.length));
+                return accum;
+            }
+            if (!line && !inContainer.verbatim) {
+                if (inTable || (inHeader = inPara = false))
+                    return accum;
+                // Close HTML definition list on empty line
+                if (inDlistHtml) {
+                    accum.push(indent + '</dl>');
+                    accum.push(''); // Blank line after </dl>
+                    inDlistHtml = false;
+                }
+                // Close Pandoc definition list on empty line (matches HTML dlist behavior above)
+                // New dlist items will re-set inDlistPandoc; continuation after blank line
+                // requires AsciiDoc '+' marker which uses the normal list continuation mechanism
+                // Don't reset if pendingColon is true — blank line is between term and definition content
+                // Don't reset inside a container (open block, etc.) — blank lines within containers
+                // attached to a dlist via + should not end the dlist
+                if (inDlistPandoc && !pandocDlistPendingColon && !inContainer) {
+                    inDlistPandoc = false;
+                    pandocDlistIndent = '';
+                }
+                inList ? (inPara = undefined) : (line = indent = inContainer.childIndent || '') && (line = line.trimEnd());
+                // Preserve blockAttrs and blockTitle across single empty line, clear verbatim
+                verbatim = verbatim?.close();
+                return accum[accum.length - 1] && (accum[accum.length] = line) ? accum : accum;
+            }
+            else if (((grab = (chr0 = line[0]) === '\\') || (chr0 === 'i' && line[1] !== 'm')) &&
+                ((grab && line === '\\endif::[]') || (line[line.length - 1] === ']' && ~line.indexOf('::') &&
+                    (match = PreprocessorDirectiveRx.exec(line)))) && !(line = grab ? line.substring(1) : undefined)) {
+                if (match[1]) {
+                    const [, , negated, name, text, drop = attrs.has(name) ? !!negated : !negated] = match;
+                    if (text ? (drop ? false : (line = text)) : !skipStack.push(drop && 'endif::[]'))
+                        continue; // redo
+                }
+            }
+            else if (inContainer.verbatim) {
+                if (line === inContainer.delimiter || line.trimEnd() === inContainer.delimiter) {
+                    ;
+                    ({ cap: line, indent, inList, listStack } = inContainer);
+                    if (inContainer.outdent && (grab = inContainer.outdent + indent.length) && ~(match = inContainer.at)) {
+                        for (let i = match, l = accum.length; ++i < l;)
+                            accum[i] = (indent + accum[i].substring(grab)).trimEnd();
+                    }
+                    inContainer = containerStack.length ? containerStack.pop() : false;
+                }
+                else if ((match = line.length)) {
+                    inContainer.outdent &&= Math.min(match - line.trimStart().length, inContainer.outdent);
+                    if (match > 2 && (~line.indexOf('{') || line[match - 1] === '>'))
+                        subs = inContainer.subs;
+                }
+            }
+            else if (!inHeader && ((grab = line.trimEnd()) in DELIMS || line in DELIMS)) {
+                // Normalize delimiter by trimming trailing whitespace (some files have tabs after ----)
+                const delimiter = grab in DELIMS ? grab : line;
+                if (inPara !== false)
+                    inPara = !(listStack = (inList = undef((indent = inContainer.childIndent || ''))) || []);
+                const opening = inContainer === false || (delimiter !== inContainer.delimiter && containerStack.push(inContainer))
+                    ? (inContainer = { delimiter, indent, childIndent: indent, inList, listStack })
+                    : undefined;
+                if ((grab = DELIMS[delimiter]) === 'v') {
+                    inContainer.subs = (inContainer.verbatim = !!(attrs.coseq = 1)) && ['callouts'];
+                    if (blockAttrs) {
+                        style = ((style = blockAttrs.get(1) || (line === '----' || line === '-----' ? 'source' : undefined)) === 'source')
+                            ? blockAttrs.get(2) || attrs.get('source-language')
+                            : style === 'listing' || style === 'literal' ? undefined : style;
+                        if (blockAttrs.get('indent') === '0')
+                            Object.assign(inContainer, { at: accum.length, outdent: Infinity });
+                        if (blockAttrs.get('subs')?.includes('attributes'))
+                            inContainer.subs.push('attributes');
+                        blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                    }
+                    else if (line === '----' || line === '-----')
+                        style = attrs.get('source-language');
+                    line = style ? (inContainer.cap = '```') + style : (inContainer.cap = '```');
+                }
+                else if (grab === 'p' && (inContainer.verbatim = true)) {
+                    line = blockAttrs && blockAttrs.get(1) === 'stem' ? (inContainer.cap = '```') + 'math' : undefined;
+                    blockTitle = undefined;
+                }
+                else if (opening === undefined) {
+                    ;
+                    ({ cap: line, indent, inList, listStack } = inContainer);
+                    inTable = blockTitle = undefined;
+                    inContainer = containerStack.length ? containerStack.pop() : false;
+                }
+                else if (grab === 't') {
+                    inTable = { header: blockAttrs?.has('header-option') || blockAttrs?.get('options')?.includes('header') || (!blockAttrs?.has('noheader-option') && undefined) };
+                    if (blockAttrs !== (line = undefined) && (grab = blockAttrs.get('cols'))) {
+                        const cols = (!~grab.indexOf('*') && grab.split(/,|;/)) || grab.split(/,|;/)
+                            .reduce((a, c) => a.push.apply(a, ~c.indexOf('*') ? Array(parseInt(c, 10)).fill(c) : [c]) && a, []);
+                        (inTable.div = ~grab.indexOf('<') || ~grab.indexOf('^') || ~grab.indexOf('>')
+                            ? cols.reduce((buf, c) => buf + TDIV[/(?<!\.)[<^>]|$/.exec(c)[0]], '') + '|'
+                            : TDIV[''].repeat(cols.length) + '|') && (inTable.cols = cols.length);
+                    }
+                }
+                else if (line === '____') {
+                    indent = inContainer.childIndent += '> ';
+                    if ((grab = blockAttrs && blockAttrs.get(2)))
+                        inContainer.cap = '>\n' + indent + '\u2014 ' + grab;
+                    line = blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                }
+                else if (line === '====' && blockAttrs) {
+                    if ((style = blockAttrs.get(1)) in ADMONS) {
+                        const admonType = ADMON_TYPES[style];
+                        const title = blockTitle ? blockTitle.text : '';
+                        const id = blockAttrs.has('id') ? blockAttrs.get('id') : '';
+                        const isCollapsible = blockAttrs.has('collapsible-option');
+                        const currentIndent = indent || '';
+                        // Include pandocDlistIndent for markers pushed directly to accum,
+                        // since the normal line output (which prepends pandocDlistIndent) is bypassed
+                        const fullIndent = (pandocDlistIndent || '') + currentIndent;
+                        if (admonitionFormat === 'mkdocs') {
+                            // MkDocs: !!! type "title" or ??? for collapsible
+                            const prefix = isCollapsible ? '???' : '!!!';
+                            accum.push(''); // Blank line before
+                            accum.push(fullIndent + prefix + ' ' + admonType + (title ? ' "' + title + '"' : ''));
+                            accum.push(''); // Blank line after opening
+                            indent = inContainer.childIndent = currentIndent + '    ';
+                            inContainer.cap = '\n';
+                            line = undefined;
+                        }
+                        else if (admonitionFormat === 'docusaurus') {
+                            // Docusaurus: :::type or :::type[title]
+                            accum.push(''); // Blank line before
+                            accum.push(fullIndent + ':::' + admonType + (title ? '[' + title + ']' : ''));
+                            accum.push(''); // Blank line after opening
+                            inContainer.cap = '\n' + fullIndent + ':::\n';
+                            line = undefined;
+                        }
+                        else if (admonitionFormat === 'github') {
+                            // GitHub: > [!TYPE]
+                            accum.push(''); // Blank line before
+                            accum.push(fullIndent + '> [!' + style + ']');
+                            indent = inContainer.childIndent = currentIndent + '> ';
+                            inContainer.cap = '\n';
+                            line = undefined;
+                        }
+                        else {
+                            // HTML (default): <dl><dt>...</dt><dd>...</dd></dl>
+                            line = '\n' + fullIndent + '<dl><dt><strong>' + (id ? '<a name="' + id + '"></a>' : '') +
+                                ADMONS[style] + ' ' + style + (title ? ': ' + title : '') + '</strong></dt><dd>\n';
+                            inContainer.cap = '\n' + fullIndent + '</dd></dl>\n';
+                        }
+                        blockTitle = undefined;
+                    }
+                    else if (blockAttrs.has('collapsible-option')) {
+                        line = attrs.get('markdown-collapsible-variant') === 'spoiler' && (grab = 'spoiler')
+                            ? (inContainer.cap = '```') + (blockTitle ? grab + ' ' + applySubs.call(attrs, blockTitle.text) : grab)
+                            : (inContainer.cap = '</details>') && (blockAttrs.has('open-option') ? '<details open>' : '<details>') +
+                                '\n' + indent + '<summary>' + (blockTitle ? blockTitle.text : 'Details') + '</summary>\n';
+                        blockTitle = undefined;
+                    }
+                    else
+                        line = blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                }
+                else
+                    line = blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                if (opening !== (blockAttrs = undefined))
+                    listStack = (inList = undefined) || [];
+            }
+            else {
+                let _chr0, _line, indented;
+                if (!(indented = chr0 === ' '))
+                    _line = line;
+                if (inPara === undefined && !(inPara = false) && (_chr0 = indented ? (_line = line.trimStart())[0] : chr0)) {
+                    // Don't clear list state for continuation markers (+) - they'll be handled below
+                    if (!(line.trim() === '+' && inList)) {
+                        isAnyListItem(_chr0, _line) && inList
+                            ? (accum.length && !accum[accum.length - 1].trim() && accum.pop())
+                            : !indented && (listStack = (inList = undef((indent = inContainer.childIndent || ''))) || []);
+                    }
+                }
+                if (chr0 === '/' && line[1] === '/') {
+                    line = line === '////' ? undef((inPara = !(skipStack.push(line)))) : undefined;
+                }
+                else if (!inPara && chr0 === '=' && (match = isHeading(line, inContainer === false, blockAttrs))) {
+                    // Heading ends any active Pandoc definition list
+                    inDlistPandoc = false;
+                    pandocDlistIndent = '';
+                    let [marker, title, id, autoId] = match;
+                    if (inHeader) {
+                        if (marker.length > 1 || (blockAttrs && blockAttrs.get(1) === 'discrete') || attrs.has('doctitle')) {
+                            if (!(inHeader = false) && accum.length)
+                                return accum;
+                            continue; // redo
+                        }
+                        attrs.set('doctitle', title);
+                        if ((id = blockAttrs?.get('id')))
+                            autoId = title.toLowerCase().replace(/[^a-z0-9_ -]/g, '').split(' ').filter(Boolean).join('-');
+                    }
+                    else {
+                        grab = (title = attributes.call(attrs, title)).toLowerCase().replace(/[^a-z0-9_ -]/g, '').split(' ').filter(Boolean);
+                        autoId = grab.join('-');
+                        id = blockAttrs?.get('id') || attrs.get('idprefix') + grab.join(attrs.get('idseparator'));
+                    }
+                    if (id)
+                        refs.set(title, refs.set(id, { autoId, reftext: blockAttrs?.get('reftext'), title }).get(id));
+                    currentHeadingLevel = marker.length; // Track current heading level for section titles
+                    blockAttrs = blockTitle = undefined;
+                    // Convert attribute references in ID to Jinja2 format (e.g., {context} → {{ context }})
+                    const convertedId = id ? attributes.call(attrs, id) : null;
+                    line = '#'.repeat(marker.length) + ' ' + title + (convertedId ? ` {id="${convertedId}"}` : '');
+                }
+                else if (!inPara && chr0 === ':' && (match = AttributeEntryRx.exec(line))) {
+                    const [, del, name, val = ''] = (line = undefined) || match;
+                    if (!(name in initialAttrs))
+                        del ? attrs.delete(name) : attrs.set(name, val && attributes.call(attrs, val));
+                }
+                else if (chr0 === '[' && line[line.length - 1] === ']') {
+                    if (verbatim && !(inPara = verbatim = verbatim.close()))
+                        continue; // redo
+                    blockAttrs = parseAttrlist(line.substring(1, line.length - 1), blockAttrs);
+                    line = (inPara = false) || undefined;
+                }
+                else if (inHeader) {
+                    if ((inHeader = attrs.has('doctitle'))) {
+                        if (!attrs.has('author') && AuthorInfoLineRx.test(line)) {
+                            const authors = line.split('; ').map((it) => it.split(' <')[0]);
+                            attrs.set('author', authors[0]).set('authors', authors.join(', '));
+                        }
+                        else if (!('revdate' in attrs) && !('revnumber' in attrs) && (match = RevisionInfoLineRx.exec(line))) {
+                            const [, revnumber, revdate_, revdate = revdate_] = match;
+                            (revnumber ? attrs.set('revnumber', revnumber) : true) && revdate && attrs.set('revdate', revdate);
+                        }
+                        else
+                            inHeader = false;
+                    }
+                    if (!inHeader && !accum.length)
+                        continue; // redo
+                    line = undefined;
+                }
+                else if (inTable) {
+                    const row = inTable.row;
+                    const cells = ~line.indexOf('|', 1)
+                        ? line.split(CellDelimiterRx)
+                        : chr0 === '|' ? ['', line.substring(line[1] === ' ' ? 2 : 1)] : [line];
+                    if (row) {
+                        if (cells[0]) {
+                            if (row.length && (row.wrapped = true)) {
+                                row[row.length - 1] = ((grab = row[row.length - 1]) && hardbreak(grab, ' +\n') + ' ') + cells[0];
+                            }
+                            else {
+                                line = (grab = accum[accum.length - 1].split('\n'))[0].substring(0, grab[0].length - 2).trimEnd();
+                                line = hardbreak(line, '<br>') + ' ' + applySubs.call(attrs, cells[0]) + ' |';
+                                accum[accum.length - 1] = grab.length > 1 ? (grab[0] = line) && grab.join('\n') : line;
+                            }
+                        }
+                        if ((cells.length === 1 ? row.length : row.push.apply(row, cells.slice(1))) < inTable.cols)
+                            return accum;
+                        line = '| ' + applySubs.call(attrs, row.splice(0, inTable.cols).join(' | ')) + ' |';
+                        if (row.wrapped && !(row.wrapped = false) && ~line.indexOf(' +\n'))
+                            line = line.replace(/ \+\n/g, '<br>');
+                        // If this completes a multi-line header row, append the divider
+                        if (inTable.headerPending) {
+                            line += '\n' + indent + (inTable.div || TDIV[''].repeat(inTable.cols) + '|');
+                            inTable.headerPending = false;
+                        }
+                        if (row.length && accum.push(indent + line) && (line = '|' + row.splice(0).join(' |')))
+                            continue; // redo
+                    }
+                    else {
+                        const cols = (inTable.row = []) && (inTable.cols ??= cells.length - 1);
+                        if (!(inTable.header ??= cols === cells.length - 1 && lines[idx + 1] === '' && lines[idx - 1] !== '')) {
+                            blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                            accum.push(indent + '|     '.repeat(cols) + '|', indent + (inTable.div || TDIV[''].repeat(cols) + '|'));
+                            continue; // redo
+                        }
+                        subs = NORMAL_SUBS;
+                        // If header cells span multiple lines, accumulate them like body rows
+                        if (cells.length - 1 < cols) {
+                            inTable.headerPending = true;
+                            inTable.row.push.apply(inTable.row, cells.slice(1));
+                            return accum;
+                        }
+                        line = '| ' + cells.slice(1).join(' | ') + ' |\n' + indent + (inTable.div || TDIV[''].repeat(cols) + '|');
+                    }
+                }
+                else if (line.trim() === '+' && (inList || listStack.length || inDlistPandoc)) {
+                    if (inList || listStack.length) {
+                        const listRef = inList || listStack[listStack.length - 1];
+                        ({ indent: line, childIndent: indent } = listRef);
+                        // Reset Pandoc dlist state if returning from dlist to ordered list via continuation
+                        if (!inList && inDlistPandoc) {
+                            inDlistPandoc = false;
+                            pandocDlistIndent = '';
+                        }
+                    }
+                    verbatim = (inPara = false) || verbatim?.close();
+                    // Skip outputting the continuation marker itself - it's just for attaching blocks
+                    // The actual indentation will be handled by the content that follows
+                    return accum;
+                }
+                else if ((!inPara || inList || inDlistHtml || inDlistPandoc) && (_chr0 ??= indented ? (_line = line.trimStart())[0] : chr0) &&
+                    (match = isAnyListItem(_chr0, _line, 'exec'))) {
+                    let [, marker, text, desc, dlist] = match;
+                    if (dlist !== undefined && (dlist = text)) { // marker and text are swapped for dlist item
+                        const isQanda = (blockAttrs && blockAttrs.get(1) === 'qanda') || (inList && inList.dlist === 'qanda');
+                        // Handle non-markdown definition list formats
+                        if (!isQanda && dlistFormat === 'html') {
+                            // Preserve ordered list context when entering dlist (push to stack instead of clearing)
+                            if (inList && !inList.dlist) {
+                                listStack.push(inList);
+                                inList = undefined;
+                            }
+                            // HTML format: <dl><dt>term</dt><dd>desc</dd></dl>
+                            const htmlIndent = indent || '';
+                            verbatim = verbatim?.close();
+                            inPara = true;
+                            if (!inDlistHtml) {
+                                accum.push(htmlIndent.trimEnd() || ''); // Blank line before <dl>
+                                accum.push(htmlIndent + '<dl>');
+                                inDlistHtml = true;
+                            }
+                            // Apply attribute substitution to term and description
+                            const htmlTerm = attributes.call(attrs, marker);
+                            const htmlDesc = desc ? attributes.call(attrs, desc) : '';
+                            // Output dt/dd - desc may be empty (description on next line)
+                            if (desc) {
+                                accum.push(htmlIndent + '<dt>' + htmlTerm + '</dt><dd>' + htmlDesc + '</dd>');
+                            }
+                            else {
+                                accum.push(htmlIndent + '<dt>' + htmlTerm + '</dt><dd>');
+                                hardbreakNext = 'dlist-html';
+                            }
+                            return accum;
+                        }
+                        else if (!isQanda && dlistFormat === 'pandoc') {
+                            // Preserve ordered list context when entering dlist (push to stack instead of clearing)
+                            if (inList && !inList.dlist) {
+                                listStack.push(inList);
+                                inList = undefined;
+                            }
+                            // Pandoc format: term\n:   description
+                            // All content in the definition must be indented with 4 spaces
+                            const pandocListIndent = indent || '';
+                            verbatim = verbatim?.close();
+                            inPara = true;
+                            inDlistPandoc = true;
+                            pandocDlistIndent = '    '; // 4 spaces for Pandoc definition content
+                            // Close HTML dlist if switching formats (shouldn't happen but be safe)
+                            if (inDlistHtml) {
+                                accum.push(pandocListIndent + '</dl>');
+                                accum.push(''); // Blank line after </dl>
+                                inDlistHtml = false;
+                            }
+                            // Apply attribute substitution to term and description
+                            const pandocTerm = attributes.call(attrs, marker);
+                            const pandocDesc = desc ? attributes.call(attrs, desc) : '';
+                            // Output term on its own line, description prefixed with :
+                            accum.push(pandocListIndent.trimEnd() || ''); // Blank line before term
+                            accum.push(pandocListIndent + pandocTerm);
+                            if (desc) {
+                                accum.push(pandocListIndent + ':   ' + pandocDesc);
+                                pandocDlistPendingColon = false;
+                            }
+                            else {
+                                // Description follows on next line - defer : prefix until first content
+                                pandocDlistPendingColon = true;
+                            }
+                            return accum;
+                        }
+                        else {
+                            // Markdown format (default) or qanda
+                            isQanda
+                                ? (text = '_' + marker + '_') && (marker = '.'.repeat(dlist.length - 1)) && (dlist = 'qanda')
+                                : (text = '*' + marker + '*') && (marker = dlist.length > 2 ? '-'.repeat(dlist.length - 1) : '-');
+                            if (!(next = desc))
+                                hardbreakNext = 'pending';
+                            // Close HTML dlist if we were in one (shouldn't happen but be safe)
+                            if (inDlistHtml) {
+                                accum.push((indent || '') + '</dl>');
+                                accum.push(''); // Blank line after </dl>
+                                inDlistHtml = false;
+                            }
+                        }
+                    }
+                    const ordered = (marker[0] === '<' && !!(marker = '<.>')) || marker[0] === '.' ||
+                        (marker[marker.length - 1] === '.' && !!(marker = '1.'));
+                    if (!inList || inList.marker !== marker) {
+                        if ((listStack.length && ~(match = listStack.findIndex((it) => it.marker === marker)))) {
+                            indent = (inList = (listStack = match ? listStack.slice(0, match + 1) : [listStack[0]]).pop()).indent;
+                        }
+                        else {
+                            indent = (inList ? (listStack[listStack.length] = inList) : inContainer).childIndent || '';
+                            const lindent = (attrs.lindent ??= parseInt(attrs.get('markdown-list-indent'), 10)) || (ordered ? 3 : 2);
+                            inList = { marker, indent, childIndent: indent + ' '.repeat(lindent), numeral: ordered && 0, dlist };
+                        }
+                    }
+                    else
+                        indent = inList.indent;
+                    // List items inside a dlist definition are legitimate content — don't reset dlist state.
+                    // Dlist state is properly reset by: blank line (when pendingColon is false),
+                    // heading detection, or new dlist term re-initializing state.
+                    verbatim = verbatim?.close();
+                    subs = (inPara = true) && NORMAL_SUBS;
+                    line = (ordered ? '1.  ' : '*   ') + text;
+                }
+                else if (inPara) {
+                    subs = NORMAL_SUBS;
+                    if (verbatim) {
+                        if (indented ? undef((subs = verbatim.subs)) : !(inPara = verbatim = verbatim.close()))
+                            continue; // redo
+                        line = line.substring(verbatim.outdent);
+                    }
+                    else if (hardbreakNext === 'dlist-html') {
+                        // HTML definition list - append description and close dd tag
+                        // Apply attribute substitution to the description
+                        accum[accum.length - 1] += attributes.call(attrs, line) + '</dd>';
+                        hardbreakNext = undefined;
+                        return accum;
+                    }
+                    else if (hardbreakNext || inPara === 'hardbreaks') {
+                        accum[accum.length - 1] += attrs.get('markdown-line-break');
+                    }
+                    else if ((grab = accum[accum.length - 1])?.[grab.length - 1] === '+' && grab[grab.length - 2] === ' ') {
+                        accum[accum.length - 1] = hardbreak(grab, attrs.get('markdown-line-break'), true);
+                    }
+                    else if (attrs.has('markdown-unwrap-prose')) {
+                        ;
+                        (inPara !== '> ' || ((line = line.trimEnd()) !== '>' && accum[accum.length - 1] !== '>' &&
+                            (line = line.substring(2)))) && (indent = accum.pop() + ' ');
+                    }
+                }
+                else if (chr0 === '.') {
+                    subs = NORMAL_SUBS;
+                    if (line !== chr0 && !(line[1] === '.' && line[2] === '.') && (match = line.length - 1)) {
+                        const text = line[1] === '*' && line[match] === '*' ? line.substring(2, match) : line.substring(1);
+                        blockTitle = (line = undefined) || { indent, text, subs };
+                    }
+                }
+                else if (indented) {
+                    if (blockAttrs && blockAttrs.get('subs')?.includes('attributes'))
+                        subs = ['attributes'];
+                    const outdent = line.length - (line = _line).length;
+                    if ((inPara = true) && _chr0 === '$' && _line[1] === ' ') {
+                        indent = (inList || inContainer).childIndent || '';
+                        verbatim = { cap: indent + '```', close: () => accum.push(verbatim.cap) && undefined, outdent, subs };
+                        line = '```console\n' + indent + line;
+                    }
+                    else {
+                        indent = ((inList || inContainer).childIndent || '') + '    ';
+                        verbatim = { close: undef, outdent, subs };
+                    }
+                }
+                else if (~(match = line.indexOf(': ')) && match < 10 && (style = line.substring(0, match)) in ADMONS) {
+                    next = (inPara = true) && line.substring(match + 2);
+                    line = '**' + ADMONS[style] + ' ' + style + '**';
+                }
+                else if (blockAttrs && (style = blockAttrs.get(1)) in ADMONS) {
+                    // Paragraph-style admonition: [NOTE] followed by paragraph text (no ==== delimiters)
+                    next = (inPara = true) && line;
+                    line = '**' + ADMONS[style] + ' ' + style + '**';
+                    blockAttrs = undefined;
+                }
+                else if (chr0 === 'i' && line.startsWith('image::') && (match = BlockImageMacroRx.exec(line))) {
+                    line = image.apply(attrs, match, (subs = ['attributes']));
+                }
+                else if (line in BREAKS) {
+                    line = BREAKS[line];
+                }
+                else {
+                    // Add blank line before starting new paragraph after list continuation (+)
+                    // Skip when pendingColon is true — first content after term needs :   prefix, not a blank line
+                    if (inPara === false && (inList || inDlistPandoc) && !pandocDlistPendingColon) {
+                        accum.push(indent.trimEnd());
+                    }
+                    inPara = blockAttrs?.has('hardbreaks-option') ? 'hardbreaks' : chr0 === '>' && line[1] === ' ' ? '> ' : true;
+                    if ((grab = blockAttrs?.get('id'))) {
+                        if (blockTitle) {
+                            blockTitle.id = grab;
+                        }
+                        else {
+                            const convertedId = attributes.call(attrs, grab);
+                            let anchorHtml = '<a name="' + convertedId + '"></a>';
+                            // Prepend pending Pandoc dlist colon to anchor
+                            if (pandocDlistPendingColon) {
+                                anchorHtml = ':   ' + anchorHtml;
+                                pandocDlistPendingColon = false;
+                            }
+                            accum.push(anchorHtml);
+                            accum.push('');
+                        }
+                        blockAttrs.delete('id');
+                    }
+                    subs = NORMAL_SUBS;
+                }
+            }
+            if (line) {
+                blockTitle &&= writeBlockTitle(accum, blockTitle, blockAttrs, attrs, refs, currentHeadingLevel);
+                if (subs && !(line = applySubs.call(attrs, line, subs)) && !accum.length)
+                    return accum;
+                // Apply Pandoc definition list indentation if active
+                const pdIndent = pandocDlistIndent + indent;
+                let finalLine;
+                // Prepend pending Pandoc dlist colon to first content
+                if (pandocDlistPendingColon) {
+                    finalLine = indent + ':   ' + line;
+                    pandocDlistPendingColon = false;
+                }
+                else {
+                    finalLine = pdIndent && line ? pdIndent + line : line;
+                }
+                accum[accum.length] = finalLine;
+                (next &&= applySubs.call(attrs, next)) && (accum[accum.length - 1] += attrs.get('markdown-line-break')) &&
+                    (accum[accum.length] = pdIndent ? pdIndent + next : next);
+            }
+            else if (line === undefined) {
+                return accum;
+            }
+            else
+                accum[accum.length] = pandocDlistIndent + (indent ? indent.trimEnd() : line);
+            hardbreakNext &&= hardbreakNext === 'pending' || undefined;
+            return accum;
+        }
+    }, [])
+        .concat(inDlistHtml ? [(indent || '') + '</dl>', ''] : []) // Close HTML definition list at end of document
+        .join('\n')
+        .trimEnd()
+        // Remove standalone AsciiDoc continuation markers (+) that weren't caught during processing
+        .replace(/\n\+[ \t]*\n/g, '\n\n')
+        // Remove __TOPLEVEL__ markers from Nunjucks includes (prevents indentation of top-level list includes)
+        .replace(/^(\s*)__TOPLEVEL__/gm, '')
+        .replace(RewriteInternalXrefRx, (_, text, id) => {
+        const { title = id, reftext = title, autoId = id } = refs.get(id) || nrefs.get(id) || {};
+        return '[' + (text || reftext) + '](#' + autoId + ')';
+    })
+        .concat(((grab = verbatim?.cap)) ? '\n' + grab : ''); // prettier-ignore
+}
+function applySubs(str, subs = NORMAL_SUBS) {
+    return /[{\x60\x27*_:<[#]/.test(str) ? subs.reduce((str, name) => SUBSTITUTORS[name].call(this, str), str) : str;
+}
+function attributes(str) {
+    // Convert AsciiDoc attribute references {attr} to Nunjucks variables {{ attr }}
+    // Escaped attributes \{attr} are kept as literal {attr}
+    // Hyphens in attribute names are converted to underscores for Jinja2 compatibility
+    return ~str.indexOf('{') ? str.replace(AttributeRefRx, (m, bs, n) => (bs ? m.substring(1) : '{{ ' + n.replace(/-/g, '_') + ' }}')) : str;
+}
+function callouts(str, apply = str[str.length - 1] === '>') {
+    return apply ? str.replace(ConumRx, (_, sp, chr) => sp + CONUMS[chr === '.' ? this.coseq++ : chr]) : str;
+}
+function hardbreak(str, mark, force, len = str.length) {
+    return force || (str[len - 1] === '+' && str[len - 2] === ' ') ? str.substring(0, str.length - 2) + mark : str;
+}
+function image(_, target, attrlist) {
+    const parts = attrlist.split(',');
+    const alt = parts[0].trim() || /(.*\/)?(.*?)($|\.)/.exec(target)[2];
+    const width = parts[1] ? parts[1].trim() : '';
+    const height = parts[2] ? parts[2].trim() : '';
+    const src = (this.get('imagesdir') ? this.get('imagesdir') + '/' : '') + target;
+    if (/^\d+$/.test(width) || /^\d+$/.test(height)) {
+        const wAttr = /^\d+$/.test(width) ? ' width="' + width + '"' : '';
+        const hAttr = /^\d+$/.test(height) ? ' height="' + height + '"' : '';
+        return '<img src="' + src + '" alt="' + alt + '"' + wAttr + hAttr + '>';
+    }
+    return '![' + alt + '](' + src + ')';
+}
+function isAnyListItem(chr0, str, mode = 'test', match = chr0 in LIST_MARKERS && ListItemRx[mode](str)) {
+    return match || (str.endsWith('::') || ~str.indexOf(':: ') ? DlistItemRx[mode](str) : undefined);
+}
+function isHeading(str, acceptAll, blockAttrs, marker, title, spaceIdx = str.indexOf(' ')) {
+    if (!(~spaceIdx && str.startsWith((marker = ['=', '==', '===', '====', '=====', '======'][spaceIdx - 1]))))
+        return;
+    if (!(title = str.substring(spaceIdx + 1)) || (title[0] === ' ' && !(title = title.trimStart())))
+        return;
+    if (acceptAll || (blockAttrs && blockAttrs.get(1) === 'discrete'))
+        return [marker, title];
+}
+function macros(str) {
+    if (!~str.indexOf(':'))
+        return ~str.indexOf('[[') ? str.replace(InlineAnchorRx, '<a name="$1"></a>') : str;
+    if (~str.indexOf('m:['))
+        str = str.replace(InlineStemMacroRx, (_, expr) => '$' + expr.replace(/\\]/g, ']') + '$');
+    if (~str.indexOf('image:'))
+        str = str.replace(InlineImageMacroRx, image.bind(this));
+    if (~str.indexOf(':/') || ~str.indexOf('link:')) {
+        str = str.replace(LinkMacroRx, (_, esc, scheme = '', url, boxed = '', text, bareScheme = scheme, bareUrl) => {
+            if (esc)
+                return bareScheme ? '<span>' + bareScheme + '</span>' + (bareUrl ?? url + boxed) : 'link:' + url + boxed;
+            if (!bareUrl)
+                return '[' + (text ||= this.has('hide-uri-scheme') ? url : scheme + url) + '](' + scheme + url + ')';
+            return this.has('hide-uri-scheme') ? '[' + bareUrl + '](' + bareScheme + bareUrl + ')' : bareScheme + bareUrl;
+        });
+    }
+    if (~str.indexOf('[['))
+        str = str.replace(InlineAnchorRx, '<a name="$1"></a>');
+    // UI macros - convert to markdown bold format
+    if (~str.indexOf('btn:[')) {
+        str = str.replace(/btn:\[([^\]]+)\]/g, '**[$1]**');
+    }
+    if (~str.indexOf('kbd:[')) {
+        str = str.replace(/kbd:\[([^\]]+)\]/g, '<kbd>$1</kbd>');
+    }
+    if (~str.indexOf('menu:')) {
+        str = str.replace(/menu:([^\[]+)\[([^\]]+)\]/g, (_, menu, path) => {
+            const parts = path.split(' > ').map(s => s.trim());
+            let result = menu;
+            parts.forEach((part) => {
+                result += ' → ' + part;
+            });
+            return '**' + result + '**';
+        });
+    }
+    if (!~str.indexOf('xref:'))
+        return str;
+    return str.replace(XrefMacroRx, (m, esc, p, ext, id_, id = id_, txt) => esc ? m.substring(1) : '[' + (p && (ext === '#' || (p += ext)) ? txt || p : (p = '#!' + id) && txt) + '](' + p + ')');
+}
+function parseAttrlist(attrlist, attrs = new Map()) {
+    if (!attrlist)
+        return attrs;
+    attrs.set(0, attrlist);
+    let chr0, idx, m, shorthand, style;
+    if ((chr0 = attrlist[0]) === '[' && (m = BlockAnchorRx.exec(attrlist))) {
+        return m[2] ? attrs.set('id', m[1]).set('reftext', m[2]) : attrs.set('id', m[1]);
+    }
+    if (!(idx = 0) && (~attrlist.indexOf('=') || ~attrlist.indexOf('"'))) {
+        while ((m = ElementAttributeRx.exec(attrlist))) {
+            attrs.set(m[1] ?? ++idx, m[4] ?? m[3]);
+            if (!m.index)
+                attrlist = (ElementAttributeRx.lastIndex = 1) && ',' + attrlist;
+        }
+    }
+    else if (chr0 === ',' || ~attrlist.indexOf(',')) {
+        for (const it of attrlist.split(','))
+            attrs.set(++idx, it.trimStart());
+    }
+    else
+        attrs.set(1, attrlist);
+    if (!(shorthand = attrs.get(1)) || (m = shorthand.split(StyleShorthandMarkersRx)).length < 2)
+        return attrs;
+    for (let i = 0, len = m.length, val; i < len; i += 2) {
+        if ((val = m[i]) && ((chr0 = m[i - 1]) || !(style = val))) {
+            chr0 === '#' ? attrs.set('id', val) : chr0 === '.' ? attrs.set('role', val) : attrs.set(val + '-option', '');
+        }
+    }
+    return attrs.set(1, style);
+}
+function quotes(str, idx) {
+    const hasLt = ~(~str.indexOf('<<') ? (str = str.replace(XrefShorthandRx, 'xref:$1[$2]')) : str).indexOf('<');
+    if (hasLt)
+        str = str.replace(/</g, '&lt;');
+    if (~(idx = str.indexOf('*')) && ~str.indexOf('*', idx + 1))
+        str = str.replace(StrongSpanRx, '*$1*');
+    if (~str.indexOf('`') && ((idx = ~str.indexOf('"`') || ~str.indexOf("'`")) || true)) {
+        if (idx)
+            str = str.replace(QuotedSpanRx, (this.q ??= this.get('quotes').split(' ').slice(0, 2).join('$2')));
+        if (hasLt || ~str.indexOf('`+') || ~str.indexOf(']`') || ~str.indexOf('\\')) {
+            str = str.replace(/(?:\[[^[\]]+\])?`(\+)?(\S|\S.*?\S)\1`/g, (_, pass, text) => {
+                if (hasLt && text.length > 3 && ~text.indexOf('&lt;'))
+                    text = text.replace(/&lt;/g, '<');
+                if (pass)
+                    return '`' + (~text.indexOf('{') ? text.replace(/\{(?=[a-z])/g, '\\{') : text) + '`';
+                return '`' + (~text.indexOf('\\') ? text.replace(/\\(?=https?:|\.\.\.)/g, '') : text) + '`';
+            });
+        }
+    }
+    if (~str.indexOf(']_'))
+        str = str.replace(EmphasisSpanMetaRx, '');
+    if (~(idx = str.indexOf('#')) && ~str.indexOf('#', idx + 1)) {
+        str = str.replace(MarkedSpanRx, (_, roles, s, text) => {
+            s &&= this.s ??= (s = this.get('markdown-strikethrough').split(' ')).length > 1 ? s.slice(0, 2) : [s[0], s[0]];
+            return roles ? (s ? s[0] + text + s[1] : text) : '<mark>' + text + '</mark>';
+        });
+    }
+    if (!~str.indexOf("'"))
+        return str;
+    return str.replace(/.'/g, (m, i, s, l = m[0], r = s[i + 2] || '') => l === '`' ? (r === '`' ? m : '\u2019') : /\p{L}/u.test(r) && /[\p{L}\d]/u.test(l) ? l + '\u2019' : m);
+}
+function writeBlockTitle(buffer, blockTitle, blockAttrs, attrs, refs, headingLevel = 2) {
+    const { id = blockAttrs?.get('id'), indent, text, subs, title = applySubs.call(attrs, text, subs) } = blockTitle;
+    // Convert section titles to headings one level deeper than current context
+    const level = Math.min(6, (headingLevel || 1) + 1); // Default to H2, max H6
+    const heading = '#'.repeat(level) + ' ' + title;
+    // Convert attribute references in ID to Jinja2 format (e.g., {context} → {{ context }})
+    const convertedId = id ? attributes.call(attrs, id) : null;
+    const idSuffix = convertedId ? ` {id="${convertedId}"}` : '';
+    if (id)
+        refs.set(id, { title, reftext: blockAttrs?.get('reftext') });
+    buffer.push(indent + heading + idSuffix, '');
+}
+//# sourceMappingURL=engine.js.map