@readme/markdown 13.8.4 → 13.8.5

package/dist/main.node.js

@@ -19232,7 +19232,8 @@ const Callout = (props) => {
     const children = external_react_.Children.toArray(props.children);
     const icon = props.icon;
     const isEmoji = icon && emoji_regex().test(icon);
-    const heading = empty ? external_react_.createElement("p", { className: 'callout-heading empty' }) : children[0];
+    const hasBody = children.length > 1;
+    const heading = empty ? (hasBody ? external_react_.createElement("p", { className: 'callout-heading empty' }) : null) : children[0];
     const theme = props.theme || (icon && themes[icon]) || 'default';
     return (
     // @ts-expect-error -- theme is not a valid attribute
@@ -24714,8 +24715,9 @@ function useScrollHighlight(navRef) {
         const nav = navRef.current;
         if (!nav)
             return;
-        const key = Array.from(nav.querySelectorAll('a[href^="#"]'))
-            .map(a => a.getAttribute('href'))
+        const key = Array.from(nav.querySelectorAll('a'))
+            .map(a => a.hash)
+            .filter(Boolean)
             .join('\0');
         setTocKey(key);
     });
@@ -24737,9 +24739,11 @@ function useScrollHighlight(navRef) {
         const scrollParent = TableOfContents_getScrollParent(headings[0]);
         const isAtBottom = () => {
             if (scrollParent instanceof Window) {
-                return window.innerHeight + window.scrollY >= document.documentElement.scrollHeight - SCROLL_BOTTOM_TOLERANCE;
+                return document.documentElement.scrollHeight > window.innerHeight
+                    && window.innerHeight + window.scrollY >= document.documentElement.scrollHeight - SCROLL_BOTTOM_TOLERANCE;
             }
-            return scrollParent.scrollTop + scrollParent.clientHeight >= scrollParent.scrollHeight - SCROLL_BOTTOM_TOLERANCE;
+            return scrollParent.scrollHeight > scrollParent.clientHeight
+                && scrollParent.scrollTop + scrollParent.clientHeight >= scrollParent.scrollHeight - SCROLL_BOTTOM_TOLERANCE;
         };
         const activate = (id) => {
             if (id === activeId)
@@ -24789,15 +24793,12 @@ function useScrollHighlight(navRef) {
         const onClick = (e) => {
             if (!(e.target instanceof Element))
                 return;
-            const anchor = e.target.closest('a[href^="#"]');
-            if (!(anchor instanceof HTMLAnchorElement))
+            const anchor = e.target.closest('a');
+            if (!(anchor instanceof HTMLAnchorElement) || !anchor.hash)
                 return;
             const id = decodeURIComponent(anchor.hash.slice(1));
             if (!linkMap.has(id))
                 return;
-            if (window.location.hash !== anchor.hash) {
-                window.location.hash = anchor.hash;
-            }
             activate(id);
             clickLocked = true;
             let unlockTimer = null;
@@ -73340,267 +73341,1078 @@ const plain = (node, opts = {}) => {
 };
 /* harmony default export */ const lib_plain = (plain);
 
-;// ./processor/compile/gemoji.ts
-const gemoji = (node) => `:${node.name}:`;
-/* harmony default export */ const compile_gemoji = (gemoji);
+;// ./lib/mdast.ts
 
-;// ./processor/compile/variable.ts
-const variable = (node) => `{user.${node.data?.hProperties?.name || ''}}`;
-/* harmony default export */ const compile_variable = (variable);
+const mdast = (text, opts = {}) => {
+    const processor = ast_processor(opts);
+    const tree = processor.parse(text);
+    return processor.runSync(tree);
+};
+/* harmony default export */ const lib_mdast = (mdast);
 
-;// ./processor/transform/extract-text.ts
+;// ./lib/utils/mdxish/protect-code-blocks.ts
 /**
- * Extracts text content from a single AST node recursively.
- * Works with both MDAST and HAST-like node structures.
- *
- * Placed this outside of the utils.ts file to avoid circular dependencies.
+ * Replaces code blocks and inline code with placeholders to protect them from preprocessing.
  *
- * @param node - The node to extract text from (can be MDAST Node or HAST-like structure)
- * @returns The concatenated text content
+ * @param content - The markdown content to process
+ * @returns Object containing protected content and arrays of original code blocks
+ * @example
+ * ```typescript
+ * const input = 'Text with `inline code` and ```fenced block```';
+ * protectCodeBlocks(input)
+ * // Returns: {
+ * //   protectedCode: {
+ * //     codeBlocks: ['```fenced block```'],
+ * //     inlineCode: ['`inline code`']
+ * //   },
+ * //   protectedContent: 'Text with ___INLINE_CODE_0___ and ___CODE_BLOCK_0___'
+ * // }
+ * ```
  */
-const extractText = (node) => {
-    if ((node.type === 'text' || node.type === 'html') && typeof node.value === 'string') {
-        return node.value;
-    }
-    // When a blockquote contains only an image (no text), treat it as having content
-    // so the blockquote is no longer treated as empty and preserved correctly.
-    if (node.type === 'image') {
-        return typeof node.alt === 'string' && node.alt ? node.alt : '[image]';
-    }
-    if (node.children && Array.isArray(node.children)) {
-        return node.children
-            .map(child => {
-            if (child && typeof child === 'object' && 'type' in child) {
-                return extractText(child);
-            }
-            return '';
-        })
-            .join('');
+function protectCodeBlocks(content) {
+    const codeBlocks = [];
+    const inlineCode = [];
+    let protectedContent = '';
+    let remaining = content;
+    let codeBlockStart = remaining.indexOf('```');
+    while (codeBlockStart !== -1) {
+        protectedContent += remaining.slice(0, codeBlockStart);
+        remaining = remaining.slice(codeBlockStart);
+        const codeBlockEnd = remaining.indexOf('```', 3);
+        if (codeBlockEnd === -1) {
+            break;
+        }
+        const match = remaining.slice(0, codeBlockEnd + 3);
+        const index = codeBlocks.length;
+        codeBlocks.push(match);
+        protectedContent += `___CODE_BLOCK_${index}___`;
+        remaining = remaining.slice(codeBlockEnd + 3);
+        codeBlockStart = remaining.indexOf('```');
     }
-    return '';
-};
-
-;// ./processor/transform/callouts.ts
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const titleParser = unified().use(remarkParse).use(remarkGfm);
-// The title paragraph may contain custom AST nodes that `toMarkdown` doesn't
-// natively understand
-const toMarkdownExtensions = [
-    gfmToMarkdown(),
-    // For mdx variable syntaxes (e.g., {user.name})
-    mdxExpressionToMarkdown(),
-    // Important: This is required and would crash the parser if there's no variable and gemoji node handler
-    { handlers: { [NodeTypes.variable]: compile_variable, [NodeTypes.emoji]: compile_gemoji } },
-];
-const callouts_regex = `^(${emoji_regex().source}|⚠)(\\s+|$)`;
-const findFirst = (node) => {
-    if ('children' in node)
-        return findFirst(node.children[0]);
-    if (node.type === 'text')
-        return node;
-    return null;
-};
-const wrapHeading = (node) => {
-    const firstChild = node.children[0];
-    return {
-        type: 'heading',
-        depth: 3,
-        children: ('children' in firstChild ? firstChild.children : []),
-        position: {
-            start: firstChild.position.start,
-            end: firstChild.position.end,
-        },
-    };
-};
+    protectedContent += remaining;
+    protectedContent = protectedContent.replace(/`([^`\n]+)`/g, match => {
+        const index = inlineCode.length;
+        inlineCode.push(match);
+        return `___INLINE_CODE_${index}___`;
+    });
+    return { protectedCode: { codeBlocks, inlineCode }, protectedContent };
+}
 /**
- * Checks if a blockquote matches the expected callout structure:
- * blockquote > paragraph > text node
+ * Restores inline code by replacing placeholders with original content.
+ *
+ * @param content - Content with inline code placeholders
+ * @param protectedCode - The protected code arrays
+ * @returns Content with inline code restored
  */
-const isCalloutStructure = (node) => {
-    const firstChild = node.children?.[0];
-    if (!firstChild || firstChild.type !== 'paragraph')
-        return false;
-    if (!('children' in firstChild))
-        return false;
-    const firstTextChild = firstChild.children?.[0];
-    return firstTextChild?.type === 'text';
-};
+function restoreInlineCode(content, protectedCode) {
+    return content.replace(/___INLINE_CODE_(\d+)___/g, (_m, idx) => {
+        return protectedCode.inlineCode[parseInt(idx, 10)];
+    });
+}
 /**
- * Finds the first text node containing a newline in a paragraph's children.
- * Returns the index and the newline position within that text node.
+ * Restores fenced code blocks by replacing placeholders with original content.
+ *
+ * @param content - Content with code block placeholders
+ * @param protectedCode - The protected code arrays
+ * @returns Content with code blocks restored
  */
-const findNewlineInParagraph = (paragraph) => {
-    for (let i = 0; i < paragraph.children.length; i += 1) {
-        const child = paragraph.children[i];
-        if (child.type === 'text' && typeof child.value === 'string') {
-            const newlineIndex = child.value.indexOf('\n');
-            if (newlineIndex !== -1) {
-                return { index: i, newlineIndex };
-            }
-        }
-    }
-    return null;
-};
+function restoreFencedCodeBlocks(content, protectedCode) {
+    return content.replace(/___CODE_BLOCK_(\d+)___/g, (_m, idx) => {
+        return protectedCode.codeBlocks[parseInt(idx, 10)];
+    });
+}
 /**
- * Splits a paragraph at the first newline, separating heading content (before \n)
- * from body content (after \n). Mutates the paragraph to contain only heading children.
+ * Restores all code blocks and inline code by replacing placeholders with original content.
+ *
+ * @param content - Content with code placeholders
+ * @param protectedCode - The protected code arrays
+ * @returns Content with all code blocks and inline code restored
+ * @example
+ * ```typescript
+ * const content = 'Text with ___INLINE_CODE_0___ and ___CODE_BLOCK_0___';
+ * const protectedCode = {
+ *   codeBlocks: ['```js\ncode\n```'],
+ *   inlineCode: ['`inline`']
+ * };
+ * restoreCodeBlocks(content, protectedCode)
+ * // Returns: 'Text with `inline` and ```js\ncode\n```'
+ * ```
  */
-const splitParagraphAtNewline = (paragraph) => {
-    const splitPoint = findNewlineInParagraph(paragraph);
-    if (!splitPoint)
-        return null;
-    const { index, newlineIndex } = splitPoint;
-    const originalChildren = paragraph.children;
-    const textNode = originalChildren[index];
-    const beforeNewline = textNode.value.slice(0, newlineIndex);
-    const afterNewline = textNode.value.slice(newlineIndex + 1);
-    // Split paragraph: heading = children[0..index-1] + text before newline
-    const headingChildren = originalChildren.slice(0, index);
-    if (beforeNewline.length > 0 || headingChildren.length === 0) {
-        headingChildren.push({ type: 'text', value: beforeNewline });
+function restoreCodeBlocks(content, protectedCode) {
+    let restored = restoreFencedCodeBlocks(content, protectedCode);
+    restored = restoreInlineCode(restored, protectedCode);
+    return restored;
+}
+
+;// ./processor/transform/mdxish/preprocess-jsx-expressions.ts
+
+// Base64 encode (Node.js + browser compatible)
+function base64Encode(str) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(str, 'utf-8').toString('base64');
     }
-    paragraph.children = headingChildren;
-    // Body = text after newline + remaining children from original array
-    const bodyChildren = [];
-    if (afterNewline.length > 0) {
-        bodyChildren.push({ type: 'text', value: afterNewline });
+    return btoa(unescape(encodeURIComponent(str)));
+}
+// Base64 decode (Node.js + browser compatible)
+function base64Decode(str) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(str, 'base64').toString('utf-8');
     }
-    bodyChildren.push(...originalChildren.slice(index + 1));
-    return bodyChildren.length > 0 ? bodyChildren : null;
-};
+    return decodeURIComponent(escape(atob(str)));
+}
+function escapeHtmlAttribute(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/\n/g, '&#10;');
+}
+// Marker prefix for JSON-serialized complex values (arrays/objects)
+// Using a prefix that won't conflict with regular string values
+const JSON_VALUE_MARKER = '__MDXISH_JSON__';
+// Markers for protected HTMLBlock content (HTML comments avoid markdown parsing issues)
+const HTML_BLOCK_CONTENT_START = '<!--RDMX_HTMLBLOCK:';
+const HTML_BLOCK_CONTENT_END = ':RDMX_HTMLBLOCK-->';
 /**
- * Removes the icon/match prefix from the first text node in a paragraph.
- * This is needed to clean up the raw AST after we've extracted the icon.
+ * Evaluates a JavaScript expression using context variables.
+ *
+ * @param expression
+ * @param context
+ * @returns The evaluated result
+ * @example
+ * ```typescript
+ * const context = { baseUrl: 'https://example.com', path: '/api' };
+ * evaluateExpression('baseUrl + path', context)
+ * // Returns: 'https://example.com/api'
+ * ```
  */
-const removeIconPrefix = (paragraph, prefixLength) => {
-    const firstTextNode = findFirst(paragraph);
-    if (firstTextNode && 'value' in firstTextNode && typeof firstTextNode.value === 'string') {
-        firstTextNode.value = firstTextNode.value.slice(prefixLength);
-    }
-};
-const processBlockquote = (node, index, parent, isMdxish = false) => {
-    if (!isCalloutStructure(node)) {
-        // Only stringify empty blockquotes (no extractable text content)
-        // Preserve blockquotes with actual content (e.g., headings, lists, etc.)
-        const content = extractText(node);
-        const isEmpty = !content || content.trim() === '';
-        if (isEmpty && index !== undefined && parent) {
-            const textNode = {
-                type: 'text',
-                value: '>',
-            };
-            const paragraphNode = {
-                type: 'paragraph',
-                children: [textNode],
-                position: node.position,
-            };
-            parent.children.splice(index, 1, paragraphNode);
-        }
-        return;
+function evaluateExpression(expression, context) {
+    const contextKeys = Object.keys(context);
+    const contextValues = Object.values(context);
+    // eslint-disable-next-line no-new-func
+    const func = new Function(...contextKeys, `return ${expression}`);
+    return func(...contextValues);
+}
+/**
+ * Base64 encodes HTMLBlock template literal content to prevent markdown parser from consuming <script>/<style> tags.
+ *
+ * @param content
+ * @returns Content with HTMLBlock template literals base64 encoded in HTML comments
+ * @example
+ * ```typescript
+ * const input = '<HTMLBlock>{`<script>alert("xss")</script>`}</HTMLBlock>';
+ * protectHTMLBlockContent(input)
+ * // Returns: '<HTMLBlock><!--RDMX_HTMLBLOCK:PHNjcmlwdD5hbGVydCgieHNzIik8L3NjcmlwdD4=:RDMX_HTMLBLOCK--></HTMLBlock>'
+ * ```
+ */
+function protectHTMLBlockContent(content) {
+    return content.replace(/(<HTMLBlock[^>]*>)\{\s*`((?:[^`\\]|\\.)*)`\s*\}(<\/HTMLBlock>)/g, (_match, openTag, templateContent, closeTag) => {
+        const encoded = base64Encode(templateContent);
+        return `${openTag}${HTML_BLOCK_CONTENT_START}${encoded}${HTML_BLOCK_CONTENT_END}${closeTag}`;
+    });
+}
+/**
+ * Removes JSX-style comments (e.g., { /* comment *\/ }) from content.
+ *
+ * @param content
+ * @returns Content with JSX comments removed
+ * @example
+ * ```typescript
+ * removeJSXComments('Text { /* comment *\/ } more text')
+ * // Returns: 'Text  more text'
+ * ```
+ */
+function removeJSXComments(content) {
+    return content.replace(/\{\s*\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\/\s*\}/g, '');
+}
+/**
+ * Extracts content between balanced braces, handling nested braces.
+ *
+ * @param content
+ * @param start
+ * @returns Object with extracted content and end position, or null if braces are unbalanced
+ * @example
+ * ```typescript
+ * const input = 'foo{bar{baz}qux}end';
+ * extractBalancedBraces(input, 3) // start at position 3 (after '{')
+ * // Returns: { content: 'bar{baz}qux', end: 16 }
+ * ```
+ */
+function extractBalancedBraces(content, start) {
+    let depth = 1;
+    let pos = start;
+    while (pos < content.length && depth > 0) {
+        const char = content[pos];
+        if (char === '{')
+            depth += 1;
+        else if (char === '}')
+            depth -= 1;
+        pos += 1;
     }
-    // isCalloutStructure ensures node.children[0] is a Paragraph with children
-    const firstParagraph = node.children[0];
-    const startText = lib_plain(firstParagraph).toString();
-    const [match, icon] = startText.match(callouts_regex) || [];
-    const firstParagraphOriginalEnd = firstParagraph.position.end;
-    if (icon && match) {
-        // Handle cases where heading and body are on the same line separated by a newline.
-        // Example: "> ⚠️ **Bold heading**\nBody text here"
-        const bodyChildren = splitParagraphAtNewline(firstParagraph);
-        const didSplit = bodyChildren !== null;
-        removeIconPrefix(firstParagraph, match.length);
-        const firstText = findFirst(firstParagraph);
-        const rawValue = firstText?.value ?? '';
-        const hasContent = rawValue.trim().length > 0 || firstParagraph.children.length > 1;
-        const empty = !hasContent;
-        const theme = themes[icon] || 'default';
-        if (hasContent || didSplit) {
-            const headingMatch = rawValue.match(/^(#{1,6})\s*/);
-            // # heading syntax is handled via direct AST manipulation so we can
-            // set the depth while preserving the original inline children (bold, etc.)
-            if (headingMatch) {
-                firstText.value = rawValue.slice(headingMatch[0].length);
-                const heading = wrapHeading(node);
-                heading.depth = headingMatch[1].length;
-                node.children[0] = heading;
-                node.children[0].position.start.offset += match.length;
-                node.children[0].position.start.column += match.length;
+    if (depth !== 0)
+        return null;
+    return { content: content.slice(start, pos - 1), end: pos };
+}
+/**
+ * Escapes problematic braces in content to prevent MDX expression parsing errors.
+ * Handles three cases:
+ * 1. Unbalanced braces (e.g., `{foo` without closing `}`)
+ * 2. Paragraph-spanning expressions (e.g., `{\n\n}` where blank line splits paragraphs)
+ * 3. Skips HTML elements to prevent backslashes appearing in output
+ *
+ */
+function escapeProblematicBraces(content) {
+    // Skip HTML elements — their content should never be escaped because
+    // rehypeRaw parses them into hast elements, making `\` literal text in output
+    const htmlElements = [];
+    const safe = content.replace(/<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, match => {
+        const idx = htmlElements.length;
+        htmlElements.push(match);
+        return `___HTML_ELEM_${idx}___`;
+    });
+    const toEscape = new Set();
+    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
+    const chars = Array.from(safe);
+    let strDelim = null;
+    let strEscaped = false;
+    // Stack of open braces with their state
+    const openStack = [];
+    // Track position of last newline (outside strings) to detect blank lines
+    let lastNewlinePos = -2; // -2 means no recent newline
+    for (let i = 0; i < chars.length; i += 1) {
+        const ch = chars[i];
+        // Track string delimiters inside expressions to ignore braces within them
+        if (openStack.length > 0) {
+            if (strDelim) {
+                if (strEscaped)
+                    strEscaped = false;
+                else if (ch === '\\')
+                    strEscaped = true;
+                else if (ch === strDelim)
+                    strDelim = null;
+                // eslint-disable-next-line no-continue
+                continue;
             }
-            else if (isMdxish) {
-                // Block-level title re-parsing is only needed for MDXish where HTML stays
-                // as raw nodes. In MDX, remarkMdx has already converted HTML to JSX AST
-                // nodes which toMarkdown can't serialize — and MDX doesn't need this
-                // block-level title handling anyway.
-                const headingText = toMarkdown({ type: 'root', children: [firstParagraph] }, {
-                    extensions: toMarkdownExtensions,
-                })
-                    .trim()
-                    .replace(/^\\(?=[>#+\-*])/, '');
-                const parsedTitle = titleParser.parse(headingText);
-                const parsedFirstChild = parsedTitle.children[0];
-                // Block-level syntax ("> quote", "- list") produces non-paragraph nodes;
-                // inline text parses as a paragraph and falls through to wrapHeading().
-                if (parsedFirstChild && parsedFirstChild.type !== 'paragraph') {
-                    // Strip positions from re-parsed nodes since they're relative to the heading text, not the original source
-                    visit(parsedTitle, (n) => {
-                        delete n.position;
-                    });
-                    const heading = wrapHeading(node);
-                    heading.children = parsedTitle.children;
-                    delete heading.position;
-                    node.children[0] = heading;
+            if (ch === '"' || ch === "'" || ch === '`') {
+                strDelim = ch;
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // Track newlines to detect blank lines (paragraph boundaries)
+            if (ch === '\n') {
+                // Check if this newline creates a blank line (only whitespace since last newline)
+                if (lastNewlinePos >= 0) {
+                    const between = chars.slice(lastNewlinePos + 1, i).join('');
+                    if (/^[ \t]*$/.test(between)) {
+                        // This is a blank line - mark all open expressions as paragraph-spanning
+                        openStack.forEach(entry => {
+                            entry.hasBlankLine = true;
+                        });
+                    }
                 }
-                else {
-                    node.children[0] = wrapHeading(node);
-                    node.children[0].position.start.offset += match.length;
-                    node.children[0].position.start.column += match.length;
+                lastNewlinePos = i;
+            }
+        }
+        // Skip already-escaped braces (count preceding backslashes)
+        if (ch === '{' || ch === '}') {
+            let bs = 0;
+            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
+                bs += 1;
+            if (bs % 2 === 1) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+        }
+        if (ch === '{') {
+            openStack.push({ pos: i, hasBlankLine: false });
+            lastNewlinePos = -2; // Reset newline tracking for new expression
+        }
+        else if (ch === '}') {
+            if (openStack.length > 0) {
+                const entry = openStack.pop();
+                // If expression spans paragraph boundary, escape both braces
+                if (entry.hasBlankLine) {
+                    toEscape.add(entry.pos);
+                    toEscape.add(i);
                 }
             }
             else {
-                node.children[0] = wrapHeading(node);
-                node.children[0].position.start.offset += match.length;
-                node.children[0].position.start.column += match.length;
+                // Unbalanced closing brace (no matching open)
+                toEscape.add(i);
             }
         }
-        // Insert body content as a separate paragraph after the heading
-        if (bodyChildren) {
-            const headingPosition = node.children[0].position;
-            node.children.splice(1, 0, {
-                type: 'paragraph',
-                children: bodyChildren,
-                ...(headingPosition && firstParagraphOriginalEnd
-                    ? {
-                        position: {
-                            start: headingPosition.end,
-                            end: firstParagraphOriginalEnd,
-                        },
-                    }
-                    : {}),
-            });
-        }
-        Object.assign(node, {
-            type: NodeTypes.callout,
-            data: {
-                hName: 'Callout',
-                hProperties: {
-                    icon,
-                    ...(empty && { empty }),
-                    theme,
-                },
-            },
+    }
+    // Any remaining open braces are unbalanced
+    openStack.forEach(entry => toEscape.add(entry.pos));
+    // If there are no problematic braces, return safe content as-is;
+    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
+    let result = toEscape.size === 0
+        ? safe
+        : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
+    // Restore HTML elements
+    if (htmlElements.length > 0) {
+        result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
+    }
+    return result;
+}
+/**
+ * Converts JSX attribute expressions (attribute={expression}) to HTML attributes (attribute="value").
+ * Handles style objects (camelCase → kebab-case), className → class, and JSON stringifies objects.
+ *
+ * @param content
+ * @param context
+ * @returns Content with attribute expressions evaluated and converted to HTML attributes
+ * @example
+ * ```typescript
+ * const context = { baseUrl: 'https://example.com' };
+ * const input = '<a href={baseUrl}>Link</a>';
+ * evaluateAttributeExpressions(input, context)
+ * // Returns: '<a href="https://example.com">Link</a>'
+ * ```
+ */
+function evaluateAttributeExpressions(content, context, protectedCode) {
+    const attrStartRegex = /(\w+)=\{/g;
+    let result = '';
+    let lastEnd = 0;
+    let match = attrStartRegex.exec(content);
+    while (match !== null) {
+        const attributeName = match[1];
+        const braceStart = match.index + match[0].length;
+        const extracted = extractBalancedBraces(content, braceStart);
+        if (extracted) {
+            // The expression might contain template literals in MDX component tag props
+            // E.g. <Component greeting={`Hello World!`} />
+            // that is marked as inline code. So we need to restore the inline codes
+            // in the expression to evaluate it
+            let expression = extracted.content;
+            if (protectedCode) {
+                expression = restoreInlineCode(expression, protectedCode);
+            }
+            const fullMatchEnd = extracted.end;
+            result += content.slice(lastEnd, match.index);
+            try {
+                const evalResult = evaluateExpression(expression, context);
+                if (typeof evalResult === 'object' && evalResult !== null) {
+                    if (attributeName === 'style') {
+                        const cssString = Object.entries(evalResult)
+                            .map(([key, value]) => {
+                            const cssKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
+                            return `${cssKey}: ${value}`;
+                        })
+                            .join('; ');
+                        result += `style="${cssString}"`;
+                    }
+                    else {
+                        // These are arrays / objects attribute values
+                        // Mark JSON-serialized values with a prefix so they can be parsed back correctly
+                        const jsonValue = escapeHtmlAttribute(JSON_VALUE_MARKER + JSON.stringify(evalResult));
+                        // Use double quotes so that multi-paragraph values are not split into multiple attributes by the processors
+                        result += `${attributeName}="${jsonValue}"`;
+                    }
+                }
+                else if (attributeName === 'className') {
+                    // Escape special characters so that it doesn't break and split the attribute value to nodes
+                    // This will be restored later in the pipeline
+                    result += `class="${escapeHtmlAttribute(String(evalResult))}"`;
+                }
+                else {
+                    result += `${attributeName}="${escapeHtmlAttribute(String(evalResult))}"`;
+                }
+            }
+            catch (_error) {
+                result += content.slice(match.index, fullMatchEnd);
+            }
+            lastEnd = fullMatchEnd;
+            attrStartRegex.lastIndex = fullMatchEnd;
+        }
+        match = attrStartRegex.exec(content);
+    }
+    result += content.slice(lastEnd);
+    return result;
+}
+/**
+ * Preprocesses JSX-like expressions in markdown before parsing.
+ * Inline expressions are handled separately; attribute expressions are processed here.
+ *
+ * @param content
+ * @param context
+ * @returns Preprocessed content ready for markdown parsing
+ */
+function preprocessJSXExpressions(content, context = {}) {
+    // Step 0: Base64 encode HTMLBlock content
+    let processed = protectHTMLBlockContent(content);
+    // Step 1: Protect code blocks and inline code
+    const { protectedCode, protectedContent } = protectCodeBlocks(processed);
+    // Step 2: Evaluate attribute expressions (JSX attribute syntax: href={baseUrl})
+    // For inline expressions, we use a library to parse the expression & evaluate it later
+    // For attribute expressions, it was difficult to use a library to parse them, so do it manually
+    processed = evaluateAttributeExpressions(protectedContent, context, protectedCode);
+    // Step 3: Escape problematic braces to prevent MDX expression parsing errors
+    // This handles both unbalanced braces and paragraph-spanning expressions in one pass
+    processed = escapeProblematicBraces(processed);
+    // Step 4: Restore protected code blocks
+    processed = restoreCodeBlocks(processed, protectedCode);
+    return processed;
+}
+
+;// ./processor/utils.ts
+
+
+
+/**
+ * Formats the hProperties of a node as a string, so they can be compiled back into JSX/MDX.
+ * This currently sets all the values to a string since we process/compile the MDX on the fly
+ * through the editor, and it'll throw errors over malformed JSX. TODO: fix this.
+ *
+ * @template T
+ * @param {Node} node
+ * @returns {string} formatted hProperties as JSX attributes
+ */
+const formatHProps = (node) => {
+    const hProps = getHProps(node);
+    return formatProps(hProps);
+};
+/**
+ * Formats an object of props as a string.
+ *
+ * @param {Object} props
+ * @returns {string}
+ */
+const formatProps = (props) => {
+    const keys = Object.keys(props);
+    return keys.map(key => `${key}="${props[key]}"`).join(' ');
+};
+/**
+ * Returns the hProperties of a node.
+ *
+ * @template T
+ * @param {Node} node
+ * @returns {T} hProperties
+ */
+const getHProps = (node) => {
+    const hProps = node.data?.hProperties || {};
+    return hProps;
+};
+/**
+ * Returns array of hProperty keys.
+ *
+ * @template T
+ * @param {Node} node
+ * @returns {Array} array of hProperty keys
+ */
+const getHPropKeys = (node) => {
+    const hProps = getHProps(node);
+    return Object.keys(hProps) || [];
+};
+/**
+ * Gets the attributes of an MDX element and returns them as an object of hProperties.
+ *
+ * @template T
+ * @param {(MdxJsxFlowElement | MdxJsxTextElement)} jsx
+ * @returns {T} object of hProperties
+ */
+const getAttrs = (jsx) => jsx.attributes.reduce((memo, attr) => {
+    if ('name' in attr) {
+        if (typeof attr.value === 'string') {
+            if (attr.value.startsWith(JSON_VALUE_MARKER)) {
+                try {
+                    memo[attr.name] = JSON.parse(attr.value.slice(JSON_VALUE_MARKER.length));
+                }
+                catch {
+                    memo[attr.name] = attr.value;
+                }
+            }
+            else {
+                memo[attr.name] = attr.value;
+            }
+        }
+        else if (attr.value === null) {
+            memo[attr.name] = true;
+        }
+        else if (attr.value.value !== 'undefined') {
+            memo[attr.name] = JSON.parse(attr.value.value);
+        }
+    }
+    return memo;
+}, {});
+/**
+ * Gets the children of an MDX element and returns them as an array of Text nodes.
+ * Currently only being used by the HTML Block component, which only expects a single text node.
+ *
+ * @template T
+ * @param {(MdxJsxFlowElement | MdxJsxTextElement)} jsx
+ * @returns {Array} array of child text nodes
+ */
+const utils_getChildren = (jsx) => jsx.children.reduce((memo, child, i) => {
+    memo[i] = {
+        type: 'text',
+        value: child.value,
+        position: child.position,
+    };
+    return memo;
+}, []);
+/**
+ * Tests if a node is an MDX element.
+ * TODO: Make this more extensible to all types of nodes. isElement(node, 'type' or ['type1', 'type2']), say
+ *
+ * @param {Node} node
+ * @returns {(node is MdxJsxFlowElement | MdxJsxTextElement | MdxjsEsm)}
+ */
+const isMDXElement = (node) => {
+    return ['mdxJsxFlowElement', 'mdxJsxTextElement'].includes(node.type);
+};
+/**
+ * Tests if a node is an MDX ESM element (i.e. import or export).
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+const isMDXEsm = (node) => {
+    return node.type === 'mdxjsEsm';
+};
+/**
+ * Takes an HTML string and formats it for display in the editor. Removes leading/trailing newlines
+ * and unindents the HTML.
+ *
+ * @param {string} html - HTML content from template literal
+ * @returns {string} processed HTML
+ */
+function formatHtmlForMdxish(html) {
+    // Remove leading/trailing backticks if present, since they're used to keep the HTML
+    // from being parsed prematurely
+    let processed = html;
+    if (processed.startsWith('`') && processed.endsWith('`')) {
+        processed = processed.slice(1, -1);
+    }
+    // Removes the leading/trailing newlines
+    let cleaned = processed.replace(/^\s*\n|\n\s*$/g, '');
+    // Convert literal \n sequences to actual newlines BEFORE processing backticks
+    // This prevents the backtick unescaping regex from incorrectly matching \n sequences
+    cleaned = cleaned.replace(/\\n/g, '\n');
+    // Unescape backticks: \` -> ` (users escape backticks in template literals)
+    // Handle both cases: \` (adjacent) and \ followed by ` (split by markdown parser)
+    cleaned = cleaned.replace(/\\`/g, '`');
+    // Also handle case where backslash and backtick got separated by markdown parsing
+    // Pattern: backslash followed by any characters (but not \n which we already handled), then a backtick
+    // This handles cases like: \example` -> `example` (replacing \ with ` at start)
+    // Exclude \n sequences to avoid matching them incorrectly
+    cleaned = cleaned.replace(/\\([^`\\n]*?)`/g, '`$1`');
+    // Fix case where markdown parser consumed one backtick from triple backticks
+    // Pattern: `` followed by a word (like ``javascript) should be ```javascript
+    // This handles cases where code fences were parsed and one backtick was lost
+    cleaned = cleaned.replace(/<(\w+[^>]*)>``(\w+)/g, '<$1>```$2');
+    // Unescape dollar signs: \$ -> $ (users escape $ in template literals to prevent interpolation)
+    cleaned = cleaned.replace(/\\\$/g, '$');
+    return cleaned;
+}
+/**
+ * Takes an HTML string and formats it for display in the editor. Removes leading/trailing newlines
+ * and unindents the HTML.
+ *
+ * @param {string} html
+ * @returns {string} formatted HTML
+ */
+const formatHTML = (html) => {
+    // Remove leading/trailing backticks if present, since they're used to keep the HTML
+    // from being parsed prematurely
+    if (html.startsWith('`') && html.endsWith('`')) {
+        // eslint-disable-next-line no-param-reassign
+        html = html.slice(1, -1);
+    }
+    // Removes the leading/trailing newlines
+    const cleaned = html.replace(/^\s*\n|\n\s*$/g, '');
+    // // Get the number of spaces in the first line to determine the tab size
+    // const tab = cleaned.match(/^\s*/)[0].length;
+    // // Remove the first indentation level from each line
+    // const tabRegex = new RegExp(`^\\s{${tab}}`, 'gm');
+    // const unindented = cleaned.replace(tabRegex, '');
+    return cleaned;
+};
+/**
+ * Reformat HTML for the markdown/mdx by adding an indentation to each line. This assures that the
+ * HTML is indentend properly within the HTMLBlock component when rendered in the markdown/mdx.
+ *
+ * @param {string} html
+ * @param {number} [indent=2]
+ * @returns {string} re-formatted HTML
+ */
+const reformatHTML = (html) => {
+    // Remove leading/trailing newlines
+    const cleaned = html.replace(/^\s*\n|\n\s*$/g, '').replaceAll(/(?<!\\(\\\\)*)`/g, '\\`');
+    // // Create a tab/indent with the specified number of spaces
+    // const tab = ' '.repeat(indent);
+    // // Indent each line of the HTML (converts to an array, indents each line, then joins back)
+    // const indented = cleaned.split('\n').map((line: string) => `${tab}${line}`).join('\n');
+    return cleaned;
+};
+const toAttributes = (object, keys = []) => {
+    const attributes = [];
+    Object.entries(object).forEach(([name, v]) => {
+        if (keys.length > 0 && !keys.includes(name))
+            return;
+        let value;
+        if (typeof v === 'undefined' || v === null || v === '' || v === false) {
+            return;
+        }
+        else if (typeof v === 'string') {
+            value = v;
+        }
+        else {
+            /* values can be null, undefined, string, or a expression, eg:
+             *
+             * ```
+             * <Image src="..." border={false} size={width - 20} />
+             * ```
+             *
+             * Parsing the expression seems to only be done by the library
+             * `mdast-util-mdx-jsx`, and so the most straight forward way to parse
+             * the expression and get the appropriate AST is with our `mdast`
+             * function.
+             */
+            const proxy = lib_mdast(`{${v}}`);
+            const data = proxy.children[0].data;
+            value = {
+                type: 'mdxJsxAttributeValueExpression',
+                value: v.toString(),
+                data,
+            };
+        }
+        attributes.push({
+            type: 'mdxJsxAttribute',
+            name,
+            value,
+        });
+    });
+    return attributes;
+};
+/**
+ * Checks if a named export exists in the MDX tree. Accepts either an mdast or
+ * a hast tree.
+ *
+ * example:
+ * ```
+ * const mdx = `export const Foo = 'bar';`
+ *
+ * hasNamedExport(mdast(mdx), 'Foo') => true
+ * ```
+ *
+ */
+const hasNamedExport = (tree, name) => {
+    let hasExport = false;
+    // eslint-disable-next-line consistent-return
+    visit(tree, 'mdxjsEsm', node => {
+        if ('declaration' in node.data.estree.body[0] &&
+            node.data.estree.body[0].declaration.type === 'VariableDeclaration') {
+            const { declarations } = node.data.estree.body[0].declaration;
+            hasExport = !!declarations.find(declaration => 'name' in declaration.id && declaration.id.name === name);
+            return hasExport ? EXIT : CONTINUE;
+        }
+    });
+    return hasExport;
+};
+/* Example mdast structures to find first export name in a mdxjsEsm node:
+There are three types of export declarations that we need to consider:
+1. VARIABLE DECLARATION
+      "type": "mdxjsEsm",
+      "value": "export const Foo = () => <div>Hello world</div>\nexport const Bar = () => <div>hello darkness my old friend</div>",
+      "data": {
+        "estree": {
+          "type": "Program",
+          "body": [
+            {
+              "type": "ExportNamedDeclaration",
+              "declaration": {
+                "type": "VariableDeclaration",
+                "declarations": [
+                  {
+                    "type": "VariableDeclarator",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "Foo" // --------> This is the export name
+                    },
+                    ...
+
+2/3. FUNCTION DECLARATION & CLASS DECLARATION
+      "estree": {
+          "type": "Program",
+          "body": [
+            {
+              "type": "ExportNamedDeclaration",
+              "declaration": {
+                "type": "ClassDeclaration" | "FunctionDeclaration",
+                "id": {
+                  "type": "Identifier",
+                  "name": "Foo" // --------> This is the export name
+                },
+*/
+const getExports = (tree) => {
+    const set = new Set();
+    visit(tree, isMDXEsm, (node) => {
+        // Once inside an mdxjsEsm node, we need to check for one or more declared exports within data.estree.body
+        // This is because single newlines \n are not considered as a new block, so there may be more than one export statement in a single mdxjsEsm node
+        const body = node.data?.estree.body;
+        if (!body)
+            return;
+        body.forEach(child => {
+            if (child.type === 'ExportNamedDeclaration') {
+                // There are three types of ExportNamedDeclaration that we need to consider: VariableDeclaration, FunctionDeclaration, ClassDeclaration
+                const declaration = child.declaration;
+                // FunctionDeclaration and ClassDeclaration have the same structure
+                if (declaration.type !== 'VariableDeclaration') {
+                    // Note: declaration.id.type is always 'Identifier' for FunctionDeclarations and ClassDeclarations
+                    set.add(declaration.id.name);
+                }
+                else {
+                    declaration.declarations.forEach(dec => {
+                        const id = dec.id;
+                        if (id.type === 'Identifier') {
+                            set.add(id.name);
+                        }
+                    });
+                }
+            }
+        });
+    });
+    return Array.from(set);
+};
+
+;// ./processor/compile/compatibility.ts
+
+
+
+/*
+ * Converts a (remark < v9) html node to a JSX string.
+ *
+ * First we replace html comments with the JSX equivalent. Then, we parse that
+ * as html, and serialize it back as xml!
+ *
+ */
+const compileHtml = (node) => {
+    const string = node.value.replaceAll(/<!--(.*)-->/gms, '{/*$1*/}');
+    return string;
+};
+const figureToImageBlock = (node) => {
+    const { align, border, width, src, url, alt, title, ...image } = node.children.find((child) => child.type === 'image');
+    const { className } = image.data.hProperties;
+    const figcaption = node.children.find((child) => child.type === 'figcaption');
+    const caption = figcaption ? toMarkdown(figcaption.children).trim() : null;
+    const attributes = {
+        ...(align && { align }),
+        ...(alt && { alt }),
+        ...(className && { border: className === 'border' }),
+        ...(border && { border }),
+        ...(caption && { caption }),
+        ...(title && { title }),
+        ...(width && { width }),
+        src: src || url,
+    };
+    return `<Image ${formatProps(attributes)} />`;
+};
+const embedToEmbedBlock = (node) => {
+    const { html, ...embed } = node.data.hProperties;
+    const attributes = {
+        ...embed,
+        ...(html && { html: encodeURIComponent(html) }),
+    };
+    return `<Embed ${formatProps(attributes)} />`;
+};
+const compatibility = (node) => {
+    switch (node.type) {
+        case NodeTypes.glossary: {
+            // Glossary terms will no longer be serialized as special node types in the Editor but we want to ensure that we compile historical
+            // data correctly
+            const term = node.data?.hProperties?.term || node.children[0].value;
+            return `<Glossary>${term}</Glossary>`;
+        }
+        case NodeTypes.reusableContent:
+            return `<${node.tag} />`;
+        case 'html':
+            return compileHtml(node);
+        case 'escape':
+            return `\\${node.value}`;
+        case 'figure':
+            return figureToImageBlock(node);
+        case 'embed':
+            return embedToEmbedBlock(node);
+        case 'i':
+            return `:${node.data.hProperties.className[1]}:`;
+        case 'yaml':
+            return `---\n${node.value}\n---`;
+        default:
+            throw new Error('Unhandled node type!');
+    }
+};
+/* harmony default export */ const compile_compatibility = (compatibility);
+
+;// ./processor/compile/gemoji.ts
+const gemoji = (node) => `:${node.name}:`;
+/* harmony default export */ const compile_gemoji = (gemoji);
+
+;// ./processor/compile/variable.ts
+const variable = (node) => `{user.${node.data?.hProperties?.name || ''}}`;
+/* harmony default export */ const compile_variable = (variable);
+
+;// ./processor/transform/extract-text.ts
+/**
+ * Extracts text content from a single AST node recursively.
+ * Works with both MDAST and HAST-like node structures.
+ *
+ * Placed this outside of the utils.ts file to avoid circular dependencies.
+ *
+ * @param node - The node to extract text from (can be MDAST Node or HAST-like structure)
+ * @returns The concatenated text content
+ */
+const extractText = (node) => {
+    if (typeof node.value === 'string') {
+        return node.value;
+    }
+    // When a blockquote contains only an image (no text), treat it as having content
+    // so the blockquote is no longer treated as empty and preserved correctly.
+    if (node.type === 'image') {
+        return typeof node.alt === 'string' && node.alt ? node.alt : '[image]';
+    }
+    if (node.children && Array.isArray(node.children)) {
+        return node.children
+            .map(child => {
+            if (child && typeof child === 'object' && 'type' in child) {
+                return extractText(child);
+            }
+            return '';
+        })
+            .join('');
+    }
+    return '';
+};
+
+;// ./processor/transform/callouts.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const titleParser = unified().use(remarkParse).use(remarkGfm);
+// The title paragraph may contain custom AST nodes that `toMarkdown` doesn't
+// natively understand
+const toMarkdownExtensions = [
+    gfmToMarkdown(),
+    // For mdx variable syntaxes (e.g., {user.name})
+    mdxExpressionToMarkdown(),
+    // Important: This is required and would crash the parser if there's no variable, gemoji, or fa-icon node handler
+    {
+        handlers: {
+            [NodeTypes.variable]: compile_variable,
+            [NodeTypes.emoji]: compile_gemoji,
+            [NodeTypes.i]: compile_compatibility,
+        },
+    },
+];
+const callouts_regex = `^(${emoji_regex().source}|⚠)(\\s+|$)`;
+const findFirst = (node) => {
+    if ('children' in node)
+        return findFirst(node.children[0]);
+    if (node.type === 'text')
+        return node;
+    return null;
+};
+const wrapHeading = (node) => {
+    const firstChild = node.children[0];
+    return {
+        type: 'heading',
+        depth: 3,
+        children: ('children' in firstChild ? firstChild.children : []),
+        position: {
+            start: firstChild.position.start,
+            end: firstChild.position.end,
+        },
+    };
+};
+/**
+ * Checks if a blockquote matches the expected callout structure:
+ * blockquote > paragraph > text node
+ */
+const isCalloutStructure = (node) => {
+    const firstChild = node.children?.[0];
+    if (!firstChild || firstChild.type !== 'paragraph')
+        return false;
+    if (!('children' in firstChild))
+        return false;
+    const firstTextChild = firstChild.children?.[0];
+    return firstTextChild?.type === 'text';
+};
+/**
+ * Finds the first text node containing a newline in a paragraph's children.
+ * Returns the index and the newline position within that text node.
+ */
+const findNewlineInParagraph = (paragraph) => {
+    for (let i = 0; i < paragraph.children.length; i += 1) {
+        const child = paragraph.children[i];
+        if (child.type === 'text' && typeof child.value === 'string') {
+            const newlineIndex = child.value.indexOf('\n');
+            if (newlineIndex !== -1) {
+                return { index: i, newlineIndex };
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Splits a paragraph at the first newline, separating heading content (before \n)
+ * from body content (after \n). Mutates the paragraph to contain only heading children.
+ */
+const splitParagraphAtNewline = (paragraph) => {
+    const splitPoint = findNewlineInParagraph(paragraph);
+    if (!splitPoint)
+        return null;
+    const { index, newlineIndex } = splitPoint;
+    const originalChildren = paragraph.children;
+    const textNode = originalChildren[index];
+    const beforeNewline = textNode.value.slice(0, newlineIndex);
+    const afterNewline = textNode.value.slice(newlineIndex + 1);
+    // Split paragraph: heading = children[0..index-1] + text before newline
+    const headingChildren = originalChildren.slice(0, index);
+    if (beforeNewline.length > 0 || headingChildren.length === 0) {
+        headingChildren.push({ type: 'text', value: beforeNewline });
+    }
+    paragraph.children = headingChildren;
+    // Body = text after newline + remaining children from original array
+    const bodyChildren = [];
+    if (afterNewline.length > 0) {
+        bodyChildren.push({ type: 'text', value: afterNewline });
+    }
+    bodyChildren.push(...originalChildren.slice(index + 1));
+    return bodyChildren.length > 0 ? bodyChildren : null;
+};
+/**
+ * Removes the icon/match prefix from the first text node in a paragraph.
+ * This is needed to clean up the raw AST after we've extracted the icon.
+ */
+const removeIconPrefix = (paragraph, prefixLength) => {
+    const firstTextNode = findFirst(paragraph);
+    if (firstTextNode && 'value' in firstTextNode && typeof firstTextNode.value === 'string') {
+        firstTextNode.value = firstTextNode.value.slice(prefixLength);
+    }
+};
+const processBlockquote = (node, index, parent, isMdxish = false) => {
+    if (!isCalloutStructure(node)) {
+        // Only stringify empty blockquotes (no extractable text content)
+        // Preserve blockquotes with actual content (e.g., headings, lists, etc.)
+        const content = extractText(node);
+        const isEmpty = !content || content.trim() === '';
+        if (isEmpty && index !== undefined && parent) {
+            const textNode = {
+                type: 'text',
+                value: '>',
+            };
+            const paragraphNode = {
+                type: 'paragraph',
+                children: [textNode],
+                position: node.position,
+            };
+            parent.children.splice(index, 1, paragraphNode);
+        }
+        return;
+    }
+    // isCalloutStructure ensures node.children[0] is a Paragraph with children
+    const firstParagraph = node.children[0];
+    const startText = lib_plain(firstParagraph).toString();
+    const [match, icon] = startText.match(callouts_regex) || [];
+    const firstParagraphOriginalEnd = firstParagraph.position.end;
+    if (icon && match) {
+        // Handle cases where heading and body are on the same line separated by a newline.
+        // Example: "> ⚠️ **Bold heading**\nBody text here"
+        const bodyChildren = splitParagraphAtNewline(firstParagraph);
+        const didSplit = bodyChildren !== null;
+        removeIconPrefix(firstParagraph, match.length);
+        const firstText = findFirst(firstParagraph);
+        const rawValue = firstText?.value ?? '';
+        const hasContent = rawValue.trim().length > 0 || firstParagraph.children.length > 1;
+        const empty = !hasContent;
+        const theme = themes[icon] || 'default';
+        if (hasContent || didSplit) {
+            const headingMatch = rawValue.match(/^(#{1,6})\s*/);
+            // # heading syntax is handled via direct AST manipulation so we can
+            // set the depth while preserving the original inline children (bold, etc.)
+            if (headingMatch) {
+                firstText.value = rawValue.slice(headingMatch[0].length);
+                const heading = wrapHeading(node);
+                heading.depth = headingMatch[1].length;
+                node.children[0] = heading;
+                node.children[0].position.start.offset += match.length;
+                node.children[0].position.start.column += match.length;
+            }
+            else if (isMdxish) {
+                // Block-level title re-parsing is only needed for MDXish where HTML stays
+                // as raw nodes. In MDX, remarkMdx has already converted HTML to JSX AST
+                // nodes which toMarkdown can't serialize — and MDX doesn't need this
+                // block-level title handling anyway.
+                const headingText = toMarkdown({ type: 'root', children: [firstParagraph] }, {
+                    extensions: toMarkdownExtensions,
+                })
+                    .trim()
+                    .replace(/^\\(?=[>#+\-*])/, '');
+                const parsedTitle = titleParser.parse(headingText);
+                const parsedFirstChild = parsedTitle.children[0];
+                // Block-level syntax ("> quote", "- list") produces non-paragraph nodes;
+                // inline text parses as a paragraph and falls through to wrapHeading().
+                if (parsedFirstChild && parsedFirstChild.type !== 'paragraph') {
+                    // Strip positions from re-parsed nodes since they're relative to the heading text, not the original source
+                    visit(parsedTitle, (n) => {
+                        delete n.position;
+                    });
+                    const heading = wrapHeading(node);
+                    heading.children = parsedTitle.children;
+                    delete heading.position;
+                    node.children[0] = heading;
+                }
+                else {
+                    node.children[0] = wrapHeading(node);
+                    node.children[0].position.start.offset += match.length;
+                    node.children[0].position.start.column += match.length;
+                }
+            }
+            else {
+                node.children[0] = wrapHeading(node);
+                node.children[0].position.start.offset += match.length;
+                node.children[0].position.start.column += match.length;
+            }
+        }
+        // Insert body content as a separate paragraph after the heading
+        if (bodyChildren) {
+            const headingPosition = node.children[0].position;
+            node.children.splice(1, 0, {
+                type: 'paragraph',
+                children: bodyChildren,
+                ...(headingPosition && firstParagraphOriginalEnd
+                    ? {
+                        position: {
+                            start: headingPosition.end,
+                            end: firstParagraphOriginalEnd,
+                        },
+                    }
+                    : {}),
+            });
+        }
+        Object.assign(node, {
+            type: NodeTypes.callout,
+            data: {
+                hName: 'Callout',
+                hProperties: {
+                    icon,
+                    ...(empty && { empty }),
+                    theme,
+                },
+            },
         });
     }
 };
@@ -90683,857 +91495,121 @@ const emojiToName = {
   '🇾🇪': 'yemen',
   '🇾🇹': 'mayotte',
   '🇿🇦': 'south_africa',
-  '🇿🇲': 'zambia',
-  '🇿🇼': 'zimbabwe',
-  '🏴󠁧󠁢󠁥󠁮󠁧󠁿': 'england',
-  '🏴󠁧󠁢󠁳󠁣󠁴󠁿': 'scotland',
-  '🏴󠁧󠁢󠁷󠁬󠁳󠁿': 'wales'
-}
-
-;// ./lib/owlmoji.ts
-
-const owlmoji = [
-    {
-        emoji: '', // This `emoji` property doesn't get consumed, but is required for type consistency
-        names: ['owlbert'],
-        tags: ['owlbert'],
-        description: 'an owlbert for any occasion',
-        category: 'ReadMe',
-    },
-    {
-        emoji: '',
-        names: ['owlbert-books'],
-        tags: ['owlbert'],
-        description: 'owlbert carrying books',
-        category: 'ReadMe',
-    },
-    {
-        emoji: '',
-        names: ['owlbert-mask'],
-        tags: ['owlbert'],
-        description: 'owlbert with a respirator',
-        category: 'ReadMe',
-    },
-    {
-        emoji: '',
-        names: ['owlbert-reading'],
-        tags: ['owlbert'],
-        description: 'owlbert reading',
-        category: 'ReadMe',
-    },
-    {
-        emoji: '',
-        names: ['owlbert-thinking'],
-        tags: ['owlbert'],
-        description: 'owlbert thinking',
-        category: 'ReadMe',
-    },
-];
-const owlmojiNames = owlmoji.flatMap(emoji => emoji.names);
-class Owlmoji {
-    static kind = (name) => {
-        if (name in nameToEmoji)
-            return 'gemoji';
-        else if (name.match(/^fa-/))
-            return 'fontawesome';
-        else if (owlmojiNames.includes(name))
-            return 'owlmoji';
-        return null;
-    };
-    static nameToEmoji = nameToEmoji;
-    static owlmoji = gemoji_gemoji.concat(owlmoji);
-}
-
-;// ./processor/transform/gemoji+.ts
-
-
-
-const gemoji_regex = /(?<=^|\s):(?<name>\+1|[-\w]+):/g;
-const gemojiReplacer = (_, name) => {
-    switch (Owlmoji.kind(name)) {
-        case 'gemoji': {
-            const node = {
-                type: NodeTypes.emoji,
-                value: Owlmoji.nameToEmoji[name],
-                name,
-            };
-            return node;
-        }
-        case 'fontawesome': {
-            const node = {
-                type: NodeTypes.i,
-                value: name,
-                data: {
-                    hName: 'i',
-                    hProperties: {
-                        className: ['fa-regular', name],
-                    },
-                },
-            };
-            return node;
-        }
-        case 'owlmoji': {
-            const node = {
-                type: 'image',
-                title: `:${name}:`,
-                alt: `:${name}:`,
-                url: `/public/img/emojis/${name}.png`,
-                data: {
-                    hProperties: {
-                        className: 'emoji',
-                        align: 'absmiddle',
-                        height: '20',
-                        width: '20',
-                    },
-                },
-            };
-            return node;
-        }
-        default:
-            return false;
-    }
-};
-const gemojiTransformer = () => (tree) => {
-    findAndReplace(tree, [gemoji_regex, gemojiReplacer]);
-    return tree;
-};
-/* harmony default export */ const gemoji_ = (gemojiTransformer);
-
-;// ./lib/mdast.ts
-
-const mdast = (text, opts = {}) => {
-    const processor = ast_processor(opts);
-    const tree = processor.parse(text);
-    return processor.runSync(tree);
-};
-/* harmony default export */ const lib_mdast = (mdast);
-
-;// ./lib/utils/mdxish/protect-code-blocks.ts
-/**
- * Replaces code blocks and inline code with placeholders to protect them from preprocessing.
- *
- * @param content - The markdown content to process
- * @returns Object containing protected content and arrays of original code blocks
- * @example
- * ```typescript
- * const input = 'Text with `inline code` and ```fenced block```';
- * protectCodeBlocks(input)
- * // Returns: {
- * //   protectedCode: {
- * //     codeBlocks: ['```fenced block```'],
- * //     inlineCode: ['`inline code`']
- * //   },
- * //   protectedContent: 'Text with ___INLINE_CODE_0___ and ___CODE_BLOCK_0___'
- * // }
- * ```
- */
-function protectCodeBlocks(content) {
-    const codeBlocks = [];
-    const inlineCode = [];
-    let protectedContent = '';
-    let remaining = content;
-    let codeBlockStart = remaining.indexOf('```');
-    while (codeBlockStart !== -1) {
-        protectedContent += remaining.slice(0, codeBlockStart);
-        remaining = remaining.slice(codeBlockStart);
-        const codeBlockEnd = remaining.indexOf('```', 3);
-        if (codeBlockEnd === -1) {
-            break;
-        }
-        const match = remaining.slice(0, codeBlockEnd + 3);
-        const index = codeBlocks.length;
-        codeBlocks.push(match);
-        protectedContent += `___CODE_BLOCK_${index}___`;
-        remaining = remaining.slice(codeBlockEnd + 3);
-        codeBlockStart = remaining.indexOf('```');
-    }
-    protectedContent += remaining;
-    protectedContent = protectedContent.replace(/`([^`\n]+)`/g, match => {
-        const index = inlineCode.length;
-        inlineCode.push(match);
-        return `___INLINE_CODE_${index}___`;
-    });
-    return { protectedCode: { codeBlocks, inlineCode }, protectedContent };
-}
-/**
- * Restores inline code by replacing placeholders with original content.
- *
- * @param content - Content with inline code placeholders
- * @param protectedCode - The protected code arrays
- * @returns Content with inline code restored
- */
-function restoreInlineCode(content, protectedCode) {
-    return content.replace(/___INLINE_CODE_(\d+)___/g, (_m, idx) => {
-        return protectedCode.inlineCode[parseInt(idx, 10)];
-    });
-}
-/**
- * Restores fenced code blocks by replacing placeholders with original content.
- *
- * @param content - Content with code block placeholders
- * @param protectedCode - The protected code arrays
- * @returns Content with code blocks restored
- */
-function restoreFencedCodeBlocks(content, protectedCode) {
-    return content.replace(/___CODE_BLOCK_(\d+)___/g, (_m, idx) => {
-        return protectedCode.codeBlocks[parseInt(idx, 10)];
-    });
-}
-/**
- * Restores all code blocks and inline code by replacing placeholders with original content.
- *
- * @param content - Content with code placeholders
- * @param protectedCode - The protected code arrays
- * @returns Content with all code blocks and inline code restored
- * @example
- * ```typescript
- * const content = 'Text with ___INLINE_CODE_0___ and ___CODE_BLOCK_0___';
- * const protectedCode = {
- *   codeBlocks: ['```js\ncode\n```'],
- *   inlineCode: ['`inline`']
- * };
- * restoreCodeBlocks(content, protectedCode)
- * // Returns: 'Text with `inline` and ```js\ncode\n```'
- * ```
- */
-function restoreCodeBlocks(content, protectedCode) {
-    let restored = restoreFencedCodeBlocks(content, protectedCode);
-    restored = restoreInlineCode(restored, protectedCode);
-    return restored;
-}
-
-;// ./processor/transform/mdxish/preprocess-jsx-expressions.ts
-
-// Base64 encode (Node.js + browser compatible)
-function base64Encode(str) {
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(str, 'utf-8').toString('base64');
-    }
-    return btoa(unescape(encodeURIComponent(str)));
-}
-// Base64 decode (Node.js + browser compatible)
-function base64Decode(str) {
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(str, 'base64').toString('utf-8');
-    }
-    return decodeURIComponent(escape(atob(str)));
-}
-function escapeHtmlAttribute(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/"/g, '&quot;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/\n/g, '&#10;');
-}
-// Marker prefix for JSON-serialized complex values (arrays/objects)
-// Using a prefix that won't conflict with regular string values
-const JSON_VALUE_MARKER = '__MDXISH_JSON__';
-// Markers for protected HTMLBlock content (HTML comments avoid markdown parsing issues)
-const HTML_BLOCK_CONTENT_START = '<!--RDMX_HTMLBLOCK:';
-const HTML_BLOCK_CONTENT_END = ':RDMX_HTMLBLOCK-->';
-/**
- * Evaluates a JavaScript expression using context variables.
- *
- * @param expression
- * @param context
- * @returns The evaluated result
- * @example
- * ```typescript
- * const context = { baseUrl: 'https://example.com', path: '/api' };
- * evaluateExpression('baseUrl + path', context)
- * // Returns: 'https://example.com/api'
- * ```
- */
-function evaluateExpression(expression, context) {
-    const contextKeys = Object.keys(context);
-    const contextValues = Object.values(context);
-    // eslint-disable-next-line no-new-func
-    const func = new Function(...contextKeys, `return ${expression}`);
-    return func(...contextValues);
-}
-/**
- * Base64 encodes HTMLBlock template literal content to prevent markdown parser from consuming <script>/<style> tags.
- *
- * @param content
- * @returns Content with HTMLBlock template literals base64 encoded in HTML comments
- * @example
- * ```typescript
- * const input = '<HTMLBlock>{`<script>alert("xss")</script>`}</HTMLBlock>';
- * protectHTMLBlockContent(input)
- * // Returns: '<HTMLBlock><!--RDMX_HTMLBLOCK:PHNjcmlwdD5hbGVydCgieHNzIik8L3NjcmlwdD4=:RDMX_HTMLBLOCK--></HTMLBlock>'
- * ```
- */
-function protectHTMLBlockContent(content) {
-    return content.replace(/(<HTMLBlock[^>]*>)\{\s*`((?:[^`\\]|\\.)*)`\s*\}(<\/HTMLBlock>)/g, (_match, openTag, templateContent, closeTag) => {
-        const encoded = base64Encode(templateContent);
-        return `${openTag}${HTML_BLOCK_CONTENT_START}${encoded}${HTML_BLOCK_CONTENT_END}${closeTag}`;
-    });
-}
-/**
- * Removes JSX-style comments (e.g., { /* comment *\/ }) from content.
- *
- * @param content
- * @returns Content with JSX comments removed
- * @example
- * ```typescript
- * removeJSXComments('Text { /* comment *\/ } more text')
- * // Returns: 'Text  more text'
- * ```
- */
-function removeJSXComments(content) {
-    return content.replace(/\{\s*\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\/\s*\}/g, '');
-}
-/**
- * Extracts content between balanced braces, handling nested braces.
- *
- * @param content
- * @param start
- * @returns Object with extracted content and end position, or null if braces are unbalanced
- * @example
- * ```typescript
- * const input = 'foo{bar{baz}qux}end';
- * extractBalancedBraces(input, 3) // start at position 3 (after '{')
- * // Returns: { content: 'bar{baz}qux', end: 16 }
- * ```
- */
-function extractBalancedBraces(content, start) {
-    let depth = 1;
-    let pos = start;
-    while (pos < content.length && depth > 0) {
-        const char = content[pos];
-        if (char === '{')
-            depth += 1;
-        else if (char === '}')
-            depth -= 1;
-        pos += 1;
-    }
-    if (depth !== 0)
-        return null;
-    return { content: content.slice(start, pos - 1), end: pos };
-}
-/**
- * Escapes problematic braces in content to prevent MDX expression parsing errors.
- * Handles three cases:
- * 1. Unbalanced braces (e.g., `{foo` without closing `}`)
- * 2. Paragraph-spanning expressions (e.g., `{\n\n}` where blank line splits paragraphs)
- * 3. Skips HTML elements to prevent backslashes appearing in output
- *
- */
-function escapeProblematicBraces(content) {
-    // Skip HTML elements — their content should never be escaped because
-    // rehypeRaw parses them into hast elements, making `\` literal text in output
-    const htmlElements = [];
-    const safe = content.replace(/<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, match => {
-        const idx = htmlElements.length;
-        htmlElements.push(match);
-        return `___HTML_ELEM_${idx}___`;
-    });
-    const toEscape = new Set();
-    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
-    const chars = Array.from(safe);
-    let strDelim = null;
-    let strEscaped = false;
-    // Stack of open braces with their state
-    const openStack = [];
-    // Track position of last newline (outside strings) to detect blank lines
-    let lastNewlinePos = -2; // -2 means no recent newline
-    for (let i = 0; i < chars.length; i += 1) {
-        const ch = chars[i];
-        // Track string delimiters inside expressions to ignore braces within them
-        if (openStack.length > 0) {
-            if (strDelim) {
-                if (strEscaped)
-                    strEscaped = false;
-                else if (ch === '\\')
-                    strEscaped = true;
-                else if (ch === strDelim)
-                    strDelim = null;
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            if (ch === '"' || ch === "'" || ch === '`') {
-                strDelim = ch;
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            // Track newlines to detect blank lines (paragraph boundaries)
-            if (ch === '\n') {
-                // Check if this newline creates a blank line (only whitespace since last newline)
-                if (lastNewlinePos >= 0) {
-                    const between = chars.slice(lastNewlinePos + 1, i).join('');
-                    if (/^[ \t]*$/.test(between)) {
-                        // This is a blank line - mark all open expressions as paragraph-spanning
-                        openStack.forEach(entry => {
-                            entry.hasBlankLine = true;
-                        });
-                    }
-                }
-                lastNewlinePos = i;
-            }
-        }
-        // Skip already-escaped braces (count preceding backslashes)
-        if (ch === '{' || ch === '}') {
-            let bs = 0;
-            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
-                bs += 1;
-            if (bs % 2 === 1) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-        }
-        if (ch === '{') {
-            openStack.push({ pos: i, hasBlankLine: false });
-            lastNewlinePos = -2; // Reset newline tracking for new expression
-        }
-        else if (ch === '}') {
-            if (openStack.length > 0) {
-                const entry = openStack.pop();
-                // If expression spans paragraph boundary, escape both braces
-                if (entry.hasBlankLine) {
-                    toEscape.add(entry.pos);
-                    toEscape.add(i);
-                }
-            }
-            else {
-                // Unbalanced closing brace (no matching open)
-                toEscape.add(i);
-            }
-        }
-    }
-    // Any remaining open braces are unbalanced
-    openStack.forEach(entry => toEscape.add(entry.pos));
-    // If there are no problematic braces, return safe content as-is;
-    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
-    let result = toEscape.size === 0
-        ? safe
-        : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
-    // Restore HTML elements
-    if (htmlElements.length > 0) {
-        result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
-    }
-    return result;
-}
-/**
- * Converts JSX attribute expressions (attribute={expression}) to HTML attributes (attribute="value").
- * Handles style objects (camelCase → kebab-case), className → class, and JSON stringifies objects.
- *
- * @param content
- * @param context
- * @returns Content with attribute expressions evaluated and converted to HTML attributes
- * @example
- * ```typescript
- * const context = { baseUrl: 'https://example.com' };
- * const input = '<a href={baseUrl}>Link</a>';
- * evaluateAttributeExpressions(input, context)
- * // Returns: '<a href="https://example.com">Link</a>'
- * ```
- */
-function evaluateAttributeExpressions(content, context, protectedCode) {
-    const attrStartRegex = /(\w+)=\{/g;
-    let result = '';
-    let lastEnd = 0;
-    let match = attrStartRegex.exec(content);
-    while (match !== null) {
-        const attributeName = match[1];
-        const braceStart = match.index + match[0].length;
-        const extracted = extractBalancedBraces(content, braceStart);
-        if (extracted) {
-            // The expression might contain template literals in MDX component tag props
-            // E.g. <Component greeting={`Hello World!`} />
-            // that is marked as inline code. So we need to restore the inline codes
-            // in the expression to evaluate it
-            let expression = extracted.content;
-            if (protectedCode) {
-                expression = restoreInlineCode(expression, protectedCode);
-            }
-            const fullMatchEnd = extracted.end;
-            result += content.slice(lastEnd, match.index);
-            try {
-                const evalResult = evaluateExpression(expression, context);
-                if (typeof evalResult === 'object' && evalResult !== null) {
-                    if (attributeName === 'style') {
-                        const cssString = Object.entries(evalResult)
-                            .map(([key, value]) => {
-                            const cssKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
-                            return `${cssKey}: ${value}`;
-                        })
-                            .join('; ');
-                        result += `style="${cssString}"`;
-                    }
-                    else {
-                        // These are arrays / objects attribute values
-                        // Mark JSON-serialized values with a prefix so they can be parsed back correctly
-                        const jsonValue = escapeHtmlAttribute(JSON_VALUE_MARKER + JSON.stringify(evalResult));
-                        // Use double quotes so that multi-paragraph values are not split into multiple attributes by the processors
-                        result += `${attributeName}="${jsonValue}"`;
-                    }
-                }
-                else if (attributeName === 'className') {
-                    // Escape special characters so that it doesn't break and split the attribute value to nodes
-                    // This will be restored later in the pipeline
-                    result += `class="${escapeHtmlAttribute(String(evalResult))}"`;
-                }
-                else {
-                    result += `${attributeName}="${escapeHtmlAttribute(String(evalResult))}"`;
-                }
-            }
-            catch (_error) {
-                result += content.slice(match.index, fullMatchEnd);
-            }
-            lastEnd = fullMatchEnd;
-            attrStartRegex.lastIndex = fullMatchEnd;
-        }
-        match = attrStartRegex.exec(content);
-    }
-    result += content.slice(lastEnd);
-    return result;
+  '🇿🇲': 'zambia',
+  '🇿🇼': 'zimbabwe',
+  '🏴󠁧󠁢󠁥󠁮󠁧󠁿': 'england',
+  '🏴󠁧󠁢󠁳󠁣󠁴󠁿': 'scotland',
+  '🏴󠁧󠁢󠁷󠁬󠁳󠁿': 'wales'
 }
-/**
- * Preprocesses JSX-like expressions in markdown before parsing.
- * Inline expressions are handled separately; attribute expressions are processed here.
- *
- * @param content
- * @param context
- * @returns Preprocessed content ready for markdown parsing
- */
-function preprocessJSXExpressions(content, context = {}) {
-    // Step 0: Base64 encode HTMLBlock content
-    let processed = protectHTMLBlockContent(content);
-    // Step 1: Protect code blocks and inline code
-    const { protectedCode, protectedContent } = protectCodeBlocks(processed);
-    // Step 2: Evaluate attribute expressions (JSX attribute syntax: href={baseUrl})
-    // For inline expressions, we use a library to parse the expression & evaluate it later
-    // For attribute expressions, it was difficult to use a library to parse them, so do it manually
-    processed = evaluateAttributeExpressions(protectedContent, context, protectedCode);
-    // Step 3: Escape problematic braces to prevent MDX expression parsing errors
-    // This handles both unbalanced braces and paragraph-spanning expressions in one pass
-    processed = escapeProblematicBraces(processed);
-    // Step 4: Restore protected code blocks
-    processed = restoreCodeBlocks(processed, protectedCode);
-    return processed;
+
+;// ./lib/owlmoji.ts
+
+const owlmoji = [
+    {
+        emoji: '', // This `emoji` property doesn't get consumed, but is required for type consistency
+        names: ['owlbert'],
+        tags: ['owlbert'],
+        description: 'an owlbert for any occasion',
+        category: 'ReadMe',
+    },
+    {
+        emoji: '',
+        names: ['owlbert-books'],
+        tags: ['owlbert'],
+        description: 'owlbert carrying books',
+        category: 'ReadMe',
+    },
+    {
+        emoji: '',
+        names: ['owlbert-mask'],
+        tags: ['owlbert'],
+        description: 'owlbert with a respirator',
+        category: 'ReadMe',
+    },
+    {
+        emoji: '',
+        names: ['owlbert-reading'],
+        tags: ['owlbert'],
+        description: 'owlbert reading',
+        category: 'ReadMe',
+    },
+    {
+        emoji: '',
+        names: ['owlbert-thinking'],
+        tags: ['owlbert'],
+        description: 'owlbert thinking',
+        category: 'ReadMe',
+    },
+];
+const owlmojiNames = owlmoji.flatMap(emoji => emoji.names);
+class Owlmoji {
+    static kind = (name) => {
+        if (name in nameToEmoji)
+            return 'gemoji';
+        else if (name.match(/^fa-/))
+            return 'fontawesome';
+        else if (owlmojiNames.includes(name))
+            return 'owlmoji';
+        return null;
+    };
+    static nameToEmoji = nameToEmoji;
+    static owlmoji = gemoji_gemoji.concat(owlmoji);
 }
 
-;// ./processor/utils.ts
+;// ./processor/transform/gemoji+.ts
 
 
 
-/**
- * Formats the hProperties of a node as a string, so they can be compiled back into JSX/MDX.
- * This currently sets all the values to a string since we process/compile the MDX on the fly
- * through the editor, and it'll throw errors over malformed JSX. TODO: fix this.
- *
- * @template T
- * @param {Node} node
- * @returns {string} formatted hProperties as JSX attributes
- */
-const formatHProps = (node) => {
-    const hProps = getHProps(node);
-    return formatProps(hProps);
-};
-/**
- * Formats an object of props as a string.
- *
- * @param {Object} props
- * @returns {string}
- */
-const formatProps = (props) => {
-    const keys = Object.keys(props);
-    return keys.map(key => `${key}="${props[key]}"`).join(' ');
-};
-/**
- * Returns the hProperties of a node.
- *
- * @template T
- * @param {Node} node
- * @returns {T} hProperties
- */
-const getHProps = (node) => {
-    const hProps = node.data?.hProperties || {};
-    return hProps;
-};
-/**
- * Returns array of hProperty keys.
- *
- * @template T
- * @param {Node} node
- * @returns {Array} array of hProperty keys
- */
-const getHPropKeys = (node) => {
-    const hProps = getHProps(node);
-    return Object.keys(hProps) || [];
-};
-/**
- * Gets the attributes of an MDX element and returns them as an object of hProperties.
- *
- * @template T
- * @param {(MdxJsxFlowElement | MdxJsxTextElement)} jsx
- * @returns {T} object of hProperties
- */
-const getAttrs = (jsx) => jsx.attributes.reduce((memo, attr) => {
-    if ('name' in attr) {
-        if (typeof attr.value === 'string') {
-            if (attr.value.startsWith(JSON_VALUE_MARKER)) {
-                try {
-                    memo[attr.name] = JSON.parse(attr.value.slice(JSON_VALUE_MARKER.length));
-                }
-                catch {
-                    memo[attr.name] = attr.value;
-                }
-            }
-            else {
-                memo[attr.name] = attr.value;
-            }
-        }
-        else if (attr.value === null) {
-            memo[attr.name] = true;
-        }
-        else if (attr.value.value !== 'undefined') {
-            memo[attr.name] = JSON.parse(attr.value.value);
-        }
-    }
-    return memo;
-}, {});
-/**
- * Gets the children of an MDX element and returns them as an array of Text nodes.
- * Currently only being used by the HTML Block component, which only expects a single text node.
- *
- * @template T
- * @param {(MdxJsxFlowElement | MdxJsxTextElement)} jsx
- * @returns {Array} array of child text nodes
- */
-const utils_getChildren = (jsx) => jsx.children.reduce((memo, child, i) => {
-    memo[i] = {
-        type: 'text',
-        value: child.value,
-        position: child.position,
-    };
-    return memo;
-}, []);
-/**
- * Tests if a node is an MDX element.
- * TODO: Make this more extensible to all types of nodes. isElement(node, 'type' or ['type1', 'type2']), say
- *
- * @param {Node} node
- * @returns {(node is MdxJsxFlowElement | MdxJsxTextElement | MdxjsEsm)}
- */
-const isMDXElement = (node) => {
-    return ['mdxJsxFlowElement', 'mdxJsxTextElement'].includes(node.type);
-};
-/**
- * Tests if a node is an MDX ESM element (i.e. import or export).
- *
- * @param {Node} node
- * @returns {boolean}
- */
-const isMDXEsm = (node) => {
-    return node.type === 'mdxjsEsm';
-};
-/**
- * Takes an HTML string and formats it for display in the editor. Removes leading/trailing newlines
- * and unindents the HTML.
- *
- * @param {string} html - HTML content from template literal
- * @returns {string} processed HTML
- */
-function formatHtmlForMdxish(html) {
-    // Remove leading/trailing backticks if present, since they're used to keep the HTML
-    // from being parsed prematurely
-    let processed = html;
-    if (processed.startsWith('`') && processed.endsWith('`')) {
-        processed = processed.slice(1, -1);
-    }
-    // Removes the leading/trailing newlines
-    let cleaned = processed.replace(/^\s*\n|\n\s*$/g, '');
-    // Convert literal \n sequences to actual newlines BEFORE processing backticks
-    // This prevents the backtick unescaping regex from incorrectly matching \n sequences
-    cleaned = cleaned.replace(/\\n/g, '\n');
-    // Unescape backticks: \` -> ` (users escape backticks in template literals)
-    // Handle both cases: \` (adjacent) and \ followed by ` (split by markdown parser)
-    cleaned = cleaned.replace(/\\`/g, '`');
-    // Also handle case where backslash and backtick got separated by markdown parsing
-    // Pattern: backslash followed by any characters (but not \n which we already handled), then a backtick
-    // This handles cases like: \example` -> `example` (replacing \ with ` at start)
-    // Exclude \n sequences to avoid matching them incorrectly
-    cleaned = cleaned.replace(/\\([^`\\n]*?)`/g, '`$1`');
-    // Fix case where markdown parser consumed one backtick from triple backticks
-    // Pattern: `` followed by a word (like ``javascript) should be ```javascript
-    // This handles cases where code fences were parsed and one backtick was lost
-    cleaned = cleaned.replace(/<(\w+[^>]*)>``(\w+)/g, '<$1>```$2');
-    // Unescape dollar signs: \$ -> $ (users escape $ in template literals to prevent interpolation)
-    cleaned = cleaned.replace(/\\\$/g, '$');
-    return cleaned;
-}
-/**
- * Takes an HTML string and formats it for display in the editor. Removes leading/trailing newlines
- * and unindents the HTML.
- *
- * @param {string} html
- * @returns {string} formatted HTML
- */
-const formatHTML = (html) => {
-    // Remove leading/trailing backticks if present, since they're used to keep the HTML
-    // from being parsed prematurely
-    if (html.startsWith('`') && html.endsWith('`')) {
-        // eslint-disable-next-line no-param-reassign
-        html = html.slice(1, -1);
-    }
-    // Removes the leading/trailing newlines
-    const cleaned = html.replace(/^\s*\n|\n\s*$/g, '');
-    // // Get the number of spaces in the first line to determine the tab size
-    // const tab = cleaned.match(/^\s*/)[0].length;
-    // // Remove the first indentation level from each line
-    // const tabRegex = new RegExp(`^\\s{${tab}}`, 'gm');
-    // const unindented = cleaned.replace(tabRegex, '');
-    return cleaned;
-};
-/**
- * Reformat HTML for the markdown/mdx by adding an indentation to each line. This assures that the
- * HTML is indentend properly within the HTMLBlock component when rendered in the markdown/mdx.
- *
- * @param {string} html
- * @param {number} [indent=2]
- * @returns {string} re-formatted HTML
- */
-const reformatHTML = (html) => {
-    // Remove leading/trailing newlines
-    const cleaned = html.replace(/^\s*\n|\n\s*$/g, '').replaceAll(/(?<!\\(\\\\)*)`/g, '\\`');
-    // // Create a tab/indent with the specified number of spaces
-    // const tab = ' '.repeat(indent);
-    // // Indent each line of the HTML (converts to an array, indents each line, then joins back)
-    // const indented = cleaned.split('\n').map((line: string) => `${tab}${line}`).join('\n');
-    return cleaned;
-};
-const toAttributes = (object, keys = []) => {
-    const attributes = [];
-    Object.entries(object).forEach(([name, v]) => {
-        if (keys.length > 0 && !keys.includes(name))
-            return;
-        let value;
-        if (typeof v === 'undefined' || v === null || v === '' || v === false) {
-            return;
-        }
-        else if (typeof v === 'string') {
-            value = v;
-        }
-        else {
-            /* values can be null, undefined, string, or a expression, eg:
-             *
-             * ```
-             * <Image src="..." border={false} size={width - 20} />
-             * ```
-             *
-             * Parsing the expression seems to only be done by the library
-             * `mdast-util-mdx-jsx`, and so the most straight forward way to parse
-             * the expression and get the appropriate AST is with our `mdast`
-             * function.
-             */
-            const proxy = lib_mdast(`{${v}}`);
-            const data = proxy.children[0].data;
-            value = {
-                type: 'mdxJsxAttributeValueExpression',
-                value: v.toString(),
-                data,
+const gemoji_regex = /(?<=^|\s):(?<name>\+1|[-\w]+):/g;
+const gemojiReplacer = (_, name) => {
+    switch (Owlmoji.kind(name)) {
+        case 'gemoji': {
+            const node = {
+                type: NodeTypes.emoji,
+                value: Owlmoji.nameToEmoji[name],
+                name,
             };
+            return node;
         }
-        attributes.push({
-            type: 'mdxJsxAttribute',
-            name,
-            value,
-        });
-    });
-    return attributes;
-};
-/**
- * Checks if a named export exists in the MDX tree. Accepts either an mdast or
- * a hast tree.
- *
- * example:
- * ```
- * const mdx = `export const Foo = 'bar';`
- *
- * hasNamedExport(mdast(mdx), 'Foo') => true
- * ```
- *
- */
-const hasNamedExport = (tree, name) => {
-    let hasExport = false;
-    // eslint-disable-next-line consistent-return
-    visit(tree, 'mdxjsEsm', node => {
-        if ('declaration' in node.data.estree.body[0] &&
-            node.data.estree.body[0].declaration.type === 'VariableDeclaration') {
-            const { declarations } = node.data.estree.body[0].declaration;
-            hasExport = !!declarations.find(declaration => 'name' in declaration.id && declaration.id.name === name);
-            return hasExport ? EXIT : CONTINUE;
+        case 'fontawesome': {
+            const node = {
+                type: NodeTypes.i,
+                value: name,
+                data: {
+                    hName: 'i',
+                    hProperties: {
+                        className: ['fa-regular', name],
+                    },
+                },
+            };
+            return node;
         }
-    });
-    return hasExport;
-};
-/* Example mdast structures to find first export name in a mdxjsEsm node:
-There are three types of export declarations that we need to consider:
-1. VARIABLE DECLARATION
-      "type": "mdxjsEsm",
-      "value": "export const Foo = () => <div>Hello world</div>\nexport const Bar = () => <div>hello darkness my old friend</div>",
-      "data": {
-        "estree": {
-          "type": "Program",
-          "body": [
-            {
-              "type": "ExportNamedDeclaration",
-              "declaration": {
-                "type": "VariableDeclaration",
-                "declarations": [
-                  {
-                    "type": "VariableDeclarator",
-                    "id": {
-                      "type": "Identifier",
-                      "name": "Foo" // --------> This is the export name
+        case 'owlmoji': {
+            const node = {
+                type: 'image',
+                title: `:${name}:`,
+                alt: `:${name}:`,
+                url: `/public/img/emojis/${name}.png`,
+                data: {
+                    hProperties: {
+                        className: 'emoji',
+                        align: 'absmiddle',
+                        height: '20',
+                        width: '20',
                     },
-                    ...
-
-2/3. FUNCTION DECLARATION & CLASS DECLARATION
-      "estree": {
-          "type": "Program",
-          "body": [
-            {
-              "type": "ExportNamedDeclaration",
-              "declaration": {
-                "type": "ClassDeclaration" | "FunctionDeclaration",
-                "id": {
-                  "type": "Identifier",
-                  "name": "Foo" // --------> This is the export name
                 },
-*/
-const getExports = (tree) => {
-    const set = new Set();
-    visit(tree, isMDXEsm, (node) => {
-        // Once inside an mdxjsEsm node, we need to check for one or more declared exports within data.estree.body
-        // This is because single newlines \n are not considered as a new block, so there may be more than one export statement in a single mdxjsEsm node
-        const body = node.data?.estree.body;
-        if (!body)
-            return;
-        body.forEach(child => {
-            if (child.type === 'ExportNamedDeclaration') {
-                // There are three types of ExportNamedDeclaration that we need to consider: VariableDeclaration, FunctionDeclaration, ClassDeclaration
-                const declaration = child.declaration;
-                // FunctionDeclaration and ClassDeclaration have the same structure
-                if (declaration.type !== 'VariableDeclaration') {
-                    // Note: declaration.id.type is always 'Identifier' for FunctionDeclarations and ClassDeclarations
-                    set.add(declaration.id.name);
-                }
-                else {
-                    declaration.declarations.forEach(dec => {
-                        const id = dec.id;
-                        if (id.type === 'Identifier') {
-                            set.add(id.name);
-                        }
-                    });
-                }
-            }
-        });
-    });
-    return Array.from(set);
+            };
+            return node;
+        }
+        default:
+            return false;
+    }
 };
+const gemojiTransformer = () => (tree) => {
+    findAndReplace(tree, [gemoji_regex, gemojiReplacer]);
+    return tree;
+};
+/* harmony default export */ const gemoji_ = (gemojiTransformer);
 
 ;// ./processor/transform/handle-missing-components.ts
 
@@ -92494,6 +92570,23 @@ const mdxishTables = () => tree => {
             return;
         try {
             const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(node.value));
+            // since we use a subparser in `tableNodeProcessor` to parse `node.value`,
+            // positions are relative to that substring. shifting them by the base
+            // offset and line number makes them valid in the outer source coordinate space.
+            // otherwise, consumers who directly slice based on position would read and grab the
+            // wrong content
+            const baseOffset = node.position?.start?.offset ?? 0;
+            const baseLine = (node.position?.start?.line ?? 1) - 1;
+            visit(parsed, child => {
+                if (child.position?.start) {
+                    child.position.start.offset = (child.position.start.offset ?? 0) + baseOffset;
+                    child.position.start.line += baseLine;
+                }
+                if (child.position?.end) {
+                    child.position.end.offset = (child.position.end.offset ?? 0) + baseOffset;
+                    child.position.end.line += baseLine;
+                }
+            });
             visit(parsed, isMDXElement, (tableNode) => {
                 if (tableNode.name === 'Table') {
                     processTableNode(tableNode, index, parent, node.position);
@@ -112904,74 +112997,6 @@ const codeTabs = (node, _, state, info) => {
 };
 /* harmony default export */ const compile_code_tabs = (codeTabs);
 
-;// ./processor/compile/compatibility.ts
-
-
-
-/*
- * Converts a (remark < v9) html node to a JSX string.
- *
- * First we replace html comments with the JSX equivalent. Then, we parse that
- * as html, and serialize it back as xml!
- *
- */
-const compileHtml = (node) => {
-    const string = node.value.replaceAll(/<!--(.*)-->/gms, '{/*$1*/}');
-    return string;
-};
-const figureToImageBlock = (node) => {
-    const { align, border, width, src, url, alt, title, ...image } = node.children.find((child) => child.type === 'image');
-    const { className } = image.data.hProperties;
-    const figcaption = node.children.find((child) => child.type === 'figcaption');
-    const caption = figcaption ? toMarkdown(figcaption.children).trim() : null;
-    const attributes = {
-        ...(align && { align }),
-        ...(alt && { alt }),
-        ...(className && { border: className === 'border' }),
-        ...(border && { border }),
-        ...(caption && { caption }),
-        ...(title && { title }),
-        ...(width && { width }),
-        src: src || url,
-    };
-    return `<Image ${formatProps(attributes)} />`;
-};
-const embedToEmbedBlock = (node) => {
-    const { html, ...embed } = node.data.hProperties;
-    const attributes = {
-        ...embed,
-        ...(html && { html: encodeURIComponent(html) }),
-    };
-    return `<Embed ${formatProps(attributes)} />`;
-};
-const compatibility = (node) => {
-    switch (node.type) {
-        case NodeTypes.glossary: {
-            // Glossary terms will no longer be serialized as special node types in the Editor but we want to ensure that we compile historical
-            // data correctly
-            const term = node.data?.hProperties?.term || node.children[0].value;
-            return `<Glossary>${term}</Glossary>`;
-        }
-        case NodeTypes.reusableContent:
-            return `<${node.tag} />`;
-        case 'html':
-            return compileHtml(node);
-        case 'escape':
-            return `\\${node.value}`;
-        case 'figure':
-            return figureToImageBlock(node);
-        case 'embed':
-            return embedToEmbedBlock(node);
-        case 'i':
-            return `:${node.data.hProperties.className[1]}:`;
-        case 'yaml':
-            return `---\n${node.value}\n---`;
-        default:
-            throw new Error('Unhandled node type!');
-    }
-};
-/* harmony default export */ const compile_compatibility = (compatibility);
-
 ;// ./processor/compile/embed.ts
 
 const embed_embed = (node) => {
@@ -119118,7 +119143,7 @@ function findJsxTableToken() {
     return undefined;
 }
 function enterJsxTable(token) {
-    jsx_table_contextMap.set(token, { chunks: [] });
+    jsx_table_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
     this.enter({ type: 'html', value: '' }, token);
 }
 function exitJsxTableData(token) {
@@ -119126,14 +119151,20 @@ function exitJsxTableData(token) {
     if (!tableToken)
         return;
     const ctx = jsx_table_contextMap.get(tableToken);
-    if (ctx)
+    if (ctx) {
+        const gap = token.start.line - ctx.lastEndLine;
+        if (ctx.chunks.length > 0 && gap > 0) {
+            ctx.chunks.push('\n'.repeat(gap));
+        }
         ctx.chunks.push(this.sliceSerialize(token));
+        ctx.lastEndLine = token.end.line;
+    }
 }
 function exitJsxTable(token) {
     const ctx = jsx_table_contextMap.get(token);
     const node = this.stack[this.stack.length - 1];
     if (ctx) {
-        node.value = ctx.chunks.join('\n');
+        node.value = ctx.chunks.join('');
         jsx_table_contextMap.delete(token);
     }
     this.exit(token);