@readme/markdown 14.12.0 → 14.12.1

package/dist/processor/plugin/hard-breaks.d.ts

@@ -0,0 +1,13 @@
+import type { Root } from 'mdast';
+import type { Plugin } from 'unified';
+/**
+ * Converts LF and CRLF line endings into hard breaks while leaving standalone
+ * carriage returns as soft whitespace.
+ *
+ * Unlike `remark-breaks`, this does not promote a lone `\r` into a `<br>`.
+ * Standalone carriage returns can be left behind by generators that replace
+ * the LF in Windows line endings with an explicit `<br>`, producing input such
+ * as `\r<br>`. Treating both characters as hard breaks doubles the spacing.
+ */
+declare const hardBreaks: Plugin<[], Root>;
+export default hardBreaks;

package/dist/processor/transform/mdxish/indentation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CommonMark indentation helpers, shared by the mdxish preprocessors so tab- and
+ * space-indented content is measured (and sliced) on one scale.
+ *
+ * CommonMark's indented-code threshold is 4 *columns*, and a tab is a 4-column tab
+ * stop — not a fixed 4 characters. Counting characters (tab = 1) under-measures
+ * tab-indented lines, letting them slip past the 4-column gate so their content
+ * fragments into code blocks. Keeping one implementation here stops the two callers
+ * from drifting on what "4 columns" means.
+ */
+/** The run of leading spaces/tabs on a line. */
+export declare const leadingIndent: (line: string) => string;
+/**
+ * Expand a leading-whitespace run to spaces using CommonMark's 4-column tab stops,
+ * so a run of mixed tabs/spaces can be measured by length and sliced by column.
+ */
+export declare function expandIndentToColumns(indent: string): string;
+/** Indentation width of a line in CommonMark columns (a tab advances to the next 4-column stop). */
+export declare const indentWidth: (line: string) => number;

package/dist/render-fixture.node.js

@@ -109833,63 +109833,6 @@ 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;
@@ -109911,6 +109854,22 @@ class MdxSyntaxError extends SyntaxError {
     }
 }
 
+;// ./processor/plugin/hard-breaks.ts
+
+/**
+ * Converts LF and CRLF line endings into hard breaks while leaving standalone
+ * carriage returns as soft whitespace.
+ *
+ * Unlike `remark-breaks`, this does not promote a lone `\r` into a `<br>`.
+ * Standalone carriage returns can be left behind by generators that replace
+ * the LF in Windows line endings with an explicit `<br>`, producing input such
+ * as `\r<br>`. Treating both characters as hard breaks doubles the spacing.
+ */
+const hardBreaks = () => tree => {
+    findAndReplace(tree, [/\r?\n/g, () => ({ type: 'break' })]);
+};
+/* harmony default export */ const hard_breaks = (hardBreaks);
+
 ;// ./node_modules/estree-util-value-to-estree/dist/estree-util-value-to-estree.js
 /**
  * Create an ESTree identifier node for a given name.
@@ -112615,7 +112574,7 @@ const compile_compile = (text, { components = {}, missingComponents, copyButtons
     const remarkPlugins = [
         remarkFrontmatter,
         lib_remarkGfm,
-        ...(hardBreaks ? [remarkBreaks] : []),
+        ...(hardBreaks ? [hard_breaks] : []),
         ...Object.values(transforms),
         [codeTabsTransformer, { copyButtons }],
         [
@@ -121379,10 +121338,36 @@ const mdxishInlineMdxComponents = () => tree => {
 };
 /* harmony default export */ const inline_mdx_blocks = (mdxishInlineMdxComponents);
 
+;// ./processor/transform/mdxish/indentation.ts
+/**
+ * CommonMark indentation helpers, shared by the mdxish preprocessors so tab- and
+ * space-indented content is measured (and sliced) on one scale.
+ *
+ * CommonMark's indented-code threshold is 4 *columns*, and a tab is a 4-column tab
+ * stop — not a fixed 4 characters. Counting characters (tab = 1) under-measures
+ * tab-indented lines, letting them slip past the 4-column gate so their content
+ * fragments into code blocks. Keeping one implementation here stops the two callers
+ * from drifting on what "4 columns" means.
+ */
+/** The run of leading spaces/tabs on a line. */
+const leadingIndent = (line) => line.match(/^[ \t]*/)?.[0] ?? '';
+/**
+ * Expand a leading-whitespace run to spaces using CommonMark's 4-column tab stops,
+ * so a run of mixed tabs/spaces can be measured by length and sliced by column.
+ */
+function expandIndentToColumns(indent) {
+    return indent
+        .split('')
+        .reduce((columns, char) => columns + (char === '\t' ? ' '.repeat(4 - (columns.length % 4)) : ' '), '');
+}
+/** Indentation width of a line in CommonMark columns (a tab advances to the next 4-column stop). */
+const indentWidth = (line) => expandIndentToColumns(leadingIndent(line)).length;
+
 ;// ./processor/transform/mdxish/terminate-html-flow-blocks.ts
 
 
 
+
 const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
 const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
 // A line that is exactly one lowercase opening (or self-closing) tag — the shape
@@ -121408,11 +121393,6 @@ function countRawContentTags(line) {
         closes: (line.match(close) ?? []).length,
     }));
 }
-// Indentation width in columns, counting a tab as 4 per CommonMark.
-function indentWidth(line) {
-    const leading = line.match(/^[ \t]*/)?.[0] ?? '';
-    return leading.replace(/\t/g, '    ').length;
-}
 /**
  * Decides whether a blank line belongs between `line` and `next` so the HTML
  * flow block opened on `line` terminates and `next` parses as markdown.
@@ -121484,6 +121464,7 @@ function terminateHtmlFlowBlocks(content) {
 
 
 
+
 // Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
 // Name shape mirrors `componentTagPattern`; the lookbehind skips the inner tag
@@ -121494,25 +121475,33 @@ const NESTED_COMPONENT_TAG_RE = /(?<!<)<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
 const hasNestedGenericComponentTag = (content) => [...content.matchAll(NESTED_COMPONENT_TAG_RE)].some(match => !GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(match[1]));
 /**
  * Strip the shared leading indentation from a component body so readability indentation
- * isn't parsed as indented code (4+ spaces), e.g. `  <p>` / `   text` -> `<p>` / ` text`.
+ * isn't parsed as indented code (4+ columns), e.g. `  <p>` / `   text` -> `<p>` / ` text`.
  * Relative indentation is kept, so content genuinely 4+ columns deeper stays code. We
  * only strip when a line actually reaches 4 columns; otherwise the body is left as-is so
  * its leading whitespace survives as text nodes (mixed component + HTML content needs it).
+ *
+ * Indentation is measured in CommonMark columns (tab = up to 4), matching how the parser
+ * decides indented code. A char count (tab = 1) under-measures tab-indented bodies, so
+ * they slip past the 4-column gate and their nested content fragments into code blocks.
  */
 function safeDeindent(text) {
     const lines = text.split('\n');
     const nonEmptyLines = lines.filter(line => line.trim().length > 0);
     if (nonEmptyLines.length === 0)
         return text;
-    // Indent counts characters (tab = 1), unlike indentWidth's CommonMark columns
-    // (tab = 4) in terminate-html-flow-blocks.
-    const indents = nonEmptyLines.map(line => line.match(/^(\s*)/)?.[1].length ?? 0);
+    const indents = nonEmptyLines.map(line => expandIndentToColumns(leadingIndent(line)).length);
     const minIndent = Math.min(...indents);
     const maxIndent = Math.max(...indents);
-    const stripAmount = maxIndent > 3 ? minIndent : 0;
-    if (stripAmount === 0)
+    if (maxIndent < 4 || minIndent === 0)
         return text;
-    return lines.map(line => line.slice(stripAmount)).join('\n');
+    // Expand each line's leading run to spaces before slicing so a shared indent of mixed
+    // tabs/spaces (and partial-tab remainders) strips cleanly while relative depth survives.
+    return lines
+        .map(line => {
+        const indent = leadingIndent(line);
+        return expandIndentToColumns(indent).slice(minIndent) + line.slice(indent.length);
+    })
+        .join('\n');
 }
 /**
  * Parse component-body markdown into mdast children. Dedenting shifts columns and
@@ -124107,7 +124096,7 @@ const textToBlock = (text) => [{ children: textToInline(text), type: 'paragraph'
 /**
  * Converts leading newlines in magic block content to `<br>` tags.
  * Leading newlines are stripped by remark-parse before they become soft break nodes,
- * so remark-breaks cannot handle them. We convert them to HTML `<br>` tags instead.
+ * so the hard-breaks plugin cannot handle them. We convert them to HTML `<br>` tags instead.
  */
 const ensureLeadingBreaks = (text) => text.replace(/^\n+/, match => '<br>'.repeat(match.length));
 /** Preprocesses magic block body content before parsing. */
@@ -124119,7 +124108,7 @@ const contentParser = lib_unified()
     .data('micromarkExtensions', [syntax_gemoji(), legacyVariable(), looseHtmlEntity()])
     .data('fromMarkdownExtensions', [gemojiFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), looseHtmlEntityFromMarkdown()])
     .use(lib_remarkParse)
-    .use(remarkBreaks)
+    .use(hard_breaks)
     .use(lib_remarkGfm)
     .use(normalize_malformed_md_syntax);
 /**
@@ -126903,7 +126892,7 @@ function mdxish_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(remarkBreaks) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
+        .use(hard_breaks) // 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