@readme/markdown 14.11.3 → 14.11.5

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/react-element-to-hast.d.ts

@@ -0,0 +1,8 @@
+import type { ElementContent } from 'hast';
+/**
+ * Convert a React element tree into hast. Emitting `mdx-jsx` nodes (rehypeRaw passthrough, later normalized to `element`)
+ * preserves nesting that is valid JSX but not valid HTML, which parse5 would otherwise
+ * restructure — e.g. an `<a>` wrapping another `<a>`.
+ * Recursively converts the tree into an array of hast nodes, dealing with arrays and null/undefined/boolean values.
+ */
+export declare function reactElementToHast(node: unknown): ElementContent[];

package/dist/processor/transform/mdxish/tables/escape-crossing-emphasis.d.ts

@@ -0,0 +1,15 @@
+import { type RepairResult } from './utils';
+/**
+ * mdxjs rejects a table when a markdown emphasis run opens at one HTML
+ * tag-nesting depth and closes at another — e.g. `_<ul><li>text_</li></ul>`,
+ * where the `_` opens outside the list but closes inside a `<li>`. It throws
+ * "Expected a closing tag for `<li>` before the end of `emphasis`" and the
+ * whole `<Table>` fails to parse.
+ *
+ * We walk tags and emphasis together, tracking tag depth and a stack of open
+ * emphasis. A delimiter only closes an opener at the same depth; any emphasis
+ * still open when its enclosing tag closes (or at end of input), and any closer
+ * with no same-depth opener, is escaped so mdxjs treats it as literal text.
+ * Scoped to the malformed-retry path.
+ */
+export declare const escapeCrossingEmphasis: (html: string) => RepairResult;

package/dist/processor/transform/mdxish/tables/remap-positions.d.ts

@@ -1,9 +1,7 @@
 import type { Insert } from './utils';
 import type { Node } from 'mdast';
 /**
- * Walk `tree`, translating every node's position from the repaired source's
- * coordinate space back to the original source. Offsets are remapped via the
- * insert list; line/column are recomputed from the original source so they
- * remain accurate even if repairs introduced newlines.
+ * Remap positions produced after a chain of repairs (each applied to the prior
+ * one's output) back to the original source coordinates.
  */
-export declare const remapPositionsToOriginal: (tree: Node, originalSource: string, inserts: Insert[]) => void;
+export declare const remapPositionsThroughLayers: (tree: Node, originalSource: string, layers: Insert[][]) => void;

package/dist/processor/transform/mdxish/tables/split-nested-tables.d.ts

@@ -0,0 +1,11 @@
+import type { Html } from 'mdast';
+/**
+ * Given an HTML node that might contain table sequences inside it, split
+ * the node based on the table boundaries so they become a top level node.
+ *
+ * The surrounding raw HTML (the wrapper's open/close tags) would be re-nested
+ * around the parsed tables by rehype-raw.
+ *
+ * Returns null when there is no wrapped table to extract.
+ */
+export declare const splitHtmlWithNestedTables: (node: Html) => Html[] | null;

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;

package/dist/processor/utils.d.ts

@@ -2,6 +2,7 @@ import type { Root as HastRoot } from 'hast';
 import type { Node, Root as MdastRoot, Root } from 'mdast';
 import type { MdxJsxFlowElement, MdxJsxTextElement, MdxjsEsm } from 'mdast-util-mdx';
 import type { MdxJsxAttribute } from 'mdast-util-mdx-jsx';
+import type { Point } from 'unist';
 import { Parser } from 'acorn';
 /**
  * Single instance of acorn parser extended with `acorn-jsx`
@@ -24,6 +25,12 @@ export declare const jsxAcornParser: typeof Parser;
  * Throws on parse/runtime error; callers decide the fallback.
  */
 export declare function evaluate(source: string, scope?: Record<string, unknown>): any;
+/**
+ * Advance a `Point` by the `consumed` substring that follows it, returning the
+ * point at the consumed string's end. Lets split-out sub-nodes carry accurate
+ * document positions so downstream offset shifting stays correct.
+ */
+export declare const pointAfter: (start: Point, consumed: string) => Point;
 /**
  * Formats the hProperties of a node as a string, so they can be compiled back into JSX/MDX.
  * This currently sets all the values to a string since we process/compile the MDX on the fly