@readme/markdown 12.2.0 → 13.1.0

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

@@ -1,2 +1,4 @@
-declare function compilers(): void;
+import type { Processor } from 'unified';
+declare function compilers(this: Processor, mdxish?: boolean): void;
+export declare function mdxishCompilers(this: Processor): any;
 export default compilers;

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

@@ -0,0 +1,10 @@
+interface VariableNode {
+    data: {
+        hProperties: {
+            name?: string;
+        };
+    };
+    type: 'readme-variable';
+}
+declare const variable: (node: VariableNode) => string;
+export default variable;

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

@@ -0,0 +1,15 @@
+/**
+ * Unified plugin that transforms `magicBlock` MDAST nodes into final nodes.
+ *
+ * This replaces the magicBlockRestorer plugin by working directly with
+ * parsed `magicBlock` nodes from the micromark tokenizer instead of
+ * finding placeholder tokens.
+ */
+import type { MagicBlockTransformerOptions } from './types';
+import type { Root as MdastRoot } from 'mdast';
+import type { Plugin } from 'unified';
+/**
+ * Unified plugin that transforms magicBlock nodes into final MDAST nodes.
+ */
+declare const magicBlockTransformer: Plugin<[MagicBlockTransformerOptions?], MdastRoot>;
+export default magicBlockTransformer;

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

@@ -0,0 +1,72 @@
+export declare const EMPTY_IMAGE_PLACEHOLDER: {
+    type: string;
+    url: string;
+    alt: string;
+    title: string;
+    data: {
+        hProperties: {};
+    };
+};
+export declare const EMPTY_EMBED_PLACEHOLDER: {
+    type: string;
+    children: {
+        type: string;
+        url: string;
+        title: string;
+        children: {
+            type: string;
+            value: string;
+        }[];
+    }[];
+    data: {
+        hName: string;
+        hProperties: {
+            url: string;
+            href: string;
+            title: string;
+        };
+    };
+};
+export declare const EMPTY_RECIPE_PLACEHOLDER: {
+    type: string;
+    name: string;
+    attributes: any[];
+    children: any[];
+};
+export declare const EMPTY_CALLOUT_PLACEHOLDER: {
+    type: string;
+    name: string;
+    attributes: {
+        type: string;
+        name: string;
+        value: string;
+    }[];
+    children: {
+        type: string;
+        depth: number;
+        children: {
+            type: string;
+            value: string;
+        }[];
+    }[];
+};
+export declare const EMPTY_TABLE_PLACEHOLDER: {
+    type: string;
+    align: string[];
+    children: {
+        type: string;
+        children: {
+            type: string;
+            children: {
+                type: string;
+                value: string;
+            }[];
+        }[];
+    }[];
+};
+export declare const EMPTY_CODE_PLACEHOLDER: {
+    type: string;
+    value: string;
+    lang: any;
+    meta: any;
+};

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

@@ -0,0 +1,120 @@
+import type { RootContent } from 'mdast';
+import type { Position } from 'unist';
+export interface MdastNode {
+    [key: string]: unknown;
+    children?: MdastNode[];
+    type: string;
+}
+/**
+ * Base interface for magic block JSON data.
+ */
+export interface MagicBlockJson {
+    [key: string]: unknown;
+    sidebar?: boolean;
+}
+export interface CodeBlockJson extends MagicBlockJson {
+    codes: {
+        code: string;
+        language: string;
+        name?: string;
+    }[];
+}
+export interface ApiHeaderJson extends MagicBlockJson {
+    level?: number;
+    title?: string;
+}
+export interface ImageBlockJson extends MagicBlockJson {
+    images: {
+        align?: string;
+        border?: boolean;
+        caption?: string;
+        image?: [string, string?, string?];
+        sizing?: string;
+    }[];
+}
+export interface CalloutJson extends MagicBlockJson {
+    body?: string;
+    icon?: string;
+    title?: string;
+    type?: string | [string, string];
+}
+export interface ParametersJson extends MagicBlockJson {
+    align?: string[];
+    cols: number;
+    data: Record<string, string>;
+    rows: number;
+}
+export interface EmbedJson extends MagicBlockJson {
+    html?: boolean;
+    provider?: string;
+    title?: string | null;
+    url: string;
+}
+export interface HtmlJson extends MagicBlockJson {
+    html: string;
+}
+export interface RecipeJson extends MagicBlockJson {
+    backgroundColor?: string;
+    emoji?: string;
+    id?: string;
+    link?: string;
+    slug: string;
+    title: string;
+}
+export interface MagicBlockTransformerOptions {
+    compatibilityMode?: boolean;
+    safeMode?: boolean;
+}
+/**
+ * Magic block image node structure (output from magicBlockTransformer).
+ * This is an intermediate format before conversion to ImageBlock.
+ */
+export interface MagicBlockImage {
+    alt?: string;
+    data?: {
+        hProperties?: {
+            align?: string;
+            border?: string;
+            width?: string;
+        };
+    };
+    position?: Position;
+    title?: string;
+    type: 'image';
+    url?: string;
+}
+/**
+ * Magic block embed node structure (output from magicBlockTransformer).
+ * This is an intermediate format before conversion to EmbedBlock.
+ */
+export interface MagicBlockEmbed {
+    children?: RootContent[];
+    data?: {
+        hName?: string;
+        hProperties?: {
+            favicon?: string;
+            href?: string;
+            html?: string;
+            image?: string;
+            provider?: string;
+            providerName?: string;
+            providerUrl?: string;
+            title?: string;
+            url?: string;
+        };
+    };
+    position?: Position;
+    type: 'embed';
+}
+/**
+ * Figure node that may contain an image (from magicBlockTransformer with caption).
+ * This is an intermediate format before conversion to Figure.
+ */
+export interface MagicBlockFigure {
+    children: RootContent[];
+    data?: {
+        hName?: string;
+    };
+    position?: Position;
+    type: 'figure';
+}

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

@@ -0,0 +1,15 @@
+import type { Parent } from 'mdast';
+import type { Plugin } from 'unified';
+/**
+ * Transform mdxJsxFlowElement nodes and magic block nodes into proper MDAST node types.
+ *
+ * This transformer runs after mdxishComponentBlocks and converts:
+ * - JSX component elements (Image, Callout, Embed, Recipe) into their corresponding MDAST types
+ * - Magic block image nodes (type: 'image') into image-block
+ * - Magic block embed nodes (type: 'embed') into embed-block
+ * - Figure nodes containing images (from magic blocks with captions) - transforms the inner image
+ *
+ * This is controlled by the `newEditorTypes` flag to maintain backwards compatibility.
+ */
+declare const mdxishJsxToMdast: Plugin<[], Parent>;
+export default mdxishJsxToMdast;

package/dist/processor/transform/mdxish/mdxish-snake-case-components.d.ts

@@ -3,12 +3,24 @@ export interface SnakeCasePreprocessResult {
     content: string;
     mapping: SnakeCaseMapping;
 }
+export interface ProcessSnakeCaseOptions {
+    /**
+     * Set of known component names
+     * Used to filter which snake_case components to transform
+    */
+    knownComponents?: Set<string>;
+}
 /**
  * Replaces snake_case component names with valid HTML placeholders.
  * Required because remark-parse rejects tags with underscores.
  * Example: `<Snake_case />` → `<MDXishSnakeCase0 />`
+ *
+ * Code blocks and inline code are protected and will not be transformed.
+ *
+ * @param content - The markdown content to process
+ * @param options - Options including knownComponents to filter by
  */
-export declare function processSnakeCaseComponent(content: string): SnakeCasePreprocessResult;
+export declare function processSnakeCaseComponent(content: string, options?: ProcessSnakeCaseOptions): SnakeCasePreprocessResult;
 /**
  * Restores placeholder name to original snake_case name.
  * Uses case-insensitive matching since HTML parsers normalize to lowercase.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@readme/markdown",
   "description": "ReadMe's React-based Markdown parser",
   "author": "Rafe Goldberg <rafe@readme.io>",
-  "version": "12.2.0",
+  "version": "13.1.0",
   "main": "dist/main.node.js",
   "types": "dist/index.d.ts",
   "browser": "dist/main.js",
@@ -45,6 +45,8 @@
     "mdast-util-phrasing": "^4.1.0",
     "mdast-util-to-markdown": "^2.1.2",
     "micromark-extension-mdx-expression": "^3.0.1",
+    "micromark-util-character": "^2.1.1",
+    "micromark-util-symbol": "^2.0.1",
     "path-browserify": "^1.0.1",
     "postcss": "^8.5.1",
     "postcss-prefix-selector": "^2.1.0",
@@ -156,7 +158,7 @@
       },
       {
         "path": "dist/main.node.js",
-        "maxSize": "790KB"
+        "maxSize": "800KB"
       }
     ]
   },

package/styles/gfm.scss

@@ -259,6 +259,10 @@
     color: #6a737d;
     display: block;
     padding: 0 1em;
+
+    &:has(img, figure, .Image) {
+      display: flow-root;
+    }
   }
 
   blockquote > :first-child {

package/dist/lib/utils/extractMagicBlocks.d.ts

@@ -1,25 +0,0 @@
-export interface BlockHit {
-    key: string;
-    raw: string;
-    token: string;
-}
-/**
- * The content matching in this regex captures everything between `[block:TYPE]`
- * and `[/block]`, including new lines. Negative lookahead for the closing
- * `[/block]` tag is required to prevent greedy matching to ensure it stops at
- * the first closing tag it encounters preventing vulnerability to polynomial
- * backtracking issues.
- */
-export declare const MAGIC_BLOCK_REGEX: RegExp;
-/**
- * Extract legacy magic block syntax from a markdown string.
- * Returns the modified markdown and an array of extracted blocks.
- */
-export declare function extractMagicBlocks(markdown: string): {
-    replaced: string;
-    blocks: BlockHit[];
-};
-/**
- * Restore extracted magic blocks back into a markdown string.
- */
-export declare function restoreMagicBlocks(replaced: string, blocks: BlockHit[]): string;

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

@@ -1,25 +0,0 @@
-/**
- * Legacy magic block parser for RDMD compatibility.
- * Parses `[block:TYPE]JSON[/block]` syntax and returns MDAST nodes.
- * Taken from the v6 branch with some modifications to be more type safe
- * and adapted with the mdxish flow.
- */
-import type { BlockHit } from '../../../lib/utils/extractMagicBlocks';
-import type { Root as MdastRoot } from 'mdast';
-import type { Plugin } from 'unified';
-export interface ParseMagicBlockOptions {
-    alwaysThrow?: boolean;
-    compatibilityMode?: boolean;
-    safeMode?: boolean;
-}
-/**
- * Unified plugin that restores magic blocks from placeholder tokens.
- *
- * During preprocessing, extractMagicBlocks replaces [block:TYPE]...[/block]
- * with inline code tokens like `__MAGIC_BLOCK_0__`. This plugin finds those
- * tokens in the parsed MDAST and replaces them with the parsed block content.
- */
-declare const magicBlockRestorer: Plugin<[{
-    blocks: BlockHit[];
-}], MdastRoot>;
-export default magicBlockRestorer;