@readme/markdown 14.10.0 → 14.10.2

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,43 @@ 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)) };
+};
+/**
+ * Build a position ending right after the last occurrence of `closingTag` within
+ * this node's span in the original source. Used in the trailing-content path so
+ * the offset is computed against the real source bytes (including blockquote/list
+ * prefixes that were stripped from the html node's value).
+ */
+const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) => {
+    if (!nodePosition?.start || !nodePosition.end)
+        return nodePosition;
+    const nodeSource = source.slice(nodePosition.start.offset, nodePosition.end.offset);
+    const closingTagOffset = nodeSource.lastIndexOf(closingTag);
+    if (closingTagOffset === -1)
+        return nodePosition;
+    const consumed = nodeSource.slice(0, closingTagOffset + closingTag.length);
+    return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumed) };
+};
 /**
  * Create an MdxJsxFlowElement node from component data.
  */
@@ -121986,9 +122033,10 @@ const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
  * The opening tag, content, and closing tag are all captured in one HTML node
  * (guaranteed by the mdx-component tokenizer).
  */
-const mdxishMdxComponentBlocks = (opts = {}) => tree => {
+const mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
     const stack = [tree];
     const safeMode = !!opts.safeMode;
+    const source = file?.value ? String(file.value) : null;
     const parseOpts = { preserveExpressionsAsText: safeMode };
     const processChildNode = (parent, index) => {
         const node = parent.children[index];
@@ -122002,10 +122050,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 +122084,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 +122117,17 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
+                // When trailing content follows the closing tag, compute the end position precisely
+                // within the html node's value so the component doesn't claim that content.
+                // Prefer source-based positioning when the original source is available: the html
+                // node's value has '> '/space prefixes stripped for blockquotes/list items, so
+                // positionEndingAtConsumed would undercount source offsets. When the entire node
+                // is consumed, use the original node position directly.
+                endPosition: contentAfterClose
+                    ? source
+                        ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
+                        : positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length)
+                    : node.position,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
             // After the closing tag, there might be more content to be processed
@@ -124331,6 +124398,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 +124431,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 +124500,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 +124524,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 +126032,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);