@readme/markdown 13.1.2 → 13.1.4

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

@@ -70954,13 +70954,15 @@ const scanForClosingTag = (parent, startIndex, tag) => {
             if (isClosingTag(siblingValue, tag)) {
                 return { closingIndex: i, extraClosingChildren: [] };
             }
-            // Embedded closing tag (closing tag at end of HTML block content)
+            // Embedded closing tag (closing tag within HTML block content)
             if (siblingValue.includes(closingTagStr)) {
-                const contentBeforeClose = siblingValue.substring(0, siblingValue.lastIndexOf(closingTagStr)).trim();
+                const closeTagPos = siblingValue.indexOf(closingTagStr);
+                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
+                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
                 const extraChildren = contentBeforeClose
                     ? parseMdChildren(contentBeforeClose)
                     : [];
-                return { closingIndex: i, extraClosingChildren: extraChildren };
+                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
             }
         }
         // Check paragraph siblings
@@ -71105,7 +71107,7 @@ const mdxishComponentBlocks = () => tree => {
         const scanResult = scanForClosingTag(parent, index, tag);
         if (!scanResult)
             return;
-        const { closingIndex, extraClosingChildren, strippedParagraph } = scanResult;
+        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
         const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
         // Collect all intermediate siblings between opening tag and closing tag
         const intermediateChildren = parent.children.slice(index + 1, closingIndex);
@@ -71128,6 +71130,11 @@ const mdxishComponentBlocks = () => tree => {
         if (componentNode.children.length > 0) {
             stack.push(componentNode);
         }
+        // If the closing tag sibling had content after it (e.g., another component opening tag),
+        // re-insert it as a sibling so it can be processed in subsequent iterations
+        if (remainingAfterClose) {
+            parseSibling(stack, parent, index, remainingAfterClose);
+        }
     };
     // Process the nodes with the components depth-first to maintain the correct order of the nodes
     while (stack.length) {
@@ -71360,6 +71367,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 +71526,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 +71561,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 => {
@@ -93425,7 +93451,7 @@ function isActualHtmlTag(tagName, originalExcerpt) {
     return false;
 }
 /** Parse and replace text children with processed markdown */
-function parseTextChildren(node, processMarkdown) {
+function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
         return;
     // First pass: Recursively process text children as they may contain stringified markdown / mdx content
@@ -93440,6 +93466,27 @@ function parseTextChildren(node, processMarkdown) {
         }
         return children;
     });
+    // Unwrap <p> elements whose meaningful children are ALL components.
+    // The markdown parser wraps inline content in <p> tags, but when that content
+    // is actually component children (e.g., <Tab> inside <Tabs>), the wrapper
+    // should be removed so components appear as direct children.
+    // Only unwrap when every non-whitespace, non-br child is a known component
+    // to avoid breaking paragraphs with mixed content (text + inline HTML like <code>).
+    node.children = node.children.flatMap(child => {
+        if (child.type !== 'element' || child.tagName !== 'p')
+            return [child];
+        const meaningfulChildren = child.children.filter(gc => {
+            if (gc.type === 'text' && !gc.value.trim())
+                return false;
+            if (gc.type === 'element' && gc.tagName === 'br')
+                return false;
+            return true;
+        });
+        const allComponents = meaningfulChildren.length > 0 && meaningfulChildren.every(gc => gc.type === 'element' && getComponentName(gc.tagName, components));
+        if (!allComponents)
+            return [child];
+        return meaningfulChildren;
+    });
     // Post-processing: remove whitespace-only text nodes if all siblings are components
     // This prevents whitespace between component children from being counted as extra children
     if (areAllChildrenComponents(node.children)) {
@@ -93494,7 +93541,7 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             }
             node.tagName = componentName;
             normalizeProperties(node);
-            parseTextChildren(node, processMarkdown);
+            parseTextChildren(node, processMarkdown, components);
         });
         // Remove unknown components in reverse order to preserve indices
         for (let i = nodesToRemove.length - 1; i >= 0; i -= 1) {
@@ -93795,8 +93842,10 @@ function escapeUnbalancedBraces(content) {
     const unbalanced = new Set();
     let strDelim = null;
     let strEscaped = false;
-    for (let i = 0; i < content.length; i += 1) {
-        const ch = content[i];
+    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
+    const chars = Array.from(content);
+    for (let i = 0; i < chars.length; i += 1) {
+        const ch = chars[i];
         // Track strings inside expressions to ignore braces within them
         if (opens.length > 0) {
             if (strDelim) {
@@ -93818,7 +93867,7 @@ function escapeUnbalancedBraces(content) {
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
             let bs = 0;
-            for (let j = i - 1; j >= 0 && content[j] === '\\'; j -= 1)
+            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
                 bs += 1;
             if (bs % 2 === 1) {
                 // eslint-disable-next-line no-continue
@@ -93837,7 +93886,7 @@ function escapeUnbalancedBraces(content) {
     opens.forEach(pos => unbalanced.add(pos));
     if (unbalanced.size === 0)
         return content;
-    return Array.from(content)
+    return chars
         .map((ch, i) => (unbalanced.has(i) ? `\\${ch}` : ch))
         .join('');
 }
@@ -97742,8 +97791,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 +97858,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 +97901,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

@@ -91158,13 +91158,15 @@ const scanForClosingTag = (parent, startIndex, tag) => {
             if (isClosingTag(siblingValue, tag)) {
                 return { closingIndex: i, extraClosingChildren: [] };
             }
-            // Embedded closing tag (closing tag at end of HTML block content)
+            // Embedded closing tag (closing tag within HTML block content)
             if (siblingValue.includes(closingTagStr)) {
-                const contentBeforeClose = siblingValue.substring(0, siblingValue.lastIndexOf(closingTagStr)).trim();
+                const closeTagPos = siblingValue.indexOf(closingTagStr);
+                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
+                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
                 const extraChildren = contentBeforeClose
                     ? parseMdChildren(contentBeforeClose)
                     : [];
-                return { closingIndex: i, extraClosingChildren: extraChildren };
+                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
             }
         }
         // Check paragraph siblings
@@ -91309,7 +91311,7 @@ const mdxishComponentBlocks = () => tree => {
         const scanResult = scanForClosingTag(parent, index, tag);
         if (!scanResult)
             return;
-        const { closingIndex, extraClosingChildren, strippedParagraph } = scanResult;
+        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
         const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
         // Collect all intermediate siblings between opening tag and closing tag
         const intermediateChildren = parent.children.slice(index + 1, closingIndex);
@@ -91332,6 +91334,11 @@ const mdxishComponentBlocks = () => tree => {
         if (componentNode.children.length > 0) {
             stack.push(componentNode);
         }
+        // If the closing tag sibling had content after it (e.g., another component opening tag),
+        // re-insert it as a sibling so it can be processed in subsequent iterations
+        if (remainingAfterClose) {
+            parseSibling(stack, parent, index, remainingAfterClose);
+        }
     };
     // Process the nodes with the components depth-first to maintain the correct order of the nodes
     while (stack.length) {
@@ -91564,6 +91571,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 +91730,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 +91765,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 => {
@@ -113629,7 +113655,7 @@ function isActualHtmlTag(tagName, originalExcerpt) {
     return false;
 }
 /** Parse and replace text children with processed markdown */
-function parseTextChildren(node, processMarkdown) {
+function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
         return;
     // First pass: Recursively process text children as they may contain stringified markdown / mdx content
@@ -113644,6 +113670,27 @@ function parseTextChildren(node, processMarkdown) {
         }
         return children;
     });
+    // Unwrap <p> elements whose meaningful children are ALL components.
+    // The markdown parser wraps inline content in <p> tags, but when that content
+    // is actually component children (e.g., <Tab> inside <Tabs>), the wrapper
+    // should be removed so components appear as direct children.
+    // Only unwrap when every non-whitespace, non-br child is a known component
+    // to avoid breaking paragraphs with mixed content (text + inline HTML like <code>).
+    node.children = node.children.flatMap(child => {
+        if (child.type !== 'element' || child.tagName !== 'p')
+            return [child];
+        const meaningfulChildren = child.children.filter(gc => {
+            if (gc.type === 'text' && !gc.value.trim())
+                return false;
+            if (gc.type === 'element' && gc.tagName === 'br')
+                return false;
+            return true;
+        });
+        const allComponents = meaningfulChildren.length > 0 && meaningfulChildren.every(gc => gc.type === 'element' && getComponentName(gc.tagName, components));
+        if (!allComponents)
+            return [child];
+        return meaningfulChildren;
+    });
     // Post-processing: remove whitespace-only text nodes if all siblings are components
     // This prevents whitespace between component children from being counted as extra children
     if (areAllChildrenComponents(node.children)) {
@@ -113698,7 +113745,7 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             }
             node.tagName = componentName;
             normalizeProperties(node);
-            parseTextChildren(node, processMarkdown);
+            parseTextChildren(node, processMarkdown, components);
         });
         // Remove unknown components in reverse order to preserve indices
         for (let i = nodesToRemove.length - 1; i >= 0; i -= 1) {
@@ -113999,8 +114046,10 @@ function escapeUnbalancedBraces(content) {
     const unbalanced = new Set();
     let strDelim = null;
     let strEscaped = false;
-    for (let i = 0; i < content.length; i += 1) {
-        const ch = content[i];
+    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
+    const chars = Array.from(content);
+    for (let i = 0; i < chars.length; i += 1) {
+        const ch = chars[i];
         // Track strings inside expressions to ignore braces within them
         if (opens.length > 0) {
             if (strDelim) {
@@ -114022,7 +114071,7 @@ function escapeUnbalancedBraces(content) {
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
             let bs = 0;
-            for (let j = i - 1; j >= 0 && content[j] === '\\'; j -= 1)
+            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
                 bs += 1;
             if (bs % 2 === 1) {
                 // eslint-disable-next-line no-continue
@@ -114041,7 +114090,7 @@ function escapeUnbalancedBraces(content) {
     opens.forEach(pos => unbalanced.add(pos));
     if (unbalanced.size === 0)
         return content;
-    return Array.from(content)
+    return chars
         .map((ch, i) => (unbalanced.has(i) ? `\\${ch}` : ch))
         .join('');
 }
@@ -117946,8 +117995,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 +118062,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 +118105,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);