@deot/docs-markdown 1.0.1

package/dist/index.cjs

@@ -0,0 +1,827 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let vue = require("vue");
+let _deot_docs_locale = require("@deot/docs-locale");
+let markdown_it_chain = require("markdown-it-chain");
+markdown_it_chain = __toESM(markdown_it_chain);
+let markdown_it_anchor = require("markdown-it-anchor");
+markdown_it_anchor = __toESM(markdown_it_anchor);
+let markdown_it_container = require("markdown-it-container");
+markdown_it_container = __toESM(markdown_it_container);
+let markdown_it = require("markdown-it");
+markdown_it = __toESM(markdown_it);
+let json5 = require("json5");
+json5 = __toESM(json5);
+let _deot_helper_dom = require("@deot/helper-dom");
+let _deot_vc = require("@deot/vc");
+//#region packages/markdown/src/markdown.ts
+var HTML_MD_SIGN = "md";
+var PLAYGROUND = "playground";
+var TIP = "tip";
+var WARNING = "warning";
+var config = new markdown_it_chain.default();
+config.options.html(true).typographer(true).linkify(true).end().plugin("anchor").use(markdown_it_anchor.default, [{ permalink: markdown_it_anchor.default.permalink.linkInsideHeader({
+	placement: "before",
+	symbol: "#"
+}) }]).end().plugin("container").use(($md) => {
+	const reg = new RegExp(`^${PLAYGROUND}\\s*(.*)$`);
+	$md.use(markdown_it_container.default, PLAYGROUND, { validate(params) {
+		return params.trim().match(reg);
+	} });
+	$md.use(markdown_it_container.default, TIP);
+	$md.use(markdown_it_container.default, WARNING);
+}).end();
+var md = config.toMd(markdown_it.default);
+var playgroundOpen = `container_${PLAYGROUND}_open`;
+var playgroundClose = `container_${PLAYGROUND}_close`;
+var htmlCommentRE = /<!--([\s\S]*?)-->/g;
+var runtimeConfigRE = /<config\s+lang\s*=\s*["']json5["']\s*>([\s\S]*?)<\/config>/i;
+var renderPlaygroundError = (message) => `<div class="docs-playground-error">PLAYGROUND: ${md.utils.escapeHtml(message)}</div>\n`;
+var PLAYGROUND_VIEWS = ["runtime", "files"];
+var isPlaygroundView = (value) => typeof value === "string" && PLAYGROUND_VIEWS.includes(value);
+var isRuntimeViewport = (viewport) => {
+	if (viewport === "auto") return true;
+	if (typeof viewport === "number") return Number.isFinite(viewport) && viewport > 0;
+	return Array.isArray(viewport) && viewport.length === 2 && viewport.every((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
+};
+var getRuntimeViewportKey = (viewport) => Array.isArray(viewport) ? `${viewport[0]}x${viewport[1]}` : String(viewport);
+var validateRuntimeViews = (propsData) => {
+	if ("view" in propsData) return "不支持 view 参数，请使用 views";
+	if (!("views" in propsData)) return "";
+	const views = propsData.views;
+	if (!Array.isArray(views) || !views.length) return "views 必须是非空数组";
+	const invalidView = views.find((view) => !isPlaygroundView(view));
+	if (invalidView !== void 0) return `views 不支持 ${String(invalidView)}`;
+	const duplicateView = views.find((view, viewIndex) => views.indexOf(view) !== viewIndex);
+	if (duplicateView !== void 0) return `views 不能重复声明 ${String(duplicateView)}`;
+	return "";
+};
+var validateRuntimeViewport = (propsData) => {
+	if ("viewport" in propsData && !isRuntimeViewport(propsData.viewport)) return "viewport 必须是 auto、正数宽度或 [宽,高]";
+	if (!("viewportOptions" in propsData)) return "";
+	const options = propsData.viewportOptions;
+	if (!Array.isArray(options)) return "viewportOptions 必须是数组";
+	const invalidIndex = options.findIndex((option) => !isRuntimeViewport(option));
+	if (invalidIndex >= 0) return `viewportOptions[${invalidIndex}] 必须是 auto、正数宽度或 [宽,高]`;
+	const keys = options.filter(isRuntimeViewport).map(getRuntimeViewportKey);
+	const duplicateIndex = keys.findIndex((key, index) => keys.indexOf(key) !== index);
+	if (duplicateIndex >= 0) return `viewportOptions 不能重复声明 ${keys[duplicateIndex]}`;
+	return "";
+};
+var parseRuntimeProps = (tokens) => {
+	for (const token of tokens) {
+		const sources = [];
+		if (token.type === "html_block" && token.content) sources.push(token.content);
+		if (token.type === "inline" && token.content) sources.push(token.content);
+		for (const source of sources) {
+			htmlCommentRE.lastIndex = 0;
+			let commentMatch = htmlCommentRE.exec(source);
+			while (commentMatch) {
+				const configMatch = commentMatch[1].match(runtimeConfigRE);
+				if (configMatch) try {
+					const parsed = json5.default.parse(configMatch[1]);
+					if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+				} catch {}
+				commentMatch = htmlCommentRE.exec(source);
+			}
+		}
+	}
+	return {};
+};
+var renderPlaygroundAttrs = (propsData) => `data-props="${md.utils.escapeHtml(JSON.stringify(propsData))}"`;
+md.core.ruler.after("block", "runtime-files", (state) => {
+	for (let index = 0; index < state.tokens.length; index++) {
+		if (state.tokens[index].type !== playgroundOpen) continue;
+		let depth = 1;
+		let closeIndex = index + 1;
+		for (; closeIndex < state.tokens.length; closeIndex++) {
+			if (state.tokens[closeIndex].type === playgroundOpen) depth++;
+			if (state.tokens[closeIndex].type === playgroundClose) depth--;
+			if (depth === 0) break;
+		}
+		const innerTokens = state.tokens.slice(index + 1, closeIndex);
+		const fences = innerTokens.filter((token) => token.type === "fence");
+		const placeholder = new state.Token("html_block", "", 0);
+		placeholder.block = true;
+		const propsData = parseRuntimeProps(innerTokens);
+		const propsError = validateRuntimeViews(propsData) || validateRuntimeViewport(propsData);
+		const propsAttr = renderPlaygroundAttrs(propsData);
+		if (!fences.length) placeholder.content = renderPlaygroundError("至少需要声明一个代码文件");
+		else if (propsError) placeholder.content = renderPlaygroundError(propsError);
+		else {
+			const fileEntries = fences.map((token) => {
+				const [, filename = ""] = token.info.trim().split(/\s+/, 2);
+				return [filename, token.content];
+			});
+			if (fences.length === 1 && !fileEntries[0][0]) placeholder.content = [
+				"<div data-playground",
+				`data-code="${md.utils.escapeHtml(fences[0].content)}"`,
+				`${propsAttr}></div>\n`
+			].join(" ");
+			else {
+				const missingFilename = fileEntries.some(([filename]) => !filename);
+				const filenames = fileEntries.map(([filename]) => filename);
+				const duplicateFilename = filenames.find((filename, fileIndex) => filenames.indexOf(filename) !== fileIndex);
+				const entry = (typeof propsData.entry === "string" ? propsData.entry : "") || filenames[0];
+				if (missingFilename) placeholder.content = renderPlaygroundError("多文件模式下每个代码块都必须声明文件名");
+				else if (duplicateFilename) placeholder.content = renderPlaygroundError(`文件名 ${duplicateFilename} 重复`);
+				else if (!filenames.includes(entry)) placeholder.content = renderPlaygroundError(`入口文件 ${entry} 不存在`);
+				else {
+					const files = Object.fromEntries(fileEntries);
+					placeholder.content = [
+						"<div data-playground",
+						`data-files="${md.utils.escapeHtml(JSON.stringify(files))}"`,
+						`data-entry="${md.utils.escapeHtml(entry)}"`,
+						`${propsAttr}></div>\n`
+					].join(" ");
+				}
+			}
+		}
+		state.tokens.splice(index, closeIndex - index + 1, placeholder);
+	}
+});
+var renderAttrs = md.renderer.renderAttrs;
+md.renderer.renderAttrs = (token) => {
+	const reg = new RegExp(`container_${PLAYGROUND}|fence|text`);
+	if (token.nesting !== -1 && token.type && !reg.test(token.type)) token.attrPush([HTML_MD_SIGN, ""]);
+	return renderAttrs(token);
+};
+var Markdown = md;
+var normalizeSearchText = (value) => value.replace(/\s+/gu, " ").trim();
+/**
+* 从 inline token 中提取用户可见文本。HTML token 不进入索引，避免标签、
+* 注释或嵌入代码污染搜索结果；链接仍保留其可见标题。
+* @param token Markdown-It inline token。
+* @returns 规范化后的可搜索文本。
+*/
+var getInlineSearchText = (token) => {
+	if (!token.children) return normalizeSearchText(token.content);
+	return normalizeSearchText(token.children.map((child) => {
+		if (child.type === "html_inline") return "";
+		if (child.type === "softbreak" || child.type === "hardbreak") return " ";
+		return ["text", "code_inline"].includes(child.type) ? child.content : "";
+	}).join(" "));
+};
+/**
+* 使用页面渲染共用的 Markdown Engine 生成搜索文档。heading ID 直接读取
+* markdown-it-anchor 处理后的 token，确保重复标题和中文标题的跳转地址
+* 与实际页面一致。
+* @param content Markdown 原文。
+* @returns 文档标题、正文和按标题划分的小节。
+*/
+var parseMarkdownSearchSections = (content) => {
+	const tokens = md.parse(content, {});
+	const sections = [];
+	const documentParts = [];
+	let activeSection;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.type === "heading_open") {
+			const inline = tokens[index + 1];
+			if (inline?.type !== "inline") continue;
+			const title = getInlineSearchText(inline);
+			if (!title) continue;
+			activeSection = {
+				title,
+				anchor: token.attrGet("id") || "",
+				level: Number(token.tag.slice(1)) || 1,
+				text: ""
+			};
+			sections.push(activeSection);
+			continue;
+		}
+		if (token.type !== "inline" || tokens[index - 1]?.type === "heading_open") continue;
+		const text = getInlineSearchText(token);
+		if (!text) continue;
+		documentParts.push(text);
+		if (activeSection) activeSection.text = normalizeSearchText(`${activeSection.text} ${text}`);
+	}
+	return {
+		title: sections.find((section) => section.level === 1)?.title || sections[0]?.title || "",
+		text: normalizeSearchText(documentParts.join(" ")),
+		sections
+	};
+};
+//#endregion
+//#region packages/markdown/src/directive.ts
+var mountedApps = /* @__PURE__ */ new WeakMap();
+var renderVersions = /* @__PURE__ */ new WeakMap();
+var playgroundModule;
+var loadPlayground = () => playgroundModule ||= import("@deot/docs-playground");
+var cleanup = (el) => {
+	for (const app of mountedApps.get(el) || []) app.unmount();
+	mountedApps.delete(el);
+};
+var resolveBlockLanguage = (block) => {
+	return [...block.classList].find((className) => className.startsWith("language-"))?.slice(9) || "";
+};
+var render = async (el, binding) => {
+	cleanup(el);
+	const version = (renderVersions.get(el) || 0) + 1;
+	renderVersions.set(el, version);
+	el.innerHTML = binding.value.source ? Markdown.render(binding.value.source) : "";
+	const apps = [];
+	const blocks = el.querySelectorAll("pre code");
+	const playgrounds = el.querySelectorAll("div[data-playground]");
+	if (!blocks.length && !playgrounds.length) {
+		mountedApps.set(el, apps);
+		return;
+	}
+	const DocsPlayground = await loadPlayground();
+	if (renderVersions.get(el) !== version) return;
+	blocks.forEach((block) => {
+		const pre = block.parentElement;
+		if (!pre) return;
+		const mountPoint = document.createElement("div");
+		mountPoint.className = "docs-markdown-code-preview";
+		pre.replaceWith(mountPoint);
+		const app = (0, vue.createApp)(() => (0, vue.h)(DocsPlayground.CodePreview, {
+			code: block.textContent || "",
+			language: resolveBlockLanguage(block),
+			locale: binding.value.locale
+		}));
+		app.mount(mountPoint);
+		apps.push(app);
+	});
+	playgrounds.forEach((item) => {
+		const code = item.dataset.code;
+		let files;
+		let propsData = {};
+		try {
+			propsData = JSON.parse(item.dataset.props || "{}");
+		} catch {}
+		try {
+			files = item.dataset.files ? JSON.parse(item.dataset.files) : void 0;
+		} catch {}
+		const runtimeProps = files ? {
+			files,
+			entry: item.dataset.entry
+		} : { modelValue: code };
+		const app = (0, vue.createApp)(() => (0, vue.h)(DocsPlayground.Playground, {
+			...typeof propsData === "object" ? propsData : {},
+			...runtimeProps,
+			locale: binding.value.locale
+		}));
+		app.mount(item);
+		apps.push(app);
+	});
+	mountedApps.set(el, apps);
+};
+var update = (el, binding) => {
+	if (binding.value.source !== binding.oldValue?.source || binding.value.locale !== binding.oldValue?.locale) render(el, binding);
+};
+var vMarkdown = {
+	mounted: (el, binding) => void render(el, binding),
+	updated: update,
+	beforeUnmount: (el) => {
+		renderVersions.set(el, (renderVersions.get(el) || 0) + 1);
+		cleanup(el);
+	}
+};
+//#endregion
+//#region packages/markdown/src/indicator.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = ["aria-label"];
+var _hoisted_2 = { class: "docs-markdown-indicator__list" };
+var _hoisted_3 = ["aria-label", "onClick"];
+var _hoisted_4 = { class: "docs-markdown-indicator__preview-title" };
+var _hoisted_5 = {
+	key: 0,
+	class: "docs-markdown-indicator__preview-content"
+};
+var MAX_ARIA_LABEL_LENGTH = 180;
+//#endregion
+//#region packages/markdown/src/indicator.vue
+var indicator_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "indicator",
+	props: {
+		options: {},
+		target: {}
+	},
+	setup(__props) {
+		const BLOCK_SELECTOR = [
+			"h1",
+			"h2",
+			"h3",
+			"h4",
+			"h5",
+			"h6",
+			"p",
+			"li",
+			"pre",
+			"blockquote",
+			"table",
+			".tip",
+			".warning",
+			".docs-markdown-code-preview",
+			"[data-playground]"
+		].join(",");
+		const CONTAINER_SELECTOR = [
+			"li",
+			"blockquote",
+			"table",
+			".tip",
+			".warning",
+			".docs-markdown-code-preview",
+			"[data-playground]"
+		].join(",");
+		const props = __props;
+		const { lang: localeName, t } = (0, _deot_docs_locale.useLocale)();
+		const parentScroller = (0, vue.inject)("vc-scroller", null);
+		const indicatorRoot = (0, vue.ref)();
+		const viewport = (0, vue.ref)();
+		const rail = (0, vue.ref)();
+		const indicatorScroller = (0, vue.ref)();
+		const markers = (0, vue.shallowRef)([]);
+		const activeIndex = (0, vue.ref)(0);
+		const hoverIndex = (0, vue.ref)();
+		const previewTop = (0, vue.ref)(0);
+		const dragging = (0, vue.ref)(false);
+		const stickyInset = (0, vue.ref)("0px");
+		let observer;
+		let hostResizeObserver;
+		let scrollHost;
+		let usesParentScroller = false;
+		let captureTarget;
+		let refreshFrame = 0;
+		let activeFrame = 0;
+		let targetGeneration = 0;
+		const toCssLength = (value, fallback) => typeof value === "number" ? `${value}px` : value || fallback;
+		const rootStyle = (0, vue.computed)(() => ({
+			"--docs-markdown-indicator-height": toCssLength(props.options.height, "min(72vh, 600px)"),
+			"--docs-markdown-indicator-inset": stickyInset.value,
+			"--docs-markdown-indicator-top": toCssLength(props.options.top, "0px")
+		}));
+		const hoveredMarker = (0, vue.computed)(() => typeof hoverIndex.value === "number" ? markers.value[hoverIndex.value] : void 0);
+		const previewStyle = (0, vue.computed)(() => ({ top: `${previewTop.value}px` }));
+		/**
+		* 保留文档块的有效换行，同时折叠每行内部的多余空白。
+		* @param element 当前文档块。
+		* @returns 适合摘要卡展示的文本。
+		*/
+		const getBlockText = (element) => (element.textContent || "").split(/\n+/).map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
+		/**
+		* 清理标题锚点产生的井号，并提供无标题内容的兜底文本。
+		* @param element 当前标题节点。
+		* @returns 单行章节标题。
+		*/
+		const getHeadingTitle = (element) => getBlockText(element).replace(/^#\s*/, "").replace(/\s+/g, " ").trim() || t("markdown.indicator.untitled");
+		/**
+		* 为无障碍名称限制长度，避免长代码块生成过大的属性值。
+		* @param title 当前章节标题。
+		* @param content 当前文档块内容。
+		* @returns 标题和内容组成的简短名称。
+		*/
+		const getAriaLabel = (title, content) => {
+			const value = content ? `${title}: ${content.replace(/\s+/g, " ")}` : title;
+			if (value.length <= MAX_ARIA_LABEL_LENGTH) return value;
+			return `${value.slice(0, MAX_ARIA_LABEL_LENGTH).trim()}…`;
+		};
+		/**
+		* 判断候选节点是否已经包含在另一个可独立定位的文档块内。
+		* @param element 当前候选节点。
+		* @returns 是否应由外层文档块统一表示。
+		*/
+		const isNestedBlock = (element) => {
+			const container = element.closest(CONTAINER_SELECTOR);
+			return Boolean(container && container !== element);
+		};
+		/**
+		* 获取 Markdown 使用的原生滚动宿主。
+		* Scroller 组件由注入上下文优先处理；仅在没有 Scroller 时才向上查找普通滚动层。
+		* @returns 当前文档使用的滚动容器。
+		*/
+		const getScrollHost = () => (0, _deot_helper_dom.getScroller)(props.target) || window;
+		/**
+		* 获取当前滚动宿主的可视区域顶部。
+		* @returns 相对于视口的顶部坐标。
+		*/
+		const getScrollHostTop = () => {
+			if (usesParentScroller) return parentScroller?.wrapper?.getBoundingClientRect().top || 0;
+			return scrollHost instanceof HTMLElement ? scrollHost.getBoundingClientRect().top : 0;
+		};
+		/**
+		* 判断文档是否已经到达滚动末尾。
+		* 末屏通常无法把最后一个内容块推到顶部阈值，因此需要显式选中最后一条刻度。
+		* @returns 是否位于可滚动内容末尾。
+		*/
+		const isScrollEnd = () => {
+			let clientHeight;
+			let scrollHeight;
+			let scrollTop;
+			if (usesParentScroller) {
+				clientHeight = parentScroller?.clientHeight || 0;
+				scrollHeight = parentScroller?.scrollHeight || 0;
+				scrollTop = parentScroller?.scrollTop || 0;
+			} else if (scrollHost instanceof HTMLElement) {
+				clientHeight = scrollHost.clientHeight;
+				scrollHeight = scrollHost.scrollHeight;
+				scrollTop = scrollHost.scrollTop;
+			} else {
+				clientHeight = window.innerHeight;
+				scrollHeight = document.documentElement.scrollHeight;
+				scrollTop = window.scrollY;
+			}
+			return scrollHeight > clientHeight && scrollTop + clientHeight >= scrollHeight - 1;
+		};
+		/**
+		* 保证当前阅读刻度处于内部 Scroller 的可视范围内。
+		* @param index 当前阅读刻度序号。
+		*/
+		const followActiveMarker = async (index) => {
+			await (0, vue.nextTick)();
+			const marker = rail.value?.querySelectorAll(".docs-markdown-indicator__marker")[index];
+			const wrapper = viewport.value?.querySelector(".vc-scroller__wrapper");
+			if (!marker || !wrapper) return;
+			const markerRect = marker.getBoundingClientRect();
+			const wrapperRect = wrapper.getBoundingClientRect();
+			const padding = 16;
+			if (markerRect.top >= wrapperRect.top + padding && markerRect.bottom <= wrapperRect.bottom - padding) return;
+			const markerCenter = markerRect.top + markerRect.height / 2;
+			const wrapperCenter = wrapperRect.top + wrapperRect.height / 2;
+			indicatorScroller.value?.setScrollTop(Math.max(0, wrapper.scrollTop + markerCenter - wrapperCenter));
+		};
+		/** 根据滚动位置更新当前阅读块，不触发 Markdown 内容重渲染。 */
+		const updateActiveIndex = () => {
+			activeFrame = 0;
+			if (!markers.value.length) return;
+			const threshold = getScrollHostTop() + 80;
+			let nextIndex = markers.value.length - 1;
+			if (!isScrollEnd()) {
+				nextIndex = 0;
+				for (let index = 0; index < markers.value.length; index++) {
+					if (markers.value[index].element.getBoundingClientRect().top > threshold) break;
+					nextIndex = index;
+				}
+			}
+			if (activeIndex.value !== nextIndex) {
+				activeIndex.value = nextIndex;
+				followActiveMarker(nextIndex);
+			}
+		};
+		/** 将连续滚动事件合并到浏览器的下一绘制帧。 */
+		const handleScroll = () => {
+			if (!activeFrame) activeFrame = requestAnimationFrame(updateActiveIndex);
+		};
+		/** 从最新渲染的 Markdown DOM 重建文档刻度。 */
+		const refreshMarkers = () => {
+			refreshFrame = 0;
+			const target = props.target;
+			if (!target) {
+				markers.value = [];
+				return;
+			}
+			const elements = [...target.querySelectorAll(BLOCK_SELECTOR)].filter((element) => !isNestedBlock(element));
+			let sectionTitle = t("markdown.indicator.document");
+			markers.value = elements.map((element, index) => {
+				const isHeading = /^H[1-6]$/.test(element.tagName);
+				if (isHeading) sectionTitle = getHeadingTitle(element);
+				const nextElement = elements[index + 1];
+				const content = isHeading && nextElement && !/^H[1-6]$/.test(nextElement.tagName) ? getBlockText(nextElement) : isHeading ? "" : getBlockText(element);
+				return {
+					ariaLabel: getAriaLabel(sectionTitle, content),
+					content,
+					element,
+					id: `${index}-${element.id || element.tagName}`,
+					title: sectionTitle
+				};
+			});
+			hoverIndex.value = void 0;
+			updateActiveIndex();
+			followActiveMarker(activeIndex.value);
+		};
+		/** 合并 MutationObserver 的密集通知，避免 Playground 挂载时重复扫描。 */
+		const scheduleRefresh = () => {
+			if (!refreshFrame) refreshFrame = requestAnimationFrame(refreshMarkers);
+		};
+		/**
+		* 读取当前滚动容器的可视高度。
+		* sticky 的百分比 top 会相对整篇文档计算，不能用来做容器垂直居中。
+		* @returns 滚动容器 clientHeight，窗口滚动时回退到 innerHeight。
+		*/
+		const getScrollHostClientHeight = () => {
+			if (usesParentScroller) return parentScroller?.wrapper?.clientHeight || parentScroller?.clientHeight || window.innerHeight;
+			if (scrollHost instanceof HTMLElement) return scrollHost.clientHeight;
+			return window.innerHeight;
+		};
+		/**
+		* 读取指示器可视高度：数字配置优先，否则测量已挂载节点或回退默认值。
+		* @returns 指示器高度，单位 px。
+		*/
+		const resolveIndicatorHeight = () => {
+			const height = props.options.height;
+			if (typeof height === "number" && Number.isFinite(height) && height > 0) return height;
+			const measured = viewport.value?.getBoundingClientRect().height || 0;
+			if (measured > 0) return measured;
+			return Math.min(window.innerHeight * .72, 600);
+		};
+		/** 把指示器钉在滚动容器可视区域的垂直中心。 */
+		const updateStickyInset = () => {
+			const hostHeight = getScrollHostClientHeight();
+			const indicatorHeight = resolveIndicatorHeight();
+			stickyInset.value = hostHeight > 0 ? `${Math.max(0, (hostHeight - indicatorHeight) / 2)}px` : "0px";
+		};
+		/** 跟随滚动容器和指示器自身的尺寸变化，保持垂直居中。 */
+		const observeHostSize = () => {
+			hostResizeObserver?.disconnect();
+			hostResizeObserver = void 0;
+			if (typeof ResizeObserver !== "undefined") {
+				hostResizeObserver = new ResizeObserver(updateStickyInset);
+				const host = usesParentScroller ? parentScroller?.wrapper : scrollHost instanceof HTMLElement ? scrollHost : void 0;
+				if (host) hostResizeObserver.observe(host);
+				if (viewport.value) hostResizeObserver.observe(viewport.value);
+			}
+			updateStickyInset();
+		};
+		/** 解除旧文档的观察和滚动监听。 */
+		const cleanupTarget = () => {
+			observer?.disconnect();
+			observer = void 0;
+			hostResizeObserver?.disconnect();
+			hostResizeObserver = void 0;
+			window.removeEventListener("resize", updateStickyInset);
+			if (usesParentScroller) parentScroller?.off?.(handleScroll);
+			else if (scrollHost) scrollHost.removeEventListener("scroll", handleScroll);
+			usesParentScroller = false;
+			scrollHost = void 0;
+		};
+		/** 为当前 Markdown DOM 建立内容观察与滚动同步。 */
+		const setupTarget = async () => {
+			const generation = ++targetGeneration;
+			cleanupTarget();
+			await (0, vue.nextTick)();
+			if (generation !== targetGeneration) return;
+			if (!props.target) {
+				markers.value = [];
+				return;
+			}
+			usesParentScroller = Boolean(parentScroller?.on);
+			if (usesParentScroller) {
+				parentScroller?.on?.(handleScroll);
+				scrollHost = parentScroller?.wrapper || window;
+			} else {
+				scrollHost = getScrollHost();
+				scrollHost.addEventListener("scroll", handleScroll, { passive: true });
+			}
+			window.addEventListener("resize", updateStickyInset, { passive: true });
+			observer = new MutationObserver(scheduleRefresh);
+			observer.observe(props.target, {
+				childList: true,
+				characterData: true,
+				subtree: true
+			});
+			refreshMarkers();
+			observeHostSize();
+		};
+		/**
+		* 将指示器内的纵坐标转换为最近的文档块序号。
+		* @param event 当前指针事件。
+		* @returns 距离指针最近的文档块序号。
+		*/
+		const getIndexByPointer = (event) => {
+			if (!rail.value || !markers.value.length) return 0;
+			const elements = [...rail.value.querySelectorAll(".docs-markdown-indicator__marker")];
+			let closestIndex = 0;
+			let closestDistance = Number.POSITIVE_INFINITY;
+			elements.forEach((element, index) => {
+				const bounds = element.getBoundingClientRect();
+				const distance = Math.abs(event.clientY - (bounds.top + bounds.height / 2));
+				if (distance < closestDistance) {
+					closestIndex = index;
+					closestDistance = distance;
+				}
+			});
+			return closestIndex;
+		};
+		/**
+		* 让摘要跟随当前刻度，同时限制在指示器可视高度内。
+		* @param index 当前刻度序号。
+		* @param clientY 指针的视口纵坐标。
+		*/
+		const updatePreviewPosition = (index, clientY) => {
+			const rootBounds = indicatorRoot.value?.getBoundingClientRect();
+			const viewportBounds = viewport.value?.getBoundingClientRect();
+			const marker = rail.value?.querySelectorAll(".docs-markdown-indicator__marker")[index];
+			if (!rootBounds || !viewportBounds || !marker) return;
+			const markerBounds = marker.getBoundingClientRect();
+			const relativeY = (clientY ?? markerBounds.top + markerBounds.height / 2) - rootBounds.top;
+			previewTop.value = Math.min(viewportBounds.height - 48, Math.max(48, relativeY));
+		};
+		/**
+		* 滚动到指定文档块；拖动使用即时定位，点击使用平滑定位。
+		* @param index 目标文档块序号。
+		* @param behavior 滚动行为。
+		*/
+		const scrollToMarker = (index, behavior) => {
+			const marker = markers.value[index];
+			if (!marker || !scrollHost) return;
+			const markerTop = marker.element.getBoundingClientRect().top;
+			if (usesParentScroller && parentScroller?.setScrollTop) parentScroller.setScrollTop((parentScroller.scrollTop || 0) + markerTop - getScrollHostTop() - 24);
+			else if (scrollHost instanceof HTMLElement) {
+				const hostTop = scrollHost.getBoundingClientRect().top;
+				scrollHost.scrollTo({
+					top: scrollHost.scrollTop + markerTop - hostTop - 24,
+					behavior
+				});
+			} else window.scrollTo({
+				top: window.scrollY + markerTop - 24,
+				behavior
+			});
+			activeIndex.value = index;
+			followActiveMarker(index);
+		};
+		/**
+		* 指针移动时展示摘要；按下拖动时同步快速浏览文档。
+		* @param event 当前指针事件。
+		*/
+		const handlePointerMove = (event) => {
+			const index = getIndexByPointer(event);
+			hoverIndex.value = index;
+			updatePreviewPosition(index, event.clientY);
+			if (dragging.value) scrollToMarker(index, "auto");
+		};
+		/**
+		* 开始拖动指示器并定位到按下位置。
+		* @param event 当前指针事件。
+		*/
+		const handlePointerDown = (event) => {
+			if (event.button !== 0) return;
+			dragging.value = props.options.draggable !== false;
+			const index = getIndexByPointer(event);
+			hoverIndex.value = index;
+			updatePreviewPosition(index, event.clientY);
+			if (dragging.value) {
+				captureTarget = event.currentTarget;
+				captureTarget.setPointerCapture?.(event.pointerId);
+				scrollToMarker(index, "auto");
+				event.preventDefault();
+			}
+		};
+		/**
+		* 结束拖动并释放指针捕获。
+		* @param event 当前指针事件。
+		*/
+		const handlePointerUp = (event) => {
+			dragging.value = false;
+			if (captureTarget?.hasPointerCapture?.(event.pointerId)) captureTarget.releasePointerCapture(event.pointerId);
+			captureTarget = void 0;
+		};
+		/** 离开指示器时隐藏摘要；拖动期间由指针捕获继续处理。 */
+		const handlePointerLeave = () => {
+			if (!dragging.value) hoverIndex.value = void 0;
+		};
+		/**
+		* 点击单条刻度时平滑定位到对应文档块。
+		* @param index 目标文档块序号。
+		*/
+		const handleClick = (index) => {
+			hoverIndex.value = index;
+			updatePreviewPosition(index);
+			scrollToMarker(index, "smooth");
+		};
+		/**
+		* 计算刻度位置、基础宽度和靠近指针时的鱼眼展开宽度。
+		* @param index 当前刻度序号。
+		* @returns 刻度的定位和宽度样式。
+		*/
+		const getMarkerStyle = (index) => {
+			const distance = typeof hoverIndex.value === "number" ? Math.abs(index - hoverIndex.value) : Number.POSITIVE_INFINITY;
+			return { width: `${distance <= 3 ? [
+				28,
+				22,
+				16,
+				10
+			][distance] : 8}px` };
+		};
+		(0, vue.watch)([() => props.target, localeName], setupTarget, { immediate: true });
+		(0, vue.watch)([() => props.options.height, viewport], () => {
+			if (viewport.value && hostResizeObserver) hostResizeObserver.observe(viewport.value);
+			updateStickyInset();
+		});
+		(0, vue.onBeforeUnmount)(() => {
+			targetGeneration++;
+			cleanupTarget();
+			if (refreshFrame) cancelAnimationFrame(refreshFrame);
+			if (activeFrame) cancelAnimationFrame(activeFrame);
+		});
+		return (_ctx, _cache) => {
+			return markers.value.length > 1 ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("aside", {
+				key: 0,
+				ref_key: "indicatorRoot",
+				ref: indicatorRoot,
+				class: (0, vue.normalizeClass)(["docs-markdown-indicator", `is-${__props.options.position || "right"}`]),
+				style: (0, vue.normalizeStyle)(rootStyle.value),
+				"aria-label": (0, vue.unref)(t)("markdown.indicator.label")
+			}, [(0, vue.createElementVNode)("div", {
+				ref_key: "viewport",
+				ref: viewport,
+				class: "docs-markdown-indicator__viewport",
+				onPointermove: handlePointerMove,
+				onPointerleave: handlePointerLeave,
+				onPointerdown: handlePointerDown,
+				onPointerup: handlePointerUp,
+				onPointercancel: handlePointerUp
+			}, [(0, vue.createVNode)((0, vue.unref)(_deot_vc.Scroller), {
+				ref_key: "indicatorScroller",
+				ref: indicatorScroller,
+				class: "docs-markdown-indicator__scroller",
+				"auto-resize": true,
+				native: false,
+				"show-bar": true,
+				height: "100%",
+				"wrapper-style": "overflow-x: hidden;"
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", {
+					ref_key: "rail",
+					ref: rail,
+					class: "docs-markdown-indicator__rail"
+				}, [(0, vue.createElementVNode)("div", _hoisted_2, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(markers.value, (marker, index) => {
+					return (0, vue.openBlock)(), (0, vue.createElementBlock)("button", {
+						key: marker.id,
+						type: "button",
+						class: (0, vue.normalizeClass)(["docs-markdown-indicator__marker", {
+							"is-active": index === activeIndex.value,
+							"is-hovered": index === hoverIndex.value
+						}]),
+						style: (0, vue.normalizeStyle)(getMarkerStyle(index)),
+						"aria-label": marker.ariaLabel,
+						onClick: ($event) => handleClick(index)
+					}, null, 14, _hoisted_3);
+				}), 128))])], 512)]),
+				_: 1
+			}, 512)], 544), __props.options.preview !== false && hoveredMarker.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+				key: 0,
+				class: "docs-markdown-indicator__preview",
+				style: (0, vue.normalizeStyle)(previewStyle.value)
+			}, [(0, vue.createElementVNode)("div", _hoisted_4, (0, vue.toDisplayString)(hoveredMarker.value.title), 1), hoveredMarker.value.content ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_5, (0, vue.toDisplayString)(hoveredMarker.value.content), 1)) : (0, vue.createCommentVNode)("v-if", true)], 4)) : (0, vue.createCommentVNode)("v-if", true)], 14, _hoisted_1$1)) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+//#endregion
+//#region packages/markdown/src/wrapper.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "docs-markdown" };
+//#endregion
+//#region packages/markdown/src/wrapper.vue
+var wrapper_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "wrapper",
+	props: {
+		indicator: {
+			type: [Boolean, Object],
+			default: true
+		},
+		locale: {},
+		modelValue: {},
+		value: {}
+	},
+	emits: ["update:modelValue", "change"],
+	setup(__props) {
+		const props = __props;
+		const content = (0, vue.ref)();
+		const inheritedLocale = (0, _deot_docs_locale.useLocale)();
+		const locale = (0, vue.computed)(() => props.locale || inheritedLocale.locale.value);
+		(0, _deot_docs_locale.provideLocale)(locale);
+		const indicatorOptions = (0, vue.computed)(() => {
+			if (props.indicator === false) return void 0;
+			return typeof props.indicator === "object" ? props.indicator : {};
+		});
+		const source = (0, vue.computed)(() => typeof props.modelValue === "string" ? props.modelValue : props.value);
+		const markdownBinding = (0, vue.computed)(() => ({
+			source: source.value,
+			locale: locale.value
+		}));
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1, [indicatorOptions.value ? ((0, vue.openBlock)(), (0, vue.createBlock)(indicator_default, {
+				key: 0,
+				target: content.value,
+				options: indicatorOptions.value
+			}, null, 8, ["target", "options"])) : (0, vue.createCommentVNode)("v-if", true), (0, vue.withDirectives)((0, vue.createElementVNode)("div", {
+				ref_key: "content",
+				ref: content,
+				class: "docs-markdown-reset"
+			}, null, 512), [[(0, vue.unref)(vMarkdown), markdownBinding.value]])]);
+		};
+	}
+});
+//#endregion
+exports.Markdown = wrapper_default;
+exports.parseMarkdownSearchSections = parseMarkdownSearchSections;