vitepress-plugin-sfc 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/index.d.mts

@@ -1,1084 +1,27 @@
-import { MarkdownEnv, Plugin } from "vitepress";
-import LinkifyIt from "linkify-it";
+import { t as ComponentViewProps } from "./index-DHKDP_Um.mjs";
+import { MarkdownEnv, MarkdownRenderer, Plugin, SfcBlock } from "vitepress";
 
-//#region \0rolldown/runtime.js
-declare namespace index_d_exports$1 {
-  export { Url, decode, encode, format, parse };
-}
-interface Url {
-  protocol: string | null;
-  slashes: boolean | null;
-  auth: string | null;
-  port: string | null;
-  hostname: string | null;
-  hash: string | null;
-  search: string | null;
-  pathname: string | null;
-}
-declare function decode(string: string, exclude?: string): string;
-declare namespace decode {
-  let defaultChars: string;
-  let componentChars: string;
-}
-declare function encode(string: string, keepEscaped?: boolean): string;
-declare function encode(string: string, exclude: string, keepEscaped?: boolean): string;
-declare namespace encode {
-  let defaultChars: string;
-  let componentChars: string;
-}
-declare function format(url: Url): string;
-declare function parse(url: string, slashesDenoteHost?: boolean): Url;
-declare namespace utils_d_exports {
-  export { arrayReplaceAt, assign, escapeHtml, escapeRE, fromCodePoint, has, isMdAsciiPunct, isPunctChar, isPunctCharCode, isSpace, isString, isValidEntityCode, isWhiteSpace, lib, normalizeReference, unescapeAll, unescapeMd };
-}
-// import * as ucmicro from "uc.micro";
-declare const lib: {
-  mdurl: typeof index_d_exports$1;
-  ucmicro: any;
-};
-/**
- * Merge objects
- */
-declare function assign(obj: any, ...from: any[]): any;
-declare function isString(obj: any): obj is string;
-declare function has(obj: any, key: keyof any): boolean;
-declare function unescapeMd(str: string): string;
-declare function unescapeAll(str: string): string;
-declare function isValidEntityCode(c: number): boolean;
-declare function fromCodePoint(c: number): string;
-declare function escapeHtml(str: string): string;
-/**
- * Remove element from array and put another array at those position.
- * Useful for some operations with tokens
- */
-declare function arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
-declare function isSpace(code: number): boolean;
-/**
- * Zs (unicode class) || [\t\f\v\r\n]
- */
-declare function isWhiteSpace(code: number): boolean;
-/**
- * Markdown [ASCII punctuation characters](https://spec.commonmark.org/0.31.2/#ascii-punctuation-character).
- *
- * !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, \@, [, \\, ], ^, _, `, {, |, }, or ~
- *
- * {@link isPunctChar} is missing some ASCII punctuation chars in < 14.1.0.
- * This is consistent with CommonMark 0.30 and older behavior, where the range of ASCII punctuation
- * characters was not fully contained in that of
- * [Unicode punctuation characters](https://spec.commonmark.org/0.31.2/#unicode-punctuation-character).
- *
- * In >= 14.1.0 (compliant with CommonMark 0.31.2), {@link isPunctChar} includes all ASCII punctuation characters,
- * so combining {@link isMdAsciiPunct} with {@link isPunctChar} is only for backwards compatibility or
- * to try to provide a fast path for ASCII ranges.
- *
- * @see https://spec.commonmark.org/0.31.2/changes.html#part-4
- */
-declare function isMdAsciiPunct(code: number): boolean;
-/**
- * [Unicode punctuation characters](https://spec.commonmark.org/0.31.2/#unicode-punctuation-character).
- *
- * Astral (supplementary) characters support requires >= 14.2.0.
- */
-declare function isPunctChar(ch: string): boolean;
-/**
- * [Unicode punctuation characters](https://spec.commonmark.org/0.31.2/#unicode-punctuation-character).
- *
- * Added in 14.2.0. Supports astral (supplementary) characters.
- */
-declare function isPunctCharCode(code: number): boolean;
-declare function escapeRE(str: string): string;
-/**
- * Helper to unify [reference labels].
- */
-declare function normalizeReference(str: string): string;
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/helpers/parse_link_destination.d.mts
-interface ParseLinkDestinationResult {
-  ok: boolean;
-  pos: number;
-  str: string;
-}
-declare function parseLinkDestination(str: string, start: number, max: number): ParseLinkDestinationResult;
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/token.d.mts
-type Nesting = 1 | 0 | -1;
-declare class Token {
-  /**
-   * Create new token and fill passed properties.
-   */
-  constructor(type: string, tag: string, nesting: Nesting);
-  /**
-   * Type of the token, e.g. "paragraph_open"
-   */
-  type: string;
-  /**
-   * HTML tag name, e.g. "p"
-   */
-  tag: string;
-  /**
-   * HTML attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
-   */
-  attrs: Array<[string, string]> | null;
-  /**
-   * Source map info. Format: `[ line_begin, line_end ]`
-   */
-  map: [number, number] | null;
-  /**
-   * Level change (number in {-1, 0, 1} set), where:
-   *
-   * -  `1` means the tag is opening
-   * -  `0` means the tag is self-closing
-   * - `-1` means the tag is closing
-   */
-  nesting: Nesting;
-  /**
-   * Nesting level, the same as `state.level`
-   */
-  level: number;
-  /**
-   * An array of child nodes (inline and img tokens)
-   */
-  children: Token[] | null;
-  /**
-   * In a case of self-closing tag (code, html, fence, etc.),
-   * it has contents of this tag.
-   */
-  content: string;
-  /**
-   * '*' or '_' for emphasis, fence string for fence, etc.
-   */
-  markup: string;
-  /**
-   * - Info string for "fence" tokens
-   * - The value "auto" for autolink "link_open" and "link_close" tokens
-   * - The string value of the item marker for ordered-list "list_item_open" tokens
-   */
-  info: string;
-  /**
-   * A place for plugins to store an arbitrary data
-   */
-  meta: any;
-  /**
-   * True for block-level tokens, false for inline tokens.
-   * Used in renderer to calculate line breaks
-   */
-  block: boolean;
-  /**
-   * If it's true, ignore this element when rendering. Used for tight lists
-   * to hide paragraphs.
-   */
-  hidden: boolean;
-  /**
-   * Search attribute index by name.
-   */
-  attrIndex(name: string): number;
-  /**
-   * Add `[ name, value ]` attribute to list. Init attrs if necessary
-   */
-  attrPush(attrData: [string, string]): void;
-  /**
-   * Set `name` attribute to `value`. Override old value if exists.
-   */
-  attrSet(name: string, value: string): void;
-  /**
-   * Get the value of attribute `name`, or null if it does not exist.
-   */
-  attrGet(name: string): string | null;
-  /**
-   * Join value to existing attribute via space. Or create new attribute if not
-   * exists. Useful to operate with token classes.
-   */
-  attrJoin(name: string, value: string): void;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/rules_inline/state_inline.d.mts
-interface Scanned {
-  can_open: boolean;
-  can_close: boolean;
-  length: number;
-}
-interface Delimiter {
-  marker: number;
-  length: number;
-  token: number;
-  end: number;
-  open: boolean;
-  close: boolean;
-}
-interface TokenMeta {
-  delimiters: Delimiter[];
-}
-declare class StateInline {
-  constructor(src: string, md: MarkdownIt, env: any, outTokens: Token[]);
-  src: string;
-  env: any;
-  md: MarkdownIt;
-  tokens: Token[];
-  tokens_meta: Array<TokenMeta | null>;
-  pos: number;
-  posMax: number;
-  level: number;
-  pending: string;
-  pendingLevel: number;
-  /**
-   * Stores { start: end } pairs. Useful for backtrack
-   * optimization of pairs parse (emphasis, strikes).
-   */
-  cache: any;
-  /**
-   * List of emphasis-like delimiters for current tag
-   */
-  delimiters: Delimiter[]; // Stack of delimiter lists for upper level tags
-  // _prev_delimiters: StateInline.Delimiter[][];
-  /**
-   * Flush pending text
-   */
-  pushPending(): Token;
-  /**
-   * Push new token to "stream".
-   * If pending text exists - flush it as text token
-   */
-  push(type: string, tag: string, nesting: Nesting): Token;
-  /**
-   * Scan a sequence of emphasis-like markers, and determine whether
-   * it can start an emphasis sequence or end an emphasis sequence.
-   *
-   * @param start position to scan from (it should point at a valid marker)
-   * @param canSplitWord determine if these markers can be found inside a word
-   */
-  scanDelims(start: number, canSplitWord: boolean): Scanned;
-  Token: typeof Token;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/helpers/parse_link_label.d.mts
-declare function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/helpers/parse_link_title.d.mts
-interface ParseLinkTitleResult {
-  /**
-   * if `true`, this is a valid link title
-   */
-  ok: boolean;
-  /**
-   * if `true`, this link can be continued on the next line
-   */
-  can_continue: boolean;
-  /**
-   * if `ok`, it's the position of the first character after the closing marker
-   */
-  pos: number;
-  /**
-   * if `ok`, it's the unescaped title
-   */
-  str: string;
-  /**
-   * expected closing marker character code
-   */
-  marker: number;
-}
-declare function parseLinkTitle(str: string, start: number, max: number, prev_state?: ParseLinkTitleResult): ParseLinkTitleResult;
-declare namespace index_d_exports {
-  export { parseLinkDestination, parseLinkLabel, parseLinkTitle };
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/ruler.d.mts
-interface RuleOptions {
-  /**
-   * array with names of "alternate" chains.
-   */
-  alt: string[];
-}
-/**
- * Helper class, used by {@link MarkdownIt#core}, {@link MarkdownIt#block} and
- * {@link MarkdownIt#inline} to manage sequences of functions (rules):
- *
- * - keep rules in defined order
- * - assign the name to each rule
- * - enable/disable rules
- * - add/replace rules
- * - allow assign rules to additional named chains (in the same)
- * - caching lists of active rules
- *
- * You will not need use this class directly until write plugins. For simple
- * rules control use {@link MarkdownIt.disable}, {@link MarkdownIt.enable} and
- * {@link MarkdownIt.use}.
- */
-declare class Ruler<T> {
-  constructor();
-  /**
-   * Replace rule by name with new function & options. Throws error if name not
-   * found.
-   *
-   * ##### Example
-   *
-   * Replace existing typographer replacement rule with new one:
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.core.ruler.at('replacements', function replace(state) {
-   *   //...
-   * });
-   * ```
-   *
-   * @param name rule name to replace.
-   * @param fn new rule function.
-   * @param options new rule options (not mandatory).
-   */
-  at(name: string, fn: T, options?: RuleOptions): void;
-  /**
-   * Add new rule to chain before one with given name.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
-   *   //...
-   * });
-   * ```
-   *
-   * @see {@link Ruler.after}, {@link Ruler.push}
-   *
-   * @param beforeName new rule will be added before this one.
-   * @param ruleName name of added rule.
-   * @param fn rule function.
-   * @param options rule options (not mandatory).
-   */
-  before(beforeName: string, ruleName: string, fn: T, options?: RuleOptions): void;
-  /**
-   * Add new rule to chain after one with given name.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.inline.ruler.after('text', 'my_rule', function replace(state) {
-   *   //...
-   * });
-   * ```
-   *
-   * @see {@link Ruler.before}, {@link Ruler.push}
-   *
-   * @param afterName new rule will be added after this one.
-   * @param ruleName name of added rule.
-   * @param fn rule function.
-   * @param options rule options (not mandatory).
-   */
-  after(afterName: string, ruleName: string, fn: T, options?: RuleOptions): void;
-  /**
-   * Push new rule to the end of chain.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.core.ruler.push('my_rule', function replace(state) {
-   *   //...
-   * });
-   * ```
-   *
-   * @see {@link Ruler.before}, {@link Ruler.after}
-   *
-   * @param ruleName name of added rule.
-   * @param fn rule function.
-   * @param options rule options (not mandatory).
-   */
-  push(ruleName: string, fn: T, options?: RuleOptions): void;
-  /**
-   * Enable rules with given names. If any rule name not found - throw Error.
-   * Errors can be disabled by second param.
-   *
-   * Returns list of found rule names (if no exception happened).
-   *
-   * @see {@link Ruler.disable}, {@link Ruler.enableOnly}
-   *
-   * @param list list of rule names to enable.
-   * @param ignoreInvalid set `true` to ignore errors when rule not found.
-   */
-  enable(list: string | string[], ignoreInvalid?: boolean): string[];
-  /**
-   * Enable rules with given names, and disable everything else. If any rule name
-   * not found - throw Error. Errors can be disabled by second param.
-   *
-   * @see {@link Ruler.disable}, {@link Ruler.enable}
-   *
-   * @param list list of rule names to enable (whitelist).
-   * @param ignoreInvalid set `true` to ignore errors when rule not found.
-   */
-  enableOnly(list: string | string[], ignoreInvalid?: boolean): void;
-  /**
-   * Disable rules with given names. If any rule name not found - throw Error.
-   * Errors can be disabled by second param.
-   *
-   * Returns list of found rule names (if no exception happened).
-   *
-   * @see {@link Ruler.enable}, {@link Ruler.enableOnly}
-   *
-   * @param list list of rule names to disable.
-   * @param ignoreInvalid set `true` to ignore errors when rule not found.
-   */
-  disable(list: string | string[], ignoreInvalid?: boolean): string[];
-  /**
-   * Return array of active functions (rules) for given chain name. It analyzes
-   * rules configuration, compiles caches if not exists and returns result.
-   *
-   * Default chain name is `''` (empty string). It can't be skipped. That's
-   * done intentionally, to keep signature monomorphic for high speed.
-   */
-  getRules(chainName: string): T[];
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/rules_block/state_block.d.mts
-type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
-declare class StateBlock {
-  constructor(src: string, md: MarkdownIt, env: any, tokens: Token[]);
-  src: string;
-  /**
-   * link to parser instance
-   */
-  md: MarkdownIt;
-  env: any; //
-  // Internal state vartiables
-  //
-  tokens: Token[];
-  /**
-   * line begin offsets for fast jumps
-   */
-  bMarks: number[];
-  /**
-   * line end offsets for fast jumps
-   */
-  eMarks: number[];
-  /**
-   * offsets of the first non-space characters (tabs not expanded)
-   */
-  tShift: number[];
-  /**
-   * indents for each line (tabs expanded)
-   */
-  sCount: number[];
-  /**
-   * An amount of virtual spaces (tabs expanded) between beginning
-   * of each line (bMarks) and real beginning of that line.
-   *
-   * It exists only as a hack because blockquotes override bMarks
-   * losing information in the process.
-   *
-   * It's used only when expanding tabs, you can think about it as
-   * an initial tab length, e.g. bsCount=21 applied to string `\t123`
-   * means first tab should be expanded to 4-21%4 === 3 spaces.
-   */
-  bsCount: number[]; // block parser variables
-  /**
-   * required block content indent (for example, if we are
-   * inside a list, it would be positioned after list marker)
-   */
-  blkIndent: number;
-  /**
-   * line index in src
-   */
-  line: number;
-  /**
-   * lines count
-   */
-  lineMax: number;
-  /**
-   * loose/tight mode for lists
-   */
-  tight: boolean;
-  /**
-   * indent of the current dd block (-1 if there isn't any)
-   */
-  ddIndent: number;
-  /**
-   * indent of the current list block (-1 if there isn't any)
-   */
-  listIndent: number;
-  /**
-   * used in lists to determine if they interrupt a paragraph
-   */
-  parentType: ParentType;
-  level: number;
-  /**
-   * Push new token to "stream".
-   */
-  push(type: string, tag: string, nesting: Nesting): Token;
-  isEmpty(line: number): boolean;
-  skipEmptyLines(from: number): number;
-  /**
-   * Skip spaces from given position.
-   */
-  skipSpaces(pos: number): number;
-  /**
-   * Skip spaces from given position in reverse.
-   */
-  skipSpacesBack(pos: number, min: number): number;
-  /**
-   * Skip char codes from given position
-   */
-  skipChars(pos: number, code: number): number;
-  /**
-   * Skip char codes reverse from given position - 1
-   */
-  skipCharsBack(pos: number, code: number, min: number): number;
-  /**
-   * cut lines range from source.
-   */
-  getLines(begin: number, end: number, indent: number, keepLastLF: boolean): string;
-  Token: typeof Token;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/parser_block.d.mts
-type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
-declare class ParserBlock {
-  /**
-   * {@link Ruler} instance. Keep configuration of block rules.
-   */
-  ruler: Ruler<RuleBlock>;
-  /**
-   * Generate tokens for input range
-   */
-  tokenize(state: StateBlock, startLine: number, endLine: number): void;
-  /**
-   * Process input string and push block tokens into `outTokens`
-   */
-  parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
-  State: typeof StateBlock;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/rules_core/state_core.d.mts
-declare class StateCore {
-  constructor(src: string, md: MarkdownIt, env: any);
-  src: string;
-  env: any;
-  tokens: Token[];
-  inlineMode: boolean;
-  /**
-   * link to parser instance
-   */
-  md: MarkdownIt;
-  Token: typeof Token;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/parser_core.d.mts
-type RuleCore = (state: StateCore) => void;
-declare class Core {
-  /**
-   * {@link Ruler} instance. Keep configuration of core rules.
-   */
-  ruler: Ruler<RuleCore>;
-  /**
-   * Executes core chain rules.
-   */
-  process(state: StateCore): void;
-  State: typeof StateCore;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/parser_inline.d.mts
-type RuleInline = (state: StateInline, silent: boolean) => boolean;
-type RuleInline2 = (state: StateInline) => boolean;
-declare class ParserInline {
-  /**
-   * {@link Ruler} instance. Keep configuration of inline rules.
-   */
-  ruler: Ruler<RuleInline>;
-  /**
-   * {@link Ruler} instance. Second ruler used for post-processing
-   * (e.g. in emphasis-like rules).
-   */
-  ruler2: Ruler<RuleInline2>;
-  /**
-   * Skip single token by running all rules in validation mode;
-   * returns `true` if any rule reported success
-   */
-  skipToken(state: StateInline): void;
-  /**
-   * Generate tokens for input range
-   */
-  tokenize(state: StateInline): void;
-  /**
-   * Process input string and push inline tokens into `outTokens`
-   */
-  parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
-  State: typeof StateInline;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/renderer.d.mts
-type RenderRule = (tokens: Token[], idx: number, options: Options, env: any, self: Renderer) => string;
-interface RenderRuleRecord {
-  [type: string]: RenderRule | undefined;
-  code_inline?: RenderRule | undefined;
-  code_block?: RenderRule | undefined;
-  fence?: RenderRule | undefined;
-  image?: RenderRule | undefined;
-  hardbreak?: RenderRule | undefined;
-  softbreak?: RenderRule | undefined;
-  text?: RenderRule | undefined;
-  html_block?: RenderRule | undefined;
-  html_inline?: RenderRule | undefined;
-}
-declare class Renderer {
-  /**
-   * Creates new {@link Renderer} instance and fill {@link Renderer#rules} with defaults.
-   */
-  constructor();
-  /**
-   * Contains render rules for tokens. Can be updated and extended.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.renderer.rules.strong_open  = function () { return '<b>'; };
-   * md.renderer.rules.strong_close = function () { return '</b>'; };
-   *
-   * var result = md.renderInline(...);
-   * ```
-   *
-   * Each rule is called as independent static function with fixed signature:
-   *
-   * ```javascript
-   * function my_token_render(tokens, idx, options, env, renderer) {
-   *   // ...
-   *   return renderedHTML;
-   * }
-   * ```
-   *
-   * @see https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs
-   */
-  rules: RenderRuleRecord;
-  /**
-   * Render token attributes to string.
-   */
-  renderAttrs(token: Token): string;
-  /**
-   * Default token renderer. Can be overriden by custom function
-   * in {@link Renderer#rules}.
-   *
-   * @param tokens list of tokens
-   * @param idx token index to render
-   * @param options params of parser instance
-   */
-  renderToken(tokens: Token[], idx: number, options: Options): string;
-  /**
-   * The same as {@link Renderer.render}, but for single token of `inline` type.
-   *
-   * @param tokens list of block tokens to render
-   * @param options params of parser instance
-   * @param env additional data from parsed input (references, for example)
-   */
-  renderInline(tokens: Token[], options: Options, env: any): string;
-  /**
-   * Special kludge for image `alt` attributes to conform CommonMark spec.
-   * Don't try to use it! Spec requires to show `alt` content with stripped markup,
-   * instead of simple escaping.
-   *
-   * @param tokens list of block tokens to render
-   * @param options params of parser instance
-   * @param env additional data from parsed input (references, for example)
-   */
-  renderInlineAsText(tokens: Token[], options: Options, env: any): string;
-  /**
-   * Takes token stream and generates HTML. Probably, you will never need to call
-   * this method directly.
-   *
-   * @param tokens list of block tokens to render
-   * @param options params of parser instance
-   * @param env additional data from parsed input (references, for example)
-   */
-  render(tokens: Token[], options: Options, env: any): string;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+markdown-it@14.2.0/node_modules/@types/markdown-it/lib/index.d.mts
-/**
- * MarkdownIt provides named presets as a convenience to quickly
- * enable/disable active syntax rules and options for common use cases.
- *
- * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
- *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
- * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
- *   similar to GFM, used when no preset name given. Enables all available rules,
- *   but still without html, typographer & autolinker.
- * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
- *   all rules disabled. Useful to quickly setup your config via `.enable()`.
- *   For example, when you need only `bold` and `italic` markup and nothing else.
- */
-type PresetName = "default" | "zero" | "commonmark";
-interface Options {
-  /**
-   * Set `true` to enable HTML tags in source. Be careful!
-   * That's not safe! You may need external sanitizer to protect output from XSS.
-   * It's better to extend features via plugins, instead of enabling HTML.
-   * @default false
-   */
-  html?: boolean | undefined;
-  /**
-   * Set `true` to add '/' when closing single tags
-   * (`<br />`). This is needed only for full CommonMark compatibility. In real
-   * world you will need HTML output.
-   * @default false
-   */
-  xhtmlOut?: boolean | undefined;
-  /**
-   * Set `true` to convert `\n` in paragraphs into `<br>`.
-   * @default false
-   */
-  breaks?: boolean | undefined;
-  /**
-   * CSS language class prefix for fenced blocks.
-   * Can be useful for external highlighters.
-   * @default 'language-'
-   */
-  langPrefix?: string | undefined;
-  /**
-   * Set `true` to autoconvert URL-like text to links.
-   * @default false
-   */
-  linkify?: boolean | undefined;
-  /**
-   * Set `true` to enable [some language-neutral replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
-   * quotes beautification (smartquotes).
-   * @default false
-   */
-  typographer?: boolean | undefined;
-  /**
-   * Double + single quotes replacement
-   * pairs, when typographer enabled and smartquotes on. For example, you can
-   * use `'«»„“'` for Russian, `'„“‚‘'` for German, and
-   * `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
-   * @default '“”‘’'
-   */
-  quotes?: string | string[];
-  /**
-   * Highlighter function for fenced code blocks.
-   * Highlighter `function (str, lang, attrs)` should return escaped HTML. It can
-   * also return empty string if the source was not changed and should be escaped
-   * externally. If result starts with <pre... internal wrapper is skipped.
-   * @default null
-   */
-  highlight?: ((str: string, lang: string, attrs: string) => string) | null | undefined;
-}
-type PluginSimple = (md: MarkdownIt) => void;
-type PluginWithOptions<T = any> = (md: MarkdownIt, options?: T) => void;
-type PluginWithParams = (md: MarkdownIt, ...params: any[]) => void;
-interface MarkdownItConstructor {
-  new (): MarkdownIt;
-  new (presetName: PresetName, options?: Options): MarkdownIt;
-  new (options: Options): MarkdownIt;
-  (): MarkdownIt;
-  (presetName: PresetName, options?: Options): MarkdownIt;
-  (options: Options): MarkdownIt;
-}
-interface MarkdownIt {
-  /**
-   * Instance of {@link ParserInline}. You may need it to add new rules when
-   * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
-   * {@link MarkdownIt.enable}.
-   */
-  readonly inline: ParserInline;
-  /**
-   * Instance of {@link ParserBlock}. You may need it to add new rules when
-   * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
-   * {@link MarkdownIt.enable}.
-   */
-  readonly block: ParserBlock;
-  /**
-   * Instance of {@link Core} chain executor. You may need it to add new rules when
-   * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
-   * {@link MarkdownIt.enable}.
-   */
-  readonly core: Core;
-  /**
-   * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
-   * rules for new token types, generated by plugins.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * function myToken(tokens, idx, options, env, self) {
-   *   //...
-   *   return result;
-   * };
-   *
-   * md.renderer.rules['my_token'] = myToken
-   * ```
-   *
-   * See {@link Renderer} docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
-   */
-  readonly renderer: Renderer;
-  /**
-   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
-   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
-   * rule.
-   */
-  readonly linkify: LinkifyIt;
-  /**
-   * Link validation function. CommonMark allows too much in links. By default
-   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
-   * except some embedded image types.
-   *
-   * You can change this behaviour:
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   * // enable everything
-   * md.validateLink = function () { return true; }
-   * ```
-   */
-  validateLink(url: string): boolean;
-  /**
-   * Function used to encode link url to a machine-readable format,
-   * which includes url-encoding, punycode, etc.
-   */
-  normalizeLink(url: string): string;
-  /**
-   * Function used to decode link url to a human-readable format`
-   */
-  normalizeLinkText(url: string): string;
-  readonly utils: typeof utils_d_exports;
-  readonly helpers: typeof index_d_exports;
-  readonly options: Options;
-  /**
-   * *chainable*
-   *
-   * Set parser options (in the same format as in constructor). Probably, you
-   * will never need it, but you can change options after constructor call.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')()
-   *             .set({ html: true, breaks: true })
-   *             .set({ typographer: true });
-   * ```
-   *
-   * __Note:__ To achieve the best possible performance, don't modify a
-   * `markdown-it` instance options on the fly. If you need multiple configurations
-   * it's best to create multiple instances and initialize each with separate
-   * config.
-   */
-  set(options: Options): this;
-  /**
-   * *chainable*, *internal*
-   *
-   * Batch load of all options and compenent settings. This is internal method,
-   * and you probably will not need it. But if you with - see available presets
-   * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
-   *
-   * We strongly recommend to use presets instead of direct config loads. That
-   * will give better compatibility with next versions.
-   */
-  configure(presets: PresetName): this;
-  /**
-   * *chainable*
-   *
-   * Enable list or rules. It will automatically find appropriate components,
-   * containing rules with given names. If rule not found, and `ignoreInvalid`
-   * not set - throws exception.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')()
-   *             .enable(['sub', 'sup'])
-   *             .disable('smartquotes');
-   * ```
-   *
-   * @param list rule name or list of rule names to enable
-   * @param ignoreInvalid set `true` to ignore errors when rule not found.
-   */
-  enable(list: string | string[], ignoreInvalid?: boolean): this;
-  /**
-   * *chainable*
-   *
-   * The same as {@link MarkdownIt.enable}, but turn specified rules off.
-   *
-   * @param list rule name or list of rule names to disable.
-   * @param ignoreInvalid set `true` to ignore errors when rule not found.
-   */
-  disable(list: string | string[], ignoreInvalid?: boolean): this;
-  /**
-   * *chainable*
-   *
-   * Load specified plugin with given params into current parser instance.
-   * It's just a sugar to call `plugin(md, params)` with curring.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var iterator = require('markdown-it-for-inline');
-   * var md = require('markdown-it')()
-   *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
-   *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
-   *             });
-   * ```
-   */
-  use(plugin: PluginSimple): this;
-  use<T = any>(plugin: PluginWithOptions<T>, options?: T): this;
-  use(plugin: PluginWithParams, ...params: any[]): this;
-  /**
-   * *internal*
-   *
-   * Parse input string and returns list of block tokens (special token type
-   * "inline" will contain list of inline tokens). You should not call this
-   * method directly, until you write custom renderer (for example, to produce
-   * AST).
-   *
-   * `env` is used to pass data between "distributed" rules and return additional
-   * metadata like reference info, needed for the renderer. It also can be used to
-   * inject data in specific cases. Usually, you will be ok to pass `{}`,
-   * and then pass updated object to renderer.
-   *
-   * @param src source string
-   * @param env environment sandbox
-   */
-  parse(src: string, env: any): Token[];
-  /**
-   * Render markdown string into html. It does all magic for you :).
-   *
-   * `env` can be used to inject additional metadata (`{}` by default).
-   * But you will not need it with high probability. See also comment
-   * in {@link MarkdownIt.parse}.
-   *
-   * @param src source string
-   * @param env environment sandbox
-   */
-  render(src: string, env?: any): string;
-  /**
-   * *internal*
-   *
-   * The same as {@link MarkdownIt.parse} but skip all block rules. It returns the
-   * block tokens list with the single `inline` element, containing parsed inline
-   * tokens in `children` property. Also updates `env` object.
-   *
-   * @param src source string
-   * @param env environment sandbox
-   */
-  parseInline(src: string, env: any): Token[];
-  /**
-   * Similar to {@link MarkdownIt.render} but for single paragraph content. Result
-   * will NOT be wrapped into `<p>` tags.
-   *
-   * @param src source string
-   * @param env environment sandbox
-   */
-  renderInline(src: string, env?: any): string;
-}
-/**
- * Main parser/renderer class.
- *
- * ##### Usage
- *
- * ```javascript
- * // node.js, "classic" way:
- * var MarkdownIt = require('markdown-it'),
- *     md = new MarkdownIt();
- * var result = md.render('# markdown-it rulezz!');
- *
- * // node.js, the same, but with sugar:
- * var md = require('markdown-it')();
- * var result = md.render('# markdown-it rulezz!');
- *
- * // browser without AMD, added to "window" on script load
- * // Note, there are no dash.
- * var md = window.markdownit();
- * var result = md.render('# markdown-it rulezz!');
- * ```
- *
- * Single line rendering, without paragraph wrap:
- *
- * ```javascript
- * var md = require('markdown-it')();
- * var result = md.renderInline('__markdown-it__ rulezz!');
- * ```
- *
- * ##### Example
- *
- * ```javascript
- * // commonmark mode
- * var md = require('markdown-it')('commonmark');
- *
- * // default mode
- * var md = require('markdown-it')();
- *
- * // enable everything
- * var md = require('markdown-it')({
- *   html: true,
- *   linkify: true,
- *   typographer: true
- * });
- * ```
- *
- * ##### Syntax highlighting
- *
- * ```js
- * var hljs = require('highlight.js') // https://highlightjs.org/
- *
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return hljs.highlight(lang, str, true).value;
- *       } catch (__) {}
- *     }
- *
- *     return ''; // use external default escaping
- *   }
- * });
- * ```
- *
- * Or with full wrapper override (if you need assign class to `<pre>`):
- *
- * ```javascript
- * var hljs = require('highlight.js') // https://highlightjs.org/
- *
- * // Actual default values
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return '<pre class="hljs"><code>' +
- *                hljs.highlight(lang, str, true).value +
- *                '</code></pre>';
- *       } catch (__) {}
- *     }
- *
- *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
- *   }
- * });
- * ```
- */
-declare const MarkdownIt: MarkdownItConstructor;
-//#endregion
 //#region src/node/markdown.d.ts
 declare const SCRIPT_RE: RegExp;
 declare const SFC_IMPORTER_RE: RegExp;
+declare function createDefaultSfcBlock(): SfcBlock;
+declare function createVirtualImport(content: string): Pick<SFC, "hash" | "name" | "importer" | "renderedContent">;
 interface SFC {
   name: string;
-  content: string;
   hash: string;
   importer: string;
-  markupParams: MarkupParams;
+  content: string;
+  renderedContent: string;
+  markupParams: ComponentViewProps;
 }
 interface MarkdownEnvExt extends MarkdownEnv {
   sfcs: SFC[];
   __matched_sfc_set__: Set<string>;
 }
-interface MarkupParams {
-  showSource: boolean;
-  filepath?: string;
-  component?: string;
-}
-declare const sfcPlugin: PluginSimple;
+declare function plugin(md: MarkdownRenderer): void;
+declare const sfcPlugin: typeof plugin;
 //#endregion
 //#region src/node/vite.d.ts
 declare function sfcRegistryVitePlugin(): Promise<Plugin>;
 //#endregion
-export { MarkdownEnvExt, MarkupParams, SCRIPT_RE, SFC, SFC_IMPORTER_RE, sfcPlugin, sfcRegistryVitePlugin };
+export { MarkdownEnvExt, SCRIPT_RE, SFC, SFC_IMPORTER_RE, createDefaultSfcBlock, createVirtualImport, sfcPlugin, sfcRegistryVitePlugin };