@f-o-t/markdown 1.0.2 → 1.0.6

package/dist/index.d.ts

@@ -1,780 +1,12 @@
-import { z } from "zod";
-/**
-* Default maximum buffer size (10MB) to prevent memory exhaustion attacks.
-*/
-declare const DEFAULT_MAX_BUFFER_SIZE: number;
-/**
-* Source position for a node in the original markdown.
-*/
-declare const positionSchema: any;
-type Position = z.infer<typeof positionSchema>;
-interface TextNode {
-	type: "text";
-	value: string;
-	position?: Position;
-}
-interface CodeSpanNode {
-	type: "codeSpan";
-	value: string;
-	position?: Position;
-}
-interface HardBreakNode {
-	type: "hardBreak";
-	position?: Position;
-}
-interface SoftBreakNode {
-	type: "softBreak";
-	position?: Position;
-}
-interface HtmlInlineNode {
-	type: "htmlInline";
-	value: string;
-	position?: Position;
-}
-interface EmphasisNode {
-	type: "emphasis";
-	children: InlineNode[];
-	marker: "*" | "_";
-	position?: Position;
-}
-interface StrongNode {
-	type: "strong";
-	children: InlineNode[];
-	marker: "**" | "__";
-	position?: Position;
-}
-interface LinkNode {
-	type: "link";
-	url: string;
-	children: InlineNode[];
-	title?: string;
-	reference?: string;
-	position?: Position;
-}
-interface ImageNode {
-	type: "image";
-	alt: string;
-	url: string;
-	title?: string;
-	reference?: string;
-	position?: Position;
-}
-type InlineNode = TextNode | CodeSpanNode | HardBreakNode | SoftBreakNode | HtmlInlineNode | EmphasisNode | StrongNode | LinkNode | ImageNode;
-interface ThematicBreakNode {
-	type: "thematicBreak";
-	marker: "-" | "*" | "_";
-	position?: Position;
-}
-interface HeadingNode {
-	type: "heading";
-	level: 1 | 2 | 3 | 4 | 5 | 6;
-	children: InlineNode[];
-	style: "atx" | "setext";
-	position?: Position;
-}
-interface CodeBlockNode {
-	type: "codeBlock";
-	value: string;
-	style: "fenced" | "indented";
-	lang?: string;
-	meta?: string;
-	fence?: "`" | "~";
-	fenceLength?: number;
-	position?: Position;
-}
-interface HtmlBlockNode {
-	type: "htmlBlock";
-	value: string;
-	htmlType: number;
-	position?: Position;
-}
-interface ParagraphNode {
-	type: "paragraph";
-	children: InlineNode[];
-	position?: Position;
-}
-interface LinkReferenceDefinitionNode {
-	type: "linkReferenceDefinition";
-	label: string;
-	url: string;
-	title?: string;
-	position?: Position;
-}
-interface BlockquoteNode {
-	type: "blockquote";
-	children: BlockNode[];
-	position?: Position;
-}
-interface ListItemNode {
-	type: "listItem";
-	children: BlockNode[];
-	marker: "-" | "*" | "+" | ")" | ".";
-	spread: boolean;
-	checked?: boolean;
-	position?: Position;
-}
-interface ListNode {
-	type: "list";
-	ordered: boolean;
-	start?: number;
-	spread: boolean;
-	marker: "-" | "*" | "+" | ")" | ".";
-	children: ListItemNode[];
-	position?: Position;
-}
-interface TableCellNode {
-	type: "tableCell";
-	children: InlineNode[];
-	align?: "left" | "center" | "right";
-	isHeader: boolean;
-	position?: Position;
-}
-interface TableRowNode {
-	type: "tableRow";
-	children: TableCellNode[];
-	isHeader: boolean;
-	position?: Position;
-}
-interface TableNode {
-	type: "table";
-	children: TableRowNode[];
-	align: Array<"left" | "center" | "right" | null>;
-	position?: Position;
-}
-type BlockNode = ThematicBreakNode | HeadingNode | CodeBlockNode | HtmlBlockNode | ParagraphNode | LinkReferenceDefinitionNode | BlockquoteNode | ListItemNode | ListNode | TableNode;
-interface DocumentNode {
-	type: "document";
-	children: BlockNode[];
-	references?: Record<string, {
-		type: "linkReferenceDefinition";
-		label: string;
-		url: string;
-		title?: string;
-		position?: Position;
-	}>;
-	position?: Position;
-}
-interface MarkdownDocument {
-	root: DocumentNode;
-	lineEnding: "\n" | "\r\n";
-	source?: string;
-}
-declare const textNodeSchema: any;
-declare const codeSpanNodeSchema: any;
-declare const hardBreakNodeSchema: any;
-declare const softBreakNodeSchema: any;
-declare const htmlInlineNodeSchema: any;
-declare const emphasisNodeSchema: any;
-declare const strongNodeSchema: any;
-declare const linkNodeSchema: any;
-declare const imageNodeSchema: any;
-declare const inlineNodeSchema: any;
-declare const thematicBreakNodeSchema: any;
-declare const headingNodeSchema: any;
-declare const codeBlockNodeSchema: any;
-declare const htmlBlockNodeSchema: any;
-declare const paragraphNodeSchema: any;
-declare const linkReferenceDefinitionSchema: any;
-declare const blockquoteNodeSchema: any;
-declare const listItemNodeSchema: any;
-declare const listNodeSchema: any;
-declare const tableCellNodeSchema: any;
-declare const tableRowNodeSchema: any;
-declare const tableNodeSchema: any;
-declare const blockNodeSchema: any;
-declare const documentNodeSchema: any;
-declare const markdownDocumentSchema: any;
-/**
-* Parse options.
-*/
-declare const parseOptionsSchema: any;
-type ParseOptions = z.input<typeof parseOptionsSchema>;
-/**
-* Generate options.
-*/
-declare const generateOptionsSchema: any;
-type GenerateOptions = z.input<typeof generateOptionsSchema>;
-/**
-* Stream options.
-*/
-declare const streamOptionsSchema: any;
-type StreamOptions = z.input<typeof streamOptionsSchema>;
-interface BlockStreamEvent {
-	type: "block";
-	data: BlockNode;
-}
-interface CompleteStreamEvent {
-	type: "complete";
-	document: MarkdownDocument;
-}
-interface ErrorStreamEvent {
-	type: "error";
-	error: string;
-}
-type StreamEvent = BlockStreamEvent | CompleteStreamEvent | ErrorStreamEvent;
-interface BatchMarkdownFileInput {
-	filename: string;
-	content: string;
-}
-interface FileStartEvent {
-	type: "file_start";
-	fileIndex: number;
-	filename: string;
-}
-interface FileCompleteEvent {
-	type: "file_complete";
-	fileIndex: number;
-	filename: string;
-	document: MarkdownDocument;
-}
-interface FileErrorEvent {
-	type: "file_error";
-	fileIndex: number;
-	filename: string;
-	error: string;
-}
-interface BatchBlockEvent {
-	type: "block";
-	fileIndex: number;
-	data: BlockNode;
-}
-interface BatchCompleteEvent {
-	type: "batch_complete";
-	totalFiles: number;
-	errorCount: number;
-}
-type BatchMarkdownStreamEvent = FileStartEvent | FileCompleteEvent | FileErrorEvent | BatchBlockEvent | BatchCompleteEvent;
-interface BatchMarkdownFileResult {
-	filename: string;
-	document?: MarkdownDocument;
-	error?: string;
-}
-/** Alias for LinkReferenceDefinitionNode */
-type LinkReferenceDefinition = LinkReferenceDefinitionNode;
-/** Alias for BatchMarkdownFileResult */
-type BatchParsedMarkdownFile = BatchMarkdownFileResult;
-/** Union type for any node */
-type Node = InlineNode | BlockNode | DocumentNode;
-/** Nodes that contain a value property */
-type LiteralNode = TextNode | CodeSpanNode | HtmlInlineNode | CodeBlockNode | HtmlBlockNode;
-/** Nodes that contain children */
-type ParentNode = EmphasisNode | StrongNode | LinkNode | HeadingNode | ParagraphNode | BlockquoteNode | ListItemNode | ListNode | TableNode | TableRowNode | TableCellNode | DocumentNode;
-/**
-* Result type for parse operations that may fail.
-*/
-type ParseResult<T> = {
-	success: true;
-	data: T;
-} | {
-	success: false;
-	error: Error;
-};
-/**
-* Parses markdown content and returns a result object.
-*
-* @param content - The markdown string to parse
-* @param options - Parsing options
-* @returns A ParseResult containing either the parsed document or an error
-*
-* @example
-* ```typescript
-* const result = parse("# Hello World");
-* if (result.success) {
-*   console.log(result.data.root.children);
-* }
-* ```
-*/
-declare function parse(content: string, options?: ParseOptions): ParseResult<MarkdownDocument>;
-/**
-* Parses markdown content and throws on error.
-*
-* @param content - The markdown string to parse
-* @param options - Parsing options
-* @returns The parsed markdown document
-* @throws Error if parsing fails or options are invalid
-*
-* @example
-* ```typescript
-* const doc = parseOrThrow("# Hello World");
-* console.log(doc.root.children);
-* ```
-*/
-declare function parseOrThrow(content: string, options?: ParseOptions): MarkdownDocument;
-/**
-* Parses markdown from a buffer with automatic encoding detection.
-*
-* @param buffer - The buffer containing markdown data
-* @param options - Parsing options
-* @returns A ParseResult containing either the parsed document or an error
-*
-* @example
-* ```typescript
-* const buffer = new Uint8Array([...]);
-* const result = parseBuffer(buffer);
-* if (result.success) {
-*   console.log(result.data.root.children);
-* }
-* ```
-*/
-declare function parseBuffer(buffer: Uint8Array, options?: ParseOptions): ParseResult<MarkdownDocument>;
-/**
-* Parses markdown from a buffer with automatic encoding detection.
-* Throws on error.
-*
-* @param buffer - The buffer containing markdown data
-* @param options - Parsing options
-* @returns The parsed markdown document
-* @throws Error if parsing fails
-*
-* @example
-* ```typescript
-* const buffer = new Uint8Array([...]);
-* const doc = parseBufferOrThrow(buffer);
-* console.log(doc.root.children);
-* ```
-*/
-declare function parseBufferOrThrow(buffer: Uint8Array, options?: ParseOptions): MarkdownDocument;
-/**
-* Parses markdown and returns just the AST root node.
-*
-* @param content - The markdown string to parse
-* @param options - Parsing options
-* @returns The root document node
-*
-* @example
-* ```typescript
-* const root = parseToAst("# Hello");
-* console.log(root.type); // "document"
-* ```
-*/
-declare function parseToAst(content: string, options?: ParseOptions): MarkdownDocument["root"];
-/**
-* Checks if the given content is valid markdown (doesn't throw during parsing).
-*
-* @param content - The content to check
-* @returns True if the content can be parsed as markdown
-*
-* @example
-* ```typescript
-* isValidMarkdown("# Hello"); // true
-* isValidMarkdown("anything"); // true (markdown is very permissive)
-* ```
-*/
-declare function isValidMarkdown(content: string): boolean;
-/**
-* Generates markdown string from a document AST.
-*
-* @param document - The markdown document or root node to convert
-* @param options - Generation options
-* @returns The generated markdown string
-*
-* @example
-* ```typescript
-* const doc = parse("# Hello");
-* const markdown = generate(doc);
-* console.log(markdown); // "# Hello"
-* ```
-*/
-declare function generate(document: MarkdownDocument | DocumentNode, options?: GenerateOptions): string;
-/**
-* Generates markdown string from any AST node.
-*
-* @param node - The node to convert
-* @param options - Generation options
-* @returns The generated markdown string
-*
-* @example
-* ```typescript
-* const node: HeadingNode = { type: "heading", level: 1, children: [...], style: "atx" };
-* const markdown = generateNode(node);
-* ```
-*/
-declare function generateNode(node: Node, options?: GenerateOptions): string;
-/**
-* Creates an incremental markdown generator.
-*
-* @param options - Generation options
-* @returns A generator object with methods to add nodes
-*
-* @example
-* ```typescript
-* const gen = createGenerator();
-* gen.addNode({ type: "heading", level: 1, children: [...], style: "atx" });
-* gen.addNode({ type: "paragraph", children: [...] });
-* console.log(gen.toString());
-* ```
-*/
-declare function createGenerator(options?: GenerateOptions): {
-	addNode: (node: Node) => void;
-	toString: () => string;
-	toStream: () => ReadableStream<string>;
-};
-/**
-* Generates a heading string.
-*
-* @param level - Heading level (1-6)
-* @param text - Heading text
-* @param style - Heading style (atx or setext)
-* @returns The generated heading
-*
-* @example
-* ```typescript
-* generateHeadingString(1, "Hello"); // "# Hello"
-* generateHeadingString(2, "World", "setext"); // "World\n------"
-* ```
-*/
-declare function generateHeadingString(level: 1 | 2 | 3 | 4 | 5 | 6, text: string, style?: "atx" | "setext"): string;
-/**
-* Generates a link string.
-*
-* @param text - Link text
-* @param url - Link URL
-* @param title - Optional link title
-* @returns The generated link
-*
-* @example
-* ```typescript
-* generateLinkString("Example", "https://example.com"); // "[Example](https://example.com)"
-* ```
-*/
-declare function generateLinkString(text: string, url: string, title?: string): string;
-/**
-* Generates an image string.
-*
-* @param alt - Alt text
-* @param url - Image URL
-* @param title - Optional image title
-* @returns The generated image
-*
-* @example
-* ```typescript
-* generateImageString("Logo", "logo.png"); // "![Logo](logo.png)"
-* ```
-*/
-declare function generateImageString(alt: string, url: string, title?: string): string;
-/**
-* Generates a code block string.
-*
-* @param code - The code content
-* @param lang - Optional language identifier
-* @param style - Code block style (fenced or indented)
-* @returns The generated code block
-*
-* @example
-* ```typescript
-* generateCodeBlockString("console.log('hi');", "js");
-* // "```js\nconsole.log('hi');\n```"
-* ```
-*/
-declare function generateCodeBlockString(code: string, lang?: string, style?: "fenced" | "indented"): string;
-/**
-* Generates a list string from items.
-*
-* @param items - List items (strings or nested lists)
-* @param ordered - Whether the list is ordered
-* @param start - Starting number for ordered lists
-* @returns The generated list
-*
-* @example
-* ```typescript
-* generateListString(["First", "Second"]); // "- First\n- Second"
-* generateListString(["First", "Second"], true); // "1. First\n2. Second"
-* ```
-*/
-declare function generateListString(items: string[], ordered?: boolean, start?: number): string;
-/**
-* Generates a blockquote string.
-*
-* @param content - The content to quote
-* @returns The generated blockquote
-*
-* @example
-* ```typescript
-* generateBlockquoteString("Hello world"); // "> Hello world"
-* ```
-*/
-declare function generateBlockquoteString(content: string): string;
-/**
-* Wraps text with emphasis markers.
-*
-* @param text - The text to emphasize
-* @param marker - The emphasis marker (* or _)
-* @returns The emphasized text
-*
-* @example
-* ```typescript
-* generateEmphasisString("hello"); // "*hello*"
-* ```
-*/
-declare function generateEmphasisString(text: string, marker?: "*" | "_"): string;
-/**
-* Wraps text with strong emphasis markers.
-*
-* @param text - The text to emphasize
-* @param marker - The strong marker (** or __)
-* @returns The strongly emphasized text
-*
-* @example
-* ```typescript
-* generateStrongString("hello"); // "**hello**"
-* ```
-*/
-declare function generateStrongString(text: string, marker?: "**" | "__"): string;
-/**
-* Wraps text in inline code.
-*
-* @param text - The text to wrap
-* @returns The inline code
-*
-* @example
-* ```typescript
-* generateInlineCodeString("foo"); // "`foo`"
-* ```
-*/
-declare function generateInlineCodeString(text: string): string;
-/**
-* Generates a GFM table string from headers, rows, and optional alignment.
-*
-* @param headers - Array of column header strings
-* @param rows - 2D array of cell values
-* @param alignments - Optional array of alignment values ('left' | 'center' | 'right')
-* @returns The generated table markdown
-*
-* @example
-* ```typescript
-* generateTableString(
-*   ["Name", "Age"],
-*   [["Alice", "30"], ["Bob", "25"]]
-* );
-* // "| Name | Age |\n| --- | --- |\n| Alice | 30 |\n| Bob | 25 |"
-* ```
-*/
-declare function generateTableString(headers: string[], rows: string[][], alignments?: ("left" | "center" | "right" | null)[]): string;
-/**
-* Generates a task list (checklist) string.
-*
-* @param items - Array of items with text and optional checked state
-* @returns The generated task list markdown
-*
-* @example
-* ```typescript
-* generateTaskListString([
-*   { text: "Buy groceries", checked: true },
-*   { text: "Walk the dog", checked: false },
-* ]);
-* // "- [x] Buy groceries\n- [ ] Walk the dog"
-* ```
-*/
-declare function generateTaskListString(items: Array<{
-	text: string;
-	checked?: boolean;
-}>): string;
-/**
-* Wraps text with strikethrough markers (GFM extension).
-*
-* @param text - The text to strike through
-* @returns The strikethrough text
-*
-* @example
-* ```typescript
-* generateStrikethroughString("deleted"); // "~~deleted~~"
-* ```
-*/
-declare function generateStrikethroughString(text: string): string;
-/**
-* Options for HTML rendering.
-*/
-interface HtmlRenderOptions {
-	/** Whether to sanitize raw HTML blocks/inline (default: true) */
-	sanitizeHtml?: boolean;
-	/** Whether to add target="_blank" to external links (default: false) */
-	externalLinksNewTab?: boolean;
-	/** Custom class prefix for elements (default: none) */
-	classPrefix?: string;
-	/** Whether to render soft breaks as <br> (default: false) */
-	softBreakAsBr?: boolean;
-	/** Custom URL transformer for links and images */
-	transformUrl?: (url: string, type: "link" | "image") => string;
-	/** Custom attributes to add to specific elements */
-	elementAttributes?: {
-		link?: Record<string, string>;
-		image?: Record<string, string>;
-		codeBlock?: Record<string, string>;
-		heading?: Record<string, string>;
-	};
-}
-/**
-* Renders a markdown document to HTML string.
-*
-* @param document - The markdown document or root node
-* @param options - Rendering options
-* @returns The generated HTML string
-*
-* @example
-* ```typescript
-* const doc = parse("# Hello **World**");
-* const html = renderToHtml(doc);
-* // => "<h1>Hello <strong>World</strong></h1>"
-* ```
-*/
-declare function renderToHtml(document: MarkdownDocument | DocumentNode, options?: HtmlRenderOptions): string;
-/**
-* Renders any AST node to HTML string.
-*
-* @param node - The node to render
-* @param options - Rendering options
-* @returns The generated HTML string
-*/
-declare function renderNodeToHtml(node: Node, options?: HtmlRenderOptions): string;
-/**
-* Options for HTML to Markdown conversion
-*/
-interface HtmlToMarkdownOptions {
-	/** Keep original whitespace (default: false) */
-	preserveWhitespace?: boolean;
-	/** Heading style: "atx" (#) or "setext" (===) (default: "atx") */
-	headingStyle?: "atx" | "setext";
-	/** Unordered list marker (default: "-") */
-	bulletMarker?: "-" | "*" | "+";
-	/** Code block style (default: "fenced") */
-	codeBlockStyle?: "fenced" | "indented";
-	/** Fence character (default: "`") */
-	fence?: "`" | "~";
-	/** Strong marker (default: "**") */
-	strongMarker?: "**" | "__";
-	/** Emphasis marker (default: "*") */
-	emphasisMarker?: "*" | "_";
-	/** Link style (default: "inline") */
-	linkStyle?: "inline" | "reference";
-}
-/** Intermediate HTML node representation */
-interface HtmlNode {
-	type: "element" | "text" | "comment";
-	tag?: string;
-	attributes?: Record<string, string>;
-	children?: HtmlNode[];
-	content?: string;
-}
-/**
-* Parse HTML string into an intermediate AST
-*/
-declare function parseHtml(html: string): HtmlNode[];
-/**
-* Convert HTML AST to Markdown AST
-*/
-declare function htmlAstToMarkdownAst(nodes: HtmlNode[], options?: HtmlToMarkdownOptions): DocumentNode;
-/**
-* Convert HTML string to Markdown string
-*
-* @param html - The HTML content to convert
-* @param options - Conversion options
-* @returns Markdown string
-*
-* @example
-* ```typescript
-* const html = '<h1>Hello</h1><p>This is <strong>bold</strong> text.</p>';
-* const markdown = htmlToMarkdown(html);
-* // Result: "# Hello\n\nThis is **bold** text."
-* ```
-*/
-declare function htmlToMarkdown(html: string, options?: HtmlToMarkdownOptions): string;
-/**
-* Parses markdown content from a stream, yielding events for each block.
-*
-* @param input - A ReadableStream of Uint8Array or AsyncIterable of strings
-* @param options - Parsing options
-* @yields StreamEvent for each block and completion
-*
-* @example
-* ```typescript
-* const response = await fetch("doc.md");
-* for await (const event of parseStream(response.body)) {
-*   if (event.type === "block") {
-*     console.log(event.data.type);
-*   }
-* }
-* ```
-*/
-declare function parseStream(input: ReadableStream<Uint8Array> | AsyncIterable<string>, options?: StreamOptions): AsyncGenerator<StreamEvent>;
-/**
-* Parses markdown content from a stream and collects all blocks into a document.
-*
-* @param input - A ReadableStream of Uint8Array or AsyncIterable of strings
-* @param options - Parsing options
-* @returns A promise that resolves to the complete MarkdownDocument
-*
-* @example
-* ```typescript
-* const response = await fetch("doc.md");
-* const doc = await parseStreamToDocument(response.body);
-* console.log(doc.root.children.length);
-* ```
-*/
-declare function parseStreamToDocument(input: ReadableStream<Uint8Array> | AsyncIterable<string>, options?: StreamOptions): Promise<MarkdownDocument>;
-/**
-* Creates a streaming parser from a buffer.
-* Useful when you have a buffer but want to use the streaming API.
-*
-* @param buffer - The buffer containing markdown data
-* @param options - Parsing options
-* @yields StreamEvent for each block and completion
-*/
-declare function parseBufferStream(buffer: Uint8Array, options?: StreamOptions): AsyncGenerator<StreamEvent>;
-/**
-* Streaming batch parser - processes files sequentially, yielding events.
-*
-* @param files - Array of files with filename and content
-* @param options - Stream options
-* @yields BatchMarkdownStreamEvent for each file start, block, completion, or error
-*
-* @example
-* ```typescript
-* const files = [
-*   { filename: "readme.md", content: "# Hello" },
-*   { filename: "docs.md", content: "## World" }
-* ];
-* for await (const event of parseBatchStream(files)) {
-*   console.log(event.type, event.filename);
-* }
-* ```
-*/
-declare function parseBatchStream(files: BatchMarkdownFileInput[], options?: StreamOptions): AsyncGenerator<BatchMarkdownStreamEvent>;
-/**
-* Convenience function that collects streaming batch results into arrays.
-*
-* @param files - Array of files with filename and content
-* @param options - Stream options
-* @returns Array of parsed file results
-*/
-declare function parseBatchStreamToArray(files: BatchMarkdownFileInput[], options?: StreamOptions): Promise<BatchParsedMarkdownFile[]>;
-/**
-* Normalizes line endings to LF.
-*
-* @param content - The content to normalize
-* @returns The content with normalized line endings
-*/
-declare function normalizeLineEndings(content: string): string;
-/**
-* Normalizes escaped newline sequences to actual newlines.
-* Handles AI-generated content that may contain literal \n strings
-* instead of actual newline characters.
-*
-* @param content - The content to normalize
-* @returns The content with escaped newlines converted to actual newlines
-*/
-declare function normalizeEscapedNewlines(content: string): string;
-/**
-* Normalizes markdown by unescaping incorrectly escaped emphasis markers.
-* LLMs sometimes escape ** or * markers that shouldn't be escaped.
-*
-* @param text - The markdown text to normalize
-* @returns The normalized text with unescaped emphasis markers
-*
-* @example
-* ```typescript
-* normalizeMarkdownEmphasis("\\*\\*bold\\*\\*"); // "**bold**"
-* normalizeMarkdownEmphasis("\\*italic\\*");     // "*italic*"
-* ```
-*/
-declare function normalizeMarkdownEmphasis(text: string): string;
-export { thematicBreakNodeSchema, textNodeSchema, tableRowNodeSchema, tableNodeSchema, tableCellNodeSchema, strongNodeSchema, streamOptionsSchema, softBreakNodeSchema, renderToHtml, renderNodeToHtml, positionSchema, parseToAst, parseStreamToDocument, parseStream, parseOrThrow, parseOptionsSchema, parseHtml, parseBufferStream, parseBufferOrThrow, parseBuffer, parseBatchStreamToArray, parseBatchStream, parse, paragraphNodeSchema, normalizeMarkdownEmphasis, normalizeLineEndings, normalizeEscapedNewlines, markdownDocumentSchema, listNodeSchema, listItemNodeSchema, linkReferenceDefinitionSchema, linkNodeSchema, isValidMarkdown, inlineNodeSchema, imageNodeSchema, htmlToMarkdown, htmlInlineNodeSchema, htmlBlockNodeSchema, htmlAstToMarkdownAst, headingNodeSchema, hardBreakNodeSchema, generateTaskListString, generateTableString, generateStrongString, generateStrikethroughString, generateOptionsSchema, generateNode, generateListString, generateLinkString, generateInlineCodeString, generateImageString, generateHeadingString, generateEmphasisString, generateCodeBlockString, generateBlockquoteString, generate, emphasisNodeSchema, documentNodeSchema, createGenerator, codeSpanNodeSchema, codeBlockNodeSchema, blockquoteNodeSchema, blockNodeSchema, ThematicBreakNode, TextNode, TableRowNode, TableNode, TableCellNode, StrongNode, StreamOptions, StreamEvent, SoftBreakNode, Position, ParseResult, ParseOptions, ParentNode, ParagraphNode, Node, MarkdownDocument, LiteralNode, ListNode, ListItemNode, LinkReferenceDefinition, LinkNode, InlineNode, ImageNode, HtmlToMarkdownOptions, HtmlRenderOptions, HtmlInlineNode, HtmlBlockNode, HeadingNode, HardBreakNode, GenerateOptions, EmphasisNode, DocumentNode, DEFAULT_MAX_BUFFER_SIZE, CodeSpanNode, CodeBlockNode, BlockquoteNode, BlockNode, BatchParsedMarkdownFile, BatchMarkdownStreamEvent, BatchMarkdownFileInput };
+export { isValidMarkdown, parse, parseBuffer, parseBufferOrThrow, parseOrThrow, parseToAst, } from "./parser";
+export { createGenerator, generate, generateBlockquoteString, generateCodeBlockString, generateEmphasisString, generateHeadingString, generateImageString, generateInlineCodeString, generateLinkString, generateListString, generateNode, generateStrikethroughString, generateStrongString, generateTableString, generateTaskListString, } from "./generator";
+export type { HtmlRenderOptions } from "./html-renderer";
+export { renderNodeToHtml, renderToHtml } from "./html-renderer";
+export type { HtmlToMarkdownOptions } from "./html-parser";
+export { htmlAstToMarkdownAst, htmlToMarkdown, parseHtml, } from "./html-parser";
+export { parseBatchStream, parseBatchStreamToArray, parseBufferStream, parseStream, parseStreamToDocument, } from "./stream";
+export { blockNodeSchema, blockquoteNodeSchema, codeBlockNodeSchema, codeSpanNodeSchema, DEFAULT_MAX_BUFFER_SIZE, documentNodeSchema, emphasisNodeSchema, generateOptionsSchema, hardBreakNodeSchema, headingNodeSchema, htmlBlockNodeSchema, htmlInlineNodeSchema, imageNodeSchema, inlineNodeSchema, linkNodeSchema, linkReferenceDefinitionSchema, listItemNodeSchema, listNodeSchema, markdownDocumentSchema, paragraphNodeSchema, parseOptionsSchema, positionSchema, softBreakNodeSchema, streamOptionsSchema, strongNodeSchema, tableCellNodeSchema, tableNodeSchema, tableRowNodeSchema, textNodeSchema, thematicBreakNodeSchema, } from "./schemas";
+export type { BatchMarkdownFileInput, BatchMarkdownStreamEvent, BatchParsedMarkdownFile, BlockNode, BlockquoteNode, CodeBlockNode, CodeSpanNode, DocumentNode, EmphasisNode, GenerateOptions, HardBreakNode, HeadingNode, HtmlBlockNode, HtmlInlineNode, ImageNode, InlineNode, LinkNode, LinkReferenceDefinition, ListItemNode, ListNode, LiteralNode, MarkdownDocument, Node, ParagraphNode, ParentNode, ParseOptions, Position, SoftBreakNode, StreamEvent, StreamOptions, StrongNode, TableCellNode, TableNode, TableRowNode, TextNode, ThematicBreakNode, } from "./schemas";
+export type { ParseResult } from "./types";
+export { normalizeEscapedNewlines, normalizeLineEndings, normalizeMarkdownEmphasis, } from "./utils";
+//# sourceMappingURL=index.d.ts.map