@vuepress/client 2.0.0-rc.3 → 2.0.0-rc.31

package/dist/index-wQR7Pl0s.d.ts

@@ -0,0 +1,112 @@
+import { App, Component, ComputedRef, Ref } from "vue";
+import { HeadConfig, PageData, PageFrontmatter, PageHeader, SiteData, SiteLocaleData } from "@vuepress/shared";
+import { Router } from "vue-router";
+//#region src/constants.d.ts
+/**
+ * Name of the default layout
+ */
+declare const LAYOUT_NAME_DEFAULT = "Layout";
+/**
+ * Name of the 404 page layout
+ */
+declare const LAYOUT_NAME_NOT_FOUND = "NotFound";
+//#endregion
+//#region src/types/routes.d.ts
+interface PageChunk {
+  default: Component;
+  _pageData: PageData;
+}
+type RouteMeta = Record<string, unknown>;
+interface Route<T extends RouteMeta = RouteMeta> {
+  loader: () => Promise<PageChunk>;
+  meta: T;
+}
+type Redirects = Record<string, string>;
+type Routes = Record<string, Route>;
+//#endregion
+//#region src/types/clientData.d.ts
+interface Layouts {
+  [LAYOUT_NAME_DEFAULT]: Component;
+  [LAYOUT_NAME_NOT_FOUND]: Component;
+  [key: string]: Component;
+}
+type PageComponent = Component;
+type PageHead = HeadConfig[];
+type PageHeadTitle = string;
+type PageLang = string;
+type PageLayout = Component;
+type RoutePath = string;
+type RouteLocale = string;
+type LayoutsRef = ComputedRef<Layouts>;
+type PageComponentRef = ComputedRef<PageComponent>;
+type PageDataRef<T extends Record<string, unknown> = Record<string, unknown>> = ComputedRef<PageData<T>>;
+type PageFrontmatterRef<T extends Record<string, unknown> = Record<string, unknown>> = ComputedRef<PageFrontmatter<T>>;
+type PageHeadRef = ComputedRef<PageHead>;
+type PageHeadTitleRef = ComputedRef<PageHeadTitle>;
+type PageLangRef = ComputedRef<PageLang>;
+type PageLayoutRef = ComputedRef<PageLayout>;
+type RedirectsRef = Ref<Redirects>;
+type RoutePathRef = ComputedRef<RoutePath>;
+type RouteLocaleRef = ComputedRef<RouteLocale>;
+type RoutesRef = Ref<Routes>;
+type SiteDataRef = Ref<SiteData>;
+type SiteLocaleDataRef = ComputedRef<SiteLocaleData>;
+interface ClientData<Frontmatter extends Record<string, unknown> = Record<string, unknown>, Data extends Record<string, unknown> = Record<string, unknown>> {
+  layouts: LayoutsRef;
+  pageComponent: PageComponentRef;
+  pageData: PageDataRef<Data>;
+  pageFrontmatter: PageFrontmatterRef<Frontmatter>;
+  pageHead: PageHeadRef;
+  pageHeadTitle: PageHeadTitleRef;
+  pageLang: PageLangRef;
+  pageLayout: PageLayoutRef;
+  redirects: RedirectsRef;
+  routePath: RoutePathRef;
+  routeLocale: RouteLocaleRef;
+  routes: RoutesRef;
+  siteData: SiteDataRef;
+  siteLocaleData: SiteLocaleDataRef;
+  frontmatter: PageFrontmatterRef<Frontmatter>;
+  head: PageHeadRef;
+  headTitle: PageHeadTitleRef;
+  lang: PageLangRef;
+  page: PageDataRef<Data>;
+  site: SiteDataRef;
+  siteLocale: SiteLocaleDataRef;
+}
+//#endregion
+//#region src/types/clientConfig.d.ts
+/**
+ * Configure vuepress client
+ */
+interface ClientConfig {
+  /**
+   * An enhance function to be called after vue app instance and
+   * vue-router instance has been created
+   */
+  enhance?: (context: {
+    app: App;
+    router: Router;
+    siteData: SiteDataRef;
+  }) => Promise<void> | void;
+  /**
+   * A function to be called inside the setup function of vue app
+   */
+  setup?: () => void;
+  /**
+   * Layout components
+   */
+  layouts?: Partial<Layouts>;
+  /**
+   * Components to be placed directly into the root node of vue app
+   */
+  rootComponents?: Component[];
+}
+//#endregion
+//#region src/types/createVueAppFunction.d.ts
+type CreateVueAppFunction = () => Promise<{
+  app: App;
+  router: Router;
+}>;
+//#endregion
+export { SiteLocaleData as A, RouteLocale as C, RoutesRef as D, RoutePathRef as E, RouteMeta as F, Routes as I, PageChunk as M, Redirects as N, SiteData as O, Route as P, RedirectsRef as S, RoutePath as T, PageHeader as _, Layouts as a, PageLayout as b, PageComponentRef as c, PageFrontmatter as d, PageFrontmatterRef as f, PageHeadTitleRef as g, PageHeadTitle as h, HeadConfig as i, SiteLocaleDataRef as j, SiteDataRef as k, PageData as l, PageHeadRef as m, ClientConfig as n, LayoutsRef as o, PageHead as p, ClientData as r, PageComponent as s, CreateVueAppFunction as t, PageDataRef as u, PageLang as v, RouteLocaleRef as w, PageLayoutRef as x, PageLangRef as y };

package/dist/index.d.ts

@@ -1,194 +1,220 @@
-import { PageData, PageFrontmatter, HeadConfig, SiteData } from '@vuepress/shared';
-export { PageData, PageFrontmatter, PageHeader, SiteData } from '@vuepress/shared';
-import * as vue from 'vue';
-import { ComputedRef, InjectionKey, Ref, Component, App, FunctionalComponent, VNode } from 'vue';
-import { Redirects, Routes, PageMetaDefault, Route } from '@internal/routes';
-export { PageChunk, PageMetaDefault, Redirects, Route, Routes } from '@internal/routes';
-import { Router } from 'vue-router';
-export { C as CreateVueAppFunction } from './createVueAppFunction-YNGNKfE3.js';
-
+import { A as SiteLocaleData, C as RouteLocale, D as RoutesRef, E as RoutePathRef, F as RouteMeta, I as Routes, M as PageChunk, N as Redirects, O as SiteData, P as Route, S as RedirectsRef, T as RoutePath, _ as PageHeader, a as Layouts, b as PageLayout, c as PageComponentRef, d as PageFrontmatter, f as PageFrontmatterRef, g as PageHeadTitleRef, h as PageHeadTitle, i as HeadConfig, j as SiteLocaleDataRef, k as SiteDataRef, l as PageData, m as PageHeadRef, n as ClientConfig, o as LayoutsRef, p as PageHead, r as ClientData, s as PageComponent, t as CreateVueAppFunction, u as PageDataRef, v as PageLang, w as RouteLocaleRef, x as PageLayoutRef, y as PageLangRef } from "./index-wQR7Pl0s.js";
+import { InjectionKey, PropType, SlotsType, VNode } from "vue";
+import { RouteLocationNormalizedLoaded, Router, useRoute, useRouter } from "vue-router";
+//#region src/types/onContentUpdated.d.ts
+type ContentUpdatedReason = 'beforeUnmount' | 'mounted' | 'updated';
+type ContentUpdatedCallback = (reason: ContentUpdatedReason) => unknown;
+//#endregion
+//#region src/components/AutoLink.d.ts
+interface AutoLinkConfig {
+  /**
+   * Pattern to determine if the link should be active, which has higher priority than `exact`
+   */
+  activeMatch?: RegExp | string;
+  /**
+   * The `aria-label` attribute
+   */
+  ariaLabel?: string;
+  /**
+   * Whether the link should be active only if the url is an exact match
+   */
+  exact?: boolean;
+  /**
+   * URL of the auto link
+   */
+  link: string;
+  /**
+   * The `rel` attribute
+   */
+  rel?: string;
+  /**
+   * The `target` attribute
+   */
+  target?: string;
+  /**
+   * Text of the auto link
+   */
+  text: string;
+}
 /**
- * Ref wrapper of `Layouts`
+ * Component to render a link automatically according to the link type
+ *
+ * - If the link is internal, it will be rendered as a `<RouteLink>`
+ * - If the link is external, it will be rendered as a normal `<a>` tag
+ */
+declare const AutoLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  config: {
+    type: PropType<AutoLinkConfig>;
+    required: true;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  config: {
+    type: PropType<AutoLinkConfig>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, SlotsType<{
+  default?: (config: AutoLinkConfig) => VNode | VNode[];
+  before?: (config: AutoLinkConfig) => VNode | VNode[] | null;
+  after?: (config: AutoLinkConfig) => VNode | VNode[] | null;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/ClientOnly.d.ts
+/**
+ * Wrapper component that only renders its content on the client side and skips server side rendering
+ *
+ * Since vue 3.5, you can try the new `data-allow-mismatch` attribute instead of `<ClientOnly>` component in some cases to avoid hydration mismatch.
+ *
+ * @see https://blog.vuejs.org/posts/vue-3-5#data-allow-mismatch
  */
-type LayoutsRef = ComputedRef<Layouts>;
+declare const ClientOnly: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>[] | null | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/Content.d.ts
 /**
- * Injection key for layouts
+ * Markdown rendered content
  */
-declare const layoutsSymbol: InjectionKey<LayoutsRef>;
+declare const Content: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  path: {
+    type: StringConstructor;
+    required: false;
+    default: string;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  path: {
+    type: StringConstructor;
+    required: false;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  path: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/RouteLink.d.ts
+interface RouteLinkProps {
+  /**
+   * Whether the link is active to have an active class
+   *
+   * Notice that the active status is not automatically determined according to the current route.
+   *
+   * @default false
+   */
+  active?: boolean;
+  /**
+   * The class to add when the link is active
+   *
+   * @default 'route-link-active'
+   */
+  activeClass?: string;
+  /**
+   * The route path to link to
+   */
+  to: string;
+}
 /**
- * Returns layouts component map
- */
+ * Component to render a link to another route.
+ *
+ * It's similar to `RouterLink` in `vue-router`, but more lightweight.
+ *
+ * It's recommended to use `RouteLink` in VuePress.
+ */
+declare const RouteLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  /**
+   * The route path to link to
+   */
+  to: {
+    type: StringConstructor;
+    required: true;
+  };
+  /**
+   * Whether the link is active to have an active class
+   *
+   * Notice that the active status is not automatically determined according to the current route.
+   */
+  active: BooleanConstructor;
+  /**
+   * The class to add when the link is active
+   */
+  activeClass: {
+    type: StringConstructor;
+    default: string;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  /**
+   * The route path to link to
+   */
+  to: {
+    type: StringConstructor;
+    required: true;
+  };
+  /**
+   * Whether the link is active to have an active class
+   *
+   * Notice that the active status is not automatically determined according to the current route.
+   */
+  active: BooleanConstructor;
+  /**
+   * The class to add when the link is active
+   */
+  activeClass: {
+    type: StringConstructor;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  active: boolean;
+  activeClass: string;
+}, SlotsType<{
+  default: () => (VNode | string)[] | VNode | string;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/composables/clientData.d.ts
+/**
+ * The problem only occurs during hot updates in the development environment,
+ * It only needs to be processed in the development environment.
+ * (see vuepress/core#1715)
+ */
+declare const clientDataSymbol: InjectionKey<ClientData>;
+/**
+ * Returns client data
+ */
+declare const useClientData: <Frontmatter extends Record<string, unknown> = Record<string, unknown>, Data extends Record<string, unknown> = Record<string, unknown>>() => ClientData<Frontmatter, Data>;
+//#endregion
+//#region src/composables/clientDataUtils.d.ts
 declare const useLayouts: () => LayoutsRef;
-
-/**
- * Ref wrapper of `PageData`
- */
-type PageDataRef<T extends Record<any, any> = Record<never, never>> = Ref<PageData<T>>;
-/**
- * Injection key for page data
- */
-declare const pageDataSymbol: InjectionKey<PageDataRef>;
-/**
- * Returns the ref of the data of current page
- */
-declare const usePageData: <T extends Record<any, any> = Record<never, never>>() => PageDataRef<T>;
-
-/**
- * Ref wrapper of `PageFrontmatter`
- */
-type PageFrontmatterRef<T extends Record<any, any> = Record<string, unknown>> = ComputedRef<PageFrontmatter<T>>;
-/**
- * Injection key for page frontmatter
- */
-declare const pageFrontmatterSymbol: InjectionKey<PageFrontmatterRef>;
-/**
- * Returns the ref of the frontmatter of current page
- */
-declare const usePageFrontmatter: <T extends Record<any, any> = Record<string, unknown>>() => PageFrontmatterRef<T>;
-
-/**
- * Page head config, which would be used for generate html tags in `<head>`
- */
-type PageHead = HeadConfig[];
-/**
- * Ref wrapper of `PageHead`
- */
-type PageHeadRef = ComputedRef<PageHead>;
-/**
- * Injection key for page head
- */
-declare const pageHeadSymbol: InjectionKey<PageHeadRef>;
-/**
- * Returns the ref of the head config of current page
- */
+declare const usePageComponent: () => PageComponentRef;
+declare const usePageData: <T extends Record<string, unknown> = Record<string, unknown>>() => PageDataRef<T>;
+declare const usePageFrontmatter: <T extends Record<string, unknown> = Record<string, unknown>>() => PageFrontmatterRef<T>;
 declare const usePageHead: () => PageHeadRef;
-
-/**
- * Page head title, which would be used as the content of `head > title` tag
- */
-type PageHeadTitle = string;
-/**
- * Ref wrapper of `PageHeadTitle`
- */
-type PageHeadTitleRef = ComputedRef<PageHeadTitle>;
-/**
- * Injection key for page head title
- */
-declare const pageHeadTitleSymbol: InjectionKey<PageHeadTitleRef>;
-/**
- * Returns the ref of the head title of current page
- */
-declare const usePageHeadTitle: () => PageHeadTitleRef;
-
-/**
- * Page language
- */
-type PageLang = string;
-/**
- * Ref wrapper of `PageLang`
- */
-type PageLangRef = ComputedRef<PageLang>;
-/**
- * Injection key for page language
- */
-declare const pageLangSymbol: InjectionKey<PageLangRef>;
-/**
- * Returns the ref of the language of current page
- */
 declare const usePageLang: () => PageLangRef;
-
-/**
- * Ref wrapper of `PageLayout`
- */
-type PageLayoutRef = ComputedRef<Component>;
-/**
- * Injection key for page layout
- */
-declare const pageLayoutSymbol: InjectionKey<PageLayoutRef>;
-/**
- * Returns layout component of current page
- */
-declare const usePageLayout: () => ComputedRef<Component>;
-
-/**
- * Route locale path
- */
-type RouteLocale = string;
-/**
- * Ref wrapper of `RouteLocale`
- */
-type RouteLocaleRef = Readonly<Ref<RouteLocale>>;
-/**
- * Injection key for page route locale path
- */
-declare const routeLocaleSymbol: InjectionKey<RouteLocaleRef>;
-/**
- * Returns the ref of the route locale path of current page
- */
+declare const usePageLayout: () => PageLayoutRef;
+declare const useRedirects: () => RedirectsRef;
 declare const useRouteLocale: () => RouteLocaleRef;
-
-/**
- * Global redirects ref
- */
-declare const redirects: Ref<Redirects>;
-/**
- * Global routes ref
- */
-declare const routes: Ref<Routes>;
-
-interface ResolvedRoute<PageMeta extends PageMetaDefault = PageMetaDefault> extends Route<PageMeta> {
-    path: string;
-    notFound: boolean;
-}
-/**
- * Resolve route with given path
- */
-declare const resolveRoute: <PageMeta extends PageMetaDefault = PageMetaDefault>(path: string) => ResolvedRoute<PageMeta>;
-
-/**
- * Resolve route path with given raw path
- */
-declare const resolveRoutePath: (path: string) => string;
-
-/**
- * Returns the ref of pages map
- */
-declare const useRedirects: () => typeof redirects;
-/**
- * Returns the ref of routes map
- */
-declare const useRoutes: () => typeof routes;
-
-/**
- * Ref wrapper of `SiteData`
- */
-type SiteDataRef = Ref<SiteData>;
-/**
- * Global site data ref
- */
-declare const siteData: SiteDataRef;
-/**
- * Returns the ref of the site data
- */
+declare const useRoutePath: () => RoutePathRef;
+declare const useRoutes: () => RoutesRef;
 declare const useSiteData: () => SiteDataRef;
-
-/**
- * Site data of current locale
- */
-type SiteLocaleData = SiteData;
-/**
- * Ref wrapper of `SiteLocaleData`
- */
-type SiteLocaleDataRef = ComputedRef<SiteLocaleData>;
-/**
- * Injection key for site locale data
- */
-declare const siteLocaleDataSymbol: InjectionKey<SiteLocaleDataRef>;
-/**
- * Returns the ref of the site data of current locale
- */
 declare const useSiteLocaleData: () => SiteLocaleDataRef;
-
+declare const useData: <Frontmatter extends Record<string, unknown> = Record<string, unknown>, Data extends Record<string, unknown> = Record<string, unknown>>() => ClientData<Frontmatter, Data>;
+declare const useFrontmatter: <T extends Record<string, unknown> = Record<string, unknown>>() => PageFrontmatterRef<T>;
+declare const useHead: () => PageHeadRef;
+declare const useLang: () => PageLangRef;
+declare const usePage: <T extends Record<string, unknown> = Record<string, unknown>>() => PageDataRef<T>;
+declare const useSite: () => SiteDataRef;
+declare const useSiteLocale: () => SiteLocaleDataRef;
+//#endregion
+//#region src/composables/onContentUpdated.d.ts
+/**
+ * Register callback that is called every time the markdown content is updated
+ * in the DOM.
+ */
+declare const onContentUpdated: (fn: ContentUpdatedCallback) => void;
+//#endregion
+//#region src/composables/updateHead.d.ts
 /**
  * A util function to force update `<head>` of current page
  */
@@ -201,78 +227,61 @@ declare const updateHeadSymbol: InjectionKey<UpdateHead>;
  * Returns the `updateHead` util
  */
 declare const useUpdateHead: () => UpdateHead;
-
-type Layouts = Record<string, Component>;
-
-/**
- * Configure vuepress client
- */
-interface ClientConfig {
-    /**
-     * An enhance function to be called after vue app instance and
-     * vue-router instance has been created
-     */
-    enhance?: (context: {
-        app: App;
-        router: Router;
-        siteData: SiteDataRef;
-    }) => void | Promise<void>;
-    /**
-     * A function to be called inside the setup function of vue app
-     */
-    setup?: () => void;
-    /**
-     * Layout components
-     */
-    layouts?: Layouts;
-    /**
-     * Components to be placed directly into the root node of vue app
-     */
-    rootComponents?: Component[];
+declare namespace constants_d_exports {
+  export { COMPONENT_STATE_TYPE, INSPECTOR_ID, INSPECTOR_LABEL, INSPECTOR_NODES, INSPECTOR_STATE_SECTION_NAME, PLUGIN_ID, PLUGIN_LABEL };
+}
+declare const PLUGIN_ID = "org.vuejs.vuepress";
+declare const PLUGIN_LABEL = "VuePress";
+declare const COMPONENT_STATE_TYPE = "VuePress";
+declare const INSPECTOR_ID = "org.vuejs.vuepress";
+declare const INSPECTOR_LABEL = "VuePress";
+declare const INSPECTOR_NODES: {
+  INTERNAL: {
+    readonly id: "INTERNAL";
+    readonly label: "Internal";
+    readonly keys: ["layouts", "routes", "redirects"];
+  };
+  SITE: {
+    readonly id: "SITE";
+    readonly label: "Site";
+    readonly keys: ["siteData", "siteLocaleData"];
+  };
+  ROUTE: {
+    readonly id: "ROUTE";
+    readonly label: "Route";
+    readonly keys: ["routePath", "routeLocale"];
+  };
+  PAGE: {
+    readonly id: "PAGE";
+    readonly label: "Page";
+    readonly keys: ["pageData", "pageFrontmatter", "pageLang", "pageHead", "pageHeadTitle", "pageLayout", "pageComponent"];
+  };
+};
+declare const INSPECTOR_STATE_SECTION_NAME = "State";
+//#endregion
+//#region src/router/resolveRoute.d.ts
+interface ResolvedRoute<T extends RouteMeta = RouteMeta> extends Route<T> {
+  path: string;
+  notFound: boolean;
 }
-
-declare const ClientOnly: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | null | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
-
 /**
- * Markdown rendered content
+ * Resolve route with given path
  */
-declare const Content: vue.DefineComponent<{
-    path: {
-        type: StringConstructor;
-        required: false;
-        default: string;
-    };
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    path: {
-        type: StringConstructor;
-        required: false;
-        default: string;
-    };
-}>>, {
-    path: string;
-}, {}>;
-
-interface VPLinkProps {
-    to: string;
-}
-declare const VPLink: FunctionalComponent<VPLinkProps, Record<never, never>, {
-    default: () => string | VNode | (string | VNode)[];
-}>;
-
+declare const resolveRoute: <T extends RouteMeta = RouteMeta>(path: string, currentPath?: string) => ResolvedRoute<T>;
+//#endregion
+//#region src/router/resolveRouteFullPath.d.ts
 /**
- * A helper function to help you define vuepress client config file
+ * Resolve route full path with given raw path
  */
-declare const defineClientConfig: (clientConfig?: ClientConfig) => ClientConfig;
-
+declare const resolveRouteFullPath: (path: string, currentPath?: string) => string;
+//#endregion
+//#region src/router/resolveRoutePath.d.ts
 /**
- * Prefix url with site base
+ * Resolve route path with given raw path
  */
-declare const withBase: (url: string) => string;
-
+declare const resolveRoutePath: (pathname: string, currentPath?: string) => string;
+//#endregion
+//#region src/resolvers.d.ts
 /**
  * Resolver methods to get global computed
  *
@@ -281,14 +290,25 @@ declare const withBase: (url: string) => string;
  * @experimental - This is an experimental API and may be changed in minor versions
  */
 declare const resolvers: {
-    resolveLayouts: (clientConfigs: ClientConfig[]) => Layouts;
-    resolvePageFrontmatter: (pageData: PageData) => PageFrontmatter;
-    resolvePageHead: (headTitle: PageHeadTitle, frontmatter: PageFrontmatter, siteLocale: SiteLocaleData) => PageHead;
-    resolvePageHeadTitle: (page: PageData, siteLocale: SiteLocaleData) => PageHeadTitle;
-    resolvePageLang: (page: PageData, siteLocale: SiteLocaleData) => PageLang;
-    resolvePageLayout: (page: PageData, layouts: Layouts) => Component;
-    resolveRouteLocale: (locales: SiteData['locales'], routePath: string) => RouteLocale;
-    resolveSiteLocaleData: (site: SiteData, routeLocale: RouteLocale) => SiteLocaleData;
+  resolveLayouts: (clientConfigs: ClientConfig[]) => Layouts;
+  resolvePageHead: (pageHeadTitle: PageHeadTitle, pageFrontmatter: PageFrontmatter, siteLocaleDate: SiteLocaleData) => PageHead;
+  resolvePageHeadTitle: (pageData: PageData, siteLocaleDate: SiteLocaleData) => PageHeadTitle;
+  resolvePageLang: (pageData: PageData, siteLocaleData: SiteLocaleData) => PageLang;
+  resolvePageLayout: (pageData: PageData, layouts: Layouts) => PageLayout;
+  resolveRouteLocale: (locales: SiteData["locales"], routePath: string) => RouteLocale;
+  resolveSiteLocaleData: ({ base, locales, ...siteData }: SiteData, routeLocale: RouteLocale) => SiteLocaleData;
 };
-
-export { type ClientConfig, ClientOnly, Content, type Layouts, type LayoutsRef, type PageDataRef, type PageFrontmatterRef, type PageHead, type PageHeadRef, type PageHeadTitle, type PageHeadTitleRef, type PageLang, type PageLangRef, type PageLayoutRef, type RouteLocale, type RouteLocaleRef, type SiteDataRef, type SiteLocaleData, type SiteLocaleDataRef, type UpdateHead, VPLink, type VPLinkProps, defineClientConfig, layoutsSymbol, pageDataSymbol, pageFrontmatterSymbol, pageHeadSymbol, pageHeadTitleSymbol, pageLangSymbol, pageLayoutSymbol, redirects, resolveRoute, resolveRoutePath, resolvers, routeLocaleSymbol, routes, siteData, siteLocaleDataSymbol, updateHeadSymbol, useLayouts, usePageData, usePageFrontmatter, usePageHead, usePageHeadTitle, usePageLang, usePageLayout, useRedirects, useRouteLocale, useRoutes, useSiteData, useSiteLocaleData, useUpdateHead, withBase };
+//#endregion
+//#region src/utils/defineClientConfig.d.ts
+/**
+ * A helper function to help you define vuepress client config file
+ */
+declare const defineClientConfig: (clientConfig?: ClientConfig) => ClientConfig;
+//#endregion
+//#region src/utils/withBase.d.ts
+/**
+ * Prefix url with site base
+ */
+declare const withBase: (url: string) => string;
+//#endregion
+export { AutoLink, AutoLinkConfig, type ClientConfig, type ClientData, ClientOnly, Content, type ContentUpdatedCallback, type ContentUpdatedReason, type CreateVueAppFunction, constants_d_exports as DEVTOOLS, type HeadConfig, type Layouts, type LayoutsRef, type PageChunk, type PageComponent, type PageComponentRef, type PageData, type PageDataRef, type PageFrontmatter, type PageFrontmatterRef, type PageHead, type PageHeadRef, type PageHeadTitle, type PageHeadTitleRef, type PageHeader, type PageLang, type PageLangRef, type PageLayout, type PageLayoutRef, type Redirects, type RedirectsRef, ResolvedRoute, type Route, RouteLink, RouteLinkProps, type RouteLocale, type RouteLocaleRef, type RouteLocationNormalizedLoaded, type RouteMeta, type RoutePath, type RoutePathRef, type Router, type Routes, type RoutesRef, type SiteData, type SiteDataRef, type SiteLocaleData, type SiteLocaleDataRef, UpdateHead, clientDataSymbol, defineClientConfig, onContentUpdated, resolveRoute, resolveRouteFullPath, resolveRoutePath, resolvers, updateHeadSymbol, useClientData, useData, useFrontmatter, useHead, useLang, useLayouts, usePage, usePageComponent, usePageData, usePageFrontmatter, usePageHead, usePageLang, usePageLayout, useRedirects, useRoute, useRouteLocale, useRoutePath, useRouter, useRoutes, useSite, useSiteData, useSiteLocale, useSiteLocaleData, useUpdateHead, withBase };