@readme/markdown 14.10.0 → 14.10.1

package/dist/main.js

@@ -76783,6 +76783,7 @@ const readmeComponents = (opts) => () => tree => {
 
 
 
+
 const imageAttrs = ['align', 'alt', 'caption', 'border', 'height', 'src', 'title', 'width', 'lazy', 'className'];
 const readmeToMdx = () => tree => {
     // Unwrap pinned nodes, replace rdme-pin with its child node
@@ -76873,7 +76874,11 @@ const readmeToMdx = () => tree => {
         }
     });
     visit(tree, NodeTypes.imageBlock, (image, index, parent) => {
-        const attributes = toAttributes({ ...image, ...image.data.hProperties }, imageAttrs);
+        // Special case for caption: Captions are parsed as children of the image node, so we need to extract them explicitly
+        const captionChildren = Array.isArray(image.children) ? image.children : [];
+        // We want to add it back to the attributes, so re-serialize it to string
+        const caption = captionChildren.length ? toMarkdown({ type: 'root', children: captionChildren }).trim() : '';
+        const attributes = toAttributes({ ...image, ...image.data.hProperties, ...(caption && { caption }) }, imageAttrs);
         if (hasExtra(attributes)) {
             parent.children.splice(index, 1, {
                 type: 'mdxJsxFlowElement',
@@ -98611,6 +98616,11 @@ function smartCamelCase(str) {
     if (str.includes('-')) {
         return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
     }
+    // Keys that already carry casing (e.g. `cardWidth`) are correct as-is; running
+    // boundary matching over them mangles inner matches (e.g. `id` inside `Width`).
+    if (/[A-Z]/.test(str)) {
+        return str;
+    }
     const allBoundaries = [...REACT_HTML_PROP_BOUNDARIES, ...CSS_STYLE_PROP_BOUNDARIES, ...CUSTOM_PROP_BOUNDARIES];
     // Return as-is if already a boundary word to avoid incorrect splitting
     if (allBoundaries.includes(str.toLowerCase())) {
@@ -101719,6 +101729,27 @@ const parseSibling = (stack, parent, index, sibling, safeMode) => {
         stack.push(parent);
     }
 };
+/**
+ * Advance a point by the substring of source consumed from it.
+ */
+const pointAfter = (start, consumed) => {
+    const newlineIndex = consumed.lastIndexOf('\n');
+    const newlineCount = newlineIndex === -1 ? 0 : consumed.split('\n').length - 1;
+    return {
+        line: start.line + newlineCount,
+        column: newlineCount === 0 ? start.column + consumed.length : consumed.length - newlineIndex,
+        offset: start.offset + consumed.length,
+    };
+};
+/**
+ * Build a position ending at `consumedLength` into the html node's value, so the
+ * component doesn't claim trailing content the tokenizer swallowed into one node.
+ */
+const positionEndingAtConsumed = (nodePosition, value, consumedLength) => {
+    if (!nodePosition?.start)
+        return nodePosition;
+    return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
+};
 /**
  * Create an MdxJsxFlowElement node from component data.
  */
@@ -101778,10 +101809,16 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
         const value = node.value;
         if (node.type !== 'html' || typeof value !== 'string')
             return;
-        const parsed = parseTag(value.trim(), parseOpts);
+        const trimmed = value.trim();
+        const parsed = parseTag(trimmed, parseOpts);
         if (!parsed)
             return;
         const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
+        // Offset of `trimmed` within the (possibly whitespace-padded) html node value,
+        // so consumed-length math maps back onto the node's real source offsets.
+        const leadingWhitespace = value.length - value.trimStart().length;
+        // Index right after the opening tag's `>` within `trimmed`.
+        const openingTagEnd = trimmed.length - contentAfterTag.length;
         // Skip tags that have dedicated transformers
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
             return;
@@ -101806,6 +101843,8 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
                 attributes,
                 children: [],
                 startPosition: node.position,
+                // End at the self-closing tag, not at any trailing content.
+                endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
             // Check and parse if there's relevant content after the current closing tag
@@ -101837,6 +101876,8 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
+                // End at the closing tag, not at trailing content re-parsed as siblings below.
+                endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
             // After the closing tag, there might be more content to be processed
@@ -104107,6 +104148,24 @@ function restoreHTMLElements(content, htmlElements) {
         return content;
     return content.replace(HTML_ELEM_PLACEHOLDER, (_m, idx) => htmlElements[parseInt(idx, 10)]);
 }
+const ESM_DECLARATION_START = /^(?:export|import)\b/;
+/**
+ * Whether a line begins a top-level `export`/`import` declaration. Its braces
+ * are valid JS owned by the mdxjsEsm tokenizer (which tolerates blank lines),
+ * so escaping them would corrupt the source and break acorn parsing.
+ */
+function startsEsmDeclaration(chars, lineStart) {
+    return ESM_DECLARATION_START.test(chars.slice(lineStart, lineStart + 7).join(''));
+}
+function isBlankLine(chars, lineStart) {
+    for (let i = lineStart; i < chars.length; i += 1) {
+        if (chars[i] === '\n')
+            return true;
+        if (chars[i] !== ' ' && chars[i] !== '\t')
+            return false;
+    }
+    return true;
+}
 /**
  * Escapes unbalanced and paragraph-spanning braces so MDX doesn't trip on them.
  */
@@ -104122,8 +104181,18 @@ function escapeProblematicBraces(content) {
     // Convert to array of Unicode code points so that emojis and multi-byte characters are correctly tracked
     const chars = Array.from(protectedContent);
     const openStack = [];
+    // Whether the current top-level statement is an `export`/`import` declaration.
+    let insideEsmDeclaration = false;
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
+        // At a top-level (brace depth 0) line start, decide whether we're inside an
+        // ESM declaration. The flag persists across the declaration's own lines.
+        if (openStack.length === 0 && (i === 0 || chars[i - 1] === '\n')) {
+            if (startsEsmDeclaration(chars, i))
+                insideEsmDeclaration = true;
+            else if (isBlankLine(chars, i))
+                insideEsmDeclaration = false;
+        }
         // Track string delimiters inside expressions to ignore braces within them
         if (openStack.length > 0) {
             if (strDelim) {
@@ -104181,19 +104250,22 @@ function escapeProblematicBraces(content) {
             if (!isAttrExpr && openStack.length > 0 && openStack[openStack.length - 1].isAttrExpr) {
                 isAttrExpr = true;
             }
-            openStack.push({ pos: i, hasBlankLine: false, isAttrExpr });
+            openStack.push({ pos: i, hasBlankLine: false, isAttrExpr, isEsmDeclaration: insideEsmDeclaration });
             lastNewlinePos = -2;
         }
         else if (ch === '}') {
             if (openStack.length > 0) {
                 const entry = openStack.pop();
+                // The declaration's braces are closed; later top-level braces are not ESM.
+                if (openStack.length === 0)
+                    insideEsmDeclaration = false;
                 // Pure `{/* ... */}` comments are handled downstream by the jsxComment
                 // tokenizer — escaping their braces would prevent it from running.
                 const isPureJsxComment = chars[entry.pos + 1] === '/' &&
                     chars[entry.pos + 2] === '*' &&
                     chars[i - 1] === '/' &&
                     chars[i - 2] === '*';
-                if (entry.hasBlankLine && !isPureJsxComment && !entry.isAttrExpr) {
+                if (entry.hasBlankLine && !isPureJsxComment && !entry.isAttrExpr && !entry.isEsmDeclaration) {
                     toEscape.add(entry.pos);
                     toEscape.add(i);
                 }
@@ -104202,9 +104274,16 @@ function escapeProblematicBraces(content) {
                 toEscape.add(i);
             }
         }
+        else if (ch === ';' && openStack.length === 0) {
+            // A top-level `;` ends the current statement, ESM or otherwise.
+            insideEsmDeclaration = false;
+        }
     }
     // Anything still open is unbalanced.
-    openStack.forEach(entry => toEscape.add(entry.pos));
+    openStack.forEach(entry => {
+        if (!entry.isEsmDeclaration)
+            toEscape.add(entry.pos);
+    });
     // Reconstruct the content with the escaped braces.
     const escapedContent = toEscape.size === 0 ? protectedContent : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
     return restoreHTMLElements(escapedContent, htmlElements);
@@ -105703,11 +105782,18 @@ function exportComponentsForRehype(components) {
  * semantics). That breaks any component prop that is genuinely an array. With
  * `passNode: true` we get the original hast node in `props.node` for components
  * and can read the raw properties directly.
+ *
+ * Only arrays win over `rest`, overwriting other shapes would undo correct
+ * React conversions like `style="color:red"` → `{ color: 'red' }`.
  */
 function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
-        const mergedProps = { ...rest, ...node.properties };
+        const mergedProps = { ...rest };
+        Object.entries(node.properties).forEach(([key, value]) => {
+            if (Array.isArray(value))
+                mergedProps[key] = value;
+        });
         // Strip undefined so positional args don't shadow node.properties.children
         const definedChildren = children.filter(c => c !== undefined);
         return external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement(type, mergedProps, ...definedChildren);

package/dist/main.node.js

@@ -97007,6 +97007,7 @@ const readmeComponents = (opts) => () => tree => {
 
 
 
+
 const imageAttrs = ['align', 'alt', 'caption', 'border', 'height', 'src', 'title', 'width', 'lazy', 'className'];
 const readmeToMdx = () => tree => {
     // Unwrap pinned nodes, replace rdme-pin with its child node
@@ -97097,7 +97098,11 @@ const readmeToMdx = () => tree => {
         }
     });
     visit(tree, NodeTypes.imageBlock, (image, index, parent) => {
-        const attributes = toAttributes({ ...image, ...image.data.hProperties }, imageAttrs);
+        // Special case for caption: Captions are parsed as children of the image node, so we need to extract them explicitly
+        const captionChildren = Array.isArray(image.children) ? image.children : [];
+        // We want to add it back to the attributes, so re-serialize it to string
+        const caption = captionChildren.length ? toMarkdown({ type: 'root', children: captionChildren }).trim() : '';
+        const attributes = toAttributes({ ...image, ...image.data.hProperties, ...(caption && { caption }) }, imageAttrs);
         if (hasExtra(attributes)) {
             parent.children.splice(index, 1, {
                 type: 'mdxJsxFlowElement',
@@ -118835,6 +118840,11 @@ function smartCamelCase(str) {
     if (str.includes('-')) {
         return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
     }
+    // Keys that already carry casing (e.g. `cardWidth`) are correct as-is; running
+    // boundary matching over them mangles inner matches (e.g. `id` inside `Width`).
+    if (/[A-Z]/.test(str)) {
+        return str;
+    }
     const allBoundaries = [...REACT_HTML_PROP_BOUNDARIES, ...CSS_STYLE_PROP_BOUNDARIES, ...CUSTOM_PROP_BOUNDARIES];
     // Return as-is if already a boundary word to avoid incorrect splitting
     if (allBoundaries.includes(str.toLowerCase())) {
@@ -121943,6 +121953,27 @@ const parseSibling = (stack, parent, index, sibling, safeMode) => {
         stack.push(parent);
     }
 };
+/**
+ * Advance a point by the substring of source consumed from it.
+ */
+const pointAfter = (start, consumed) => {
+    const newlineIndex = consumed.lastIndexOf('\n');
+    const newlineCount = newlineIndex === -1 ? 0 : consumed.split('\n').length - 1;
+    return {
+        line: start.line + newlineCount,
+        column: newlineCount === 0 ? start.column + consumed.length : consumed.length - newlineIndex,
+        offset: start.offset + consumed.length,
+    };
+};
+/**
+ * Build a position ending at `consumedLength` into the html node's value, so the
+ * component doesn't claim trailing content the tokenizer swallowed into one node.
+ */
+const positionEndingAtConsumed = (nodePosition, value, consumedLength) => {
+    if (!nodePosition?.start)
+        return nodePosition;
+    return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
+};
 /**
  * Create an MdxJsxFlowElement node from component data.
  */
@@ -122002,10 +122033,16 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
         const value = node.value;
         if (node.type !== 'html' || typeof value !== 'string')
             return;
-        const parsed = parseTag(value.trim(), parseOpts);
+        const trimmed = value.trim();
+        const parsed = parseTag(trimmed, parseOpts);
         if (!parsed)
             return;
         const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
+        // Offset of `trimmed` within the (possibly whitespace-padded) html node value,
+        // so consumed-length math maps back onto the node's real source offsets.
+        const leadingWhitespace = value.length - value.trimStart().length;
+        // Index right after the opening tag's `>` within `trimmed`.
+        const openingTagEnd = trimmed.length - contentAfterTag.length;
         // Skip tags that have dedicated transformers
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
             return;
@@ -122030,6 +122067,8 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
                 attributes,
                 children: [],
                 startPosition: node.position,
+                // End at the self-closing tag, not at any trailing content.
+                endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
             // Check and parse if there's relevant content after the current closing tag
@@ -122061,6 +122100,8 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
+                // End at the closing tag, not at trailing content re-parsed as siblings below.
+                endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
             // After the closing tag, there might be more content to be processed
@@ -124331,6 +124372,24 @@ function restoreHTMLElements(content, htmlElements) {
         return content;
     return content.replace(HTML_ELEM_PLACEHOLDER, (_m, idx) => htmlElements[parseInt(idx, 10)]);
 }
+const ESM_DECLARATION_START = /^(?:export|import)\b/;
+/**
+ * Whether a line begins a top-level `export`/`import` declaration. Its braces
+ * are valid JS owned by the mdxjsEsm tokenizer (which tolerates blank lines),
+ * so escaping them would corrupt the source and break acorn parsing.
+ */
+function startsEsmDeclaration(chars, lineStart) {
+    return ESM_DECLARATION_START.test(chars.slice(lineStart, lineStart + 7).join(''));
+}
+function isBlankLine(chars, lineStart) {
+    for (let i = lineStart; i < chars.length; i += 1) {
+        if (chars[i] === '\n')
+            return true;
+        if (chars[i] !== ' ' && chars[i] !== '\t')
+            return false;
+    }
+    return true;
+}
 /**
  * Escapes unbalanced and paragraph-spanning braces so MDX doesn't trip on them.
  */
@@ -124346,8 +124405,18 @@ function escapeProblematicBraces(content) {
     // Convert to array of Unicode code points so that emojis and multi-byte characters are correctly tracked
     const chars = Array.from(protectedContent);
     const openStack = [];
+    // Whether the current top-level statement is an `export`/`import` declaration.
+    let insideEsmDeclaration = false;
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
+        // At a top-level (brace depth 0) line start, decide whether we're inside an
+        // ESM declaration. The flag persists across the declaration's own lines.
+        if (openStack.length === 0 && (i === 0 || chars[i - 1] === '\n')) {
+            if (startsEsmDeclaration(chars, i))
+                insideEsmDeclaration = true;
+            else if (isBlankLine(chars, i))
+                insideEsmDeclaration = false;
+        }
         // Track string delimiters inside expressions to ignore braces within them
         if (openStack.length > 0) {
             if (strDelim) {
@@ -124405,19 +124474,22 @@ function escapeProblematicBraces(content) {
             if (!isAttrExpr && openStack.length > 0 && openStack[openStack.length - 1].isAttrExpr) {
                 isAttrExpr = true;
             }
-            openStack.push({ pos: i, hasBlankLine: false, isAttrExpr });
+            openStack.push({ pos: i, hasBlankLine: false, isAttrExpr, isEsmDeclaration: insideEsmDeclaration });
             lastNewlinePos = -2;
         }
         else if (ch === '}') {
             if (openStack.length > 0) {
                 const entry = openStack.pop();
+                // The declaration's braces are closed; later top-level braces are not ESM.
+                if (openStack.length === 0)
+                    insideEsmDeclaration = false;
                 // Pure `{/* ... */}` comments are handled downstream by the jsxComment
                 // tokenizer — escaping their braces would prevent it from running.
                 const isPureJsxComment = chars[entry.pos + 1] === '/' &&
                     chars[entry.pos + 2] === '*' &&
                     chars[i - 1] === '/' &&
                     chars[i - 2] === '*';
-                if (entry.hasBlankLine && !isPureJsxComment && !entry.isAttrExpr) {
+                if (entry.hasBlankLine && !isPureJsxComment && !entry.isAttrExpr && !entry.isEsmDeclaration) {
                     toEscape.add(entry.pos);
                     toEscape.add(i);
                 }
@@ -124426,9 +124498,16 @@ function escapeProblematicBraces(content) {
                 toEscape.add(i);
             }
         }
+        else if (ch === ';' && openStack.length === 0) {
+            // A top-level `;` ends the current statement, ESM or otherwise.
+            insideEsmDeclaration = false;
+        }
     }
     // Anything still open is unbalanced.
-    openStack.forEach(entry => toEscape.add(entry.pos));
+    openStack.forEach(entry => {
+        if (!entry.isEsmDeclaration)
+            toEscape.add(entry.pos);
+    });
     // Reconstruct the content with the escaped braces.
     const escapedContent = toEscape.size === 0 ? protectedContent : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
     return restoreHTMLElements(escapedContent, htmlElements);
@@ -125927,11 +126006,18 @@ function exportComponentsForRehype(components) {
  * semantics). That breaks any component prop that is genuinely an array. With
  * `passNode: true` we get the original hast node in `props.node` for components
  * and can read the raw properties directly.
+ *
+ * Only arrays win over `rest`, overwriting other shapes would undo correct
+ * React conversions like `style="color:red"` → `{ color: 'red' }`.
  */
 function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
-        const mergedProps = { ...rest, ...node.properties };
+        const mergedProps = { ...rest };
+        Object.entries(node.properties).forEach(([key, value]) => {
+            if (Array.isArray(value))
+                mergedProps[key] = value;
+        });
         // Strip undefined so positional args don't shadow node.properties.children
         const definedChildren = children.filter(c => c !== undefined);
         return external_react_default().createElement(type, mergedProps, ...definedChildren);