@ubean/vue 0.2.0

package/dist/vite.js

@@ -0,0 +1,1189 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative } from "pathe";
+import { glob } from "tinyglobby";
+import { pascalCase } from "scule";
+import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
+//#region src/extract-page.ts
+/**
+* `definePage(...)` 宏参数提取器(构建期,零 AST 依赖的括号平衡扫描)。
+*
+* 所有权:`@ubean/vue`;`@ubean/scan` re-export `extractDefinePage*` 保持
+* 向后兼容,其服务端 `defineHandlerMeta` 提取复用下方导出的通用
+* `extractCallObject`。
+*/
+function extractScriptContent(code) {
+	if (!code.includes("<script")) return code;
+	let scriptContent = "";
+	const scriptRegex = /<script([^>]*)>([\s\S]*?)<\/script>/g;
+	let match;
+	while ((match = scriptRegex.exec(code)) !== null) {
+		const attrs = match[1] || "";
+		const content = match[2] || "";
+		if (attrs.includes("setup")) return content;
+		scriptContent += `${content}\n`;
+	}
+	return scriptContent || null;
+}
+function findBalancedCall(code, funcName) {
+	const callPattern = new RegExp(`\\b${funcName}\\s*\\(`, "g");
+	let match;
+	while ((match = callPattern.exec(code)) !== null) {
+		const lineStart = code.lastIndexOf("\n", match.index) + 1;
+		if (code.slice(lineStart, match.index).includes("//")) continue;
+		const startIdx = match.index + match[0].length;
+		let depth = 1;
+		let i = startIdx;
+		let inString = null;
+		let escaped = false;
+		while (i < code.length && depth > 0) {
+			const ch = code[i];
+			if (escaped) {
+				escaped = false;
+				i++;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				i++;
+				continue;
+			}
+			if (inString) {
+				if (ch === inString) inString = null;
+				i++;
+				continue;
+			}
+			if (ch === "\"" || ch === "'" || ch === "`") {
+				inString = ch;
+				i++;
+				continue;
+			}
+			if (ch === "(" || ch === "{" || ch === "[") depth++;
+			else if (ch === ")" || ch === "}" || ch === "]") {
+				depth--;
+				if (depth === 0 && ch === ")") return code.slice(startIdx, i);
+			}
+			i++;
+		}
+	}
+	return null;
+}
+function skipWhitespace(code, pos) {
+	while (pos < code.length && /\s/.test(code[pos])) pos++;
+	return pos;
+}
+function parseStringValue(code, pos) {
+	const quote = code[pos];
+	if (quote !== "\"" && quote !== "'" && quote !== "`") return null;
+	pos++;
+	let value = "";
+	let escaped = false;
+	while (pos < code.length) {
+		const ch = code[pos];
+		if (escaped) {
+			value += ch;
+			escaped = false;
+			pos++;
+			continue;
+		}
+		if (ch === "\\") {
+			escaped = true;
+			pos++;
+			continue;
+		}
+		if (ch === quote) {
+			if (quote === "`") {
+				value += ch;
+				pos++;
+				if (pos >= code.length || code[pos] !== "`") {
+					pos--;
+					break;
+				}
+			} else {
+				pos++;
+				break;
+			}
+		}
+		value += ch;
+		pos++;
+	}
+	return {
+		value,
+		pos
+	};
+}
+function parseIdentifier(code, pos) {
+	const start = pos;
+	while (pos < code.length && /[\w$]/.test(code[pos])) pos++;
+	if (pos === start) return null;
+	return {
+		name: code.slice(start, pos),
+		pos
+	};
+}
+function parseValue(code, pos) {
+	pos = skipWhitespace(code, pos);
+	if (pos >= code.length) return null;
+	const ch = code[pos];
+	if (ch === "\"" || ch === "'" || ch === "`") {
+		const str = parseStringValue(code, pos);
+		if (str) return {
+			value: str.value,
+			pos: str.pos
+		};
+		return null;
+	}
+	if (ch === "{") return parseObjectValue(code, pos);
+	if (ch === "[") return parseArrayValue(code, pos);
+	if (ch === "t" && code.slice(pos, pos + 4) === "true") return {
+		value: true,
+		pos: pos + 4
+	};
+	if (ch === "f" && code.slice(pos, pos + 5) === "false") return {
+		value: false,
+		pos: pos + 5
+	};
+	if (ch === "n" && code.slice(pos, pos + 4) === "null") return {
+		value: null,
+		pos: pos + 4
+	};
+	const numMatch = code.slice(pos).match(/^-?\d+\.?\d*(?:[eE][+-]?\d+)?/);
+	if (numMatch) return {
+		value: Number(numMatch[0]),
+		pos: pos + numMatch[0].length
+	};
+	const ident = parseIdentifier(code, pos);
+	if (ident) return {
+		value: ident.name,
+		pos: ident.pos
+	};
+	return null;
+}
+function parseObjectValue(code, pos) {
+	if (code[pos] !== "{") return null;
+	pos++;
+	const result = {};
+	pos = skipWhitespace(code, pos);
+	if (code[pos] === "}") return {
+		value: result,
+		pos: pos + 1
+	};
+	while (pos < code.length) {
+		pos = skipWhitespace(code, pos);
+		let key = null;
+		if (code[pos] === "\"" || code[pos] === "'") {
+			const keyStr = parseStringValue(code, pos);
+			if (keyStr) {
+				key = keyStr.value;
+				pos = keyStr.pos;
+			}
+		} else {
+			const ident = parseIdentifier(code, pos);
+			if (ident) {
+				key = ident.name;
+				pos = ident.pos;
+			}
+		}
+		if (!key) break;
+		pos = skipWhitespace(code, pos);
+		if (code[pos] !== ":") break;
+		pos++;
+		pos = skipWhitespace(code, pos);
+		const val = parseValue(code, pos);
+		if (val) {
+			result[key] = val.value;
+			pos = val.pos;
+		}
+		pos = skipWhitespace(code, pos);
+		if (code[pos] === ",") {
+			pos++;
+			continue;
+		}
+		if (code[pos] === "}") {
+			pos++;
+			break;
+		}
+		break;
+	}
+	return {
+		value: result,
+		pos
+	};
+}
+function parseArrayValue(code, pos) {
+	if (code[pos] !== "[") return null;
+	pos++;
+	const result = [];
+	pos = skipWhitespace(code, pos);
+	if (code[pos] === "]") return {
+		value: result,
+		pos: pos + 1
+	};
+	while (pos < code.length) {
+		pos = skipWhitespace(code, pos);
+		const val = parseValue(code, pos);
+		if (val) {
+			result.push(val.value);
+			pos = val.pos;
+		}
+		pos = skipWhitespace(code, pos);
+		if (code[pos] === ",") {
+			pos++;
+			continue;
+		}
+		if (code[pos] === "]") {
+			pos++;
+			break;
+		}
+		break;
+	}
+	return {
+		value: result,
+		pos
+	};
+}
+function parseObjectLiteral(code) {
+	const start = skipWhitespace(code, 0);
+	if (code[start] !== "{") return {};
+	const parsed = parseObjectValue(code, start);
+	if (parsed) return parsed.value;
+	const result = {};
+	const simpleRegex = /(\w+)\s*:\s*(['"`])((?:(?!\2)[^\\]|\\.)*)\2/g;
+	let m;
+	while ((m = simpleRegex.exec(code)) !== null) result[m[1]] = m[3];
+	return result;
+}
+/**
+* 通用宏调用提取:在代码中查找 `funcName({...})` 形式的调用并解析其
+* 对象字面量参数。供本包的 `definePage` 提取与 `@ubean/scan` 的
+* `defineHandlerMeta` 提取共用(单一解析器实现)。
+*/
+function extractCallObject(code, funcName) {
+	const argStr = findBalancedCall(code, funcName);
+	if (!argStr) return null;
+	const trimmed = argStr.trim();
+	if (!trimmed.startsWith("{")) return null;
+	return parseObjectLiteral(trimmed);
+}
+/**
+* Normalize a parsed `head` value into a `PageHead` object。
+*
+* Mirrors the markdown frontmatter head validation so Vue pages (via
+* `definePage`) and Markdown pages (via frontmatter) share the same rules.
+*/
+function normalizePageHead(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const src = raw;
+	const head = {};
+	if (typeof src.title === "string") head.title = src.title;
+	if (Array.isArray(src.meta)) head.meta = src.meta;
+	if (Array.isArray(src.link)) head.link = src.link;
+	if (Array.isArray(src.script)) head.script = src.script;
+	if (src.htmlAttrs && typeof src.htmlAttrs === "object") head.htmlAttrs = src.htmlAttrs;
+	if (src.bodyAttrs && typeof src.bodyAttrs === "object") head.bodyAttrs = src.bodyAttrs;
+	return Object.keys(head).length > 0 ? head : void 0;
+}
+function extractDefinePageFromCode(code) {
+	const scriptContent = extractScriptContent(code);
+	if (!scriptContent) return null;
+	const parsed = extractCallObject(scriptContent, "definePage");
+	if (!parsed) return null;
+	const result = {};
+	if (typeof parsed.name === "string") result.name = parsed.name;
+	if (typeof parsed.path === "string") result.path = parsed.path;
+	if (parsed.layout === false) result.layout = false;
+	else if (typeof parsed.layout === "string" && parsed.layout !== "default") result.layout = parsed.layout;
+	else if (Array.isArray(parsed.layout)) {
+		const layouts = parsed.layout.filter((l) => typeof l === "string");
+		if (layouts.length > 0) result.layout = layouts;
+	}
+	if (typeof parsed.reuse === "string") result.reuse = parsed.reuse;
+	if (parsed.meta && typeof parsed.meta === "object") result.meta = parsed.meta;
+	if (typeof parsed.requiresAuth === "boolean") result.requiresAuth = parsed.requiresAuth;
+	if (typeof parsed.cache === "boolean") result.cache = parsed.cache;
+	if (typeof parsed.transition === "string") result.transition = parsed.transition;
+	const head = normalizePageHead(parsed.head);
+	if (head) result.head = head;
+	return result;
+}
+async function extractDefinePage(filePath) {
+	return extractDefinePageFromCode(await readFile(filePath, "utf-8"));
+}
+//#endregion
+//#region src/route-name.ts
+/**
+* 路由名生成器(页面路由所有权归属 `@ubean/vue`)。
+* `@ubean/scan` 聚合层 re-export 保持向后兼容;服务端专用的
+* `generateApiRouteId` 保留在 `@ubean/scan`。
+*/
+function generateRouteName(routePath) {
+	if (routePath === "/" || routePath === "") return "Index";
+	const segments = routePath.replace(/^\//, "").replace(/\/$/, "").split("/");
+	const nameSegments = [];
+	for (const segment of segments) {
+		if (segment.startsWith("(") && segment.endsWith(")")) continue;
+		if (segment.startsWith("[...")) {
+			const param = segment.slice(4, -1);
+			nameSegments.push(`All${formatParamName(param)}`);
+			continue;
+		}
+		if (segment.startsWith("[[")) {
+			const param = segment.slice(2, -2);
+			nameSegments.push(`${formatParamName(param)}Optional`);
+			continue;
+		}
+		if (segment.startsWith("[")) {
+			const param = segment.slice(1, -1);
+			nameSegments.push(formatParamName(param));
+			continue;
+		}
+		nameSegments.push(pascalCase(segment));
+	}
+	return nameSegments.join("") || "Index";
+}
+function generateLayoutName(layoutPath) {
+	const base = layoutPath.replace(/\.(vue|ts)$/, "");
+	if (base === "default" || base === "default/index") return "default";
+	return base.split("/").filter(Boolean).map((s) => pascalCase(s)).join("");
+}
+function formatParamName(param) {
+	const cleaned = param.replace(/^\.{3}/, "").replace(/\?$/, "");
+	return pascalCase(cleaned);
+}
+//#endregion
+//#region src/route-path.ts
+/**
+* 路由路径算法(页面路由所有权归属 `@ubean/vue`,服务端 API 路由复用同一解析器):
+* - stripRouteGroups
+* - ParsedRoutePath 类型
+* - parseMatchers
+* - filePathToRoute
+*
+* `@ubean/scan` 聚合层 re-export 本文件导出保持向后兼容。
+*/
+const EXTENSION_REGEX = /\.(mjs|js|jsx|cjs|ts|tsx|mts|cts|vue|md|mdx)$/i;
+const METHOD_SUFFIX_REGEX = /\.(connect|delete|get|head|options|patch|post|put|trace)$/i;
+const ENV_SUFFIX_REGEX = /\.(dev|prod|prerender)$/i;
+const MIXED_SUFFIX_REGEX = /\.(connect|delete|get|head|options|patch|post|put|trace)\.(dev|prod|prerender)$/i;
+const DYNAMIC_PARAM_REGEX = /\[([^\]]+)\]/g;
+const CATCH_ALL_REGEX = /\[\.{3}([^\]]+)\]/g;
+const OPTIONAL_PARAM_REGEX = /\[\[([^\]]+)\]\]/g;
+const ROUTE_GROUP_REGEX = /\(([^(/\\]+)\)[/\\]/g;
+const ROUTE_GROUP_TRAILING_REGEX = /\(([^(/\\]+)\)$/;
+/**
+* `[id=numeric]` / `[...slug=anything]` matcher 语法解析。
+*
+* 捕获组:
+*   $1 = 可选的 `...`(catch-all 前缀)
+*   $2 = 参数名(id / slug / ...)
+*   $3 = 可选的 `=matcherName`
+*/
+const DYNAMIC_PARAM_WITH_MATCHER_REGEX = /\[(\.{3})?([A-Za-z_][\w-]*)(?:=([A-Za-z_][\w-]*))?\]/g;
+const INDEX_FILE_REGEX = /\/index$/;
+function stripRouteGroups(path) {
+	let result = path.replace(ROUTE_GROUP_REGEX, "");
+	result = result.replace(ROUTE_GROUP_TRAILING_REGEX, "");
+	return result;
+}
+/**
+* 解析 `[param=matcher]` 语法,从原始路径中提取 matcher 名称映射,并把
+* `=matcher` 后缀剥离,以便后续正则能正确识别为普通动态参数。
+*
+* @example
+* parseMatchers('users/[id=numeric]') → { cleaned: 'users/[id]', matchers: { id: 'numeric' } }
+* parseMatchers('blog/[...slug=any]') → { cleaned: 'blog/[...slug]', matchers: { slug: 'any' } }
+* parseMatchers('users/[id]')         → { cleaned: 'users/[id]', matchers: undefined }
+*/
+function parseMatchers(filePath) {
+	const matchers = {};
+	let hasMatchers = false;
+	const cleaned = filePath.replace(DYNAMIC_PARAM_WITH_MATCHER_REGEX, (full, dots, name, matcherName) => {
+		if (matcherName) {
+			matchers[name] = matcherName;
+			hasMatchers = true;
+		}
+		return dots ? `[${dots}${name}]` : `[${name}]`;
+	});
+	return hasMatchers ? {
+		cleaned,
+		matchers
+	} : { cleaned: filePath };
+}
+function filePathToRoute(filePath, prefix = "/") {
+	const { cleaned: matcherStripped, matchers } = parseMatchers(filePath);
+	let route = matcherStripped;
+	let method;
+	let env;
+	route = route.replace(EXTENSION_REGEX, "");
+	const mixedMatch = route.match(MIXED_SUFFIX_REGEX);
+	if (mixedMatch && mixedMatch.index !== void 0) {
+		route = route.slice(0, mixedMatch.index);
+		method = mixedMatch[1].toLowerCase();
+		env = mixedMatch[2];
+	} else {
+		const methodMatch = route.match(METHOD_SUFFIX_REGEX);
+		if (methodMatch && methodMatch.index !== void 0) {
+			route = route.slice(0, methodMatch.index);
+			method = methodMatch[1].toLowerCase();
+		}
+		const envMatch = route.match(ENV_SUFFIX_REGEX);
+		if (envMatch && envMatch.index !== void 0) {
+			route = route.slice(0, envMatch.index);
+			env = envMatch[1];
+		}
+	}
+	route = stripRouteGroups(route);
+	route = route.replace(CATCH_ALL_REGEX, (_, p) => `**:${p.replace(/[^\w-]/g, "_")}`);
+	route = route.replace(OPTIONAL_PARAM_REGEX, (_, p) => `:${p.replace(/[^\w-]/g, "_")}?`);
+	route = route.replace(DYNAMIC_PARAM_REGEX, (_, p) => `:${p.replace(/[^\w-]/g, "_")}`);
+	route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
+	route = route.replace(INDEX_FILE_REGEX, "") || "/";
+	return {
+		route,
+		method,
+		env,
+		cleaned: matcherStripped,
+		matchers
+	};
+}
+//#endregion
+//#region src/scan-pages.ts
+/**
+* 页面/布局扫描器(页面路由所有权归属 `@ubean/vue`)。
+*
+* 能力(从 `@ubean/scan` 沉淀并增强):
+* - 多 `pagesDir` / `layoutsDir`(先到先得去重,可分层叠加目录)
+* - reuse 路由(`.reuse.ts` / `.reuse.js`,纯元数据文件单独注入 `definePage`)+ cache 继承
+* - markdown 页面(opt-in,`@ubean/markdown` 按需加载解析 frontmatter)
+* - 页面级 head(opt-in,`definePage({ head })` / frontmatter `head`)
+* - 特殊页:`404` / `loading` / `error`(仅页面目录根级)
+* - 并行路由 `@slot/` 与拦截路由 `(..)target/` `(.)target/` `(...)target/`
+* - `[param=matcher]` 语法 → matchers 映射
+*
+* `@ubean/scan` 聚合层的 `scanProject` 委托本模块。
+*/
+/** 轻量告警(去重)—— 保持本包零 `@ubean/*` 硬依赖,不用 @ubean/logger。 */
+const _warned$1 = /* @__PURE__ */ new Set();
+function warn$1(message) {
+	if (_warned$1.has(message)) return;
+	_warned$1.add(message);
+	console.warn(`[ubean/vue] ${message}`);
+}
+let _frontmatterParser;
+async function getFrontmatterParser() {
+	if (_frontmatterParser !== void 0) return _frontmatterParser;
+	try {
+		const mod = await import("@ubean/markdown");
+		if (typeof mod.parseFrontmatter === "function") _frontmatterParser = mod.parseFrontmatter;
+		else _frontmatterParser = null;
+	} catch {
+		warn$1("`markdown` is enabled but `@ubean/markdown` is not installed — frontmatter parsing will be skipped. Install it to enable markdown pages.");
+		_frontmatterParser = null;
+	}
+	return _frontmatterParser;
+}
+/** Build a `PageHead` from Markdown frontmatter(与 definePage head 校验规则一致)。 */
+function buildMarkdownHead(fm, enabled) {
+	if (!enabled || !fm || typeof fm.head !== "object" || fm.head === null) return void 0;
+	const fmHead = fm.head;
+	const head = {};
+	if (typeof fmHead.title === "string") head.title = fmHead.title;
+	if (Array.isArray(fmHead.meta)) head.meta = fmHead.meta;
+	if (Array.isArray(fmHead.link)) head.link = fmHead.link;
+	if (Array.isArray(fmHead.script)) head.script = fmHead.script;
+	if (fmHead.htmlAttrs && typeof fmHead.htmlAttrs === "object") head.htmlAttrs = fmHead.htmlAttrs;
+	if (fmHead.bodyAttrs && typeof fmHead.bodyAttrs === "object") head.bodyAttrs = fmHead.bodyAttrs;
+	return Object.keys(head).length > 0 ? head : void 0;
+}
+/**
+* Extract parallel route slot name and intercept info from a relative file path.
+*
+* Parallel routes: `@slotName/page.vue` → slot = 'slotName'
+* Intercepting routes:
+*   `(..)target/page.vue`  → intercept from parent, target = 'target'
+*   `(.)target/page.vue`   → intercept from same level, target = 'target'
+*   `(...)target/page.vue` → intercept from root, target = 'target'
+*/
+function extractSlotAndIntercept(fileBase) {
+	const segments = fileBase.split("/");
+	let slot;
+	let interceptFrom;
+	let interceptTarget;
+	const cleanedSegments = [];
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg.startsWith("@")) {
+			slot = seg.slice(1);
+			continue;
+		}
+		const interceptMatch = seg.match(/^\((\.{1,3})\)(.+)$/);
+		if (interceptMatch) {
+			const dots = interceptMatch[1];
+			interceptTarget = interceptMatch[2];
+			const prefixSegments = cleanedSegments.slice(0, i);
+			if (dots === "..") interceptFrom = `/${prefixSegments.slice(0, -1).join("/")}`;
+			else if (dots === "...") interceptFrom = "/";
+			else interceptFrom = `/${prefixSegments.join("/")}`;
+			continue;
+		}
+		cleanedSegments.push(seg);
+	}
+	return {
+		cleanedBase: cleanedSegments.join("/"),
+		slot,
+		interceptFrom,
+		interceptTarget
+	};
+}
+/**
+* Normalize a `string | string[]` dir entry into `string[]`。Falsy 值回退到
+* 默认值;空数组同样回退,保证下游 glob 始终拿到非空列表。
+*/
+function normalizeDirs(value, fallback) {
+	if (value === void 0 || value === null || value === "") return [fallback];
+	if (Array.isArray(value)) {
+		const filtered = value.filter((d) => typeof d === "string" && d.length > 0);
+		return filtered.length > 0 ? filtered : [fallback];
+	}
+	return [value];
+}
+/** 目录条目 → 绝对路径(相对 `srcDir` 或已是绝对路径)。 */
+function resolveDirs(srcDir, value, fallback) {
+	return normalizeDirs(value, fallback).map((single) => isAbsolute(single) ? single : join(srcDir, single));
+}
+function toPosixPath(p) {
+	return p.replace(/\\/g, "/");
+}
+const DEFAULT_IGNORE = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/*.d.ts"
+];
+/** 解析 markdown 配置 → 参与扫描的 markdown 扩展名列表(空 = 关闭)。 */
+function resolveMarkdownExts(markdown) {
+	if (markdown === true) return ["md", "mdx"];
+	if (markdown === "md" || markdown === "mdx") return [markdown];
+	return [];
+}
+async function scanPages(options) {
+	const srcDir = isAbsolute(options.srcDir) ? options.srcDir : join(options.cwd, options.srcDir);
+	const ignore = [...DEFAULT_IGNORE, ...options.ignore || []];
+	const markdownExts = resolveMarkdownExts(options.markdown);
+	const headEnabled = options.head === true;
+	const extensions = [...options.extensions && options.extensions.length > 0 ? options.extensions : [
+		"vue",
+		"tsx",
+		"jsx"
+	]];
+	for (const ext of markdownExts) if (!extensions.includes(ext)) extensions.push(ext);
+	const pagesDirs = resolveDirs(srcDir, options.pagesDir, "pages");
+	const layoutsDirs = resolveDirs(srcDir, options.layoutsDir, "layouts");
+	const pagesPattern = [`**/*.{${extensions.join(",")}}`, "**/*.reuse.{ts,js}"];
+	const layoutsPattern = "**/*.{vue,ts}";
+	const pages = [];
+	const layouts = [];
+	const seenPagePaths = /* @__PURE__ */ new Set();
+	const seenLayoutPaths = /* @__PURE__ */ new Set();
+	let notFoundPage;
+	let loadingPage;
+	let errorPage;
+	for (const dir of pagesDirs) {
+		const files = await glob(pagesPattern, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/components/**",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			if (seenPagePaths.has(fullPath)) continue;
+			seenPagePaths.add(fullPath);
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const ext = extname(relativePath);
+			const base = basename(relativePath, ext);
+			if (base.startsWith("_")) continue;
+			const isMarkdown = ext === ".md" || ext === ".mdx";
+			const isReuse = !isMarkdown && /\.reuse\.(ts|js)$/.test(relativePath);
+			const pageBase = isReuse ? base.slice(0, -6) : base;
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			const { cleanedBase, slot, interceptFrom, interceptTarget } = extractSlotAndIntercept(dirPart ? `${dirPart}/${pageBase}` : pageBase);
+			const fileBase = cleanedBase;
+			if (!isReuse && dirPart === "" && (pageBase === "404" || pageBase === "loading" || pageBase === "error")) {
+				const { route: specialRoute, cleaned: specialCleaned } = filePathToRoute(fileBase);
+				const specialName = pageBase === "404" ? "NotFound" : generateRouteName(specialCleaned || specialRoute);
+				const specialPage = {
+					fullPath,
+					relativePath,
+					dirname: dirname(relativePath),
+					basename: basename(relativePath),
+					name: specialName,
+					route: specialRoute,
+					path: specialRoute,
+					layout: void 0,
+					cache: void 0,
+					isReuse: false,
+					isMarkdown,
+					reuseTarget: void 0,
+					pageMeta: void 0,
+					frontmatter: void 0
+				};
+				if (pageBase === "404") notFoundPage ??= specialPage;
+				else if (pageBase === "loading") loadingPage ??= specialPage;
+				else errorPage ??= specialPage;
+				continue;
+			}
+			const { route, cleaned, matchers } = filePathToRoute(fileBase);
+			const name = generateRouteName(cleaned || route);
+			let pageMeta = null;
+			let frontmatter;
+			if (isMarkdown) try {
+				const content = await readFile(fullPath, "utf-8");
+				const parser = await getFrontmatterParser();
+				if (parser) {
+					frontmatter = parser(content).data;
+					pageMeta = {
+						name: frontmatter?.name || name,
+						path: frontmatter?.path || route,
+						layout: frontmatter?.layout,
+						cache: frontmatter?.cache,
+						head: buildMarkdownHead(frontmatter, headEnabled)
+					};
+				} else pageMeta = {
+					name,
+					path: route
+				};
+			} catch {
+				pageMeta = null;
+			}
+			else pageMeta = await readFile(fullPath, "utf-8").then((code) => extractDefinePageFromCode(code)).catch(() => null);
+			if (pageMeta?.head && !headEnabled) {
+				warn$1("`definePage({ head })` / frontmatter `head` declared but the `head` option is disabled — head will be ignored.");
+				delete pageMeta.head;
+			}
+			pages.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name: pageMeta?.name || name,
+				route: pageMeta?.path || route,
+				path: pageMeta?.path || route,
+				layout: pageMeta?.layout,
+				cache: pageMeta?.cache,
+				isReuse,
+				isMarkdown,
+				reuseTarget: pageMeta?.reuse,
+				pageMeta: pageMeta || void 0,
+				frontmatter,
+				slot,
+				interceptFrom,
+				interceptTarget,
+				matchers
+			});
+		}
+	}
+	for (const dir of layoutsDirs) {
+		const files = await glob(layoutsPattern, {
+			cwd: dir,
+			dot: true,
+			ignore: [...ignore, "**/_*"],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			if (seenLayoutPaths.has(fullPath)) continue;
+			seenLayoutPaths.add(fullPath);
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const base = basename(relativePath, extname(relativePath));
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			const layoutBase = base === "index" ? dirPart : dirPart ? `${dirPart}/${base}` : base;
+			const isDefault = base === "default" || base === "index" && !dirPart;
+			const name = layoutBase || "default";
+			layouts.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name,
+				path: toPosixPath(relativePath),
+				isDefault
+			});
+		}
+	}
+	const regularPageNames = new Set(pages.filter((p) => !p.isReuse).map((p) => p.name));
+	for (const page of pages) if (page.isReuse && page.reuseTarget && !regularPageNames.has(page.reuseTarget)) warn$1(`Reuse page "${page.name}" references target "${page.reuseTarget}" which does not exist. Available page targets: ${[...regularPageNames].join(", ") || "(none)"}`);
+	const targetCacheMap = /* @__PURE__ */ new Map();
+	for (const p of pages) if (!p.isReuse) targetCacheMap.set(p.name, p.cache);
+	for (const page of pages) if (page.isReuse && page.reuseTarget && page.cache === void 0) {
+		if (targetCacheMap.get(page.reuseTarget) === true) {
+			page.cache = true;
+			if (page.pageMeta) page.pageMeta.cache = true;
+			else page.pageMeta = { cache: true };
+		}
+	}
+	return {
+		pages,
+		layouts,
+		notFoundPage,
+		loadingPage,
+		errorPage
+	};
+}
+//#endregion
+//#region src/virtual-pages.ts
+/**
+* 页面虚拟模块生成器(页面路由所有权归属 `@ubean/vue`)。
+*
+* 输出统一的模块形态,同时服务两个消费方:
+* - 精简内核:`virtual:ubean-vue-routes`(`@ubean/vue/vite` 插件)
+* - 框架层:`virtual:ubean-pages`(`packages/vite` 经 `defineVirtualModule` 包装)
+*
+* 导出面(纯 JS,SSR-safe):
+* - `routes` —— vue-router `RouteRecordRaw[]`
+* - `pageNames` / `layoutNames` / `defaultLayout`
+* - `resolvePageComponent` / `resolveLayoutComponent` /
+*   `resolveLoadingComponent` / `resolveErrorComponent`
+* - `loadingComponent` / `errorComponent`(精简内核 BC:loader 或 null)
+* - `hasNotFoundPage` / `hasErrorPage`
+* - `pages` / `layouts` 元信息映射
+*/
+/** `** :param`(scanner 方言)→ vue-router `:param(.*)*`。 */
+function toVueRouterPath(route) {
+	return route.replace(/\*\*:(\w[\w-]*)/g, ":$1(.*)*");
+}
+/**
+* Sort pages so that reuse routes come after their targets.
+*
+* A reuse route generates `const Page_Reuse = Page_Target;` in the virtual
+* module. If the reuse route is declared before its target, JavaScript's TDZ
+* throws `Cannot access 'Page_Target' before initialization`. This
+* topological sort ensures targets are always emitted before their reuse
+* routes.
+*/
+function sortPagesByReuseDependency(pages) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const byName = /* @__PURE__ */ new Map();
+	for (const p of pages) byName.set(p.name, p);
+	function visit(page) {
+		if (visited.has(page.name)) return;
+		visited.add(page.name);
+		if (page.isReuse && page.reuseTarget && byName.has(page.reuseTarget)) visit(byName.get(page.reuseTarget));
+		result.push(page);
+	}
+	for (const p of pages) visit(p);
+	return result;
+}
+function varNameFor(name) {
+	return `Page_${name.replace(/[^a-zA-Z0-9]/g, "_")}`;
+}
+function layoutVarNameFor(name) {
+	return `Layout_${name.replace(/[^a-zA-Z0-9]/g, "_")}`;
+}
+/** 组装单条路由的 meta(JSON 序列化;undefined 字段自动省略)。 */
+function buildRouteMeta(page, extra = {}) {
+	const meta = {
+		pageName: page.name,
+		layout: page.layout,
+		cache: page.cache === true ? true : void 0,
+		reuseTarget: page.isReuse ? page.reuseTarget : void 0,
+		transition: page.pageMeta?.transition,
+		requiresAuth: page.pageMeta?.requiresAuth === true ? true : void 0,
+		matchers: page.matchers && Object.keys(page.matchers).length > 0 ? page.matchers : void 0,
+		head: page.pageMeta?.head,
+		...page.pageMeta?.meta,
+		...extra
+	};
+	return JSON.stringify(meta);
+}
+/** Generate the virtual module source(plain JS — no TS syntax, SSR-safe)。 */
+function generatePagesModuleSource(input) {
+	const { pages, layouts } = input;
+	const pageLoaders = [];
+	const layoutLoaders = [];
+	const routeEntries = [];
+	const pageByName = /* @__PURE__ */ new Map();
+	for (const p of pages) pageByName.set(p.name, p);
+	const sortedPages = sortPagesByReuseDependency(pages);
+	for (const p of sortedPages) {
+		const varName = varNameFor(p.name);
+		if (p.isReuse && p.reuseTarget && pageByName.has(p.reuseTarget)) pageLoaders.push(`const ${varName} = ${varNameFor(p.reuseTarget)};`);
+		else pageLoaders.push(`const ${varName} = () => import(${JSON.stringify(p.fullPath)}).then(m => m.default || m);`);
+	}
+	if (input.notFoundPage) pageLoaders.push(`const Page_NotFound = () => import(${JSON.stringify(input.notFoundPage.fullPath)}).then(m => m.default || m);`);
+	const namedPages = input.notFoundPage ? [...sortedPages, input.notFoundPage] : sortedPages;
+	const routeGroups = /* @__PURE__ */ new Map();
+	const interceptPages = [];
+	for (const p of sortedPages) {
+		if (p.interceptTarget) {
+			interceptPages.push(p);
+			continue;
+		}
+		const routerPath = toVueRouterPath(p.route);
+		let group = routeGroups.get(routerPath);
+		if (!group) {
+			group = { slots: /* @__PURE__ */ new Map() };
+			routeGroups.set(routerPath, group);
+		}
+		if (p.slot) group.slots.set(p.slot, p);
+		else if (!group.default) group.default = p;
+	}
+	for (const [routerPath, group] of routeGroups) {
+		const defaultPage = group.default;
+		const slotPages = [...group.slots.values()];
+		if (!defaultPage && slotPages.length === 0) continue;
+		const primaryPage = defaultPage || slotPages[0];
+		if (slotPages.length > 0) {
+			const componentParts = [];
+			if (defaultPage) componentParts.push(`default: ${varNameFor(defaultPage.name)}`);
+			for (const sp of slotPages) componentParts.push(`${JSON.stringify(sp.slot)}: ${varNameFor(sp.name)}`);
+			routeEntries.push(`  { path: ${JSON.stringify(routerPath)}, name: ${JSON.stringify(primaryPage.name)}, components: { ${componentParts.join(", ")} }, meta: ${buildRouteMeta(primaryPage, { parallelSlots: slotPages.map((s) => s.slot) })} }`);
+		} else routeEntries.push(`  { path: ${JSON.stringify(routerPath)}, name: ${JSON.stringify(defaultPage.name)}, component: ${varNameFor(defaultPage.name)}, meta: ${buildRouteMeta(defaultPage)} }`);
+	}
+	for (const p of interceptPages) {
+		const routerPath = toVueRouterPath(p.route);
+		const interceptName = `__intercept_${p.name}`;
+		routeEntries.push(`  { path: ${JSON.stringify(routerPath)}, name: ${JSON.stringify(interceptName)}, component: ${varNameFor(p.name)}, meta: ${buildRouteMeta(p, {
+			interceptFrom: p.interceptFrom,
+			interceptTarget: p.interceptTarget,
+			isIntercepting: true
+		})} }`);
+	}
+	let hasNotFound = false;
+	if (input.notFoundPage) {
+		hasNotFound = true;
+		routeEntries.push(`  { path: ${JSON.stringify("/:pathMatch(.*)*")}, name: "NotFound", component: Page_NotFound, meta: { pageName: "NotFound" } }`);
+	}
+	let loadingLoaderName = "null";
+	if (input.loadingPage) {
+		loadingLoaderName = "LoadingPage";
+		pageLoaders.push(`const ${loadingLoaderName} = () => import(${JSON.stringify(input.loadingPage.fullPath)}).then(m => m.default || m);`);
+	}
+	let errorLoaderName = "null";
+	if (input.errorPage) {
+		errorLoaderName = "ErrorPage";
+		pageLoaders.push(`const ${errorLoaderName} = () => import(${JSON.stringify(input.errorPage.fullPath)}).then(m => m.default || m);`);
+	}
+	for (const l of layouts) layoutLoaders.push(`const ${layoutVarNameFor(l.name)} = () => import(${JSON.stringify(l.fullPath)}).then(m => m.default || m);`);
+	const defaultLayout = layouts.find((l) => l.isDefault);
+	const defaultLayoutName = defaultLayout ? defaultLayout.name : "null";
+	const layoutLoaderMap = layouts.map((l) => `  ${JSON.stringify(l.name)}: ${layoutVarNameFor(l.name)}`).join(",\n");
+	return `// Generated by @ubean/vue — file-based pages virtual module. Do not edit.
+/* eslint-disable */
+
+${pageLoaders.join("\n")}
+${layoutLoaders.join("\n")}
+
+export const routes = [
+${routeEntries.join(",\n")}
+];
+
+const _layoutLoaders = {
+${layoutLoaderMap}
+};
+
+const _pageLoaders = {
+${namedPages.map((p) => `  ${JSON.stringify(p.name)}: ${varNameFor(p.name)}`).join(",\n")}
+};
+
+export const pageNames = [${namedPages.map((p) => JSON.stringify(p.name)).join(", ")}];
+export const layoutNames = [${layouts.map((l) => JSON.stringify(l.name)).join(", ")}];
+export const defaultLayout = ${defaultLayoutName === "null" ? "null" : JSON.stringify(defaultLayoutName)};
+
+export function resolvePageComponent(name) {
+  const loader = _pageLoaders[name];
+  if (!loader) {
+    return Promise.reject(new Error('[ubean] Page component not found: ' + name));
+  }
+  return loader();
+}
+
+export function resolveLayoutComponent(name) {
+  if (!name) return Promise.resolve(null);
+  const loader = _layoutLoaders[name];
+  if (!loader) {
+    return Promise.resolve(null);
+  }
+  return loader();
+}
+
+export function resolveLoadingComponent() {
+  ${loadingLoaderName === "null" ? "return Promise.resolve(null);" : `return ${loadingLoaderName}();`}
+}
+
+export function resolveErrorComponent() {
+  ${errorLoaderName === "null" ? "return Promise.resolve(null);" : `return ${errorLoaderName}();`}
+}
+
+export const loadingComponent = ${loadingLoaderName === "null" ? "null" : loadingLoaderName};
+export const errorComponent = ${errorLoaderName === "null" ? "null" : errorLoaderName};
+
+export function hasNotFoundPage() {
+  return ${hasNotFound};
+}
+
+export function hasErrorPage() {
+  return ${errorLoaderName !== "null"};
+}
+
+export const pages = {
+${pages.map((p) => `  ${JSON.stringify(p.name)}: { name: ${JSON.stringify(p.name)}, route: ${JSON.stringify(p.route)}, path: ${JSON.stringify(p.path)}, layout: ${JSON.stringify(p.layout)}, isReuse: ${p.isReuse}, reuseTarget: ${JSON.stringify(p.reuseTarget)} }`).join(",\n")}
+};
+
+export const layouts = {
+${layouts.map((l) => `  ${JSON.stringify(l.name)}: { name: ${JSON.stringify(l.name)}, isDefault: ${l.isDefault} }`).join(",\n")}
+};
+`.trimEnd().concat("\n");
+}
+/**
+* 从 vue-router 风格路径中提取参数信息。
+*
+* 支持:`:name`、`:name?`、`:name*`、`:name+`、`:name(...)`。
+* 不识别 `:pathMatch(.*)*`(catch-all),视为无参数。
+*/
+function extractRouteParams(path) {
+	const params = [];
+	const paramRegex = /:([A-Za-z_][A-Za-z0-9_]*)(?:\([^)]*\))?([?*+]?)/g;
+	let match;
+	while ((match = paramRegex.exec(path)) !== null) {
+		const name = match[1];
+		const modifier = match[2];
+		const optional = modifier === "?" || modifier === "*";
+		if (!params.some((p) => p.name === name)) params.push({
+			name,
+			optional
+		});
+	}
+	return params;
+}
+/** 渲染参数类型字面量(`ParamValue<true/false>` / `ParamValueZeroOrOne<...>`)。 */
+function renderParamsType(params, isRaw) {
+	if (params.length === 0) return "Record<never, never>";
+	return `{\n${params.map((p) => {
+		const optionalMarker = p.optional ? "?" : "";
+		const type = p.optional ? `ParamValueZeroOrOne<${isRaw ? "true" : "false"}>` : `ParamValue<${isRaw ? "true" : "false"}>`;
+		return `    ${p.name}${optionalMarker}: ${type}`;
+	}).join(",\n")}\n  }`;
+}
+function renderRouteRecordInfo(page) {
+	const params = extractRouteParams(page.route);
+	const paramsRaw = renderParamsType(params, true);
+	const paramsResolved = renderParamsType(params, false);
+	return `RouteRecordInfo<${JSON.stringify(page.name)}, ${JSON.stringify(page.route)}, ${paramsRaw}, ${paramsResolved}>`;
+}
+/** 虚拟模块导出面声明(`declare module` 内部内容,环境声明产物使用)。 */
+function renderVirtualModuleBody(input, moduleId) {
+	const pages = input.pages;
+	return `declare module '${moduleId}' {
+  export const routes: import('vue-router').RouteRecordRaw[];
+  export type PageName = ${pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never"}${input.notFoundPage ? ` | ${JSON.stringify(input.notFoundPage.name)}` : ""};
+  export const pageNames: PageName[];
+  export const layoutNames: string[];
+  export const defaultLayout: string | null;
+  export const loadingComponent: import('vue').Component | null;
+  export const errorComponent: import('vue').Component | null;
+  export function resolvePageComponent(name: string): Promise<import('vue').Component>;
+  export function resolveLayoutComponent(name: string): Promise<import('vue').Component | null>;
+  export function resolveLoadingComponent(): Promise<import('vue').Component | null>;
+  export function resolveErrorComponent(): Promise<import('vue').Component | null>;
+  export function hasNotFoundPage(): boolean;
+  export function hasErrorPage(): boolean;
+}`;
+}
+/**
+* Generate the ambient module declaration d.ts for the virtual module.
+*
+* 产物必须是 **script 文件**(无顶层 import/export)—— `declare module` 在
+* script 上下文中才注册「环境模块声明」;在 module 文件中会被当作模块增强,
+* 对不存在的模块无法生效。由 `/vite` 插件写入 `<root>/ubean-vue-routes.d.ts`。
+*/
+function generateVirtualModuleDts(input, moduleId = "virtual:ubean-vue-routes") {
+	return `// Generated by @ubean/vue — do not edit.
+/* eslint-disable */
+
+${renderVirtualModuleBody(input, moduleId)}
+`;
+}
+/**
+* Generate `typed-router.d.ts` content for the virtual module.
+*
+* 包含 `vue-router/auto-routes` 的 `RouteNamedMap` 增强,让 vue-router 的
+* `useRoute<Name>(name)` / `RouterLink` 能推断 `route.params` 类型。
+*
+* 产物是 **module 文件**(顶层 `export {}`)—— `declare module` 块按「模块
+* 增强」语义合并进真实的 'vue-router' / 'vue-router/auto-routes' 模块;
+* 若以 script 形式输出,同名环境模块声明会整体遮蔽真实包的类型。
+* 虚拟模块自身的环境声明见 `generateVirtualModuleDts`。
+*/
+function generateTypedRouter(input, _moduleId = "virtual:ubean-vue-routes") {
+	const pages = input.pages;
+	return `// Generated by @ubean/vue — do not edit.
+/* eslint-disable */
+
+// 本文件为 module(顶层 export)—— declare module 块按「模块增强」语义合并。
+// 虚拟模块 'virtual:ubean-vue-routes' 的环境声明在伴生文件 ubean-vue-routes.d.ts。
+export {};
+
+declare module 'vue-router/auto-routes' {
+  import type { RouteRecordInfo, ParamValue, ParamValueZeroOrOne } from 'vue-router';
+
+  export interface RouteNamedMap {
+${pages.length > 0 ? pages.map((p) => `    "${p.name}": ${renderRouteRecordInfo(p)};`).join("\n") : "    // (no pages scanned)"}
+  }
+}
+
+declare module 'vue-router' {
+  export interface TypesConfig {
+    RouteNamedMap: import('vue-router/auto-routes').RouteNamedMap;
+  }
+}
+`;
+}
+//#endregion
+//#region src/vite.ts
+/**
+* `@ubean/vue/vite` —— 精简客户端路由 Vite 插件(页面路由唯一所有者)。
+*
+* 能力:
+* - 多 `pagesDir` / `layoutsDir` 扫描(先到先得去重)
+* - reuse 路由、特殊页(404/loading/error)、并行路由 `@slot/`、拦截路由
+* - `[param=matcher]` 语法(matchers 注入 `route.meta`)
+* - markdown 页面(opt-in,默认 false,`@ubean/markdown` 按需加载)
+* - 页面级 head(opt-in,默认 false,写入 `route.meta.head`)
+* - `typed-router.d.ts` 生成(RouteNamedMap 完整类型推断,产物在 `dtsDir`,默认 `.ubean`)
+*
+* 框架层(`@ubean/vite`)通过 `generatePagesModuleSource` /
+* `scanPages` / `generateTypedRouter` 复用同一套生成器。
+*/
+const VUE_ROUTES_MODULE_ID = "virtual:ubean-vue-routes";
+const RESOLVED_MODULE_ID = `\0${VUE_ROUTES_MODULE_ID}`;
+/** 剥离 `definePage({...})` 宏调用(构建期,扫描后源码中不再需要)。 */
+function stripDefinePageCalls(code) {
+	return code.replace(/(^|\n)[ \t]*(?:export[ \t]+)?definePage\s*\(\s*\{[\s\S]*?\}\s*\)[ \t]*;?/g, "$1");
+}
+/**
+* 扫描客户端页面/布局(对外工具函数,`root` 为项目根)。
+*/
+async function scanClientPages(root, options = {}) {
+	return scanPages({
+		cwd: root,
+		srcDir: root,
+		pagesDir: options.pagesDir ?? "src/pages",
+		layoutsDir: options.layoutsDir ?? "src/layouts",
+		extensions: options.extensions,
+		ignore: options.ignore,
+		markdown: options.markdown,
+		head: options.head
+	});
+}
+const _warned = /* @__PURE__ */ new Set();
+function warn(message) {
+	if (_warned.has(message)) return;
+	_warned.add(message);
+	console.warn(`[ubean/vue] ${message}`);
+}
+function ubeanVueVite(options = {}) {
+	let root = process.cwd();
+	let scan = null;
+	let markdownApi = null;
+	const markdownEnabled = options.markdown === true || options.markdown === "md" || options.markdown === "mdx";
+	const mdxEnabled = options.markdown === true || options.markdown === "mdx";
+	async function loadMarkdownApi() {
+		if (!markdownEnabled) return null;
+		try {
+			const mod = await import("@ubean/markdown");
+			if (typeof mod.parseFrontmatter === "function" && typeof mod.markdownToHtml === "function") return mod;
+		} catch {}
+		warn("`markdown` is enabled but `@ubean/markdown` is not installed — markdown pages will not render.");
+		return null;
+	}
+	async function rescan() {
+		scan = await scanClientPages(root, options);
+		if (options.generateTypes !== false) await writeTypedRouter();
+		return scan;
+	}
+	async function writeTypedRouter() {
+		if (!scan) return;
+		const dtsDirOption = options.dtsDir ?? ".ubean";
+		const dtsDir = isAbsolute(dtsDirOption) ? dtsDirOption : join(root, dtsDirOption);
+		const files = [[join(dtsDir, "ubean-vue-routes.d.ts"), generateVirtualModuleDts(scan, VUE_ROUTES_MODULE_ID)], [join(dtsDir, "typed-router.d.ts"), generateTypedRouter(scan, VUE_ROUTES_MODULE_ID)]];
+		for (const [outPath, content] of files) try {
+			if (await readFile(outPath, "utf-8").catch(() => null) !== content) {
+				await mkdir(dtsDir, { recursive: true });
+				await writeFile(outPath, content, "utf-8");
+			}
+		} catch {}
+	}
+	function isUnderPagesDir(id) {
+		return (Array.isArray(options.pagesDir) ? options.pagesDir : [options.pagesDir ?? "src/pages"]).map((d) => isAbsolute(d) ? d : join(root, d)).some((d) => id.startsWith(`${d}/`) || id.startsWith(`${d}\\`));
+	}
+	return {
+		name: "ubean-vue-routes",
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+		},
+		async buildStart() {
+			markdownApi = await loadMarkdownApi();
+			await rescan();
+		},
+		resolveId(id) {
+			if (id === "virtual:ubean-vue-routes") return RESOLVED_MODULE_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_MODULE_ID) {
+				if (!scan) return rescan().then((result) => generatePagesModuleSource(result));
+				return generatePagesModuleSource(scan);
+			}
+			return null;
+		},
+		transform(code, id) {
+			const [filePath] = id.split("?", 2);
+			if (!isUnderPagesDir(filePath)) return null;
+			if (filePath.endsWith(".md") || mdxEnabled && filePath.endsWith(".mdx")) {
+				if (!markdownApi) return null;
+				if (filePath.endsWith(".mdx") && typeof markdownApi.compileMdx === "function") return markdownApi.compileMdx(code, { filePath: relative(root, filePath) }).then((result) => ({
+					code: result.code,
+					map: null
+				}));
+				const { data: frontmatter, content } = markdownApi.parseFrontmatter(code);
+				const html = markdownApi.markdownToHtml(content);
+				return {
+					code: [
+						`import { h } from 'vue';`,
+						`export const frontmatter = ${JSON.stringify(frontmatter)};`,
+						`const _html = ${JSON.stringify(html)};`,
+						`export default {`,
+						`  name: ${JSON.stringify(`MdPage_${relative(root, filePath).replace(/[^\w]/g, "_")}`)},`,
+						`  data() { return { frontmatter }; },`,
+						`  render() { return h('div', { class: 'ubean-md-page', innerHTML: _html }); }`,
+						`};`
+					].join("\n"),
+					map: null
+				};
+			}
+			if (/\.(vue|tsx?|jsx?)$/.test(filePath) && code.includes("definePage")) return {
+				code: stripDefinePageCalls(code),
+				map: null
+			};
+			return null;
+		},
+		configureServer(server) {
+			const pageExts = markdownEnabled ? /\.(vue|tsx?|jsx?|md|mdx)$/ : /\.(vue|tsx?|jsx?)$/;
+			const onChange = (file) => {
+				if (!pageExts.test(file) || !isUnderPagesDir(file)) return;
+				rescan().then(() => {
+					const mod = server.moduleGraph.getModuleById(RESOLVED_MODULE_ID);
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				});
+			};
+			server.watcher.on("add", onChange);
+			server.watcher.on("unlink", onChange);
+		}
+	};
+}
+//#endregion
+export { VUE_ROUTES_MODULE_ID, ubeanVueVite as default, ubeanVueVite, extractCallObject, extractDefinePage, extractDefinePageFromCode, extractSlotAndIntercept, filePathToRoute, generateLayoutName, generatePagesModuleSource, generateRouteName, generateTypedRouter, generateVirtualModuleDts, normalizePageHead, parseMatchers, scanClientPages, scanPages, stripDefinePageCalls, stripRouteGroups };