vitepress 1.1.0 → 1.1.2

package/dist/node/index.d.ts

@@ -4,7 +4,7 @@ import { BuildOptions, Logger, UserConfig as UserConfig$1, ConfigEnv, ServerOpti
 export { Plugin, loadEnv } from 'vite';
 import { Awaitable, SiteData, PageData, HeadConfig, LocaleSpecificConfig, LocaleConfig, SSGContext, DefaultTheme } from '../../types/shared.js';
 export { DefaultTheme, HeadConfig, Header, SiteData } from '../../types/shared.js';
-import { Options as Options$2 } from '@vitejs/plugin-vue';
+import { Options as Options$3 } from '@vitejs/plugin-vue';
 import { UseDarkOptions } from '@vueuse/core';
 import { TransformOptions } from 'stream';
 import { ThemeRegistrationAny, BuiltinTheme, LanguageInput, ShikiTransformer, Highlighter } from 'shiki';
@@ -168,119 +168,6 @@ interface SitemapItem {
     lastmodrealtime?: boolean;
 }
 
-declare namespace Token {
-    type Nesting = 1 | 0 | -1;
-}
-
-/**
- * Create new token and fill passed properties.
- */
-declare class Token {
-    constructor(type: string, tag: string, nesting: Token.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: 1 | 0 | -1;
-
-    /**
-     * 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;
-
-    /**
-     * Fence info string
-     */
-    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;
-}
-
-declare namespace __token {
-  export { Token as default };
-}
-
 declare const LinkifyIt: {
     (
         schemas?: LinkifyIt.SchemaRules | LinkifyIt.Options,
@@ -378,92 +265,225 @@ declare namespace mdurl {
 
 // import ucmicro from 'uc.micro';
 
-interface Utils {
-    lib: {
-        mdurl: typeof mdurl;
-    };
+declare const lib: {
+    mdurl: typeof mdurl;
+    // ucmicro: typeof ucmicro;
+};
+
+/**
+ * Merge objects
+ */
+declare function assign(target: any, ...sources: any[]): any;
+
+/**
+ * Check if the type is string or not
+ */
+declare function isString(obj: any): obj is string;
+
+/**
+ * has own property
+ */
+declare function has(obj: any, key: keyof any): boolean;
+
+declare function unescapeMd(str: string): string;
+declare function unescapeAll(str: string): string;
+
+declare function isValidEntityCode(code: number): boolean;
+declare function fromCodePoint(code: 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.
+ * Return a new array.
+ */
+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.
+ *
+ * !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
+ * http://spec.commonmark.org/0.15/#ascii-punctuation-character
+ *
+ * Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
+ */
+declare function isMdAsciiPunct(code: number): boolean;
+
+/**
+ * Currently without astral characters support.
+ */
+declare function isPunctChar(ch: string): boolean;
+
+declare function escapeRE(str: string): string;
+
+/**
+ * Hepler to unify [reference labels].
+ */
+declare function normalizeReference(str: string): string;
+
+declare const utils_arrayReplaceAt: typeof arrayReplaceAt;
+declare const utils_assign: typeof assign;
+declare const utils_escapeHtml: typeof escapeHtml;
+declare const utils_escapeRE: typeof escapeRE;
+declare const utils_fromCodePoint: typeof fromCodePoint;
+declare const utils_has: typeof has;
+declare const utils_isMdAsciiPunct: typeof isMdAsciiPunct;
+declare const utils_isPunctChar: typeof isPunctChar;
+declare const utils_isSpace: typeof isSpace;
+declare const utils_isString: typeof isString;
+declare const utils_isValidEntityCode: typeof isValidEntityCode;
+declare const utils_isWhiteSpace: typeof isWhiteSpace;
+declare const utils_lib: typeof lib;
+declare const utils_normalizeReference: typeof normalizeReference;
+declare const utils_unescapeAll: typeof unescapeAll;
+declare const utils_unescapeMd: typeof unescapeMd;
+declare namespace utils {
+  export { utils_arrayReplaceAt as arrayReplaceAt, utils_assign as assign, utils_escapeHtml as escapeHtml, utils_escapeRE as escapeRE, utils_fromCodePoint as fromCodePoint, utils_has as has, utils_isMdAsciiPunct as isMdAsciiPunct, utils_isPunctChar as isPunctChar, utils_isSpace as isSpace, utils_isString as isString, utils_isValidEntityCode as isValidEntityCode, utils_isWhiteSpace as isWhiteSpace, utils_lib as lib, utils_normalizeReference as normalizeReference, utils_unescapeAll as unescapeAll, utils_unescapeMd as unescapeMd };
+}
+
+declare namespace parseLinkDestination {
+    interface ParseResult {
+        ok: boolean;
+        pos: number;
+        lines: number;
+        str: string;
+    }
+}
+
+declare function parseLinkDestination(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
+
+type Nesting = 1 | 0 | -1;
+
+/**
+ * Create new token and fill passed properties.
+ */
+declare class Token {
+    constructor(type: string, tag: string, nesting: Nesting);
 
     /**
-     * Merge objects
+     * Type of the token, e.g. "paragraph_open"
      */
-    assign(target: any, ...sources: any[]): any;
+    type: string;
 
     /**
-     * Check if the type is string or not
+     * HTML tag name, e.g. "p"
      */
-    isString(obj: any): obj is string;
+    tag: string;
 
     /**
-     * has own property
+     * HTML attributes. Format: `[[name1, value1], [name2, value2]]`
      */
-    has(obj: any, key: keyof any): boolean;
+    attrs: Array<[string, string]> | null;
 
-    unescapeMd(str: string): string;
-    unescapeAll(str: string): string;
+    /**
+     * Source map info. Format: `[line_begin, line_end]`
+     */
+    map: [number, number] | null;
 
-    isValidEntityCode(code: number): boolean;
-    fromCodePoint(code: number): string;
-    escapeHtml(str: string): string;
+    /**
+     * 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;
 
     /**
-     * Remove element from array and put another array at those position.
-     * Useful for some operations with tokens.
-     * Return a new array.
+     * nesting level, the same as `state.level`
      */
-    arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
+    level: number;
 
-    isSpace(code: number): boolean;
+    /**
+     * An array of child nodes (inline and img tokens)
+     */
+    children: Token[] | null;
 
     /**
-     * Zs (unicode class) || [\t\f\v\r\n]
+     * In a case of self-closing tag (code, html, fence, etc.),
+     * it has contents of this tag.
      */
-    isWhiteSpace(code: number): boolean;
+    content: string;
 
     /**
-     * Markdown ASCII punctuation characters.
-     *
-     * !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
-     * http://spec.commonmark.org/0.15/#ascii-punctuation-character
-     *
-     * Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
+     * '*' or '_' for emphasis, fence string for fence, etc.
+     */
+    markup: string;
+
+    /**
+     * Fence info string
      */
-    isMdAsciiPunct(code: number): boolean;
+    info: string;
 
     /**
-     * Currently without astral characters support.
+     * A place for plugins to store an arbitrary data
      */
-    isPunctChar(ch: string): boolean;
+    meta: any;
 
-    escapeRE(str: string): string;
+    /**
+     * True for block-level tokens, false for inline tokens.
+     * Used in renderer to calculate line breaks
+     */
+    block: boolean;
 
     /**
-     * Hepler to unify [reference labels].
+     * If it's true, ignore this element when rendering. Used for tight lists
+     * to hide paragraphs.
      */
-    normalizeReference(str: string): string;
-}
+    hidden: boolean;
 
-declare const utils: Utils;
+    /**
+     * Search attribute index by name.
+     */
+    attrIndex(name: string): number;
 
-declare namespace StateInline {
-    interface Scanned {
-        can_open: boolean;
-        can_close: boolean;
-        length: number;
-    }
+    /**
+     * Add `[name, value]` attribute to list. Init attrs if necessary
+     */
+    attrPush(attrData: [string, string]): void;
 
-    interface Delimiter {
-        marker: number;
-        length: number;
-        jump: number;
-        token: number;
-        end: number;
-        open: boolean;
-        close: boolean;
-    }
+    /**
+     * Set `name` attribute to `value`. Override old value if exists.
+     */
+    attrSet(name: string, value: string): void;
 
-    interface TokenMata {
-        delimiters: Delimiter[];
-    }
+    /**
+     * 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;
+}
+
+interface Scanned {
+    can_open: boolean;
+    can_close: boolean;
+    length: number;
+}
+
+interface Delimiter {
+    marker: number;
+    length: number;
+    jump: number;
+    token: number;
+    end: number;
+    open: boolean;
+    close: boolean;
+}
+
+interface TokenMeta {
+    delimiters: Delimiter[];
 }
 
 declare class StateInline {
@@ -473,7 +493,7 @@ declare class StateInline {
     env: any;
     md: MarkdownIt;
     tokens: Token[];
-    tokens_meta: Array<StateInline.TokenMata | null>;
+    tokens_meta: Array<TokenMeta | null>;
 
     pos: number;
     posMax: number;
@@ -490,7 +510,7 @@ declare class StateInline {
     /**
      * List of emphasis-like delimiters for current tag
      */
-    delimiters: StateInline.Delimiter[];
+    delimiters: Delimiter[];
 
     // Stack of delimiter lists for upper level tags
     // _prev_delimiters: StateInline.Delimiter[][];
@@ -504,7 +524,7 @@ declare class StateInline {
      * Push new token to "stream".
      * If pending text exists - flush it as text token
      */
-    push(type: string, tag: string, nesting: Token.Nesting): Token;
+    push(type: string, tag: string, nesting: Nesting): Token;
 
     /**
      * Scan a sequence of emphasis-like markers, and determine whether
@@ -513,34 +533,22 @@ declare class StateInline {
      * @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): StateInline.Scanned;
+    scanDelims(start: number, canSplitWord: boolean): Scanned;
 
     Token: typeof Token;
 }
 
 declare function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;
 
-declare namespace parseLinkDestination {
-    interface ParseResult {
-        ok: boolean;
-        pos: number;
-        lines: number;
-        str: string;
-    }
-}
-
-declare function parseLinkDestination(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
-
 declare function parseLinkTitle(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
 
-interface Helpers {
-    parseLinkLabel: typeof parseLinkLabel;
-    parseLinkDestination: typeof parseLinkDestination;
-    parseLinkTitle: typeof parseLinkTitle;
+declare const helpers_parseLinkDestination: typeof parseLinkDestination;
+declare const helpers_parseLinkLabel: typeof parseLinkLabel;
+declare const helpers_parseLinkTitle: typeof parseLinkTitle;
+declare namespace helpers {
+  export { helpers_parseLinkDestination as parseLinkDestination, helpers_parseLinkLabel as parseLinkLabel, helpers_parseLinkTitle as parseLinkTitle };
 }
 
-declare const helpers: Helpers;
-
 declare namespace Ruler {
     interface RuleOptions {
         /**
@@ -707,9 +715,7 @@ declare class Ruler<T> {
     getRules(chainName: string): T[];
 }
 
-declare namespace StateBlock {
-    type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
-}
+type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
 
 declare class StateBlock {
     constructor(src: string, md: MarkdownIt, env: any, tokens: Token[]);
@@ -791,7 +797,7 @@ declare class StateBlock {
      * can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
      * used in lists to determine if they interrupt a paragraph
      */
-    parentType: StateBlock.ParentType;
+    parentType: ParentType;
 
     level: number;
 
@@ -803,7 +809,7 @@ declare class StateBlock {
     /**
      * Push new token to "stream".
      */
-    push(type: string, tag: string, nesting: Token.Nesting): Token;
+    push(type: string, tag: string, nesting: Nesting): Token;
 
     isEmpty(line: number): boolean;
 
@@ -837,15 +843,13 @@ declare class StateBlock {
     Token: typeof Token;
 }
 
-declare namespace ParserBlock {
-    type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
-}
+type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
 
 declare class ParserBlock {
     /**
      * [[Ruler]] instance. Keep configuration of block rules.
      */
-    ruler: Ruler<ParserBlock.RuleBlock>;
+    ruler: Ruler<RuleBlock>;
 
     /**
      * Generate tokens for input range
@@ -876,12 +880,10 @@ declare class StateCore {
     Token: typeof Token;
 }
 
-declare namespace Core {
-    type RuleCore = (state: StateCore) => void;
-}
+type RuleCore = (state: StateCore) => void;
 
 declare class Core {
-    ruler: Ruler<Core.RuleCore>;
+    ruler: Ruler<RuleCore>;
 
     /**
      * Executes core chain rules.
@@ -891,22 +893,20 @@ declare class Core {
     State: typeof StateCore;
 }
 
-declare namespace ParserInline {
-    type RuleInline = (state: StateInline, silent: boolean) => boolean;
-    type RuleInline2 = (state: StateInline) => boolean;
-}
+type RuleInline = (state: StateInline, silent: boolean) => boolean;
+type RuleInline2 = (state: StateInline) => boolean;
 
 declare class ParserInline {
     /**
      * [[Ruler]] instance. Keep configuration of inline rules.
      */
-    ruler: Ruler<ParserInline.RuleInline>;
+    ruler: Ruler<RuleInline>;
 
     /**
      * [[Ruler]] instance. Second ruler used for post-processing
      * (e.g. in emphasis-like rules).
      */
-    ruler2: Ruler<ParserInline.RuleInline2>;
+    ruler2: Ruler<RuleInline2>;
 
     /**
      * Skip single token by running all rules in validation mode;
@@ -927,21 +927,19 @@ declare class ParserInline {
     State: typeof StateInline;
 }
 
-declare namespace Renderer {
-    type RenderRule = (tokens: Token[], idx: number, options: MarkdownIt.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;
-    }
+type RenderRule = (tokens: Token[], idx: number, options: Options$2, 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 {
@@ -971,7 +969,7 @@ declare class Renderer {
      * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
      * for more details and examples.
      */
-    rules: Renderer.RenderRuleRecord;
+    rules: RenderRuleRecord;
 
     /**
      * Render token attributes to string.
@@ -986,7 +984,7 @@ declare class Renderer {
      * @param idx token index to render
      * @param options params of parser instance
      */
-    renderToken(tokens: Token[], idx: number, options: MarkdownIt.Options): string;
+    renderToken(tokens: Token[], idx: number, options: Options$2): string;
 
     /**
      * The same as [[Renderer.render]], but for single token of `inline` type.
@@ -995,7 +993,7 @@ declare class Renderer {
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
-    renderInline(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+    renderInline(tokens: Token[], options: Options$2, env: any): string;
 
     /**
      * Special kludge for image `alt` attributes to conform CommonMark spec.
@@ -1006,7 +1004,7 @@ declare class Renderer {
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
-    renderInlineAsText(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+    renderInlineAsText(tokens: Token[], options: Options$2, env: any): string;
 
     /**
      * Takes token stream and generates HTML. Probably, you will never need to call
@@ -1016,101 +1014,97 @@ declare class Renderer {
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
-    render(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+    render(tokens: Token[], options: Options$2, env: any): string;
 }
 
-interface MarkdownItConstructor {
-    new(): MarkdownIt;
-    new(presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
-    new(options: MarkdownIt.Options): MarkdownIt;
-    (): MarkdownIt;
-    (presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
-    (options: MarkdownIt.Options): MarkdownIt;
-}
-
-declare namespace MarkdownIt {
-    type Token = __token;
+/**
+ * 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$2 {
     /**
-     * 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.
+     * 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
      */
-    type PresetName = "default" | "zero" | "commonmark";
+    html?: boolean | undefined;
 
-    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 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;
 
-        /**
-         * 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;
 
-        /**
-         * 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 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;
 
-        /**
-         * 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[];
 
-        /**
-         * 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;
+}
 
-        /**
-         * 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;
 
-    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$2): MarkdownIt;
+    new(options: Options$2): MarkdownIt;
+    (): MarkdownIt;
+    (presetName: PresetName, options?: Options$2): MarkdownIt;
+    (options: Options$2): MarkdownIt;
 }
 
 interface MarkdownIt {
@@ -1193,7 +1187,7 @@ interface MarkdownIt {
 
     readonly helpers: typeof helpers;
 
-    readonly options: MarkdownIt.Options;
+    readonly options: Options$2;
 
     /**
      * *chainable*
@@ -1214,7 +1208,7 @@ interface MarkdownIt {
      * it's best to create multiple instances and initialize each with separate
      * config.
      */
-    set(options: MarkdownIt.Options): this;
+    set(options: Options$2): this;
 
     /**
      * *chainable*, *internal*
@@ -1226,7 +1220,7 @@ interface MarkdownIt {
      * We strongly recommend to use presets instead of direct config loads. That
      * will give better compatibility with next versions.
      */
-    configure(presets: MarkdownIt.PresetName): this;
+    configure(presets: PresetName): this;
 
     /**
      * *chainable*
@@ -1274,9 +1268,9 @@ interface MarkdownIt {
      *             });
      * ```
      */
-    use(plugin: MarkdownIt.PluginSimple): this;
-    use<T = any>(plugin: MarkdownIt.PluginWithOptions<T>, options?: T): this;
-    use(plugin: MarkdownIt.PluginWithParams, ...params: any[]): this;
+    use(plugin: PluginSimple): this;
+    use<T = any>(plugin: PluginWithOptions<T>, options?: T): this;
+    use(plugin: PluginWithParams, ...params: any[]): this;
 
     /**
      * *internal*
@@ -1785,7 +1779,7 @@ interface TocPluginOptions {
      *
      * @default 'ul'
      */
-    listTag?: 'ul' | 'ol';
+    listTag?: 'ol' | 'ul';
     /**
      * The class for the TOC list
      *
@@ -1901,7 +1895,7 @@ type ThemeOptions = ThemeRegistrationAny | BuiltinTheme | {
     light: ThemeRegistrationAny | BuiltinTheme;
     dark: ThemeRegistrationAny | BuiltinTheme;
 };
-interface MarkdownOptions extends MarkdownIt.Options {
+interface MarkdownOptions extends Options$2 {
     /**
      * Setup markdown-it instance before applying plugins
      */
@@ -2091,7 +2085,7 @@ interface UserConfig<ThemeConfig = any> extends LocaleSpecificConfig<ThemeConfig
     /**
      * Options to pass on to `@vitejs/plugin-vue`
      */
-    vue?: Options$2;
+    vue?: Options$3;
     /**
      * Vite config
      */