md2x 0.1.0

package/dist/types/src/exporters/docx-exporter.d.ts

@@ -0,0 +1,77 @@
+import type { PluginRenderer } from '../types/plugin';
+import type { ImageBufferResult, DOCXProgressCallback, DOCXExportResult } from '../types/docx';
+export { convertPluginResultToDOCX } from './docx-image-utils';
+/**
+ * Main class for exporting Markdown to DOCX
+ */
+declare class DocxExporter {
+    private renderer;
+    private imageCache;
+    private listInstanceCounter;
+    private mathJaxInitialized;
+    private baseUrl;
+    private themeStyles;
+    private codeHighlighter;
+    private linkDefinitions;
+    private progressCallback;
+    private totalResources;
+    private processedResources;
+    private docxHrAsPageBreak;
+    private docxEmojiStyle;
+    private frontmatterDisplay;
+    private tableConverter;
+    private blockquoteConverter;
+    private listConverter;
+    private inlineConverter;
+    constructor(renderer?: PluginRenderer | null);
+    setBaseUrl(url: string): void;
+    /**
+     * Get DocumentService from platform
+     */
+    private getDocumentService;
+    initializeMathJax(): Promise<void>;
+    /**
+     * Initialize all converters with current context
+     */
+    private initializeConverters;
+    exportToDocx(markdown: string, filename?: string, onProgress?: DOCXProgressCallback | null): Promise<DOCXExportResult>;
+    private countResources;
+    private reportResourceProgress;
+    /**
+     * Extract frontmatter from markdown text
+     * @returns Tuple of [frontmatter content or null, markdown without frontmatter]
+     */
+    private extractFrontmatter;
+    /**
+     * Parse frontmatter YAML content (simple key: value parsing)
+     */
+    private parseFrontmatterData;
+    private frontmatterContent;
+    private parseMarkdown;
+    /**
+     * Check if a node is a [toc] marker
+     * Detects paragraphs containing only [toc] or [TOC]
+     */
+    private isTocMarker;
+    /**
+     * Convert frontmatter to DOCX elements based on display mode
+     */
+    private convertFrontmatterToDocx;
+    private convertAstToDocx;
+    private convertNode;
+    private convertHeading;
+    private convertParagraph;
+    private convertCodeBlock;
+    private convertHtml;
+    private convertThematicBreak;
+    private convertMathBlock;
+    private toAlignmentType;
+    private toDocumentDefaults;
+    private toHeadingStyle;
+    fetchImageAsBuffer(url: string): Promise<ImageBufferResult>;
+    /**
+     * Guess content type from URL extension
+     */
+    private guessContentType;
+}
+export default DocxExporter;

package/dist/types/src/exporters/docx-image-utils.d.ts

@@ -0,0 +1,71 @@
+import { Paragraph, TextRun, ImageRun } from 'docx';
+import type { UnifiedRenderResult } from '../types/index';
+import type { ImageBufferResult, DOCXImageType } from '../types/docx';
+interface ImageDimensions {
+    width: number;
+    height: number;
+}
+interface Renderer {
+    render(type: string, content: string, options?: Record<string, unknown>): Promise<{
+        base64: string;
+        width: number;
+        height: number;
+    }>;
+}
+type FetchImageAsBufferFunction = (url: string) => Promise<ImageBufferResult>;
+/**
+ * Calculate appropriate image dimensions for DOCX to fit within page constraints
+ * Maximum width: 6 inches (page width with 1 inch margins on letter size)
+ * Maximum height: 9.5 inches (page height with 1 inch margins on letter size)
+ * @param originalWidth - Original image width in pixels
+ * @param originalHeight - Original image height in pixels
+ * @returns {width: number, height: number} in pixels
+ */
+export declare function calculateImageDimensions(originalWidth: number, originalHeight: number): ImageDimensions;
+/**
+ * Convert unified plugin render result to DOCX elements
+ * @param renderResult - Unified render result from plugin.renderToCommon()
+ * @param pluginType - Plugin type for alt text
+ * @returns DOCX Paragraph or ImageRun
+ */
+export declare function convertPluginResultToDOCX(renderResult: UnifiedRenderResult, pluginType?: string): Paragraph | TextRun | ImageRun;
+/**
+ * Get image dimensions from buffer
+ * @param buffer - Image buffer
+ * @param contentType - Image content type
+ * @returns Promise with width and height
+ */
+export declare function getImageDimensions(buffer: Uint8Array, contentType: string): Promise<ImageDimensions>;
+/**
+ * Determine image type from content type or URL
+ * @param contentType - Image content type
+ * @param url - Image URL
+ * @returns Image type for docx
+ */
+export declare function determineImageType(contentType: string | null, url: string): DOCXImageType;
+/**
+ * Check if URL or content type indicates an SVG image
+ * @param url - Image URL
+ * @param contentType - Content type (optional)
+ * @returns True if SVG
+ */
+export declare function isSvgImage(url: string, contentType?: string | null): boolean;
+/**
+ * Convert SVG content to PNG using renderer
+ * @param svgContent - SVG content string
+ * @param renderer - Renderer instance with render() method
+ * @returns Promise with buffer, width, and height
+ */
+export declare function convertSvgToPng(svgContent: string, renderer: Renderer): Promise<{
+    buffer: Uint8Array;
+    width: number;
+    height: number;
+}>;
+/**
+ * Get SVG content from URL or data URL
+ * @param url - SVG URL or data URL
+ * @param fetchImageAsBuffer - Function to fetch image as buffer
+ * @returns SVG content string
+ */
+export declare function getSvgContent(url: string, fetchImageAsBuffer: FetchImageAsBufferFunction): Promise<string>;
+export {};

package/dist/types/src/exporters/docx-inline-converter.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Inline node conversion for DOCX export
+ */
+import { TextRun, ImageRun, type IRunOptions, type ParagraphChild } from 'docx';
+import type { DOCXThemeStyles, LinkDefinition, ImageBufferResult, EmojiStyle } from '../types/docx';
+/**
+ * Renderer interface for SVG conversion
+ */
+interface Renderer {
+    render(type: string, content: string, options?: object): Promise<{
+        base64: string;
+        width: number;
+        height: number;
+        format: string;
+    }>;
+}
+/**
+ * Options for creating inline converter
+ */
+interface InlineConverterOptions {
+    themeStyles: DOCXThemeStyles;
+    fetchImageAsBuffer: (url: string) => Promise<ImageBufferResult>;
+    reportResourceProgress: () => void;
+    linkDefinitions?: Map<string, LinkDefinition>;
+    renderer?: Renderer | null;
+    emojiStyle?: EmojiStyle;
+    linkColor?: string;
+}
+/**
+ * Parent style for inline elements
+ */
+interface ParentStyle extends Partial<IRunOptions> {
+    size?: number;
+    bold?: boolean;
+    italics?: boolean;
+    strike?: boolean;
+}
+/**
+ * AST Node types
+ */
+interface BaseNode {
+    type: string;
+}
+interface TextNode extends BaseNode {
+    type: 'text';
+    value: string;
+}
+interface StrongNode extends BaseNode {
+    type: 'strong';
+    children: InlineNode[];
+}
+interface EmphasisNode extends BaseNode {
+    type: 'emphasis';
+    children: InlineNode[];
+}
+interface DeleteNode extends BaseNode {
+    type: 'delete';
+    children: InlineNode[];
+}
+interface InlineCodeNode extends BaseNode {
+    type: 'inlineCode';
+    value: string;
+}
+interface LinkNode extends BaseNode {
+    type: 'link';
+    url: string;
+    title?: string;
+    children: InlineNode[];
+}
+interface LinkReferenceNode extends BaseNode {
+    type: 'linkReference';
+    identifier: string;
+    children: InlineNode[];
+}
+interface ImageNode extends BaseNode {
+    type: 'image';
+    url: string;
+    alt?: string;
+    title?: string;
+}
+interface InlineMathNode extends BaseNode {
+    type: 'inlineMath';
+    value: string;
+}
+interface BreakNode extends BaseNode {
+    type: 'break';
+}
+interface HtmlNode extends BaseNode {
+    type: 'html';
+    value?: string;
+}
+interface SuperscriptNode extends BaseNode {
+    type: 'superscript';
+    children: InlineNode[];
+}
+interface SubscriptNode extends BaseNode {
+    type: 'subscript';
+    children: InlineNode[];
+}
+export type InlineNode = TextNode | StrongNode | EmphasisNode | DeleteNode | InlineCodeNode | LinkNode | LinkReferenceNode | ImageNode | InlineMathNode | BreakNode | HtmlNode | SuperscriptNode | SubscriptNode;
+/**
+ * Inline converter result type
+ */
+export type InlineResult = ParagraphChild;
+/**
+ * Inline converter interface
+ */
+export interface InlineConverter {
+    convertInlineNodes(nodes: InlineNode[], parentStyle?: ParentStyle): Promise<InlineResult[]>;
+    convertInlineNode(node: InlineNode, parentStyle?: ParentStyle): Promise<InlineResult | InlineResult[] | null>;
+    convertImage(node: ImageNode): Promise<ImageRun | TextRun>;
+    extractText(node: InlineNode | {
+        type: string;
+        children?: InlineNode[];
+        value?: string;
+    }): string;
+}
+/**
+ * Create an inline node converter
+ * @param options - Configuration options
+ * @returns Inline node converter
+ */
+export declare function createInlineConverter({ themeStyles, fetchImageAsBuffer, reportResourceProgress, linkDefinitions, renderer, emojiStyle, linkColor }: InlineConverterOptions): InlineConverter;
+export {};

package/dist/types/src/exporters/docx-list-converter.d.ts

@@ -0,0 +1,50 @@
+import { AlignmentType, LevelFormat, type FileChild } from 'docx';
+import type { DOCXThemeStyles, DOCXListNode, DOCXASTNode } from '../types/docx';
+import type { InlineResult, InlineNode } from './docx-inline-converter';
+interface ListItemNode {
+    type: string;
+    checked?: boolean | null;
+    children: (InlineNode | DOCXListNode | {
+        type: string;
+        children?: InlineNode[];
+    })[];
+}
+type ConvertInlineNodesFunction = (children: InlineNode[], options?: Record<string, unknown>) => Promise<InlineResult[]>;
+type ConvertChildNodeFunction = (node: DOCXASTNode, listLevel?: number) => Promise<FileChild | FileChild[] | null>;
+interface ListConverterOptions {
+    themeStyles: DOCXThemeStyles;
+    convertInlineNodes: ConvertInlineNodesFunction;
+    getListInstanceCounter: () => number;
+    incrementListInstanceCounter: () => number;
+}
+interface NumberingLevel {
+    level: number;
+    format: (typeof LevelFormat)[keyof typeof LevelFormat];
+    text: string;
+    alignment: typeof AlignmentType.START;
+    style: {
+        paragraph: {
+            indent: {
+                left: number;
+                hanging: number;
+            };
+        };
+    };
+}
+/**
+ * Create numbering levels configuration for ordered lists
+ * @returns Numbering levels configuration
+ */
+export declare function createNumberingLevels(): NumberingLevel[];
+export interface ListConverter {
+    convertList(node: DOCXListNode): Promise<FileChild[]>;
+    convertListItem(ordered: boolean, item: ListItemNode, level: number, listInstance: number): Promise<FileChild[]>;
+    setConvertChildNode(fn: ConvertChildNodeFunction): void;
+}
+/**
+ * Create a list converter
+ * @param options - Configuration options
+ * @returns List converter
+ */
+export declare function createListConverter({ themeStyles, convertInlineNodes, getListInstanceCounter, incrementListInstanceCounter }: ListConverterOptions): ListConverter;
+export {};

package/dist/types/src/exporters/docx-math-converter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DOCX Math Converter
+ * Converts LaTeX math expressions to DOCX-compatible OMML format
+ */
+import { XmlComponent } from 'docx';
+export declare function convertMathMl2Omml(mathMlString: string): string;
+declare function convertOmml2Math(ommlString: string): XmlComponent;
+declare function convertMathMl2Math(mathMlString: string): XmlComponent;
+export declare function mathJaxReady(): Promise<boolean>;
+export declare function convertLatex2Math(latexString: string): XmlComponent;
+export { convertMathMl2Math, convertOmml2Math };

package/dist/types/src/exporters/docx-table-converter.d.ts

@@ -0,0 +1,22 @@
+import { Table } from 'docx';
+import type { DOCXThemeStyles, DOCXTableNode } from '../types/docx';
+import type { InlineResult, InlineNode } from './docx-inline-converter';
+type ConvertInlineNodesFunction = (children: InlineNode[], options?: {
+    bold?: boolean;
+    size?: number;
+    color?: string;
+}) => Promise<InlineResult[]>;
+interface TableConverterOptions {
+    themeStyles: DOCXThemeStyles;
+    convertInlineNodes: ConvertInlineNodesFunction;
+}
+export interface TableConverter {
+    convertTable(node: DOCXTableNode, listLevel?: number): Promise<Table>;
+}
+/**
+ * Create a table converter
+ * @param options - Configuration options
+ * @returns Table converter
+ */
+export declare function createTableConverter({ themeStyles, convertInlineNodes }: TableConverterOptions): TableConverter;
+export {};

package/dist/types/src/exporters/mml2omml.d.ts

@@ -0,0 +1,2 @@
+declare const mml2omml: (mmlString: any, options: any) => any;
+export { mml2omml };

package/dist/types/src/exporters/theme-to-docx.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Theme to DOCX Converter
+ * Converts theme configuration to DOCX styles
+ */
+import type { DOCXThemeStyles } from '../types/docx';
+import type { ColorScheme } from '../types/index';
+export type { DOCXThemeStyles };
+/**
+ * Heading style configuration (font-related properties only)
+ */
+interface HeadingConfig {
+    fontFamily?: string;
+    fontWeight?: string;
+}
+/**
+ * Font scheme configuration (font-related properties only)
+ * Layout properties (fontSize, lineHeight, spacing) are in LayoutScheme
+ * Color properties are in ColorScheme
+ */
+interface FontScheme {
+    body: {
+        fontFamily: string;
+    };
+    headings: {
+        fontFamily: string;
+        fontWeight?: string;
+        [key: string]: string | HeadingConfig | undefined;
+    };
+    code: {
+        fontFamily: string;
+    };
+}
+/**
+ * Theme configuration
+ */
+interface ThemeConfig {
+    fontScheme: FontScheme;
+    layoutScheme: string;
+    tableStyle: string;
+    codeTheme: string;
+}
+/**
+ * Layout scheme heading configuration
+ */
+interface LayoutHeadingConfig {
+    fontSize: string;
+    spacingBefore: string;
+    spacingAfter: string;
+    alignment?: 'left' | 'center' | 'right';
+}
+/**
+ * Layout scheme block configuration
+ */
+interface LayoutBlockConfig {
+    spacingBefore?: string;
+    spacingAfter?: string;
+    paddingVertical?: string;
+    paddingHorizontal?: string;
+}
+/**
+ * Layout scheme configuration (absolute pt values)
+ */
+interface LayoutScheme {
+    id: string;
+    name: string;
+    name_en: string;
+    description: string;
+    description_en?: string;
+    body: {
+        fontSize: string;
+        lineHeight: number;
+    };
+    headings: {
+        h1: LayoutHeadingConfig;
+        h2: LayoutHeadingConfig;
+        h3: LayoutHeadingConfig;
+        h4: LayoutHeadingConfig;
+        h5: LayoutHeadingConfig;
+        h6: LayoutHeadingConfig;
+    };
+    code: {
+        fontSize: string;
+    };
+    blocks: {
+        paragraph: LayoutBlockConfig;
+        list: LayoutBlockConfig;
+        listItem: LayoutBlockConfig;
+        blockquote: LayoutBlockConfig;
+        codeBlock: LayoutBlockConfig;
+        table: LayoutBlockConfig;
+        horizontalRule: LayoutBlockConfig;
+    };
+}
+/**
+ * Border configuration (layout properties only, color from ColorScheme)
+ */
+interface BorderConfig {
+    style: string;
+    width: string;
+}
+/**
+ * Table style configuration (layout properties only, colors from ColorScheme)
+ */
+interface TableStyleConfig {
+    border?: {
+        all?: BorderConfig;
+        headerTop?: BorderConfig;
+        headerBottom?: BorderConfig;
+        rowBottom?: BorderConfig;
+        lastRowBottom?: BorderConfig;
+    };
+    header: {
+        fontWeight?: string;
+    };
+    cell: {
+        padding: string;
+    };
+    zebra?: {
+        enabled: boolean;
+    };
+}
+/**
+ * Code theme configuration (from code theme JSON)
+ */
+interface CodeThemeConfig {
+    colors: Record<string, string>;
+    foreground?: string;
+}
+/**
+ * Convert theme configuration to DOCX styles object
+ * @param theme - Theme configuration object
+ * @param layoutScheme - Layout scheme configuration
+ * @param colorScheme - Color scheme configuration
+ * @param tableStyle - Table style configuration
+ * @param codeTheme - Code highlighting theme
+ * @returns DOCX styles configuration
+ */
+export declare function themeToDOCXStyles(theme: ThemeConfig, layoutScheme: LayoutScheme, colorScheme: ColorScheme, tableStyle: TableStyleConfig, codeTheme: CodeThemeConfig): DOCXThemeStyles;
+/**
+ * Load and prepare complete theme configuration for DOCX export
+ * @param themeId - Theme ID to load
+ * @returns DOCX styles configuration
+ */
+export declare function loadThemeForDOCX(themeId: string): Promise<DOCXThemeStyles>;

package/dist/types/src/plugins/base-plugin.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Base Plugin Class
+ *
+ * Abstract base class for diagram plugins.
+ * Defines the plugin interface and core rendering logic.
+ */
+import type { ASTNode, PluginRenderer, UnifiedRenderResult } from '../types/index';
+export declare class BasePlugin {
+    type: string;
+    /**
+     * @param type - Plugin type identifier (e.g., 'mermaid', 'vega')
+     */
+    constructor(type: string);
+    /**
+     * Get AST node selectors for remark visit
+     * @returns Array of node types to visit (e.g., ['code'], ['code', 'image'])
+     */
+    get nodeSelector(): string[];
+    /**
+     * Get language identifier for code blocks
+     * @returns Language identifier or null for non-code nodes
+     */
+    get language(): string | null;
+    /**
+     * Extract content from AST node
+     * Plugins override this to implement their own node matching logic
+     * @param node - AST node
+     * @returns Extracted content or null if not applicable
+     */
+    extractContent(node: ASTNode): string | null;
+    /**
+     * Create async task data for rendering
+     * @param content - Extracted content
+     * @returns Task data with code and any extra parameters
+     */
+    createTaskData(content: string): Record<string, unknown>;
+    /**
+     * Get extra rendering parameters
+     * @returns Extra parameters for renderer
+     */
+    getRenderParams(): Record<string, unknown>;
+    /**
+     * Check if this plugin uses inline rendering
+     * @returns True for inline (span), false for block (div)
+     */
+    isInline(): boolean;
+    /**
+     * Check if extracted content is a URL that needs fetching
+     * @param content - Extracted content
+     * @returns True if content is a URL
+     */
+    isUrl(content: string): boolean;
+    /**
+     * Fetch content from URL
+     * @param url - URL to fetch
+     * @returns Fetched content
+     */
+    fetchContent(url: string): Promise<string>;
+    /**
+     * Render content to unified intermediate format
+     * This is the core rendering method that returns a format-agnostic result
+     * @param renderer - Renderer instance
+     * @param content - Content to render
+     * @returns Unified render result
+     */
+    renderToCommon(renderer: PluginRenderer | null, content: string): Promise<UnifiedRenderResult>;
+}

package/dist/types/src/plugins/canvas-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JSON Canvas Plugin
+ *
+ * Handles JSON Canvas processing in content script and DOCX export
+ */
+import { BasePlugin } from './base-plugin';
+export declare class JsonCanvasPlugin extends BasePlugin {
+    constructor();
+}

package/dist/types/src/plugins/dot-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * DOT Plugin
+ *
+ * Handles Graphviz DOT diagram processing in content script and DOCX export
+ */
+import { BasePlugin } from './base-plugin';
+export declare class DotPlugin extends BasePlugin {
+    constructor();
+}

package/dist/types/src/plugins/html-plugin.d.ts

@@ -0,0 +1,28 @@
+/**
+ * HTML Plugin
+ *
+ * Handles HTML code block processing in content script and DOCX export
+ */
+import { BasePlugin } from './base-plugin';
+/**
+ * AST node interface for HTML plugin
+ */
+interface AstNode {
+    type: string;
+    value?: string;
+}
+export declare class HtmlPlugin extends BasePlugin {
+    constructor();
+    /**
+     * Get AST node selectors for remark visit
+     * @returns Array with 'html' node type
+     */
+    get nodeSelector(): string[];
+    /**
+     * Extract content from HTML node
+     * @param node - AST node
+     * @returns Extracted content or null
+     */
+    extractContent(node: AstNode): string | null;
+}
+export {};

package/dist/types/src/plugins/index.d.ts

@@ -0,0 +1,56 @@
+import type { BasePlugin } from './base-plugin';
+import type { Processor } from 'unified';
+import type { Node, Parent } from 'unist';
+import type { AsyncTaskQueueManager, TranslateFunction, EscapeHtmlFunction, PluginRenderer } from '../types/index';
+/**
+ * Visit function type from unist-util-visit
+ */
+type VisitFn = (tree: Node, test: string, visitor: (node: Node, index: number | undefined, parent: Parent | undefined) => void) => void;
+/**
+ * DOCX helper objects
+ */
+interface DOCXHelpers {
+    [key: string]: unknown;
+}
+export declare const plugins: BasePlugin[];
+/**
+ * Register all plugins to a remark processor
+ * This creates a single unified plugin that processes all node types in document order
+ * @param processor - Unified/remark processor
+ * @param renderer - Renderer instance
+ * @param asyncTask - Async task creator from AsyncTaskQueueManager
+ * @param translate - Translation function
+ * @param escapeHtml - HTML escape function
+ * @param visit - unist-util-visit function
+ * @returns The processor (for chaining)
+ */
+export declare function registerRemarkPlugins(processor: Processor, renderer: PluginRenderer, asyncTask: AsyncTaskQueueManager['asyncTask'], translate: TranslateFunction, escapeHtml: EscapeHtmlFunction, visit: VisitFn): Processor;
+/**
+ * Get a plugin by type
+ * @param type - Plugin type (e.g., 'mermaid', 'svg', 'html')
+ * @returns Plugin instance or null if not found
+ */
+export declare function getPluginByType(type: string): BasePlugin | null;
+/**
+ * Get a plugin that can handle a specific AST node
+ * @param node - AST node (e.g., code block or html node)
+ * @returns Plugin instance or null if no plugin can handle
+ */
+export declare function getPluginForNode(node: Node): BasePlugin | null;
+/**
+ * Get all plugin types
+ * @returns Array of plugin types
+ */
+export declare function getPluginTypes(): string[];
+/**
+ * Convert AST node to DOCX element using appropriate plugin
+ * High-level wrapper that encapsulates plugin lookup, content extraction, and conversion
+ *
+ * @param node - AST node to convert
+ * @param renderer - Renderer instance for generating images
+ * @param docxHelpers - DOCX helper objects and functions
+ * @param progressCallback - Optional callback to report progress
+ * @returns DOCX element (Paragraph/ImageRun) or null if no plugin handles this node
+ */
+export declare function convertNodeToDOCX(node: Node, renderer: PluginRenderer, docxHelpers: DOCXHelpers, progressCallback?: (() => void) | null): Promise<unknown | null>;
+export {};

package/dist/types/src/plugins/infographic-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Infographic Plugin
+ *
+ * Handles AntV Infographic syntax processing in content script and DOCX export
+ */
+import { BasePlugin } from './base-plugin';
+export declare class InfographicPlugin extends BasePlugin {
+    constructor();
+}