@readme/markdown 12.2.0 → 13.1.0

package/dist/main.node.js

@@ -24514,7 +24514,9 @@ const CreateHeading = (depth) => {
 ;// ./components/Image/index.tsx
 
 const Image = (Props) => {
-    const { align = '', alt = '', border = false, caption, className = '', height = 'auto', src, title = '', width = 'auto', lazy = true, children, } = Props;
+    const { align = '', alt = '', border: borderProp = false, caption, className = '', height = 'auto', src, title = '', width = 'auto', lazy = true, children, } = Props;
+    // Normalize border: MDXish passes {false} as the string "false", not a boolean
+    const border = borderProp === true || borderProp === 'true';
     const [lightbox, setLightbox] = external_react_.useState(false);
     if (className === 'emoji') {
         return external_react_.createElement("img", { alt: alt, height: height, loading: lazy ? 'lazy' : 'eager', src: src, title: title, width: width });
@@ -26898,7 +26900,7 @@ function htmlExtension(all, extension) {
 
 ;// ./node_modules/micromark-util-character/index.js
 /**
- * @typedef {import('micromark-util-types').Code} Code
+ * @import {Code} from 'micromark-util-types'
  */
 
 /**
@@ -27124,7 +27126,9 @@ const unicodeWhitespace = regexCheck(/\s/);
  * Create a code check from a regex.
  *
  * @param {RegExp} regex
+ *   Expression.
  * @returns {(code: Code) => boolean}
+ *   Check.
  */
 function regexCheck(regex) {
   return check;
@@ -73302,6 +73306,59 @@ const isCalloutStructure = (node) => {
     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) => {
     if (!isCalloutStructure(node)) {
         // Only stringify empty blockquotes (no extractable text content)
@@ -73326,22 +73383,39 @@ const processBlockquote = (node, index, parent) => {
     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) {
-        const heading = startText.slice(match.length);
-        const empty = !heading.length && firstParagraph.children.length === 1;
+        // 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;
+        // Extract heading text after removing the icon prefix.
+        // Use `plain()` to handle complex markdown structures (bold, inline code, etc.)
+        const headingText = lib_plain(firstParagraph)
+            .toString()
+            .slice(match.length);
+        // Clean up the raw AST by removing the icon prefix from the first text node
+        removeIconPrefix(firstParagraph, match.length);
+        const empty = !headingText.length && firstParagraph.children.length === 1;
         const theme = themes[icon] || 'default';
-        const firstChild = findFirst(node.children[0]);
-        if (firstChild && 'value' in firstChild && typeof firstChild.value === 'string') {
-            firstChild.value = firstChild.value.slice(match.length);
-        }
-        if (heading) {
+        // Convert the first paragraph (first children of node) to a heading if it has content or was split
+        if (headingText || didSplit) {
             node.children[0] = wrapHeading(node);
-            // @note: We add to the offset/column the length of the unicode
-            // character that was stripped off, so that the start position of the
-            // heading/text matches where it actually starts.
+            // Adjust position to account for the stripped icon prefix
             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) {
+            node.children.splice(1, 0, {
+                type: 'paragraph',
+                children: bodyChildren,
+                position: {
+                    start: node.children[0].position.end,
+                    end: firstParagraphOriginalEnd,
+                },
+            });
+        }
         Object.assign(node, {
             type: NodeTypes.callout,
             data: {
@@ -90721,7 +90795,7 @@ const toAttributes = (object, keys = []) => {
         if (keys.length > 0 && !keys.includes(name))
             return;
         let value;
-        if (typeof v === 'undefined' || v === null || v === '') {
+        if (typeof v === 'undefined' || v === null || v === '' || v === false) {
             return;
         }
         else if (typeof v === 'string') {
@@ -106756,7 +106830,7 @@ const CUSTOM_PROP_BOUNDARIES = [
 /**
  * Tags that should be passed through and handled at runtime (not by the mdxish plugin)
  */
-const RUNTIME_COMPONENT_TAGS = new Set(['Variable', 'variable', 'rdme-pin']);
+const RUNTIME_COMPONENT_TAGS = new Set(['Variable', 'variable', 'html-block', 'rdme-pin']);
 /**
  * Standard HTML tags that should never be treated as custom components.
  * Uses the html-tags package, converted to a Set<string> for efficient lookups.
@@ -111869,6 +111943,10 @@ ${reformatHTML(html)}
 const plain_plain = (node) => node.value;
 /* harmony default export */ const compile_plain = (plain_plain);
 
+;// ./processor/compile/variable.ts
+const variable = (node) => `{user.${node.data?.hProperties?.name || ''}}`;
+/* harmony default export */ const compile_variable = (variable);
+
 ;// ./processor/compile/index.ts
 
 
@@ -111878,7 +111956,8 @@ const plain_plain = (node) => node.value;
 
 
 
-function compilers() {
+
+function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
     const handlers = {
@@ -111889,6 +111968,7 @@ function compilers() {
         [NodeTypes.glossary]: compile_compatibility,
         [NodeTypes.htmlBlock]: html_block,
         [NodeTypes.reusableContent]: compile_compatibility,
+        ...(mdxish && { [NodeTypes.variable]: compile_variable }),
         embed: compile_compatibility,
         escape: compile_compatibility,
         figure: compile_compatibility,
@@ -111899,6 +111979,9 @@ function compilers() {
     };
     toMarkdownExtensions.push({ extensions: [{ handlers }] });
 }
+function mdxishCompilers() {
+    return compilers.call(this, true);
+}
 /* harmony default export */ const processor_compile = (compilers);
 
 ;// ./processor/transform/escape-pipes-in-tables.ts
@@ -113609,13 +113692,17 @@ const htmlBlockHandler = (_state, node) => {
 const embedHandler = (state, node) => {
     // Assert to get the minimum properties we need
     const { data } = node;
+    // Magic block embeds (hName === 'embed-block') render as Embed component
+    // which doesn't use children - it renders based on props only
+    const isMagicBlockEmbed = data?.hName === NodeTypes.embedBlock;
     return {
         type: 'element',
         // To differentiate between regular embeds and magic block embeds,
         // magic block embeds have a certain hName
-        tagName: data?.hName === NodeTypes.embedBlock ? 'Embed' : 'embed',
+        tagName: isMagicBlockEmbed ? 'Embed' : 'embed',
         properties: data?.hProperties,
-        children: state.all(node),
+        // Don't include children for magic block embeds - Embed component renders based on props
+        children: isMagicBlockEmbed ? [] : state.all(node),
     };
 };
 const mdxComponentHandlers = {
@@ -113628,7 +113715,102 @@ const mdxComponentHandlers = {
     [NodeTypes.htmlBlock]: htmlBlockHandler,
 };
 
+;// ./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') {
@@ -113695,52 +113877,6 @@ function protectHTMLBlockContent(content) {
         return `${openTag}${HTML_BLOCK_CONTENT_START}${encoded}${HTML_BLOCK_CONTENT_END}${closeTag}`;
     });
 }
-/**
- * Replaces code blocks and inline code with placeholders to protect them from JSX processing.
- *
- * @param content
- * @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(/`[^`]+`/g, match => {
-        const index = inlineCode.length;
-        inlineCode.push(match);
-        return `___INLINE_CODE_${index}___`;
-    });
-    return { protectedCode: { codeBlocks, inlineCode }, protectedContent };
-}
 /**
  * Removes JSX-style comments (e.g., { /* comment *\/ }) from content.
  *
@@ -113783,16 +113919,6 @@ function extractBalancedBraces(content, start) {
         return null;
     return { content: content.slice(start, pos - 1), end: pos };
 }
-function restoreInlineCode(content, protectedCode) {
-    return content.replace(/___INLINE_CODE_(\d+)___/g, (_m, idx) => {
-        return protectedCode.inlineCode[parseInt(idx, 10)];
-    });
-}
-function restoreCodeBlocks(content, protectedCode) {
-    return content.replace(/___CODE_BLOCK_(\d+)___/g, (_m, idx) => {
-        return protectedCode.codeBlocks[parseInt(idx, 10)];
-    });
-}
 /**
  * Escapes unbalanced braces in content to prevent MDX expression parsing errors.
  * Handles: already-escaped braces, string literals inside expressions, nested balanced braces.
@@ -113923,28 +114049,6 @@ function evaluateAttributeExpressions(content, context, protectedCode) {
     result += content.slice(lastEnd);
     return result;
 }
-/**
- * Restores code blocks and inline code by replacing placeholders with original content.
- *
- * @param content
- * @param protectedCode
- * @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 restoreProtectedCodes(content, protectedCode) {
-    let restored = restoreCodeBlocks(content, protectedCode);
-    restored = restoreInlineCode(restored, protectedCode);
-    return restored;
-}
 /**
  * Preprocesses JSX-like expressions in markdown before parsing.
  * Inline expressions are handled separately; attribute expressions are processed here.
@@ -113967,7 +114071,7 @@ function preprocessJSXExpressions(content, context = {}) {
     // Step 4: Escape unbalanced braces to prevent MDX expression parsing errors
     processed = escapeUnbalancedBraces(processed);
     // Step 5: Restore protected code blocks
-    processed = restoreProtectedCodes(processed, protectedCode);
+    processed = restoreCodeBlocks(processed, protectedCode);
     return processed;
 }
 
@@ -114022,360 +114126,407 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
 };
 /* harmony default export */ const evaluate_expressions = (evaluateExpressions);
 
-;// ./processor/transform/mdxish/mdxish-html-blocks.ts
-
-
-
+;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
 
-/**
- * Decodes HTMLBlock content that was protected during preprocessing.
- * Content is wrapped in <!--RDMX_HTMLBLOCK:base64:RDMX_HTMLBLOCK-->
- */
-function decodeProtectedContent(content) {
-    // Escape special regex characters in the markers
-    const startEscaped = HTML_BLOCK_CONTENT_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const endEscaped = HTML_BLOCK_CONTENT_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const markerRegex = new RegExp(`${startEscaped}([A-Za-z0-9+/=]+)${endEscaped}`, 'g');
-    return content.replace(markerRegex, (_match, encoded) => {
-        try {
-            return base64Decode(encoded);
+// Marker patterns for multi-node emphasis detection
+const MARKER_PATTERNS = [
+    { isBold: true, marker: '**' },
+    { isBold: true, marker: '__' },
+    { isBold: false, marker: '*' },
+    { isBold: false, marker: '_' },
+];
+// Patterns to detect for bold (** and __) and italic (* and _) syntax:
+// Bold: ** text**, **text **, word** text**, ** text **
+// Italic: * text*, *text *, word* text*, * text *
+// Same patterns for underscore variants
+// We use separate patterns for each marker type to allow this flexibility.
+// Pattern for ** bold **
+// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
+// trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
+const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
+// Pattern for __ bold __
+const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:[^_\n]|_(?!_))+?)(\s*)\2|((?:[^_\n]|_(?!_))+?)(\s+)\2)(\S|$)?/g;
+// Pattern for * italic *
+const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
+// Pattern for _ italic _
+const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+([^_\n]+?)(\s*)\2|([^_\n]+?)(\s+)\2)(\S|$)?/g;
+// CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
+// Pattern for intraword _word_ in words like hello_world_
+const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
+// Pattern for intraword __word__ in words like hello__world__
+const intrawordUnderscoreBoldRegex = /(\w)__([a-zA-Z0-9]+)__(?![\w_])/g;
+// Pattern for intraword *word* in words like hello*world*
+const intrawordAsteriskItalicRegex = /(\w)\*(?!\*)([a-zA-Z0-9]+)\*(?![\w*])/g;
+// Pattern for intraword **word** in words like hello**world**
+const intrawordAsteriskBoldRegex = /(\w)\*\*([a-zA-Z0-9]+)\*\*(?![\w*])/g;
+/**
+ * Finds opening emphasis marker in a text value.
+ * Returns marker info if found, null otherwise.
+ */
+function findOpeningMarker(text) {
+    const results = MARKER_PATTERNS.map(({ isBold, marker }) => {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        if (text.startsWith(marker) && text.length > marker.length) {
+            return { isBold, marker, textAfter: text.slice(marker.length), textBefore: '' };
         }
-        catch {
-            return encoded;
+        const idx = text.indexOf(marker);
+        if (idx > 0 && !/\s/.test(text[idx - 1])) {
+            if (marker === '*' && text.slice(idx).startsWith('**'))
+                return null;
+            if (marker === '_' && text.slice(idx).startsWith('__'))
+                return null;
+            const after = text.slice(idx + marker.length);
+            if (after.length > 0) {
+                return { isBold, marker, textAfter: after, textBefore: text.slice(0, idx) };
+            }
         }
+        return null;
     });
+    return results.find(r => r !== null) ?? null;
 }
 /**
- * Collects text content from a node and its children recursively
+ * Finds the end/closing marker in a text node for multi-node emphasis.
  */
-function collectTextContent(node) {
-    const parts = [];
-    if (node.type === 'text' && node.value) {
-        parts.push(node.value);
-    }
-    else if (node.type === 'html' && node.value) {
-        parts.push(node.value);
-    }
-    else if (node.type === 'inlineCode' && node.value) {
-        parts.push(node.value);
-    }
-    else if (node.type === 'code' && node.value) {
-        // Reconstruct code fence syntax (markdown parser consumes opening ```)
-        const lang = node.lang || '';
-        const fence = `\`\`\`${lang ? `${lang}\n` : ''}`;
-        parts.push(fence);
-        parts.push(node.value);
-        // Add newline before closing fence if missing
-        const closingFence = node.value.endsWith('\n') ? '```' : '\n```';
-        parts.push(closingFence);
+function findEndMarker(text, marker) {
+    const spacePattern = ` ${marker}`;
+    const spaceIdx = text.indexOf(spacePattern);
+    if (spaceIdx >= 0) {
+        if (marker === '*' && text.slice(spaceIdx + 1).startsWith('**'))
+            return null;
+        if (marker === '_' && text.slice(spaceIdx + 1).startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(spaceIdx + spacePattern.length),
+            textBefore: text.slice(0, spaceIdx),
+        };
     }
-    else if (node.children && Array.isArray(node.children)) {
-        node.children.forEach(child => {
-            if (typeof child === 'object' && child !== null) {
-                parts.push(collectTextContent(child));
-            }
-        });
+    if (text.startsWith(marker)) {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(marker.length),
+            textBefore: '',
+        };
     }
-    return parts.join('');
+    return null;
 }
 /**
- * Extracts boolean attribute from HTML tag. Handles JSX (safeMode={true}) and string (safeMode="true") syntax.
- * Returns "true"/"false" string to survive rehypeRaw serialization.
+ * Scan children for an opening emphasis marker in a text node.
  */
-function extractBooleanAttr(attrs, name) {
-    // Try JSX syntax: name={true|false}
-    const jsxMatch = attrs.match(new RegExp(`${name}=\\{(true|false)\\}`));
-    if (jsxMatch) {
-        return jsxMatch[1];
-    }
-    // Try string syntax: name="true"|true
-    const stringMatch = attrs.match(new RegExp(`${name}="?(true|false)"?`));
-    if (stringMatch) {
-        return stringMatch[1];
-    }
-    return undefined;
+function findOpeningInChildren(children) {
+    let result = null;
+    children.some((child, idx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findOpeningMarker(child.value);
+        if (found) {
+            result = { idx, opening: found };
+            return true;
+        }
+        return false;
+    });
+    return result;
 }
 /**
- * Extracts runScripts attribute from HTML tag. Returns boolean for "true"/"false", string for other values, or undefined if not found.
+ * Scan children (after openingIdx) for a closing emphasis marker.
  */
-function extractRunScriptsAttr(attrs) {
-    const runScriptsMatch = attrs.match(/runScripts="?([^">\s]+)"?/);
-    if (!runScriptsMatch) {
-        return undefined;
-    }
-    const value = runScriptsMatch[1];
-    if (value === 'true') {
-        return true;
-    }
-    if (value === 'false') {
+function findClosingInChildren(children, openingIdx, marker) {
+    let result = null;
+    children.slice(openingIdx + 1).some((child, relativeIdx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findEndMarker(child.value, marker);
+        if (found) {
+            result = { closingIdx: openingIdx + 1 + relativeIdx, closing: found };
+            return true;
+        }
         return false;
-    }
-    return value;
+    });
+    return result;
 }
 /**
- * Creates an HTMLBlock node from HTML string and optional attributes
+ * Build the replacement nodes for a matched emphasis pair.
  */
-function createHTMLBlockNode(htmlString, position, runScripts, safeMode) {
-    return {
-        position,
-        children: [{ type: 'text', value: htmlString }],
-        type: NodeTypes.htmlBlock,
-        data: {
-            hName: 'html-block',
-            hProperties: {
-                html: htmlString,
-                ...(runScripts !== undefined && { runScripts }),
-                ...(safeMode !== undefined && { safeMode }),
-            },
-        },
-    };
+function buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx }) {
+    const newNodes = [];
+    if (opening.textBefore) {
+        newNodes.push({ type: 'text', value: `${opening.textBefore} ` });
+    }
+    const emphasisChildren = [];
+    const openingText = opening.textAfter.replace(/^\s+/, '');
+    if (openingText) {
+        emphasisChildren.push({ type: 'text', value: openingText });
+    }
+    container.children.slice(openingIdx + 1, closingIdx).forEach(child => {
+        emphasisChildren.push(child);
+    });
+    const closingText = closing.textBefore.replace(/\s+$/, '');
+    if (closingText) {
+        emphasisChildren.push({ type: 'text', value: closingText });
+    }
+    if (emphasisChildren.length > 0) {
+        const emphasisNode = opening.isBold
+            ? { type: 'strong', children: emphasisChildren }
+            : { type: 'emphasis', children: emphasisChildren };
+        newNodes.push(emphasisNode);
+    }
+    if (closing.textAfter) {
+        newNodes.push({ type: 'text', value: closing.textAfter });
+    }
+    return newNodes;
 }
 /**
- * Checks for opening tag only (for split detection)
+ * Find and transform one multi-node emphasis pair in the container.
+ * Returns true if a pair was found and transformed, false otherwise.
  */
-function hasOpeningTagOnly(node) {
-    let hasOpening = false;
-    let hasClosed = false;
-    let attrs = '';
-    const check = (n) => {
-        if (n.type === 'html' && n.value) {
-            if (n.value === '<HTMLBlock>') {
-                hasOpening = true;
-            }
-            else {
-                const match = n.value.match(/^<HTMLBlock(\s[^>]*)?>$/);
-                if (match) {
-                    hasOpening = true;
-                    attrs = match[1] || '';
-                }
-            }
-            if (n.value === '</HTMLBlock>' || n.value.includes('</HTMLBlock>')) {
-                hasClosed = true;
-            }
-        }
-        if (n.children && Array.isArray(n.children)) {
-            n.children.forEach(child => {
-                check(child);
-            });
-        }
-    };
-    check(node);
-    // Return true only if opening without closing (split case)
-    return { attrs, found: hasOpening && !hasClosed };
+function processOneEmphasisPair(container) {
+    const openingResult = findOpeningInChildren(container.children);
+    if (!openingResult)
+        return false;
+    const { idx: openingIdx, opening } = openingResult;
+    const closingResult = findClosingInChildren(container.children, openingIdx, opening.marker);
+    if (!closingResult)
+        return false;
+    const { closingIdx, closing } = closingResult;
+    const newNodes = buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx });
+    const deleteCount = closingIdx - openingIdx + 1;
+    container.children.splice(openingIdx, deleteCount, ...newNodes);
+    return true;
 }
 /**
- * Checks if a node contains an HTMLBlock closing tag
+ * Handle malformed emphasis that spans multiple AST nodes.
+ * E.g., "**bold [link](url)**" where markers are in different text nodes.
  */
-function hasClosingTag(node) {
-    if (node.type === 'html' && node.value) {
-        if (node.value === '</HTMLBlock>' || node.value.includes('</HTMLBlock>'))
-            return true;
-    }
-    if (node.children && Array.isArray(node.children)) {
-        return node.children.some(child => hasClosingTag(child));
-    }
-    return false;
+function visitMultiNodeEmphasis(tree) {
+    const containerTypes = ['paragraph', 'heading', 'tableCell', 'listItem', 'blockquote'];
+    visit(tree, node => {
+        if (!containerTypes.includes(node.type))
+            return;
+        if (!('children' in node) || !Array.isArray(node.children))
+            return;
+        const container = node;
+        let foundPair = true;
+        while (foundPair) {
+            foundPair = processOneEmphasisPair(container);
+        }
+    });
 }
 /**
- * Transforms HTMLBlock MDX JSX to html-block nodes. Handles <HTMLBlock>{`...`}</HTMLBlock> syntax.
+ * A remark plugin that normalizes malformed bold and italic markers in text nodes.
+ * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
+ * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
+ * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
+ *
+ * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
+ * Also supports snake_case content like `** some_snake_case**`.
+ *
+ * This runs after remark-parse, which (in v11+) is strict and doesn't parse
+ * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
  */
-const mdxishHtmlBlocks = () => tree => {
-    // Handle HTMLBlock split across root children (caused by newlines)
-    visit(tree, 'root', (root) => {
-        const children = root.children;
-        let i = 0;
-        while (i < children.length) {
-            const child = children[i];
-            const { attrs, found: hasOpening } = hasOpeningTagOnly(child);
-            if (hasOpening) {
-                // Find closing tag in subsequent siblings
-                let closingIdx = -1;
-                for (let j = i + 1; j < children.length; j += 1) {
-                    if (hasClosingTag(children[j])) {
-                        closingIdx = j;
-                        break;
-                    }
+const normalizeEmphasisAST = () => (tree) => {
+    visit(tree, 'text', function visitor(node, index, parent) {
+        if (index === undefined || !parent)
+            return undefined;
+        // Skip if inside code blocks or inline code
+        if (parent.type === 'inlineCode' || parent.type === 'code') {
+            return undefined;
+        }
+        const text = node.value;
+        const allMatches = [];
+        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '**', match });
+        });
+        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '__', match });
+        });
+        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '*', match });
+        });
+        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '__', match });
+        });
+        [...text.matchAll(intrawordAsteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '*', match });
+        });
+        [...text.matchAll(intrawordAsteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '**', match });
+        });
+        if (allMatches.length === 0)
+            return undefined;
+        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
+        const filteredMatches = [];
+        let lastEnd = 0;
+        allMatches.forEach(info => {
+            const start = info.match.index ?? 0;
+            const end = start + info.match[0].length;
+            if (start >= lastEnd) {
+                filteredMatches.push(info);
+                lastEnd = end;
+            }
+        });
+        if (filteredMatches.length === 0)
+            return undefined;
+        const parts = [];
+        let lastIndex = 0;
+        filteredMatches.forEach(({ isBold, isIntraword, marker, match }) => {
+            const matchIndex = match.index ?? 0;
+            const fullMatch = match[0];
+            if (isIntraword) {
+                // handles cases like hello_world_ where we only want to italicize 'world'
+                const charBefore = match[1] || ''; // e.g., "l" in "hello_world_"
+                const content = match[2]; // e.g., "world"
+                const combinedBefore = text.slice(lastIndex, matchIndex) + charBefore;
+                if (combinedBefore) {
+                    parts.push({ type: 'text', value: combinedBefore });
                 }
-                if (closingIdx !== -1) {
-                    // Collect inner content between tags
-                    const contentParts = [];
-                    for (let j = i; j <= closingIdx; j += 1) {
-                        const node = children[j];
-                        contentParts.push(collectTextContent(node));
-                    }
-                    // Remove the opening/closing tags and template literal syntax from content
-                    let content = contentParts.join('');
-                    content = content.replace(/^<HTMLBlock[^>]*>\s*\{?\s*`?/, '').replace(/`?\s*\}?\s*<\/HTMLBlock>$/, '');
-                    // Decode protected content that was base64 encoded during preprocessing
-                    content = decodeProtectedContent(content);
-                    const htmlString = formatHtmlForMdxish(content);
-                    const runScripts = extractRunScriptsAttr(attrs);
-                    const safeMode = extractBooleanAttr(attrs, 'safeMode');
-                    // Replace range with single HTMLBlock node
-                    const mdNode = createHTMLBlockNode(htmlString, children[i].position, runScripts, safeMode);
-                    root.children.splice(i, closingIdx - i + 1, mdNode);
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
                 }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                lastIndex = matchIndex + fullMatch.length;
+                return;
             }
-            i += 1;
-        }
-    });
-    // Handle HTMLBlock parsed as HTML elements (when template literal contains block-level HTML tags)
-    visit(tree, 'html', (node, index, parent) => {
-        if (!parent || index === undefined)
-            return;
-        const value = node.value;
-        if (!value)
-            return;
-        // Case 1: Full HTMLBlock in single node
-        const fullMatch = value.match(/^<HTMLBlock(\s[^>]*)?>([\s\S]*)<\/HTMLBlock>$/);
-        if (fullMatch) {
-            const attrs = fullMatch[1] || '';
-            let content = fullMatch[2] || '';
-            // Remove template literal syntax if present: {`...`}
-            content = content.replace(/^\s*\{\s*`/, '').replace(/`\s*\}\s*$/, '');
-            // Decode protected content that was base64 encoded during preprocessing
-            content = decodeProtectedContent(content);
-            const htmlString = formatHtmlForMdxish(content);
-            const runScripts = extractRunScriptsAttr(attrs);
-            const safeMode = extractBooleanAttr(attrs, 'safeMode');
-            parent.children[index] = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
-            return;
-        }
-        // Case 2: Opening tag only (split by blank lines)
-        if (value === '<HTMLBlock>' || value.match(/^<HTMLBlock\s[^>]*>$/)) {
-            const siblings = parent.children;
-            let closingIdx = -1;
-            // Find closing tag in siblings
-            for (let i = index + 1; i < siblings.length; i += 1) {
-                const sibling = siblings[i];
-                if (sibling.type === 'html') {
-                    const sibVal = sibling.value;
-                    if (sibVal === '</HTMLBlock>' || sibVal?.includes('</HTMLBlock>')) {
-                        closingIdx = i;
-                        break;
-                    }
+            if (matchIndex > lastIndex) {
+                const beforeText = text.slice(lastIndex, matchIndex);
+                if (beforeText) {
+                    parts.push({ type: 'text', value: beforeText });
                 }
             }
-            if (closingIdx === -1)
-                return;
-            // Collect content between tags, skipping template literal delimiters
-            const contentParts = [];
-            for (let i = index + 1; i < closingIdx; i += 1) {
-                const sibling = siblings[i];
-                // Skip template literal delimiters
-                if (sibling.type === 'text') {
-                    const textVal = sibling.value;
-                    if (textVal === '{' || textVal === '}' || textVal === '{`' || textVal === '`}') {
-                        // eslint-disable-next-line no-continue
-                        continue;
-                    }
-                }
-                contentParts.push(collectTextContent(sibling));
+            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
+            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
+            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
+            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
+            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
+            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
+            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
+            const afterChar = match[7]; // Character after closing markers (if any)
+            const markerPos = fullMatch.indexOf(marker);
+            const spacesBeforeMarkers = wordBefore
+                ? fullMatch.slice(wordBefore.length, markerPos)
+                : fullMatch.slice(0, markerPos);
+            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
+            if (wordBefore) {
+                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
+                parts.push({ type: 'text', value: wordBefore + spacing });
             }
-            // Decode protected content that was base64 encoded during preprocessing
-            const decodedContent = decodeProtectedContent(contentParts.join(''));
-            const htmlString = formatHtmlForMdxish(decodedContent);
-            const runScripts = extractRunScriptsAttr(value);
-            const safeMode = extractBooleanAttr(value, 'safeMode');
-            // Replace opening tag with HTMLBlock node, remove consumed siblings
-            parent.children[index] = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
-            parent.children.splice(index + 1, closingIdx - index);
-        }
-    });
-    // Handle HTMLBlock inside paragraphs (parsed as inline elements)
-    visit(tree, 'paragraph', (node, index, parent) => {
-        if (!parent || index === undefined)
-            return;
-        const children = node.children || [];
-        let htmlBlockStartIdx = -1;
-        let htmlBlockEndIdx = -1;
-        let templateLiteralStartIdx = -1;
-        let templateLiteralEndIdx = -1;
-        for (let i = 0; i < children.length; i += 1) {
-            const child = children[i];
-            if (child.type === 'html' && typeof child.value === 'string') {
-                const value = child.value;
-                if (value === '<HTMLBlock>' || value.match(/^<HTMLBlock\s[^>]*>$/)) {
-                    htmlBlockStartIdx = i;
-                }
-                else if (value === '</HTMLBlock>') {
-                    htmlBlockEndIdx = i;
-                }
+            else if (spacesBeforeMarkers) {
+                parts.push({ type: 'text', value: spacesBeforeMarkers });
             }
-            // Find opening brace after HTMLBlock start
-            if (htmlBlockStartIdx !== -1 && templateLiteralStartIdx === -1 && child.type === 'text') {
-                const value = child.value;
-                if (value === '{') {
-                    templateLiteralStartIdx = i;
+            if (content) {
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
                 }
-            }
-            // Find closing brace before HTMLBlock end
-            if (htmlBlockStartIdx !== -1 && htmlBlockEndIdx === -1 && child.type === 'text') {
-                const value = child.value;
-                if (value === '}') {
-                    templateLiteralEndIdx = i;
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
                 }
             }
-        }
-        if (htmlBlockStartIdx !== -1 &&
-            htmlBlockEndIdx !== -1 &&
-            templateLiteralStartIdx !== -1 &&
-            templateLiteralEndIdx !== -1 &&
-            templateLiteralStartIdx < templateLiteralEndIdx) {
-            const openingTag = children[htmlBlockStartIdx];
-            // Collect content between braces (handles code blocks)
-            const templateContent = [];
-            for (let i = templateLiteralStartIdx + 1; i < templateLiteralEndIdx; i += 1) {
-                const child = children[i];
-                templateContent.push(collectTextContent(child));
+            if (afterChar) {
+                const prefix = trailingSpace ? ' ' : '';
+                parts.push({ type: 'text', value: prefix + afterChar });
+            }
+            lastIndex = matchIndex + fullMatch.length;
+        });
+        if (lastIndex < text.length) {
+            const remainingText = text.slice(lastIndex);
+            if (remainingText) {
+                parts.push({ type: 'text', value: remainingText });
             }
-            // Decode protected content that was base64 encoded during preprocessing
-            const decodedContent = decodeProtectedContent(templateContent.join(''));
-            const htmlString = formatHtmlForMdxish(decodedContent);
-            const runScripts = openingTag.value ? extractRunScriptsAttr(openingTag.value) : undefined;
-            const safeMode = openingTag.value ? extractBooleanAttr(openingTag.value, 'safeMode') : undefined;
-            const mdNode = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
-            parent.children[index] = mdNode;
         }
-    });
-    // Ensure html-block nodes have HTML in children as text node
-    visit(tree, 'html-block', (node) => {
-        const html = node.data?.hProperties?.html;
-        if (html &&
-            (!node.children ||
-                node.children.length === 0 ||
-                (node.children.length === 1 && node.children[0].type === 'text' && node.children[0].value !== html))) {
-            node.children = [
-                {
-                    type: 'text',
-                    value: html,
-                },
-            ];
+        if (parts.length > 0) {
+            parent.children.splice(index, 1, ...parts);
+            return [SKIP, index + parts.length];
         }
+        return undefined;
     });
+    // Handle malformed emphasis spanning multiple nodes (e.g., **text [link](url) **)
+    visitMultiNodeEmphasis(tree);
     return tree;
 };
-/* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
+/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
+
+;// ./processor/transform/mdxish/magic-blocks/placeholder.ts
+const EMPTY_IMAGE_PLACEHOLDER = {
+    type: 'image',
+    url: '',
+    alt: '',
+    title: '',
+    data: { hProperties: {} },
+};
+const EMPTY_EMBED_PLACEHOLDER = {
+    type: 'embed',
+    children: [{ type: 'link', url: '', title: '', children: [{ type: 'text', value: '' }] }],
+    data: { hName: 'embed-block', hProperties: { url: '', href: '', title: '' } },
+};
+const EMPTY_RECIPE_PLACEHOLDER = {
+    type: 'mdxJsxFlowElement',
+    name: 'Recipe',
+    attributes: [],
+    children: [],
+};
+const EMPTY_CALLOUT_PLACEHOLDER = {
+    type: 'mdxJsxFlowElement',
+    name: 'Callout',
+    attributes: [
+        { type: 'mdxJsxAttribute', name: 'icon', value: '📘' },
+        { type: 'mdxJsxAttribute', name: 'theme', value: 'info' },
+        { type: 'mdxJsxAttribute', name: 'type', value: 'info' },
+        { type: 'mdxJsxAttribute', name: 'empty', value: 'true' },
+    ],
+    children: [{ type: 'heading', depth: 3, children: [{ type: 'text', value: '' }] }],
+};
+const EMPTY_TABLE_PLACEHOLDER = {
+    type: 'table',
+    align: ['left', 'left'],
+    children: [
+        { type: 'tableRow', children: [{ type: 'tableCell', children: [{ type: 'text', value: '' }] }] },
+        { type: 'tableRow', children: [{ type: 'tableCell', children: [{ type: 'text', value: '' }] }] },
+    ],
+};
+const EMPTY_CODE_PLACEHOLDER = {
+    type: 'code',
+    value: '',
+    lang: null,
+    meta: null,
+};
+
+;// ./processor/transform/mdxish/magic-blocks/magic-block-transformer.ts
+
 
-;// ./processor/transform/mdxish/mdxish-magic-blocks.ts
 
 
 
 
 
 /**
- * Matches legacy magic block syntax: [block:TYPE]...JSON...[/block]
- * Group 1: block type (e.g., "image", "code", "callout")
- * Group 2: JSON content between the tags
- * Taken from the v6 branch
- */
-const RGXP = /^\s*\[block:([^\]]*)\]([^]+?)\[\/block\]/;
-/**
- * Wraps a node in a "pinned" container if sidebar: true is set in the JSON.
- * Pinned blocks are displayed in a sidebar/floating position in the UI.
+ * Wraps a node in a "pinned" container if sidebar: true is set.
  */
-const wrapPinnedBlocks = (node, json) => {
-    if (!json.sidebar)
+const wrapPinnedBlocks = (node, data) => {
+    if (!data.sidebar)
         return node;
     return {
         children: [node],
@@ -114391,34 +114542,24 @@ const imgSizeValues = {
     original: 'auto',
 };
 /**
- * Proxy that resolves image sizing values:
- * - "full" → "100%", "original" → "auto" (from imgSizeValues)
- * - Pure numbers like "50" → "50%" (percentage)
- * - Anything else passes through as-is (e.g., "200px")
+ * Proxy that resolves image sizing values.
  */
 const imgWidthBySize = new Proxy(imgSizeValues, {
     get: (widths, size) => (size?.match(/^\d+$/) ? `${size}%` : size in widths ? widths[size] : size),
 });
-// Simple text to inline nodes (just returns text node - no markdown parsing)
 const textToInline = (text) => [{ type: 'text', value: text }];
-// Simple text to block nodes (wraps in paragraph)
 const textToBlock = (text) => [{ children: textToInline(text), type: 'paragraph' }];
 /** Parses markdown and html to markdown nodes */
-const contentParser = unified().use(remarkParse).use(remarkGfm);
-// Table cells may contain html or markdown content, so we need to parse it accordingly instead of keeping it as raw text
+const contentParser = unified().use(remarkParse).use(remarkGfm).use(normalize_malformed_md_syntax);
 const parseTableCell = (text) => {
     if (!text.trim())
         return [{ type: 'text', value: '' }];
     const tree = contentParser.runSync(contentParser.parse(text));
-    // If there are multiple block-level nodes, keep them as-is to preserve the document structure and spacing
     if (tree.children.length > 1) {
         return tree.children;
     }
-    return tree.children.flatMap(n => 
-    // This unwraps the extra p node that might appear & wrapping the content
-    n.type === 'paragraph' && 'children' in n ? n.children : [n]);
+    return tree.children.flatMap(n => n.type === 'paragraph' && 'children' in n ? n.children : [n]);
 };
-// Parse markdown/HTML into block-level nodes (preserves paragraphs, headings, lists, etc.)
 const parseBlock = (text) => {
     if (!text.trim())
         return [{ type: 'paragraph', children: [{ type: 'text', value: '' }] }];
@@ -114426,44 +114567,43 @@ const parseBlock = (text) => {
     return tree.children;
 };
 /**
- * Parse a magic block string and return MDAST nodes.
- *
- * @param raw - The raw magic block string including [block:TYPE] and [/block] tags
- * @param options - Parsing options for compatibility and error handling
- * @returns Array of MDAST nodes representing the parsed block
- */
-function parseMagicBlock(raw, options = {}) {
-    const { alwaysThrow = false, compatibilityMode = false, safeMode = false } = options;
-    const matchResult = RGXP.exec(raw);
-    if (!matchResult)
-        return [];
-    const [, rawType, jsonStr] = matchResult;
-    const type = rawType?.trim();
-    if (!type)
-        return [];
-    let json;
-    try {
-        json = JSON.parse(jsonStr);
+ * Transform a magicBlock node into final MDAST nodes.
+ */
+function transformMagicBlock(blockType, data, rawValue, options = {}) {
+    const { compatibilityMode = false, safeMode = false } = options;
+    // Handle empty data by returning placeholder nodes for known block types
+    // This allows the editor to show appropriate placeholder UI instead of nothing
+    if (Object.keys(data).length < 1) {
+        switch (blockType) {
+            case 'image':
+                return [EMPTY_IMAGE_PLACEHOLDER];
+            case 'embed':
+                return [EMPTY_EMBED_PLACEHOLDER];
+            case 'code':
+                return [EMPTY_CODE_PLACEHOLDER];
+            case 'callout':
+                return [EMPTY_CALLOUT_PLACEHOLDER];
+            case 'parameters':
+            case 'table':
+                return [EMPTY_TABLE_PLACEHOLDER];
+            case 'recipe':
+            case 'tutorial-tile':
+                return [EMPTY_RECIPE_PLACEHOLDER];
+            default:
+                return [{ type: 'paragraph', children: [{ type: 'text', value: rawValue }] }];
+        }
     }
-    catch (err) {
-        // eslint-disable-next-line no-console
-        console.error('Invalid Magic Block JSON:', err);
-        if (alwaysThrow)
-            throw new Error('Invalid Magic Block JSON');
-        return [];
-    }
-    if (Object.keys(json).length < 1)
-        return [];
-    // Each case handles a different magic block type and returns appropriate MDAST nodes
-    switch (type) {
-        // Code blocks: single code block or tabbed code blocks (multiple languages)
+    switch (blockType) {
         case 'code': {
-            const codeJson = json;
+            const codeJson = data;
+            if (!codeJson.codes || !Array.isArray(codeJson.codes)) {
+                return [wrapPinnedBlocks(EMPTY_CODE_PLACEHOLDER, data)];
+            }
             const children = codeJson.codes.map(obj => ({
                 className: 'tab-panel',
                 data: { hName: 'code', hProperties: { lang: obj.language, meta: obj.name || null } },
                 lang: obj.language,
-                meta: obj.name || null, // Tab name shown in the UI
+                meta: obj.name || null,
                 type: 'code',
                 value: obj.code.trim(),
             }));
@@ -114473,31 +114613,31 @@ function parseMagicBlock(raw, options = {}) {
                 if (!children[0].value)
                     return [];
                 if (!(children[0].meta || children[0].lang))
-                    return [wrapPinnedBlocks(children[0], json)];
+                    return [wrapPinnedBlocks(children[0], data)];
             }
             // Multiple code blocks or a single code block with a tab name (meta or language) renders as a code tabs block
-            return [wrapPinnedBlocks({ children, className: 'tabs', data: { hName: 'CodeTabs' }, type: 'code-tabs' }, json)];
+            return [wrapPinnedBlocks({ children, className: 'tabs', data: { hName: 'CodeTabs' }, type: 'code-tabs' }, data)];
         }
-        // API header: renders as a heading element (h1-h6)
         case 'api-header': {
-            const headerJson = json;
-            // In compatibility mode, default to h1; otherwise h2
+            const headerJson = data;
             const depth = headerJson.level || (compatibilityMode ? 1 : 2);
             return [
                 wrapPinnedBlocks({
                     children: 'title' in headerJson ? textToInline(headerJson.title || '') : [],
                     depth,
                     type: 'heading',
-                }, json),
+                }, data),
             ];
         }
-        // Image block: renders as <img> or <figure> with caption
         case 'image': {
-            const imageJson = json;
+            const imageJson = data;
+            if (!imageJson.images || !Array.isArray(imageJson.images)) {
+                return [wrapPinnedBlocks(EMPTY_IMAGE_PLACEHOLDER, data)];
+            }
             const imgData = imageJson.images.find(i => i.image);
-            if (!imgData?.image)
-                return [];
-            // Image array format: [url, title?, alt?]
+            if (!imgData?.image) {
+                return [wrapPinnedBlocks(EMPTY_IMAGE_PLACEHOLDER, data)];
+            }
             const [url, title, alt] = imgData.image;
             const block = {
                 alt: alt || imgData.caption || '',
@@ -114512,57 +114652,66 @@ function parseMagicBlock(raw, options = {}) {
                 type: 'image',
                 url,
             };
-            // Wrap in <figure> if caption is present
             const img = imgData.caption
                 ? {
                     children: [
                         block,
-                        { children: textToBlock(imgData.caption), data: { hName: 'figcaption' }, type: 'figcaption' },
+                        { children: parseBlock(imgData.caption), data: { hName: 'figcaption' }, type: 'figcaption' },
                     ],
                     data: { hName: 'figure' },
                     type: 'figure',
                     url,
                 }
                 : block;
-            return [wrapPinnedBlocks(img, json)];
+            return [wrapPinnedBlocks(img, data)];
         }
-        // Callout: info/warning/error boxes with icon and theme
         case 'callout': {
-            const calloutJson = json;
-            // Preset callout types map to [icon, theme] tuples
+            const calloutJson = data;
             const types = {
                 danger: ['❗️', 'error'],
                 info: ['📘', 'info'],
                 success: ['👍', 'okay'],
                 warning: ['🚧', 'warn'],
             };
-            // Resolve type to [icon, theme] - use preset if available, otherwise custom
             const resolvedType = typeof calloutJson.type === 'string' && calloutJson.type in types
                 ? types[calloutJson.type]
                 : [calloutJson.icon || '👍', typeof calloutJson.type === 'string' ? calloutJson.type : 'default'];
             const [icon, theme] = Array.isArray(resolvedType) ? resolvedType : ['👍', 'default'];
             if (!(calloutJson.title || calloutJson.body))
                 return [];
-            // Parses html & markdown content
-            const titleBlocks = parseBlock(calloutJson.title || '');
-            const bodyBlocks = parseBlock(calloutJson.body || '');
+            const hasTitle = !!calloutJson.title?.trim();
+            const hasBody = !!calloutJson.body?.trim();
+            const empty = !hasTitle;
             const children = [];
-            if (titleBlocks.length > 0 && titleBlocks[0].type === 'paragraph') {
-                const firstTitle = titleBlocks[0];
-                const heading = {
+            if (hasTitle) {
+                const titleBlocks = parseBlock(calloutJson.title || '');
+                if (titleBlocks.length > 0 && titleBlocks[0].type === 'paragraph') {
+                    const firstTitle = titleBlocks[0];
+                    const heading = {
+                        type: 'heading',
+                        depth: 3,
+                        children: (firstTitle.children || []),
+                    };
+                    children.push(heading);
+                    children.push(...titleBlocks.slice(1));
+                }
+                else {
+                    children.push(...titleBlocks);
+                }
+            }
+            else {
+                // Add empty heading placeholder so body goes to children.slice(1)
+                // The Callout component expects children[0] to be the heading
+                children.push({
                     type: 'heading',
                     depth: 3,
-                    children: (firstTitle.children || []),
-                };
-                children.push(heading);
-                children.push(...titleBlocks.slice(1), ...bodyBlocks);
+                    children: [{ type: 'text', value: '' }],
+                });
             }
-            else {
-                children.push(...titleBlocks, ...bodyBlocks);
+            if (hasBody) {
+                const bodyBlocks = parseBlock(calloutJson.body || '');
+                children.push(...bodyBlocks);
             }
-            // If there is no title or title is empty
-            const empty = !titleBlocks.length || !titleBlocks[0].children[0]?.value;
-            // Create mdxJsxFlowElement directly for mdxish
             const calloutElement = {
                 type: 'mdxJsxFlowElement',
                 name: 'Callout',
@@ -114574,23 +114723,17 @@ function parseMagicBlock(raw, options = {}) {
                 ]),
                 children: children,
             };
-            return [wrapPinnedBlocks(calloutElement, json)];
+            return [wrapPinnedBlocks(calloutElement, data)];
         }
-        // Parameters: renders as a table (used for API parameters, etc.)
         case 'parameters': {
-            const paramsJson = json;
-            const { cols, data, rows } = paramsJson;
-            if (!Object.keys(data).length)
+            const paramsJson = data;
+            const { cols, data: tableData, rows } = paramsJson;
+            if (!tableData || !Object.keys(tableData).length)
                 return [];
-            /**
-             * Convert sparse key-value data to 2D array.
-             * Keys are formatted as "ROW-COL" where ROW is "h" for header or a number.
-             * Example: { "h-0": "Name", "h-1": "Type", "0-0": "id", "0-1": "string" }
-             * Becomes: [["Name", "Type"], ["id", "string"]]
-             */
-            const sparseData = Object.entries(data).reduce((mapped, [key, v]) => {
+            if (typeof cols !== 'number' || typeof rows !== 'number' || cols < 1 || rows < 0)
+                return [];
+            const sparseData = Object.entries(tableData).reduce((mapped, [key, v]) => {
                 const [row, col] = key.split('-');
-                // Header row ("h") becomes index 0, data rows are offset by 1
                 const rowIndex = row === 'h' ? 0 : parseInt(row, 10) + 1;
                 const colIndex = parseInt(col, 10);
                 if (!mapped[rowIndex])
@@ -114598,9 +114741,8 @@ function parseMagicBlock(raw, options = {}) {
                 mapped[rowIndex][colIndex] = v;
                 return mapped;
             }, []);
-            // In compatibility mode, wrap cell content in paragraphs; otherwise inline text
             const tokenizeCell = compatibilityMode ? textToBlock : parseTableCell;
-            const children = Array.from({ length: rows + 1 }, (_, y) => ({
+            const tableChildren = Array.from({ length: rows + 1 }, (_, y) => ({
                 children: Array.from({ length: cols }, (__, x) => ({
                     children: sparseData[y]?.[x] ? tokenizeCell(sparseData[y][x]) : [{ type: 'text', value: '' }],
                     type: y === 0 ? 'tableHead' : 'tableCell',
@@ -114608,14 +114750,15 @@ function parseMagicBlock(raw, options = {}) {
                 type: 'tableRow',
             }));
             return [
-                wrapPinnedBlocks({ align: paramsJson.align ?? new Array(cols).fill('left'), children, type: 'table' }, json),
+                wrapPinnedBlocks({ align: paramsJson.align ?? new Array(cols).fill('left'), children: tableChildren, type: 'table' }, data),
             ];
         }
-        // Embed: external content (YouTube, etc.) with provider detection
         case 'embed': {
-            const embedJson = json;
+            const embedJson = data;
+            if (!embedJson.url) {
+                return [wrapPinnedBlocks(EMPTY_EMBED_PLACEHOLDER, data)];
+            }
             const { html, title, url } = embedJson;
-            // Extract provider name from URL hostname (e.g., "youtube.com" → "youtube.com")
             try {
                 embedJson.provider = new URL(url).hostname
                     .split(/(?:www)?\./)
@@ -114632,12 +114775,13 @@ function parseMagicBlock(raw, options = {}) {
                     ],
                     data: { hName: 'embed-block', hProperties: { ...embedJson, href: url, html, title, url } },
                     type: 'embed',
-                }, json),
+                }, data),
             ];
         }
-        // HTML block: raw HTML content (scripts enabled only in compatibility mode)
         case 'html': {
-            const htmlJson = json;
+            const htmlJson = data;
+            if (typeof htmlJson.html !== 'string')
+                return [];
             return [
                 wrapPinnedBlocks({
                     data: {
@@ -114645,39 +114789,33 @@ function parseMagicBlock(raw, options = {}) {
                         hProperties: { html: htmlJson.html, runScripts: compatibilityMode, safeMode },
                     },
                     type: 'html-block',
-                }, json),
+                }, data),
             ];
         }
-        // Recipe/TutorialTile: renders as Recipe component
         case 'recipe':
         case 'tutorial-tile': {
-            const recipeJson = json;
+            const recipeJson = data;
             if (!recipeJson.slug || !recipeJson.title)
                 return [];
-            // Create mdxJsxFlowElement directly for mdxish flow
-            // Note: Don't wrap in pinned blocks for mdxish - rehypeMdxishComponents handles component resolution
-            // The node structure matches what mdxishComponentBlocks creates for JSX tags
             const recipeNode = {
                 type: 'mdxJsxFlowElement',
                 name: 'Recipe',
                 attributes: toAttributes(recipeJson, ['slug', 'title']),
                 children: [],
-                // Position is optional but helps with debugging
                 position: undefined,
             };
             return [recipeNode];
         }
-        // Unknown block types: render as generic div with JSON properties
         default: {
-            const text = json.text || json.html || '';
+            const text = data.text || data.html || '';
             return [
-                wrapPinnedBlocks({ children: textToBlock(text), data: { hName: type || 'div', hProperties: json, ...json }, type: 'div' }, json),
+                wrapPinnedBlocks({ children: textToBlock(text), data: { hName: blockType || 'div', hProperties: data, ...data }, type: 'div' }, data),
             ];
         }
     }
 }
 /**
- * Block-level node types that cannot be nested inside paragraphs.
+ * Check if a child node is a flow element that needs unwrapping.
  */
 const blockTypes = [
     'heading',
@@ -114703,29 +114841,19 @@ const blockTypes = [
  */
 const isBlockNode = (node) => blockTypes.includes(node.type);
 /**
- * Unified plugin that restores magic blocks from placeholder tokens.
- *
- * During preprocessing, extractMagicBlocks replaces [block:TYPE]...[/block]
- * with inline code tokens like `__MAGIC_BLOCK_0__`. This plugin finds those
- * tokens in the parsed MDAST and replaces them with the parsed block content.
+ * Unified plugin that transforms magicBlock nodes into final MDAST nodes.
  */
-const magicBlockRestorer = ({ blocks }) => tree => {
-    if (!blocks.length)
-        return;
-    // Map: key → original raw magic block content
-    const magicBlockKeys = new Map(blocks.map(({ key, raw }) => [key, raw]));
-    // Collect replacements to apply (we need to visit in reverse to maintain indices)
+const magicBlockTransformer = (options = {}) => tree => {
     const replacements = [];
-    // First pass: collect all replacements
-    visit(tree, 'inlineCode', (node, index, parent) => {
-        if (!parent || index == null)
-            return undefined;
-        const raw = magicBlockKeys.get(node.value);
-        if (!raw)
-            return undefined;
-        const children = parseMagicBlock(raw);
-        if (!children.length)
+    visit(tree, 'magicBlock', (node, index, parent) => {
+        if (!parent || index === undefined)
             return undefined;
+        const children = transformMagicBlock(node.blockType, node.data, node.value, options);
+        if (!children.length) {
+            // Remove the node if transformation returns nothing
+            parent.children.splice(index, 1);
+            return [SKIP, index];
+        }
         // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs), lift them out
         if (parent.type === 'paragraph' && children.some(child => isBlockNode(child))) {
             const blockNodes = [];
@@ -114794,7 +114922,557 @@ const magicBlockRestorer = ({ blocks }) => tree => {
         }
     }
 };
-/* harmony default export */ const mdxish_magic_blocks = (magicBlockRestorer);
+/* harmony default export */ const magic_block_transformer = (magicBlockTransformer);
+
+;// ./processor/transform/mdxish/mdxish-html-blocks.ts
+
+
+
+
+/**
+ * Decodes HTMLBlock content that was protected during preprocessing.
+ * Content is wrapped in <!--RDMX_HTMLBLOCK:base64:RDMX_HTMLBLOCK-->
+ */
+function decodeProtectedContent(content) {
+    // Escape special regex characters in the markers
+    const startEscaped = HTML_BLOCK_CONTENT_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const endEscaped = HTML_BLOCK_CONTENT_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const markerRegex = new RegExp(`${startEscaped}([A-Za-z0-9+/=]+)${endEscaped}`, 'g');
+    return content.replace(markerRegex, (_match, encoded) => {
+        try {
+            return base64Decode(encoded);
+        }
+        catch {
+            return encoded;
+        }
+    });
+}
+/**
+ * Collects text content from a node and its children recursively
+ */
+function collectTextContent(node) {
+    const parts = [];
+    if (node.type === 'text' && node.value) {
+        parts.push(node.value);
+    }
+    else if (node.type === 'html' && node.value) {
+        parts.push(node.value);
+    }
+    else if (node.type === 'inlineCode' && node.value) {
+        parts.push(node.value);
+    }
+    else if (node.type === 'code' && node.value) {
+        // Reconstruct code fence syntax (markdown parser consumes opening ```)
+        const lang = node.lang || '';
+        const fence = `\`\`\`${lang ? `${lang}\n` : ''}`;
+        parts.push(fence);
+        parts.push(node.value);
+        // Add newline before closing fence if missing
+        const closingFence = node.value.endsWith('\n') ? '```' : '\n```';
+        parts.push(closingFence);
+    }
+    else if (node.children && Array.isArray(node.children)) {
+        node.children.forEach(child => {
+            if (typeof child === 'object' && child !== null) {
+                parts.push(collectTextContent(child));
+            }
+        });
+    }
+    return parts.join('');
+}
+/**
+ * Extracts boolean attribute from HTML tag. Handles JSX (safeMode={true}) and string (safeMode="true") syntax.
+ * Returns "true"/"false" string to survive rehypeRaw serialization.
+ */
+function extractBooleanAttr(attrs, name) {
+    // Try JSX syntax: name={true|false}
+    const jsxMatch = attrs.match(new RegExp(`${name}=\\{(true|false)\\}`));
+    if (jsxMatch) {
+        return jsxMatch[1];
+    }
+    // Try string syntax: name="true"|true
+    const stringMatch = attrs.match(new RegExp(`${name}="?(true|false)"?`));
+    if (stringMatch) {
+        return stringMatch[1];
+    }
+    return undefined;
+}
+/**
+ * Extracts runScripts attribute from HTML tag. Returns boolean for "true"/"false", string for other values, or undefined if not found.
+ */
+function extractRunScriptsAttr(attrs) {
+    const runScriptsMatch = attrs.match(/runScripts="?([^">\s]+)"?/);
+    if (!runScriptsMatch) {
+        return undefined;
+    }
+    const value = runScriptsMatch[1];
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    return value;
+}
+/**
+ * Creates an HTMLBlock node from HTML string and optional attributes
+ */
+function createHTMLBlockNode(htmlString, position, runScripts, safeMode) {
+    return {
+        position,
+        children: [{ type: 'text', value: htmlString }],
+        type: NodeTypes.htmlBlock,
+        data: {
+            hName: 'html-block',
+            hProperties: {
+                html: htmlString,
+                ...(runScripts !== undefined && { runScripts }),
+                ...(safeMode !== undefined && { safeMode }),
+            },
+        },
+    };
+}
+/**
+ * Checks for opening tag only (for split detection)
+ */
+function hasOpeningTagOnly(node) {
+    let hasOpening = false;
+    let hasClosed = false;
+    let attrs = '';
+    const check = (n) => {
+        if (n.type === 'html' && n.value) {
+            if (n.value === '<HTMLBlock>') {
+                hasOpening = true;
+            }
+            else {
+                const match = n.value.match(/^<HTMLBlock(\s[^>]*)?>$/);
+                if (match) {
+                    hasOpening = true;
+                    attrs = match[1] || '';
+                }
+            }
+            if (n.value === '</HTMLBlock>' || n.value.includes('</HTMLBlock>')) {
+                hasClosed = true;
+            }
+        }
+        if (n.children && Array.isArray(n.children)) {
+            n.children.forEach(child => {
+                check(child);
+            });
+        }
+    };
+    check(node);
+    // Return true only if opening without closing (split case)
+    return { attrs, found: hasOpening && !hasClosed };
+}
+/**
+ * Checks if a node contains an HTMLBlock closing tag
+ */
+function hasClosingTag(node) {
+    if (node.type === 'html' && node.value) {
+        if (node.value === '</HTMLBlock>' || node.value.includes('</HTMLBlock>'))
+            return true;
+    }
+    if (node.children && Array.isArray(node.children)) {
+        return node.children.some(child => hasClosingTag(child));
+    }
+    return false;
+}
+/**
+ * Transforms HTMLBlock MDX JSX to html-block nodes. Handles <HTMLBlock>{`...`}</HTMLBlock> syntax.
+ */
+const mdxishHtmlBlocks = () => tree => {
+    // Handle HTMLBlock split across root children (caused by newlines)
+    visit(tree, 'root', (root) => {
+        const children = root.children;
+        let i = 0;
+        while (i < children.length) {
+            const child = children[i];
+            const { attrs, found: hasOpening } = hasOpeningTagOnly(child);
+            if (hasOpening) {
+                // Find closing tag in subsequent siblings
+                let closingIdx = -1;
+                for (let j = i + 1; j < children.length; j += 1) {
+                    if (hasClosingTag(children[j])) {
+                        closingIdx = j;
+                        break;
+                    }
+                }
+                if (closingIdx !== -1) {
+                    // Collect inner content between tags
+                    const contentParts = [];
+                    for (let j = i; j <= closingIdx; j += 1) {
+                        const node = children[j];
+                        contentParts.push(collectTextContent(node));
+                    }
+                    // Remove the opening/closing tags and template literal syntax from content
+                    let content = contentParts.join('');
+                    content = content.replace(/^<HTMLBlock[^>]*>\s*\{?\s*`?/, '').replace(/`?\s*\}?\s*<\/HTMLBlock>$/, '');
+                    // Decode protected content that was base64 encoded during preprocessing
+                    content = decodeProtectedContent(content);
+                    const htmlString = formatHtmlForMdxish(content);
+                    const runScripts = extractRunScriptsAttr(attrs);
+                    const safeMode = extractBooleanAttr(attrs, 'safeMode');
+                    // Replace range with single HTMLBlock node
+                    const mdNode = createHTMLBlockNode(htmlString, children[i].position, runScripts, safeMode);
+                    root.children.splice(i, closingIdx - i + 1, mdNode);
+                }
+            }
+            i += 1;
+        }
+    });
+    // Handle HTMLBlock parsed as HTML elements (when template literal contains block-level HTML tags)
+    visit(tree, 'html', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        const value = node.value;
+        if (!value)
+            return;
+        // Case 1: Full HTMLBlock in single node
+        const fullMatch = value.match(/^<HTMLBlock(\s[^>]*)?>([\s\S]*)<\/HTMLBlock>$/);
+        if (fullMatch) {
+            const attrs = fullMatch[1] || '';
+            let content = fullMatch[2] || '';
+            // Remove template literal syntax if present: {`...`}
+            content = content.replace(/^\s*\{\s*`/, '').replace(/`\s*\}\s*$/, '');
+            // Decode protected content that was base64 encoded during preprocessing
+            content = decodeProtectedContent(content);
+            const htmlString = formatHtmlForMdxish(content);
+            const runScripts = extractRunScriptsAttr(attrs);
+            const safeMode = extractBooleanAttr(attrs, 'safeMode');
+            parent.children[index] = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
+            return;
+        }
+        // Case 2: Opening tag only (split by blank lines)
+        if (value === '<HTMLBlock>' || value.match(/^<HTMLBlock\s[^>]*>$/)) {
+            const siblings = parent.children;
+            let closingIdx = -1;
+            // Find closing tag in siblings
+            for (let i = index + 1; i < siblings.length; i += 1) {
+                const sibling = siblings[i];
+                if (sibling.type === 'html') {
+                    const sibVal = sibling.value;
+                    if (sibVal === '</HTMLBlock>' || sibVal?.includes('</HTMLBlock>')) {
+                        closingIdx = i;
+                        break;
+                    }
+                }
+            }
+            if (closingIdx === -1)
+                return;
+            // Collect content between tags, skipping template literal delimiters
+            const contentParts = [];
+            for (let i = index + 1; i < closingIdx; i += 1) {
+                const sibling = siblings[i];
+                // Skip template literal delimiters
+                if (sibling.type === 'text') {
+                    const textVal = sibling.value;
+                    if (textVal === '{' || textVal === '}' || textVal === '{`' || textVal === '`}') {
+                        // eslint-disable-next-line no-continue
+                        continue;
+                    }
+                }
+                contentParts.push(collectTextContent(sibling));
+            }
+            // Decode protected content that was base64 encoded during preprocessing
+            const decodedContent = decodeProtectedContent(contentParts.join(''));
+            const htmlString = formatHtmlForMdxish(decodedContent);
+            const runScripts = extractRunScriptsAttr(value);
+            const safeMode = extractBooleanAttr(value, 'safeMode');
+            // Replace opening tag with HTMLBlock node, remove consumed siblings
+            parent.children[index] = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
+            parent.children.splice(index + 1, closingIdx - index);
+        }
+    });
+    // Handle HTMLBlock inside paragraphs (parsed as inline elements)
+    visit(tree, 'paragraph', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        const children = node.children || [];
+        let htmlBlockStartIdx = -1;
+        let htmlBlockEndIdx = -1;
+        let templateLiteralStartIdx = -1;
+        let templateLiteralEndIdx = -1;
+        for (let i = 0; i < children.length; i += 1) {
+            const child = children[i];
+            if (child.type === 'html' && typeof child.value === 'string') {
+                const value = child.value;
+                if (value === '<HTMLBlock>' || value.match(/^<HTMLBlock\s[^>]*>$/)) {
+                    htmlBlockStartIdx = i;
+                }
+                else if (value === '</HTMLBlock>') {
+                    htmlBlockEndIdx = i;
+                }
+            }
+            // Find opening brace after HTMLBlock start
+            if (htmlBlockStartIdx !== -1 && templateLiteralStartIdx === -1 && child.type === 'text') {
+                const value = child.value;
+                if (value === '{') {
+                    templateLiteralStartIdx = i;
+                }
+            }
+            // Find closing brace before HTMLBlock end
+            if (htmlBlockStartIdx !== -1 && htmlBlockEndIdx === -1 && child.type === 'text') {
+                const value = child.value;
+                if (value === '}') {
+                    templateLiteralEndIdx = i;
+                }
+            }
+        }
+        if (htmlBlockStartIdx !== -1 &&
+            htmlBlockEndIdx !== -1 &&
+            templateLiteralStartIdx !== -1 &&
+            templateLiteralEndIdx !== -1 &&
+            templateLiteralStartIdx < templateLiteralEndIdx) {
+            const openingTag = children[htmlBlockStartIdx];
+            // Collect content between braces (handles code blocks)
+            const templateContent = [];
+            for (let i = templateLiteralStartIdx + 1; i < templateLiteralEndIdx; i += 1) {
+                const child = children[i];
+                templateContent.push(collectTextContent(child));
+            }
+            // Decode protected content that was base64 encoded during preprocessing
+            const decodedContent = decodeProtectedContent(templateContent.join(''));
+            const htmlString = formatHtmlForMdxish(decodedContent);
+            const runScripts = openingTag.value ? extractRunScriptsAttr(openingTag.value) : undefined;
+            const safeMode = openingTag.value ? extractBooleanAttr(openingTag.value, 'safeMode') : undefined;
+            const mdNode = createHTMLBlockNode(htmlString, node.position, runScripts, safeMode);
+            parent.children[index] = mdNode;
+        }
+    });
+    // Ensure html-block nodes have HTML in children as text node
+    visit(tree, 'html-block', (node) => {
+        const html = node.data?.hProperties?.html;
+        if (html &&
+            (!node.children ||
+                node.children.length === 0 ||
+                (node.children.length === 1 && node.children[0].type === 'text' && node.children[0].value !== html))) {
+            node.children = [
+                {
+                    type: 'text',
+                    value: html,
+                },
+            ];
+        }
+    });
+    return tree;
+};
+/* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
+
+;// ./processor/transform/mdxish/mdxish-jsx-to-mdast.ts
+
+
+
+const transformImage = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { align, alt = '', border, caption, className, height, lazy, src = '', title = '', width } = attrs;
+    const hProperties = {
+        alt,
+        src,
+        title,
+        ...(align && { align }),
+        ...(border !== undefined && { border: String(border) }),
+        ...(caption && { caption }),
+        ...(className && { className }),
+        ...(height !== undefined && { height: String(height) }),
+        ...(lazy !== undefined && { lazy }),
+        ...(width !== undefined && { width: String(width) }),
+    };
+    return {
+        type: NodeTypes.imageBlock,
+        align,
+        alt,
+        border: border !== undefined ? String(border) : undefined,
+        caption,
+        className,
+        height: height !== undefined ? String(height) : undefined,
+        lazy,
+        src,
+        title,
+        width: width !== undefined ? String(width) : undefined,
+        data: {
+            hName: 'img',
+            hProperties,
+        },
+        position: jsx.position,
+    };
+};
+const transformCallout = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { empty = false, icon = '', theme = '' } = attrs;
+    return {
+        type: NodeTypes.callout,
+        children: jsx.children,
+        data: {
+            hName: 'Callout',
+            hProperties: {
+                empty,
+                icon,
+                theme,
+            },
+        },
+        position: jsx.position,
+    };
+};
+const transformEmbed = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { favicon, html, iframe, image, providerName, providerUrl, title = '', url = '' } = attrs;
+    return {
+        type: NodeTypes.embedBlock,
+        title,
+        url,
+        data: {
+            hName: 'embed',
+            hProperties: {
+                title,
+                url,
+                ...(favicon && { favicon }),
+                ...(html && { html }),
+                ...(iframe !== undefined && { iframe }),
+                ...(image && { image }),
+                ...(providerName && { providerName }),
+                ...(providerUrl && { providerUrl }),
+            },
+        },
+        position: jsx.position,
+    };
+};
+const transformRecipe = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { backgroundColor = '', emoji = '', id = '', link = '', slug = '', title = '' } = attrs;
+    return {
+        type: NodeTypes.recipe,
+        backgroundColor,
+        emoji,
+        id,
+        link,
+        slug,
+        title,
+        position: jsx.position,
+    };
+};
+/**
+ * Transform a magic block image node into an ImageBlock.
+ * Magic block images have structure: { type: 'image', url, title, alt, data.hProperties }
+ */
+const transformMagicBlockImage = (node) => {
+    const { alt = '', data, position, title = '', url = '' } = node;
+    const hProps = data?.hProperties || {};
+    const { align, border, width } = hProps;
+    const hProperties = {
+        alt,
+        src: url,
+        title,
+        ...(align && { align }),
+        ...(border && { border }),
+        ...(width && { width }),
+    };
+    return {
+        type: NodeTypes.imageBlock,
+        align,
+        alt,
+        border,
+        src: url,
+        title,
+        width,
+        data: {
+            hName: 'img',
+            hProperties,
+        },
+        position,
+    };
+};
+/**
+ * Transform a magic block embed node into an EmbedBlock.
+ * Magic block embeds have structure: { type: 'embed', children, data.hProperties }
+ */
+const transformMagicBlockEmbed = (node) => {
+    const { data, position } = node;
+    const hProps = data?.hProperties || {};
+    const { favicon, html, image, providerName, providerUrl, title = '', url = '' } = hProps;
+    return {
+        type: NodeTypes.embedBlock,
+        title,
+        url,
+        data: {
+            hName: 'embed',
+            hProperties: {
+                title,
+                url,
+                ...(favicon && { favicon }),
+                ...(html && { html }),
+                ...(image && { image }),
+                ...(providerName && { providerName }),
+                ...(providerUrl && { providerUrl }),
+            },
+        },
+        position,
+    };
+};
+const COMPONENT_MAP = {
+    Callout: transformCallout,
+    Embed: transformEmbed,
+    Image: transformImage,
+    Recipe: transformRecipe,
+};
+/**
+ * Transform mdxJsxFlowElement nodes and magic block nodes into proper MDAST node types.
+ *
+ * This transformer runs after mdxishComponentBlocks and converts:
+ * - JSX component elements (Image, Callout, Embed, Recipe) into their corresponding MDAST types
+ * - Magic block image nodes (type: 'image') into image-block
+ * - Magic block embed nodes (type: 'embed') into embed-block
+ * - Figure nodes containing images (from magic blocks with captions) - transforms the inner image
+ *
+ * This is controlled by the `newEditorTypes` flag to maintain backwards compatibility.
+ */
+const mdxishJsxToMdast = () => tree => {
+    // Transform JSX components (Image, Callout, Embed, Recipe)
+    visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
+        if (!parent || index === undefined || !node.name)
+            return;
+        const transformer = COMPONENT_MAP[node.name];
+        if (!transformer)
+            return;
+        const newNode = transformer(node);
+        // Replace the JSX node with the MDAST node
+        parent.children[index] = newNode;
+    });
+    // Transform magic block images (type: 'image') to image-block
+    // Note: Standard markdown images are wrapped in paragraphs and handled by imageTransformer
+    // Magic block images are direct children of root, so we handle them here
+    visit(tree, 'image', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return SKIP;
+        // Skip images inside paragraphs (those are standard markdown images handled by imageTransformer)
+        if (parent.type === 'paragraph')
+            return SKIP;
+        const newNode = transformMagicBlockImage(node);
+        parent.children[index] = newNode;
+        return SKIP;
+    });
+    // Transform magic block embeds (type: 'embed') to embed-block
+    visit(tree, 'embed', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return SKIP;
+        const newNode = transformMagicBlockEmbed(node);
+        parent.children[index] = newNode;
+        return SKIP;
+    });
+    // Transform images inside figure nodes (magic blocks with captions)
+    const isFigure = (node) => node.type === 'figure';
+    visit(tree, isFigure, node => {
+        // Find and transform the image child
+        node.children = node.children.map(child => {
+            if (child.type === 'image') {
+                return transformMagicBlockImage(child);
+            }
+            return child;
+        });
+    });
+    return tree;
+};
+/* harmony default export */ const mdxish_jsx_to_mdast = (mdxishJsxToMdast);
 
 ;// ./processor/transform/mdxish/mdxish-mermaid.ts
 
@@ -114836,25 +115514,50 @@ const componentTagPattern = /<(\/?[A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>/g;
 
 ;// ./processor/transform/mdxish/mdxish-snake-case-components.ts
 
+
 /**
  * Replaces snake_case component names with valid HTML placeholders.
  * Required because remark-parse rejects tags with underscores.
  * Example: `<Snake_case />` → `<MDXishSnakeCase0 />`
+ *
+ * Code blocks and inline code are protected and will not be transformed.
+ *
+ * @param content - The markdown content to process
+ * @param options - Options including knownComponents to filter by
  */
-function processSnakeCaseComponent(content) {
+function processSnakeCaseComponent(content, options = {}) {
+    const { knownComponents } = options;
     // Early exit if no potential snake_case components
     if (!/[A-Z][A-Za-z0-9]*_[A-Za-z0-9_]*/.test(content)) {
         return { content, mapping: {} };
     }
+    // Step 1: Extract code blocks to protect them from transformation
+    const { protectedCode, protectedContent } = protectCodeBlocks(content);
+    // Find the highest existing placeholder number to avoid collisions
+    // e.g., if content has <MDXishSnakeCase0 />, start counter from 1
+    const placeholderPattern = /MDXishSnakeCase(\d+)/g;
+    let startCounter = 0;
+    let placeholderMatch;
+    while ((placeholderMatch = placeholderPattern.exec(content)) !== null) {
+        const num = parseInt(placeholderMatch[1], 10);
+        if (num >= startCounter) {
+            startCounter = num + 1;
+        }
+    }
     const mapping = {};
     const reverseMap = new Map();
-    let counter = 0;
-    const processedContent = content.replace(componentTagPattern, (match, tagName, attrs, selfClosing) => {
+    let counter = startCounter;
+    // Step 2: Transform snake_case components in non-code content
+    const processedContent = protectedContent.replace(componentTagPattern, (match, tagName, attrs, selfClosing) => {
         if (!tagName.includes('_')) {
             return match;
         }
         const isClosing = tagName.startsWith('/');
         const cleanTagName = isClosing ? tagName.slice(1) : tagName;
+        // Only transform if it's a known component (or if no filter is provided)
+        if (knownComponents && !knownComponents.has(cleanTagName)) {
+            return match;
+        }
         let placeholder = reverseMap.get(cleanTagName);
         if (!placeholder) {
             // eslint-disable-next-line no-plusplus
@@ -114865,8 +115568,10 @@ function processSnakeCaseComponent(content) {
         const processedTagName = isClosing ? `/${placeholder}` : placeholder;
         return `<${processedTagName}${attrs}${selfClosing}>`;
     });
+    // Step 3: Restore code blocks (untouched)
+    const finalContent = restoreCodeBlocks(processedContent, protectedCode);
     return {
-        content: processedContent,
+        content: finalContent,
         mapping,
     };
 }
@@ -114883,139 +115588,6 @@ function restoreSnakeCase(placeholderName, mapping) {
     return matchingKey ? mapping[matchingKey] : placeholderName;
 }
 
-;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
-
-// Patterns to detect for bold (** and __) and italic (* and _) syntax:
-// Bold: ** text**, **text **, word** text**, ** text **
-// Italic: * text*, *text *, word* text*, * text *
-// Same patterns for underscore variants
-// We use separate patterns for each marker type to allow this flexibility.
-// Pattern for ** bold **
-// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
-// trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
-const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
-// Pattern for __ bold __
-const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:[^_\n]|_(?!_))+?)(\s*)\2|((?:[^_\n]|_(?!_))+?)(\s+)\2)(\S|$)?/g;
-// Pattern for * italic *
-const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
-// Pattern for _ italic _
-const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+([^_\n]+?)(\s*)\2|([^_\n]+?)(\s+)\2)(\S|$)?/g;
-/**
- * A remark plugin that normalizes malformed bold and italic markers in text nodes.
- * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
- * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
- * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
- *
- * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
- * Also supports snake_case content like `** some_snake_case**`.
- *
- * This runs after remark-parse, which (in v11+) is strict and doesn't parse
- * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
- */
-const normalizeEmphasisAST = () => (tree) => {
-    visit(tree, 'text', function visitor(node, index, parent) {
-        if (index === undefined || !parent)
-            return undefined;
-        // Skip if inside code blocks or inline code
-        if (parent.type === 'inlineCode' || parent.type === 'code') {
-            return undefined;
-        }
-        const text = node.value;
-        const allMatches = [];
-        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '**', match });
-        });
-        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '__', match });
-        });
-        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '*', match });
-        });
-        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '_', match });
-        });
-        if (allMatches.length === 0)
-            return undefined;
-        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
-        const filteredMatches = [];
-        let lastEnd = 0;
-        allMatches.forEach(info => {
-            const start = info.match.index ?? 0;
-            const end = start + info.match[0].length;
-            if (start >= lastEnd) {
-                filteredMatches.push(info);
-                lastEnd = end;
-            }
-        });
-        if (filteredMatches.length === 0)
-            return undefined;
-        const parts = [];
-        let lastIndex = 0;
-        filteredMatches.forEach(({ match, marker, isBold }) => {
-            const matchIndex = match.index ?? 0;
-            const fullMatch = match[0];
-            if (matchIndex > lastIndex) {
-                const beforeText = text.slice(lastIndex, matchIndex);
-                if (beforeText) {
-                    parts.push({ type: 'text', value: beforeText });
-                }
-            }
-            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
-            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
-            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
-            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
-            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
-            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
-            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
-            const afterChar = match[7]; // Character after closing markers (if any)
-            const markerPos = fullMatch.indexOf(marker);
-            const spacesBeforeMarkers = wordBefore
-                ? fullMatch.slice(wordBefore.length, markerPos)
-                : fullMatch.slice(0, markerPos);
-            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
-            if (wordBefore) {
-                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
-                parts.push({ type: 'text', value: wordBefore + spacing });
-            }
-            else if (spacesBeforeMarkers) {
-                parts.push({ type: 'text', value: spacesBeforeMarkers });
-            }
-            if (content) {
-                if (isBold) {
-                    parts.push({
-                        type: 'strong',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-                else {
-                    parts.push({
-                        type: 'emphasis',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-            }
-            if (afterChar) {
-                const prefix = trailingSpace ? ' ' : '';
-                parts.push({ type: 'text', value: prefix + afterChar });
-            }
-            lastIndex = matchIndex + fullMatch.length;
-        });
-        if (lastIndex < text.length) {
-            const remainingText = text.slice(lastIndex);
-            if (remainingText) {
-                parts.push({ type: 'text', value: remainingText });
-            }
-        }
-        if (parts.length > 0) {
-            parent.children.splice(index, 1, ...parts);
-            return [SKIP, index + parts.length];
-        }
-        return undefined;
-    });
-    return tree;
-};
-/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
-
 ;// ./processor/transform/mdxish/normalize-table-separator.ts
 /**
  * Preprocessor to normalize malformed GFM table separator syntax.
@@ -115248,57 +115820,1172 @@ const variablesTextTransformer = () => tree => {
 };
 /* harmony default export */ const variables_text = (variablesTextTransformer);
 
-;// ./lib/utils/extractMagicBlocks.ts
+;// ./lib/mdast-util/magic-block/index.ts
+const contextMap = new WeakMap();
 /**
- * The content matching in this regex captures everything between `[block:TYPE]`
- * and `[/block]`, including new lines. Negative lookahead for the closing
- * `[/block]` tag is required to prevent greedy matching to ensure it stops at
- * the first closing tag it encounters preventing vulnerability to polynomial
- * backtracking issues.
+ * Find the magicBlock token in the token ancestry.
  */
-const MAGIC_BLOCK_REGEX = /\[block:[^\]]{1,100}\](?:(?!\[block:)(?!\[\/block\])[\s\S])*\[\/block\]/g;
+function findMagicBlockToken() {
+    // Walk up the token stack to find the magicBlock token
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const token = events[i][0];
+        if (token.type === 'magicBlock') {
+            return token;
+        }
+    }
+    return undefined;
+}
 /**
- * Extract legacy magic block syntax from a markdown string.
- * Returns the modified markdown and an array of extracted blocks.
+ * Enter handler: Create a new magicBlock node.
  */
-function extractMagicBlocks(markdown) {
-    const blocks = [];
-    let index = 0;
-    const replaced = markdown.replace(MAGIC_BLOCK_REGEX, match => {
-        /**
-         * Key is the unique identifier for the magic block
-         */
-        const key = `__MAGIC_BLOCK_${index}__`;
-        /**
-         * Token is a wrapper around the `key` to serialize & influence how the
-         * magic block is parsed in the remark pipeline.
-         * - Use backticks so it becomes a code span, preventing `remarkParse` from
-         *   parsing special characters in the token as markdown syntax
-         * - Prepend a newline to ensure it is parsed as a block level node
-         * - Append a newline to ensure it is separated from following content
-         */
-        const token = `\n\`${key}\`\n`;
-        blocks.push({ key, raw: match, token });
-        index += 1;
-        return token;
-    });
-    return { replaced, blocks };
+function enterMagicBlock(token) {
+    // Initialize context for this magic block
+    contextMap.set(token, { blockType: '', dataChunks: [] });
+    this.enter({
+        type: 'magicBlock',
+        blockType: '',
+        data: {},
+        value: '',
+    }, token);
 }
 /**
- * Restore extracted magic blocks back into a markdown string.
+ * Exit handler for block type: Extract the block type from the token.
  */
-function restoreMagicBlocks(replaced, blocks) {
-    // If a magic block is at the start or end of the document, the extraction
-    // token's newlines will have been trimmed during processing. We need to
-    // account for that here to ensure the token is found and replaced correctly.
-    // These extra newlines will be removed again when the final string is trimmed.
-    const content = `\n${replaced}\n`;
-    const restoredContent = blocks.reduce((acc, { token, raw }) => {
-        // Ensure each magic block is separated by newlines when restored.
-        return acc.split(token).join(`\n${raw}\n`);
-    }, content);
-    return restoredContent.trim();
+function exitMagicBlockType(token) {
+    const blockToken = findMagicBlockToken.call(this);
+    if (!blockToken)
+        return;
+    const context = contextMap.get(blockToken);
+    if (context) {
+        context.blockType = this.sliceSerialize(token);
+    }
+}
+/**
+ * Exit handler for block data: Accumulate JSON content chunks.
+ */
+function exitMagicBlockData(token) {
+    const blockToken = findMagicBlockToken.call(this);
+    if (!blockToken)
+        return;
+    const context = contextMap.get(blockToken);
+    if (context) {
+        context.dataChunks.push(this.sliceSerialize(token));
+    }
+}
+/**
+ * Exit handler for line endings: Preserve newlines in multiline blocks.
+ */
+function exitMagicBlockLineEnding(token) {
+    const blockToken = findMagicBlockToken.call(this);
+    if (!blockToken)
+        return;
+    const context = contextMap.get(blockToken);
+    if (context) {
+        context.dataChunks.push(this.sliceSerialize(token));
+    }
 }
+/**
+ * Exit handler for end marker: If this is a failed end marker check (not the final marker),
+ * add its content to the data chunks so we don't lose characters like '['.
+ */
+function exitMagicBlockMarkerEnd(token) {
+    const blockToken = findMagicBlockToken.call(this);
+    if (!blockToken)
+        return;
+    // Get the content of the marker
+    const markerContent = this.sliceSerialize(token);
+    // If this marker doesn't end with ']', it's a failed check and content belongs to data
+    // The successful end marker would be "[/block]"
+    if (!markerContent.endsWith(']') || markerContent !== '[/block]') {
+        const context = contextMap.get(blockToken);
+        if (context) {
+            context.dataChunks.push(markerContent);
+        }
+    }
+}
+/**
+ * Exit handler: Finalize the magicBlock node with parsed JSON data.
+ */
+function exitMagicBlock(token) {
+    const context = contextMap.get(token);
+    const node = this.stack[this.stack.length - 1];
+    if (context) {
+        const rawJson = context.dataChunks.join('');
+        node.blockType = context.blockType;
+        node.value = `[block:${context.blockType}]${rawJson}[/block]`;
+        // Parse JSON data
+        try {
+            node.data = JSON.parse(rawJson.trim());
+        }
+        catch {
+            // Invalid JSON - store empty object but keep the raw value
+            node.data = {};
+        }
+        // Clean up context
+        contextMap.delete(token);
+    }
+    this.exit(token);
+}
+/**
+ * Handler to serialize magicBlock nodes back to markdown.
+ */
+const handleMagicBlock = (node) => {
+    const magicNode = node;
+    // If we have the original raw value, use it
+    if (magicNode.value) {
+        return magicNode.value;
+    }
+    // Otherwise reconstruct from parsed data
+    const json = JSON.stringify(magicNode.data, null, 2);
+    return `[block:${magicNode.blockType}]\n${json}\n[/block]`;
+};
+/**
+ * Create an extension for `mdast-util-from-markdown` to enable magic blocks.
+ *
+ * Converts micromark magic block tokens into `magicBlock` MDAST nodes.
+ *
+ * @returns Extension for `mdast-util-from-markdown`
+ */
+function magicBlockFromMarkdown() {
+    return {
+        enter: {
+            magicBlock: enterMagicBlock,
+        },
+        exit: {
+            magicBlockType: exitMagicBlockType,
+            magicBlockData: exitMagicBlockData,
+            magicBlockLineEnding: exitMagicBlockLineEnding,
+            magicBlockMarkerEnd: exitMagicBlockMarkerEnd,
+            magicBlock: exitMagicBlock,
+        },
+    };
+}
+/**
+ * Create an extension for `mdast-util-to-markdown` to serialize magic blocks.
+ *
+ * Converts `magicBlock` MDAST nodes back to `[block:TYPE]JSON[/block]` syntax.
+ *
+ * @returns Extension for `mdast-util-to-markdown`
+ */
+function magicBlockToMarkdown() {
+    return {
+        handlers: {
+            magicBlock: handleMagicBlock,
+        },
+    };
+}
+
+;// ./node_modules/micromark-util-symbol/lib/codes.js
+/**
+ * Character codes.
+ *
+ * This module is compiled away!
+ *
+ * micromark works based on character codes.
+ * This module contains constants for the ASCII block and the replacement
+ * character.
+ * A couple of them are handled in a special way, such as the line endings
+ * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
+ * tab) and its expansion based on what column it’s at (virtual space),
+ * and the end-of-file (eof) character.
+ * As values are preprocessed before handling them, the actual characters LF,
+ * CR, HT, and NUL (which is present as the replacement character), are
+ * guaranteed to not exist.
+ *
+ * Unicode basic latin block.
+ */
+const codes = /** @type {const} */ ({
+  carriageReturn: -5,
+  lineFeed: -4,
+  carriageReturnLineFeed: -3,
+  horizontalTab: -2,
+  virtualSpace: -1,
+  eof: null,
+  nul: 0,
+  soh: 1,
+  stx: 2,
+  etx: 3,
+  eot: 4,
+  enq: 5,
+  ack: 6,
+  bel: 7,
+  bs: 8,
+  ht: 9, // `\t`
+  lf: 10, // `\n`
+  vt: 11, // `\v`
+  ff: 12, // `\f`
+  cr: 13, // `\r`
+  so: 14,
+  si: 15,
+  dle: 16,
+  dc1: 17,
+  dc2: 18,
+  dc3: 19,
+  dc4: 20,
+  nak: 21,
+  syn: 22,
+  etb: 23,
+  can: 24,
+  em: 25,
+  sub: 26,
+  esc: 27,
+  fs: 28,
+  gs: 29,
+  rs: 30,
+  us: 31,
+  space: 32,
+  exclamationMark: 33, // `!`
+  quotationMark: 34, // `"`
+  numberSign: 35, // `#`
+  dollarSign: 36, // `$`
+  percentSign: 37, // `%`
+  ampersand: 38, // `&`
+  apostrophe: 39, // `'`
+  leftParenthesis: 40, // `(`
+  rightParenthesis: 41, // `)`
+  asterisk: 42, // `*`
+  plusSign: 43, // `+`
+  comma: 44, // `,`
+  dash: 45, // `-`
+  dot: 46, // `.`
+  slash: 47, // `/`
+  digit0: 48, // `0`
+  digit1: 49, // `1`
+  digit2: 50, // `2`
+  digit3: 51, // `3`
+  digit4: 52, // `4`
+  digit5: 53, // `5`
+  digit6: 54, // `6`
+  digit7: 55, // `7`
+  digit8: 56, // `8`
+  digit9: 57, // `9`
+  colon: 58, // `:`
+  semicolon: 59, // `;`
+  lessThan: 60, // `<`
+  equalsTo: 61, // `=`
+  greaterThan: 62, // `>`
+  questionMark: 63, // `?`
+  atSign: 64, // `@`
+  uppercaseA: 65, // `A`
+  uppercaseB: 66, // `B`
+  uppercaseC: 67, // `C`
+  uppercaseD: 68, // `D`
+  uppercaseE: 69, // `E`
+  uppercaseF: 70, // `F`
+  uppercaseG: 71, // `G`
+  uppercaseH: 72, // `H`
+  uppercaseI: 73, // `I`
+  uppercaseJ: 74, // `J`
+  uppercaseK: 75, // `K`
+  uppercaseL: 76, // `L`
+  uppercaseM: 77, // `M`
+  uppercaseN: 78, // `N`
+  uppercaseO: 79, // `O`
+  uppercaseP: 80, // `P`
+  uppercaseQ: 81, // `Q`
+  uppercaseR: 82, // `R`
+  uppercaseS: 83, // `S`
+  uppercaseT: 84, // `T`
+  uppercaseU: 85, // `U`
+  uppercaseV: 86, // `V`
+  uppercaseW: 87, // `W`
+  uppercaseX: 88, // `X`
+  uppercaseY: 89, // `Y`
+  uppercaseZ: 90, // `Z`
+  leftSquareBracket: 91, // `[`
+  backslash: 92, // `\`
+  rightSquareBracket: 93, // `]`
+  caret: 94, // `^`
+  underscore: 95, // `_`
+  graveAccent: 96, // `` ` ``
+  lowercaseA: 97, // `a`
+  lowercaseB: 98, // `b`
+  lowercaseC: 99, // `c`
+  lowercaseD: 100, // `d`
+  lowercaseE: 101, // `e`
+  lowercaseF: 102, // `f`
+  lowercaseG: 103, // `g`
+  lowercaseH: 104, // `h`
+  lowercaseI: 105, // `i`
+  lowercaseJ: 106, // `j`
+  lowercaseK: 107, // `k`
+  lowercaseL: 108, // `l`
+  lowercaseM: 109, // `m`
+  lowercaseN: 110, // `n`
+  lowercaseO: 111, // `o`
+  lowercaseP: 112, // `p`
+  lowercaseQ: 113, // `q`
+  lowercaseR: 114, // `r`
+  lowercaseS: 115, // `s`
+  lowercaseT: 116, // `t`
+  lowercaseU: 117, // `u`
+  lowercaseV: 118, // `v`
+  lowercaseW: 119, // `w`
+  lowercaseX: 120, // `x`
+  lowercaseY: 121, // `y`
+  lowercaseZ: 122, // `z`
+  leftCurlyBrace: 123, // `{`
+  verticalBar: 124, // `|`
+  rightCurlyBrace: 125, // `}`
+  tilde: 126, // `~`
+  del: 127,
+  // Unicode Specials block.
+  byteOrderMarker: 65_279,
+  // Unicode Specials block.
+  replacementCharacter: 65_533 // `�`
+})
+
+;// ./lib/micromark/magic-block/syntax.ts
+
+
+/**
+ * Known magic block types that the tokenizer will recognize.
+ * Unknown types will not be tokenized as magic blocks.
+ */
+const KNOWN_BLOCK_TYPES = new Set([
+    'code',
+    'api-header',
+    'image',
+    'callout',
+    'parameters',
+    'table',
+    'embed',
+    'html',
+    'recipe',
+    'tutorial-tile',
+]);
+/**
+ * Check if a character is valid for a magic block type identifier.
+ * Types can contain alphanumeric characters and hyphens (e.g., "api-header", "tutorial-tile")
+ */
+function isTypeChar(code) {
+    return asciiAlphanumeric(code) || code === codes.dash;
+}
+/**
+ * Creates the opening marker state machine: [block:
+ * Returns the first state function to start parsing.
+ */
+function createOpeningMarkerParser(effects, nok, onComplete) {
+    const expectB = (code) => {
+        if (code !== codes.lowercaseB)
+            return nok(code);
+        effects.consume(code);
+        return expectL;
+    };
+    const expectL = (code) => {
+        if (code !== codes.lowercaseL)
+            return nok(code);
+        effects.consume(code);
+        return expectO;
+    };
+    const expectO = (code) => {
+        if (code !== codes.lowercaseO)
+            return nok(code);
+        effects.consume(code);
+        return expectC;
+    };
+    const expectC = (code) => {
+        if (code !== codes.lowercaseC)
+            return nok(code);
+        effects.consume(code);
+        return expectK;
+    };
+    const expectK = (code) => {
+        if (code !== codes.lowercaseK)
+            return nok(code);
+        effects.consume(code);
+        return expectColon;
+    };
+    const expectColon = (code) => {
+        if (code !== codes.colon)
+            return nok(code);
+        effects.consume(code);
+        effects.exit('magicBlockMarkerStart');
+        effects.enter('magicBlockType');
+        return onComplete;
+    };
+    return expectB;
+}
+/**
+ * Creates the type capture state machine.
+ * Captures type characters until ] and validates against known types.
+ */
+function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
+    const captureTypeFirst = (code) => {
+        // Reject empty type name [block:]
+        if (code === codes.rightSquareBracket) {
+            return nok(code);
+        }
+        if (isTypeChar(code)) {
+            blockTypeRef.value += String.fromCharCode(code);
+            effects.consume(code);
+            return captureType;
+        }
+        return nok(code);
+    };
+    const captureType = (code) => {
+        if (code === codes.rightSquareBracket) {
+            if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
+                return nok(code);
+            }
+            effects.exit('magicBlockType');
+            effects.enter('magicBlockMarkerTypeEnd');
+            effects.consume(code);
+            effects.exit('magicBlockMarkerTypeEnd');
+            return onComplete;
+        }
+        if (isTypeChar(code)) {
+            blockTypeRef.value += String.fromCharCode(code);
+            effects.consume(code);
+            return captureType;
+        }
+        return nok(code);
+    };
+    return { first: captureTypeFirst, remaining: captureType };
+}
+/**
+ * Creates the closing marker state machine: /block]
+ * Handles partial matches by calling onMismatch to fall back to data capture.
+ */
+function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
+    const handleMismatch = (code) => {
+        if (jsonState && code === codes.quotationMark) {
+            jsonState.inString = true;
+        }
+        return onMismatch(code);
+    };
+    const expectSlash = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.slash)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectB;
+    };
+    const expectB = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseB)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectL;
+    };
+    const expectL = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseL)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectO;
+    };
+    const expectO = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseO)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectC;
+    };
+    const expectC = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseC)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectK;
+    };
+    const expectK = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseK)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectBracket;
+    };
+    const expectBracket = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.rightSquareBracket)
+            return handleMismatch(code);
+        effects.consume(code);
+        return onSuccess;
+    };
+    return { expectSlash };
+}
+/**
+ * Partial construct for checking non-lazy continuation.
+ * This is used by the flow tokenizer to check if we can continue
+ * parsing on the next line.
+ */
+const syntax_nonLazyContinuation = {
+    partial: true,
+    tokenize: syntax_tokenizeNonLazyContinuation,
+};
+/**
+ * Tokenizer for non-lazy continuation checking.
+ * Returns ok if the next line is non-lazy (can continue), nok if lazy.
+ */
+function syntax_tokenizeNonLazyContinuation(effects, ok, nok) {
+    const lineStart = (code) => {
+        // `this` here refers to the micromark parser
+        // since we are just passing functions as references and not actually calling them
+        // micromarks's internal parser will call this automatically with appropriate arguments
+        return this.parser.lazy[this.now().line] ? nok(code) : ok(code);
+    };
+    const start = (code) => {
+        if (code === null) {
+            return nok(code);
+        }
+        if (!markdownLineEnding(code)) {
+            return nok(code);
+        }
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return lineStart;
+    };
+    return start;
+}
+/**
+ * Create a micromark extension for magic block syntax.
+ *
+ * This extension handles both single-line and multiline magic blocks:
+ * - Flow construct (concrete): Handles block-level multiline magic blocks at document level
+ * - Text construct: Handles inline magic blocks in lists, paragraphs, etc.
+ *
+ * The flow construct is marked as "concrete" which prevents it from being
+ * interrupted by container markers (like `>` for blockquotes or `-` for lists).
+ */
+function magicBlock() {
+    return {
+        // Flow construct - handles block-level magic blocks at document root
+        // Marked as concrete to prevent interruption by containers
+        flow: {
+            [codes.leftSquareBracket]: {
+                name: 'magicBlock',
+                concrete: true,
+                tokenize: tokenizeMagicBlockFlow,
+            },
+        },
+        // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
+        text: {
+            [codes.leftSquareBracket]: {
+                name: 'magicBlock',
+                tokenize: tokenizeMagicBlockText,
+            },
+        },
+    };
+}
+/**
+ * Flow tokenizer for block-level magic blocks (multiline).
+ * Uses the continuation checking pattern from code fences.
+ */
+function tokenizeMagicBlockFlow(effects, ok, nok) {
+    // State for tracking JSON content
+    const jsonState = { escapeNext: false, inString: false };
+    const blockTypeRef = { value: '' };
+    let seenOpenBrace = false;
+    // Create shared parsers for opening marker and type capture
+    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
+    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
+    return start;
+    function start(code) {
+        if (code !== codes.leftSquareBracket)
+            return nok(code);
+        effects.enter('magicBlock');
+        effects.enter('magicBlockMarkerStart');
+        effects.consume(code);
+        return openingMarkerParser;
+    }
+    /**
+     * State before data content - handles line endings or starts data capture.
+     */
+    function beforeData(code) {
+        // EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // Line ending before any data - check continuation
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        // Check for closing marker directly (without entering data)
+        // This handles cases like [block:type]\n{}\n\n[/block] where there are
+        // newlines after the data object
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlashFromContinuation;
+        }
+        // If we've already seen the opening brace, just continue capturing data
+        if (seenOpenBrace) {
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        // Skip whitespace (spaces/tabs) before the data - stay in beforeData
+        // Don't enter magicBlockData token yet until we confirm there's a '{'
+        if (code === codes.space || code === codes.horizontalTab) {
+            return beforeDataWhitespace(code);
+        }
+        // Data must start with '{' for valid JSON
+        if (code !== codes.leftCurlyBrace) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // We have '{' - enter data token and start capturing
+        seenOpenBrace = true;
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Consume whitespace before the data without creating a token.
+     * Uses a temporary token to satisfy micromark's requirement.
+     */
+    function beforeDataWhitespace(code) {
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            // We need to consume this but can't without a token - use magicBlockData
+            // and track that we haven't seen '{' yet
+            effects.enter('magicBlockData');
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continue consuming whitespace or validate the opening brace.
+     */
+    function beforeDataWhitespaceContinue(code) {
+        if (code === null) {
+            effects.exit('magicBlockData');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            return captureData(code);
+        }
+        effects.exit('magicBlockData');
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continuation OK before we've entered data token.
+     */
+    function continuationOkBeforeData(code) {
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return beforeData; // Stay in beforeData state - don't enter magicBlockData yet
+    }
+    function captureData(code) {
+        // EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlockData');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // At line ending, check if we can continue on the next line
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (jsonState.escapeNext) {
+            jsonState.escapeNext = false;
+            effects.consume(code);
+            return captureData;
+        }
+        if (jsonState.inString) {
+            if (code === codes.backslash) {
+                jsonState.escapeNext = true;
+                effects.consume(code);
+                return captureData;
+            }
+            if (code === codes.quotationMark) {
+                jsonState.inString = false;
+            }
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.quotationMark) {
+            jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.leftSquareBracket) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlash;
+        }
+        effects.consume(code);
+        return captureData;
+    }
+    /**
+     * Called when non-lazy continuation check passes - we can continue parsing.
+     */
+    function continuationOk(code) {
+        // Consume the line ending
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return continuationStart;
+    }
+    /**
+     * Start of continuation line - check for more line endings, closing marker, or start capturing data.
+     */
+    function continuationStart(code) {
+        // Handle consecutive line endings
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        // Check if this is the start of the closing marker [/block]
+        // If so, handle it directly without entering magicBlockData
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlashFromContinuation;
+        }
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Check for closing marker slash when coming from continuation.
+     * If not a closing marker, create an empty data token and continue.
+     */
+    function expectSlashFromContinuation(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockMarkerEnd');
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        if (code === codes.slash) {
+            effects.consume(code);
+            return expectClosingB;
+        }
+        // Not a closing marker - this is data content
+        // Exit marker and enter data
+        effects.exit('magicBlockMarkerEnd');
+        effects.enter('magicBlockData');
+        // The [ was consumed by the marker, so we need to conceptually "have it" in our data
+        // But since we already consumed it into the marker, we need a different approach
+        // Re-classify: consume this character as data and continue
+        if (code === codes.quotationMark)
+            jsonState.inString = true;
+        effects.consume(code);
+        return captureData;
+    }
+    function expectSlash(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // At line ending during marker parsing
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockMarkerEnd');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (code !== codes.slash) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingB;
+    }
+    function expectClosingB(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseB) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingL;
+    }
+    function expectClosingL(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseL) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingO;
+    }
+    function expectClosingO(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseO) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingC;
+    }
+    function expectClosingC(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseC) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingK;
+    }
+    function expectClosingK(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseK) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingBracket;
+    }
+    function expectClosingBracket(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.rightSquareBracket) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        effects.exit('magicBlockMarkerEnd');
+        // Check for trailing whitespace on the same line
+        return consumeTrailing;
+    }
+    /**
+     * Consume trailing whitespace (spaces/tabs) on the same line after [/block].
+     * For concrete flow constructs, we must end at eol/eof or fail.
+     * Trailing whitespace is consumed; other content causes nok (text tokenizer handles it).
+     */
+    function consumeTrailing(code) {
+        // End of file - done
+        if (code === null) {
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Line ending - done
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Space or tab - consume as trailing whitespace
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.enter('magicBlockTrailing');
+            effects.consume(code);
+            return consumeTrailingContinue;
+        }
+        // Any other character - fail flow tokenizer, let text tokenizer handle it
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continue consuming trailing whitespace.
+     */
+    function consumeTrailingContinue(code) {
+        // End of file - done
+        if (code === null) {
+            effects.exit('magicBlockTrailing');
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Line ending - done
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockTrailing');
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // More space or tab - keep consuming
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return consumeTrailingContinue;
+        }
+        // Non-whitespace after whitespace - fail flow tokenizer
+        effects.exit('magicBlockTrailing');
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Called when we can't continue (lazy line or EOF) - exit the construct.
+     */
+    function after(code) {
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+}
+/**
+ * Text tokenizer for single-line magic blocks only.
+ * Used in inline contexts like list items and paragraphs.
+ * Multiline blocks are handled by the flow tokenizer.
+ */
+function tokenizeMagicBlockText(effects, ok, nok) {
+    // State for tracking JSON content
+    const jsonState = { escapeNext: false, inString: false };
+    const blockTypeRef = { value: '' };
+    let seenOpenBrace = false;
+    // Create shared parsers for opening marker and type capture
+    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
+    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
+    // Success handler for closing marker - exits tokens and returns ok
+    const closingSuccess = (code) => {
+        effects.exit('magicBlockMarkerEnd');
+        effects.exit('magicBlock');
+        return ok(code);
+    };
+    // Mismatch handler - falls back to data capture
+    const closingMismatch = (code) => {
+        effects.exit('magicBlockMarkerEnd');
+        effects.enter('magicBlockData');
+        if (code === codes.quotationMark)
+            jsonState.inString = true;
+        effects.consume(code);
+        return captureData;
+    };
+    // EOF handler
+    const closingEof = (_code) => nok(_code);
+    // Create closing marker parsers
+    const closingFromBeforeData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
+    const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
+    return start;
+    function start(code) {
+        if (code !== codes.leftSquareBracket)
+            return nok(code);
+        effects.enter('magicBlock');
+        effects.enter('magicBlockMarkerStart');
+        effects.consume(code);
+        return openingMarkerParser;
+    }
+    /**
+     * State before data content - handles line endings before entering data token.
+     * Whitespace before '{' is allowed.
+     */
+    function beforeData(code) {
+        // Fail on EOF - magic block must be closed
+        if (code === null) {
+            return nok(code);
+        }
+        // Handle line endings before any data - consume them without entering data token
+        if (markdownLineEnding(code)) {
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        // Check for closing marker directly (without entering data)
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return closingFromBeforeData.expectSlash;
+        }
+        // If we've already seen the opening brace, just continue capturing data
+        if (seenOpenBrace) {
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        // Skip whitespace (spaces/tabs) before the data
+        if (code === codes.space || code === codes.horizontalTab) {
+            return beforeDataWhitespace(code);
+        }
+        // Data must start with '{' for valid JSON
+        if (code !== codes.leftCurlyBrace) {
+            return nok(code);
+        }
+        // We have '{' - enter data token and start capturing
+        seenOpenBrace = true;
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Consume whitespace before the data.
+     */
+    function beforeDataWhitespace(code) {
+        if (code === null) {
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.enter('magicBlockData');
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        return nok(code);
+    }
+    /**
+     * Continue consuming whitespace or validate the opening brace.
+     */
+    function beforeDataWhitespaceContinue(code) {
+        if (code === null) {
+            effects.exit('magicBlockData');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            return captureData(code);
+        }
+        effects.exit('magicBlockData');
+        return nok(code);
+    }
+    function captureData(code) {
+        // Fail on EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlockData');
+            return nok(code);
+        }
+        // Handle multiline magic blocks within text/paragraphs
+        // Exit data, consume line ending with proper token, then re-enter data
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData; // Go back to beforeData to handle potential empty lines
+        }
+        if (jsonState.escapeNext) {
+            jsonState.escapeNext = false;
+            effects.consume(code);
+            return captureData;
+        }
+        if (jsonState.inString) {
+            if (code === codes.backslash) {
+                jsonState.escapeNext = true;
+                effects.consume(code);
+                return captureData;
+            }
+            if (code === codes.quotationMark) {
+                jsonState.inString = false;
+            }
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.quotationMark) {
+            jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.leftSquareBracket) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return closingFromData.expectSlash;
+        }
+        effects.consume(code);
+        return captureData;
+    }
+}
+/* harmony default export */ const syntax = ((/* unused pure expression or super */ null && (magicBlock)));
+
+;// ./lib/micromark/magic-block/index.ts
+/**
+ * Micromark extension for magic block syntax.
+ *
+ * Usage:
+ * ```ts
+ * import { magicBlock } from './lib/micromark/magic-block';
+ *
+ * const processor = unified()
+ *   .data('micromarkExtensions', [magicBlock()])
+ * ```
+ */
+
 
 ;// ./lib/utils/mdxish/mdxish-load-components.ts
 
@@ -115365,46 +117052,56 @@ function loadComponents() {
 
 
 
+
+
 
 
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
 function mdxishAstProcessor(mdContent, opts = {}) {
-    const { components: userComponents = {}, jsxContext = {}, useTailwind } = opts;
+    const { components: userComponents = {}, jsxContext = {}, newEditorTypes = false, safeMode = false, useTailwind, } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
     };
+    // Build set of known component names for snake_case filtering
+    const knownComponents = new Set(Object.keys(components));
     // Preprocessing pipeline: Transform content to be parser-ready
-    // Step 1: Extract legacy magic blocks
-    const { replaced: contentAfterMagicBlocks, blocks } = extractMagicBlocks(mdContent);
-    // Step 2: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
-    const contentAfterTableNormalization = normalizeTableSeparator(contentAfterMagicBlocks);
-    // Step 3: Evaluate JSX expressions in attributes
-    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
-    // Step 4: Replace snake_case component names with parser-safe placeholders
-    // (e.g., <Snake_case /> → <MDXishSnakeCase0 /> which will be restored after parsing)
-    const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation);
+    // Step 1: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
+    const contentAfterTableNormalization = normalizeTableSeparator(mdContent);
+    // Step 2: Evaluate JSX expressions in attributes
+    const contentAfterJSXEvaluation = safeMode
+        ? contentAfterTableNormalization
+        : preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
+    // Step 3: Replace snake_case component names with parser-safe placeholders
+    const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation, { knownComponents });
     // Create string map for tailwind transformer
     const tempComponentsMap = Object.entries(components).reduce((acc, [key, value]) => {
         acc[key] = String(value);
         return acc;
     }, {});
+    // Get mdxExpression extension and remove its flow construct to prevent
+    // `{...}` from interrupting paragraphs (which breaks multiline magic blocks)
+    const mdxExprExt = mdxExpression({ allowEmpty: true });
+    const mdxExprTextOnly = {
+        text: mdxExprExt.text,
+    };
     const processor = unified()
-        .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })]) // Parse inline JSX expressions as AST nodes for later evaluation
-        .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()])
+        .data('micromarkExtensions', safeMode ? [magicBlock()] : [magicBlock(), mdxExprTextOnly])
+        .data('fromMarkdownExtensions', safeMode ? [magicBlockFromMarkdown()] : [magicBlockFromMarkdown(), mdxExpressionFromMarkdown()])
         .use(remarkParse)
         .use(remarkFrontmatter)
         .use(normalize_malformed_md_syntax)
-        .use(mdxish_magic_blocks, { blocks })
+        .use(magic_block_transformer)
         .use(transform_images, { isMdxish: true })
         .use(defaultTransformers)
         .use(mdxish_component_blocks)
         .use(restore_snake_case_component_name, { mapping: snakeCaseMapping })
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
-        .use(evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
-        .use(variables_text) // Parse {user.*} patterns from text (can't rely on remarkMdx)
+        .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert JSX elements to MDAST types
+        .use(safeMode ? undefined : evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
+        .use(variables_text) // Parse {user.*} patterns from text
         .use(useTailwind ? transform_tailwind : undefined, { components: tempComponentsMap })
         .use(remarkGfm);
     return {
@@ -115421,10 +117118,14 @@ function mdxishAstProcessor(mdContent, opts = {}) {
  * Converts an Mdast to a Markdown string.
  */
 function mdxishMdastToMd(mdast) {
-    const md = unified().use(remarkGfm).use(processor_compile).use(remarkStringify, {
+    const md = unified()
+        .use(remarkGfm)
+        .use(mdxishCompilers)
+        .use(remarkStringify, {
         bullet: '-',
         emphasis: '_',
-    }).stringify(mdast);
+    })
+        .stringify(mdast);
     return md;
 }
 /**
@@ -115920,11 +117621,14 @@ const tags = (doc) => {
 
 
 
+
 const mdxishTags_tags = (doc) => {
-    const { replaced: sanitizedDoc } = extractMagicBlocks(doc);
     const set = new Set();
-    const processor = remark().use(mdxish_component_blocks);
-    const tree = processor.parse(sanitizedDoc);
+    const processor = remark()
+        .data('micromarkExtensions', [magicBlock()])
+        .data('fromMarkdownExtensions', [magicBlockFromMarkdown()])
+        .use(mdxish_component_blocks);
+    const tree = processor.parse(doc);
     visit(processor.runSync(tree), isMDXElement, (node) => {
         if (node.name?.match(/^[A-Z]/)) {
             set.add(node.name);
@@ -115945,12 +117649,15 @@ const mdxishTags_tags = (doc) => {
 
 
 
+
 /**
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
-    const { replaced, blocks } = extractMagicBlocks(doc);
-    const processor = unified();
+    const processor = unified()
+        .data('micromarkExtensions', [magicBlock()])
+        .data('fromMarkdownExtensions', [magicBlockFromMarkdown()])
+        .data('toMarkdownExtensions', [magicBlockToMarkdown()]);
     // we still require these two extensions because:
     // 1. we can rely on remarkMdx to parse MDXish
     // 2. we need to parse JSX comments into mdxTextExpression nodes so that the transformers can pick them up
@@ -115992,10 +117699,8 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 },
             ],
         });
-    const file = await processor.process(replaced);
-    const stringified = String(file).trim();
-    const restored = restoreMagicBlocks(stringified, blocks);
-    return restored;
+    const file = await processor.process(doc);
+    return String(file).trim();
 }
 /* harmony default export */ const lib_stripComments = (stripComments);