@readme/markdown 14.11.4 → 14.12.0

package/dist/processor/compile/text.d.ts

@@ -0,0 +1,4 @@
+import type { Parents, Text } from 'mdast';
+import type { Info, State } from 'mdast-util-to-markdown';
+declare const text: (node: Text, parent: Parents | undefined, state: State, info: Info) => string;
+export default text;

package/dist/processor/transform/mdxish/components/mdx-blocks.d.ts

@@ -9,6 +9,10 @@ export { parseAttributes, parseTag } from '../../../../lib/utils/mdxish/mdxish-c
  * This transformer identifies these patterns and converts them to proper MDX JSX elements so they
  * can be accurately recognized and rendered later with their component definition code.
  *
+ * Note: The main goal is to promote PascalCase tags to MDX elements, but we want to promote
+ * normal HTML to MDX elements in some cases so they get the full custom parsing behavior.
+ * E.g. tags with JSX expressions, nested components, etc.
+ *
  * The mdx-component micromark tokenizer ensures that multi-line components are captured
  * as single HTML nodes, so this transformer only needs to handle two cases:
  *

package/dist/processor/transform/mdxish/components/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Html, PhrasingContent } from 'mdast';
+import type { Html, Node, PhrasingContent } from 'mdast';
 import type { MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
 export type MdxAttributes = (MdxJsxAttribute | MdxJsxExpressionAttribute)[];
 /**
@@ -29,3 +29,15 @@ export declare const hasExpressionAttr: (attributes: MdxAttributes) => boolean;
  * composes children from pre-existing nodes with no outer position.
  */
 export declare const toMdxJsxTextElement: (name: string, attributes: MdxAttributes, children: PhrasingContent[], position?: Html["position"]) => MdxJsxTextElement;
+export declare const NESTED_TABLE_RE: RegExp;
+export declare const isMarkdownPromotableHtmlTag: (tag: string) => boolean;
+export declare const containsMarkdownConstruct: (nodes: Node[]) => boolean;
+/**
+ * Index of the `</tag>` that balances the already-consumed opening tag (the
+ * caller starts us one level deep). `lastIndexOf` mis-slices sibling same-tag
+ * pairs like `<div>**a**</div><div>**b**</div>`, so we depth-match instead —
+ * delegating to `walkTags` (htmlparser2) so quoted attributes (`title="</div>"`),
+ * code spans, and legacy `<<VARIABLE>>` are handled for free. Returns -1 when
+ * the wrapper is left open.
+ */
+export declare function findBalancedClosingTagIndex(content: string, tag: string): number;

package/dist/processor/transform/mdxish/mdxish-html-blocks.d.ts

@@ -2,13 +2,14 @@ import type { Transform } from 'mdast-util-from-markdown';
 /**
  * Converts every `<HTMLBlock>` shape that survives parsing into the canonical
  * `html-block` MDAST node, reading the body from the tokenizer's template-literal
- * expression. Three shapes occur:
+ * expression. Two shapes occur:
  *
- *   1. JSX element (`mdxJsxFlowElement`/`mdxJsxTextElement`) — multiline/block
- *      context and table cells (after their remarkMdx re-parse).
- *   2. Raw `html` blob (`splitRawHtmlBlocks`) — single-line top-level, or nested
- *      in raw HTML like an inline `<div>`.
- *   3. Inline-in-paragraph — split into `html` + expression + `html` siblings.
+ *   1. JSX element (`mdxJsxFlowElement`/`mdxJsxTextElement`) — table cells, after
+ *      their remarkMdx re-parse (that re-parse runs without the htmlBlockComponent
+ *      tokenizer, so `<HTMLBlock>` arrives as JSX rather than an opaque `html` node).
+ *   2. Raw `html` blob (`splitRawHtmlBlocks`) — the htmlBlockComponent tokenizer's
+ *      opaque output (top-level and inline), or an `<HTMLBlock>` embedded in a
+ *      larger raw-HTML node like an inline `<div>` that the tokenizer never saw.
  *
  * Runs *after* `mdxishTables` so table cells are re-parsed first;
  * `mdxishTables` recognizes the still-JSX `<HTMLBlock>` element when deciding to

package/dist/processor/transform/mdxish/normalize-closing-tag-whitespace.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Canonicalize spaced closing tags (`</ td >` → `</td>`) for known HTML names.
+ *
+ * In HTML, `</` + whitespace is a bogus comment, so `</ table >` never closes the
+ * table (jsxTable misses it → empty table + pre; CX-3706). Only standard HTML tags;
+ * custom components, prose (`a </ b`), and code blocks are left alone.
+ *
+ * @example
+ * normalizeClosingTagWhitespace('</ td >')   // '</td>'
+ * normalizeClosingTagWhitespace('</table >') // '</table>'
+ * normalizeClosingTagWhitespace('a </ b >')  // unchanged
+ */
+export declare function normalizeClosingTagWhitespace(content: string): string;

package/dist/processor/transform/mdxish/terminate-html-flow-blocks.d.ts

@@ -1,22 +1,8 @@
 /**
- * Preprocessor to terminate HTML flow blocks.
- *
- * In CommonMark, HTML blocks (types 6 and 7) only terminate on a blank line.
- * Without one, any content on the next line is consumed as part of the HTML block
- * and never parsed as its own construct. For example, a `[block:callout]` immediately
- * following `<div><p></p></div>` gets swallowed into the HTML flow token.
+ * CommonMark HTML blocks (types 6/7) end only at a blank line, so markdown on the
+ * next line is swallowed as HTML (`## heading` after `<div>` renders as literal text).
+ * Inserts the missing blank line; the gating rules live in `shouldTerminateBetween`.
  *
  * @link https://spec.commonmark.org/0.29/#html-blocks
- *
- * This preprocessor inserts a blank line after standalone HTML lines when the next
- * line is non-blank and not an HTML construct, ensuring micromark's HTML flow
- * tokenizer terminates and subsequent content is parsed independently.
- *
- * Conditions:
- * 1. Only non-indented lines with lowercase tag names are considered. Uppercase tags
- *    (e.g. `<Table>`, `<MyComponent>`) are JSX custom components and don't trigger
- *    CommonMark HTML blocks.
- * 2. Lines inside protected blocks (e.g. fenced code) are left untouched.
- * 3. Lines with an unclosed RAW_CONTENT_TAGS opener are exempted.
  */
 export declare function terminateHtmlFlowBlocks(content: string): string;