themekit-js 1.1.0

package/dist/node/index.d.ts

@@ -0,0 +1,4588 @@
+/// <reference types="node" />
+import * as vite from 'vite';
+import { BuildOptions, Logger, UserConfig as UserConfig$1, ConfigEnv, ServerOptions } from 'vite';
+export { Plugin, loadEnv } from 'vite';
+import { UseDarkOptions } from '@vueuse/core';
+import { Options as Options$3 } from '@vitejs/plugin-vue';
+import { TransformOptions } from 'stream';
+import { ThemeRegistrationAny, BuiltinTheme, LanguageInput, ShikiTransformer, Highlighter } from 'shiki';
+import { Options as Options$2 } from 'minisearch';
+import { Ref as Ref$1, ComputedRef } from 'vue';
+import glob from 'fast-glob';
+import { Root } from 'postcss';
+import { IncomingMessage, ServerResponse } from 'http';
+import { Server, ListenOptions } from 'net';
+
+declare function build(root?: string, buildOptions?: BuildOptions & {
+    base?: string;
+    mpa?: string;
+}): Promise<void>;
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LooseRequired<T> = {
+    [P in keyof (T & Required<T>)]: T[P];
+};
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type Awaited<T> = T extends null | undefined ? T : T extends object & {
+    then(onfulfilled: infer F, ...args: infer _): any;
+} ? F extends (value: infer V, ...args: infer _) => any ? Awaited<V> : never : T;
+
+declare enum TrackOpTypes {
+    GET = "get",
+    HAS = "has",
+    ITERATE = "iterate"
+}
+declare enum TriggerOpTypes {
+    SET = "set",
+    ADD = "add",
+    DELETE = "delete",
+    CLEAR = "clear"
+}
+declare enum ReactiveFlags {
+    SKIP = "__v_skip",
+    IS_REACTIVE = "__v_isReactive",
+    IS_READONLY = "__v_isReadonly",
+    IS_SHALLOW = "__v_isShallow",
+    RAW = "__v_raw"
+}
+
+type Dep = Map<ReactiveEffect, number> & {
+    cleanup: () => void;
+    computed?: ComputedRefImpl<any>;
+};
+
+declare class EffectScope {
+    detached: boolean;
+    constructor(detached?: boolean);
+    get active(): boolean;
+    run<T>(fn: () => T): T | undefined;
+    stop(fromParent?: boolean): void;
+}
+
+type EffectScheduler = (...args: any[]) => any;
+type DebuggerEvent = {
+    effect: ReactiveEffect;
+} & DebuggerEventExtraInfo;
+type DebuggerEventExtraInfo = {
+    target: object;
+    type: TrackOpTypes | TriggerOpTypes;
+    key: any;
+    newValue?: any;
+    oldValue?: any;
+    oldTarget?: Map<any, any> | Set<any>;
+};
+declare class ReactiveEffect<T = any> {
+    fn: () => T;
+    trigger: () => void;
+    scheduler?: EffectScheduler | undefined;
+    active: boolean;
+    deps: Dep[];
+    onStop?: () => void;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    constructor(fn: () => T, trigger: () => void, scheduler?: EffectScheduler | undefined, scope?: EffectScope);
+    get dirty(): boolean;
+    set dirty(v: boolean);
+    run(): T;
+    stop(): void;
+}
+interface DebuggerOptions {
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+type ComputedGetter<T> = (oldValue?: T) => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+declare class ComputedRefImpl<T> {
+    private getter;
+    private readonly _setter;
+    dep?: Dep;
+    private _value;
+    readonly effect: ReactiveEffect<T>;
+    readonly __v_isRef = true;
+    readonly [ReactiveFlags.IS_READONLY]: boolean;
+    _cacheable: boolean;
+    /**
+     * Dev only
+     */
+    _warnRecursive?: boolean;
+    constructor(getter: ComputedGetter<T>, _setter: ComputedSetter<T>, isReadonly: boolean, isSSR: boolean);
+    get value(): T;
+    set value(newValue: T);
+    get _dirty(): boolean;
+    set _dirty(v: boolean);
+}
+
+type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ShallowReactiveMarker: unique symbol;
+
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+interface Ref<T = any> {
+    value: T;
+    /**
+     * Type differentiator only.
+     * We need this to be in public d.ts but don't want it to show up in IDE
+     * autocomplete, so we use a private Symbol instead.
+     */
+    [RefSymbol]: true;
+}
+declare const ShallowRefMarker: unique symbol;
+type ShallowRef$1<T = any> = Ref<T> & {
+    [ShallowRefMarker]?: true;
+};
+type BaseTypes = string | number | boolean;
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
+interface RefUnwrapBailTypes {
+}
+type ShallowUnwrapRef<T> = {
+    [K in keyof T]: DistrubuteRef<T[K]>;
+};
+type DistrubuteRef<T> = T extends Ref<infer V> ? V : T;
+type UnwrapRef<T> = T extends ShallowRef$1<infer V> ? V : T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Function | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+    [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
+    [K in keyof T]: UnwrapRefSimple<T[K]>;
+} : T extends object & {
+    [ShallowReactiveMarker]?: never;
+} ? {
+    [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
+} : T;
+
+type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
+type InternalSlots = {
+    [name: string]: Slot | undefined;
+};
+type Slots = Readonly<InternalSlots>;
+declare const SlotSymbol: unique symbol;
+type SlotsType<T extends Record<string, any> = Record<string, any>> = {
+    [SlotSymbol]?: T;
+};
+type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
+type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{
+    [K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? T[K] : Slot<T[K]>;
+}>>;
+type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
+
+interface SchedulerJob extends Function {
+    id?: number;
+    pre?: boolean;
+    active?: boolean;
+    computed?: boolean;
+    /**
+     * Indicates whether the effect is allowed to recursively trigger itself
+     * when managed by the scheduler.
+     *
+     * By default, a job cannot trigger itself because some built-in method calls,
+     * e.g. Array.prototype.push actually performs reads as well (#1740) which
+     * can lead to confusing infinite loops.
+     * The allowed cases are component update functions and watch callbacks.
+     * Component update functions may update child component props, which in turn
+     * trigger flush: "pre" watch callbacks that mutates state that the parent
+     * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+     * triggers itself again, it's likely intentional and it is the user's
+     * responsibility to perform recursive state mutation that eventually
+     * stabilizes (#1727).
+     */
+    allowRecurse?: boolean;
+    /**
+     * Attached by renderer.ts when setting up a component's render effect
+     * Used to obtain component information when reporting max recursive updates.
+     * dev only.
+     */
+    ownerInstance?: ComponentInternalInstance;
+}
+declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited<R>>;
+
+type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+type EmitsOptions = ObjectEmitsOptions | string[];
+type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
+    [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
+} : T extends ObjectEmitsOptions ? {
+    [K in `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : T[Uncapitalize<C>] extends null ? any[] : never) => any : never;
+} : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? {
+    [K in keyof E]: (...args: E[K]) => any;
+} : E;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
+    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void;
+}[Event]>;
+
+/**
+ * Custom properties added to component instances in any way and can be accessed through `this`
+ *
+ * @example
+ * Here is an example of adding a property `$router` to every component instance:
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { Router, createRouter } from 'vue-router'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface ComponentCustomProperties {
+ *     $router: Router
+ *   }
+ * }
+ *
+ * // effectively adding the router to every component instance
+ * const app = createApp({})
+ * const router = createRouter()
+ * app.config.globalProperties.$router = router
+ *
+ * const vm = app.mount('#app')
+ * // we can access the router from the instance
+ * vm.$router.push('/')
+ * ```
+ */
+interface ComponentCustomProperties {
+}
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
+    Mixin: MixinToOptionTypes<T>;
+}[T extends ComponentOptionsMixin ? 'Mixin' : never];
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType : UnionToIntersection<ExtractMixin<T>>;
+type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
+type EnsureNonVoid<T> = T extends void ? {} : T;
+type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    new (...args: any[]): T;
+};
+type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S>, I, S>;
+type ComponentPublicInstance<P = {}, // props type extracted from props option
+B = {}, // raw bindings returned from setup()
+D = {}, // return from data()
+C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}> = {
+    $: ComponentInternalInstance;
+    $data: D;
+    $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
+    $attrs: Data;
+    $refs: Data;
+    $slots: UnwrapSlotsType<S>;
+    $root: ComponentPublicInstance | null;
+    $parent: ComponentPublicInstance | null;
+    $emit: EmitFn<E>;
+    $el: any;
+    $options: Options & MergedComponentOptionsOverride;
+    $forceUpdate: () => void;
+    $nextTick: typeof nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R]) => any : (...args: any) => any, options?: WatchOptions): WatchStopHandle;
+} & IfAny<P, P, Omit<P, keyof ShallowUnwrapRef<B>>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>;
+
+interface SuspenseProps {
+    onResolve?: () => void;
+    onPending?: () => void;
+    onFallback?: () => void;
+    timeout?: string | number;
+    /**
+     * Allow suspense to be captured by parent suspense
+     *
+     * @default false
+     */
+    suspensible?: boolean;
+}
+declare const SuspenseImpl: {
+    name: string;
+    __isSuspense: boolean;
+    process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
+    hydrate: typeof hydrateSuspense;
+    create: typeof createSuspenseBoundary;
+    normalize: typeof normalizeSuspenseChildren;
+};
+declare const Suspense: {
+    new (): {
+        $props: VNodeProps & SuspenseProps;
+        $slots: {
+            default(): VNode[];
+            fallback(): VNode[];
+        };
+    };
+    __isSuspense: true;
+};
+interface SuspenseBoundary {
+    vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
+    parent: SuspenseBoundary | null;
+    parentComponent: ComponentInternalInstance | null;
+    namespace: ElementNamespace;
+    container: RendererElement;
+    hiddenContainer: RendererElement;
+    activeBranch: VNode | null;
+    pendingBranch: VNode | null;
+    deps: number;
+    pendingId: number;
+    timeout: number;
+    isInFallback: boolean;
+    isHydrating: boolean;
+    isUnmounted: boolean;
+    effects: Function[];
+    resolve(force?: boolean, sync?: boolean): void;
+    fallback(fallbackVNode: VNode): void;
+    move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void;
+    next(): RendererNode | null;
+    registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn): void;
+    unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
+}
+declare function createSuspenseBoundary(vnode: VNode, parentSuspense: SuspenseBoundary | null, parentComponent: ComponentInternalInstance | null, container: RendererElement, hiddenContainer: RendererElement, anchor: RendererNode | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, isHydrating?: boolean): SuspenseBoundary;
+declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function normalizeSuspenseChildren(vnode: VNode): void;
+
+type Hook<T = () => void> = T | T[];
+interface BaseTransitionProps<HostElement = RendererElement> {
+    mode?: 'in-out' | 'out-in' | 'default';
+    appear?: boolean;
+    persisted?: boolean;
+    onBeforeEnter?: Hook<(el: HostElement) => void>;
+    onEnter?: Hook<(el: HostElement, done: () => void) => void>;
+    onAfterEnter?: Hook<(el: HostElement) => void>;
+    onEnterCancelled?: Hook<(el: HostElement) => void>;
+    onBeforeLeave?: Hook<(el: HostElement) => void>;
+    onLeave?: Hook<(el: HostElement, done: () => void) => void>;
+    onAfterLeave?: Hook<(el: HostElement) => void>;
+    onLeaveCancelled?: Hook<(el: HostElement) => void>;
+    onBeforeAppear?: Hook<(el: HostElement) => void>;
+    onAppear?: Hook<(el: HostElement, done: () => void) => void>;
+    onAfterAppear?: Hook<(el: HostElement) => void>;
+    onAppearCancelled?: Hook<(el: HostElement) => void>;
+}
+interface TransitionHooks<HostElement = RendererElement> {
+    mode: BaseTransitionProps['mode'];
+    persisted: boolean;
+    beforeEnter(el: HostElement): void;
+    enter(el: HostElement): void;
+    leave(el: HostElement, remove: () => void): void;
+    clone(vnode: VNode): TransitionHooks<HostElement>;
+    afterLeave?(): void;
+    delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void;
+    delayedLeave?(): void;
+}
+type ElementNamespace = 'svg' | 'mathml' | undefined;
+interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
+    patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, prevChildren?: VNode<HostNode, HostElement>[], parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, unmountChildren?: UnmountChildrenFn): void;
+    insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
+    remove(el: HostNode): void;
+    createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
+        [key: string]: any;
+    }) | null): HostElement;
+    createText(text: string): HostNode;
+    createComment(text: string): HostNode;
+    setText(node: HostNode, text: string): void;
+    setElementText(node: HostElement, text: string): void;
+    parentNode(node: HostNode): HostElement | null;
+    nextSibling(node: HostNode): HostNode | null;
+    querySelector?(selector: string): HostElement | null;
+    setScopeId?(el: HostElement, id: string): void;
+    cloneNode?(node: HostNode): HostNode;
+    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
+}
+interface RendererNode {
+    [key: string]: any;
+}
+interface RendererElement extends RendererNode {
+}
+interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
+    p: PatchFn;
+    um: UnmountFn;
+    r: RemoveFn;
+    m: MoveFn;
+    mt: MountComponentFn;
+    mc: MountChildrenFn;
+    pc: PatchChildrenFn;
+    pbc: PatchBlockChildrenFn;
+    n: NextFn;
+    o: RendererOptions<HostNode, HostElement>;
+}
+type PatchFn = (n1: VNode | null, // null means this is a mount
+n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
+type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
+type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
+type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
+type NextFn = (vnode: VNode) => RendererNode | null;
+type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
+type RemoveFn = (vnode: VNode) => void;
+type UnmountChildrenFn = (children: VNode[], parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean, start?: number) => void;
+type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+declare enum MoveType {
+    ENTER = 0,
+    LEAVE = 1,
+    REORDER = 2
+}
+type DebuggerHook = (e: DebuggerEvent) => void;
+type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
+
+type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
+type ComponentObjectPropsOptions<P = Data> = {
+    [K in keyof P]: Prop<P[K]> | null;
+};
+type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?(value: unknown, props: Data): boolean;
+}
+type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
+type PropConstructor<T = any> = {
+    new (...args: any[]): T & {};
+} | {
+    (): T;
+} | PropMethod<T>;
+type PropMethod<T, TConstructor = any> = [T] extends [
+    ((...args: any) => any) | undefined
+] ? {
+    new (): TConstructor;
+    (): T;
+    readonly prototype: TConstructor;
+} : never;
+type RequiredKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        required: true;
+    } | {
+        default: any;
+    } | BooleanConstructor | {
+        type: BooleanConstructor;
+    } ? T[K] extends {
+        default: undefined | (() => undefined);
+    } ? never : K : never;
+}[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type DefaultKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        default: any;
+    } | BooleanConstructor | {
+        type: BooleanConstructor;
+    } ? T[K] extends {
+        type: BooleanConstructor;
+        required: true;
+    } ? never : K : never;
+}[keyof T];
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+/**
+ * Extract prop types from a runtime props options object.
+ * The extracted types are **internal** - i.e. the resolved props received by
+ * the component.
+ * - Boolean props are always present
+ * - Props with default values are always present
+ *
+ * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
+ */
+type ExtractPropTypes<O> = {
+    [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>;
+} & {
+    [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>;
+};
+type ExtractDefaultPropTypes<O> = O extends object ? {
+    [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
+} : {};
+
+/**
+Runtime helper for applying directives to a vnode. Example usage:
+
+const comp = resolveComponent('comp')
+const foo = resolveDirective('foo')
+const bar = resolveDirective('bar')
+
+return withDirectives(h(comp), [
+  [foo, this.x],
+  [bar, this.y]
+])
+*/
+
+interface DirectiveBinding<V = any> {
+    instance: ComponentPublicInstance | null;
+    value: V;
+    oldValue: V | null;
+    arg?: string;
+    modifiers: DirectiveModifiers;
+    dir: ObjectDirective<any, V>;
+}
+type DirectiveHook<T = any, Prev = VNode<any, T> | null, V = any> = (el: T, binding: DirectiveBinding<V>, vnode: VNode<any, T>, prevVNode: Prev) => void;
+type SSRDirectiveHook = (binding: DirectiveBinding, vnode: VNode) => Data | undefined;
+interface ObjectDirective<T = any, V = any> {
+    created?: DirectiveHook<T, null, V>;
+    beforeMount?: DirectiveHook<T, null, V>;
+    mounted?: DirectiveHook<T, null, V>;
+    beforeUpdate?: DirectiveHook<T, VNode<any, T>, V>;
+    updated?: DirectiveHook<T, VNode<any, T>, V>;
+    beforeUnmount?: DirectiveHook<T, null, V>;
+    unmounted?: DirectiveHook<T, null, V>;
+    getSSRProps?: SSRDirectiveHook;
+    deep?: boolean;
+}
+type FunctionDirective<T = any, V = any> = DirectiveHook<T, any, V>;
+type Directive<T = any, V = any> = ObjectDirective<T, V> | FunctionDirective<T, V>;
+type DirectiveModifiers = Record<string, boolean>;
+
+declare enum DeprecationTypes$1 {
+    GLOBAL_MOUNT = "GLOBAL_MOUNT",
+    GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
+    GLOBAL_EXTEND = "GLOBAL_EXTEND",
+    GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE",
+    GLOBAL_SET = "GLOBAL_SET",
+    GLOBAL_DELETE = "GLOBAL_DELETE",
+    GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE",
+    GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL",
+    CONFIG_SILENT = "CONFIG_SILENT",
+    CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS",
+    CONFIG_KEY_CODES = "CONFIG_KEY_CODES",
+    CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP",
+    CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS",
+    CONFIG_WHITESPACE = "CONFIG_WHITESPACE",
+    CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS",
+    INSTANCE_SET = "INSTANCE_SET",
+    INSTANCE_DELETE = "INSTANCE_DELETE",
+    INSTANCE_DESTROY = "INSTANCE_DESTROY",
+    INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER",
+    INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS",
+    INSTANCE_CHILDREN = "INSTANCE_CHILDREN",
+    INSTANCE_LISTENERS = "INSTANCE_LISTENERS",
+    INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS",
+    INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE",
+    OPTIONS_DATA_FN = "OPTIONS_DATA_FN",
+    OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE",
+    OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY",
+    OPTIONS_DESTROYED = "OPTIONS_DESTROYED",
+    WATCH_ARRAY = "WATCH_ARRAY",
+    PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS",
+    V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER",
+    CUSTOM_DIR = "CUSTOM_DIR",
+    ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE",
+    ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION",
+    TRANSITION_CLASSES = "TRANSITION_CLASSES",
+    TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT",
+    COMPONENT_ASYNC = "COMPONENT_ASYNC",
+    COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL",
+    COMPONENT_V_MODEL = "COMPONENT_V_MODEL",
+    RENDER_FUNCTION = "RENDER_FUNCTION",
+    FILTERS = "FILTERS",
+    PRIVATE_APIS = "PRIVATE_APIS"
+}
+type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
+    MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
+};
+
+/**
+ * Interface for declaring custom options.
+ *
+ * @example
+ * ```ts
+ * declare module '@vue/runtime-core' {
+ *   interface ComponentCustomOptions {
+ *     beforeRouteUpdate?(
+ *       to: Route,
+ *       from: Route,
+ *       next: () => void
+ *     ): void
+ *   }
+ * }
+ * ```
+ */
+interface ComponentCustomOptions {
+}
+type RenderFunction = () => VNodeChild;
+interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II>, ComponentInternalOptions, ComponentCustomOptions {
+    setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+    name?: string;
+    template?: string | object;
+    render?: Function;
+    components?: Record<string, Component>;
+    directives?: Record<string, Directive>;
+    inheritAttrs?: boolean;
+    emits?: (E | EE[]) & ThisType<void>;
+    slots?: S;
+    expose?: string[];
+    serverPrefetch?(): void | Promise<any>;
+    compilerOptions?: RuntimeCompilerOptions;
+    call?: (this: unknown, ...args: unknown[]) => never;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    __defaults?: Defaults;
+}
+/**
+ * Subset of compiler options that makes sense for the runtime.
+ */
+interface RuntimeCompilerOptions {
+    isCustomElement?: (tag: string) => boolean;
+    whitespace?: 'preserve' | 'condense';
+    comments?: boolean;
+    delimiters?: [string, string];
+}
+type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, PE = Props & EmitsToProps<E>> = ComponentOptionsBase<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II, S> & {
+    props?: undefined;
+} & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, PE, {}, false, I, S>>;
+type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any, S extends SlotsType = any> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, string, S> & ThisType<CreateComponentPublicInstance<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>>>;
+type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any>;
+type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
+interface MethodOptions {
+    [key: string]: Function;
+}
+type ExtractComputedReturns<T extends any> = {
+    [key in keyof T]: T[key] extends {
+        get: (...args: any[]) => infer TReturn;
+    } ? TReturn : T[key] extends (...args: any[]) => infer TReturn ? TReturn : never;
+};
+type ObjectWatchOptionItem = {
+    handler: WatchCallback | string;
+} & WatchOptions;
+type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
+type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
+type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
+type ComponentProvideOptions = ObjectProvideOptions | Function;
+type ObjectProvideOptions = Record<string | symbol, unknown>;
+type ComponentInjectOptions = string[] | ObjectInjectOptions;
+type ObjectInjectOptions = Record<string | symbol, string | symbol | {
+    from?: string | symbol;
+    default?: unknown;
+}>;
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
+    [K in T[number]]?: unknown;
+} : T extends ObjectInjectOptions ? {
+    [K in keyof T]?: unknown;
+} : never;
+interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string> {
+    compatConfig?: CompatConfig;
+    [key: string]: any;
+    data?: (this: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
+    computed?: C;
+    methods?: M;
+    watch?: ComponentWatchOptions;
+    provide?: ComponentProvideOptions;
+    inject?: I | II[];
+    filters?: Record<string, Function>;
+    mixins?: Mixin[];
+    extends?: Extends;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    /** @deprecated use `beforeUnmount` instead */
+    beforeDestroy?(): void;
+    beforeUnmount?(): void;
+    /** @deprecated use `unmounted` instead */
+    destroyed?(): void;
+    unmounted?(): void;
+    renderTracked?: DebuggerHook;
+    renderTriggered?: DebuggerHook;
+    errorCaptured?: ErrorCapturedHook;
+    /**
+     * runtime compile only
+     * @deprecated use `compilerOptions.delimiters` instead.
+     */
+    delimiters?: [string, string];
+    /**
+     * #3468
+     *
+     * type-only, used to assist Mixin's type inference,
+     * typescript will try to simplify the inferred `Mixin` type,
+     * with the `__differentiator`, typescript won't be able to combine different mixins,
+     * because the `__differentiator` will be different
+     */
+    __differentiator?: keyof D | keyof C | keyof M;
+}
+type MergedHook<T = () => void> = T | T[];
+type MergedComponentOptionsOverride = {
+    beforeCreate?: MergedHook;
+    created?: MergedHook;
+    beforeMount?: MergedHook;
+    mounted?: MergedHook;
+    beforeUpdate?: MergedHook;
+    updated?: MergedHook;
+    activated?: MergedHook;
+    deactivated?: MergedHook;
+    /** @deprecated use `beforeUnmount` instead */
+    beforeDestroy?: MergedHook;
+    beforeUnmount?: MergedHook;
+    /** @deprecated use `unmounted` instead */
+    destroyed?: MergedHook;
+    unmounted?: MergedHook;
+    renderTracked?: MergedHook<DebuggerHook>;
+    renderTriggered?: MergedHook<DebuggerHook>;
+    errorCaptured?: MergedHook<ErrorCapturedHook>;
+};
+type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
+type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
+    P: P;
+    B: B;
+    D: D;
+    C: C;
+    M: M;
+    Defaults: Defaults;
+};
+
+interface InjectionKey<T> extends Symbol {
+}
+
+type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}> = ComponentPublicInstanceConstructor<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, true, {}, S>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S> & PP;
+
+interface App<HostElement = any> {
+    version: string;
+    config: AppConfig;
+    use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: Options): this;
+    use<Options>(plugin: Plugin<Options>, options: Options): this;
+    mixin(mixin: ComponentOptions): this;
+    component(name: string): Component | undefined;
+    component(name: string, component: Component | DefineComponent): this;
+    directive<T = any, V = any>(name: string): Directive<T, V> | undefined;
+    directive<T = any, V = any>(name: string, directive: Directive<T, V>): this;
+    mount(rootContainer: HostElement | string, isHydrate?: boolean, namespace?: boolean | ElementNamespace): ComponentPublicInstance;
+    unmount(): void;
+    provide<T>(key: InjectionKey<T> | string, value: T): this;
+    /**
+     * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
+     * to variables provided via `app.provide()`.
+     *
+     * @param fn - function to run with the app as active instance
+     */
+    runWithContext<T>(fn: () => T): T;
+    _uid: number;
+    _component: ConcreteComponent;
+    _props: Data | null;
+    _container: HostElement | null;
+    _context: AppContext;
+    _instance: ComponentInternalInstance | null;
+    /**
+     * v2 compat only
+     */
+    filter?(name: string): Function | undefined;
+    filter?(name: string, filter: Function): this;
+}
+type OptionMergeFunction = (to: unknown, from: unknown) => any;
+interface AppConfig {
+    readonly isNativeTag: (tag: string) => boolean;
+    performance: boolean;
+    optionMergeStrategies: Record<string, OptionMergeFunction>;
+    globalProperties: ComponentCustomProperties & Record<string, any>;
+    errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
+    warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
+    /**
+     * Options to pass to `@vue/compiler-dom`.
+     * Only supported in runtime compiler build.
+     */
+    compilerOptions: RuntimeCompilerOptions;
+    /**
+     * @deprecated use config.compilerOptions.isCustomElement
+     */
+    isCustomElement?: (tag: string) => boolean;
+    /**
+     * TODO document for 3.5
+     * Enable warnings for computed getters that recursively trigger itself.
+     */
+    warnRecursiveComputed?: boolean;
+}
+interface AppContext {
+    app: App;
+    config: AppConfig;
+    mixins: ComponentOptions[];
+    components: Record<string, Component>;
+    directives: Record<string, Directive>;
+    provides: Record<string | symbol, any>;
+}
+type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
+type ObjectPlugin<Options = any[]> = {
+    install: PluginInstallFunction<Options>;
+};
+type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
+type Plugin<Options = any[]> = FunctionPlugin<Options> | ObjectPlugin<Options>;
+
+type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
+interface TeleportProps {
+    to: string | RendererElement | null | undefined;
+    disabled?: boolean;
+}
+declare const TeleportImpl: {
+    name: string;
+    __isTeleport: boolean;
+    process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
+    remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, optimized: boolean, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: boolean): void;
+    move: typeof moveTeleport;
+    hydrate: typeof hydrateTeleport;
+};
+declare enum TeleportMoveTypes {
+    TARGET_CHANGE = 0,
+    TOGGLE = 1,// enable / disable
+    REORDER = 2
+}
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector }, }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare const Teleport: {
+    new (): {
+        $props: VNodeProps & TeleportProps;
+        $slots: {
+            default(): VNode[];
+        };
+    };
+    __isTeleport: true;
+};
+
+declare const Fragment: {
+    new (): {
+        $props: VNodeProps;
+    };
+    __isFragment: true;
+};
+declare const Text: unique symbol;
+declare const Comment: unique symbol;
+declare const Static: unique symbol;
+type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
+type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
+type VNodeNormalizedRefAtom = {
+    i: ComponentInternalInstance;
+    r: VNodeRef;
+    k?: string;
+    f?: boolean;
+};
+type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
+type VNodeMountHook = (vnode: VNode) => void;
+type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
+type VNodeProps = {
+    key?: string | number | symbol;
+    ref?: VNodeRef;
+    ref_for?: boolean;
+    ref_key?: string;
+    onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[];
+    onVnodeMounted?: VNodeMountHook | VNodeMountHook[];
+    onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[];
+    onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[];
+    onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
+    onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
+};
+type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
+type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
+type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
+    [key: string]: any;
+}> {
+    type: VNodeTypes;
+    props: (VNodeProps & ExtraProps) | null;
+    key: string | number | symbol | null;
+    ref: VNodeNormalizedRef | null;
+    /**
+     * SFC only. This is assigned on vnode creation using currentScopeId
+     * which is set alongside currentRenderingInstance.
+     */
+    scopeId: string | null;
+    children: VNodeNormalizedChildren;
+    component: ComponentInternalInstance | null;
+    dirs: DirectiveBinding[] | null;
+    transition: TransitionHooks<HostElement> | null;
+    el: HostNode | null;
+    anchor: HostNode | null;
+    target: HostElement | null;
+    targetAnchor: HostNode | null;
+    suspense: SuspenseBoundary | null;
+    shapeFlag: number;
+    patchFlag: number;
+    appContext: AppContext | null;
+}
+
+type Data = Record<string, unknown>;
+/**
+ * For extending allowed non-declared props on components in TSX
+ */
+interface ComponentCustomProps {
+}
+/**
+ * Default allowed non-declared props on component in TSX
+ */
+interface AllowedComponentProps {
+    class?: unknown;
+    style?: unknown;
+}
+interface ComponentInternalOptions {
+    /**
+     * Compat build only, for bailing out of certain compatibility behavior
+     */
+    __isBuiltIn?: boolean;
+    /**
+     * This one should be exposed so that devtools can make use of it
+     */
+    __file?: string;
+    /**
+     * name inferred from filename
+     */
+    __name?: string;
+}
+interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
+    (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
+    props?: ComponentPropsOptions<P>;
+    emits?: EE | (keyof EE)[];
+    slots?: IfAny<S, Slots, SlotsType<S>>;
+    inheritAttrs?: boolean;
+    displayName?: string;
+    compatConfig?: CompatConfig;
+}
+/**
+ * Concrete component type matches its actual value: it's either an options
+ * object, or a function. Use this where the code expects to work with actual
+ * values, e.g. checking if its a function or not. This is mostly for internal
+ * implementation code.
+ */
+type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
+/**
+ * A type used in public APIs where a component type is expected.
+ * The constructor type is an artificial type returned by defineComponent().
+ */
+type Component<Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<Props, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<Props>;
+
+type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
+    attrs: Data;
+    slots: UnwrapSlotsType<S>;
+    emit: EmitFn<E>;
+    expose: (exposed?: Record<string, any>) => void;
+} : never;
+/**
+ * We expose a subset of properties on the internal instance as they are
+ * useful for advanced external libraries and tools.
+ */
+interface ComponentInternalInstance {
+    uid: number;
+    type: ConcreteComponent;
+    parent: ComponentInternalInstance | null;
+    root: ComponentInternalInstance;
+    appContext: AppContext;
+    /**
+     * Vnode representing this component in its parent's vdom tree
+     */
+    vnode: VNode;
+    /**
+     * Root vnode of this component's own vdom tree
+     */
+    subTree: VNode;
+    /**
+     * Render effect instance
+     */
+    effect: ReactiveEffect;
+    /**
+     * Bound effect runner to be passed to schedulers
+     */
+    update: SchedulerJob;
+    proxy: ComponentPublicInstance | null;
+    exposed: Record<string, any> | null;
+    exposeProxy: Record<string, any> | null;
+    data: Data;
+    props: Data;
+    attrs: Data;
+    slots: InternalSlots;
+    refs: Data;
+    emit: EmitFn;
+    attrsProxy: Data | null;
+    slotsProxy: Slots | null;
+    isMounted: boolean;
+    isUnmounted: boolean;
+    isDeactivated: boolean;
+}
+type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
+type OnCleanup = (cleanupFn: () => void) => void;
+interface WatchOptionsBase extends DebuggerOptions {
+    flush?: 'pre' | 'post' | 'sync';
+}
+interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
+    immediate?: Immediate;
+    deep?: boolean;
+    once?: boolean;
+}
+type WatchStopHandle = () => void;
+
+/**
+ * Vue `<script setup>` compiler macro for declaring component props. The
+ * expected argument is the same as the component `props` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * // using Array syntax
+ * const props = defineProps(['foo', 'bar'])
+ * // using Object syntax
+ * const props = defineProps({
+ *   foo: String,
+ *   bar: {
+ *     type: Number,
+ *     required: true
+ *   }
+ * })
+ * ```
+ *
+ * Equivalent type-based declaration:
+ * ```ts
+ * // will be compiled into equivalent runtime declarations
+ * const props = defineProps<{
+ *   foo?: string
+ *   bar: number
+ * }>()
+ * ```
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{
+    [key in PropNames]?: any;
+}>>;
+declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
+declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
+type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
+    readonly [K in BKeys]-?: boolean;
+};
+type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's emitted
+ * events. The expected argument is the same as the component `emits` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * const emit = defineEmits(['change', 'update'])
+ * ```
+ *
+ * Example type-based declaration:
+ * ```ts
+ * const emit = defineEmits<{
+ *   // <eventName>: <expected arguments>
+ *   change: []
+ *   update: [value: string] // named tuple syntax
+ * }>()
+ *
+ * emit('change')
+ * emit('update', 1)
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ */
+declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
+declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
+declare function defineEmits<T extends ((...args: any[]) => any) | Record<string, any[]>>(): T extends (...args: any[]) => any ? T : ShortEmits<T>;
+type RecordToUnion<T extends Record<string, any>> = T[keyof T];
+type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{
+    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+}>>;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's exposed
+ * instance properties when it is accessed by a parent component via template
+ * refs.
+ *
+ * `<script setup>` components are closed by default - i.e. variables inside
+ * the `<script setup>` scope is not exposed to parent unless explicitly exposed
+ * via `defineExpose`.
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
+ */
+declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's additional
+ * options. This should be used only for options that cannot be expressed via
+ * Composition API - e.g. `inheritAttrs`.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
+ */
+declare function defineOptions<RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsWithoutProps<{}, RawBindings, D, C, M, Mixin, Extends> & {
+    emits?: undefined;
+    expose?: undefined;
+    slots?: undefined;
+}): void;
+declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
+type ModelRef<T, M extends string | number | symbol = string> = Ref<T> & [
+    ModelRef<T, M>,
+    Record<M, true | undefined>
+];
+type DefineModelOptions<T = any> = {
+    get?: (v: T) => any;
+    set?: (v: T) => any;
+};
+/**
+ * Vue `<script setup>` compiler macro for declaring a
+ * two-way binding prop that can be consumed via `v-model` from the parent
+ * component. This will declare a prop with the same name and a corresponding
+ * `update:propName` event.
+ *
+ * If the first argument is a string, it will be used as the prop name;
+ * Otherwise the prop name will default to "modelValue". In both cases, you
+ * can also pass an additional object which will be used as the prop's options.
+ *
+ * The returned ref behaves differently depending on whether the parent
+ * provided the corresponding v-model props or not:
+ * - If yes, the returned ref's value will always be in sync with the parent
+ *   prop.
+ * - If not, the returned ref will behave like a normal local ref.
+ *
+ * @example
+ * ```ts
+ * // default model (consumed via `v-model`)
+ * const modelValue = defineModel<string>()
+ * modelValue.value = "hello"
+ *
+ * // default model with options
+ * const modelValue = defineModel<string>({ required: true })
+ *
+ * // with specified name (consumed via `v-model:count`)
+ * const count = defineModel<number>('count')
+ * count.value++
+ *
+ * // with specified name and default value
+ * const count = defineModel<number>('count', { default: 0 })
+ * ```
+ */
+declare function defineModel<T, M extends string | number | symbol = string>(options: {
+    required: true;
+} & PropOptions<T> & DefineModelOptions<T>): ModelRef<T, M>;
+declare function defineModel<T, M extends string | number | symbol = string>(options: {
+    default: any;
+} & PropOptions<T> & DefineModelOptions<T>): ModelRef<T, M>;
+declare function defineModel<T, M extends string | number | symbol = string>(options?: PropOptions<T> & DefineModelOptions<T>): ModelRef<T | undefined, M>;
+declare function defineModel<T, M extends string | number | symbol = string>(name: string, options: {
+    required: true;
+} & PropOptions<T> & DefineModelOptions<T>): ModelRef<T, M>;
+declare function defineModel<T, M extends string | number | symbol = string>(name: string, options: {
+    default: any;
+} & PropOptions<T> & DefineModelOptions<T>): ModelRef<T, M>;
+declare function defineModel<T, M extends string | number | symbol = string>(name: string, options?: PropOptions<T> & DefineModelOptions<T>): ModelRef<T | undefined, M>;
+type NotUndefined<T> = T extends undefined ? never : T;
+type MappedOmit<T, K extends keyof any> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+};
+type InferDefaults<T> = {
+    [K in keyof T]?: InferDefault<T, T[K]>;
+};
+type NativeType = null | number | string | boolean | symbol | Function;
+type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
+type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = Readonly<MappedOmit<T, keyof Defaults>> & {
+    readonly [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? T[K] : NotUndefined<T[K]> : never;
+} & {
+    readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
+};
+/**
+ * Vue `<script setup>` compiler macro for providing props default values when
+ * using type-based `defineProps` declaration.
+ *
+ * Example usage:
+ * ```ts
+ * withDefaults(defineProps<{
+ *   size?: number
+ *   labels?: string[]
+ * }>(), {
+ *   size: 3,
+ *   labels: () => ['default label']
+ * })
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the output
+ * and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
+ */
+declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
+
+declare module '@vue/reactivity' {
+    interface RefUnwrapBailTypes {
+        runtimeCoreBailTypes: VNode | {
+            $: ComponentInternalInstance;
+        };
+    }
+}
+// Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+type _defineProps = typeof defineProps
+type _defineEmits = typeof defineEmits
+type _defineExpose = typeof defineExpose
+type _defineOptions = typeof defineOptions
+type _defineSlots = typeof defineSlots
+type _defineModel = typeof defineModel
+type _withDefaults = typeof withDefaults
+
+declare global {
+  const defineProps: _defineProps
+  const defineEmits: _defineEmits
+  const defineExpose: _defineExpose
+  const defineOptions: _defineOptions
+  const defineSlots: _defineSlots
+  const defineModel: _defineModel
+  const withDefaults: _withDefaults
+}
+
+type SSRContext = {
+    [key: string]: any;
+    teleports?: Record<string, string>;
+};
+
+declare namespace Token {
+    type Nesting = 1 | 0 | -1;
+}
+
+/**
+ * Create new token and fill passed properties.
+ */
+declare class Token {
+    constructor(type: string, tag: string, nesting: Token.Nesting);
+
+    /**
+     * Type of the token, e.g. "paragraph_open"
+     */
+    type: string;
+
+    /**
+     * HTML tag name, e.g. "p"
+     */
+    tag: string;
+
+    /**
+     * HTML attributes. Format: `[[name1, value1], [name2, value2]]`
+     */
+    attrs: Array<[string, string]> | null;
+
+    /**
+     * Source map info. Format: `[line_begin, line_end]`
+     */
+    map: [number, number] | null;
+
+    /**
+     * Level change (number in {-1, 0, 1} set), where:
+     *
+     * - `1` means the tag is opening
+     * - `0` means the tag is self-closing
+     * - `-1` means the tag is closing
+     */
+    nesting: 1 | 0 | -1;
+
+    /**
+     * nesting level, the same as `state.level`
+     */
+    level: number;
+
+    /**
+     * An array of child nodes (inline and img tokens)
+     */
+    children: Token[] | null;
+
+    /**
+     * In a case of self-closing tag (code, html, fence, etc.),
+     * it has contents of this tag.
+     */
+    content: string;
+
+    /**
+     * '*' or '_' for emphasis, fence string for fence, etc.
+     */
+    markup: string;
+
+    /**
+     * Fence info string
+     */
+    info: string;
+
+    /**
+     * A place for plugins to store an arbitrary data
+     */
+    meta: any;
+
+    /**
+     * True for block-level tokens, false for inline tokens.
+     * Used in renderer to calculate line breaks
+     */
+    block: boolean;
+
+    /**
+     * If it's true, ignore this element when rendering. Used for tight lists
+     * to hide paragraphs.
+     */
+    hidden: boolean;
+
+    /**
+     * Search attribute index by name.
+     */
+    attrIndex(name: string): number;
+
+    /**
+     * Add `[name, value]` attribute to list. Init attrs if necessary
+     */
+    attrPush(attrData: [string, string]): void;
+
+    /**
+     * Set `name` attribute to `value`. Override old value if exists.
+     */
+    attrSet(name: string, value: string): void;
+
+    /**
+     * Get the value of attribute `name`, or null if it does not exist.
+     */
+    attrGet(name: string): string | null;
+
+    /**
+     * Join value to existing attribute via space. Or create new attribute if not
+     * exists. Useful to operate with token classes.
+     */
+    attrJoin(name: string, value: string): void;
+}
+
+declare namespace __token {
+  export { Token as default };
+}
+
+declare const LinkifyIt: {
+    (
+        schemas?: LinkifyIt.SchemaRules | LinkifyIt.Options,
+        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;
+
+    interface FullRule {
+        validate: string | RegExp | Validate;
+        normalize?: ((match: Match) => void) | undefined;
+    }
+
+    type Rule = string | FullRule;
+
+    interface SchemaRules {
+        [schema: string]: Rule;
+    }
+
+    interface Options {
+        fuzzyLink?: boolean | undefined;
+        fuzzyIP?: boolean | undefined;
+        fuzzyEmail?: boolean | undefined;
+    }
+
+    interface Match {
+        index: number;
+        lastIndex: number;
+        raw: string;
+        schema: string;
+        text: string;
+        url: string;
+    }
+
+    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;
+        };
+    }
+}
+
+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 function decode(input: string, exclude?: string): string;
+
+declare function parse(input: string, slashesDenoteHost?: boolean): Url;
+
+declare function format(url: Url): string;
+
+interface Url {
+    protocol: string;
+    slashes: string;
+    auth: string;
+    port: string;
+    hostname: string;
+    hash: string;
+    search: string;
+    pathname: string;
+}
+
+type mdurl_Url = 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 };
+}
+
+// import ucmicro from 'uc.micro';
+
+interface Utils {
+    lib: {
+        mdurl: typeof mdurl;
+    };
+
+    /**
+     * Merge objects
+     */
+    assign(target: any, ...sources: any[]): any;
+
+    /**
+     * Check if the type is string or not
+     */
+    isString(obj: any): obj is string;
+
+    /**
+     * has own property
+     */
+    has(obj: any, key: keyof any): boolean;
+
+    unescapeMd(str: string): string;
+    unescapeAll(str: string): string;
+
+    isValidEntityCode(code: number): boolean;
+    fromCodePoint(code: number): string;
+    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.
+     */
+    arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
+
+    isSpace(code: number): boolean;
+
+    /**
+     * Zs (unicode class) || [\t\f\v\r\n]
+     */
+    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.
+     */
+    isMdAsciiPunct(code: number): boolean;
+
+    /**
+     * Currently without astral characters support.
+     */
+    isPunctChar(ch: string): boolean;
+
+    escapeRE(str: string): string;
+
+    /**
+     * Hepler to unify [reference labels].
+     */
+    normalizeReference(str: string): string;
+}
+
+declare const utils: Utils;
+
+declare namespace StateInline {
+    interface Scanned {
+        can_open: boolean;
+        can_close: boolean;
+        length: number;
+    }
+
+    interface Delimiter {
+        marker: number;
+        length: number;
+        jump: number;
+        token: number;
+        end: number;
+        open: boolean;
+        close: boolean;
+    }
+
+    interface TokenMata {
+        delimiters: Delimiter[];
+    }
+}
+
+declare class StateInline {
+    constructor(src: string, md: MarkdownIt, env: any, outTokens: Token[]);
+
+    src: string;
+    env: any;
+    md: MarkdownIt;
+    tokens: Token[];
+    tokens_meta: Array<StateInline.TokenMata | null>;
+
+    pos: number;
+    posMax: number;
+    level: number;
+    pending: string;
+    pendingLevel: number;
+
+    /**
+     * Stores { start: end } pairs. Useful for backtrack
+     * optimization of pairs parse (emphasis, strikes).
+     */
+    cache: any;
+
+    /**
+     * List of emphasis-like delimiters for current tag
+     */
+    delimiters: StateInline.Delimiter[];
+
+    // Stack of delimiter lists for upper level tags
+    // _prev_delimiters: StateInline.Delimiter[][];
+
+    /**
+     * Flush pending text
+     */
+    pushPending(): Token;
+
+    /**
+     * Push new token to "stream".
+     * If pending text exists - flush it as text token
+     */
+    push(type: string, tag: string, nesting: Token.Nesting): Token;
+
+    /**
+     * Scan a sequence of emphasis-like markers, and determine whether
+     * it can start an emphasis sequence or end an emphasis sequence.
+     *
+     * @param start position to scan from (it should point at a valid marker);
+     * @param canSplitWord determine if these markers can be found inside a word
+     */
+    scanDelims(start: number, canSplitWord: boolean): StateInline.Scanned;
+
+    Token: typeof Token;
+}
+
+declare function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;
+
+declare namespace parseLinkDestination {
+    interface ParseResult {
+        ok: boolean;
+        pos: number;
+        lines: number;
+        str: string;
+    }
+}
+
+declare function parseLinkDestination(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
+
+declare function parseLinkTitle(str: string, pos: number, max: number): parseLinkDestination.ParseResult;
+
+interface Helpers {
+    parseLinkLabel: typeof parseLinkLabel;
+    parseLinkDestination: typeof parseLinkDestination;
+    parseLinkTitle: typeof parseLinkTitle;
+}
+
+declare const helpers: Helpers;
+
+declare namespace Ruler {
+    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):
+ *
+ * - 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 [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
+ * [[MarkdownIt.use]].
+ */
+declare class Ruler<T> {
+    /**
+     * Replace rule by name with new function & options. Throws error if name not
+     * found.
+     *
+     * ##### Example
+     *
+     * Replace existing typographer replacement rule with new one:
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.core.ruler.at('replacements', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @param name rule name to replace.
+     * @param fn new rule function.
+     * @param options new rule options (not mandatory).
+     */
+    at(name: string, fn: T, options?: Ruler.RuleOptions): void;
+
+    /**
+     * Add new rule to chain before one with given name. See also
+     * [[Ruler.after]], [[Ruler.push]].
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @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;
+
+    /**
+     * Add new rule to chain after one with given name. See also
+     * [[Ruler.before]], [[Ruler.push]].
+     *
+     * ##### Options:
+     *
+     * - __alt__ - array with names of "alternate" chains.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @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;
+
+    /**
+     * Push new rule to the end of chain. See also
+     * [[Ruler.before]], [[Ruler.after]].
+     *
+     * ##### Options:
+     *
+     * - __alt__ - array with names of "alternate" chains.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.core.ruler.push('my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @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;
+
+    /**
+     * Enable rules with given names. If any rule name not found - throw Error.
+     * Errors can be disabled by second param.
+     *
+     * Returns list of found rule names (if no exception happened).
+     *
+     * See also [[Ruler.disable]], [[Ruler.enableOnly]].
+     *
+     * @param list list of rule names to enable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    enable(list: string | string[], ignoreInvalid?: boolean): string[];
+
+    /**
+     * Enable rules with given names, and disable everything else. If any rule name
+     * not found - throw Error. Errors can be disabled by second param.
+     *
+     * See also [[Ruler.disable]], [[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[];
+
+    /**
+     * Disable rules with given names. If any rule name not found - throw Error.
+     * Errors can be disabled by second param.
+     *
+     * Returns list of found rule names (if no exception happened).
+     *
+     * See also [[Ruler.enable]], [[Ruler.enableOnly]].
+     *
+     * @param list list of rule names to disable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    disable(list: string | string[], ignoreInvalid?: boolean): string[];
+
+    /**
+     * Return array of active functions (rules) for given chain name. It analyzes
+     * rules configuration, compiles caches if not exists and returns result.
+     *
+     * Default chain name is `''` (empty string). It can't be skipped. That's
+     * done intentionally, to keep signature monomorphic for high speed.
+     */
+    getRules(chainName: string): T[];
+}
+
+declare namespace StateBlock {
+    type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
+}
+
+declare class StateBlock {
+    constructor(src: string, md: MarkdownIt, env: any, tokens: Token[]);
+
+    src: string;
+
+    /**
+     * link to parser instance
+     */
+    md: MarkdownIt;
+
+    env: any;
+
+    //
+    // Internal state vartiables
+    //
+
+    tokens: Token[];
+
+    /**
+     * line begin offsets for fast jumps
+     */
+    bMarks: number[];
+    /**
+     * line end offsets for fast jumps
+     */
+    eMarks: number[];
+    /**
+     * offsets of the first non-space characters (tabs not expanded)
+     */
+    tShift: number[];
+    /**
+     * indents for each line (tabs expanded)
+     */
+    sCount: number[];
+
+    /**
+     * An amount of virtual spaces (tabs expanded) between beginning
+     * of each line (bMarks) and real beginning of that line.
+     *
+     * It exists only as a hack because blockquotes override bMarks
+     * losing information in the process.
+     *
+     * It's used only when expanding tabs, you can think about it as
+     * an initial tab length, e.g. bsCount=21 applied to string `\t123`
+     * means first tab should be expanded to 4-21%4 === 3 spaces.
+     */
+    bsCount: number[];
+
+    // block parser variables
+
+    /**
+     * required block content indent (for example, if we are
+     * inside a list, it would be positioned after list marker)
+     */
+    blkIndent: number;
+    /**
+     * line index in src
+     */
+    line: number;
+    /**
+     * lines count
+     */
+    lineMax: number;
+    /**
+     * loose/tight mode for lists
+     */
+    tight: boolean;
+    /**
+     * indent of the current dd block (-1 if there isn't any)
+     */
+    ddIndent: number;
+    /**
+     * indent of the current list block (-1 if there isn't any)
+     */
+    listIndent: number;
+
+    /**
+     * can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
+     * used in lists to determine if they interrupt a paragraph
+     */
+    parentType: StateBlock.ParentType;
+
+    level: number;
+
+    /**
+     * renderer
+     */
+    result: string;
+
+    /**
+     * Push new token to "stream".
+     */
+    push(type: string, tag: string, nesting: Token.Nesting): Token;
+
+    isEmpty(line: number): boolean;
+
+    skipEmptyLines(from: number): number;
+
+    /**
+     * Skip spaces from given position.
+     */
+    skipSpaces(pos: number): number;
+
+    /**
+     * Skip spaces from given position in reverse.
+     */
+    skipSpacesBack(pos: number, min: number): number;
+
+    /**
+     * Skip char codes from given position
+     */
+    skipChars(pos: number, code: number): number;
+
+    /**
+     * Skip char codes reverse from given position - 1
+     */
+    skipCharsBack(pos: number, code: number, min: number): number;
+
+    /**
+     * cut lines range from source.
+     */
+    getLines(begin: number, end: number, indent: number, keepLastLF: boolean): string;
+
+    Token: typeof Token;
+}
+
+declare namespace ParserBlock {
+    type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
+}
+
+declare class ParserBlock {
+    /**
+     * [[Ruler]] instance. Keep configuration of block rules.
+     */
+    ruler: Ruler<ParserBlock.RuleBlock>;
+
+    /**
+     * Generate tokens for input range
+     */
+    tokenize(state: StateBlock, startLine: number, endLine: number): void;
+
+    /**
+     * Process input string and push block tokens into `outTokens`
+     */
+    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
+
+    State: typeof StateBlock;
+}
+
+declare class StateCore {
+    constructor(src: string, md: MarkdownIt, env: any);
+
+    src: string;
+    env: any;
+    tokens: Token[];
+    inlineMode: boolean;
+
+    /**
+     * link to parser instance
+     */
+    md: MarkdownIt;
+
+    Token: typeof Token;
+}
+
+declare namespace Core {
+    type RuleCore = (state: StateCore) => void;
+}
+
+declare class Core {
+    ruler: Ruler<Core.RuleCore>;
+
+    /**
+     * Executes core chain rules.
+     */
+    process(state: StateCore): void;
+
+    State: typeof StateCore;
+}
+
+declare namespace ParserInline {
+    type RuleInline = (state: StateInline, silent: boolean) => boolean;
+    type RuleInline2 = (state: StateInline) => boolean;
+}
+
+declare class ParserInline {
+    /**
+     * [[Ruler]] instance. Keep configuration of inline rules.
+     */
+    ruler: Ruler<ParserInline.RuleInline>;
+
+    /**
+     * [[Ruler]] instance. Second ruler used for post-processing
+     * (e.g. in emphasis-like rules).
+     */
+    ruler2: Ruler<ParserInline.RuleInline2>;
+
+    /**
+     * Skip single token by running all rules in validation mode;
+     * returns `true` if any rule reported success
+     */
+    skipToken(state: StateInline): void;
+
+    /**
+     * Generate tokens for input range
+     */
+    tokenize(state: StateInline): void;
+
+    /**
+     * Process input string and push inline tokens into `outTokens`
+     */
+    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
+
+    State: typeof StateInline;
+}
+
+declare namespace Renderer {
+    type RenderRule = (tokens: Token[], idx: number, options: MarkdownIt.Options, env: any, self: Renderer) => string;
+
+    interface RenderRuleRecord {
+        [type: string]: RenderRule | undefined;
+        code_inline?: RenderRule | undefined;
+        code_block?: RenderRule | undefined;
+        fence?: RenderRule | undefined;
+        image?: RenderRule | undefined;
+        hardbreak?: RenderRule | undefined;
+        softbreak?: RenderRule | undefined;
+        text?: RenderRule | undefined;
+        html_block?: RenderRule | undefined;
+        html_inline?: RenderRule | undefined;
+    }
+}
+
+declare class Renderer {
+    /**
+     * Contains render rules for tokens. Can be updated and extended.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.renderer.rules.strong_open  = function () { return '<b>'; };
+     * md.renderer.rules.strong_close = function () { return '</b>'; };
+     *
+     * var result = md.renderInline(...);
+     * ```
+     *
+     * Each rule is called as independent static function with fixed signature:
+     *
+     * ```javascript
+     * function my_token_render(tokens, idx, options, env, renderer) {
+     *   // ...
+     *   return renderedHTML;
+     * }
+     * ```
+     *
+     * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
+     * for more details and examples.
+     */
+    rules: Renderer.RenderRuleRecord;
+
+    /**
+     * Render token attributes to string.
+     */
+    renderAttrs(token: Token): string;
+
+    /**
+     * Default token renderer. Can be overriden by custom function
+     * in [[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: MarkdownIt.Options): string;
+
+    /**
+     * The same as [[Renderer.render]], but for single token of `inline` type.
+     *
+     * @param tokens list on block tokens to renter
+     * @param options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    renderInline(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+
+    /**
+     * 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 renter
+     * @param options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    renderInlineAsText(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+
+    /**
+     * 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 options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    render(tokens: Token[], options: MarkdownIt.Options, env: any): string;
+}
+
+interface MarkdownItConstructor {
+    new(): MarkdownIt;
+    new(presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
+    new(options: MarkdownIt.Options): MarkdownIt;
+    (): MarkdownIt;
+    (presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
+    (options: MarkdownIt.Options): MarkdownIt;
+}
+
+declare namespace MarkdownIt {
+    type Token = __token;
+
+    /**
+     * MarkdownIt provides named presets as a convenience to quickly
+     * enable/disable active syntax rules and options for common use cases.
+     *
+     * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
+     *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
+     * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
+     *   similar to GFM, used when no preset name given. Enables all available rules,
+     *   but still without html, typographer & autolinker.
+     * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
+     *   all rules disabled. Useful to quickly setup your config via `.enable()`.
+     *   For example, when you need only `bold` and `italic` markup and nothing else.
+     */
+    type PresetName = "default" | "zero" | "commonmark";
+
+    interface Options {
+        /**
+         * Set `true` to enable HTML tags in source. Be careful!
+         * That's not safe! You may need external sanitizer to protect output from XSS.
+         * It's better to extend features via plugins, instead of enabling HTML.
+         * @default false
+         */
+        html?: boolean | undefined;
+
+        /**
+         * Set `true` to add '/' when closing single tags
+         * (`<br />`). This is needed only for full CommonMark compatibility. In real
+         * world you will need HTML output.
+         * @default false
+         */
+        xhtmlOut?: boolean | undefined;
+
+        /**
+         * Set `true` to convert `\n` in paragraphs into `<br>`.
+         * @default false
+         */
+        breaks?: boolean | undefined;
+
+        /**
+         * CSS language class prefix for fenced blocks.
+         * Can be useful for external highlighters.
+         * @default 'language-'
+         */
+        langPrefix?: string | undefined;
+
+        /**
+         * Set `true` to autoconvert URL-like text to links.
+         * @default false
+         */
+        linkify?: boolean | undefined;
+
+        /**
+         * Set `true` to enable [some language-neutral replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
+         * quotes beautification (smartquotes).
+         * @default false
+         */
+        typographer?: boolean | undefined;
+
+        /**
+         * Double + single quotes replacement
+         * pairs, when typographer enabled and smartquotes on. For example, you can
+         * use `'«»„“'` for Russian, `'„“‚‘'` for German, and
+         * `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
+         * @default '“”‘’'
+         */
+        quotes?: string | string[];
+
+        /**
+         * Highlighter function for fenced code blocks.
+         * Highlighter `function (str, lang, attrs)` should return escaped HTML. It can
+         * also return empty string if the source was not changed and should be escaped
+         * externally. If result starts with <pre... internal wrapper is skipped.
+         * @default null
+         */
+        highlight?: ((str: string, lang: string, attrs: string) => string) | null | undefined;
+    }
+
+    type PluginSimple = (md: MarkdownIt) => void;
+    type PluginWithOptions<T = any> = (md: MarkdownIt, options?: T) => void;
+    type PluginWithParams = (md: MarkdownIt, ...params: any[]) => void;
+}
+
+interface 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]].
+     */
+    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]].
+     */
+    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]].
+     */
+    readonly core: Core;
+
+    /**
+     * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
+     * rules for new token types, generated by plugins.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * function myToken(tokens, idx, options, env, self) {
+     *   //...
+     *   return result;
+     * };
+     *
+     * md.renderer.rules['my_token'] = myToken
+     * ```
+     *
+     * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
+     */
+    readonly renderer: Renderer;
+
+    /**
+     * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
+     * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
+     * rule.
+     */
+    readonly linkify: LinkifyIt.LinkifyIt;
+
+    /**
+     * Link validation function. CommonMark allows too much in links. By default
+     * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
+     * except some embedded image types.
+     *
+     * You can change this behaviour:
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     * // enable everything
+     * md.validateLink = function () { return true; }
+     * ```
+     */
+    validateLink(url: string): boolean;
+
+    /**
+     * Function used to encode link url to a machine-readable format,
+     * which includes url-encoding, punycode, etc.
+     */
+    normalizeLink(url: string): string;
+
+    /**
+     * Function used to decode link url to a human-readable format`
+     */
+    normalizeLinkText(url: string): string;
+
+    readonly utils: typeof utils;
+
+    readonly helpers: typeof helpers;
+
+    readonly options: MarkdownIt.Options;
+
+    /**
+     * *chainable*
+     *
+     * Set parser options (in the same format as in constructor). Probably, you
+     * will never need it, but you can change options after constructor call.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')()
+     *             .set({ html: true, breaks: true })
+     *             .set({ typographer: true });
+     * ```
+     *
+     * __Note:__ To achieve the best possible performance, don't modify a
+     * `markdown-it` instance options on the fly. If you need multiple configurations
+     * it's best to create multiple instances and initialize each with separate
+     * config.
+     */
+    set(options: MarkdownIt.Options): this;
+
+    /**
+     * *chainable*, *internal*
+     *
+     * Batch load of all options and compenent settings. This is internal method,
+     * and you probably will not need it. But if you with - see available presets
+     * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
+     *
+     * We strongly recommend to use presets instead of direct config loads. That
+     * will give better compatibility with next versions.
+     */
+    configure(presets: MarkdownIt.PresetName): this;
+
+    /**
+     * *chainable*
+     *
+     * Enable list or rules. It will automatically find appropriate components,
+     * containing rules with given names. If rule not found, and `ignoreInvalid`
+     * not set - throws exception.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')()
+     *             .enable(['sub', 'sup'])
+     *             .disable('smartquotes');
+     * ```
+     *
+     * @param list rule name or list of rule names to enable
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    enable(list: string | string[], ignoreInvalid?: boolean): this;
+
+    /**
+     * *chainable*
+     *
+     * The same as [[MarkdownIt.enable]], but turn specified rules off.
+     *
+     * @param list rule name or list of rule names to disable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    disable(list: string | string[], ignoreInvalid?: boolean): this;
+
+    /**
+     * *chainable*
+     *
+     * Load specified plugin with given params into current parser instance.
+     * It's just a sugar to call `plugin(md, params)` with curring.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var iterator = require('markdown-it-for-inline');
+     * var md = require('markdown-it')()
+     *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
+     *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
+     *             });
+     * ```
+     */
+    use(plugin: MarkdownIt.PluginSimple): this;
+    use<T = any>(plugin: MarkdownIt.PluginWithOptions<T>, options?: T): this;
+    use(plugin: MarkdownIt.PluginWithParams, ...params: any[]): this;
+
+    /**
+     * *internal*
+     *
+     * Parse input string and returns list of block tokens (special token type
+     * "inline" will contain list of inline tokens). You should not call this
+     * method directly, until you write custom renderer (for example, to produce
+     * AST).
+     *
+     * `env` is used to pass data between "distributed" rules and return additional
+     * metadata like reference info, needed for the renderer. It also can be used to
+     * inject data in specific cases. Usually, you will be ok to pass `{}`,
+     * and then pass updated object to renderer.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    parse(src: string, env: any): Token[];
+
+    /**
+     * Render markdown string into html. It does all magic for you :).
+     *
+     * `env` can be used to inject additional metadata (`{}` by default).
+     * But you will not need it with high probability. See also comment
+     * in [[MarkdownIt.parse]].
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    render(src: string, env?: any): string;
+
+    /**
+     * *internal*
+     *
+     * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
+     * block tokens list with the single `inline` element, containing parsed inline
+     * tokens in `children` property. Also updates `env` object.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    parseInline(src: string, env: any): Token[];
+
+    /**
+     * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
+     * will NOT be wrapped into `<p>` tags.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    renderInline(src: string, env?: any): string;
+}
+
+/**
+ * Main parser/renderer class.
+ *
+ * ##### Usage
+ *
+ * ```javascript
+ * // node.js, "classic" way:
+ * var MarkdownIt = require('markdown-it'),
+ *     md = new MarkdownIt();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // node.js, the same, but with sugar:
+ * var md = require('markdown-it')();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // browser without AMD, added to "window" on script load
+ * // Note, there are no dash.
+ * var md = window.markdownit();
+ * var result = md.render('# markdown-it rulezz!');
+ * ```
+ *
+ * Single line rendering, without paragraph wrap:
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ * var result = md.renderInline('__markdown-it__ rulezz!');
+ * ```
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * // commonmark mode
+ * var md = require('markdown-it')('commonmark');
+ *
+ * // default mode
+ * var md = require('markdown-it')();
+ *
+ * // enable everything
+ * var md = require('markdown-it')({
+ *   html: true,
+ *   linkify: true,
+ *   typographer: true
+ * });
+ * ```
+ *
+ * ##### Syntax highlighting
+ *
+ * ```js
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return hljs.highlight(lang, str, true).value;
+ *       } catch (__) {}
+ *     }
+ *
+ *     return ''; // use external default escaping
+ *   }
+ * });
+ * ```
+ *
+ * Or with full wrapper override (if you need assign class to `<pre>`):
+ *
+ * ```javascript
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * // Actual default values
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return '<pre class="hljs"><code>' +
+ *                hljs.highlight(lang, str, true).value +
+ *                '</code></pre>';
+ *       } catch (__) {}
+ *     }
+ *
+ *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
+ *   }
+ * });
+ * ```
+ */
+declare const MarkdownIt: MarkdownItConstructor;
+
+interface DocSearchProps {
+  appId: string
+  apiKey: string
+  indexName: string
+  placeholder?: string
+  searchParameters?: SearchOptions
+  disableUserPersonalization?: boolean
+  initialQuery?: string
+  insights?: boolean
+  translations?: DocSearchTranslations
+}
+
+interface SearchOptions {
+  query?: string
+  similarQuery?: string
+  facetFilters?: string | string[]
+  optionalFilters?: string | string[]
+  numericFilters?: string | string[]
+  tagFilters?: string | string[]
+  sumOrFiltersScores?: boolean
+  filters?: string
+  page?: number
+  hitsPerPage?: number
+  offset?: number
+  length?: number
+  attributesToHighlight?: string[]
+  attributesToSnippet?: string[]
+  attributesToRetrieve?: string[]
+  highlightPreTag?: string
+  highlightPostTag?: string
+  snippetEllipsisText?: string
+  restrictHighlightAndSnippetArrays?: boolean
+  facets?: string[]
+  maxValuesPerFacet?: number
+  facetingAfterDistinct?: boolean
+  minWordSizefor1Typo?: number
+  minWordSizefor2Typos?: number
+  allowTyposOnNumericTokens?: boolean
+  disableTypoToleranceOnAttributes?: string[]
+  queryType?: 'prefixLast' | 'prefixAll' | 'prefixNone'
+  removeWordsIfNoResults?: 'none' | 'lastWords' | 'firstWords' | 'allOptional'
+  advancedSyntax?: boolean
+  advancedSyntaxFeatures?: ('exactPhrase' | 'excludeWords')[]
+  optionalWords?: string | string[]
+  disableExactOnAttributes?: string[]
+  exactOnSingleWordQuery?: 'attribute' | 'none' | 'word'
+  alternativesAsExact?: (
+    | 'ignorePlurals'
+    | 'singleWordSynonym'
+    | 'multiWordsSynonym'
+  )[]
+  enableRules?: boolean
+  ruleContexts?: string[]
+  distinct?: boolean | number
+  analytics?: boolean
+  analyticsTags?: string[]
+  synonyms?: boolean
+  replaceSynonymsInHighlight?: boolean
+  minProximity?: number
+  responseFields?: string[]
+  maxFacetHits?: number
+  percentileComputation?: boolean
+  clickAnalytics?: boolean
+  personalizationImpact?: number
+  enablePersonalization?: boolean
+  restrictSearchableAttributes?: string[]
+  sortFacetValuesBy?: 'count' | 'alpha'
+  typoTolerance?: boolean | 'min' | 'strict'
+  aroundLatLng?: string
+  aroundLatLngViaIP?: boolean
+  aroundRadius?: number | 'all'
+  aroundPrecision?: number | { from: number; value: number }[]
+  minimumAroundRadius?: number
+  insideBoundingBox?: number[][]
+  insidePolygon?: number[][]
+  ignorePlurals?: boolean | string[]
+  removeStopWords?: boolean | string[]
+  naturalLanguages?: string[]
+  getRankingInfo?: boolean
+  userToken?: string
+  enableABTest?: boolean
+  decompoundQuery?: boolean
+  relevancyStrictness?: number
+}
+
+interface DocSearchTranslations {
+  button?: ButtonTranslations$1
+  modal?: ModalTranslations$1
+}
+
+interface ButtonTranslations$1 {
+  buttonText?: string
+  buttonAriaLabel?: string
+}
+
+interface ModalTranslations$1 extends ScreenStateTranslations {
+  searchBox?: SearchBoxTranslations
+  footer?: FooterTranslations$1
+}
+
+interface ScreenStateTranslations {
+  errorScreen?: ErrorScreenTranslations
+  startScreen?: StartScreenTranslations
+  noResultsScreen?: NoResultsScreenTranslations
+}
+
+interface SearchBoxTranslations {
+  resetButtonTitle?: string
+  resetButtonAriaLabel?: string
+  cancelButtonText?: string
+  cancelButtonAriaLabel?: string
+}
+
+interface FooterTranslations$1 {
+  selectText?: string
+  selectKeyAriaLabel?: string
+  navigateText?: string
+  navigateUpKeyAriaLabel?: string
+  navigateDownKeyAriaLabel?: string
+  closeText?: string
+  closeKeyAriaLabel?: string
+  searchByText?: string
+}
+
+interface ErrorScreenTranslations {
+  titleText?: string
+  helpText?: string
+}
+
+interface StartScreenTranslations {
+  recentSearchesTitle?: string
+  noRecentSearchesText?: string
+  saveRecentSearchButtonTitle?: string
+  removeRecentSearchButtonTitle?: string
+  favoriteSearchesTitle?: string
+  removeFavoriteSearchButtonTitle?: string
+}
+
+interface NoResultsScreenTranslations {
+  noResultsText?: string
+  suggestedQueryText?: string
+  reportMissingResultsText?: string
+  reportMissingResultsLinkText?: string
+}
+
+interface LocalSearchTranslations {
+  button?: ButtonTranslations
+  modal?: ModalTranslations
+}
+
+interface ButtonTranslations {
+  buttonText?: string
+  buttonAriaLabel?: string
+}
+
+interface ModalTranslations {
+  displayDetails?: string
+  resetButtonTitle?: string
+  backButtonTitle?: string
+  noResultsText?: string
+  footer?: FooterTranslations
+}
+
+interface FooterTranslations {
+  selectText?: string
+  selectKeyAriaLabel?: string
+  navigateText?: string
+  navigateUpKeyAriaLabel?: string
+  navigateDownKeyAriaLabel?: string
+  closeText?: string
+  closeKeyAriaLabel?: string
+}
+
+interface PageSplitSection {
+  anchor?: string
+  titles: string[]
+  text: string
+}
+
+declare namespace DefaultTheme {
+  export interface Config {
+    /**
+     * The logo file of the site.
+     *
+     * @example '/logo.svg'
+     */
+    logo?: ThemeableImage
+
+    /**
+     * Overrides the link of the site logo.
+     */
+    logoLink?: string | { link?: string; rel?: string; target?: string }
+
+    /**
+     * Custom site title in navbar. If the value is undefined,
+     * `config.title` will be used.
+     */
+    siteTitle?: string | false
+
+    /**
+     * Custom header levels of outline in the aside component.
+     *
+     * @default 2
+     */
+    outline?: Outline | Outline['level'] | false
+
+    /**
+     * @deprecated Use `outline.label` instead.
+     *
+     * @default 'On this page'
+     */
+    outlineTitle?: string
+
+    /**
+     * The nav items.
+     */
+    nav?: NavItem[]
+
+    /**
+     * The sidebar items.
+     */
+    sidebar?: Sidebar
+
+    /**
+     * Set to `false` to prevent rendering of aside container.
+     * Set to `true` to render the aside to the right.
+     * Set to `left` to render the aside to the left.
+     *
+     * @default true
+     */
+    aside?: boolean | 'left'
+
+    /**
+     * Info for the edit link. If it's undefined, the edit link feature will
+     * be disabled.
+     */
+    editLink?: EditLink
+
+    /**
+     * @deprecated Use `lastUpdated.text` instead.
+     *
+     * Set custom last updated text.
+     *
+     * @default 'Last updated'
+     */
+    lastUpdatedText?: string
+
+    lastUpdated?: LastUpdatedOptions
+
+    /**
+     * Set custom prev/next labels.
+     */
+    docFooter?: DocFooter
+
+    /**
+     * The social links to be displayed at the end of the nav bar. Perfect for
+     * placing links to social services such as GitHub, Twitter, Facebook, etc.
+     */
+    socialLinks?: SocialLink[]
+
+    /**
+     * The footer configuration.
+     */
+    footer?: Footer
+
+    /**
+     * @default 'Appearance'
+     */
+    darkModeSwitchLabel?: string
+
+    /**
+     * @default 'Switch to light theme'
+     */
+    lightModeSwitchTitle?: string
+
+    /**
+     * @default 'Switch to dark theme'
+     */
+    darkModeSwitchTitle?: string
+
+    /**
+     * @default 'Menu'
+     */
+    sidebarMenuLabel?: string
+
+    /**
+     * @default 'Return to top'
+     */
+    returnToTopLabel?: string
+
+    /**
+     * Set custom `aria-label` for language menu button.
+     *
+     * @default 'Change language'
+     */
+    langMenuLabel?: string
+
+    search?:
+      | { provider: 'local'; options?: LocalSearchOptions }
+      | { provider: 'algolia'; options: AlgoliaSearchOptions }
+
+    /**
+     * @deprecated Use `search` instead.
+     */
+    algolia?: AlgoliaSearchOptions
+
+    /**
+     * The carbon ads options. Leave it undefined to disable the ads feature.
+     */
+    carbonAds?: CarbonAdsOptions
+
+    /**
+     * Changing locale when current url is `/foo` will redirect to `/locale/foo`.
+     *
+     * @default true
+     */
+    i18nRouting?: boolean
+
+    /**
+     * Show external link icon in Markdown links.
+     *
+     * @default false
+     */
+    externalLinkIcon?: boolean
+
+    /**
+     * Customize text of 404 page.
+     */
+    notFound?: NotFoundOptions
+  }
+
+  // nav -----------------------------------------------------------------------
+
+  export type NavItem = NavItemWithLink | NavItemWithChildren
+
+  export interface NavItemWithLink {
+    text: string
+    link: string
+    items?: never
+
+    /**
+     * `activeMatch` is expected to be a regex string. We can't use actual
+     * RegExp object here because it isn't serializable
+     */
+    activeMatch?: string
+    rel?: string
+    target?: string
+    noIcon?: boolean
+  }
+
+  export interface NavItemChildren {
+    text?: string
+    items: NavItemWithLink[]
+  }
+
+  export interface NavItemWithChildren {
+    text?: string
+    items: (NavItemChildren | NavItemWithLink)[]
+
+    /**
+     * `activeMatch` is expected to be a regex string. We can't use actual
+     * RegExp object here because it isn't serializable
+     */
+    activeMatch?: string
+  }
+
+  // image ---------------------------------------------------------------------
+
+  export type ThemeableImage =
+    | string
+    | { src: string; alt?: string; [prop: string]: any }
+    | { light: string; dark: string; alt?: string; [prop: string]: any }
+
+  export type FeatureIcon =
+    | string
+    | {
+        src: string
+        alt?: string
+        width?: string
+        height?: string
+        wrap?: boolean
+      }
+    | {
+        light: string
+        dark: string
+        alt?: string
+        width?: string
+        height?: string
+        wrap?: boolean
+      }
+
+  // sidebar -------------------------------------------------------------------
+
+  export type Sidebar = SidebarItem[] | SidebarMulti
+
+  export interface SidebarMulti {
+    [path: string]: SidebarItem[] | { items: SidebarItem[]; base: string }
+  }
+
+  export type SidebarItem = {
+    /**
+     * The text label of the item.
+     */
+    text?: string
+
+    /**
+     * The link of the item.
+     */
+    link?: string
+
+    /**
+     * The children of the item.
+     */
+    items?: SidebarItem[]
+
+    /**
+     * If not specified, group is not collapsible.
+     *
+     * If `true`, group is collapsible and collapsed by default
+     *
+     * If `false`, group is collapsible but expanded by default
+     */
+    collapsed?: boolean
+
+    /**
+     * Base path for the children items.
+     */
+    base?: string
+
+    /**
+     * Customize text that appears on the footer of previous/next page.
+     */
+    docFooterText?: string
+
+    rel?: string
+    target?: string
+  }
+
+  /**
+   * ReturnType of `useSidebar`
+   */
+  export interface DocSidebar {
+    isOpen: Ref$1<boolean>
+    sidebar: ComputedRef<SidebarItem[]>
+    sidebarGroups: ComputedRef<SidebarItem[]>
+    hasSidebar: ComputedRef<boolean>
+    hasAside: ComputedRef<boolean>
+    leftAside: ComputedRef<boolean>
+    isSidebarEnabled: ComputedRef<boolean>
+    open: () => void
+    close: () => void
+    toggle: () => void
+  }
+
+  // edit link -----------------------------------------------------------------
+
+  export interface EditLink {
+    /**
+     * Pattern for edit link.
+     *
+     * @example 'https://github.com/vuejs/vitepress/edit/main/docs/:path'
+     * @example ({ filePath }) => { ... }
+     */
+    pattern: string | ((payload: PageData) => string)
+
+    /**
+     * Custom text for edit link.
+     *
+     * @default 'Edit this page'
+     */
+    text?: string
+  }
+
+  // prev-next -----------------------------------------------------------------
+
+  export interface DocFooter {
+    /**
+     * Custom label for previous page button. Can be set to `false` to disable.
+     *
+     * @default 'Previous page'
+     */
+    prev?: string | boolean
+
+    /**
+     * Custom label for next page button. Can be set to `false` to disable.
+     *
+     * @default 'Next page'
+     */
+    next?: string | boolean
+  }
+
+  // social link ---------------------------------------------------------------
+
+  export interface SocialLink {
+    icon: SocialLinkIcon
+    link: string
+    ariaLabel?: string
+  }
+
+  export type SocialLinkIcon =
+    | 'discord'
+    | 'facebook'
+    | 'github'
+    | 'instagram'
+    | 'linkedin'
+    | 'mastodon'
+    | 'npm'
+    | 'slack'
+    | 'twitter'
+    | 'x'
+    | 'youtube'
+    | { svg: string }
+
+  // footer --------------------------------------------------------------------
+
+  export interface Footer {
+    message?: string
+    copyright?: string
+  }
+
+  // team ----------------------------------------------------------------------
+
+  export interface TeamMember {
+    avatar: string
+    name: string
+    title?: string
+    org?: string
+    orgLink?: string
+    desc?: string
+    links?: SocialLink[]
+    sponsor?: string
+    actionText?: string
+  }
+
+  // local nav -----------------------------------------------------------------
+
+  /**
+   * ReturnType of `useLocalNav`.
+   */
+  export interface DocLocalNav {
+    /**
+     * The outline headers of the current page.
+     */
+    headers: ShallowRef<MenuItem[]>
+
+    /**
+     * Whether the current page has a local nav. Local nav is shown when the
+     * "outline" is present in the page. However, note that the actual
+     * local nav visibility depends on the screen width as well.
+     */
+    hasLocalNav: ComputedRef<boolean>
+  }
+
+  // outline -------------------------------------------------------------------
+
+  export interface Outline {
+    level?: number | [number, number] | 'deep'
+    label?: string
+  }
+
+  // local search --------------------------------------------------------------
+
+  export interface LocalSearchOptions {
+    /**
+     * @default false
+     * @deprecated Use `detailedView: false` instead.
+     */
+    disableDetailedView?: boolean
+
+    /**
+     * If `true`, the detailed view will be enabled by default.
+     * If `false`, the detailed view will be disabled.
+     * If `'auto'`, the detailed view will be disabled by default, but can be enabled by the user.
+     *
+     * @default 'auto'
+     */
+    detailedView?: boolean | 'auto'
+
+    /**
+     * @default false
+     */
+    disableQueryPersistence?: boolean
+
+    translations?: LocalSearchTranslations
+    locales?: Record<string, Partial<Omit<LocalSearchOptions, 'locales'>>>
+
+    miniSearch?: {
+      /**
+       * @see https://lucaong.github.io/minisearch/modules/_minisearch_.html#options
+       */
+      options?: Pick<
+        Options$2,
+        'extractField' | 'tokenize' | 'processTerm'
+      >
+      /**
+       * @see https://lucaong.github.io/minisearch/modules/_minisearch_.html#searchoptions-1
+       */
+      searchOptions?: Options$2['searchOptions']
+
+      /**
+       * Overrides the default regex based page splitter.
+       * Supports async generator, making it possible to run in true parallel
+       * (when used along with `node:child_process` or `worker_threads`)
+       * ---
+       * This should be especially useful for scalability reasons.
+       * ---
+       * @param {string} path - absolute path to the markdown source file
+       * @param {string} html - document page rendered as html
+       */
+      _splitIntoSections?: (
+        path: string,
+        html: string
+      ) =>
+        | AsyncGenerator<PageSplitSection>
+        | Generator<PageSplitSection>
+        | Awaitable<PageSplitSection[]>
+    }
+    /**
+     * Allows transformation of content before indexing (node only)
+     * Return empty string to skip indexing
+     */
+    _render?: (
+      src: string,
+      env: MarkdownEnv,
+      md: MarkdownIt
+    ) => Awaitable<string>
+  }
+
+  // algolia -------------------------------------------------------------------
+
+  /**
+   * Algolia search options. Partially copied from
+   * `@docsearch/react/dist/esm/DocSearch.d.ts`
+   */
+  export interface AlgoliaSearchOptions extends DocSearchProps {
+    locales?: Record<string, Partial<DocSearchProps>>
+  }
+
+  // carbon ads ----------------------------------------------------------------
+
+  export interface CarbonAdsOptions {
+    code: string
+    placement: string
+  }
+
+  // last updated --------------------------------------------------------------
+
+  export interface LastUpdatedOptions {
+    /**
+     * Set custom last updated text.
+     *
+     * @default 'Last updated'
+     */
+    text?: string
+
+    /**
+     * Set options for last updated time formatting.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options
+     *
+     * @default
+     * { dateStyle: 'short', timeStyle: 'short' }
+     */
+    formatOptions?: Intl.DateTimeFormatOptions & { forceLocale?: boolean }
+  }
+
+  // not found -----------------------------------------------------------------
+
+  export interface NotFoundOptions {
+    /**
+     * Set custom not found message.
+     *
+     * @default 'PAGE NOT FOUND'
+     */
+    title?: string
+
+    /**
+     * Set custom not found description.
+     *
+     * @default "But if you don't change your direction, and if you keep looking, you may end up where you are heading."
+     */
+    quote?: string
+
+    /**
+     * Set aria label for home link.
+     *
+     * @default 'go to home'
+     */
+    linkLabel?: string
+
+    /**
+     * Set custom home link text.
+     *
+     * @default 'Take me home'
+     */
+    linkText?: string
+
+    /**
+     * @default '404'
+     */
+    code?: string
+  }
+}
+
+// types shared between server and client
+
+
+type Awaitable<T> = T | PromiseLike<T>
+
+interface PageData {
+  relativePath: string
+  filePath: string // differs from relativePath in case of path rewrites
+  title: string
+  titleTemplate?: string | boolean
+  description: string
+  headers: Header[]
+  frontmatter: Record<string, any>
+  params?: Record<string, any>
+  isNotFound?: boolean
+  lastUpdated?: number
+}
+
+/**
+ * SFC block extracted from markdown
+ */
+interface SfcBlock$1 {
+  /**
+   * The type of the block
+   */
+  type: string
+  /**
+   * The content, including open-tag and close-tag
+   */
+  content: string
+  /**
+   * The content that stripped open-tag and close-tag off
+   */
+  contentStripped: string
+  /**
+   * The open-tag
+   */
+  tagOpen: string
+  /**
+   * The close-tag
+   */
+  tagClose: string
+}
+
+interface MarkdownSfcBlocks$1 {
+  /**
+   * The `<template>` block
+   */
+  template: SfcBlock$1 | null
+  /**
+   * The common `<script>` block
+   */
+  script: SfcBlock$1 | null
+  /**
+   * The `<script setup>` block
+   */
+  scriptSetup: SfcBlock$1 | null
+  /**
+   * All `<script>` blocks.
+   *
+   * By default, SFC only allows one `<script>` block and one `<script setup>` block.
+   * However, some tools may support different types of `<script>`s, so we keep all of them here.
+   */
+  scripts: SfcBlock$1[]
+  /**
+   * All `<style>` blocks.
+   */
+  styles: SfcBlock$1[]
+  /**
+   * All custom blocks.
+   */
+  customBlocks: SfcBlock$1[]
+}
+
+interface Header {
+  /**
+   * The level of the header
+   *
+   * `1` to `6` for `<h1>` to `<h6>`
+   */
+  level: number
+  /**
+   * The title of the header
+   */
+  title: string
+  /**
+   * The slug of the header
+   *
+   * Typically the `id` attr of the header anchor
+   */
+  slug: string
+  /**
+   * Link of the header
+   *
+   * Typically using `#${slug}` as the anchor hash
+   */
+  link: string
+  /**
+   * The children of the header
+   */
+  children: Header[]
+}
+
+interface SiteData<ThemeConfig = any> {
+  base: string
+  cleanUrls?: boolean
+  lang: string
+  dir: string
+  title: string
+  titleTemplate?: string | boolean
+  description: string
+  head: HeadConfig[]
+  appearance:
+    | boolean
+    | 'dark'
+    | 'force-dark'
+    | (Omit<UseDarkOptions, 'initialValue'> & { initialValue?: 'dark' })
+  themeConfig: ThemeConfig
+  scrollOffset:
+    | number
+    | string
+    | string[]
+    | { selector: string | string[]; padding: number }
+  locales: LocaleConfig<ThemeConfig>
+  localeIndex?: string
+  contentProps?: Record<string, any>
+  router: {
+    prefetchLinks: boolean
+  }
+}
+
+type HeadConfig =
+  | [string, Record<string, string>]
+  | [string, Record<string, string>, string]
+
+interface SSGContext extends SSRContext {
+  content: string
+}
+
+interface LocaleSpecificConfig<ThemeConfig = any> {
+  lang?: string
+  dir?: string
+  title?: string
+  titleTemplate?: string | boolean
+  description?: string
+  head?: HeadConfig[]
+  themeConfig?: ThemeConfig
+}
+
+type LocaleConfig<ThemeConfig = any> = Record<
+  string,
+  LocaleSpecificConfig<ThemeConfig> & { label: string; link?: string }
+>
+
+// Manually declaring all properties as rollup-plugin-dts
+// is unable to merge augmented module declarations
+
+interface MarkdownEnv {
+  /**
+   * The raw Markdown content without frontmatter
+   */
+  content?: string
+  /**
+   * The excerpt that extracted by `@mdit-vue/plugin-frontmatter`
+   *
+   * - Would be the rendered HTML when `renderExcerpt` is enabled
+   * - Would be the raw Markdown when `renderExcerpt` is disabled
+   */
+  excerpt?: string
+  /**
+   * The frontmatter that extracted by `@mdit-vue/plugin-frontmatter`
+   */
+  frontmatter?: Record<string, unknown>
+  /**
+   * The headers that extracted by `@mdit-vue/plugin-headers`
+   */
+  headers?: Header[]
+  /**
+   * SFC blocks that extracted by `@mdit-vue/plugin-sfc`
+   */
+  sfcBlocks?: MarkdownSfcBlocks$1
+  /**
+   * The title that extracted by `@mdit-vue/plugin-title`
+   */
+  title?: string
+  path: string
+  relativePath: string
+  cleanUrls: boolean
+  links?: string[]
+  includes?: string[]
+  realPath?: string
+}
+
+/**
+ * How frequently the page is likely to change. This value provides general
+ * information to search engines and may not correlate exactly to how often they crawl the page. Please note that the
+ * value of this tag is considered a hint and not a command. See
+ * <https://www.sitemaps.org/protocol.html#xmlTagDefinitions> for the acceptable
+ * values
+ */
+declare enum EnumChangefreq {
+    DAILY = "daily",
+    MONTHLY = "monthly",
+    ALWAYS = "always",
+    HOURLY = "hourly",
+    WEEKLY = "weekly",
+    YEARLY = "yearly",
+    NEVER = "never"
+}
+/**
+ * https://support.google.com/webmasters/answer/74288?hl=en&ref_topic=4581190
+ */
+interface NewsItem {
+    access?: 'Registration' | 'Subscription';
+    publication: {
+        name: string;
+        /**
+         * The `<language>` is the language of your publication. Use an ISO 639
+         * language code (2 or 3 letters).
+         */
+        language: string;
+    };
+    /**
+     * @example 'PressRelease, Blog'
+     */
+    genres?: string;
+    /**
+     * Article publication date in W3C format, using either the "complete date" (YYYY-MM-DD) format or the "complete date
+     * plus hours, minutes, and seconds"
+     */
+    publication_date: string;
+    /**
+     * The title of the news article
+     * @example 'Companies A, B in Merger Talks'
+     */
+    title: string;
+    /**
+     * @example 'business, merger, acquisition'
+     */
+    keywords?: string;
+    /**
+     * @example 'NASDAQ:A, NASDAQ:B'
+     */
+    stock_tickers?: string;
+}
+/**
+ * Sitemap Image
+ * https://support.google.com/webmasters/answer/178636?hl=en&ref_topic=4581190
+ */
+interface Img {
+    /**
+     * The URL of the image
+     * @example 'https://example.com/image.jpg'
+     */
+    url: string;
+    /**
+     * The caption of the image
+     * @example 'Thanksgiving dinner'
+     */
+    caption?: string;
+    /**
+     * The title of the image
+     * @example 'Star Wars EP IV'
+     */
+    title?: string;
+    /**
+     * The geographic location of the image.
+     * @example 'Limerick, Ireland'
+     */
+    geoLocation?: string;
+    /**
+     * A URL to the license of the image.
+     * @example 'https://example.com/license.txt'
+     */
+    license?: string;
+}
+/**
+ * https://support.google.com/webmasters/answer/189077
+ */
+interface LinkItem {
+    /**
+     * @example 'en'
+     */
+    lang: string;
+    /**
+     * @example 'en-us'
+     */
+    hreflang?: string;
+    url: string;
+}
+/**
+ * How to handle errors in passed in urls
+ */
+declare enum ErrorLevel {
+    /**
+     * Validation will be skipped and nothing logged or thrown.
+     */
+    SILENT = "silent",
+    /**
+     * If an invalid value is encountered, a console.warn will be called with details
+     */
+    WARN = "warn",
+    /**
+     * An Error will be thrown on encountering invalid data.
+     */
+    THROW = "throw"
+}
+declare type ErrorHandler = (error: Error, level: ErrorLevel) => void;
+
+interface NSArgs {
+    news: boolean;
+    video: boolean;
+    xhtml: boolean;
+    image: boolean;
+    custom?: string[];
+}
+interface SitemapStreamOptions extends TransformOptions {
+    hostname?: string;
+    level?: ErrorLevel;
+    lastmodDateOnly?: boolean;
+    xmlns?: NSArgs;
+    xslUrl?: string;
+    errorHandler?: ErrorHandler;
+}
+
+interface SitemapItem {
+    lastmod?: string | number | Date;
+    changefreq?: `${EnumChangefreq}`;
+    fullPrecisionPriority?: boolean;
+    priority?: number;
+    news?: NewsItem;
+    expires?: string;
+    androidLink?: string;
+    ampLink?: string;
+    url: string;
+    video?: any;
+    img?: string | Img | (string | Img)[];
+    links?: LinkItem[];
+    lastmodfile?: string | Buffer | URL;
+    lastmodISO?: string;
+    lastmodrealtime?: boolean;
+}
+
+/**
+ * Options of @mdit-vue/plugin-component
+ */
+interface ComponentPluginOptions {
+    /**
+     * Extra tags to be treated as block tags.
+     *
+     * @default []
+     */
+    blockTags?: string[];
+    /**
+     * Extra tags to be treated as inline tags.
+     *
+     * @default []
+     */
+    inlineTags?: string[];
+}
+
+/**
+ * Takes a string or object with `content` property, extracts
+ * and parses front-matter from the string, then returns an object
+ * with `data`, `content` and other [useful properties](#returned-object).
+ *
+ * ```js
+ * var matter = require('gray-matter');
+ * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
+ * //=> { data: { title: 'Home'}, content: 'Other stuff' }
+ * ```
+ * @param {Object|String} `input` String, or object with `content` string
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+declare function matter<
+  I extends matter.Input,
+  O extends matter.GrayMatterOption<I, O>
+>(input: I | { content: I }, options?: O): matter.GrayMatterFile<I>
+
+declare namespace matter {
+  type Input = string | Buffer
+  interface GrayMatterOption<
+    I extends Input,
+    O extends GrayMatterOption<I, O>
+  > {
+    parser?: () => void
+    eval?: boolean
+    excerpt?: boolean | ((input: I, options: O) => string)
+    excerpt_separator?: string
+    engines?: {
+      [index: string]:
+        | ((input: string) => object)
+        | { parse: (input: string) => object; stringify?: (data: object) => string }
+    }
+    language?: string
+    delimiters?: string | [string, string]
+  }
+  interface GrayMatterFile<I extends Input> {
+    data: { [key: string]: any }
+    content: string
+    excerpt?: string
+    orig: Buffer | I
+    language: string
+    matter: string
+    stringify(lang: string): string
+  }
+  
+  /**
+   * Stringify an object to YAML or the specified language, and
+   * append it to the given string. By default, only YAML and JSON
+   * can be stringified. See the [engines](#engines) section to learn
+   * how to stringify other languages.
+   *
+   * ```js
+   * console.log(matter.stringify('foo bar baz', {title: 'Home'}));
+   * // results in:
+   * // ---
+   * // title: Home
+   * // ---
+   * // foo bar baz
+   * ```
+   * @param {String|Object} `file` The content string to append to stringified front-matter, or a file object with `file.content` string.
+   * @param {Object} `data` Front matter to stringify.
+   * @param {Object} `options` [Options](#options) to pass to gray-matter and [js-yaml].
+   * @return {String} Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.
+   */
+  export function stringify<O extends GrayMatterOption<string, O>>(
+    file: string | { content: string },
+    data: object,
+    options?: GrayMatterOption<string, O>
+  ): string
+
+  /**
+   * Synchronously read a file from the file system and parse
+   * front matter. Returns the same object as the [main function](#matter).
+   *
+   * ```js
+   * var file = matter.read('./content/blog-post.md');
+   * ```
+   * @param {String} `filepath` file path of the file to read.
+   * @param {Object} `options` [Options](#options) to pass to gray-matter.
+   * @return {Object} Returns [an object](#returned-object) with `data` and `content`
+   */
+  export function read<O extends GrayMatterOption<string, O>>(
+    fp: string,
+    options?: GrayMatterOption<string, O>
+  ): matter.GrayMatterFile<string>
+
+  /**
+   * Returns true if the given `string` has front matter.
+   * @param  {String} `string`
+   * @param  {Object} `options`
+   * @return {Boolean} True if front matter exists.
+   */
+  export function test<O extends matter.GrayMatterOption<string, O>>(
+    str: string,
+    options?: GrayMatterOption<string, O>
+  ): boolean
+
+  /**
+   * Detect the language to use, if one is defined after the
+   * first front-matter delimiter.
+   * @param  {String} `string`
+   * @param  {Object} `options`
+   * @return {Object} Object with `raw` (actual language string), and `name`, the language with whitespace trimmed
+   */
+  export function language<O extends matter.GrayMatterOption<string, O>>(
+    str: string,
+    options?: GrayMatterOption<string, O>
+  ): { name: string; raw: string }
+}
+
+type GrayMatterOptions = matter.GrayMatterOption<string, GrayMatterOptions>;
+/**
+ * Options of @mdit-vue/plugin-frontmatter
+ */
+interface FrontmatterPluginOptions {
+    /**
+     * Options of gray-matter
+     *
+     * @see https://github.com/jonschlinkert/gray-matter#options
+     */
+    grayMatterOptions?: GrayMatterOptions;
+    /**
+     * Render the excerpt or not
+     *
+     * @default true
+     */
+    renderExcerpt?: boolean;
+}
+declare module '@mdit-vue/types' {
+    interface MarkdownItEnv {
+        /**
+         * The raw Markdown content without frontmatter
+         */
+        content?: string;
+        /**
+         * The excerpt that extracted by `@mdit-vue/plugin-frontmatter`
+         *
+         * - Would be the rendered HTML when `renderExcerpt` is enabled
+         * - Would be the raw Markdown when `renderExcerpt` is disabled
+         */
+        excerpt?: string;
+        /**
+         * The frontmatter that extracted by `@mdit-vue/plugin-frontmatter`
+         */
+        frontmatter?: Record<string, unknown>;
+    }
+}
+
+interface MarkdownItHeader {
+    /**
+     * The level of the header
+     *
+     * `1` to `6` for `<h1>` to `<h6>`
+     */
+    level: number;
+    /**
+     * The title of the header
+     */
+    title: string;
+    /**
+     * The slug of the header
+     *
+     * Typically the `id` attr of the header anchor
+     */
+    slug: string;
+    /**
+     * Link of the header
+     *
+     * Typically using `#${slug}` as the anchor hash
+     */
+    link: string;
+    /**
+     * The children of the header
+     */
+    children: MarkdownItHeader[];
+}
+
+/**
+ * Options of @mdit-vue/plugin-headers
+ */
+interface HeadersPluginOptions {
+    /**
+     * A custom slugification function
+     *
+     * Should use the same slugify function with markdown-it-anchor
+     * to ensure the link is matched
+     */
+    slugify?: (str: string) => string;
+    /**
+     * A function for formatting header title
+     */
+    format?: (str: string) => string;
+    /**
+     * Heading level that going to be extracted
+     *
+     * Should be a subset of markdown-it-anchor's `level` option
+     * to ensure the slug is existed
+     *
+     * @default [2,3]
+     */
+    level?: number[];
+    /**
+     * Should allow headers inside nested blocks or not
+     *
+     * If set to `true`, headers inside blockquote, list, etc. would also be extracted.
+     *
+     * @default false
+     */
+    shouldAllowNested?: boolean;
+}
+declare module '@mdit-vue/types' {
+    interface MarkdownItEnv {
+        /**
+         * The headers that extracted by `@mdit-vue/plugin-headers`
+         */
+        headers?: MarkdownItHeader[];
+    }
+}
+
+/**
+ * Options of @mdit-vue/plugin-sfc
+ */
+interface SfcPluginOptions {
+    /**
+     * Custom blocks to be extracted
+     *
+     * @default []
+     */
+    customBlocks?: string[];
+}
+/**
+ * SFC block that extracted from markdown
+ */
+interface SfcBlock {
+    /**
+     * The type of the block
+     */
+    type: string;
+    /**
+     * The content, including open-tag and close-tag
+     */
+    content: string;
+    /**
+     * The content that stripped open-tag and close-tag off
+     */
+    contentStripped: string;
+    /**
+     * The open-tag
+     */
+    tagOpen: string;
+    /**
+     * The close-tag
+     */
+    tagClose: string;
+}
+interface MarkdownSfcBlocks {
+    /**
+     * The `<template>` block
+     */
+    template: SfcBlock | null;
+    /**
+     * The common `<script>` block
+     */
+    script: SfcBlock | null;
+    /**
+     * The `<script setup>` block
+     */
+    scriptSetup: SfcBlock | null;
+    /**
+     * All `<script>` blocks.
+     *
+     * By default, SFC only allows one `<script>` block and one `<script setup>` block.
+     * However, some tools may support different types of `<script>`s, so we keep all of them here.
+     */
+    scripts: SfcBlock[];
+    /**
+     * All `<style>` blocks.
+     */
+    styles: SfcBlock[];
+    /**
+     * All custom blocks.
+     */
+    customBlocks: SfcBlock[];
+}
+declare module '@mdit-vue/types' {
+    interface MarkdownItEnv {
+        /**
+         * SFC blocks that extracted by `@mdit-vue/plugin-sfc`
+         */
+        sfcBlocks?: MarkdownSfcBlocks;
+    }
+}
+
+/**
+ * Options of @mdit-vue/plugin-toc
+ */
+interface TocPluginOptions {
+    /**
+     * The pattern serving as the TOC placeholder in your markdown
+     *
+     * @default /^\[\[toc\]\]$/i
+     */
+    pattern?: RegExp;
+    /**
+     * A custom slugification function
+     *
+     * Should use the same slugify function with markdown-it-anchor
+     * to ensure the link is matched
+     */
+    slugify?: (str: string) => string;
+    /**
+     * A function for formatting headings
+     */
+    format?: (str: string) => string;
+    /**
+     * Heading level that going to be included in the TOC
+     *
+     * Should be a subset of markdown-it-anchor's `level` option
+     * to ensure the link is existed
+     *
+     * @default [2,3]
+     */
+    level?: number[];
+    /**
+     * Should allow headers inside nested blocks or not
+     *
+     * If set to `true`, headers inside blockquote, list, etc. would also be included.
+     *
+     * @default false
+     */
+    shouldAllowNested?: boolean;
+    /**
+     * HTML tag of the TOC container
+     *
+     * @default 'nav'
+     */
+    containerTag?: string;
+    /**
+     * The class for the TOC container
+     *
+     * @default 'table-of-contents'
+     */
+    containerClass?: string;
+    /**
+     * HTML tag of the TOC list
+     *
+     * @default 'ul'
+     */
+    listTag?: 'ul' | 'ol';
+    /**
+     * The class for the TOC list
+     *
+     * @default ''
+     */
+    listClass?: string;
+    /**
+     * The class for the `<li>` tag
+     *
+     * @default ''
+     */
+    itemClass?: string;
+    /**
+     * The tag of the link inside `<li>` tag
+     *
+     * @default 'a'
+     */
+    linkTag?: 'a' | 'router-link';
+    /**
+     * The class for the link inside the `<li>` tag
+     *
+     * @default ''
+     */
+    linkClass?: string;
+}
+
+declare namespace anchor {
+  export type RenderHref = (slug: string, state: StateCore) => string;
+  export type RenderAttrs = (slug: string, state: StateCore) => Record<string, string | number>;
+
+  export interface PermalinkOptions {
+    class?: string,
+    symbol?: string,
+    renderHref?: RenderHref,
+    renderAttrs?: RenderAttrs
+  }
+
+  export interface HeaderLinkPermalinkOptions extends PermalinkOptions {
+    safariReaderFix?: boolean;
+  }
+
+  export interface LinkAfterHeaderPermalinkOptions extends PermalinkOptions {
+    style?: 'visually-hidden' | 'aria-label' | 'aria-describedby' | 'aria-labelledby',
+    assistiveText?: (title: string) => string,
+    visuallyHiddenClass?: string,
+    space?: boolean | string,
+    placement?: 'before' | 'after'
+    wrapper?: [string, string] | null
+  }
+
+  export interface LinkInsideHeaderPermalinkOptions extends PermalinkOptions {
+    space?: boolean | string,
+    placement?: 'before' | 'after',
+    ariaHidden?: boolean
+  }
+
+  export interface AriaHiddenPermalinkOptions extends PermalinkOptions {
+    space?: boolean | string,
+    placement?: 'before' | 'after'
+  }
+
+  export type PermalinkGenerator = (slug: string, opts: PermalinkOptions, state: StateCore, index: number) => void;
+
+  export interface AnchorInfo {
+    slug: string;
+    title: string;
+  }
+
+  export interface AnchorOptions {
+    level?: number | number[];
+
+    slugify?(str: string): string;
+    getTokensText?(tokens: Token[]): string;
+
+    uniqueSlugStartIndex?: number;
+    permalink?: PermalinkGenerator;
+
+    callback?(token: Token, anchor_info: AnchorInfo): void;
+
+    tabIndex?: number | false;
+  }
+
+  export const permalink: {
+    headerLink: (opts?: HeaderLinkPermalinkOptions) => PermalinkGenerator
+    linkAfterHeader: (opts?: LinkAfterHeaderPermalinkOptions) => PermalinkGenerator
+    linkInsideHeader: (opts?: LinkInsideHeaderPermalinkOptions) => PermalinkGenerator
+    ariaHidden: (opts?: AriaHiddenPermalinkOptions) => PermalinkGenerator
+  };
+}
+
+declare function anchor(md: MarkdownIt, opts?: anchor.AnchorOptions): void;
+
+interface ContainerOptions {
+    infoLabel?: string;
+    noteLabel?: string;
+    tipLabel?: string;
+    warningLabel?: string;
+    dangerLabel?: string;
+    detailsLabel?: string;
+    importantLabel?: string;
+    cautionLabel?: string;
+}
+
+interface Options$1 {
+    /**
+     * Support native lazy loading for the `<img>` tag.
+     * @default false
+     */
+    lazyLoading?: boolean;
+}
+
+type ThemeOptions = ThemeRegistrationAny | BuiltinTheme | {
+    light: ThemeRegistrationAny | BuiltinTheme;
+    dark: ThemeRegistrationAny | BuiltinTheme;
+};
+interface MarkdownOptions extends MarkdownIt.Options {
+    /**
+     * Setup markdown-it instance before applying plugins
+     */
+    preConfig?: (md: MarkdownIt) => void;
+    /**
+     * Setup markdown-it instance
+     */
+    config?: (md: MarkdownIt) => void;
+    /**
+     * Disable cache (experimental)
+     */
+    cache?: boolean;
+    externalLinks?: Record<string, string>;
+    /**
+     * Custom theme for syntax highlighting.
+     *
+     * You can also pass an object with `light` and `dark` themes to support dual themes.
+     *
+     * @example { theme: 'github-dark' }
+     * @example { theme: { light: 'github-light', dark: 'github-dark' } }
+     *
+     * You can use an existing theme.
+     * @see https://shiki.style/themes
+     * Or add your own theme.
+     * @see https://shiki.style/guide/load-theme
+     */
+    theme?: ThemeOptions;
+    /**
+     * Languages for syntax highlighting.
+     * @see https://shiki.style/languages
+     */
+    languages?: LanguageInput[];
+    /**
+     * Custom language aliases.
+     *
+     * @example { 'my-lang': 'js' }
+     * @see https://shiki.style/guide/load-lang#custom-language-aliases
+     */
+    languageAlias?: Record<string, string>;
+    /**
+     * Show line numbers in code blocks
+     * @default false
+     */
+    lineNumbers?: boolean;
+    /**
+     * Fallback language when the specified language is not available.
+     */
+    defaultHighlightLang?: string;
+    /**
+     * Transformers applied to code blocks
+     * @see https://shiki.style/guide/transformers
+     */
+    codeTransformers?: ShikiTransformer[];
+    /**
+     * Setup Shiki instance
+     */
+    shikiSetup?: (shiki: Highlighter) => void | Promise<void>;
+    /**
+     * Options for `markdown-it-anchor`
+     * @see https://github.com/valeriangalliat/markdown-it-anchor
+     */
+    anchor?: anchor.AnchorOptions;
+    /**
+     * Options for `markdown-it-attrs`
+     * @see https://github.com/arve0/markdown-it-attrs
+     */
+    attrs?: {
+        leftDelimiter?: string;
+        rightDelimiter?: string;
+        allowedAttributes?: Array<string | RegExp>;
+        disable?: boolean;
+    };
+    /**
+     * Options for `markdown-it-emoji`
+     * @see https://github.com/markdown-it/markdown-it-emoji
+     */
+    emoji?: {
+        defs?: Record<string, string>;
+        enabled?: string[];
+        shortcuts?: Record<string, string | string[]>;
+    };
+    /**
+     * Options for `@mdit-vue/plugin-frontmatter`
+     * @see https://github.com/mdit-vue/mdit-vue/tree/main/packages/plugin-frontmatter
+     */
+    frontmatter?: FrontmatterPluginOptions;
+    /**
+     * Options for `@mdit-vue/plugin-headers`
+     * @see https://github.com/mdit-vue/mdit-vue/tree/main/packages/plugin-headers
+     */
+    headers?: HeadersPluginOptions | boolean;
+    /**
+     * Options for `@mdit-vue/plugin-sfc`
+     * @see https://github.com/mdit-vue/mdit-vue/tree/main/packages/plugin-sfc
+     */
+    sfc?: SfcPluginOptions;
+    /**
+     * Options for `@mdit-vue/plugin-toc`
+     * @see https://github.com/mdit-vue/mdit-vue/tree/main/packages/plugin-toc
+     */
+    toc?: TocPluginOptions;
+    /**
+     * Options for `@mdit-vue/plugin-component`
+     * @see https://github.com/mdit-vue/mdit-vue/tree/main/packages/plugin-component
+     */
+    component?: ComponentPluginOptions;
+    /**
+     * Options for `markdown-it-container`
+     * @see https://github.com/markdown-it/markdown-it-container
+     */
+    container?: ContainerOptions;
+    /**
+     * Math support (experimental)
+     *
+     * You need to install `markdown-it-mathjax3` and set `math` to `true` to enable it.
+     * You can also pass options to `markdown-it-mathjax3` here.
+     * @default false
+     * @see https://vitepress.dev/guide/markdown#math-equations
+     */
+    math?: boolean | any;
+    image?: Options$1;
+    /**
+     * Allows disabling the github alerts plugin
+     * @default true
+     * @see https://vitepress.dev/guide/markdown#github-flavored-alerts
+     */
+    gfmAlerts?: boolean;
+}
+type MarkdownRenderer = MarkdownIt;
+declare const createMarkdownRenderer: (srcDir: string, options?: MarkdownOptions, base?: string, logger?: Pick<Logger, 'warn'>) => Promise<MarkdownRenderer>;
+
+type RawConfigExports<ThemeConfig = any> = Awaitable<UserConfig<ThemeConfig>> | (() => Awaitable<UserConfig<ThemeConfig>>);
+interface TransformContext {
+    page: string;
+    siteConfig: SiteConfig;
+    siteData: SiteData;
+    pageData: PageData;
+    title: string;
+    description: string;
+    head: HeadConfig[];
+    content: string;
+    assets: string[];
+}
+interface UserRouteConfig {
+    params: Record<string, string>;
+    content?: string;
+}
+type ResolvedRouteConfig = UserRouteConfig & {
+    /**
+     * the raw route (relative to src root), e.g. foo/[bar].md
+     */
+    route: string;
+    /**
+     * the actual path with params resolved (relative to src root), e.g. foo/1.md
+     */
+    path: string;
+    /**
+     * absolute fs path
+     */
+    fullPath: string;
+};
+interface TransformPageContext {
+    siteConfig: SiteConfig;
+}
+interface UserConfig<ThemeConfig = any> extends LocaleSpecificConfig<ThemeConfig> {
+    extends?: RawConfigExports<ThemeConfig>;
+    base?: string;
+    srcDir?: string;
+    srcExclude?: string[];
+    outDir?: string;
+    assetsDir?: string;
+    cacheDir?: string;
+    shouldPreload?: (link: string, page: string) => boolean;
+    locales?: LocaleConfig<ThemeConfig>;
+    router?: {
+        prefetchLinks?: boolean;
+    };
+    appearance?: boolean | 'dark' | 'force-dark' | (Omit<UseDarkOptions, 'initialValue'> & {
+        initialValue?: 'dark';
+    });
+    lastUpdated?: boolean;
+    contentProps?: Record<string, any>;
+    /**
+     * MarkdownIt options
+     */
+    markdown?: MarkdownOptions;
+    /**
+     * Options to pass on to `@vitejs/plugin-vue`
+     */
+    vue?: Options$3;
+    /**
+     * Vite config
+     */
+    vite?: UserConfig$1 & {
+        configFile?: string | false;
+    };
+    /**
+     * Configure the scroll offset when the theme has a sticky header.
+     * Can be a number or a selector element to get the offset from.
+     * Can also be an array of selectors in case some elements will be
+     * invisible due to responsive layout. VitePress will fallback to the next
+     * selector if a selector fails to match, or the matched element is not
+     * currently visible in viewport.
+     */
+    scrollOffset?: number | string | string[] | {
+        selector: string | string[];
+        padding: number;
+    };
+    /**
+     * Enable MPA / zero-JS mode.
+     * @experimental
+     */
+    mpa?: boolean;
+    /**
+     * Extracts metadata to a separate chunk.
+     * @experimental
+     */
+    metaChunk?: boolean;
+    /**
+     * Don't fail builds due to dead links.
+     *
+     * @default false
+     */
+    ignoreDeadLinks?: boolean | 'localhostLinks' | (string | RegExp | ((link: string) => boolean))[];
+    /**
+     * Don't force `.html` on URLs.
+     *
+     * @default false
+     */
+    cleanUrls?: boolean;
+    /**
+     * Use web fonts instead of emitting font files to dist.
+     * The used theme should import a file named `fonts.(s)css` for this to work.
+     * If you are a theme author, to support this, place your web font import
+     * between `webfont-marker-begin` and `webfont-marker-end` comments.
+     *
+     * @default true in webcontainers, else false
+     */
+    useWebFonts?: boolean;
+    /**
+     * This option allows you to configure the concurrency of the build.
+     * A lower number will reduce the memory usage but will increase the build time.
+     *
+     * @experimental
+     * @default 64
+     */
+    buildConcurrency?: number;
+    /**
+     * @experimental
+     *
+     * source -> destination
+     */
+    rewrites?: Record<string, string>;
+    /**
+     * @experimental
+     */
+    sitemap?: SitemapStreamOptions & {
+        hostname: string;
+        transformItems?: (items: SitemapItem[]) => Awaitable<SitemapItem[]>;
+    };
+    /**
+     * Build end hook: called when SSG finish.
+     * @param siteConfig The resolved configuration.
+     */
+    buildEnd?: (siteConfig: SiteConfig) => Awaitable<void>;
+    /**
+     * Render end hook: called when SSR rendering is done.
+     */
+    postRender?: (context: SSGContext) => Awaitable<SSGContext | void>;
+    /**
+     * Head transform hook: runs before writing HTML to dist.
+     *
+     * This build hook will allow you to modify the head adding new entries that cannot be statically added.
+     */
+    transformHead?: (context: TransformContext) => Awaitable<HeadConfig[] | void>;
+    /**
+     * HTML transform hook: runs before writing HTML to dist.
+     */
+    transformHtml?: (code: string, id: string, ctx: TransformContext) => Awaitable<string | void>;
+    /**
+     * PageData transform hook: runs when rendering markdown to vue
+     */
+    transformPageData?: (pageData: PageData, ctx: TransformPageContext) => Awaitable<Partial<PageData> | {
+        [key: string]: any;
+    } | void>;
+}
+interface SiteConfig<ThemeConfig = any> extends Pick<UserConfig, 'markdown' | 'vue' | 'vite' | 'shouldPreload' | 'router' | 'mpa' | 'metaChunk' | 'lastUpdated' | 'ignoreDeadLinks' | 'cleanUrls' | 'useWebFonts' | 'postRender' | 'buildEnd' | 'transformHead' | 'transformHtml' | 'transformPageData' | 'sitemap'> {
+    root: string;
+    srcDir: string;
+    site: SiteData<ThemeConfig>;
+    configPath: string | undefined;
+    configDeps: string[];
+    themeDir: string;
+    outDir: string;
+    assetsDir: string;
+    cacheDir: string;
+    tempDir: string;
+    pages: string[];
+    dynamicRoutes: {
+        routes: ResolvedRouteConfig[];
+        fileToModulesMap: Record<string, Set<string>>;
+    };
+    rewrites: {
+        map: Record<string, string | undefined>;
+        inv: Record<string, string | undefined>;
+    };
+    logger: Logger;
+    userConfig: UserConfig;
+    buildConcurrency: number;
+}
+
+declare function resolvePages(srcDir: string, userConfig: UserConfig, logger: Logger): Promise<{
+    pages: string[];
+    dynamicRoutes: {
+        routes: ResolvedRouteConfig[];
+        fileToModulesMap: Record<string, Set<string>>;
+    };
+    rewrites: {
+        map: Record<string, string>;
+        inv: Record<string, string>;
+    };
+}>;
+
+type UserConfigFn<ThemeConfig> = (env: ConfigEnv) => UserConfig<ThemeConfig> | Promise<UserConfig<ThemeConfig>>;
+type UserConfigExport<ThemeConfig> = UserConfig<ThemeConfig> | Promise<UserConfig<ThemeConfig>> | UserConfigFn<ThemeConfig>;
+/**
+ * Type config helper
+ */
+declare function defineConfig(config: UserConfig<DefaultTheme.Config>): UserConfig<DefaultTheme.Config>;
+/**
+ * Type config helper for custom theme config
+ */
+declare function defineConfigWithTheme<ThemeConfig>(config: UserConfig<ThemeConfig>): UserConfig<ThemeConfig>;
+declare function resolveConfig(root?: string, command?: 'serve' | 'build', mode?: string): Promise<SiteConfig>;
+declare function resolveUserConfig(root: string, command: 'serve' | 'build', mode: string): Promise<[UserConfig, string | undefined, string[]]>;
+declare function mergeConfig(a: UserConfig, b: UserConfig, isRoot?: boolean): Record<string, any>;
+declare function resolveSiteData(root: string, userConfig?: UserConfig, command?: 'serve' | 'build', mode?: string): Promise<SiteData>;
+
+interface ContentOptions<T = ContentData[]> {
+    /**
+     * Include src?
+     * @default false
+     */
+    includeSrc?: boolean;
+    /**
+     * Render src to HTML and include in data?
+     * @default false
+     */
+    render?: boolean;
+    /**
+     * If `boolean`, whether to parse and include excerpt? (rendered as HTML)
+     *
+     * If `function`, control how the excerpt is extracted from the content.
+     *
+     * If `string`, define a custom separator to be used for extracting the
+     * excerpt. Default separator is `---` if `excerpt` is `true`.
+     *
+     * @see https://github.com/jonschlinkert/gray-matter#optionsexcerpt
+     * @see https://github.com/jonschlinkert/gray-matter#optionsexcerpt_separator
+     *
+     * @default false
+     */
+    excerpt?: boolean | ((file: {
+        data: {
+            [key: string]: any;
+        };
+        content: string;
+        excerpt?: string;
+    }, options?: any) => void) | string;
+    /**
+     * Transform the data. Note the data will be inlined as JSON in the client
+     * bundle if imported from components or markdown files.
+     */
+    transform?: (data: ContentData[]) => T | Promise<T>;
+    /**
+     * Options to pass to `fast-glob`.
+     * You'll need to manually specify `node_modules` and `dist` in
+     * `globOptions.ignore` if you've overridden it.
+     */
+    globOptions?: glob.Options;
+}
+interface ContentData {
+    url: string;
+    src: string | undefined;
+    html: string | undefined;
+    frontmatter: Record<string, any>;
+    excerpt: string | undefined;
+}
+/**
+ * Create a loader object that can be directly used as the default export
+ * of a data loader file.
+ */
+declare function createContentLoader<T = ContentData[]>(
+/**
+ * files to glob / watch - relative to srcDir
+ */
+pattern: string | string[], { includeSrc, render, excerpt: renderExcerpt, transform, globOptions }?: ContentOptions<T>): {
+    watch: string | string[];
+    load: () => Promise<T>;
+};
+
+declare enum ScaffoldThemeType {
+    Default = "default theme",
+    DefaultCustom = "default theme + customization",
+    Custom = "custom theme"
+}
+interface ScaffoldOptions {
+    root: string;
+    title?: string;
+    description?: string;
+    theme: ScaffoldThemeType;
+    useTs: boolean;
+    injectNpmScripts: boolean;
+}
+declare function init(): Promise<void>;
+declare function scaffold({ root, title, description, theme, useTs, injectNpmScripts }: ScaffoldOptions): string;
+
+interface LoaderModule {
+    watch?: string[] | string;
+    load: (watchedFiles: string[]) => any;
+}
+/**
+ * Helper for defining loaders with type inference
+ */
+declare function defineLoader(loader: LoaderModule): LoaderModule;
+
+interface Options {
+    prefix?: string | undefined;
+    exclude?: ReadonlyArray<string | RegExp> | undefined;
+    ignoreFiles?: ReadonlyArray<string | RegExp> | undefined;
+    includeFiles?: ReadonlyArray<string | RegExp> | undefined;
+    transform?:
+        | ((
+            prefix: Readonly<string>,
+            selector: Readonly<string>,
+            prefixedSelector: Readonly<string>,
+            file: Readonly<string>,
+        ) => string)
+        | undefined;
+}
+
+declare function postcssPrefixSelector(options: Readonly<Options>): (root: Root) => void;
+
+declare function postcssIsolateStyles(options?: Parameters<typeof postcssPrefixSelector>[0]): ReturnType<typeof postcssPrefixSelector>;
+
+interface ParsedURL {
+	pathname: string;
+	search: string;
+	query: Record<string, string | string[]> | void;
+	raw: string;
+}
+
+// Thank you: @fwilkerson, @stahlstift
+// ---
+
+/** @type {import('http').METHODS} */
+type Methods = 'ACL' | 'BIND' | 'CHECKOUT' | 'CONNECT' | 'COPY' | 'DELETE' | 'GET' | 'HEAD' | 'LINK' | 'LOCK' |'M-SEARCH' | 'MERGE' | 'MKACTIVITY' |'MKCALENDAR' | 'MKCOL' | 'MOVE' |'NOTIFY' | 'OPTIONS' | 'PATCH' | 'POST' | 'PRI' | 'PROPFIND' |  'PROPPATCH' |  'PURGE' | 'PUT' | 'REBIND' | 'REPORT' | 'SEARCH' | 'SOURCE' | 'SUBSCRIBE' | 'TRACE' | 'UNBIND' | 'UNLINK' | 'UNLOCK' | 'UNSUBSCRIBE';
+
+type Pattern = RegExp | string;
+
+declare class Trouter<T = Function> {
+	find(method: Methods, url: string): {
+		params: Record<string, string>;
+		handlers: T[];
+	};
+	add(method: Methods, pattern: Pattern, ...handlers: T[]): this;
+	use(pattern: Pattern, ...handlers: T[]): this;
+	all(pattern: Pattern, ...handlers: T[]): this;
+	get(pattern: Pattern, ...handlers: T[]): this;
+	head(pattern: Pattern, ...handlers: T[]): this;
+	patch(pattern: Pattern, ...handlers: T[]): this;
+	options(pattern: Pattern, ...handlers: T[]): this;
+	connect(pattern: Pattern, ...handlers: T[]): this;
+	delete(pattern: Pattern, ...handlers: T[]): this;
+	trace(pattern: Pattern, ...handlers: T[]): this;
+	post(pattern: Pattern, ...handlers: T[]): this;
+	put(pattern: Pattern, ...handlers: T[]): this;
+}
+
+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 ServeOptions {
+    base?: string;
+    root?: string;
+    port?: number;
+}
+declare function serve(options?: ServeOptions): Promise<polka.Polka<polka.Request>>;
+
+declare function createServer(root?: string, serverOptions?: ServerOptions & {
+    base?: string;
+}, recreateServer?: () => Promise<void>): Promise<vite.ViteDevServer>;
+
+export { type ContentData, type ContentOptions, DefaultTheme, type HeadConfig, type Header, type LoaderModule, type MarkdownOptions, type MarkdownRenderer, type RawConfigExports, type ResolvedRouteConfig, type ScaffoldOptions, ScaffoldThemeType, type ServeOptions, type SiteConfig, type SiteData, type ThemeOptions, type TransformContext, type TransformPageContext, type UserConfig, type UserConfigExport, type UserConfigFn, build, createContentLoader, createMarkdownRenderer, createServer, defineConfig, defineConfigWithTheme, defineLoader, init, mergeConfig, postcssIsolateStyles, resolveConfig, resolvePages, resolveSiteData, resolveUserConfig, scaffold, serve };