@readme/markdown 14.1.4 → 14.2.1

package/dist/main.node.js

@@ -73519,9 +73519,16 @@ function formatHtmlForMdxish(html) {
     }
     // Removes the leading/trailing newlines
     let cleaned = processed.replace(/^\s*\n|\n\s*$/g, '');
-    // Convert literal \n sequences to actual newlines BEFORE processing backticks
-    // This prevents the backtick unescaping regex from incorrectly matching \n sequences
-    cleaned = cleaned.replace(/\\n/g, '\n');
+    // Convert literal \n sequences to actual newlines only inside <pre> and <code>.
+    // Because <pre> needs to respect the newline visual and
+    // escape characters should be processed in the <code> tag.
+    //
+    // We don't want to unescape every \n because it might break the HTML & cause errors
+    // Example: <script>console.log("\n");</script>
+    // Would get turned into: <script>console.log("
+    // ");</script>
+    // which is invalid javascript and will cause error
+    cleaned = cleaned.replace(/(<(pre|code)\b[^>]*>)([\s\S]*?)(<\/\2>)/gi, (_m, open, _tag, inner, close) => open + inner.replace(/\\n/g, '\n') + close);
     // Unescape backticks: \` -> ` (users escape backticks in template literals)
     // Handle both cases: \` (adjacent) and \ followed by ` (split by markdown parser)
     cleaned = cleaned.replace(/\\`/g, '`');
@@ -91417,6 +91424,87 @@ function gemojiFromMarkdown() {
     };
 }
 
+;// ./lib/mdast-util/legacy-variable/index.ts
+
+const contextMap = new WeakMap();
+function findlegacyVariableToken() {
+    // tokenStack is micromark's current open token ancestry; find the nearest legacyVariable token.
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const token = events[i][0];
+        if (token.type === 'legacyVariable')
+            return token;
+    }
+    return undefined;
+}
+function enterlegacyVariable(token) {
+    contextMap.set(token, { value: '' });
+}
+function exitlegacyVariableValue(token) {
+    const variableToken = findlegacyVariableToken.call(this);
+    if (!variableToken)
+        return;
+    const ctx = contextMap.get(variableToken);
+    // Build up the variable characters
+    if (ctx)
+        ctx.value += this.sliceSerialize(token);
+}
+function exitlegacyVariable(token) {
+    const ctx = contextMap.get(token);
+    const serialized = this.sliceSerialize(token);
+    const variableName = serialized.startsWith('<<') && serialized.endsWith('>>')
+        ? serialized.slice(2, -2)
+        : ctx?.value ?? '';
+    const nodePosition = {
+        start: {
+            offset: token.start.offset,
+            line: token.start.line,
+            column: token.start.column,
+        },
+        end: {
+            offset: token.end.offset,
+            line: token.end.line,
+            column: token.end.column,
+        },
+    };
+    if (variableName.startsWith('glossary:')) {
+        const term = variableName.slice('glossary:'.length).trim();
+        this.enter({
+            type: NodeTypes.glossary,
+            data: {
+                hName: 'Glossary',
+                hProperties: { term },
+            },
+            children: [{ type: 'text', value: term }],
+            position: nodePosition,
+        }, token);
+        this.exit(token);
+        contextMap.delete(token);
+        return;
+    }
+    this.enter({
+        type: NodeTypes.variable,
+        data: {
+            hName: 'Variable',
+            hProperties: { name: variableName.trim(), isLegacy: true },
+        },
+        value: `<<${variableName}>>`,
+    }, token);
+    this.exit(token);
+    contextMap.delete(token);
+}
+function legacyVariableFromMarkdown() {
+    return {
+        enter: {
+            legacyVariable: enterlegacyVariable,
+        },
+        exit: {
+            legacyVariableValue: exitlegacyVariableValue,
+            legacyVariable: exitlegacyVariable,
+        },
+    };
+}
+
 ;// ./node_modules/micromark-util-symbol/lib/codes.js
 /**
  * Character codes.
@@ -91670,6 +91758,74 @@ function syntax_gemoji() {
  */
 
 
+;// ./lib/micromark/legacy-variable/syntax.ts
+
+
+function isAllowedValueChar(code) {
+    return (code !== null &&
+        code !== codes.lessThan &&
+        code !== codes.greaterThan &&
+        !markdownLineEnding(code));
+}
+const legacyVariableConstruct = {
+    name: 'legacyVariable',
+    tokenize: syntax_tokenize,
+};
+function syntax_tokenize(effects, ok, nok) {
+    let hasValue = false;
+    const start = (code) => {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.enter('legacyVariable');
+        effects.enter('legacyVariableMarkerStart');
+        effects.consume(code); // <
+        return open2;
+    };
+    const open2 = (code) => {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.consume(code); // <<
+        effects.exit('legacyVariableMarkerStart');
+        effects.enter('legacyVariableValue');
+        return value;
+    };
+    const value = (code) => {
+        if (code === codes.greaterThan) {
+            if (!hasValue)
+                return nok(code);
+            effects.exit('legacyVariableValue');
+            effects.enter('legacyVariableMarkerEnd');
+            effects.consume(code); // >
+            return close2;
+        }
+        if (!isAllowedValueChar(code))
+            return nok(code);
+        hasValue = true;
+        effects.consume(code);
+        return value;
+    };
+    const close2 = (code) => {
+        if (code !== codes.greaterThan)
+            return nok(code);
+        effects.consume(code); // >>
+        effects.exit('legacyVariableMarkerEnd');
+        effects.exit('legacyVariable');
+        return ok;
+    };
+    return start;
+}
+function legacyVariable() {
+    return {
+        text: { [codes.lessThan]: legacyVariableConstruct },
+    };
+}
+
+;// ./lib/micromark/legacy-variable/index.ts
+/**
+ * Micromark extension for <<variable>> / <<glossary:term>> inline syntax.
+ */
+
+
 ;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
 
 // Marker patterns for multi-node emphasis detection
@@ -92048,20 +92204,59 @@ const unwrapSoleParagraph = (children) => {
 
 
 
+
+
+
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
 const tableTypes = {
     tr: 'tableRow',
     th: 'tableCell',
     td: 'tableCell',
 };
-const tableNodeProcessor = unified()
-    .data('micromarkExtensions', [syntax_gemoji()])
-    .data('fromMarkdownExtensions', [gemojiFromMarkdown()])
+// `mdxjs` + `mdxFromMarkdown` is what `remarkMdx` registers internally; we
+// register them manually so we control ordering against our other tokenizers.
+// The fallback omits these so blank-line-separated markdown inside cells still
+// parses when mdxjs throws on malformed JSX.
+const buildTableNodeProcessor = (withMdx) => unified()
+    .data('micromarkExtensions', [...(withMdx ? [mdxjs()] : []), syntax_gemoji(), legacyVariable()])
+    .data('fromMarkdownExtensions', [
+    ...(withMdx ? [mdxFromMarkdown()] : []),
+    gemojiFromMarkdown(),
+    legacyVariableFromMarkdown(),
+])
     .use(remarkParse)
-    .use(remarkMdx)
     .use(normalize_malformed_md_syntax)
     .use([[callouts, { isMdxish: true }], code_tabs])
     .use(remarkGfm);
+const tableNodeProcessor = buildTableNodeProcessor(true);
+const fallbackTableNodeProcessor = buildTableNodeProcessor(false);
+// Since we use a subparser in `tableNodeProcessor` to parse `node.value`,
+// positions are relative to that substring. Shifting them by the base
+// offset and line number makes them valid in the outer source coordinate space.
+// Otherwise, consumers who directly slice based on position would read and grab the
+// wrong content
+const parseTableNode = (processor, node) => {
+    let parsed;
+    try {
+        parsed = processor.runSync(processor.parse(node.value));
+    }
+    catch {
+        return undefined;
+    }
+    const baseOffset = node.position?.start?.offset ?? 0;
+    const baseLine = (node.position?.start?.line ?? 1) - 1;
+    visit(parsed, child => {
+        if (child.position?.start) {
+            child.position.start.offset = (child.position.start.offset ?? 0) + baseOffset;
+            child.position.start.line += baseLine;
+        }
+        if (child.position?.end) {
+            child.position.end.offset = (child.position.end.offset ?? 0) + baseOffset;
+            child.position.end.line += baseLine;
+        }
+    });
+    return parsed;
+};
 /**
  * Check if children are only text nodes that might contain markdown
  */
@@ -92164,27 +92359,54 @@ const processTableNode = (node, index, parent, documentPosition) => {
     }
     // All cells are phrasing-only — convert to markdown table
     const children = [];
+    // Collect `<td>`/`<th>` cells under any container (a `<tr>`, or a section
+    // when cells are bare).
+    const collectCells = (container) => {
+        const cells = [];
+        visit(container, isTableCell, ({ name, children: cellChildren, position: cellPosition }) => {
+            cells.push({
+                type: tableTypes[name],
+                children: unwrapSoleParagraph(cellChildren),
+                position: cellPosition,
+            });
+        });
+        return cells;
+    };
+    // remarkMdx wraps inline `<tr>`s in a paragraph; unwrap one level so the
+    // hasRow check below sees them.
+    const flattenSectionChildren = (nodes) => nodes.flatMap(n => n.type === 'paragraph' && 'children' in n && Array.isArray(n.children) ? n.children : [n]);
     visit(node, isMDXElement, (child) => {
-        if (child.name === 'thead' || child.name === 'tbody') {
+        if (child.name !== 'thead' && child.name !== 'tbody')
+            return;
+        const sectionChildren = flattenSectionChildren(child.children);
+        const hasRow = sectionChildren.some(c => isMDXElement(c) && c.name === 'tr');
+        if (hasRow) {
             visit(child, isMDXElement, (row) => {
                 if (row.name !== 'tr')
                     return;
-                const rowChildren = [];
-                visit(row, isTableCell, ({ name, children: cellChildren, position: cellPosition }) => {
-                    const parsedChildren = unwrapSoleParagraph(cellChildren);
-                    rowChildren.push({
-                        type: tableTypes[name],
-                        children: parsedChildren,
-                        position: cellPosition,
-                    });
-                });
                 children.push({
                     type: 'tableRow',
-                    children: rowChildren,
+                    children: collectCells(row),
                     position: row.position,
                 });
             });
         }
+        else {
+            // No `<tr>`, chunk bare cells into rows using the prior row's column
+            // count (e.g. from `<thead>`), so 4 bare `<td>`s under a 2-col header
+            // become 2 rows of 2.
+            const cells = collectCells(child);
+            if (cells.length === 0)
+                return;
+            const cols = children[0]?.children?.length || cells.length;
+            for (let i = 0; i < cells.length; i += cols) {
+                children.push({
+                    type: 'tableRow',
+                    children: cells.slice(i, i + cols),
+                    position: child.position,
+                });
+            }
+        }
     });
     const firstRow = children[0];
     const columnCount = firstRow?.children?.length || 0;
@@ -92217,35 +92439,22 @@ const mdxishTables = () => tree => {
             return;
         if (!node.value.startsWith('<Table') && !node.value.startsWith('<table'))
             return;
-        try {
-            const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(node.value));
-            // since we use a subparser in `tableNodeProcessor` to parse `node.value`,
-            // positions are relative to that substring. shifting them by the base
-            // offset and line number makes them valid in the outer source coordinate space.
-            // otherwise, consumers who directly slice based on position would read and grab the
-            // wrong content
-            const baseOffset = node.position?.start?.offset ?? 0;
-            const baseLine = (node.position?.start?.line ?? 1) - 1;
-            visit(parsed, child => {
-                if (child.position?.start) {
-                    child.position.start.offset = (child.position.start.offset ?? 0) + baseOffset;
-                    child.position.start.line += baseLine;
-                }
-                if (child.position?.end) {
-                    child.position.end.offset = (child.position.end.offset ?? 0) + baseOffset;
-                    child.position.end.line += baseLine;
-                }
-            });
+        const parsed = parseTableNode(tableNodeProcessor, node);
+        if (parsed) {
             visit(parsed, isMDXElement, (tableNode) => {
                 if (tableNode.name !== 'Table' && tableNode.name !== 'table')
                     return undefined;
                 processTableNode(tableNode, index, parent, node.position);
                 return EXIT;
             });
+            return;
         }
-        catch {
-            // If parsing fails, leave the node as-is
-        }
+        // MDX parse failed (usually unbalanced JSX). Re-parse without MDX so
+        // markdown between `<td>` and `</td>` still renders; tags stay as raw HTML.
+        const fallback = parseTableNode(fallbackTableNodeProcessor, node);
+        if (!fallback || fallback.children.length <= 1)
+            return;
+        parent.children.splice(index, 1, ...fallback.children);
     });
     return tree;
 };
@@ -104996,6 +105205,63 @@ function rehypeSanitize(options) {
   }
 }
 
+;// ./node_modules/mdast-util-newline-to-break/lib/index.js
+/**
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
+ */
+
+
+
+/**
+ * Turn normal line endings into hard breaks.
+ *
+ * @param {Nodes} tree
+ *   Tree to change.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function newlineToBreak(tree) {
+  findAndReplace(tree, [/\r?\n|\r/g, lib_replace])
+}
+
+/**
+ * Replace line endings.
+ *
+ * @type {ReplaceFunction}
+ */
+function lib_replace() {
+  return {type: 'break'}
+}
+
+;// ./node_modules/remark-breaks/lib/index.js
+/**
+ * @typedef {import('mdast').Root} Root
+ */
+
+
+
+/**
+ * Support hard breaks without needing spaces or escapes (turns enters into
+ * `<br>`s).
+ *
+ * @returns
+ *   Transform.
+ */
+function remarkBreaks() {
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    newlineToBreak(tree)
+  }
+}
+
 ;// ./errors/mdx-syntax-error.ts
 class MdxSyntaxError extends SyntaxError {
     original = null;
@@ -107801,6 +108067,7 @@ const tocHastToMdx = (toc, components, variables) => {
 
 
 
+
 const sanitizeSchema = cjs_default()(defaultSchema, {
     attributes: {
         a: ['target'],
@@ -107809,12 +108076,13 @@ const sanitizeSchema = cjs_default()(defaultSchema, {
         href: ['doc', 'ref', 'blog', 'changelog', 'page'],
     },
 });
-const compile_compile = (text, { components = {}, missingComponents, copyButtons, useTailwind, ...opts } = {}) => {
+const compile_compile = (text, { components = {}, missingComponents, copyButtons, useTailwind, hardBreaks, ...opts } = {}) => {
     // Destructure at runtime to avoid circular dependency issues
     const { codeTabsTransformer, ...transforms } = defaultTransforms;
     const remarkPlugins = [
         remarkFrontmatter,
         remarkGfm,
+        ...(hardBreaks ? [remarkBreaks] : []),
         ...Object.values(transforms),
         [codeTabsTransformer, { copyButtons }],
         [
@@ -114220,63 +114488,6 @@ function rehypeStringify(options) {
   }
 }
 
-;// ./node_modules/mdast-util-newline-to-break/lib/index.js
-/**
- * @typedef {import('mdast').Nodes} Nodes
- * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
- */
-
-
-
-/**
- * Turn normal line endings into hard breaks.
- *
- * @param {Nodes} tree
- *   Tree to change.
- * @returns {undefined}
- *   Nothing.
- */
-function newlineToBreak(tree) {
-  findAndReplace(tree, [/\r?\n|\r/g, lib_replace])
-}
-
-/**
- * Replace line endings.
- *
- * @type {ReplaceFunction}
- */
-function lib_replace() {
-  return {type: 'break'}
-}
-
-;// ./node_modules/remark-breaks/lib/index.js
-/**
- * @typedef {import('mdast').Root} Root
- */
-
-
-
-/**
- * Support hard breaks without needing spaces or escapes (turns enters into
- * `<br>`s).
- *
- * @returns
- *   Transform.
- */
-function remarkBreaks() {
-  /**
-   * Transform.
-   *
-   * @param {Root} tree
-   *   Tree.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  return function (tree) {
-    newlineToBreak(tree)
-  }
-}
-
 ;// ./processor/plugin/flatten-table-cell-paragraphs.ts
 
 /** List elements that cause margin issues when adjacent to paragraphs */
@@ -115056,87 +115267,6 @@ function emptyTaskListItemFromMarkdown() {
     };
 }
 
-;// ./lib/mdast-util/legacy-variable/index.ts
-
-const contextMap = new WeakMap();
-function findlegacyVariableToken() {
-    // tokenStack is micromark's current open token ancestry; find the nearest legacyVariable token.
-    const events = this.tokenStack;
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-        const token = events[i][0];
-        if (token.type === 'legacyVariable')
-            return token;
-    }
-    return undefined;
-}
-function enterlegacyVariable(token) {
-    contextMap.set(token, { value: '' });
-}
-function exitlegacyVariableValue(token) {
-    const variableToken = findlegacyVariableToken.call(this);
-    if (!variableToken)
-        return;
-    const ctx = contextMap.get(variableToken);
-    // Build up the variable characters
-    if (ctx)
-        ctx.value += this.sliceSerialize(token);
-}
-function exitlegacyVariable(token) {
-    const ctx = contextMap.get(token);
-    const serialized = this.sliceSerialize(token);
-    const variableName = serialized.startsWith('<<') && serialized.endsWith('>>')
-        ? serialized.slice(2, -2)
-        : ctx?.value ?? '';
-    const nodePosition = {
-        start: {
-            offset: token.start.offset,
-            line: token.start.line,
-            column: token.start.column,
-        },
-        end: {
-            offset: token.end.offset,
-            line: token.end.line,
-            column: token.end.column,
-        },
-    };
-    if (variableName.startsWith('glossary:')) {
-        const term = variableName.slice('glossary:'.length).trim();
-        this.enter({
-            type: NodeTypes.glossary,
-            data: {
-                hName: 'Glossary',
-                hProperties: { term },
-            },
-            children: [{ type: 'text', value: term }],
-            position: nodePosition,
-        }, token);
-        this.exit(token);
-        contextMap.delete(token);
-        return;
-    }
-    this.enter({
-        type: NodeTypes.variable,
-        data: {
-            hName: 'Variable',
-            hProperties: { name: variableName.trim(), isLegacy: true },
-        },
-        value: `<<${variableName}>>`,
-    }, token);
-    this.exit(token);
-    contextMap.delete(token);
-}
-function legacyVariableFromMarkdown() {
-    return {
-        enter: {
-            legacyVariable: enterlegacyVariable,
-        },
-        exit: {
-            legacyVariableValue: exitlegacyVariableValue,
-            legacyVariable: exitlegacyVariable,
-        },
-    };
-}
-
 ;// ./lib/mdast-util/magic-block/index.ts
 const magic_block_contextMap = new WeakMap();
 /**
@@ -115326,74 +115456,6 @@ function mdxComponentFromMarkdown() {
     };
 }
 
-;// ./lib/micromark/legacy-variable/syntax.ts
-
-
-function isAllowedValueChar(code) {
-    return (code !== null &&
-        code !== codes.lessThan &&
-        code !== codes.greaterThan &&
-        !markdownLineEnding(code));
-}
-const legacyVariableConstruct = {
-    name: 'legacyVariable',
-    tokenize: syntax_tokenize,
-};
-function syntax_tokenize(effects, ok, nok) {
-    let hasValue = false;
-    const start = (code) => {
-        if (code !== codes.lessThan)
-            return nok(code);
-        effects.enter('legacyVariable');
-        effects.enter('legacyVariableMarkerStart');
-        effects.consume(code); // <
-        return open2;
-    };
-    const open2 = (code) => {
-        if (code !== codes.lessThan)
-            return nok(code);
-        effects.consume(code); // <<
-        effects.exit('legacyVariableMarkerStart');
-        effects.enter('legacyVariableValue');
-        return value;
-    };
-    const value = (code) => {
-        if (code === codes.greaterThan) {
-            if (!hasValue)
-                return nok(code);
-            effects.exit('legacyVariableValue');
-            effects.enter('legacyVariableMarkerEnd');
-            effects.consume(code); // >
-            return close2;
-        }
-        if (!isAllowedValueChar(code))
-            return nok(code);
-        hasValue = true;
-        effects.consume(code);
-        return value;
-    };
-    const close2 = (code) => {
-        if (code !== codes.greaterThan)
-            return nok(code);
-        effects.consume(code); // >>
-        effects.exit('legacyVariableMarkerEnd');
-        effects.exit('legacyVariable');
-        return ok;
-    };
-    return start;
-}
-function legacyVariable() {
-    return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
-    };
-}
-
-;// ./lib/micromark/legacy-variable/index.ts
-/**
- * Micromark extension for <<variable>> / <<glossary:term>> inline syntax.
- */
-
-
 ;// ./lib/micromark/magic-block/syntax.ts
 
 
@@ -120712,11 +120774,43 @@ const transformMagicBlockEmbed = (node) => {
     };
 };
 const mdxish_jsx_to_mdast_isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
+/**
+ * Wraps bare `<td>`/`<th>` cells directly inside `<thead>`/`<tbody>` with an
+ * implicit `<tr>`. remarkMdx may wrap inline JSX elements in paragraph nodes,
+ * so unwrap those first.
+ */
+const wrapBareCellsInRow = (node) => {
+    visit(node, isMDXElement, (section) => {
+        if (section.name !== 'thead' && section.name !== 'tbody')
+            return;
+        const children = section.children;
+        const hasRow = children.some(c => isMDXElement(c) && c.name === 'tr');
+        if (hasRow)
+            return;
+        const unwrapped = children.flatMap(c => {
+            if (c.type === 'paragraph' && 'children' in c && Array.isArray(c.children)) {
+                return c.children;
+            }
+            return [c];
+        });
+        const cells = unwrapped.filter(c => mdxish_jsx_to_mdast_isTableCell(c));
+        if (cells.length === 0)
+            return;
+        const tr = {
+            type: 'mdxJsxFlowElement',
+            name: 'tr',
+            attributes: [],
+            children: cells,
+        };
+        section.children = [tr];
+    });
+};
 /**
  * Converts a JSX <Table> element to an MDAST table node with alignment.
  * Returns null for header-less tables since MDAST always promotes the first row to <thead>.
  */
 const transformTable = (jsx) => {
+    wrapBareCellsInRow(jsx);
     let hasThead = false;
     visit(jsx, isMDXElement, (child) => {
         if (child.name === 'thead')