@readme/markdown 14.13.2 → 14.14.1

package/dist/index.d.ts

@@ -6,7 +6,7 @@ declare const utils: {
     getHref: typeof getHref;
     calloutIcons: {};
 };
-export { compile, exports, FLOW_TYPES, hast, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, extractToc, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
+export { compile, exports, FLOW_TYPES, hast, htmlToMarkdown, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, extractToc, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
 export type { MdxishOpts, RenderMdxishOpts, RunOpts } from './lib';
 export { default as Owlmoji } from './lib/owlmoji';
 export { Components, utils };

package/dist/lib/constants.d.ts

@@ -43,8 +43,10 @@ export declare const INLINE_COMPONENT_TAGS: Set<string>;
  */
 export declare const GENERIC_MDX_COMPONENT_EXCLUDED_TAGS: Set<string>;
 /**
- * Tags the micromark `mdxComponent` tokenizer must not claim, which
- * are inline components and those that have their own dedicated tokenizer
+ * Tags the micromark `mdxComponent` tokenizer must not claim: inline components,
+ * plus `Table` (whose rows `jsxTable` has to keep together). `HTMLBlock` is absent
+ * on purpose — claiming it yields the same `html` node, and the transforms skip it
+ * by name via {@link GENERIC_MDX_COMPONENT_EXCLUDED_TAGS}.
  */
 export declare const TOKENIZER_MDX_COMPONENT_EXCLUDED_TAGS: Set<string>;
 /**

package/dist/lib/htmlToMarkdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the Markdown form of `html`, or an empty string when there is no
+ * usable input. Synchronous, so it can run inside non-async serializers.
+ */
+export default function htmlToMarkdown(html?: string | null): string;

package/dist/lib/index.d.ts

@@ -4,6 +4,7 @@ export { default as astProcessor, remarkPlugins } from './ast-processor';
 export { default as compile } from './compile';
 export { default as exports } from './exports';
 export { default as hast } from './hast';
+export { default as htmlToMarkdown } from './htmlToMarkdown';
 export { default as mdast } from './mdast';
 export { default as mdastV6 } from './mdastV6';
 export { default as mdx } from './mdx';

package/dist/lib/micromark/mdx-component/syntax.d.ts

@@ -21,8 +21,10 @@ declare module 'micromark-util-types' {
  * transformer. All other PascalCase is flow-only; ReadMe's custom components
  * are authored as block-level elements.
  *
- * Excludes tags handled by dedicated tokenizers: Table, HTMLBlock, Glossary,
- * Anchor.
+ * Excludes Table, Glossary and Anchor (`TOKENIZER_MDX_COMPONENT_EXCLUDED_TAGS`).
+ * `HTMLBlock` is deliberately *not* excluded — this claims it into the same
+ * opaque `html` node `htmlBlockComponent` would, and the transforms skip it by
+ * name via `GENERIC_MDX_COMPONENT_EXCLUDED_TAGS`.
  *
  * The resulting `html` mdast node is later restructured into an
  * `mdxJsxFlowElement` (block) or `mdxJsxTextElement` (inline) by the

package/dist/lib/micromark/mdxish-extensions.d.ts

@@ -0,0 +1,140 @@
+import type { Extension as FromMarkdownExtension } from 'mdast-util-from-markdown';
+import type { Extension } from 'micromark-util-types';
+import { mdxExpressionFromMarkdown } from 'mdast-util-mdx-expression';
+import { mdxjsEsmFromMarkdown } from 'mdast-util-mdxjs-esm';
+import { emptyTaskListItemFromMarkdown } from '../mdast-util/empty-task-list-item';
+import { gemojiFromMarkdown } from '../mdast-util/gemoji';
+import { htmlBlockComponentFromMarkdown } from '../mdast-util/html-block-component';
+import { jsxTableFromMarkdown } from '../mdast-util/jsx-table';
+import { legacyVariableFromMarkdown } from '../mdast-util/legacy-variable';
+import { magicBlockFromMarkdown } from '../mdast-util/magic-block';
+import { mdxComponentFromMarkdown } from '../mdast-util/mdx-component';
+import { gemoji } from './gemoji';
+import { htmlBlockComponent } from './html-block-component';
+import { jsxComment } from './jsx-comment';
+import { jsxTable } from './jsx-table';
+import { legacyVariable } from './legacy-variable';
+import { looseHtmlEntity, looseHtmlEntityFromMarkdown } from './loose-html-entities';
+import { magicBlock } from './magic-block';
+import { mdxComponent } from './mdx-component';
+import { mdxExpressionLenient } from './mdx-expression-lenient';
+/**
+ * Constructs disabled for every MDXish parser.
+ * -`codeIndented`: To avoid formatting 4+ column indentation as code (default commonmark behavior)
+ *                  and match MDX behavior.
+ * Pass `extra` to disable more on top of the shared set, never in place of it.
+ */
+export declare const disableConstructs: (extra?: readonly string[]) => Extension;
+/**
+ * Every MDXish extension, in canonical registration order — **lowest priority
+ * first** (`combineExtensions` prepends, so a later entry is tried first), each
+ * syntax extension paired with its `fromMarkdown` counterpart.
+ *
+ * Notes:
+ * - `<` is the only contended code, in both `flow` and `text`. Every contender
+ *   currently emits the same opaque `html` node, so this order is a latent
+ *   guarantee, not an active fix — it starts mattering if one emits a different token.
+ */
+declare const REGISTRY: {
+    jsxComment: {
+        syntax: typeof jsxComment;
+        expression: true;
+    };
+    jsxTable: {
+        syntax: typeof jsxTable;
+        fromMarkdown: typeof jsxTableFromMarkdown;
+    };
+    magicBlock: {
+        syntax: typeof magicBlock;
+        fromMarkdown: typeof magicBlockFromMarkdown;
+    };
+    mdxExpressionLenient: {
+        syntax: typeof mdxExpressionLenient;
+        fromMarkdown: typeof mdxExpressionFromMarkdown;
+        expression: true;
+    };
+    mdxExpression: {
+        syntax: () => Extension;
+        fromMarkdown: typeof mdxExpressionFromMarkdown;
+        expression: true;
+    };
+    mdxComponent: {
+        syntax: typeof mdxComponent;
+        fromMarkdown: typeof mdxComponentFromMarkdown;
+    };
+    gemoji: {
+        syntax: typeof gemoji;
+        fromMarkdown: typeof gemojiFromMarkdown;
+    };
+    legacyVariable: {
+        syntax: typeof legacyVariable;
+        fromMarkdown: typeof legacyVariableFromMarkdown;
+    };
+    looseHtmlEntity: {
+        syntax: typeof looseHtmlEntity;
+        fromMarkdown: typeof looseHtmlEntityFromMarkdown;
+    };
+    htmlBlockComponent: {
+        syntax: typeof htmlBlockComponent;
+        fromMarkdown: typeof htmlBlockComponentFromMarkdown;
+    };
+    mdxjsEsm: {
+        syntax: () => Extension;
+        fromMarkdown: typeof mdxjsEsmFromMarkdown;
+        expression: true;
+    };
+    emptyTaskListItem: {
+        fromMarkdown: typeof emptyTaskListItemFromMarkdown;
+    };
+};
+export type MdxishFeature = keyof typeof REGISTRY;
+/**
+ * The feature set of every MDXish sub-parser, kept together so adding a
+ * tokenizer means deciding for each one rather than silently reaching none of
+ * them. A site opting out of a group should say so here, in the open.
+ */
+export declare const FEATURES: {
+    /** `lib/mdxish.ts` — the document parser; the only site taking every group */
+    document: ("gemoji" | "mdxjsEsm" | "magicBlock" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /**
+     * `components/utils.ts` — re-parses a component body, which should tokenize
+     * like the document around it: when the two drifted a `<Table>` in a
+     * `<Callout>` lost every row (CX-3705).
+     */
+    componentBody: ("gemoji" | "mdxjsEsm" | "magicBlock" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /**
+     * `lib/mdxishTags.ts` — collects component names, so nothing inline is needed.
+     * Omits `htmlBlockComponent` deliberately since it's not a custom component,
+     * and no components are meant to be nested inside it (it's just for raw HTML).
+     */
+    tags: ("gemoji" | "mdxjsEsm" | "magicBlock" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /** `tables/mdxish-tables.ts` — table cells */
+    tableCell: ("gemoji" | "mdxjsEsm" | "magicBlock" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /** `magic-blocks` — legacy content, no components */
+    magicBlockBody: ("gemoji" | "mdxjsEsm" | "magicBlock" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /** `magic-blocks` — api-header titles */
+    apiHeaderTitle: ("gemoji" | "mdxjsEsm" | "magicBlock" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+    /**
+     * `lib/stripComments.ts` — parses only to strip comments, then re-stringifies,
+     * so it needs the tokenizers that keep a construct in one piece across the
+     * round trip.
+     * No inline syntax: nothing here rewrites prose, and magic blocks are already excluded.
+     */
+    stripComments: ("gemoji" | "mdxjsEsm" | "htmlBlockComponent" | "jsxTable" | "legacyVariable" | "looseHtmlEntity" | "mdxComponent" | "jsxComment" | "mdxExpressionLenient" | "mdxExpression" | "emptyTaskListItem")[];
+};
+/**
+ * Builds the extension lists for an MDXish parser. `features` is an unordered
+ * set — ordering is `REGISTRY`'s job, so a call site can't get it wrong — and
+ * the base construct config is always registered.
+ *
+ * Extensions outside the registry (`mdxjs()`, `gfmStrikethrough()`) stay at their
+ * call site; spread them onto the result, minding the `flow` + `<` order.
+ */
+export declare function mdxishExtensions(features: readonly MdxishFeature[], { disable, safeMode }?: {
+    disable?: readonly string[];
+    safeMode?: boolean;
+}): {
+    fromMarkdownExtensions: FromMarkdownExtension[];
+    micromarkExtensions: Extension[];
+};
+export {};

package/dist/lib/utils/jsx-acorn-parser.d.ts

@@ -0,0 +1,10 @@
+import { Parser } from 'acorn';
+/**
+ * Single instance of acorn parser extended with `acorn-jsx`
+ * to parse expressions containing JSX.
+ *
+ * Lives in its own dependency-free module because the micromark extension
+ * registry needs it during module initialisation, and `processor/utils` sits in
+ * an import cycle with the parsers that consume the registry.
+ */
+export declare const jsxAcornParser: typeof Parser;