@delta-comic/ui 3.0.0-next.7 → 3.0.0-next.9

package/dist/index.d.ts

@@ -3,8 +3,6 @@ import { FormCheckbox, FormConfigure, FormDate, FormDateRange, FormNumber, FormP
 import { ImageProps } from "naive-ui";
 import { RouteLocationRaw } from "vue-router";
 import { DataState, UseInfiniteQueryReturn, UseQueryReturn } from "@pinia/colada";
-import MarkdownIt, { Options } from "markdown-it";
-
 //#region lib/components/DcAuthorIcon.vue.d.ts
 type __VLS_Props$17 = {
   author: {
@@ -37,7 +35,7 @@ declare const __VLS_export$27: <T extends PromiseLike<unknown>>(__VLS_props: Non
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$1: typeof __VLS_export$27;
-type __VLS_PrettifyLocal$9<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcAwait.vue.d.ts.map
+type __VLS_PrettifyLocal$9<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcCell.vue.d.ts
 type __VLS_Props$16 = {
@@ -57,7 +55,8 @@ type __VLS_Props$16 = {
   titleStyle?: string | Record<string, any>;
   arrowDirection?: 'up' | 'down' | 'left' | 'right';
   required?: boolean | 'auto';
-  clickable?: boolean | null; /** vue-router 路由跳转 */
+  clickable?: boolean | null;
+  /** vue-router 路由跳转 */
   to?: any;
   url?: string;
   replace?: boolean;
@@ -84,19 +83,14 @@ declare const __VLS_base$6: import("vue").DefineComponent<__VLS_Props$16, {}, {}
   click: (event: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props$16> & Readonly<{
   onClick?: ((event: MouseEvent) => any) | undefined;
-}>, {
-  border: boolean;
-  tag: string;
-  required: boolean | "auto";
-  clickable: boolean | null;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$26: __VLS_WithSlots$6<typeof __VLS_base$6, __VLS_Slots$6>;
 declare const _default$2: typeof __VLS_export$26;
 type __VLS_WithSlots$6<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcCell.vue.d.ts.map
+};
 //#endregion
 //#region lib/components/DcCellGroup.vue.d.ts
 type __VLS_Props$15 = {
@@ -115,7 +109,7 @@ type __VLS_WithSlots$5<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcCellGroup.vue.d.ts.map
+};
 //#endregion
 //#region lib/components/config-provider/context.d.ts
 type DcConfigTheme = 'dark' | 'light';
@@ -144,7 +138,7 @@ type __VLS_WithSlots$4<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcConfigProvider.vue.d.ts.map
+};
 //#endregion
 //#region lib/utils/layout.d.ts
 /**
@@ -232,7 +226,7 @@ declare const __VLS_export$23: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$5: typeof __VLS_export$23;
-type __VLS_PrettifyLocal$8<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcContent.vue.d.ts.map
+type __VLS_PrettifyLocal$8<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcImage.vue.d.ts
 type __VLS_Props$14 = {
@@ -994,24 +988,21 @@ declare const __VLS_base$3: import("vue").DefineComponent<__VLS_Props$14, {
     previewDisabled: boolean;
   }> | null>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  error: () => any;
   click: (e: Event) => any;
+  error: () => any;
   load: (...args: any[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props$14> & Readonly<{
-  onError?: (() => any) | undefined;
   onClick?: ((e: Event) => any) | undefined;
+  onError?: (() => any) | undefined;
   onLoad?: ((...args: any[]) => any) | undefined;
-}>, {
-  retryMax: number;
-  fetchpriority: "high" | "low" | "auto";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$22: __VLS_WithSlots$3<typeof __VLS_base$3, __VLS_Slots$3>;
 declare const _default$17: typeof __VLS_export$22;
 type __VLS_WithSlots$3<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcImage.vue.d.ts.map
+};
 //#endregion
 //#region lib/components/DcImagedIcon.vue.d.ts
 type __VLS_Props$13 = {
@@ -1032,8 +1023,11 @@ declare const __VLS_export$20: <T extends object>(__VLS_props: NonNullable<Await
     __VLS_PROPS_FALLBACK: infer P;
   } ? P : {});
   expose: (exposed: import("vue").ShallowUnwrapRef<{
-    /** 当前滚动位置 */readonly scrollTop: number | undefined; /** 滚动容器元素引用 */
-    readonly scrollParent: HTMLElement | undefined; /** 重置瀑布流列表 */
+    /** 当前滚动位置 */
+    readonly scrollTop: number | undefined;
+    /** 滚动容器元素引用 */
+    readonly scrollParent: HTMLElement | undefined;
+    /** 重置瀑布流列表 */
     reloadList(): Promise<void> | undefined;
   }>) => void;
   attrs: any;
@@ -1051,7 +1045,7 @@ declare const __VLS_export$20: <T extends object>(__VLS_props: NonNullable<Await
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$19: typeof __VLS_export$20;
-type __VLS_PrettifyLocal$7<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcList.vue.d.ts.map
+type __VLS_PrettifyLocal$7<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcLoading.vue.d.ts
 type __VLS_Props$12 = {
@@ -1066,30 +1060,1268 @@ declare var __VLS_1: {};
 type __VLS_Slots$2 = {} & {
   default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props$12, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$12> & Readonly<{}>, {
-  strokeWidth: string | number;
-  spinning: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props$12, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$12> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$19: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
 declare const _default$20: typeof __VLS_export$19;
 type __VLS_WithSlots$2<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcLoading.vue.d.ts.map
+};
+declare namespace index_d_exports$2 {
+  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 index_d_exports$1 {
+  export { Any, Cc, Cf, P$1 as P, S$1 as S, Z };
+}
+declare const Any: RegExp;
+declare const Cc: RegExp;
+declare const Cf: RegExp;
+declare const P$1: RegExp;
+declare const S$1: RegExp;
+declare const Z: RegExp;
+//#endregion
+//#region ../../node_modules/.pnpm/linkify-it@6.1.0/node_modules/linkify-it/build/index.d.ts
+/**
+ * @category types
+ */
+interface REBuilderOptions {
+  '---'?: boolean;
+  fuzzyIP?: boolean;
+  schema_names?: string[];
+  tlds?: string[];
+  urlAuth?: boolean;
+  maxLength?: number;
+}
+declare class REBuilder {
+  src_Any: string;
+  src_Cc: string;
+  src_Z: string;
+  src_P: string;
+  src_ZPCc: string;
+  src_ZCc: string;
+  cache: Record<string, RegExp | undefined>;
+  opts: REBuilderOptions;
+  constructor(opts?: REBuilderOptions);
+  set(opts?: REBuilderOptions): this;
+  escapeRE(str: string): string;
+  nestedPairRE(open: string, close: string, depth?: number): string;
+  get_text_separators(): RegExp;
+  get_pseudo_letter(): RegExp;
+  get_ipv4_addr(): RegExp;
+  get_ipv6_addr(): RegExp;
+  get_ipv6_url_host(): RegExp;
+  get_ipv6_mail_host(): RegExp;
+  get_auth(): RegExp;
+  get_port(): RegExp;
+  get_host_terminator(): RegExp;
+  get_path_terminator(): RegExp;
+  get_path(): RegExp;
+  get_mail_name(): RegExp;
+  get_xn(): RegExp;
+  get_tld(): RegExp;
+  get_domain_root(): RegExp;
+  get_domain(): RegExp;
+  get_url_host_port(): RegExp;
+  get_fuzzy_url_host_port(): RegExp;
+  get_mail_host(): RegExp;
+  get_fuzzy_mail_host(): RegExp;
+  get_path_extra(): RegExp;
+  get_fuzzy_mail_host_search(): RegExp;
+  get_fuzzy_link_search(): RegExp;
+  get_http_validator(): RegExp;
+  get_relative_proto_validator(): RegExp;
+  get_mail_name_validator(): RegExp;
+  get_mailto_validator(): RegExp;
+  get_schema_names(): RegExp;
+  get_schema_search(): RegExp;
+  get_schema_at_start(): RegExp;
+}
+/**
+ * Recognition options for schemaless links.
+ *
+ * @category types
+ */
+interface LinkifyOptions {
+  /** Recognize URLs without `http(s)://` prefix. Default `false`. */
+  fuzzyLink?: boolean;
+  /** Recognize emails without `mailto:` prefix. Default `true`. */
+  fuzzyEmail?: boolean;
+  /**
+   * Allow IPs in fuzzy links. Can conflict with some texts, like version
+   * numbers. Default `false`.
+   */
+  fuzzyIP?: boolean;
+  /**
+   * Terminate link with `---` if it is considered a long dash. Default `false`.
+   */
+  '---'?: boolean;
+  /** Allowed TLDs list for fuzzy links. Replaces the default list when set. */
+  tlds?: string[];
+  /** Recognize authentication data in URLs. Default `false`. */
+  urlAuth?: boolean;
+  /** Maximum link length. Default `10000`. */
+  maxLength?: number;
+}
+interface LinkifyConstructorOptions extends LinkifyOptions {
+  /** Custom regular expression builder. */
+  rebuilder?: REBuilder;
+}
+/**
+ * Custom schema definition.
+ *
+ * @category types
+ */
+interface SchemaOpts {
+  /**
+   * Checks text after the schema prefix. Should return matched tail length on
+   * success, or `0` on fail.
+   */
+  validate: (text: string, pos: number, self: LinkifyIt) => number;
+  /**
+   * Optional function to normalize `text` and `url` of matched result, for
+   * example for `@twitter` mentions.
+   */
+  normalize?: (match: Match, self: LinkifyIt) => void;
+}
+/**
+ * Match result returned by {@link LinkifyIt.match} and
+ * {@link LinkifyIt.matchAtStart}.
+ *
+ * @category types
+ */
+declare class Match {
+  /** Prefix (protocol) for matched string. Empty for fuzzy links. */
+  schema: string;
+  /** First position of matched string. */
+  index: number;
+  /** Next position after matched string. */
+  lastIndex: number;
+  /** Matched string. */
+  raw: string;
+  /** Normalized text of matched string. */
+  text: string;
+  /** Normalized URL of matched string. */
+  url: string;
+  constructor(text: string, schema: string, index: number, lastIndex: number);
+}
+/** Linkifier instance. */
+declare class LinkifyIt {
+  __opts__: Required<LinkifyOptions>;
+  private __schemas__;
+  re: REBuilder;
+  /**
+   * Creates new linkifier instance.
+   *
+   * By default understands:
+   *
+   * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
+   * - "fuzzy" emails (foo@bar.com).
+   *
+   * See {@link LinkifyConstructorOptions} for available options.
+   *
+   * @param options Recognition options.
+   *
+   * @example
+   * ```javascript
+   * import { LinkifyIt } from 'linkify-it'
+   *
+   * const linkify = new LinkifyIt({ fuzzyLink: true })
+   *
+   * linkify
+   *   .tlds(require('tlds'))       // Reload with full TLD list
+   *   .tlds('onion', true)         // Add unofficial `.onion` domain
+   *   .add('ftp:', null)           // Disable `ftp:` protocol
+   *   .set({ fuzzyIP: true })      // Enable IPs in fuzzy links
+   *
+   * console.log(linkify.test('Site github.com!')) // true
+   * console.log(linkify.match('Site github.com!'))
+   * ```
+   */
+  constructor(options?: LinkifyConstructorOptions);
+  /**
+   * Add new rule definition.
+   *
+   * `schema` is a 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.
+   *
+   * `definition` is a rule to check tail after link prefix. To disable an
+   * existing rule, pass `null`.
+   *
+   * @param schema Rule name (fixed pattern prefix).
+   * @param definition Schema definition, or `null` to disable the rule.
+   *
+   * See [twitter mentions example](https://github.com/markdown-it/linkify-it/blob/master/examples/twitter.mjs).
+   */
+  add(schema: string, definition?: SchemaOpts | null): this;
+  /**
+   * Set recognition options for links without schema.
+   *
+   * @param options Recognition options.
+   */
+  set(options?: LinkifyOptions): this;
+  /**
+   * Searches linkifiable pattern and returns `true` on success or `false` on fail.
+   *
+   * @param text Text to scan.
+   */
+  test(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.
+   *
+   * @param text Text to scan.
+   */
+  match(text: string): Match[] | null;
+  /**
+   * Returns fully-formed (not fuzzy) link if it starts at the beginning
+   * of the string, and null otherwise.
+   *
+   * @param text Text to scan.
+   */
+  matchAtStart(text: string): Match | null;
+  /**
+   * Load (or merge) new TLDs list. Those are used for fuzzy links (without
+   * prefix) to avoid false positives. By default this algorithm is 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 its own).
+   *
+   * @param match Match to normalize.
+   */
+  normalize(match: Match): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/markdown-it@15.0.0/node_modules/markdown-it/dist/markdown-it.d.mts
+//#endregion
+//#region src/types.d.ts
+/** @inline */
+interface Reference {
+  title: string;
+  href: string;
+}
+/**
+ * Shared environment passed through parsing and rendering.
+ *
+ * Plugins may use it to store arbitrary data.
+ */
+interface Env {
+  [key: string | symbol]: unknown;
+  references?: Record<string, Reference>;
+}
+/** Delimiter entry used by emphasis-like inline rules. */
+interface Delimiter {
+  /** Char code of the starting marker. */
+  marker: number;
+  /** Total length of this series of delimiters. */
+  length?: number;
+  /** A position of the token this delimiter corresponds to. */
+  token: number;
+  /**
+   * If this delimiter is matched as a valid opener, `end` will be
+   * equal to its position, otherwise it's `-1`.
+   */
+  end: number;
+  /** Whether this delimiter can open an emphasis. */
+  open: boolean;
+  /** Whether this delimiter can close an emphasis. */
+  close: boolean;
+  /** One delimiter represents two characters. */
+  jump?: number;
+}
+/**
+ * Options controlling Markdown parsing and rendering.
+ *
+ * @category Main
+ */
+interface MarkdownItOptions {
+  /** Enable HTML tags in source. */
+  html?: boolean;
+  /** Use '/' to close single tags (`<br />`). */
+  xhtmlOut?: boolean;
+  /** Convert '\n' in paragraphs into `<br>`. */
+  breaks?: boolean;
+  /** CSS language prefix for fenced blocks, used by external syntax highlighters. */
+  langPrefix?: string;
+  /** Autoconvert URL-like text to links. */
+  linkify?: boolean;
+  /**
+   * Enable language-neutral replacements and quotes beautification.
+   *
+   * See the [replacement rules](https://github.com/markdown-it/markdown-it/blob/master/src/rules_core/replacements.ts)
+   * for the full list.
+   */
+  typographer?: boolean;
+  /**
+   * Double + single quotes replacement pairs, when typographer is enabled
+   * and smartquotes are on. Can be either a string or an array.
+   *
+   * For example, use `'«»„“'` for Russian, `'„“‚‘'` for German, and
+   * `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
+   */
+  quotes?: string | string[];
+  /**
+   * Highlighter function. Should return escaped HTML, or an empty string if
+   * the source string was not changed and should be escaped externally.
+   * If the result starts with `<pre`, the internal wrapper is skipped.
+   *
+   * The highlighter is called by the default `fence` renderer rule. If needed,
+   * you can replace that renderer rule completely; see the
+   * [renderer source](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts).
+   *
+   * @example
+   * ```js
+   * import MarkdownIt from 'markdown-it'
+   * import hljs from 'highlight.js' // https://highlightjs.org
+   *
+   * const md = new MarkdownIt({
+   *   highlight: function (str, lang) {
+   *     if (lang && hljs.getLanguage(lang)) {
+   *       try {
+   *         return hljs.highlight(str, { language: lang }).value
+   *       } catch (__) {}
+   *     }
+   *
+   *     return '' // use external default escaping
+   *   }
+   * });
+   * ```
+   *
+   * @example
+   * Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):
+   * ```js
+   * import MarkdownIt from 'markdown-it'
+   * import hljs from 'highlight.js' // https://highlightjs.org
+   *
+   * const md = new MarkdownIt({
+   *   highlight: function (str, lang) {
+   *     if (lang && hljs.getLanguage(lang)) {
+   *       try {
+   *         return `<pre><code class="hljs">${hljs.highlight(str,
+   *           { language: lang, ignoreIllegals: true }).value}</code></pre>`
+   *       } catch (__) {}
+   *     }
+   *
+   *     return `<pre><code class="hljs">${md.utils.escapeHtml(str)}</code></pre>`
+   *   }
+   * });
+   * ```
+   */
+  highlight?: ((str: string, lang: string, attrs: string) => string) | null;
+  /** Internal protection against excessive recursion. */
+  maxNesting?: number;
+}
+declare namespace utils_d_exports {
+  export { arrayReplaceAt, asciiTrim, callable, escapeHtml, escapeRE, fromCodePoint, isMdAsciiPunct, isPunctChar, isPunctCharCode, isSpace, isValidEntityCode, isWhiteSpace, lib, normalizeReference, unescapeAll, unescapeMd };
+}
+/** @hidden */
+type ClassToWrap = new (...args: any[]) => object;
+/** Wraps a class so it can be called with or without `new`. */
+declare function callable<T extends ClassToWrap>(cls: T): T & ((...args: ConstructorParameters<T>) => InstanceType<T>);
+/**
+ * Returns a copy of a token array with the token at `pos` replaced by
+ * `newElements`. Used to transform token streams without modifying the
+ * original array.
+ */
+declare function arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
+/** Checks whether a code point can be decoded from a numeric HTML entity. */
+declare function isValidEntityCode(c: number): boolean;
+/**
+ * Converts a Unicode code point to a string, like `String.fromCodePoint()`,
+ * but does not throw for invalid input.
+ */
+declare function fromCodePoint(c: number): string;
+/** Decodes Markdown backslash escapes. */
+declare function unescapeMd(str: string): string;
+/**
+ * Decodes Markdown backslash escapes and HTML character references in link
+ * destinations, link titles, and fenced code info strings.
+ */
+declare function unescapeAll(str: string): string;
+/** Escapes HTML special characters in a string. */
+declare function escapeHtml(str: string): string;
+/** Escapes regular expression metacharacters in a string. */
+declare function escapeRE(str: string): string;
+/** Checks whether a character code is an ASCII space or tab. */
+declare function isSpace(code: number): boolean;
+/**
+ * Checks whether a character code is whitespace recognized by Markdown.
+ *
+ * Matches the Unicode `Zs` category or `\t`, `\f`, `\v`, `\r`, `\n`.
+ */
+declare function isWhiteSpace(code: number): boolean;
+/**
+ * Checks whether a character is Unicode punctuation or a symbol.
+ *
+ * Does not support astral characters.
+ */
+declare function isPunctChar(ch: string): boolean;
+/** Checks whether a Unicode code point is punctuation or a symbol. */
+declare function isPunctCharCode(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 characters in the
+ * ASCII range.
+ */
+declare function isMdAsciiPunct(ch: number): boolean;
+/** Normalizes `[reference labels]` for case-insensitive lookup. */
+declare function normalizeReference(str: string): string;
+/**
+ * "Light" `.trim()` for blocks (headings, paragraphs), where Unicode spaces
+ * should be preserved.
+ */
+declare function asciiTrim(str: string): string;
+/**
+ * Libraries commonly used by markdown-it and its plugins, re-exported to
+ * reduce duplicate dependencies in browser bundles.
+ */
+declare const lib: {
+  mdurl: typeof index_d_exports$2;
+  ucmicro: typeof index_d_exports$1;
+};
+//#endregion
+//#region src/token.d.ts
+/** @inline */
+type TokenNesting = -1 | 0 | 1;
+/** @inline */
+type TokenAttribute = [name: string, value: string | number];
+/**
+ * Represents one item in the parsed token stream, storing parsed data and
+ * providing helpers for managing HTML attributes.
+ */
+declare class Token {
+  /**
+   * Type of the token (string, e.g. "paragraph_open")
+   */
+  type: string;
+  /**
+   * html tag name, e.g. "p"
+   */
+  tag: string;
+  /** Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]` */
+  attrs: TokenAttribute[] | 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: TokenNesting;
+  /**
+   * 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;
+  /**
+   * Additional information:
+   *
+   * - 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: Record<string, unknown> | null;
+  /**
+   * 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;
+  constructor(type: string, tag: string, nesting: TokenNesting);
+  /**
+   * Search attribute index by name.
+   */
+  attrIndex(name: string): number;
+  /**
+   * Add `[ name, value ]` attribute to list. Init attrs if necessary
+   */
+  attrPush(attrData: TokenAttribute): void;
+  /**
+   * Set `name` attribute to `value`. Override old value if exists.
+   */
+  attrSet(name: string, value: string | number): void;
+  /**
+   * Get the value of attribute `name`, or null if it does not exist.
+   */
+  attrGet(name: string): string | number | 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 | number): void;
+}
+//#endregion
+//#region src/rules_inline/state_inline.d.ts
+/** @inline */
+interface ScannedDelimiters {
+  can_open: boolean;
+  can_close: boolean;
+  length: number;
+}
+/** @inline */
+type StateTokenMeta = Record<string, unknown> & {
+  delimiters?: Delimiter[];
+};
+/** Mutable state passed to inline rules while tokenizing inline content. */
+declare class StateInline {
+  src: string;
+  env: Env;
+  md: MarkdownIt;
+  tokens: Token[];
+  tokens_meta: Array<StateTokenMeta | undefined>;
+  pos: number;
+  posMax: number;
+  level: number;
+  pending: string;
+  pendingLevel: number;
+  cache: Record<number, number>;
+  backticks: Record<number, number>;
+  backticksScanned: boolean;
+  linkLevel: number;
+  delimiters: Delimiter[];
+  _prev_delimiters: Delimiter[][];
+  Token: typeof Token;
+  constructor(src: string, md: MarkdownIt, env: Env, outTokens: Token[]);
+  pushPending(): Token;
+  push(type: string, tag: string, nesting: -1 | 0 | 1): Token;
+  scanDelims(start: number, canSplitWord: boolean): ScannedDelimiters;
+}
+//#endregion
+//#region src/helpers/parse_link_label.d.ts
+/** Finds the end of a link or image label (`[label]`). */
+declare function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;
+//#endregion
+//#region src/helpers/parse_link_destination.d.ts
+/** Parses the destination in `[label](destination "title")`. */
+declare function parseLinkDestination(str: string, start: number, max: number): {
+  ok: boolean;
+  pos: number;
+  str: string;
+};
+//#endregion
+//#region src/helpers/parse_link_title.d.ts
+/** @inline */
+interface ParseLinkTitleResult {
+  ok: boolean;
+  can_continue: boolean;
+  pos: number;
+  str: string;
+  marker: number;
+}
+/**
+ * Parses the optional title in `[label](destination "title")` or
+ * `[label]: destination "title"`.
+ *
+ * `prev_state` continues a reference title on the next source line.
+ */
+declare function parseLinkTitle(str: string, start: number, max: number, prev_state?: ParseLinkTitleResult): ParseLinkTitleResult;
+declare namespace index_d_exports {
+  export { parseLinkDestination, parseLinkLabel, parseLinkTitle };
+}
+//#endregion
+//#region src/ruler.d.ts
+/** @inline */
+type RuleOptions = {
+  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)
+ * - cacheing 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<Args extends unknown[], Result> {
+  __rules__: Array<{
+    name: string;
+    enabled: boolean;
+    fn: (...args: Args) => Result;
+    alt: string[];
+  }>;
+  __cache__: Record<string, Array<(...args: Args) => Result>> | null;
+  __find__(name: string): number;
+  __compile__(): void;
+  /**
+   * Replace rule by name with new function & options. Throws error if name not
+   * found.
+   *
+   * @param name Rule name to replace.
+   * @param fn New rule function.
+   * @param options Rule options. `alt` is an array with names of "alternate"
+   * chains.
+   *
+   * @example Replace existing typographer replacement rule with new one
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * md.core.ruler.at('replacements', function replace(state) {
+   *   //...
+   * });
+   * ```
+   */
+  at(name: string, fn: (...args: Args) => Result, options?: RuleOptions): void;
+  /**
+   * Add new rule to chain before one with given name. See also
+   * {@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. `alt` is an array with names of "alternate"
+   * chains.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+   *   //...
+   * });
+   * ```
+   */
+  before(beforeName: string, ruleName: string, fn: (...args: Args) => Result, options?: RuleOptions): void;
+  /**
+   * Add new rule to chain after one with given name. See also
+   * {@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. `alt` is an array with names of "alternate"
+   * chains.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+   *   //...
+   * });
+   * ```
+   */
+  after(afterName: string, ruleName: string, fn: (...args: Args) => Result, options?: RuleOptions): void;
+  /**
+   * Push new rule to the end of chain. See also
+   * {@link Ruler.before}, {@link Ruler.after}.
+   *
+   * @param ruleName Name of added rule.
+   * @param fn Rule function.
+   * @param options Rule options. `alt` is an array with names of "alternate"
+   * chains.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * md.core.ruler.push('my_rule', function replace(state) {
+   *   //...
+   * });
+   * ```
+   */
+  push(ruleName: string, fn: (...args: Args) => Result, options?: RuleOptions): void;
+  /**
+   * Enable rules with given names. If any rule name not found - throw Error.
+   * Errors can be disabled by second param.
+   *
+   * See also {@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.
+   * @returns List of found rule names (if no exception happened).
+   */
+  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 also {@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.
+   *
+   * See also {@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.
+   * @returns List of found rule names (if no exception happened).
+   */
+  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): Array<(...args: Args) => Result>;
+}
+//#endregion
+//#region src/renderer.d.ts
+/** Function that renders a token at a given position in a token stream. */
+type RendererRule = (tokens: Token[], idx: number, options: Required<MarkdownItOptions>, env: Env | undefined, renderer: Renderer) => string;
+/**
+ * Generates HTML from parsed token stream. Each instance has independent
+ * copy of rules. Those can be rewritten with ease. Also, you can add new
+ * rules if you create plugin and adds new token types.
+ *
+ * Creates new renderer instance and fills {@link Renderer.rules} with defaults.
+ */
+declare class Renderer {
+  /**
+   * Contains render rules for tokens. Can be updated and extended.
+   *
+   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts)
+   * for more details and examples.
+   *
+   * @example Custom render rules
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * md.renderer.rules.strong_open  = function () { return '<b>'; };
+   * md.renderer.rules.strong_close = function () { return '</b>'; };
+   *
+   * const result = md.renderInline(...);
+   * ```
+   *
+   * @example Each rule is called as independent static function with fixed signature
+   * ```javascript
+   * function my_token_render(tokens, idx, options, env, renderer) {
+   *   // ...
+   *   return renderedHTML;
+   * }
+   * ```
+   */
+  rules: Record<string, RendererRule>;
+  /**
+   * Render token attributes to string.
+   */
+  renderAttrs(token: Pick<Token, 'attrs'>): 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: Required<MarkdownItOptions>): string;
+  /**
+   * The same as {@link Renderer.render}, but for single token of `inline` type.
+   *
+   * @param tokens List on block tokens to render.
+   * @param options Params of parser instance.
+   * @param env Additional data from parsed input (references, for example).
+   */
+  renderInline(tokens: Token[], options: Required<MarkdownItOptions>, env: Env | undefined): 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 on block tokens to render.
+   * @param options Params of parser instance.
+   * @param env Additional data from parsed input (references, for example).
+   */
+  renderInlineAsText(tokens: Token[], options: Required<MarkdownItOptions>, env: Env | undefined): string;
+  /**
+   * Takes token stream and generates HTML. Probably, you will never need to call
+   * this method directly.
+   *
+   * @param tokens List on block tokens to render.
+   * @param options Params of parser instance.
+   * @param env Additional data from parsed input (references, for example).
+   */
+  render(tokens: Token[], options: Required<MarkdownItOptions>, env?: Env): string;
+}
+//#endregion
+//#region src/rules_core/state_core.d.ts
+/** Mutable state passed through the core rules chain. */
+declare class StateCore {
+  src: string;
+  env: Env;
+  tokens: Token[];
+  inlineMode: boolean;
+  md: MarkdownIt;
+  Token: typeof Token;
+  constructor(src: string, md: MarkdownIt, env: Env);
+}
+//#endregion
+//#region src/parser_core.d.ts
+/**
+ * Top-level rules executor. Glues block/inline parsers and does intermediate
+ * transformations.
+ */
+declare class ParserCore {
+  /**
+   * {@link Ruler} instance. Keep configuration of core rules.
+   */
+  ruler: Ruler<[StateCore], void>;
+  State: typeof StateCore;
+  constructor();
+  /**
+   * Executes core chain rules.
+   */
+  process(state: StateCore): void;
+}
+//#endregion
+//#region src/rules_block/state_block.d.ts
+/** Mutable state passed to block rules while tokenizing a source document. */
+declare class StateBlock {
+  src: string;
+  md: MarkdownIt;
+  env: Env;
+  tokens: Token[];
+  bMarks: number[];
+  eMarks: number[];
+  tShift: number[];
+  sCount: number[];
+  bsCount: number[];
+  blkIndent: number;
+  line: number;
+  lineMax: number;
+  tight: boolean;
+  listIndent: number;
+  parentType: string;
+  level: number;
+  Token: typeof Token;
+  constructor(src: string, md: MarkdownIt, env: Env, tokens: Token[]);
+  push(type: string, tag: string, nesting: -1 | 0 | 1): Token;
+  isEmpty(line: number): boolean;
+  skipEmptyLines(from: number): number;
+  skipSpaces(pos: number): number;
+  skipSpacesBack(pos: number, min: number): number;
+  skipChars(pos: number, code: number): number;
+  skipCharsBack(pos: number, code: number, min: number): number;
+  getLines(begin: number, end: number, indent: number, keepLastLF: boolean): string;
+}
+//#endregion
+//#region src/parser_block.d.ts
+/**
+ * Block-level tokenizer.
+ */
+declare class ParserBlock {
+  /**
+   * {@link Ruler} instance. Keep configuration of block rules.
+   */
+  ruler: Ruler<[StateBlock, number, number, boolean], boolean>;
+  State: typeof StateBlock;
+  constructor();
+  tokenize(state: StateBlock, startLine: number, endLine: number): void;
+  /**
+   * Process input string and push block tokens into `outTokens`
+   */
+  parse(src: string, md: MarkdownIt, env: Env, outTokens: Token[]): void;
+}
+//#endregion
+//#region src/parser_inline.d.ts
+/**
+ * Tokenizes paragraph content.
+ */
+declare class ParserInline {
+  /**
+   * {@link Ruler} instance. Keep configuration of inline rules.
+   */
+  ruler: Ruler<[StateInline, boolean], boolean>;
+  /**
+   * {@link Ruler} instance. Second ruler used for post-processing
+   * (e.g. in emphasis-like rules).
+   */
+  ruler2: Ruler<[StateInline], void>;
+  State: typeof StateInline;
+  constructor();
+  skipToken(state: StateInline): void;
+  tokenize(state: StateInline): void;
+  /**
+   * Process input string and push inline tokens into `outTokens`
+   */
+  parse(str: string, md: MarkdownIt, env: Env, outTokens: Token[]): void;
+}
+//#endregion
+//#region src/markdownit.d.ts
+declare const config: {
+  default: {
+    options: Required<MarkdownItOptions>;
+    components: {
+      core: {};
+      block: {};
+      inline: {};
+    };
+  };
+  zero: {
+    options: Required<MarkdownItOptions>;
+    components: {
+      core: {
+        rules: string[];
+      };
+      block: {
+        rules: string[];
+      };
+      inline: {
+        rules: string[];
+        rules2: string[];
+      };
+    };
+  };
+  commonmark: {
+    options: Required<MarkdownItOptions>;
+    components: {
+      core: {
+        rules: string[];
+      };
+      block: {
+        rules: string[];
+      };
+      inline: {
+        rules: string[];
+        rules2: string[];
+      };
+    };
+  };
+};
+type MarkdownItPresetName = keyof typeof config;
+/**
+ * Parser preset containing options and enabled rules for each parser component.
+ */
+interface MarkdownItPreset {
+  options?: Required<MarkdownItOptions>;
+  components?: {
+    core?: {
+      rules?: string[];
+    };
+    block?: {
+      rules?: string[];
+    };
+    inline?: {
+      rules?: string[];
+      rules2?: string[];
+    };
+  };
+}
+/**
+ * Parses Markdown into tokens and renders them to HTML.
+ *
+ * @category Main
+ */
+declare class 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}.
+   */
+  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}.
+   */
+  block: ParserBlock;
+  /**
+   * Instance of {@link ParserCore} 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}.
+   */
+  core: ParserCore;
+  /**
+   * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
+   * rules for new token types, generated by plugins.
+   *
+   * See {@link Renderer} docs and
+   * [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts).
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * function myToken(tokens, idx, options, env, self) {
+   *   //...
+   *   return result;
+   * };
+   *
+   * md.renderer.rules['my_token'] = myToken
+   * ```
+   */
+  renderer: Renderer;
+  /**
+   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
+   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/src/rules_core/linkify.ts)
+   * rule.
+   */
+  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:
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * const md = new MarkdownIt()
+   *
+   * // 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;
+  /**
+   * Assorted utility functions, useful to write plugins. See details
+   * [here](https://github.com/markdown-it/markdown-it/blob/master/src/common/utils.ts).
+   */
+  utils: typeof utils_d_exports;
+  /**
+   * Link components parser functions, useful to write plugins. See details
+   * [here](https://github.com/markdown-it/markdown-it/blob/master/src/helpers).
+   */
+  helpers: typeof index_d_exports;
+  options: Required<MarkdownItOptions>;
+  constructor(...args: [] | [options: MarkdownItOptions] | [presetName: MarkdownItPresetName, options?: MarkdownItOptions]);
+  /**
+   * Set parser options (in the same format as in constructor). Probably, you
+   * will never need it, but you can change options after constructor call.
+   *
+   * __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.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   *
+   * const md = new MarkdownIt()
+   *   .set({ html: true, breaks: true })
+   *   .set({ typographer: true })
+   * ```
+   */
+  set(options: MarkdownItOptions): this;
+  /**
+   * Batch load of all options and compenent settings. This is internal method,
+   * and you probably will not need it. But if you will - see available presets
+   * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/src/presets)
+   *
+   * We strongly recommend to use presets instead of direct config loads. That
+   * will give better compatibility with next versions.
+   */
+  configure(presets: MarkdownItPresetName | MarkdownItPreset): this;
+  /**
+   * 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.
+   *
+   * @param list Rule name or list of rule names to enable.
+   * @param ignoreInvalid Set `true` to ignore errors when rule not found.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   *
+   * const md = new MarkdownIt()
+   *   .enable(['sub', 'sup'])
+   *   .disable('smartquotes')
+   * ```
+   */
+  enable(list: string | string[], ignoreInvalid?: boolean): this;
+  /**
+   * 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;
+  /**
+   * Load specified plugin with given params into current parser instance.
+   * It's just a sugar to call `plugin(md, params)` with curring.
+   *
+   * @example
+   * ```javascript
+   * import MarkdownIt from 'markdown-it'
+   * import iterator from 'markdown-it-for-inline'
+   *
+   * const md = new MarkdownIt()
+   *   .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
+   *     tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar')
+   *   })
+   * ```
+   */
+  use<Params extends unknown[]>(plugin: (md: this, ...params: Params) => void, ...params: Params): this;
+  /**
+   * Parse input string and return 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: Env): 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?: Env): string;
+  /**
+   * 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: Env): 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?: Env): string;
+  static Token: typeof Token;
+  static Ruler: typeof Ruler;
+  static Renderer: typeof Renderer;
+  static ParserCore: typeof ParserCore;
+  static StateCore: typeof StateCore;
+  static ParserBlock: typeof ParserBlock;
+  static StateBlock: typeof StateBlock;
+  static ParserInline: typeof ParserInline;
+  static StateInline: typeof StateInline;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Default package export.
+ *
+ * For backward compatibility, the {@link MarkdownIt} class is wrapped so
+ * legacy code can call it without `new`. New code should instantiate it as a
+ * regular class with `new`. The compatibility wrapper may be removed in a
+ * future release.
+ *
+ * @category Main
+ */
+declare const MarkdownItCallable: typeof MarkdownIt & ((...args: [] | [options: MarkdownItOptions] | [presetName: "default" | "zero" | "commonmark", options?: MarkdownItOptions | undefined]) => MarkdownIt);
 //#endregion
 //#region lib/components/DcMarkdown/index.vue.d.ts
 type __VLS_Props$11 = {
   markdown: string;
-  plugins?: Parameters<MarkdownIt['use']>[];
-  config?: Options;
-  env?: object;
+  plugins?: Parameters<InstanceType<typeof MarkdownItCallable>['use']>[];
+  config?: MarkdownItOptions;
+  env?: Env;
   isDarkMode?: boolean;
 } & StyleProps;
-declare const __VLS_export$18: import("vue").DefineComponent<__VLS_Props$11, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$11> & Readonly<{}>, {
-  plugins: Parameters<MarkdownIt["use"]>[];
-  config: Options;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$18: import("vue").DefineComponent<__VLS_Props$11, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$11> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default$21: typeof __VLS_export$18;
 //#endregion
 //#region lib/components/DcPullRefresh.vue.d.ts
@@ -1114,17 +2346,14 @@ declare const __VLS_base$1: import("vue").DefineComponent<__VLS_PublicProps$9, {
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps$9> & Readonly<{
   "onUpdate:refreshing"?: ((value: boolean) => any) | undefined;
   "onUpdate:pulling"?: ((value: boolean) => any) | undefined;
-}>, {
-  disabled: boolean;
-  pullDistance: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$17: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
 declare const _default$22: typeof __VLS_export$17;
 type __VLS_WithSlots$1<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcPullRefresh.vue.d.ts.map
+};
 //#endregion
 //#region ../../node_modules/.pnpm/tailwind-merge@3.6.0/node_modules/tailwind-merge/dist/types.d.ts
 /**
@@ -1159,7 +2388,7 @@ declare const __VLS_export$16: <T extends DataState<any, any, any>>(__VLS_props:
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$23: typeof __VLS_export$16;
-type __VLS_PrettifyLocal$6<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcState.vue.d.ts.map
+type __VLS_PrettifyLocal$6<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcTab.vue.d.ts
 declare const __VLS_export$15: <T extends {
@@ -1172,9 +2401,12 @@ declare const __VLS_export$15: <T extends {
      * 基于路由的name匹配
      */
     items: T[];
-    mode?: "replace" | "push"; /** 是否使用路由模式，为 false 时使用 v-model 控制选中项 */
-    router?: boolean; /** 标签宽度自适应内容 */
-    shrink?: boolean; /** 是否启用手势滑动切换 */
+    mode?: "replace" | "push";
+    /** 是否使用路由模式，为 false 时使用 v-model 控制选中项 */
+    router?: boolean;
+    /** 标签宽度自适应内容 */
+    shrink?: boolean;
+    /** 是否启用手势滑动切换 */
     swipeable?: boolean;
   } & StyleProps & {
     modelValue?: string;
@@ -1195,15 +2427,13 @@ declare const __VLS_export$15: <T extends {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$24: typeof __VLS_export$15;
-type __VLS_PrettifyLocal$5<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcTab.vue.d.ts.map
+type __VLS_PrettifyLocal$5<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcText.vue.d.ts
 type __VLS_Props$9 = {
   text?: string;
 } & StyleProps;
-declare const __VLS_export$14: import("vue").DefineComponent<__VLS_Props$9, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$9> & Readonly<{}>, {
-  text: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$14: import("vue").DefineComponent<__VLS_Props$9, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$9> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default$25: typeof __VLS_export$14;
 //#endregion
 //#region lib/components/DcToggleIcon.vue.d.ts
@@ -1223,14 +2453,14 @@ type __VLS_Slots = {} & {
   default?: (props: typeof __VLS_12) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps$8, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  click: (to: boolean) => any;
   "update:modelValue": (value: boolean) => any;
   change: (mode: boolean) => any;
+  click: (to: boolean) => any;
   longClick: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps$8> & Readonly<{
-  onClick?: ((to: boolean) => any) | undefined;
   "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
   onChange?: ((mode: boolean) => any) | undefined;
+  onClick?: ((to: boolean) => any) | undefined;
   onLongClick?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$13: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
@@ -1239,7 +2469,7 @@ type __VLS_WithSlots<T, S> = T & {
   new (): {
     $slots: S;
   };
-}; //# sourceMappingURL=DcToggleIcon.vue.d.ts.map
+};
 //#endregion
 //#region lib/components/DcVar.vue.d.ts
 declare const __VLS_export$12: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
@@ -1260,7 +2490,7 @@ declare const __VLS_export$12: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$27: typeof __VLS_export$12;
-type __VLS_PrettifyLocal$4<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcVar.vue.d.ts.map
+type __VLS_PrettifyLocal$4<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/DcWaterfall.vue.d.ts
 declare const __VLS_export$11: <T extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
@@ -1294,9 +2524,9 @@ declare const __VLS_export$11: <T extends object>(__VLS_props: NonNullable<Await
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$28: typeof __VLS_export$11;
-type __VLS_PrettifyLocal$3<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcWaterfall.vue.d.ts.map
+type __VLS_PrettifyLocal$3<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
-//#region ../../node_modules/.pnpm/vue-component-type-helpers@3.3.7/node_modules/vue-component-type-helpers/index.d.ts
+//#region ../../node_modules/.pnpm/vue-component-type-helpers@3.3.9/node_modules/vue-component-type-helpers/index.d.ts
 type ComponentProps<T> = T extends (new (...args: any) => {
   $props: infer P;
 }) ? NonNullable<P> : T extends ((props: infer P, ...args: any) => any) ? P : {};
@@ -1337,7 +2567,7 @@ declare const __VLS_export$10: <TKey extends EnvironmentKey, TComponent extends
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$6: typeof __VLS_export$10;
-type __VLS_PrettifyLocal$2<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcEnvironment.vue.d.ts.map
+type __VLS_PrettifyLocal$2<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/form/type.d.ts
 interface FormRowSlot<T extends FormConfigure, O extends (keyof T)[], K extends O[number]> {
@@ -1378,7 +2608,7 @@ declare const __VLS_export$9: <T extends FormConfigure, O extends (keyof T)[] =
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$7: typeof __VLS_export$9;
-type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcForm.vue.d.ts.map
+type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/form/components/DcFormCheckbox.vue.d.ts
 type __VLS_Props$7 = {
@@ -1445,7 +2675,7 @@ declare const __VLS_export$5: <T extends FormSingleConfigure>(__VLS_props: NonNu
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$11: typeof __VLS_export$5;
-type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {}; //# sourceMappingURL=DcFormItem.vue.d.ts.map
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
 //#endregion
 //#region lib/components/form/components/DcFormNumber.vue.d.ts
 type __VLS_Props$4 = {
@@ -1543,8 +2773,7 @@ declare const translateUi: (key: UiMessageKey, params?: UiMessageParams) => stri
 //#endregion
 //#region lib/message/download.d.ts
 interface DownloadMessageProgress extends DownloadMessageLoading {
-  /** 0~100 */
-  progress: number;
+  /** 0~100 */ progress: number;
 }
 interface DownloadMessageLoading {
   description: string;