@readme/markdown 13.1.2 → 13.1.3

package/dist/lib/utils/extractMagicBlocks.d.ts

@@ -0,0 +1,25 @@
+export interface BlockHit {
+    key: string;
+    raw: string;
+    token: string;
+}
+/**
+ * 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.
+ */
+export declare const MAGIC_BLOCK_REGEX: RegExp;
+/**
+ * Extract legacy magic block syntax from a markdown string.
+ * Returns the modified markdown and an array of extracted blocks.
+ */
+export declare function extractMagicBlocks(markdown: string): {
+    replaced: string;
+    blocks: BlockHit[];
+};
+/**
+ * Restore extracted magic blocks back into a markdown string.
+ */
+export declare function restoreMagicBlocks(replaced: string, blocks: BlockHit[]): string;

package/dist/main.js

@@ -71360,6 +71360,10 @@ const types = {
     Recipe: NodeTypes.recipe,
     TutorialTile: NodeTypes.recipe, // coerce to recipe for backwards compatibility
 };
+// Node types that are phrasing (inline) content per the mdast spec. Phrasing
+// content at the document root violates the spec and causes mdx() to collapse
+// blank lines, so these must be wrapped in a paragraph when at root level.
+const phrasingTypes = new Set([NodeTypes.variable]);
 var TableNames;
 (function (TableNames) {
     TableNames["td"] = "td";
@@ -71515,7 +71519,16 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             type: types[node.name],
             position: node.position,
         };
-        parent.children[index] = mdNode;
+        // Wrap in a paragraph if at root level. Links are phrasing content and
+        // root children must all be the same category (per mdast spec). Mixing
+        // phrasing with flow content (headings, paragraphs, etc.) causes mdx()
+        // to collapse blank lines in the document.
+        if (parent.type === 'root') {
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
     }
     else if (node.name === 'Recipe' || node.name === 'TutorialTile') {
         const hProperties = getAttrs(node);
@@ -71541,7 +71554,13 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             },
             position: node.position,
         };
-        parent.children[index] = mdNode;
+        if (parent.type === 'root' && phrasingTypes.has(types[node.name])) {
+            // @ts-expect-error mdNode is typed as BlockContent but is actually phrasing content
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
     }
 };
 const readmeComponents = (opts) => () => tree => {
@@ -97742,8 +97761,59 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = (mdxishTags_tags);
 
-;// ./lib/stripComments.ts
+;// ./lib/utils/extractMagicBlocks.ts
+/**
+ * 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.
+ */
+const MAGIC_BLOCK_REGEX = /\[block:[^\]]{1,100}\](?:(?!\[block:)(?!\[\/block\])[\s\S])*\[\/block\]/g;
+/**
+ * Extract legacy magic block syntax from a markdown string.
+ * Returns the modified markdown and an array of extracted blocks.
+ */
+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 };
+}
+/**
+ * Restore extracted magic blocks back into a markdown string.
+ */
+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();
+}
 
+;// ./lib/stripComments.ts
 
 
 
@@ -97758,19 +97828,16 @@ const mdxishTags_tags = (doc) => {
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
-    const micromarkExtensions = [magicBlock()];
-    const fromMarkdownExtensions = [magicBlockFromMarkdown()];
+    const { replaced, blocks } = extractMagicBlocks(doc);
+    const processor = unified();
     // we still require these two extensions because:
-    // 1. we cant rely on remarkMdx to parse MDXish
+    // 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
     if (mdxish) {
-        micromarkExtensions.push(mdxExpression({ allowEmpty: true }));
-        fromMarkdownExtensions.push(mdxExpressionFromMarkdown());
+        processor
+            .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()]);
     }
-    const processor = unified()
-        .data('micromarkExtensions', micromarkExtensions)
-        .data('fromMarkdownExtensions', fromMarkdownExtensions)
-        .data('toMarkdownExtensions', [magicBlockToMarkdown()]);
     processor
         .use(remarkParse)
         .use(normalize_malformed_md_syntax)
@@ -97804,8 +97871,10 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 },
             ],
         });
-    const file = await processor.process(doc);
-    return String(file).trim();
+    const file = await processor.process(replaced);
+    const stringified = String(file).trim();
+    const restored = restoreMagicBlocks(stringified, blocks);
+    return restored;
 }
 /* harmony default export */ const lib_stripComments = (stripComments);
 

package/dist/main.node.js

@@ -91564,6 +91564,10 @@ const readme_components_types = {
     Recipe: NodeTypes.recipe,
     TutorialTile: NodeTypes.recipe, // coerce to recipe for backwards compatibility
 };
+// Node types that are phrasing (inline) content per the mdast spec. Phrasing
+// content at the document root violates the spec and causes mdx() to collapse
+// blank lines, so these must be wrapped in a paragraph when at root level.
+const phrasingTypes = new Set([NodeTypes.variable]);
 var TableNames;
 (function (TableNames) {
     TableNames["td"] = "td";
@@ -91719,7 +91723,16 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             type: readme_components_types[node.name],
             position: node.position,
         };
-        parent.children[index] = mdNode;
+        // Wrap in a paragraph if at root level. Links are phrasing content and
+        // root children must all be the same category (per mdast spec). Mixing
+        // phrasing with flow content (headings, paragraphs, etc.) causes mdx()
+        // to collapse blank lines in the document.
+        if (parent.type === 'root') {
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
     }
     else if (node.name === 'Recipe' || node.name === 'TutorialTile') {
         const hProperties = getAttrs(node);
@@ -91745,7 +91758,13 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             },
             position: node.position,
         };
-        parent.children[index] = mdNode;
+        if (parent.type === 'root' && phrasingTypes.has(readme_components_types[node.name])) {
+            // @ts-expect-error mdNode is typed as BlockContent but is actually phrasing content
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
     }
 };
 const readmeComponents = (opts) => () => tree => {
@@ -117946,8 +117965,59 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = (mdxishTags_tags);
 
-;// ./lib/stripComments.ts
+;// ./lib/utils/extractMagicBlocks.ts
+/**
+ * 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.
+ */
+const MAGIC_BLOCK_REGEX = /\[block:[^\]]{1,100}\](?:(?!\[block:)(?!\[\/block\])[\s\S])*\[\/block\]/g;
+/**
+ * Extract legacy magic block syntax from a markdown string.
+ * Returns the modified markdown and an array of extracted blocks.
+ */
+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 };
+}
+/**
+ * Restore extracted magic blocks back into a markdown string.
+ */
+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();
+}
 
+;// ./lib/stripComments.ts
 
 
 
@@ -117962,19 +118032,16 @@ const mdxishTags_tags = (doc) => {
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
-    const micromarkExtensions = [magicBlock()];
-    const fromMarkdownExtensions = [magicBlockFromMarkdown()];
+    const { replaced, blocks } = extractMagicBlocks(doc);
+    const processor = unified();
     // we still require these two extensions because:
-    // 1. we cant rely on remarkMdx to parse MDXish
+    // 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
     if (mdxish) {
-        micromarkExtensions.push(mdxExpression({ allowEmpty: true }));
-        fromMarkdownExtensions.push(mdxExpressionFromMarkdown());
+        processor
+            .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()]);
     }
-    const processor = unified()
-        .data('micromarkExtensions', micromarkExtensions)
-        .data('fromMarkdownExtensions', fromMarkdownExtensions)
-        .data('toMarkdownExtensions', [magicBlockToMarkdown()]);
     processor
         .use(remarkParse)
         .use(normalize_malformed_md_syntax)
@@ -118008,8 +118075,10 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 },
             ],
         });
-    const file = await processor.process(doc);
-    return String(file).trim();
+    const file = await processor.process(replaced);
+    const stringified = String(file).trim();
+    const restored = restoreMagicBlocks(stringified, blocks);
+    return restored;
 }
 /* harmony default export */ const lib_stripComments = (stripComments);