@readme/markdown 15.2.0 → 15.3.0

package/dist/processor/transform/mdxish/anchor-to-jsx.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'mdast-util-from-markdown';
+/**
+ * Serializes mdxish anchors to JSX `<Anchor>` syntax. Handing the node to
+ * `mdast-util-mdx-jsx` runs the label through the document's own serializer
+ * state, so readme nodes (variables, emoji, glossary) reach their handlers.
+ */
+declare const mdxishAnchorToJsx: () => Transform;
+export default mdxishAnchorToJsx;

package/dist/processor/transform/mdxish/magic-blocks/patterns.d.ts

@@ -2,8 +2,11 @@
 export declare const HTML_TAG_RE: RegExp;
 /** Matches an HTML element from its opening tag to the matching closing tag. */
 export declare const HTML_ELEMENT_BLOCK_RE: RegExp;
+export declare const NEWLINE_RE: RegExp;
 /** Matches a newline with surrounding horizontal whitespace. */
 export declare const NEWLINE_WITH_WHITESPACE_RE: RegExp;
+/** Matches a run of two or more newlines (a blank line) with surrounding horizontal whitespace. */
+export declare const BLANK_LINE_RE: RegExp;
 /** Matches a closing block-level tag followed by non-tag text or by a newline then non-blank content. */
 export declare const CLOSE_BLOCK_TAG_BOUNDARY_RE: RegExp;
 /** Strips HTML open/close tags. Used to detect non-tag inner text content. */

package/dist/processor/transform/mdxish/magic-blocks/types.d.ts

@@ -63,6 +63,7 @@ export interface RecipeJson extends MagicBlockJson {
 }
 export interface MagicBlockTransformerOptions {
     compatibilityMode?: boolean;
+    hardBreaks?: boolean;
     safeMode?: boolean;
 }
 /**

package/dist/render-fixture.node.js

@@ -19045,7 +19045,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 6009
+/***/ 345
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -95928,6 +95928,7 @@ var allCSS2RNProps = __webpack_unused_export__ = flatten([allProps, CSS2RNProps]
 
 
 
+
 /**
  * Extract word boundaries from camelCase strings (e.g., "borderWidth" -> ["border", "width"])
  */
@@ -96007,10 +96008,43 @@ const CUSTOM_PROP_BOUNDARIES = [
  */
 const RUNTIME_COMPONENT_TAGS = new Set(['Variable', 'variable', 'html-block', 'rdme-pin']);
 /**
- * Standard HTML tags that should never be treated as custom components.
- * Uses the html-tags package, converted to a Set<string> for efficient lookups.
+ * Elements that are not actually standard HTML tags, or those that we intentionally
+ * don't want to treat as one & is mute to check with. These include:
+ * - SVG/MathML descendants
+ * - Namespaced foreign content
+ * - `image`, which the HTML tree builder rewrites to `img`
+ * Most of these are bundled in parse5's `TAG_NAMES` set, but we can also add a few more.
+ */
+const NON_STANDARD_TAGS = new Set([
+    'annotation-xml',
+    'desc',
+    'foreignObject',
+    'image',
+    'malignmark',
+    'mglyph',
+    'mi',
+    'mn',
+    'mo',
+    'ms',
+    'mtext',
+]);
+/**
+ * Standard HTML tags list.
+ * A use case of this is to differentiate custom components tag vs standard HTML tags.
+ *
+ * Unioned from:
+ * - `html-tags`: All modern spec HTML elements
+ * - parse5's `TAG_NAMES`: Elements the HTML tree-construction algorithm has to special-case
+ *   This includes obsolete tags that are still rendered by browsers.
+ * - NON_STANDARD_TAGS: We've had to filter because currently parse5's `TAG_NAMES` set over-enumerates
+ *   tags that are not actually standard HTML tags. It also allows custom tags to be filtered out.
  */
-const STANDARD_HTML_TAGS = new Set(html_tags_namespaceObject);
+const STANDARD_HTML_TAGS = new Set([
+    ...html_tags_namespaceObject,
+    ...Object.values(TAG_NAMES),
+    'acronym', // Obselete tag not included either of the above sources. Add here if we have missed any.
+    'blink',
+].filter(tag => !NON_STANDARD_TAGS.has(tag)));
 /**
  * Table structural tags. Blank lines inside these carry deliberate meaning for
  * `mdxishTables` (e.g. splitting cell content into paragraphs, or deciding
@@ -121415,27 +121449,6 @@ function htmlToMarkdown(html) {
     return processor.processSync(html).toString().trim();
 }
 
-;// ./processor/compile/anchor.ts
-
-
-const anchor_anchor = (node) => {
-    const { href, label, target, title } = getHProps(node);
-    const attrs = {
-        ...(label && { label }),
-        ...(target && { target }),
-        href: href ?? '',
-        ...(title && { title }),
-    };
-    // Serialize children (phrasing content) back to markdown
-    // Wrap in paragraph to satisfy RootContent type requirement
-    const children = toMarkdown({
-        type: 'paragraph',
-        children: node.children,
-    }).trim();
-    return `<Anchor ${formatProps(attrs)}>${children}</Anchor>`;
-};
-/* harmony default export */ const compile_anchor = (anchor_anchor);
-
 ;// ./processor/compile/callout.ts
 
 const callout = (node, _, state, info) => {
@@ -121593,7 +121606,6 @@ const compile_text_text = (node, parent, state, info) => {
 
 
 
-
 function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
@@ -121613,7 +121625,6 @@ function compilers(mdxish = false) {
         plain: compile_plain,
         yaml: compile_compatibility,
         // needed only for mdxish
-        ...(mdxish && { [NodeTypes.anchor]: compile_anchor }),
         ...(mdxish && { list: compile_list }),
         ...(mdxish && { listItem: list_item }),
         ...(mdxish && { text: compile_text }),
@@ -122078,6 +122089,43 @@ const mdxComponentHandlers = {
     [NodeTypes.htmlBlock]: htmlBlockHandler,
 };
 
+;// ./processor/transform/mdxish/anchor-to-jsx.ts
+/* unused harmony import specifier */ var anchor_to_jsx_visit;
+/* unused harmony import specifier */ var anchor_to_jsx_NodeTypes;
+/* unused harmony import specifier */ var anchor_to_jsx_getHProps;
+/* unused harmony import specifier */ var anchor_to_jsx_toAttributes;
+
+
+
+/**
+ * Serializes mdxish anchors to JSX `<Anchor>` syntax. Handing the node to
+ * `mdast-util-mdx-jsx` runs the label through the document's own serializer
+ * state, so readme nodes (variables, emoji, glossary) reach their handlers.
+ */
+const mdxishAnchorToJsx = () => tree => {
+    anchor_to_jsx_visit(tree, anchor_to_jsx_NodeTypes.anchor, (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        const { href, label, target, title } = anchor_to_jsx_getHProps(node);
+        const jsx = {
+            type: 'mdxJsxTextElement',
+            name: 'Anchor',
+            // An anchor always renders an `href`, even an empty one, so it's built
+            // directly rather than through `toAttributes`, which drops empty values.
+            attributes: [
+                ...anchor_to_jsx_toAttributes({ label, target }),
+                { type: 'mdxJsxAttribute', name: 'href', value: href ?? '' },
+                ...anchor_to_jsx_toAttributes({ title }),
+            ],
+            children: node.children,
+            position: node.position,
+        };
+        parent.children[index] = jsx;
+    });
+    return tree;
+};
+/* harmony default export */ const anchor_to_jsx = ((/* unused pure expression or super */ null && (mdxishAnchorToJsx)));
+
 ;// ./processor/transform/mdxish/callout-to-jsx.ts
 /* unused harmony import specifier */ var callout_to_jsx_visit;
 /* unused harmony import specifier */ var callout_to_jsx_defaultIcons;
@@ -125284,8 +125332,11 @@ function rehypeStringify(options) {
 const HTML_TAG_RE = /<\/?([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']*(?:"[^"]*"|'[^']*'))*[^>"']*)>/g;
 /** Matches an HTML element from its opening tag to the matching closing tag. */
 const HTML_ELEMENT_BLOCK_RE = /<([a-zA-Z][a-zA-Z0-9-]*)[\s>][\s\S]*?<\/\1>/g;
+const NEWLINE_RE = /\n/g;
 /** Matches a newline with surrounding horizontal whitespace. */
 const NEWLINE_WITH_WHITESPACE_RE = /[^\S\n]*\n[^\S\n]*/g;
+/** Matches a run of two or more newlines (a blank line) with surrounding horizontal whitespace. */
+const BLANK_LINE_RE = /[^\S\n]*\n(?:[^\S\n]*\n)+[^\S\n]*/g;
 /** Matches a closing block-level tag followed by non-tag text or by a newline then non-blank content. */
 const CLOSE_BLOCK_TAG_BOUNDARY_RE = /<\/([a-zA-Z][a-zA-Z0-9-]*)>\s*(?:(?!<)(\S)|\n([^\n]))/g;
 /** Strips HTML open/close tags. Used to detect non-tag inner text content. */
@@ -125355,7 +125406,6 @@ const EMPTY_CODE_PLACEHOLDER = {
 
 
 
-
 /**
  * Wraps a node in a "pinned" container if sidebar: true is set.
  */
@@ -125390,16 +125440,13 @@ const textToBlock = (text) => [{ children: textToInline(text), type: 'paragraph'
  */
 const ensureLeadingBreaks = (text) => text.replace(/^\n+/, match => '<br>'.repeat(match.length));
 /** Preprocesses magic block body content before parsing. */
-const preprocessBody = (text) => {
-    return ensureLeadingBreaks(text);
-};
+const preprocessBody = (text, hardBreaks) => (hardBreaks ? ensureLeadingBreaks(text) : text);
 const bodyExtensions = mdxishExtensions(FEATURES.magicBlockBody);
 /** Markdown parser */
 const contentParser = unified()
     .data('micromarkExtensions', bodyExtensions.micromarkExtensions)
     .data('fromMarkdownExtensions', bodyExtensions.fromMarkdownExtensions)
     .use(remarkParse)
-    .use(hard_breaks)
     .use(remarkGfm)
     .use(normalize_malformed_md_syntax);
 /**
@@ -125496,17 +125543,21 @@ const processMarkdownInHtmlString = (html) => {
 /**
  * Separate a closing block-level tag from the content that follows it.
  *
- * Each \n in the original text becomes a <br> tag to preserve spacing, then a
- * blank line (\n\n) is appended so CommonMark ends the HTML block and parses
- * the following content as markdown.
+ * A blank line (\n\n) is appended so CommonMark ends the HTML block and parses the
+ * following content as markdown; with hard breaks each \n also becomes a <br> to keep its spacing.
  */
-const separateBlockTagFromContent = (match, tag, inlineChar, nextLineChar) => {
+const separateBlockTagFromContent = (hardBreaks, match, tag, inlineChar, nextLineChar) => {
     if (!BLOCK_LEVEL_TAGS.has(tag.toLowerCase()))
         return match;
-    const newlineCount = (match.match(/\n/g) ?? []).length;
+    const newlineCount = hardBreaks ? (match.match(NEWLINE_RE) ?? []).length : 0;
     const breaks = '<br>'.repeat(newlineCount);
     return `</${tag}>${breaks}\n\n${inlineChar || nextLineChar}`;
 };
+/**
+ * Newlines inside an HTML block become <br> so CommonMark doesn't end the block on a blank
+ * line. Without hard breaks only blank lines break, but they still have to be replaced.
+ */
+const collapseHtmlBlockNewlines = (html, hardBreaks) => html.replace(hardBreaks ? NEWLINE_WITH_WHITESPACE_RE : BLANK_LINE_RE, '<br>');
 /** Escape a leading (possibly indented) `-`/`*`/`+` so cells don't become bullet lists. */
 const escapeLeadingListMarkers = (text) => text.replace(/^([ \t]*)([-*+])(?=[ \t]|$)/gm, '$1\\$2');
 /**
@@ -125514,15 +125565,13 @@ const escapeLeadingListMarkers = (text) => text.replace(/^([ \t]*)([-*+])(?=[ \t
  * so `<ul><li>_text_</li></ul>` won't convert underscores to emphasis.
  * We parse first, then visit html nodes and process their text content.
  */
-const parseTableCell = (text) => {
+const parseTableCell = (text, hardBreaks) => {
     if (!text.trim())
         return [{ type: 'text', value: '' }];
-    // Convert \n (and surrounding whitespace) to <br> inside HTML blocks so
-    // CommonMark doesn't split them on blank lines.
     const escaped = processBackslashEscapes(text);
     const normalized = escaped
-        .replace(HTML_ELEMENT_BLOCK_RE, match => match.replace(NEWLINE_WITH_WHITESPACE_RE, '<br>'))
-        .replace(CLOSE_BLOCK_TAG_BOUNDARY_RE, separateBlockTagFromContent);
+        .replace(HTML_ELEMENT_BLOCK_RE, match => collapseHtmlBlockNewlines(match, hardBreaks))
+        .replace(CLOSE_BLOCK_TAG_BOUNDARY_RE, (match, tag, inlineChar, nextLineChar) => separateBlockTagFromContent(hardBreaks, match, tag, inlineChar, nextLineChar));
     const processed = escapeLeadingListMarkers(normalized);
     const tree = contentParser.runSync(contentParser.parse(processed));
     // Process markdown inside HTML blocks that have non-tag inner text (e.g. `<div>**x**`
@@ -125571,7 +125620,7 @@ const parseApiHeaderTitle = (text) => {
  * Transform a magicBlock node into final MDAST nodes.
  */
 function transformMagicBlock(blockType, data, rawValue, options = {}) {
-    const { compatibilityMode = false, safeMode = false } = options;
+    const { compatibilityMode = false, hardBreaks = true, safeMode = false } = options;
     // Handle empty data by returning placeholder nodes for known block types
     // This allows the editor to show appropriate placeholder UI instead of nothing
     if (Object.keys(data).length < 1) {
@@ -125710,7 +125759,7 @@ function transformMagicBlock(blockType, data, rawValue, options = {}) {
                 });
             }
             if (hasBody) {
-                const bodyBlocks = parseBlock(preprocessBody(calloutJson.body || ''));
+                const bodyBlocks = parseBlock(preprocessBody(calloutJson.body || '', hardBreaks));
                 children.push(...bodyBlocks);
             }
             const calloutElement = {
@@ -125742,12 +125791,12 @@ function transformMagicBlock(blockType, data, rawValue, options = {}) {
                 mapped[rowIndex][colIndex] = v;
                 return mapped;
             }, []);
-            const tokenizeCell = compatibilityMode
-                ? textToBlock
-                : parseTableCell;
+            const tokenizeCell = compatibilityMode ? textToBlock : (text) => parseTableCell(text, hardBreaks);
             const tableChildren = Array.from({ length: rows + 1 }, (_, y) => ({
                 children: Array.from({ length: cols }, (__, x) => ({
-                    children: sparseData[y]?.[x] ? tokenizeCell(preprocessBody(sparseData[y][x])) : [{ type: 'text', value: '' }],
+                    children: sparseData[y]?.[x]
+                        ? tokenizeCell(preprocessBody(sparseData[y][x], hardBreaks))
+                        : [{ type: 'text', value: '' }],
                     type: y === 0 ? 'tableHead' : 'tableCell',
                 })),
                 type: 'tableRow',
@@ -127510,6 +127559,7 @@ function loadComponents() {
 /* unused harmony import specifier */ var mdxish_unified;
 /* unused harmony import specifier */ var mdxish_mdxishCompilers;
 /* unused harmony import specifier */ var mdxish_DEFAULT_BULLET;
+/* unused harmony import specifier */ var mdxish_mdxishAnchorToJsx;
 /* unused harmony import specifier */ var mdxish_mdxishCalloutToJsx;
 /* unused harmony import specifier */ var mdxish_mdxishTablesToJsx;
 
@@ -127564,6 +127614,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -127602,7 +127653,7 @@ function preprocessContent(content, opts) {
     return processSnakeCaseComponent(result, { knownComponents });
 }
 function mdxishAstProcessor(mdContent, opts = {}) {
-    const { components: userComponents = {}, newEditorTypes = false, safeMode = false, useTailwind } = opts;
+    const { components: userComponents = {}, hardBreaks: enableHardBreaks = true, newEditorTypes = false, safeMode = false, useTailwind, } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
@@ -127631,7 +127682,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         // The next few transformers must appear after mdxishMdxComponentBlocks
         // so nodes produced by the inline re-parse of component bodies
         // (e.g. code/image/embed inside <Tabs>) get visited too
-        .use(magic_block_transformer)
+        .use(magic_block_transformer, { hardBreaks: enableHardBreaks })
         .use(transform_images, { isMdxish: true })
         .use(defaultTransformers)
         .use(newEditorTypes ? inline_mdx_blocks : undefined) // Merge inline html components (e.g. <Anchor>) into MDAST nodes
@@ -127666,6 +127717,7 @@ function mdxishMdastToMd(mdast) {
         .use(mdxish_remarkGfm)
         .use(mdxish_mdxishCalloutToJsx)
         .use(mdxish_mdxishTablesToJsx)
+        .use(mdxish_mdxishAnchorToJsx)
         .use(mdxish_mdxishCompilers)
         .use(mdxJsxStringify)
         .use(mdxish_remarkStringify, {
@@ -127687,7 +127739,7 @@ function mdxishMdastToMd(mdast) {
  * @see .claude/context/MDXish/Processor Overview.md
  */
 function mdxish(mdContent, opts = {}) {
-    const { components: userComponents = {}, safeMode = false, variables } = opts;
+    const { components: userComponents = {}, hardBreaks: enableHardBreaks = true, safeMode = false, variables } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
@@ -127699,7 +127751,7 @@ function mdxish(mdContent, opts = {}) {
     const { processor, parserReadyContent } = mdxishAstProcessor(contentWithoutComments, opts);
     processor
         .use(safeMode ? undefined : evaluate_exports) // Evaluate `export const/function` and stash scope on file.data.mdxishScope
-        .use(hard_breaks) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
+        .use(enableHardBreaks ? hard_breaks : undefined) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
         .use(safeMode ? undefined : evaluate_expressions) // Evaluate self-contained MDX expressions (e.g. `{1+1}`)
         .use(safeMode ? undefined : evaluate_style_block_expressions) // Evaluate `<style>{`...`}</style>` template literals into plain CSS
         .use(variables_code, { variables }) // Resolve <<...>> and {user.*} inside code and inline code nodes
@@ -128791,7 +128843,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"*":["about","acceptCharset","accessK
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module used 'module' so it can't be inlined
-/******/ 	let __webpack_exports__ = __webpack_require__(6009);
+/******/ 	let __webpack_exports__ = __webpack_require__(345);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()