// Generated by dts-bundle-generator v9.5.1

type MarkedToken = (Tokens.Blockquote | Tokens.Br | Tokens.Checkbox | Tokens.Code | Tokens.Codespan | Tokens.Def | Tokens.Del | Tokens.Em | Tokens.Escape | Tokens.Heading | Tokens.Hr | Tokens.HTML | Tokens.Image | Tokens.Link | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.Space | Tokens.Strong | Tokens.Table | Tokens.Tag | Tokens.Text);
type Token = (MarkedToken | Tokens.Generic);
declare namespace Tokens {
	interface Blockquote {
		type: "blockquote";
		raw: string;
		text: string;
		tokens: Token[];
	}
	interface Br {
		type: "br";
		raw: string;
	}
	interface Checkbox {
		type: "checkbox";
		raw: string;
		checked: boolean;
	}
	interface Code {
		type: "code";
		raw: string;
		codeBlockStyle?: "indented";
		lang?: string;
		text: string;
		escaped?: boolean;
	}
	interface Codespan {
		type: "codespan";
		raw: string;
		text: string;
	}
	interface Def {
		type: "def";
		raw: string;
		tag: string;
		href: string;
		title: string;
	}
	interface Del {
		type: "del";
		raw: string;
		text: string;
		tokens: Token[];
	}
	interface Em {
		type: "em";
		raw: string;
		text: string;
		tokens: Token[];
	}
	interface Escape {
		type: "escape";
		raw: string;
		text: string;
	}
	interface Generic {
		[index: string]: any;
		type: string;
		raw: string;
		tokens?: Token[];
	}
	interface Heading {
		type: "heading";
		raw: string;
		depth: number;
		text: string;
		tokens: Token[];
	}
	interface Hr {
		type: "hr";
		raw: string;
	}
	interface HTML {
		type: "html";
		raw: string;
		pre: boolean;
		text: string;
		block: boolean;
	}
	interface Image {
		type: "image";
		raw: string;
		href: string;
		title: string | null;
		text: string;
		tokens: Token[];
	}
	interface Link {
		type: "link";
		raw: string;
		href: string;
		title?: string | null;
		text: string;
		tokens: Token[];
	}
	interface List {
		type: "list";
		raw: string;
		ordered: boolean;
		start: number | "";
		loose: boolean;
		items: ListItem[];
	}
	interface ListItem {
		type: "list_item";
		raw: string;
		task: boolean;
		checked?: boolean;
		loose: boolean;
		text: string;
		tokens: Token[];
	}
	interface Paragraph {
		type: "paragraph";
		raw: string;
		pre?: boolean;
		text: string;
		tokens: Token[];
	}
	interface Space {
		type: "space";
		raw: string;
	}
	interface Strong {
		type: "strong";
		raw: string;
		text: string;
		tokens: Token[];
	}
	interface Table {
		type: "table";
		raw: string;
		align: Array<"center" | "left" | "right" | null>;
		header: TableCell[];
		rows: TableCell[][];
	}
	interface TableCell {
		text: string;
		tokens: Token[];
		header: boolean;
		align: "center" | "left" | "right" | null;
	}
	interface TableRow<P = string> {
		text: P;
	}
	interface Tag {
		type: "html";
		raw: string;
		inLink: boolean;
		inRawBlock: boolean;
		text: string;
		block: boolean;
	}
	interface Text {
		type: "text";
		raw: string;
		text: string;
		tokens?: Token[];
		escaped?: boolean;
	}
}
type Links = Record<string, Pick<Tokens.Link | Tokens.Image, "href" | "title">>;
type TokensList = Token[] & {
	links: Links;
};
/**
 * Renderer
 */
declare class _Renderer<ParserOutput = string, RendererOutput = string> {
	options: MarkedOptions<ParserOutput, RendererOutput>;
	parser: _Parser<ParserOutput, RendererOutput>;
	constructor(options?: MarkedOptions<ParserOutput, RendererOutput>);
	space(token: Tokens.Space): RendererOutput;
	code({ text, lang, escaped }: Tokens.Code): RendererOutput;
	blockquote({ tokens }: Tokens.Blockquote): RendererOutput;
	html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput;
	def(token: Tokens.Def): RendererOutput;
	heading({ tokens, depth }: Tokens.Heading): RendererOutput;
	hr(token: Tokens.Hr): RendererOutput;
	list(token: Tokens.List): RendererOutput;
	listitem(item: Tokens.ListItem): RendererOutput;
	checkbox({ checked }: Tokens.Checkbox): RendererOutput;
	paragraph({ tokens }: Tokens.Paragraph): RendererOutput;
	table(token: Tokens.Table): RendererOutput;
	tablerow({ text }: Tokens.TableRow<ParserOutput>): RendererOutput;
	tablecell(token: Tokens.TableCell): RendererOutput;
	/**
	 * span level renderer
	 */
	strong({ tokens }: Tokens.Strong): RendererOutput;
	em({ tokens }: Tokens.Em): RendererOutput;
	codespan({ text }: Tokens.Codespan): RendererOutput;
	br(token: Tokens.Br): RendererOutput;
	del({ tokens }: Tokens.Del): RendererOutput;
	link({ href, title, tokens }: Tokens.Link): RendererOutput;
	image({ href, title, text, tokens }: Tokens.Image): RendererOutput;
	text(token: Tokens.Text | Tokens.Escape): RendererOutput;
}
/**
 * TextRenderer
 * returns only the textual part of the token
 */
declare class _TextRenderer<RendererOutput = string> {
	strong({ text }: Tokens.Strong): RendererOutput;
	em({ text }: Tokens.Em): RendererOutput;
	codespan({ text }: Tokens.Codespan): RendererOutput;
	del({ text }: Tokens.Del): RendererOutput;
	html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput;
	text({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag): RendererOutput;
	link({ text }: Tokens.Link): RendererOutput;
	image({ text }: Tokens.Image): RendererOutput;
	br(): RendererOutput;
	checkbox({ raw }: Tokens.Checkbox): RendererOutput;
}
/**
 * Parsing & Compiling
 */
declare class _Parser<ParserOutput = string, RendererOutput = string> {
	options: MarkedOptions<ParserOutput, RendererOutput>;
	renderer: _Renderer<ParserOutput, RendererOutput>;
	textRenderer: _TextRenderer<RendererOutput>;
	constructor(options?: MarkedOptions<ParserOutput, RendererOutput>);
	/**
	 * Static Parse Method
	 */
	static parse<ParserOutput = string, RendererOutput = string>(tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput>): ParserOutput;
	/**
	 * Static Parse Inline Method
	 */
	static parseInline<ParserOutput = string, RendererOutput = string>(tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput>): ParserOutput;
	/**
	 * Parse Loop
	 */
	parse(tokens: Token[]): ParserOutput;
	/**
	 * Parse Inline Tokens
	 */
	parseInline(tokens: Token[], renderer?: _Renderer<ParserOutput, RendererOutput> | _TextRenderer<RendererOutput>): ParserOutput;
}
declare const other: {
	codeRemoveIndent: RegExp;
	outputLinkReplace: RegExp;
	indentCodeCompensation: RegExp;
	beginningSpace: RegExp;
	endingHash: RegExp;
	startingSpaceChar: RegExp;
	endingSpaceChar: RegExp;
	nonSpaceChar: RegExp;
	newLineCharGlobal: RegExp;
	tabCharGlobal: RegExp;
	multipleSpaceGlobal: RegExp;
	blankLine: RegExp;
	doubleBlankLine: RegExp;
	blockquoteStart: RegExp;
	blockquoteSetextReplace: RegExp;
	blockquoteSetextReplace2: RegExp;
	listReplaceNesting: RegExp;
	listIsTask: RegExp;
	listReplaceTask: RegExp;
	listTaskCheckbox: RegExp;
	anyLine: RegExp;
	hrefBrackets: RegExp;
	tableDelimiter: RegExp;
	tableAlignChars: RegExp;
	tableRowBlankLine: RegExp;
	tableAlignRight: RegExp;
	tableAlignCenter: RegExp;
	tableAlignLeft: RegExp;
	startATag: RegExp;
	endATag: RegExp;
	startPreScriptTag: RegExp;
	endPreScriptTag: RegExp;
	startAngleBracket: RegExp;
	endAngleBracket: RegExp;
	pedanticHrefTitle: RegExp;
	unicodeAlphaNumeric: RegExp;
	escapeTest: RegExp;
	escapeReplace: RegExp;
	escapeTestNoEncode: RegExp;
	escapeReplaceNoEncode: RegExp;
	caret: RegExp;
	percentDecode: RegExp;
	findPipe: RegExp;
	splitPipe: RegExp;
	slashPipe: RegExp;
	carriageReturn: RegExp;
	spaceLine: RegExp;
	notSpaceStart: RegExp;
	endingNewline: RegExp;
	listItemRegex: (bull: string) => RegExp;
	nextBulletRegex: (indent: number) => RegExp;
	hrRegex: (indent: number) => RegExp;
	fencesBeginRegex: (indent: number) => RegExp;
	headingBeginRegex: (indent: number) => RegExp;
	htmlBeginRegex: (indent: number) => RegExp;
	blockquoteBeginRegex: (indent: number) => RegExp;
};
declare const blockNormal: {
	blockquote: RegExp;
	code: RegExp;
	def: RegExp;
	fences: RegExp;
	heading: RegExp;
	hr: RegExp;
	html: RegExp;
	lheading: RegExp;
	list: RegExp;
	newline: RegExp;
	paragraph: RegExp;
	table: RegExp;
	text: RegExp;
};
type BlockKeys = keyof typeof blockNormal;
declare const inlineNormal: {
	_backpedal: RegExp;
	anyPunctuation: RegExp;
	autolink: RegExp;
	blockSkip: RegExp;
	br: RegExp;
	code: RegExp;
	del: RegExp;
	delLDelim: RegExp;
	delRDelim: RegExp;
	emStrongLDelim: RegExp;
	emStrongRDelimAst: RegExp;
	emStrongRDelimUnd: RegExp;
	escape: RegExp;
	link: RegExp;
	nolink: RegExp;
	punctuation: RegExp;
	reflink: RegExp;
	reflinkSearch: RegExp;
	tag: RegExp;
	text: RegExp;
	url: RegExp;
};
type InlineKeys = keyof typeof inlineNormal;
interface Rules {
	other: typeof other;
	block: Record<BlockKeys, RegExp>;
	inline: Record<InlineKeys, RegExp>;
}
/**
 * Tokenizer
 */
declare class _Tokenizer<ParserOutput = string, RendererOutput = string> {
	options: MarkedOptions<ParserOutput, RendererOutput>;
	rules: Rules;
	lexer: _Lexer<ParserOutput, RendererOutput>;
	constructor(options?: MarkedOptions<ParserOutput, RendererOutput>);
	space(src: string): Tokens.Space | undefined;
	code(src: string): Tokens.Code | undefined;
	fences(src: string): Tokens.Code | undefined;
	heading(src: string): Tokens.Heading | undefined;
	hr(src: string): Tokens.Hr | undefined;
	blockquote(src: string): Tokens.Blockquote | undefined;
	list(src: string): Tokens.List | undefined;
	html(src: string): Tokens.HTML | undefined;
	def(src: string): Tokens.Def | undefined;
	table(src: string): Tokens.Table | undefined;
	lheading(src: string): Tokens.Heading | undefined;
	paragraph(src: string): Tokens.Paragraph | undefined;
	text(src: string): Tokens.Text | undefined;
	escape(src: string): Tokens.Escape | undefined;
	tag(src: string): Tokens.Tag | undefined;
	link(src: string): Tokens.Link | Tokens.Image | undefined;
	reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined;
	emStrong(src: string, maskedSrc: string, prevChar?: string): Tokens.Em | Tokens.Strong | undefined;
	codespan(src: string): Tokens.Codespan | undefined;
	br(src: string): Tokens.Br | undefined;
	del(src: string, maskedSrc: string, prevChar?: string): Tokens.Del | undefined;
	autolink(src: string): Tokens.Link | undefined;
	url(src: string): Tokens.Link | undefined;
	inlineText(src: string): Tokens.Text | undefined;
}
declare class _Hooks<ParserOutput = string, RendererOutput = string> {
	options: MarkedOptions<ParserOutput, RendererOutput>;
	block?: boolean;
	constructor(options?: MarkedOptions<ParserOutput, RendererOutput>);
	static passThroughHooks: Set<string>;
	static passThroughHooksRespectAsync: Set<string>;
	/**
	 * Process markdown before marked
	 */
	preprocess(markdown: string): string;
	/**
	 * Process HTML after marked is finished
	 */
	postprocess(html: ParserOutput): ParserOutput;
	/**
	 * Process all tokens before walk tokens
	 */
	processAllTokens(tokens: Token[] | TokensList): Token[] | TokensList;
	/**
	 * Mask contents that should not be interpreted as em/strong delimiters
	 */
	emStrongMask(src: string): string;
	/**
	 * Provide function to tokenize markdown
	 */
	provideLexer(block?: boolean | undefined): typeof _Lexer.lexInline;
	/**
	 * Provide function to parse tokens
	 */
	provideParser(block?: boolean | undefined): (tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput> | undefined) => ParserOutput;
}
interface TokenizerThis {
	lexer: _Lexer;
}
type TokenizerExtensionFunction = (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | undefined;
type TokenizerStartFunction = (this: TokenizerThis, src: string) => number | void;
interface TokenizerExtension {
	name: string;
	level: "block" | "inline";
	start?: TokenizerStartFunction;
	tokenizer: TokenizerExtensionFunction;
	childTokens?: string[];
}
interface RendererThis<ParserOutput = string, RendererOutput = string> {
	parser: _Parser<ParserOutput, RendererOutput>;
}
type RendererExtensionFunction<ParserOutput = string, RendererOutput = string> = (this: RendererThis<ParserOutput, RendererOutput>, token: Tokens.Generic) => RendererOutput | false | undefined;
interface RendererExtension<ParserOutput = string, RendererOutput = string> {
	name: string;
	renderer: RendererExtensionFunction<ParserOutput, RendererOutput>;
}
type TokenizerAndRendererExtension<ParserOutput = string, RendererOutput = string> = TokenizerExtension | RendererExtension<ParserOutput, RendererOutput> | (TokenizerExtension & RendererExtension<ParserOutput, RendererOutput>);
type HooksApi<ParserOutput = string, RendererOutput = string> = Omit<_Hooks<ParserOutput, RendererOutput>, "constructor" | "options" | "block">;
type HooksObject<ParserOutput = string, RendererOutput = string> = {
	[K in keyof HooksApi<ParserOutput, RendererOutput>]?: (this: _Hooks<ParserOutput, RendererOutput>, ...args: Parameters<HooksApi<ParserOutput, RendererOutput>[K]>) => ReturnType<HooksApi<ParserOutput, RendererOutput>[K]> | Promise<ReturnType<HooksApi<ParserOutput, RendererOutput>[K]>>;
};
type RendererApi<ParserOutput = string, RendererOutput = string> = Omit<_Renderer<ParserOutput, RendererOutput>, "constructor" | "options" | "parser">;
type RendererObject<ParserOutput = string, RendererOutput = string> = {
	[K in keyof RendererApi<ParserOutput, RendererOutput>]?: (this: _Renderer<ParserOutput, RendererOutput>, ...args: Parameters<RendererApi<ParserOutput, RendererOutput>[K]>) => ReturnType<RendererApi<ParserOutput, RendererOutput>[K]> | false;
};
type TokenizerApi<ParserOutput = string, RendererOutput = string> = Omit<_Tokenizer<ParserOutput, RendererOutput>, "constructor" | "options" | "rules" | "lexer">;
type TokenizerObject<ParserOutput = string, RendererOutput = string> = {
	[K in keyof TokenizerApi<ParserOutput, RendererOutput>]?: (this: _Tokenizer<ParserOutput, RendererOutput>, ...args: Parameters<TokenizerApi<ParserOutput, RendererOutput>[K]>) => ReturnType<TokenizerApi<ParserOutput, RendererOutput>[K]> | false;
};
interface MarkedExtension<ParserOutput = string, RendererOutput = string> {
	/**
	 * True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string.
	 */
	async?: boolean;
	/**
	 * Enable GFM line breaks. This option requires the gfm option to be true.
	 */
	breaks?: boolean;
	/**
	 * Add tokenizers and renderers to marked
	 */
	extensions?: TokenizerAndRendererExtension<ParserOutput, RendererOutput>[] | null;
	/**
	 * Enable GitHub flavored markdown.
	 */
	gfm?: boolean;
	/**
	 * Hooks are methods that hook into some part of marked.
	 * preprocess is called to process markdown before sending it to marked.
	 * processAllTokens is called with the TokensList before walkTokens.
	 * postprocess is called to process html after marked has finished parsing.
	 * emStrongMask is called to mask contents that should not be interpreted as em/strong delimiters.
	 * provideLexer is called to provide a function to tokenize markdown.
	 * provideParser is called to provide a function to parse tokens.
	 */
	hooks?: HooksObject<ParserOutput, RendererOutput> | null;
	/**
	 * Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.
	 */
	pedantic?: boolean;
	/**
	 * Type: object Default: new Renderer()
	 *
	 * An object containing functions to render tokens to HTML.
	 */
	renderer?: RendererObject<ParserOutput, RendererOutput> | null;
	/**
	 * Shows an HTML error message when rendering fails.
	 */
	silent?: boolean;
	/**
	 * The tokenizer defines how to turn markdown text into tokens.
	 */
	tokenizer?: TokenizerObject | null;
	/**
	 * The walkTokens function gets called with every token.
	 * Child tokens are called before moving on to sibling tokens.
	 * Each token is passed by reference so updates are persisted when passed to the parser.
	 * The return value of the function is ignored.
	 */
	walkTokens?: ((token: Token) => void | Promise<void>) | null;
}
interface MarkedOptions<ParserOutput = string, RendererOutput = string> extends Omit<MarkedExtension<ParserOutput, RendererOutput>, "hooks" | "renderer" | "tokenizer" | "extensions" | "walkTokens"> {
	/**
	 * Hooks are methods that hook into some part of marked.
	 */
	hooks?: _Hooks<ParserOutput, RendererOutput> | null;
	/**
	 * Type: object Default: new Renderer()
	 *
	 * An object containing functions to render tokens to HTML.
	 */
	renderer?: _Renderer<ParserOutput, RendererOutput> | null;
	/**
	 * The tokenizer defines how to turn markdown text into tokens.
	 */
	tokenizer?: _Tokenizer<ParserOutput, RendererOutput> | null;
	/**
	 * Custom extensions
	 */
	extensions?: null | {
		renderers: {
			[name: string]: RendererExtensionFunction<ParserOutput, RendererOutput>;
		};
		childTokens: {
			[name: string]: string[];
		};
		inline?: TokenizerExtensionFunction[];
		block?: TokenizerExtensionFunction[];
		startInline?: TokenizerStartFunction[];
		startBlock?: TokenizerStartFunction[];
	};
	/**
	 * walkTokens function returns array of values for Promise.all
	 */
	walkTokens?: null | ((token: Token) => void | Promise<void> | (void | Promise<void>)[]);
}
/**
 * Block Lexer
 */
declare class _Lexer<ParserOutput = string, RendererOutput = string> {
	tokens: TokensList;
	options: MarkedOptions<ParserOutput, RendererOutput>;
	state: {
		inLink: boolean;
		inRawBlock: boolean;
		top: boolean;
	};
	inlineQueue: {
		src: string;
		tokens: Token[];
	}[];
	private tokenizer;
	constructor(options?: MarkedOptions<ParserOutput, RendererOutput>);
	/**
	 * Expose Rules
	 */
	static get rules(): {
		block: {
			normal: {
				blockquote: RegExp;
				code: RegExp;
				def: RegExp;
				fences: RegExp;
				heading: RegExp;
				hr: RegExp;
				html: RegExp;
				lheading: RegExp;
				list: RegExp;
				newline: RegExp;
				paragraph: RegExp;
				table: RegExp;
				text: RegExp;
			};
			gfm: Record<"code" | "blockquote" | "hr" | "html" | "table" | "text" | "def" | "heading" | "list" | "paragraph" | "fences" | "lheading" | "newline", RegExp>;
			pedantic: Record<"code" | "blockquote" | "hr" | "html" | "table" | "text" | "def" | "heading" | "list" | "paragraph" | "fences" | "lheading" | "newline", RegExp>;
		};
		inline: {
			normal: {
				_backpedal: RegExp;
				anyPunctuation: RegExp;
				autolink: RegExp;
				blockSkip: RegExp;
				br: RegExp;
				code: RegExp;
				del: RegExp;
				delLDelim: RegExp;
				delRDelim: RegExp;
				emStrongLDelim: RegExp;
				emStrongRDelimAst: RegExp;
				emStrongRDelimUnd: RegExp;
				escape: RegExp;
				link: RegExp;
				nolink: RegExp;
				punctuation: RegExp;
				reflink: RegExp;
				reflinkSearch: RegExp;
				tag: RegExp;
				text: RegExp;
				url: RegExp;
			};
			gfm: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>;
			breaks: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>;
			pedantic: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>;
		};
	};
	/**
	 * Static Lex Method
	 */
	static lex<ParserOutput = string, RendererOutput = string>(src: string, options?: MarkedOptions<ParserOutput, RendererOutput>): TokensList;
	/**
	 * Static Lex Inline Method
	 */
	static lexInline<ParserOutput = string, RendererOutput = string>(src: string, options?: MarkedOptions<ParserOutput, RendererOutput>): Token[];
	/**
	 * Preprocessing
	 */
	lex(src: string): TokensList;
	/**
	 * Lexing
	 */
	blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];
	blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList;
	inline(src: string, tokens?: Token[]): Token[];
	/**
	 * Lexing/Compiling
	 */
	inlineTokens(src: string, tokens?: Token[]): Token[];
	private infiniteLoopError;
}

/**
 * A tokenizer + renderer extension colocated on a single object — the
 * preferred shape for new XMarkdownMini extensions. Structurally mirrors
 * marked's `TokenizerAndRendererExtension` but adds `miniRenderer` so the
 * renderer can return `MiniNode` directly instead of HTML.
 */
interface XMarkdownTokenizerExtension {
    /** Token.type produced by this tokenizer. */
    name: string;
    /** Tokenizer level: 'block' or 'inline'. */
    level?: 'block' | 'inline';
    /** Marked start hook: returns the index of the next potential match. */
    start?: (src: string) => number | undefined;
    /** Marked tokenizer hook. */
    tokenizer?: (this: any, src: string, tokens: Token[]) => Tokens.Generic | undefined;
    /** Optional child token names (forwarded to marked). */
    childTokens?: string[];
    /** Preferred: return a MiniNode tree directly for this token. */
    miniRenderer?: (token: Token, ctx: RenderContext) => MiniNode | MiniNode[] | null | undefined;
    /**
     * marked-style HTML renderer. When present without `miniRenderer`, the HTML
     * output is run through `htmlToMiniNodes` and the result is used.
     */
    renderer?: (this: any, token: Token) => string;
}
/**
 * Preferred extension shape for `XMarkdownMiniOptions.extensions`. A subset of
 * `MarkedExtension` whose tokenizer entries carry `miniRenderer` / `renderer`
 * alongside the tokenizer. `MarkedExtension`s (e.g. community plugins that
 * only emit HTML) are also accepted in the same array.
 */
interface XMarkdownExtension {
    /** Tokenizer entries with colocated mini-program renderers. */
    extensions?: XMarkdownTokenizerExtension[];
    /** Marked walkTokens hook (forwarded to marked). */
    walkTokens?: MarkedExtension['walkTokens'];
    /** Marked hooks (forwarded to marked). */
    hooks?: MarkedExtension['hooks'];
    /** Marked tokenizer overrides (forwarded to marked). */
    tokenizer?: MarkedExtension['tokenizer'];
}
/** Context passed to a code-block header renderer. */
interface CodeHeaderContext {
    /** Resolved language id ('' when the fence has no language). */
    lang: string;
    /** Raw code text — the clipboard payload. */
    text: string;
    token: Tokens.Code;
}
/** Context passed to a table header renderer. */
interface TableHeaderContext {
    /** Raw markdown source of the table — the clipboard payload. */
    markdown: string;
    token: Tokens.Table;
}
type CodeHeaderRenderer = (ctx: CodeHeaderContext) => MiniNode | MiniNode[] | null;
type TableHeaderRenderer = (ctx: TableHeaderContext) => MiniNode | MiniNode[] | null;
/** 渲染上下文：transformer 共用的公共配置。 */
interface RenderContext {
    /** 是否启用块级动画 */
    animation?: boolean;
    /** Internal Alipay marker for platform-specific extension render fallbacks. */
    a?: 1;
    /** 文本是否可选择 */
    selectable?: boolean;
    /**
     * 是否对文本节点的 value 做 HTML 实体转义。
     * - true（默认）：用于会解码实体的平台节点容器
     * - false：用于自渲染组件（<text>{{value}}</text> 不解码实体）
     */
    escapeText?: boolean;
    /**
     * Colocated tokenizer+renderer extensions registered on the instance.
     */
    extensions?: readonly XMarkdownExtension[];
    /**
     * Code-block header config. `true`/undefined = default (language + copy
     * button); `false` = no header; function = custom header nodes.
     */
    codeHeader?: boolean | CodeHeaderRenderer;
    /** Table header config. Same semantics as `codeHeader`. */
    tableHeader?: boolean | TableHeaderRenderer;
    /**
     * Recursively render an inline token array to MiniNode[]. Provided by the
     * platform transformer; used by custom extension miniRenderers that emit
     * tokens with children (e.g. <custom-tag>inner</custom-tag>).
     */
    renderInlineTokens?: (tokens: Token[]) => MiniNode[];
}
interface MiniNode {
    /** 标签名，小写 */
    name: string;
    /**
     * 自定义组件原始标签名。仅由 `components` 白名单合成的节点携带，等于 `name`，
     * 用于宿主页面在作用域插槽 / dispatcher 里按 `node.tag` 分发（对齐 markdown-x 约定）。
     */
    tag?: string;
    /** 属性，class/style 等小写 */
    attrs?: Record<string, string | number | boolean>;
    /** 子节点 */
    children?: MiniNode[];
    /** 代码块/表格顶部 header 栏（语言/标题 + 复制按钮）。 */
    header?: MiniNode[];
    /** 是否开启动画 */
    animate?: boolean;
    /**
     * 兄弟节点内的稳定下标 key，由 `flattenInlineNodes` 递归赋值。供小程序模板的
     * wx:for / a:for 作 wx:key —— index 变量不能直接当 key，缺了稳定 key 会让流式
     * 每帧整树重建、入场动画全体重播（整段闪）。追加时旧节点 k 不变得以复用。
    */
    k?: number;
    /** 流式文本的时间轴片段；重建节点时通过负 animation-delay 从原进度续播。 */
    animationSegments?: MiniNodeAnimationSegment[];
}
interface MiniNodeAnimationSegment {
    k: number;
    value: string;
    bornAt: number;
    animate?: true;
    style?: string;
}

export type { MiniNode as M, XMarkdownExtension as X };