vitepress 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/client/theme-default/composables/flyout.js

@@ -1,41 +1,42 @@
-import { onUnmounted, readonly, ref, watch } from 'vue';
-import { inBrowser } from '../../shared';
-export const focusedElement = ref();
+import { onUnmounted, readonly, ref, watch } from "vue";
+import { inBrowser } from "vitepress";
+//#region src/client/theme-default/composables/flyout.ts
+const focusedElement = ref();
 let active = false;
 let listeners = 0;
-export function useFlyout(options) {
-    const focus = ref(false);
-    if (inBrowser) {
-        !active && activateFocusTracking();
-        listeners++;
-        const unwatch = watch(focusedElement, (el) => {
-            if (el === options.el.value || options.el.value?.contains(el)) {
-                focus.value = true;
-                options.onFocus?.();
-            }
-            else {
-                focus.value = false;
-                options.onBlur?.();
-            }
-        });
-        onUnmounted(() => {
-            unwatch();
-            listeners--;
-            if (!listeners) {
-                deactivateFocusTracking();
-            }
-        });
-    }
-    return readonly(focus);
+function useFlyout(options) {
+	const focus = ref(false);
+	if (inBrowser) {
+		!active && activateFocusTracking();
+		listeners++;
+		const unwatch = watch(focusedElement, (el) => {
+			if (el === options.el.value || options.el.value?.contains(el)) {
+				focus.value = true;
+				options.onFocus?.();
+			} else {
+				focus.value = false;
+				options.onBlur?.();
+			}
+		});
+		onUnmounted(() => {
+			unwatch();
+			listeners--;
+			if (!listeners) deactivateFocusTracking();
+		});
+	}
+	return readonly(focus);
 }
 function activateFocusTracking() {
-    document.addEventListener('focusin', handleFocusIn);
-    active = true;
-    focusedElement.value = document.activeElement;
+	document.addEventListener("focusin", handleFocusIn);
+	active = true;
+	focusedElement.value = document.activeElement;
 }
 function deactivateFocusTracking() {
-    document.removeEventListener('focusin', handleFocusIn);
+	document.removeEventListener("focusin", handleFocusIn);
+	active = false;
 }
 function handleFocusIn() {
-    focusedElement.value = document.activeElement;
+	focusedElement.value = document.activeElement;
 }
+//#endregion
+export { focusedElement, useFlyout };

package/dist/client/theme-default/composables/langs.d.ts

@@ -0,0 +1,44 @@
+import { Route, VitePressData } from "../../shared.js";
+import { DefaultTheme } from "vitepress/theme";
+//#region src/client/theme-default/composables/langs.d.ts
+export declare function useLangs({ linkToCorrespondingPage }?: {
+  /**
+   * Link each entry of the translations menu to the current page's
+   * equivalent in that locale (resolved by `resolveLocaleLink`) instead of
+   * that locale's home page.
+   */
+  linkToCorrespondingPage?: boolean;
+}): {
+  currentLang: import("vue").ComputedRef<{
+    label: string | undefined;
+    link: string;
+  }>;
+  localeLinks: import("vue").ComputedRef<{
+    text: string;
+    link: string;
+    lang: string | undefined;
+    dir: "ltr" | "rtl" | "auto" | undefined;
+  }[]>;
+};
+/**
+ * Resolves the link used for switching from the current page to
+ * `targetLocale`. Without `linkToCorrespondingPage`, this is simply the home
+ * of the target locale. With it, the current page's path is rewritten into
+ * the target locale (honoring `cleanUrls`) — unless
+ * `themeConfig.i18nRouting` is `false` (the locale home is used instead) or
+ * a function (which then fully controls the resolution).
+ *
+ * The current query and hash are carried over, except when a custom
+ * `i18nRouting` function is used.
+ */
+export declare function resolveLocaleLink(data: VitePressData<DefaultTheme.Config>, route: Route, { targetLocale, targetLocaleLink, currentLocaleLink, linkToCorrespondingPage }: {
+  /** Key of the target locale in `site.locales`, e.g. `'fr'` or `'root'`. */
+  targetLocale: string;
+  /** Home link of the target locale, e.g. `'/fr/'`. */
+  targetLocaleLink: string;
+  /** Home link of the locale the current page is in, e.g. `'/'`. */
+  currentLocaleLink: string;
+  /** Link to the current page's equivalent instead of the locale home. */
+  linkToCorrespondingPage: boolean;
+}): string;
+//#endregion

package/dist/client/theme-default/composables/langs.js

@@ -1,26 +1,50 @@
-import { computed } from 'vue';
-import { ensureStartingSlash } from '../support/utils';
-import { useData } from './data';
-export function useLangs({ correspondingLink = false } = {}) {
-    const { site, localeIndex, page, theme, hash } = useData();
-    const currentLang = computed(() => ({
-        label: site.value.locales[localeIndex.value]?.label,
-        link: site.value.locales[localeIndex.value]?.link ||
-            (localeIndex.value === 'root' ? '/' : `/${localeIndex.value}/`)
-    }));
-    const localeLinks = computed(() => Object.entries(site.value.locales).flatMap(([key, value]) => currentLang.value.label === value.label
-        ? []
-        : {
-            text: value.label,
-            link: normalizeLink(value.link || (key === 'root' ? '/' : `/${key}/`), theme.value.i18nRouting !== false && correspondingLink, page.value.relativePath.slice(currentLang.value.link.length - 1), !site.value.cleanUrls) + hash.value
-        }));
-    return { localeLinks, currentLang };
+import { useRoute } from "../../app/router.js";
+import { useData } from "./data.js";
+import { ensureStartingSlash } from "../support/utils.js";
+import { computed } from "vue";
+//#region src/client/theme-default/composables/langs.ts
+function useLangs({ linkToCorrespondingPage = false } = {}) {
+	const data = useData();
+	const route = useRoute();
+	const { site, localeIndex } = data;
+	const currentLang = computed(() => ({
+		label: site.value.locales[localeIndex.value]?.label,
+		link: site.value.locales[localeIndex.value]?.link || (localeIndex.value === "root" ? "/" : `/${localeIndex.value}/`)
+	}));
+	return {
+		currentLang,
+		localeLinks: computed(() => Object.entries(site.value.locales).flatMap(([key, value]) => currentLang.value.label === value.label ? [] : {
+			text: value.label,
+			link: resolveLocaleLink(data, route, {
+				targetLocale: key,
+				targetLocaleLink: value.link || (key === "root" ? "/" : `/${key}/`),
+				currentLocaleLink: currentLang.value.link,
+				linkToCorrespondingPage
+			}),
+			lang: value.lang,
+			dir: value.dir
+		}))
+	};
 }
-function normalizeLink(link, addPath, path, addExt) {
-    return addPath
-        ? link.replace(/\/$/, '') +
-            ensureStartingSlash(path
-                .replace(/(^|\/)index\.md$/, '$1')
-                .replace(/\.md$/, addExt ? '.html' : ''))
-        : link;
+/**
+* Resolves the link used for switching from the current page to
+* `targetLocale`. Without `linkToCorrespondingPage`, this is simply the home
+* of the target locale. With it, the current page's path is rewritten into
+* the target locale (honoring `cleanUrls`) — unless
+* `themeConfig.i18nRouting` is `false` (the locale home is used instead) or
+* a function (which then fully controls the resolution).
+*
+* The current query and hash are carried over, except when a custom
+* `i18nRouting` function is used.
+*/
+function resolveLocaleLink(data, route, { targetLocale, targetLocaleLink, currentLocaleLink, linkToCorrespondingPage }) {
+	const { site, theme } = data;
+	const i18nRouting = theme.value.i18nRouting;
+	if (linkToCorrespondingPage && typeof i18nRouting === "function") return i18nRouting(data, route, targetLocale);
+	return normalizeLink(targetLocaleLink, i18nRouting !== false && linkToCorrespondingPage, route.data.relativePath.slice(currentLocaleLink.length - 1), !site.value.cleanUrls) + route.query + route.hash;
 }
+function normalizeLink(localeLink, appendPagePath, pagePath, addHtmlExt) {
+	return appendPagePath ? localeLink.replace(/\/$/, "") + ensureStartingSlash(pagePath.replace(/(^|\/)index\.md$/, "$1").replace(/\.md$/, addHtmlExt ? ".html" : "")) : localeLink;
+}
+//#endregion
+export { resolveLocaleLink, useLangs };

package/dist/client/theme-default/composables/layout.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, InjectionKey } from "vue";
+import { DefaultTheme } from "vitepress/theme";
+//#region src/client/theme-default/composables/layout.d.ts
+export declare function useLayout(): DefaultTheme.Layout;
+interface RegisterWatchersOptions {
+  closeSidebar: () => void;
+}
+export declare function registerWatchers({ closeSidebar }: RegisterWatchersOptions): void;
+export interface LayoutInfo {
+  heroImageSlotExists: ComputedRef<boolean>;
+}
+export declare const layoutInfoInjectionKey: InjectionKey<LayoutInfo>;
+//#endregion

package/dist/client/theme-default/composables/layout.js

@@ -0,0 +1,68 @@
+import { useData as useData$1 } from "./data.js";
+import { getSidebar, getSidebarGroups } from "../support/sidebar.js";
+import { getHeaders } from "./outline.js";
+import { useCloseSidebarOnEscape } from "./sidebar.js";
+import { computed, shallowReadonly, shallowRef, watch } from "vue";
+import { onContentUpdated, useRoute } from "vitepress";
+import { useMediaQuery } from "@vueuse/core";
+//#region src/client/theme-default/composables/layout.ts
+const headers = shallowRef([]);
+const sidebar = shallowRef([]);
+const isDesktop = useMediaQuery("(min-width: 60rem)");
+function useLayout() {
+	const { frontmatter, theme } = useData$1();
+	const isHome = computed(() => {
+		return !!(frontmatter.value.isHome ?? frontmatter.value.layout === "home");
+	});
+	const hasSidebar = computed(() => {
+		return frontmatter.value.sidebar !== false && sidebar.value.length > 0 && !isHome.value;
+	});
+	const isSidebarEnabled = computed(() => hasSidebar.value && isDesktop.value);
+	const sidebarGroups = computed(() => {
+		return hasSidebar.value ? getSidebarGroups(sidebar.value) : [];
+	});
+	const hasAside = computed(() => {
+		if (isHome.value) return false;
+		if (frontmatter.value.aside != null) return !!frontmatter.value.aside;
+		return theme.value.aside !== false;
+	});
+	const leftAside = computed(() => {
+		if (!hasAside.value) return false;
+		return frontmatter.value.aside == null ? theme.value.aside === "left" : frontmatter.value.aside === "left";
+	});
+	const hasLocalNav = computed(() => {
+		return headers.value.length > 0;
+	});
+	return {
+		isHome,
+		sidebar: shallowReadonly(sidebar),
+		sidebarGroups,
+		hasSidebar,
+		isSidebarEnabled,
+		hasAside,
+		leftAside,
+		headers: shallowReadonly(headers),
+		hasLocalNav
+	};
+}
+function registerWatchers({ closeSidebar }) {
+	const { theme, page, frontmatter } = useData$1();
+	watch(() => [page.value.relativePath, theme.value.sidebar], ([relativePath, sidebarConfig]) => {
+		const newSidebar = sidebarConfig ? getSidebar(sidebarConfig, relativePath) : [];
+		if (JSON.stringify(newSidebar) !== JSON.stringify(sidebar.value)) sidebar.value = newSidebar;
+	}, {
+		immediate: true,
+		deep: true,
+		flush: "sync"
+	});
+	onContentUpdated(() => {
+		headers.value = getHeaders(frontmatter.value.outline ?? theme.value.outline);
+	});
+	const route = useRoute();
+	watch(() => route.path, closeSidebar);
+	watch(isDesktop, closeSidebar);
+	useCloseSidebarOnEscape(closeSidebar);
+}
+const layoutInfoInjectionKey = Symbol("layout-info");
+//#endregion
+export { layoutInfoInjectionKey, registerWatchers, useLayout };

package/dist/client/theme-default/composables/nav-overflow.d.ts

@@ -0,0 +1,54 @@
+import { MaybeRefOrGetter } from "vue";
+//#region src/client/theme-default/composables/nav-overflow.d.ts
+/**
+ * Priority+ overflow for the navbar (#1271, #2842).
+ *
+ * Collapse order under space pressure: social links → appearance switch →
+ * translations → menu items right-to-left. Collapsed units move into the
+ * `⋯` flyout (VPNavBarExtra) instead of being clipped, so nothing ever
+ * becomes unreachable.
+ *
+ * Collapsed units stay mounted but hidden (visibility: hidden + absolute,
+ * which also removes them from the a11y tree and tab order), so their
+ * natural widths remain measurable and observed — re-expanding never works
+ * from stale data.
+ */
+export declare const navClusterUnits: readonly ["translations", "appearance", "socialLinks"];
+export type NavClusterUnit = (typeof navClusterUnits)[number];
+export interface NavFitInput {
+  /** widths of the top-level menu items, in nav order (px) */
+  itemWidths: number[];
+  /** cluster unit widths; null = the unit isn't configured on this site */
+  translations: number | null;
+  appearance: number | null;
+  socialLinks: number | null;
+  /** px available to all collapsible units */
+  available: number;
+  /** px the `⋯` button occupies once anything is collapsed */
+  extraWidth: number;
+}
+export interface NavFitResult {
+  /** number of menu items that stay in the bar (Infinity = all) */
+  visibleItemCount: number;
+  translations: boolean;
+  appearance: boolean;
+  socialLinks: boolean;
+}
+export declare function computeNavFit(input: NavFitInput): NavFitResult;
+export interface NavOverflow {
+  /** reactive collapse state, all-visible during SSR and below 48rem */
+  state: NavFitResult;
+  /** true when anything is collapsed into the `⋯` menu */
+  hasCollapsed: () => boolean;
+  setContainerEl(el: HTMLElement | null): void;
+  setMenuEl(el: HTMLElement | null): void;
+  setExtraEl(el: HTMLElement | null): void;
+  setItemEl(index: number, el: HTMLElement | null): void;
+  setClusterEl(unit: NavClusterUnit, el: HTMLElement | null): void;
+}
+export declare function useNavOverflow(): NavOverflow | null;
+export declare function provideNavOverflow(options: {
+  /** stringified nav config — collapse state resets when it changes */
+  itemsKey: MaybeRefOrGetter<string>;
+}): NavOverflow;
+//#endregion

package/dist/client/theme-default/composables/nav-overflow.js

@@ -0,0 +1,179 @@
+import { inject, onScopeDispose, provide, reactive, toValue, watch } from "vue";
+import { inBrowser } from "vitepress";
+import { useMediaQuery } from "@vueuse/core";
+//#region src/client/theme-default/composables/nav-overflow.ts
+/**
+* Priority+ overflow for the navbar (#1271, #2842).
+*
+* Collapse order under space pressure: social links → appearance switch →
+* translations → menu items right-to-left. Collapsed units move into the
+* `⋯` flyout (VPNavBarExtra) instead of being clipped, so nothing ever
+* becomes unreachable.
+*
+* Collapsed units stay mounted but hidden (visibility: hidden + absolute,
+* which also removes them from the a11y tree and tab order), so their
+* natural widths remain measurable and observed — re-expanding never works
+* from stale data.
+*/
+const navClusterUnits = [
+	"translations",
+	"appearance",
+	"socialLinks"
+];
+const allVisible = {
+	visibleItemCount: Infinity,
+	translations: true,
+	appearance: true,
+	socialLinks: true
+};
+function computeNavFit(input) {
+	const { itemWidths, available, extraWidth } = input;
+	const itemsTotal = itemWidths.reduce((sum, w) => sum + w, 0);
+	if (itemsTotal + ((input.translations ?? 0) + (input.appearance ?? 0) + (input.socialLinks ?? 0)) <= available) return allVisible;
+	const budget = available - extraWidth;
+	if (itemsTotal > budget) {
+		let used = 0;
+		let visibleItemCount = 0;
+		for (const width of itemWidths) {
+			if (used + width > budget) break;
+			used += width;
+			visibleItemCount++;
+		}
+		return {
+			visibleItemCount,
+			translations: input.translations == null,
+			appearance: input.appearance == null,
+			socialLinks: input.socialLinks == null
+		};
+	}
+	const result = { ...allVisible };
+	let used = itemsTotal;
+	let dropRest = false;
+	for (const unit of navClusterUnits) {
+		const width = input[unit];
+		if (width == null) continue;
+		if (dropRest || used + width > budget) {
+			dropRest = true;
+			result[unit] = false;
+		} else used += width;
+	}
+	return result;
+}
+/** headroom against sub-pixel rounding and the inter-unit dividers */
+const SLACK = 24;
+/** used until the real `⋯` button has been measured once */
+const EXTRA_WIDTH_ESTIMATE = 48;
+const navOverflowKey = Symbol("nav-overflow");
+function useNavOverflow() {
+	return inject(navOverflowKey, null);
+}
+function provideNavOverflow(options) {
+	const state = reactive({ ...allVisible });
+	const itemEls = /* @__PURE__ */ new Map();
+	const clusterEls = /* @__PURE__ */ new Map();
+	let containerEl = null;
+	let menuEl = null;
+	let extraEl = null;
+	let extraWidth = EXTRA_WIDTH_ESTIMATE;
+	let observer = null;
+	const observed = /* @__PURE__ */ new Set();
+	let scheduled = false;
+	function observe(el) {
+		if (!inBrowser || !(el instanceof Element) || observed.has(el)) return;
+		observed.add(el);
+		(observer ??= new ResizeObserver(schedule)).observe(el);
+	}
+	function schedule() {
+		if (!inBrowser || scheduled) return;
+		scheduled = true;
+		requestAnimationFrame(() => {
+			scheduled = false;
+			recompute();
+		});
+	}
+	const controller = {
+		state,
+		hasCollapsed: () => state.visibleItemCount !== Infinity || !state.translations || !state.appearance || !state.socialLinks,
+		setContainerEl(el) {
+			containerEl = el;
+			observe(el);
+			schedule();
+		},
+		setMenuEl(el) {
+			menuEl = el;
+			observe(el);
+			schedule();
+		},
+		setExtraEl(el) {
+			extraEl = el;
+			observe(el);
+			schedule();
+		},
+		setItemEl(index, el) {
+			el ? itemEls.set(index, el) : itemEls.delete(index);
+			observe(el);
+			schedule();
+		},
+		setClusterEl(unit, el) {
+			el ? clusterEls.set(unit, el) : clusterEls.delete(unit);
+			observe(el);
+			schedule();
+		}
+	};
+	provide(navOverflowKey, controller);
+	if (!inBrowser) return controller;
+	const isEngineActive = useMediaQuery("(min-width: 48rem)");
+	function measureUnit(el) {
+		return Math.max(el.offsetWidth, el.scrollWidth);
+	}
+	function recompute() {
+		if (!isEngineActive.value) return applyResult(allVisible);
+		if (!containerEl) return;
+		if (extraEl && extraEl.offsetWidth > 0) extraWidth = extraEl.offsetWidth;
+		let fixed = 0;
+		for (const child of Array.from(containerEl.children)) {
+			if (!(child instanceof HTMLElement)) continue;
+			if (child === menuEl || child === extraEl) continue;
+			let isCluster = false;
+			for (const el of clusterEls.values()) if (el === child) {
+				isCluster = true;
+				break;
+			}
+			if (isCluster) continue;
+			fixed += child.offsetWidth;
+		}
+		const itemWidths = [];
+		for (let i = 0; i < itemEls.size; i++) {
+			const el = itemEls.get(i);
+			if (!el) return;
+			itemWidths.push(measureUnit(el));
+		}
+		const clusterWidth = (unit) => {
+			const el = clusterEls.get(unit);
+			return el ? measureUnit(el) : null;
+		};
+		applyResult(computeNavFit({
+			itemWidths,
+			translations: clusterWidth("translations"),
+			appearance: clusterWidth("appearance"),
+			socialLinks: clusterWidth("socialLinks"),
+			available: containerEl.clientWidth - fixed - SLACK,
+			extraWidth
+		}));
+	}
+	function applyResult(result) {
+		if (state.visibleItemCount !== result.visibleItemCount) state.visibleItemCount = result.visibleItemCount;
+		for (const unit of navClusterUnits) if (state[unit] !== result[unit]) state[unit] = result[unit];
+	}
+	watch(isEngineActive, schedule);
+	watch(() => toValue(options.itemsKey), schedule);
+	if (document.fonts?.ready) document.fonts.ready.then(schedule).catch(() => {});
+	onScopeDispose(() => {
+		observer?.disconnect();
+		observer = null;
+		observed.clear();
+	});
+	return controller;
+}
+//#endregion
+export { computeNavFit, navClusterUnits, provideNavOverflow, useNavOverflow };

package/dist/client/theme-default/composables/nav.d.ts

@@ -0,0 +1,25 @@
+import { InjectionKey, MaybeRefOrGetter } from "vue";
+import { DefaultTheme } from "vitepress/theme";
+//#region src/client/theme-default/composables/nav.d.ts
+declare function openScreen(): void;
+declare function closeScreen(): void;
+declare function toggleScreen(): void;
+export declare function useNav(): {
+  isScreenOpen: import("vue").Ref<boolean, boolean>;
+  screenTriggerEl: import("vue").ShallowRef<HTMLButtonElement | null, HTMLButtonElement | null>;
+  openScreen: typeof openScreen;
+  closeScreen: typeof closeScreen;
+  toggleScreen: typeof toggleScreen;
+};
+export declare function useAppearanceSwitch(): import("vue").ComputedRef<boolean>;
+export declare function useNavItemLink(item: MaybeRefOrGetter<DefaultTheme.NavItemWithLink>): {
+  href: import("vue").ComputedRef<string>;
+  isActiveLink: import("vue").ComputedRef<boolean>;
+  isCurrentLink: import("vue").ComputedRef<boolean>;
+};
+export interface NavExposedMethods {
+  closeScreen: () => void;
+}
+export declare const navInjectionKey: InjectionKey<NavExposedMethods>;
+export declare const navScreenInjectionKey: InjectionKey<boolean>;
+//#endregion

package/dist/client/theme-default/composables/nav.js

@@ -1,30 +1,59 @@
-import { useRoute } from 'vitepress';
-import { ref, watch } from 'vue';
-export function useNav() {
-    const isScreenOpen = ref(false);
-    function openScreen() {
-        isScreenOpen.value = true;
-        window.addEventListener('resize', closeScreenOnTabletWindow);
-    }
-    function closeScreen() {
-        isScreenOpen.value = false;
-        window.removeEventListener('resize', closeScreenOnTabletWindow);
-    }
-    function toggleScreen() {
-        isScreenOpen.value ? closeScreen() : openScreen();
-    }
-    /**
-     * Close screen when the user resizes the window wider than tablet size.
-     */
-    function closeScreenOnTabletWindow() {
-        window.outerWidth >= 768 && closeScreen();
-    }
-    const route = useRoute();
-    watch(() => route.path, closeScreen);
-    return {
-        isScreenOpen,
-        openScreen,
-        closeScreen,
-        toggleScreen
-    };
+import { isActive } from "../../shared.js";
+import { useData as useData$1 } from "./data.js";
+import { computed, ref, shallowRef, toValue, watch } from "vue";
+import { inBrowser, useRoute } from "vitepress";
+import { useMediaQuery, whenever } from "@vueuse/core";
+//#region src/client/theme-default/composables/nav.ts
+const isScreenOpen = ref(false);
+const screenTriggerEl = shallowRef(null);
+function openScreen() {
+	isScreenOpen.value = true;
 }
+function closeScreen() {
+	isScreenOpen.value = false;
+}
+function toggleScreen() {
+	isScreenOpen.value ? closeScreen() : openScreen();
+}
+let watchersRegistered = false;
+function useNav() {
+	if (inBrowser && !watchersRegistered) {
+		watchersRegistered = true;
+		const isTablet = useMediaQuery("(min-width: 48rem)");
+		whenever(isTablet, closeScreen);
+		const route = useRoute();
+		watch(() => route.path, closeScreen);
+	}
+	return {
+		isScreenOpen,
+		screenTriggerEl,
+		openScreen,
+		closeScreen,
+		toggleScreen
+	};
+}
+function useAppearanceSwitch() {
+	const { site } = useData$1();
+	return computed(() => !!site.value.appearance && site.value.appearance !== "force-dark" && site.value.appearance !== "force-auto");
+}
+function useNavItemLink(item) {
+	const route = useRoute();
+	const href = computed(() => {
+		const { link } = toValue(item);
+		return typeof link === "function" ? link(route.data) : link;
+	});
+	return {
+		href,
+		isActiveLink: computed(() => {
+			const { activeMatch } = toValue(item);
+			return isActive(route.data.relativePath, route.hash, activeMatch || href.value, !!activeMatch);
+		}),
+		isCurrentLink: computed(() => {
+			return isActive(route.data.relativePath, route.hash, href.value);
+		})
+	};
+}
+const navInjectionKey = Symbol("nav");
+const navScreenInjectionKey = Symbol("nav-screen");
+//#endregion
+export { navInjectionKey, navScreenInjectionKey, useAppearanceSwitch, useNav, useNavItemLink };

package/dist/client/theme-default/composables/outline.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from "vue";
+import { DefaultTheme } from "vitepress/theme";
+//#region src/client/theme-default/composables/outline.d.ts
+export declare function resolveTitle(theme: DefaultTheme.Config): string;
+export declare function getHeaders(range: DefaultTheme.Config['outline']): DefaultTheme.OutlineItem[];
+export declare function resolveHeaders(headers: DefaultTheme.OutlineItem[], range?: DefaultTheme.Config['outline']): DefaultTheme.OutlineItem[];
+export declare function useActiveAnchor(container: TemplateRef<HTMLElement>, marker: TemplateRef<HTMLElement>): void;
+//#endregion