vitepress 1.1.3 → 1.2.0

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$3 } from '@vitejs/plugin-vue';
+import { Options as Options$4 } from '@vitejs/plugin-vue';
 import { UseDarkOptions } from '@vueuse/core';
 import { TransformOptions } from 'stream';
 import { ThemeRegistrationAny, BuiltinTheme, LanguageInput, ShikiTransformer, Highlighter } from 'shiki';
@@ -132,7 +132,7 @@ declare enum ErrorLevel {
      */
     THROW = "throw"
 }
-declare type ErrorHandler = (error: Error, level: ErrorLevel) => void;
+declare type ErrorHandler$1 = (error: Error, level: ErrorLevel) => void;
 
 interface NSArgs {
     news: boolean;
@@ -147,7 +147,7 @@ interface SitemapStreamOptions extends TransformOptions {
     lastmodDateOnly?: boolean;
     xmlns?: NSArgs;
     xslUrl?: string;
-    errorHandler?: ErrorHandler;
+    errorHandler?: ErrorHandler$1;
 }
 
 interface SitemapItem {
@@ -168,82 +168,202 @@ interface SitemapItem {
     lastmodrealtime?: boolean;
 }
 
-declare const LinkifyIt: {
-    (
-        schemas?: LinkifyIt.SchemaRules | LinkifyIt.Options,
-        options?: LinkifyIt.Options,
-    ): LinkifyIt.LinkifyIt;
-    new(
-        schemas?: LinkifyIt.SchemaRules | LinkifyIt.Options,
-        options?: LinkifyIt.Options,
-    ): LinkifyIt.LinkifyIt;
-};
-
-declare namespace LinkifyIt {
-    type Validate = (text: string, pos: number, self: LinkifyIt) => number | boolean;
+type Validate = (text: string, pos: number, self: LinkifyIt) => number | boolean;
 
-    interface FullRule {
-        validate: string | RegExp | Validate;
-        normalize?: ((match: Match) => void) | undefined;
-    }
+interface FullRule {
+    validate: string | RegExp | Validate;
+    normalize?: ((match: Match) => void) | undefined;
+}
 
-    type Rule = string | FullRule;
+type Rule = string | FullRule;
 
-    interface SchemaRules {
-        [schema: string]: Rule;
-    }
+/**
+ * An object, where each key/value describes protocol/rule:
+ *
+ * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
+ *   for example). `linkify-it` makes sure that prefix is not preceded with
+ *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.
+ * - __value__ - rule to check tail after link prefix
+ *   - _String_ - just alias to existing rule
+ *   - _Object_
+ *     - _validate_ - validator function (should return matched length on success),
+ *       or `RegExp`.
+ *     - _normalize_ - optional function to normalize text & url of matched result
+ *       (for example, for `@twitter` mentions).
+ */
+interface SchemaRules {
+    [schema: string]: Rule;
+}
 
-    interface Options {
-        fuzzyLink?: boolean | undefined;
-        fuzzyIP?: boolean | undefined;
-        fuzzyEmail?: boolean | undefined;
-    }
+interface Options$3 {
+    /**
+     * recognize URL-s without `http(s):` prefix. Default `true`.
+     */
+    fuzzyLink?: boolean | undefined;
+    /**
+     *  allow IPs in fuzzy links above. Can conflict with some texts
+     *  like version numbers. Default `false`.
+     */
+    fuzzyIP?: boolean | undefined;
+    /**
+     * recognize emails without `mailto:` prefix. Default `true`.
+     */
+    fuzzyEmail?: boolean | undefined;
+}
 
-    interface Match {
-        index: number;
-        lastIndex: number;
-        raw: string;
-        schema: string;
-        text: string;
-        url: string;
-    }
+/**
+ * Match result. Single element of array, returned by {@link LinkifyIt#match}.
+ */
+declare class Match {
+    constructor(self: LinkifyIt, shift: number);
 
-    interface LinkifyIt {
-        // Use overloads to provide contextual typing to `FullRule.normalize`, which is ambiguous with string.normalize
-        // This appears unneeded to the unified-signatures lint rule.
-        add(schema: string, rule: string): LinkifyIt;
-        // tslint:disable-next-line: unified-signatures
-        add(schema: string, rule: FullRule | null): LinkifyIt;
-        match(text: string): Match[] | null;
-        normalize(raw: string): string;
-        pretest(text: string): boolean;
-        set(options: Options): LinkifyIt;
-        test(text: string): boolean;
-        testSchemaAt(text: string, schemaName: string, pos: number): number;
-        tlds(list: string | string[], keepOld?: boolean): LinkifyIt;
-        re: {
-            [key: string]: RegExp;
-        };
-    }
+    /**
+     * First position of matched string.
+     */
+    index: number;
+    /**
+     * Next position after matched string.
+     */
+    lastIndex: number;
+    /**
+     * Matched string.
+     */
+    raw: string;
+    /**
+     * Prefix (protocol) for matched string.
+     */
+    schema: string;
+    /**
+     * Normalized text of matched string.
+     */
+    text: string;
+    /**
+     * Normalized url of matched string.
+     */
+    url: string;
 }
 
-declare namespace encode {
-    const defaultChars: string;
-    const componentChars: string;
-}
-declare function encode(str: string, exclude?: string, keepEscaped?: boolean): string;
 
-declare namespace decode {
-    const defaultChars: string;
-    const componentChars: string;
+declare class LinkifyIt {
+    /**
+     * new LinkifyIt(schemas, options)
+     * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)
+     * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
+     *
+     * Creates new linkifier instance with optional additional schemas.
+     * Can be called without `new` keyword for convenience.
+     *
+     * By default understands:
+     *
+     * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
+     * - "fuzzy" links and emails (example.com, foo@bar.com).
+     */
+    constructor(schemas?: SchemaRules | Options$3, options?: Options$3);
+
+    // Use overloads to provide contextual typing to `FullRule.normalize`, which is ambiguous with string.normalize
+    /**
+     * Add new rule definition. See constructor description for details.
+     *
+     * @param schema rule name (fixed pattern prefix)
+     * @param definition schema definition
+     */
+    add(schema: string, definition: string): this;
+    add(schema: string, definition: FullRule | null): this;
+
+    /**
+     * Set recognition options for links without schema.
+     */
+    set(options: Options$3): this;
+
+    /**
+     * Searches linkifiable pattern and returns `true` on success or `false` on fail.
+     */
+    test(text: string): boolean;
+
+    /**
+     * Very quick check, that can give false positives. Returns true if link MAY BE
+     * can exists. Can be used for speed optimization, when you need to check that
+     * link NOT exists.
+     */
+    pretest(text: string): boolean;
+
+    /**
+     * Similar to {@link LinkifyIt#test} but checks only specific protocol tail exactly
+     * at given position. Returns length of found pattern (0 on fail).
+     *
+     * @param text text to scan
+     * @param schema rule (schema) name
+     * @param pos text offset to check from
+     */
+    testSchemaAt(text: string, schema: string, pos: number): number;
+
+    /**
+     * Returns array of found link descriptions or `null` on fail. We strongly
+     * recommend to use {@link LinkifyIt#test} first, for best speed.
+     */
+    match(text: string): Match[] | null;
+
+    /**
+     * Returns fully-formed (not fuzzy) link if it starts at the beginning
+     * of the string, and null otherwise.
+     */
+    matchAtStart(text: string): Match | null;
+
+    /**
+     * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)
+     * to avoid false positives. By default this algorythm used:
+     *
+     * - hostname with any 2-letter root zones are ok.
+     * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф
+     *   are ok.
+     * - encoded (`xn--...`) root zones are ok.
+     *
+     * If list is replaced, then exact match for 2-chars root zones will be checked.
+     *
+     * @param list list of tlds
+     * @param keepOld merge with current list if `true` (`false` by default)
+     */
+    tlds(list: string | string[], keepOld?: boolean): this;
+
+    /**
+     * Default normalizer (if schema does not define it's own).
+     */
+    normalize(match: Match): void;
+
+    /**
+     * Override to modify basic RegExp-s.
+     */
+    onCompile(): void;
+
+    re: {
+        [key: string]: RegExp;
+    };
 }
-declare function decode(input: string, exclude?: string): string;
 
-declare function parse(input: string, slashesDenoteHost?: boolean): Url;
+declare const decode: {
+    defaultChars: string;
+    componentChars: string;
+    /**
+     * Decode percent-encoded string.
+     */
+    (str: string, exclude?: string): string;
+};
 
-declare function format(url: Url): string;
+declare const encode: {
+    defaultChars: string;
+    componentChars: string;
+    /**
+     * Encode unsafe characters with percent-encoding, skipping already
+     * encoded sequences.
+     *
+     * @param str string to encode
+     * @param exclude list of characters to ignore (in addition to a-zA-Z0-9)
+     * @param keepEscaped don't encode '%' in a correct escape sequence (default: true)
+     */
+    (str: string, exclude?: string, keepEscaped?: boolean): string;
+};
 
-interface Url {
+declare class Url {
     protocol: string;
     slashes: string;
     auth: string;
@@ -252,50 +372,56 @@ interface Url {
     hash: string;
     search: string;
     pathname: string;
+
+    constructor();
+
+    parse(url: string, slashesDenoteHost?: boolean): this;
+    parseHost(host: string): void;
 }
 
+declare function parse(url: string | Url, slashesDenoteHost?: boolean): Url;
+
+declare function format(url: Omit<Url, "parse" | "parseHost">): string;
+
 type mdurl_Url = Url;
+declare const mdurl_Url: typeof Url;
 declare const mdurl_decode: typeof decode;
 declare const mdurl_encode: typeof encode;
 declare const mdurl_format: typeof format;
 declare const mdurl_parse: typeof parse;
 declare namespace mdurl {
-  export { type mdurl_Url as Url, mdurl_decode as decode, mdurl_encode as encode, mdurl_format as format, mdurl_parse as parse };
+  export { mdurl_Url as Url, mdurl_decode as decode, mdurl_encode as encode, mdurl_format as format, mdurl_parse as parse };
 }
 
-// import ucmicro from 'uc.micro';
+// import * as ucmicro from "uc.micro";
 
 declare const lib: {
     mdurl: typeof mdurl;
-    // ucmicro: typeof ucmicro;
+    ucmicro: any;
 };
 
 /**
  * Merge objects
  */
-declare function assign(target: any, ...sources: any[]): any;
+declare function assign(obj: any, ...from: 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 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.
- * Return a new array.
+ * Useful for some operations with tokens
  */
 declare function arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
 
@@ -310,9 +436,10 @@ 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.
+ *
+ * @see http://spec.commonmark.org/0.15/#ascii-punctuation-character
  */
 declare function isMdAsciiPunct(code: number): boolean;
 
@@ -324,7 +451,7 @@ declare function isPunctChar(ch: string): boolean;
 declare function escapeRE(str: string): string;
 
 /**
- * Hepler to unify [reference labels].
+ * Helper to unify [reference labels].
  */
 declare function normalizeReference(str: string): string;
 
@@ -348,23 +475,20 @@ 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;
-    }
+interface ParseLinkDestinationResult {
+    ok: boolean;
+    pos: number;
+    str: string;
 }
 
-declare function parseLinkDestination(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
+declare function parseLinkDestination(str: string, start: number, max: number): ParseLinkDestinationResult;
 
 type Nesting = 1 | 0 | -1;
 
-/**
- * Create new token and fill passed properties.
- */
 declare class Token {
+    /**
+     * Create new token and fill passed properties.
+     */
     constructor(type: string, tag: string, nesting: Nesting);
 
     /**
@@ -378,26 +502,26 @@ declare class Token {
     tag: string;
 
     /**
-     * HTML attributes. Format: `[[name1, value1], [name2, value2]]`
+     * HTML attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
      */
     attrs: Array<[string, string]> | null;
 
     /**
-     * Source map info. Format: `[line_begin, line_end]`
+     * 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 opening
+     * -  `0` means the tag is self-closing
      * - `-1` means the tag is closing
      */
     nesting: Nesting;
 
     /**
-     * nesting level, the same as `state.level`
+     * Nesting level, the same as `state.level`
      */
     level: number;
 
@@ -418,7 +542,9 @@ declare class Token {
     markup: string;
 
     /**
-     * Fence info 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;
 
@@ -445,7 +571,7 @@ declare class Token {
     attrIndex(name: string): number;
 
     /**
-     * Add `[name, value]` attribute to list. Init attrs if necessary
+     * Add `[ name, value ]` attribute to list. Init attrs if necessary
      */
     attrPush(attrData: [string, string]): void;
 
@@ -530,7 +656,7 @@ declare class StateInline {
      * 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 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;
@@ -540,7 +666,35 @@ declare class StateInline {
 
 declare function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;
 
-declare function parseLinkTitle(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
+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 const helpers_parseLinkDestination: typeof parseLinkDestination;
 declare const helpers_parseLinkLabel: typeof parseLinkLabel;
@@ -549,33 +703,31 @@ declare namespace helpers {
   export { helpers_parseLinkDestination as parseLinkDestination, helpers_parseLinkLabel as parseLinkLabel, helpers_parseLinkTitle as parseLinkTitle };
 }
 
-declare namespace Ruler {
-    interface RuleOptions {
-        /**
-         * array with names of "alternate" chains.
-         */
-        alt: string[];
-    }
+interface RuleOptions {
+    /**
+     * array with names of "alternate" chains.
+     */
+    alt: string[];
 }
 
 /**
- * class Ruler
- *
- * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
- * [[MarkdownIt#inline]] to manage sequences of functions (rules):
+ * 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)
- * - cacheing lists of active rules
+ * - caching lists of active rules
  *
  * You will not need use this class directly until write plugins. For simple
- * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
- * [[MarkdownIt.use]].
+ * 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.
@@ -596,11 +748,10 @@ declare class Ruler<T> {
      * @param fn new rule function.
      * @param options new rule options (not mandatory).
      */
-    at(name: string, fn: T, options?: Ruler.RuleOptions): void;
+    at(name: string, fn: T, options?: RuleOptions): void;
 
     /**
-     * Add new rule to chain before one with given name. See also
-     * [[Ruler.after]], [[Ruler.push]].
+     * Add new rule to chain before one with given name.
      *
      * ##### Example
      *
@@ -612,20 +763,17 @@ declare class Ruler<T> {
      * });
      * ```
      *
+     * @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?: Ruler.RuleOptions): void;
+    before(beforeName: string, ruleName: string, fn: T, options?: RuleOptions): void;
 
     /**
-     * Add new rule to chain after one with given name. See also
-     * [[Ruler.before]], [[Ruler.push]].
-     *
-     * ##### Options:
-     *
-     * - __alt__ - array with names of "alternate" chains.
+     * Add new rule to chain after one with given name.
      *
      * ##### Example
      *
@@ -637,20 +785,17 @@ declare class Ruler<T> {
      * });
      * ```
      *
+     * @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?: Ruler.RuleOptions): void;
+    after(afterName: string, ruleName: string, fn: T, options?: RuleOptions): void;
 
     /**
-     * Push new rule to the end of chain. See also
-     * [[Ruler.before]], [[Ruler.after]].
-     *
-     * ##### Options:
-     *
-     * - __alt__ - array with names of "alternate" chains.
+     * Push new rule to the end of chain.
      *
      * ##### Example
      *
@@ -662,11 +807,13 @@ declare class Ruler<T> {
      * });
      * ```
      *
+     * @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?: Ruler.RuleOptions): void;
+    push(ruleName: string, fn: T, options?: RuleOptions): void;
 
     /**
      * Enable rules with given names. If any rule name not found - throw Error.
@@ -674,7 +821,7 @@ declare class Ruler<T> {
      *
      * Returns list of found rule names (if no exception happened).
      *
-     * See also [[Ruler.disable]], [[Ruler.enableOnly]].
+     * @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.
@@ -685,12 +832,12 @@ declare class Ruler<T> {
      * 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 also [[Ruler.disable]], [[Ruler.enable]].
+     * @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): string[];
+    enableOnly(list: string | string[], ignoreInvalid?: boolean): void;
 
     /**
      * Disable rules with given names. If any rule name not found - throw Error.
@@ -698,7 +845,7 @@ declare class Ruler<T> {
      *
      * Returns list of found rule names (if no exception happened).
      *
-     * See also [[Ruler.enable]], [[Ruler.enableOnly]].
+     * @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.
@@ -794,18 +941,12 @@ declare class StateBlock {
     listIndent: number;
 
     /**
-     * can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
      * used in lists to determine if they interrupt a paragraph
      */
     parentType: ParentType;
 
     level: number;
 
-    /**
-     * renderer
-     */
-    result: string;
-
     /**
      * Push new token to "stream".
      */
@@ -847,7 +988,7 @@ type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent:
 
 declare class ParserBlock {
     /**
-     * [[Ruler]] instance. Keep configuration of block rules.
+     * {@link Ruler} instance. Keep configuration of block rules.
      */
     ruler: Ruler<RuleBlock>;
 
@@ -883,6 +1024,9 @@ declare class StateCore {
 type RuleCore = (state: StateCore) => void;
 
 declare class Core {
+    /**
+     * {@link Ruler} instance. Keep configuration of core rules.
+     */
     ruler: Ruler<RuleCore>;
 
     /**
@@ -898,12 +1042,12 @@ type RuleInline2 = (state: StateInline) => boolean;
 
 declare class ParserInline {
     /**
-     * [[Ruler]] instance. Keep configuration of inline rules.
+     * {@link Ruler} instance. Keep configuration of inline rules.
      */
     ruler: Ruler<RuleInline>;
 
     /**
-     * [[Ruler]] instance. Second ruler used for post-processing
+     * {@link Ruler} instance. Second ruler used for post-processing
      * (e.g. in emphasis-like rules).
      */
     ruler2: Ruler<RuleInline2>;
@@ -943,6 +1087,11 @@ interface RenderRuleRecord {
 }
 
 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.
      *
@@ -966,8 +1115,7 @@ declare class Renderer {
      * }
      * ```
      *
-     * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
-     * for more details and examples.
+     * @see https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs
      */
     rules: RenderRuleRecord;
 
@@ -978,7 +1126,7 @@ declare class Renderer {
 
     /**
      * Default token renderer. Can be overriden by custom function
-     * in [[Renderer#rules]].
+     * in {@link Renderer#rules}.
      *
      * @param tokens list of tokens
      * @param idx token index to render
@@ -987,9 +1135,9 @@ declare class Renderer {
     renderToken(tokens: Token[], idx: number, options: Options$2): string;
 
     /**
-     * The same as [[Renderer.render]], but for single token of `inline` type.
+     * The same as {@link Renderer.render}, but for single token of `inline` type.
      *
-     * @param tokens list on block tokens to renter
+     * @param tokens list of block tokens to render
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
@@ -1000,7 +1148,7 @@ declare class Renderer {
      * Don't try to use it! Spec requires to show `alt` content with stripped markup,
      * instead of simple escaping.
      *
-     * @param tokens list on block tokens to renter
+     * @param tokens list of block tokens to render
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
@@ -1010,7 +1158,7 @@ declare class Renderer {
      * Takes token stream and generates HTML. Probably, you will never need to call
      * this method directly.
      *
-     * @param tokens list on block tokens to renter
+     * @param tokens list of block tokens to render
      * @param options params of parser instance
      * @param env additional data from parsed input (references, for example)
      */
@@ -1109,28 +1257,28 @@ interface MarkdownItConstructor {
 
 interface MarkdownIt {
     /**
-     * Instance of [[ParserInline]]. You may need it to add new rules when
-     * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-     * [[MarkdownIt.enable]].
+     * 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 [[ParserBlock]]. You may need it to add new rules when
-     * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-     * [[MarkdownIt.enable]].
+     * 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 [[Core]] chain executor. You may need it to add new rules when
-     * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-     * [[MarkdownIt.enable]].
+     * 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 [[Renderer]]. Use it to modify output look. Or to add rendering
+     * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
      * rules for new token types, generated by plugins.
      *
      * ##### Example
@@ -1146,7 +1294,7 @@ interface MarkdownIt {
      * md.renderer.rules['my_token'] = myToken
      * ```
      *
-     * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
+     * See {@link Renderer} docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
      */
     readonly renderer: Renderer;
 
@@ -1155,7 +1303,7 @@ interface MarkdownIt {
      * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
      * rule.
      */
-    readonly linkify: LinkifyIt.LinkifyIt;
+    readonly linkify: LinkifyIt;
 
     /**
      * Link validation function. CommonMark allows too much in links. By default
@@ -1245,7 +1393,7 @@ interface MarkdownIt {
     /**
      * *chainable*
      *
-     * The same as [[MarkdownIt.enable]], but turn specified rules off.
+     * 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.
@@ -1295,7 +1443,7 @@ interface MarkdownIt {
      *
      * `env` can be used to inject additional metadata (`{}` by default).
      * But you will not need it with high probability. See also comment
-     * in [[MarkdownIt.parse]].
+     * in {@link MarkdownIt.parse}.
      *
      * @param src source string
      * @param env environment sandbox
@@ -1305,7 +1453,7 @@ interface MarkdownIt {
     /**
      * *internal*
      *
-     * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
+     * 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.
      *
@@ -1315,7 +1463,7 @@ interface MarkdownIt {
     parseInline(src: string, env: any): Token[];
 
     /**
-     * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
+     * Similar to {@link MarkdownIt.render} but for single paragraph content. Result
      * will NOT be wrapped into `<p>` tags.
      *
      * @param src source string
@@ -1953,6 +2101,11 @@ interface MarkdownOptions extends Options$2 {
      * Setup Shiki instance
      */
     shikiSetup?: (shiki: Highlighter) => void | Promise<void>;
+    /**
+     * The tooltip text for the copy button in code blocks
+     * @default 'Copy Code'
+     */
+    codeCopyButtonTitle?: string;
     /**
      * Options for `markdown-it-anchor`
      * @see https://github.com/valeriangalliat/markdown-it-anchor
@@ -2085,7 +2238,7 @@ interface UserConfig<ThemeConfig = any> extends LocaleSpecificConfig<ThemeConfig
     /**
      * Options to pass on to `@vitejs/plugin-vue`
      */
-    vue?: Options$3;
+    vue?: Options$4;
     /**
      * Vite config
      */
@@ -2378,73 +2531,61 @@ declare class Trouter<T = Function> {
 type Promisable<T> = Promise<T> | T;
 type ListenCallback = () => Promisable<void>;
 
-declare namespace polka {
-	export interface IError extends Error {
-		code?: number;
-		status?: number;
-		details?: any;
-	}
-
-	export type NextHandler = (err?: string | IError) => Promisable<void>;
-	export type ErrorHandler<T extends Request = Request> = (err: string | IError, req: T, res: Response, next: NextHandler) => Promisable<void>;
-	export type Middleware<T extends IncomingMessage = Request> = (req: T & Request, res: Response, next: NextHandler) => Promisable<void>;
-
-	export interface IOptions<T extends Request = Request> {
-		server?: Server;
-		onNoMatch?: Middleware<T>;
-		onError?: ErrorHandler<T>;
-	}
-
-	export type Response = ServerResponse;
-
-	export interface Request extends IncomingMessage {
-		url: string;
-		method: string;
-		originalUrl: string;
-		params: Record<string, string>;
-		path: string;
-		search: string;
-		query: Record<string,string>;
-		body?: any;
-		_decoded?: true;
-		_parsedUrl: ParsedURL;
-	}
-
-	export interface Polka<T extends Request = Request> extends Trouter<Middleware<T>> {
-		readonly server: Server;
-		readonly wares: Middleware<T>[];
-
-		readonly onError: ErrorHandler<T>;
-		readonly onNoMatch: Middleware<T>;
-
-		readonly handler: Middleware<T>;
-		parse: (req: IncomingMessage) => ParsedURL;
-
-		use(pattern: RegExp|string, ...handlers: (Polka<T> | Middleware<T>)[]): this;
-		use(...handlers: (Polka<T> | Middleware<T>)[]): this;
-
-		listen(port?: number, hostname?: string, backlog?: number, callback?: ListenCallback): this;
-		listen(port?: number, hostname?: string, callback?: ListenCallback): this;
-		listen(port?: number, backlog?: number, callback?: ListenCallback): this;
-		listen(port?: number, callback?: ListenCallback): this;
-		listen(path: string, backlog?: number, callback?: ListenCallback): this;
-		listen(path: string, callback?: ListenCallback): this;
-		listen(options: ListenOptions, callback?: ListenCallback): this;
-		listen(handle: any, backlog?: number, callback?: ListenCallback): this;
-		listen(handle: any, callback?: ListenCallback): this;
-	}
-}
-
-declare function polka<T extends polka.Request = polka.Request>(
-	options?: polka.IOptions<T>
-): polka.Polka<T>;
+interface IError extends Error {
+	code?: number;
+	status?: number;
+	details?: any;
+}
+
+type NextHandler = (err?: string | IError) => Promisable<void>;
+type ErrorHandler<T extends Request = Request> = (err: string | IError, req: T, res: Response, next: NextHandler) => Promisable<void>;
+type Middleware<T extends IncomingMessage = Request> = (req: T & Request, res: Response, next: NextHandler) => Promisable<void>;
+
+type Response = ServerResponse;
+
+interface Request extends IncomingMessage {
+	url: string;
+	method: string;
+	originalUrl: string;
+	params: Record<string, string>;
+	path: string;
+	search: string;
+	query: Record<string,string>;
+	body?: any;
+	_decoded?: true;
+	_parsedUrl: ParsedURL;
+}
+
+interface Polka<T extends Request = Request> extends Trouter<Middleware<T>> {
+	readonly server: Server;
+	readonly wares: Middleware<T>[];
+
+	readonly onError: ErrorHandler<T>;
+	readonly onNoMatch: Middleware<T>;
+
+	readonly handler: Middleware<T>;
+	parse: (req: IncomingMessage) => ParsedURL;
+
+	use(pattern: RegExp|string, ...handlers: (Polka<T> | Middleware<T>)[]): this;
+	use(...handlers: (Polka<T> | Middleware<T>)[]): this;
+
+	listen(port?: number, hostname?: string, backlog?: number, callback?: ListenCallback): this;
+	listen(port?: number, hostname?: string, callback?: ListenCallback): this;
+	listen(port?: number, backlog?: number, callback?: ListenCallback): this;
+	listen(port?: number, callback?: ListenCallback): this;
+	listen(path: string, backlog?: number, callback?: ListenCallback): this;
+	listen(path: string, callback?: ListenCallback): this;
+	listen(options: ListenOptions, callback?: ListenCallback): this;
+	listen(handle: any, backlog?: number, callback?: ListenCallback): this;
+	listen(handle: any, callback?: ListenCallback): this;
+}
 
 interface ServeOptions {
     base?: string;
     root?: string;
     port?: number;
 }
-declare function serve(options?: ServeOptions): Promise<polka.Polka<polka.Request>>;
+declare function serve(options?: ServeOptions): Promise<Polka<Request>>;
 
 declare function createServer(root?: string, serverOptions?: ServerOptions & {
     base?: string;