weapp-vite 7.5.0 → 7.6.0

package/dist/devProvider-D-hTfsEO.mjs

@@ -0,0 +1,3027 @@
+import { n as withRealpathScope, t as resolveRealpath } from "./realpathScope-Tf9mz-fh.mjs";
+import { n as normalizeFsResolvedId, t as isSkippableResolvedId } from "./resolvedId-CiDl7SC1.mjs";
+import { a as parseSidecarModuleId, c as resolveVirtualModuleId, i as parseLogicalEntryId, n as createSidecarModuleId, o as parseSidecarSourceMetadata, r as createSidecarSourceSpecifier, s as parseSidecarSourceRequest } from "./protocol-Cg6Jdlvb.mjs";
+import { a as normalizeWatchPath, n as normalizePath$1, s as toPosixPath, t as isPathInside } from "./path-CYYIQGS7.mjs";
+import { a as getPlatformNpmDistDirName, h as resolveMiniPlatformWithDefault } from "./platform-CnkySBKz.mjs";
+import process$1 from "node:process";
+import { WEAPP_VITE_RUNTIME_VIRTUAL_ID, WEVU_AUTO_ROUTES_MODULE_ID as WEVU_AUTO_ROUTES_MODULE_ID$1, WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID as WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID$1, WEVU_AUTO_ROUTES_VIRTUAL_MODULE_ID as WEVU_AUTO_ROUTES_VIRTUAL_MODULE_ID$1 } from "@weapp-core/constants";
+import path from "pathe";
+import { readlinkSync, stat, unwatchFile, watch, watchFile } from "node:fs";
+import * as sp from "node:path";
+import path$1, { join, resolve, sep } from "node:path";
+import picomatch from "picomatch";
+import { readAndParseSfc } from "wevu/compiler";
+import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
+import { createLogger, createServer, transformWithOxc } from "vite";
+import { EventEmitter, once } from "node:events";
+import { Readable } from "node:stream";
+import { type } from "node:os";
+import { getPackageInfoSync } from "local-pkg";
+//#region src/moduleGraph/traversal.ts
+function normalizeSourceId(id) {
+	const normalized = normalizeFsResolvedId(id);
+	if (isSkippableResolvedId(normalized)) return normalized;
+	try {
+		return normalizeFsResolvedId(resolveRealpath(normalized));
+	} catch {
+		if (!path$1.isAbsolute(normalized) && path$1.win32.isAbsolute(normalized)) return normalized;
+		let candidate = normalized;
+		let links;
+		for (;;) {
+			let target;
+			try {
+				target = readlinkSync(candidate);
+			} catch {
+				break;
+			}
+			links ??= /* @__PURE__ */ new Set();
+			if (links.has(candidate)) return normalized;
+			links.add(candidate);
+			candidate = path$1.resolve(path$1.dirname(candidate), target);
+		}
+		try {
+			return normalizeFsResolvedId(path$1.join(resolveRealpath(path$1.dirname(candidate)), path$1.basename(candidate)));
+		} catch {
+			return normalizeFsResolvedId(candidate);
+		}
+	}
+}
+/** 逻辑入口与源码按同一真实路径比较，避免 junction 或原生分隔符制造第二个输出归属。 */
+function isLogicalEntrySource(id, importers = []) {
+	let normalizedSource;
+	for (const importer of importers) {
+		const logicalEntry = parseLogicalEntryId(importer);
+		if (!logicalEntry) continue;
+		normalizedSource ??= normalizeSourceId(id);
+		if (logicalEntry.sourceId === normalizedSource) return true;
+	}
+	return false;
+}
+function moduleIdMatchesFile(id, file) {
+	const sidecarSource = parseSidecarSourceRequest(id);
+	if (sidecarSource) return normalizeSourceId(sidecarSource.sourceId) === file;
+	const sidecar = parseSidecarModuleId(id);
+	if (sidecar) return normalizeSourceId(sidecar.sourceId) === file;
+	const logicalEntry = parseLogicalEntryId(id);
+	if (logicalEntry) return normalizeSourceId(logicalEntry.sourceId) === file;
+	return normalizeSourceId(id) === file;
+}
+/** 存在性查询首次命中即返回，不为布尔结果收集全部模块。 */
+function hasBuildModule(context, file) {
+	return withRealpathScope(() => {
+		for (const id of context.getModuleIds?.() ?? []) if (moduleIdMatchesFile(id, file)) return true;
+		return false;
+	});
+}
+/** 优先查询当前文件索引；未命中时仍按完整协议与真实路径查找别名。 */
+function hasDevModule(server, file) {
+	return withRealpathScope(() => {
+		if (server.moduleGraph.getModulesByFile(file)?.size) return true;
+		for (const [id] of server.moduleGraph.idToModuleMap ?? []) if (moduleIdMatchesFile(id, file)) return true;
+		return false;
+	});
+}
+function collectBuildStartIds(context, file) {
+	return withRealpathScope(() => {
+		const ids = /* @__PURE__ */ new Set();
+		if (typeof context.getModuleIds !== "function") return ids;
+		for (const id of context.getModuleIds()) if (moduleIdMatchesFile(id, file)) ids.add(id);
+		return ids;
+	});
+}
+function collectDevStartNodes(server, file) {
+	return withRealpathScope(() => {
+		const nodes = new Set(server.moduleGraph.getModulesByFile(file) ?? []);
+		for (const [id, node] of server.moduleGraph.idToModuleMap ?? []) if (moduleIdMatchesFile(id, file)) nodes.add(node);
+		return nodes;
+	});
+}
+//#endregion
+//#region src/utils/regexp.ts
+const CSS_LANGS_RE = /\.(wxss|css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+function isCSSRequest(request) {
+	return CSS_LANGS_RE.test(request);
+}
+function isRegexp(value) {
+	return Object.prototype.toString.call(value) === "[object RegExp]";
+}
+//#endregion
+//#region src/runtime/autoRoutesPlugin/matcher.ts
+const DEFAULT_AUTO_ROUTE_INCLUDE = ["pages/**"];
+const GLOB_MAGIC_PATTERN = /[*?[\]{}()!]/;
+const RELATIVE_PREFIX_PATTERN = /^\.?\//;
+const LEADING_SLASH_PATTERN = /^\/+/;
+function toArray(include) {
+	if (include == null) return [...DEFAULT_AUTO_ROUTE_INCLUDE];
+	return Array.isArray(include) ? [...include] : [include];
+}
+function normalizeRuleCandidate(candidate) {
+	return toPosixPath(candidate.replace(RELATIVE_PREFIX_PATTERN, "").replace(LEADING_SLASH_PATTERN, ""));
+}
+function createRule(pattern) {
+	if (pattern instanceof RegExp) return {
+		pattern,
+		match(candidate) {
+			pattern.lastIndex = 0;
+			return pattern.test(candidate);
+		}
+	};
+	return {
+		pattern,
+		match: picomatch(pattern, { dot: true })
+	};
+}
+function isDefaultAutoRouteInclude(include) {
+	return include.length === DEFAULT_AUTO_ROUTE_INCLUDE.length && include.every((pattern, index) => pattern === DEFAULT_AUTO_ROUTE_INCLUDE[index]);
+}
+function extractStaticPrefix(pattern) {
+	const normalized = normalizeRuleCandidate(pattern);
+	if (!normalized) return;
+	const segments = normalized.split("/");
+	const staticSegments = [];
+	for (const segment of segments) {
+		if (!segment || GLOB_MAGIC_PATTERN.test(segment)) break;
+		staticSegments.push(segment);
+	}
+	if (staticSegments.length === 0) return;
+	return staticSegments.join("/");
+}
+function createAutoRoutesMatcher(include, subPackageRoots = []) {
+	const normalizedInclude = toArray(include);
+	const rules = normalizedInclude.map(createRule);
+	const isDefault = isDefaultAutoRouteInclude(normalizedInclude);
+	const normalizedSubPackageRoots = [...subPackageRoots].filter(Boolean).map((root) => normalizeRuleCandidate(root)).filter(Boolean);
+	function matches(candidate) {
+		const normalizedCandidate = normalizeRuleCandidate(candidate);
+		if (!normalizedCandidate) return false;
+		if (isDefault) {
+			if (normalizedCandidate.startsWith("pages/")) return true;
+			return normalizedSubPackageRoots.some((root) => {
+				return normalizedCandidate.startsWith(`${root}/`);
+			});
+		}
+		return rules.some((rule) => rule.match(normalizedCandidate));
+	}
+	function getRoots(absoluteSrcRoot) {
+		if (isDefault) {
+			const roots = /* @__PURE__ */ new Set([path.join(absoluteSrcRoot, "pages")]);
+			for (const root of normalizedSubPackageRoots) roots.add(path.join(absoluteSrcRoot, root));
+			return Array.from(roots, (root) => normalizePath$1(root));
+		}
+		const roots = /* @__PURE__ */ new Set();
+		for (const rule of rules) {
+			if (rule.pattern instanceof RegExp) {
+				roots.add(absoluteSrcRoot);
+				continue;
+			}
+			const prefix = extractStaticPrefix(rule.pattern);
+			if (!prefix) {
+				roots.add(absoluteSrcRoot);
+				continue;
+			}
+			roots.add(path.resolve(absoluteSrcRoot, prefix));
+		}
+		if (roots.size === 0) roots.add(absoluteSrcRoot);
+		return Array.from(roots, (root) => normalizePath$1(root));
+	}
+	return {
+		include: normalizedInclude,
+		isDefault,
+		matches,
+		matchesRelativePath(relativePath) {
+			return matches(relativePath);
+		},
+		getSearchRoots(absoluteSrcRoot) {
+			return getRoots(absoluteSrcRoot);
+		},
+		getWatchRoots(absoluteSrcRoot) {
+			return getRoots(absoluteSrcRoot);
+		}
+	};
+}
+//#endregion
+//#region src/autoRoutesConfig.ts
+function resolveWeappAutoRoutesConfig(config) {
+	if (config == null || config === false) return {
+		enabled: false,
+		typedRouter: false,
+		include: [...DEFAULT_AUTO_ROUTE_INCLUDE],
+		persistentCache: false,
+		watch: false
+	};
+	const record = typeof config === "object" && config ? config : {};
+	return {
+		enabled: config === true || record.enabled !== false,
+		typedRouter: record.typedRouter !== false,
+		include: record.include == null ? [...DEFAULT_AUTO_ROUTE_INCLUDE] : Array.isArray(record.include) ? [...record.include] : [record.include],
+		...record.extensions?.length ? { extensions: [...new Set(record.extensions.map((extension) => extension.replace(/^\./, "")))] } : {},
+		persistentCache: typeof record.persistentCache === "string" || record.persistentCache === true,
+		persistentCachePath: typeof record.persistentCache === "string" ? record.persistentCache : void 0,
+		watch: record.watch !== false
+	};
+}
+//#endregion
+//#region src/runtime/autoRoutesPlugin/generatedPaths.ts
+const AUTO_ROUTES_CACHE_FILE = ".weapp-vite/auto-routes.cache.json";
+const TYPED_ROUTER_OUTPUT_FILE = ".weapp-vite/typed-router.d.ts";
+const GENERATED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+	".cache",
+	".rolldown-require",
+	".rolldown-require-cache",
+	".tmp",
+	".weapp-vite",
+	".wevu-config",
+	"__temp__",
+	"coverage",
+	"dist",
+	"miniprogram_npm",
+	"node_modules"
+]);
+const GENERATED_FILE_NAMES = /* @__PURE__ */ new Set([path.basename(AUTO_ROUTES_CACHE_FILE), path.basename(TYPED_ROUTER_OUTPUT_FILE)]);
+function stripQuery(candidate) {
+	return candidate.split("?")[0];
+}
+function resolveGeneratedCandidatePath(candidate, cwd) {
+	const pathWithoutQuery = stripQuery(candidate);
+	if (!pathWithoutQuery) return;
+	return normalizePath$1(path.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path.resolve(cwd, pathWithoutQuery));
+}
+function isAutoRoutesGeneratedDirectoryName(name) {
+	return GENERATED_DIRECTORY_NAMES.has(name);
+}
+function isAutoRoutesGeneratedFileName(fileName) {
+	return GENERATED_FILE_NAMES.has(fileName) || fileName.includes(".auto-routes.") || fileName.includes(".auto-routes-");
+}
+function isAutoRoutesGeneratedRelativePath(relativePath) {
+	const segments = toPosixPath(relativePath).split("/").filter(Boolean);
+	if (segments.some(isAutoRoutesGeneratedDirectoryName)) return true;
+	const fileName = segments[segments.length - 1];
+	return Boolean(fileName && isAutoRoutesGeneratedFileName(fileName));
+}
+function resolveAutoRoutesManagedOutputPaths(ctx) {
+	const configService = ctx.configService;
+	const outputPaths = /* @__PURE__ */ new Set();
+	if (!configService) return outputPaths;
+	const baseDir = typeof configService.configFilePath === "string" ? path.dirname(configService.configFilePath) : configService.cwd;
+	if (!baseDir) return outputPaths;
+	outputPaths.add(normalizePath$1(path.resolve(baseDir, TYPED_ROUTER_OUTPUT_FILE)));
+	outputPaths.add(normalizePath$1(path.resolve(baseDir, AUTO_ROUTES_CACHE_FILE)));
+	const autoRoutesConfig = resolveWeappAutoRoutesConfig(configService.weappViteConfig?.autoRoutes);
+	if (autoRoutesConfig.persistentCache) outputPaths.add(normalizePath$1(path.resolve(baseDir, autoRoutesConfig.persistentCachePath ?? AUTO_ROUTES_CACHE_FILE)));
+	return outputPaths;
+}
+function isAutoRoutesGeneratedPath(candidate, options) {
+	const absolutePath = resolveGeneratedCandidatePath(candidate, options.cwd);
+	if (!absolutePath) return false;
+	for (const outputPath of options.managedOutputPaths ?? []) if (absolutePath === normalizePath$1(outputPath)) return true;
+	const normalizedSrcRoot = normalizePath$1(options.absoluteSrcRoot);
+	const relativePath = toPosixPath(path.relative(normalizedSrcRoot, absolutePath));
+	if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) return false;
+	return isAutoRoutesGeneratedRelativePath(relativePath);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 256
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+	/**
+	* Directories discovered but not yet emitted from. Listings are read
+	* lazily (on pop, plus one prefetch) instead of eagerly on discovery:
+	* keeping whole listings for every queued dir balloons RAM on wide trees.
+	*/
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	_relStart;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark ?? defaultOptions.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const root = opts.root ?? defaultOptions.root;
+		const type = opts.type ?? defaultOptions.type;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = DIR_TYPES.has(type);
+		this._wantsFile = FILE_TYPES.has(type);
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._relStart = this._root.endsWith(sep) ? this._root.length : this._root.length + 1;
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		const rootDir = {
+			path: this._root,
+			depth: 1
+		};
+		rootDir.pending = this._exploreDir(this._root, 1);
+		this.parents = [rootDir];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+					const awaited = this._isDirent ? slice : await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						let entryType = this._getEntryType(entry);
+						if (typeof entryType !== "string") entryType = await entryType;
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push({
+								path: entry.fullPath,
+								depth: depth + 1
+							});
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					const dir = parent.pending ?? this._exploreDir(parent.path, parent.depth);
+					const next = this.parents[this.parents.length - 1];
+					if (next && !next.pending) next.pending = this._exploreDir(next.path, next.depth);
+					this.parent = await dir;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	_formatEntry(dirent, path) {
+		const basename = this._isDirent ? dirent.name : dirent;
+		const fullPath = join(path, basename);
+		const entry = {
+			path: fullPath.slice(this._relStart),
+			fullPath,
+			basename
+		};
+		if (this._isDirent) {
+			entry.dirent = dirent;
+			return entry;
+		}
+		return this._stat(fullPath).then((stats) => {
+			entry.stats = stats;
+			return entry;
+		}, (err) => {
+			this._onError(err);
+		});
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	_getEntryType(entry) {
+		if (!entry || !(this._statsProp in entry)) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats.isSymbolicLink()) return this._getSymlinkEntryType(entry);
+		return "";
+	}
+	async _getSymlinkEntryType(entry) {
+		const full = entry.fullPath;
+		try {
+			const entryRealPath = await realpath(full);
+			const entryRealPathStats = await lstat(entryRealPath);
+			if (entryRealPathStats.isFile()) return "file";
+			if (entryRealPathStats.isDirectory()) {
+				const len = entryRealPath.length;
+				if (full.startsWith(entryRealPath) && full[len] === sep) {
+					const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+					recursiveError.code = RECURSIVE_ERROR_CODE;
+					this._onError(recursiveError);
+					return "";
+				}
+				return "directory";
+			}
+		} catch (error) {
+			this._onError(error);
+		}
+		return "";
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	const opts = {
+		...options,
+		root
+	};
+	if (type) opts.type = type;
+	return new ReaddirpStream(opts);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@5.0.0_patch_hash=fafb20ce736d8edb3357d9d04cebccbd6e05ecc1bc10aa26a7484d2369016811/node_modules/chokidar/handler.js
+const STR_DATA = "data";
+const STR_CLOSE = "close";
+const EMPTY_FN = () => {};
+const pl = process.platform;
+const isWindows = pl === "win32";
+const isMacos = pl === "darwin";
+const isLinux = pl === "linux";
+const isFreeBSD = pl === "freebsd";
+const isIBMi = type() === "OS400";
+const EVENTS = {
+	ALL: "all",
+	READY: "ready",
+	ADD: "add",
+	CHANGE: "change",
+	ADD_DIR: "addDir",
+	UNLINK: "unlink",
+	UNLINK_DIR: "unlinkDir",
+	RAW: "raw",
+	ERROR: "error"
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = "watch";
+const clearPreviousRemoveThrottle = (fsw, path, throttler) => {
+	if (!throttler) return;
+	if (fsw._throttled.get("remove")?.get(path) === throttler) throttler.clear();
+	else clearTimeout(throttler.timeoutObject);
+};
+const statMethods = {
+	lstat,
+	stat: stat$1
+};
+const KEY_LISTENERS = "listeners";
+const KEY_ERR = "errHandlers";
+const KEY_RAW = "rawEmitters";
+const HANDLER_KEYS = [
+	KEY_LISTENERS,
+	KEY_ERR,
+	KEY_RAW
+];
+const binaryExtensions = /* @__PURE__ */ new Set([
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+const foreach = (val, fn) => {
+	if (val instanceof Set) val.forEach(fn);
+	else fn(val);
+};
+const addAndConvert = (main, prop, item) => {
+	let container = main[prop];
+	if (!(container instanceof Set)) main[prop] = container = /* @__PURE__ */ new Set([container]);
+	container.add(item);
+};
+const clearItem = (cont) => (key) => {
+	const set = cont[key];
+	if (set instanceof Set) set.clear();
+	else delete cont[key];
+};
+const delFromSet = (main, prop, item) => {
+	const container = main[prop];
+	if (container instanceof Set) container.delete(item);
+	else if (container === item) delete main[prop];
+};
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+const FsWatchInstances = /* @__PURE__ */ new Map();
+const NATIVE_SUBSCRIPTION = Symbol();
+const sameInode = (binding, stats) => binding && stats && binding.dev !== void 0 && binding.ino !== void 0 && binding.dev === stats.dev && binding.ino === stats.ino;
+/**
+* Instantiates the fs_watch interface
+* @param path to be watched
+* @param options to be passed to fs_watch
+* @param listener main event handler
+* @param errHandler emits info about errors
+* @param emitRaw emits raw event data
+* @returns {NativeFsWatcher}
+*/
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw, isActive = () => true) {
+	const handleEvent = (rawEvent, evPath) => {
+		if (!isActive()) return;
+		listener(path);
+		if (!isActive()) return;
+		emitRaw(rawEvent, evPath, { watchedPath: path });
+		if (!isActive()) return;
+		if (evPath && path !== evPath) fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
+	};
+	try {
+		return watch(path, { persistent: options.persistent }, handleEvent);
+	} catch (error) {
+		errHandler(error);
+		return;
+	}
+}
+/**
+* Helper for passing fs_watch event data to a collection of listeners
+* @param fullPath absolute path bound to fs_watch instance
+*/
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3, expectedBinding) => {
+	const cont = FsWatchInstances.get(fullPath);
+	if (!cont) return;
+	const isCurrent = () => FsWatchInstances.get(fullPath) === cont && (!expectedBinding || cont.binding === expectedBinding && !expectedBinding.closed);
+	foreach(cont[listenerType], (listener) => {
+		if (isCurrent()) listener(val1, val2, val3);
+	});
+};
+/** 为同一个共享容器取得下一代原生句柄，发布前的回调保持失活。 */
+const createPersistentBinding = (path, fullPath, options, cont, acquireErrorHandler, stats) => {
+	const binding = {
+		watcher: void 0,
+		generation: (cont.binding?.generation || 0) + 1,
+		dev: stats?.dev,
+		ino: stats?.ino,
+		closed: false,
+		close: EMPTY_FN
+	};
+	const isCurrent = () => FsWatchInstances.get(fullPath) === cont && cont.binding === binding && !binding.closed;
+	const broadcastError = (error) => fsWatchBroadcast(fullPath, KEY_ERR, error, void 0, void 0, binding);
+	const watcher = createFsWatchInstance(path, options, (changedPath) => fsWatchBroadcast(fullPath, KEY_LISTENERS, changedPath, void 0, void 0, binding), acquireErrorHandler, (event, eventPath, details) => fsWatchBroadcast(fullPath, KEY_RAW, event, eventPath, details, binding), isCurrent);
+	if (!watcher) return;
+	binding.watcher = watcher;
+	binding.close = () => {
+		if (binding.closed) return;
+		binding.closed = true;
+		watcher.close();
+	};
+	watcher.on(EV.ERROR, async (error) => {
+		if (!isCurrent()) return;
+		cont.watcherUnusable = true;
+		if (isWindows && error.code === "EPERM") try {
+			await (await open(path, "r")).close();
+			if (isCurrent()) broadcastError(error);
+		} catch (err) {}
+		else broadcastError(error);
+	});
+	return binding;
+};
+/**
+* Instantiates the fs_watch interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path
+* @param fullPath absolute path
+* @param options to be passed to fs_watch
+* @param handlers container for event listener functions
+*/
+const setFsWatchListener = (path, fullPath, options, handlers, registrationErrorHandler) => {
+	const { listener, errHandler, rawEmitter } = handlers;
+	const acquireErrorHandler = registrationErrorHandler || errHandler;
+	let cont = FsWatchInstances.get(fullPath);
+	if (!options.persistent) {
+		let active = true;
+		const watcher = createFsWatchInstance(path, options, listener, acquireErrorHandler, rawEmitter, () => active);
+		if (!watcher) return;
+		return () => {
+			if (!active) return;
+			active = false;
+			watcher.close();
+		};
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_ERR, errHandler);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		cont = {
+			listeners: /* @__PURE__ */ new Set([listener]),
+			errHandlers: /* @__PURE__ */ new Set([errHandler]),
+			rawEmitters: /* @__PURE__ */ new Set([rawEmitter]),
+			watcher: void 0,
+			binding: void 0
+		};
+		const binding = createPersistentBinding(path, fullPath, options, cont, acquireErrorHandler, options.stats);
+		if (!binding) return;
+		cont.binding = binding;
+		cont.watcher = binding.watcher;
+		FsWatchInstances.set(fullPath, cont);
+	}
+	let active = true;
+	const close = () => {
+		if (!active) return;
+		active = false;
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_ERR, errHandler);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			const binding = cont.binding;
+			cont.binding = void 0;
+			if (FsWatchInstances.get(fullPath) === cont) FsWatchInstances.delete(fullPath);
+			binding?.close();
+			HANDLER_KEYS.forEach(clearItem(cont));
+			cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+	const isOwned = () => active && FsWatchInstances.get(fullPath) === cont && cont.binding !== void 0;
+	close[NATIVE_SUBSCRIPTION] = {
+		snapshot: () => isOwned() ? cont.binding : void 0,
+		accepts: (observed, stats) => isOwned() && (cont.binding === observed || sameInode(cont.binding, stats)),
+		rebind: (stats) => {
+			if (!isOwned()) return false;
+			const previous = cont.binding;
+			if (sameInode(previous, stats)) return true;
+			let failed = false;
+			let failure;
+			const replacement = createPersistentBinding(path, fullPath, options, cont, (error) => {
+				failed = true;
+				failure = error;
+			}, stats);
+			if (failed) throw failure;
+			if (!replacement) return false;
+			if (FsWatchInstances.get(fullPath) !== cont || cont.binding !== previous || isEmptySet(cont.listeners)) {
+				replacement.close();
+				return false;
+			}
+			cont.binding = replacement;
+			cont.watcher = replacement.watcher;
+			cont.watcherUnusable = false;
+			previous.close();
+			return true;
+		}
+	};
+	return close;
+};
+const FsWatchFileInstances = /* @__PURE__ */ new Map();
+const createFsWatchFileBinding = (path, fullPath, options, cont) => {
+	const binding = {
+		closed: false,
+		watcher: void 0,
+		close: EMPTY_FN
+	};
+	const listener = (curr, prev) => {
+		if (binding.closed || FsWatchFileInstances.get(fullPath) !== cont || cont.binding !== binding) return;
+		const rawEmitters = [...cont.rawEmitters];
+		const listeners = [...cont.listeners];
+		rawEmitters.forEach((rawEmitter) => {
+			if (FsWatchFileInstances.get(fullPath) === cont && cont.rawEmitters.has(rawEmitter)) rawEmitter(EV.CHANGE, fullPath, {
+				curr,
+				prev
+			});
+		});
+		const currmtime = curr.mtimeMs;
+		if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) listeners.forEach((listener) => {
+			if (FsWatchFileInstances.get(fullPath) === cont && cont.listeners.has(listener)) listener(path, curr);
+		});
+	};
+	binding.watcher = watchFile(fullPath, options, listener);
+	binding.close = () => {
+		if (binding.closed) return;
+		binding.closed = true;
+		unwatchFile(fullPath, listener);
+	};
+	return binding;
+};
+/**
+* Instantiates the fs_watchFile interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path to be watched
+* @param fullPath absolute path
+* @param options options to be passed to fs_watchFile
+* @param handlers container for event listener functions
+* @returns closer
+*/
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	const { listener, rawEmitter } = handlers;
+	let cont = FsWatchFileInstances.get(fullPath);
+	const copts = cont && cont.options;
+	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+		const merged = {
+			...options,
+			persistent: copts.persistent || options.persistent,
+			interval: Math.min(copts.interval, options.interval)
+		};
+		cont.binding.close();
+		try {
+			cont.binding = createFsWatchFileBinding(path, fullPath, merged, cont);
+		} catch (error) {
+			try {
+				cont.binding = createFsWatchFileBinding(path, fullPath, copts, cont);
+				cont.watcher = cont.binding.watcher;
+			} catch (restoreError) {
+				throw new AggregateError([error, restoreError], "polling watcher 升级与恢复均失败");
+			}
+			throw error;
+		}
+		cont.watcher = cont.binding.watcher;
+		cont.options = merged;
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		cont = {
+			listeners: /* @__PURE__ */ new Set([listener]),
+			rawEmitters: /* @__PURE__ */ new Set([rawEmitter]),
+			options,
+			watcher: void 0,
+			binding: void 0
+		};
+		cont.binding = createFsWatchFileBinding(path, fullPath, options, cont);
+		cont.watcher = cont.binding.watcher;
+		FsWatchFileInstances.set(fullPath, cont);
+	}
+	let active = true;
+	return () => {
+		if (!active) return;
+		active = false;
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			if (FsWatchFileInstances.get(fullPath) === cont) FsWatchFileInstances.delete(fullPath);
+			cont.binding.close();
+			cont.binding = void 0;
+			cont.options = cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+/**
+* @mixin
+*/
+var NodeFsHandler = class {
+	fsw;
+	_boundHandleError;
+	constructor(fsW) {
+		this.fsw = fsW;
+		this._boundHandleError = (error) => fsW._handleError(error);
+	}
+	/**
+	* Watch file for changes with fs_watchFile or fs_watch.
+	* @param path to file or dir
+	* @param listener on fs change
+	* @returns closer for the watcher instance
+	*/
+	_watchWithNodeFs(path, listener, throwRegistrationError = false, stats) {
+		const opts = this.fsw.options;
+		const directory = sp.dirname(path);
+		const basename = sp.basename(path);
+		if (!throwRegistrationError) this.fsw._getWatchedDir(directory).add(basename);
+		const absolutePath = sp.resolve(path);
+		const options = {
+			persistent: opts.persistent,
+			stats
+		};
+		if (!listener) listener = EMPTY_FN;
+		let closer;
+		if (opts.usePolling) {
+			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+			closer = setFsWatchFileListener(path, absolutePath, options, {
+				listener,
+				rawEmitter: this.fsw._emitRaw
+			});
+		} else {
+			let registrationFailed = false;
+			let registrationError;
+			const onRegistrationError = throwRegistrationError ? (error) => {
+				registrationFailed = true;
+				registrationError = error;
+			} : void 0;
+			closer = setFsWatchListener(path, absolutePath, options, {
+				listener,
+				errHandler: this._boundHandleError,
+				rawEmitter: this.fsw._emitRaw
+			}, onRegistrationError);
+			if (registrationFailed) throw registrationError;
+		}
+		return closer;
+	}
+	/**
+	* Watch a file and emit add event if warranted.
+	* @returns closer for the watcher instance
+	*/
+	_handleFile(file, stats, initialAdd) {
+		if (this.fsw.closed) return;
+		const dirname = sp.dirname(file);
+		const basename = sp.basename(file);
+		const parentPath = sp.resolve(dirname);
+		const parent = this.fsw._getWatchedDir(dirname);
+		let prevStats = stats;
+		if (parent.has(basename)) return;
+		const removePath = sp.join(dirname, basename);
+		const previousRemoveThrottle = this.fsw._throttled.get("remove")?.get(removePath);
+		let ownerActive = true;
+		let currentBinding;
+		const isCurrentBinding = (binding) => ownerActive && binding.active && currentBinding === binding && !this.fsw.closed && this.fsw._watched.get(parentPath) === parent && parent.has(basename);
+		const closeOwner = () => {
+			if (!ownerActive) return;
+			ownerActive = false;
+			const binding = currentBinding;
+			currentBinding = void 0;
+			if (binding) binding.close();
+		};
+		const subscribe = () => {
+			if (!ownerActive || this.fsw.closed) return;
+			const binding = {
+				active: false,
+				close: EMPTY_FN
+			};
+			let nativeControl;
+			const listener = async (path, newStats) => {
+				if (!isCurrentBinding(binding) || !this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+				const observedNative = nativeControl?.snapshot();
+				if (!newStats || newStats.mtimeMs === 0) {
+					let currentStats;
+					try {
+						currentStats = await stat$1(file);
+					} catch (error) {
+						if (isCurrentBinding(binding) && (!nativeControl || nativeControl.accepts(observedNative))) this.fsw._remove(dirname, basename);
+						return;
+					}
+					if (!isCurrentBinding(binding) || nativeControl && !nativeControl.accepts(observedNative, currentStats)) return;
+					const at = currentStats.atimeMs;
+					const mt = currentStats.mtimeMs;
+					if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, currentStats);
+					if (!isCurrentBinding(binding)) return;
+					if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== currentStats.ino) {
+						if (nativeControl) try {
+							if (!nativeControl.rebind(currentStats)) return;
+						} catch (error) {
+							if (isCurrentBinding(binding)) this._boundHandleError(error);
+							return;
+						}
+						else if (!this.fsw.options.usePolling) {
+							binding.close();
+							prevStats = currentStats;
+							subscribe();
+							return;
+						}
+					}
+					if (isCurrentBinding(binding)) prevStats = currentStats;
+				} else {
+					const at = newStats.atimeMs;
+					const mt = newStats.mtimeMs;
+					if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+					if (isCurrentBinding(binding)) prevStats = newStats;
+				}
+			};
+			const nativeCloser = this._watchWithNodeFs(file, listener, false, prevStats);
+			if (!nativeCloser) return;
+			nativeControl = nativeCloser[NATIVE_SUBSCRIPTION];
+			let closed = false;
+			binding.close = () => {
+				if (closed) return;
+				closed = true;
+				binding.active = false;
+				if (currentBinding === binding) currentBinding = void 0;
+				nativeCloser();
+			};
+			if (!ownerActive || this.fsw.closed || this.fsw._watched.get(parentPath) !== parent || !parent.has(basename)) {
+				binding.close();
+				return;
+			}
+			binding.active = true;
+			currentBinding = binding;
+			return binding;
+		};
+		const binding = subscribe();
+		if (binding && isCurrentBinding(binding)) clearPreviousRemoveThrottle(this.fsw, removePath, previousRemoveThrottle);
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+			if (this.fsw._throttle(EV.ADD, file, 0)) this.fsw._emit(EV.ADD, file, stats);
+		}
+		if (binding && !isCurrentBinding(binding)) {
+			closeOwner();
+			return;
+		}
+		return binding ? closeOwner : void 0;
+	}
+	/**
+	* Handle symlinks encountered while reading a dir.
+	* @param entry returned by readdirp
+	* @param directory path of dir being read
+	* @param path of this item
+	* @param item basename of this item
+	* @returns true if no more processing is needed for this entry.
+	*/
+	async _handleSymlink(entry, directory, path, item, isActive = () => true) {
+		if (this.fsw.closed) return;
+		const full = entry.fullPath;
+		const dir = this.fsw._getWatchedDir(directory);
+		if (!this.fsw.options.followSymlinks) {
+			this.fsw._incrReadyCount();
+			let linkPath;
+			try {
+				linkPath = await realpath(path);
+			} catch (e) {
+				this.fsw._emitReady();
+				return true;
+			}
+			if (this.fsw.closed) return;
+			if (!isActive()) {
+				this.fsw._emitReady();
+				return true;
+			}
+			if (dir.has(item)) {
+				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+					this.fsw._symlinkPaths.set(full, linkPath);
+					this.fsw._emit(EV.CHANGE, path, entry.stats);
+				}
+			} else {
+				dir.add(item);
+				this.fsw._symlinkPaths.set(full, linkPath);
+				this.fsw._emit(EV.ADD, path, entry.stats);
+			}
+			this.fsw._emitReady();
+			return true;
+		}
+		if (this.fsw._symlinkPaths.has(full)) return true;
+		this.fsw._symlinkPaths.set(full, true);
+	}
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler, isActive = () => true, registerRead) {
+		if (this.fsw.closed || !isActive()) return;
+		directory = sp.join(directory, "");
+		const throttleKey = target ? `${directory}:${target}` : directory;
+		throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+		if (!throttler) return;
+		let stream;
+		let finished = false;
+		let unregisterRead = EMPTY_FN;
+		let resolveRead;
+		const completion = new Promise((resolve) => {
+			resolveRead = resolve;
+		});
+		const finish = () => {
+			if (finished) return false;
+			finished = true;
+			const currentThrottle = this.fsw._throttled.get("readdir")?.get(throttleKey);
+			const wasThrottled = currentThrottle === throttler ? throttler.clear() : false;
+			if (currentThrottle !== throttler) clearTimeout(throttler.timeoutObject);
+			unregisterRead();
+			unregisterRead = EMPTY_FN;
+			stream = void 0;
+			resolveRead(void 0);
+			return wasThrottled;
+		};
+		const cancel = () => {
+			const ownedStream = stream;
+			finish();
+			if (ownedStream && !ownedStream.destroyed) ownedStream.destroy();
+		};
+		if (registerRead) {
+			unregisterRead = registerRead(cancel);
+			if (finished) {
+				unregisterRead();
+				return completion;
+			}
+		}
+		const previous = this.fsw._getWatchedDir(wh.path);
+		const current = /* @__PURE__ */ new Set();
+		let missingDirectory = false;
+		try {
+			stream = this.fsw._readdirp(directory, {
+				fileFilter: (entry) => wh.filterPath(entry),
+				directoryFilter: (entry) => wh.filterDir(entry)
+			});
+		} catch (error) {
+			finish();
+			throw error;
+		}
+		if (!stream) {
+			finish();
+			return completion;
+		}
+		stream.on(STR_DATA, async (entry) => {
+			if (this.fsw.closed || !isActive()) return;
+			const item = entry.path;
+			let path = sp.join(directory, item);
+			current.add(item);
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item, isActive)) return;
+			if (this.fsw.closed || !isActive()) return;
+			if (item === target || !target && !previous.has(item)) {
+				this.fsw._incrReadyCount();
+				path = sp.join(dir, sp.relative(dir, path));
+				this._addToNodeFs(path, initialAdd, wh, depth + 1, void 0, isActive);
+			}
+		}).on("warn", (error) => {
+			if (error?.code === "ENOENT" && typeof error.path === "string" && sp.resolve(error.path) === sp.resolve(directory)) missingDirectory = true;
+		}).on(EV.ERROR, this._boundHandleError).once(STR_CLOSE, finish).once("end", () => {
+			const wasThrottled = finish();
+			if (this.fsw.closed || !isActive()) return;
+			if (missingDirectory) {
+				this.fsw._remove(sp.dirname(directory), sp.basename(directory), true);
+				return;
+			}
+			previous.getChildren().filter((item) => {
+				return item !== directory && !current.has(item);
+			}).forEach((item) => {
+				if (!this.fsw.closed && isActive()) this.fsw._remove(directory, item);
+			});
+			if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler, isActive, registerRead);
+		});
+		return completion;
+	}
+	/**
+	* Read directory to add / remove files from `@watched` list and re-read it on change.
+	* @param dir fs path
+	* @param stats
+	* @param initialAdd
+	* @param depth relative to user-supplied path
+	* @param target child path targeted for watch
+	* @param wh Common watch helpers for this path
+	* @param realpath
+	* @returns 用于后续异步提交的当前目录归属检查。
+	*/
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath, registerCloser, isActive = () => true) {
+		const parentPath = sp.resolve(sp.dirname(dir));
+		const basename = sp.basename(dir);
+		const tracked = this.fsw._watched.get(parentPath)?.has(basename);
+		const removePath = sp.join(sp.dirname(dir), basename);
+		const previousRemoveThrottle = !tracked ? this.fsw._throttled.get("remove")?.get(removePath) : void 0;
+		const fullPath = sp.resolve(dir);
+		let directoryEntry;
+		let active = true;
+		const reads = /* @__PURE__ */ new Set();
+		const isCurrentDirectory = () => active && !this.fsw.closed && isActive() && directoryEntry !== void 0 && this.fsw._watched.get(fullPath) === directoryEntry;
+		const registerRead = (cancel) => {
+			if (!isCurrentDirectory()) {
+				cancel();
+				return EMPTY_FN;
+			}
+			reads.add(cancel);
+			return () => {
+				reads.delete(cancel);
+			};
+		};
+		let throttler;
+		const oDepth = this.fsw.options.depth;
+		const shouldWatch = (oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath);
+		if (shouldWatch) {
+			const closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+				if (!isCurrentDirectory() || stats && stats.mtimeMs === 0) return;
+				this._handleRead(dirPath, false, wh, target, dir, depth, throttler, isCurrentDirectory, registerRead);
+			}, true);
+			if (!closer) throw new Error("Directory watcher registration returned no closer");
+			registerCloser(() => {
+				if (!active) return;
+				active = false;
+				try {
+					for (const cancel of [...reads]) cancel();
+				} finally {
+					reads.clear();
+					closer();
+				}
+			});
+		}
+		this.fsw._getWatchedDir(parentPath).add(basename);
+		directoryEntry = this.fsw._getWatchedDir(dir);
+		if (shouldWatch && !tracked && isCurrentDirectory()) clearPreviousRemoveThrottle(this.fsw, removePath, previousRemoveThrottle);
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
+		if (shouldWatch && !target && isCurrentDirectory()) await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler, isCurrentDirectory, registerRead);
+		return isCurrentDirectory;
+	}
+	/**
+	* Handle added file, directory, or glob pattern.
+	* Delegates call to _handleFile / _handleDir after checks.
+	* @param path to file or ir
+	* @param initialAdd was the file added at watch instantiation?
+	* @param priorWh depth relative to user-supplied path
+	* @param depth Child path actually targeted for watch
+	* @param target Child path actually targeted for watch
+	*/
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target, isActive = () => true) {
+		const ready = this.fsw._emitReady;
+		const completeMissing = () => {
+			if (priorWh) {
+				ready();
+				return false;
+			}
+			return path;
+		};
+		if (this.fsw._isIgnored(path) || this.fsw.closed || !isActive()) {
+			ready();
+			return false;
+		}
+		const wh = this.fsw._getWatchHelpers(path);
+		if (priorWh) {
+			wh.filterPath = (entry) => priorWh.filterPath(entry);
+			wh.filterDir = (entry) => priorWh.filterDir(entry);
+		}
+		let directoryWatchPath;
+		const registerCloser = (closer) => this.fsw._addPathCloser(path, closer);
+		try {
+			const stats = await statMethods[wh.statMethod](wh.watchPath);
+			if (this.fsw.closed) return;
+			if (!isActive() || this.fsw._isIgnored(wh.watchPath, stats)) {
+				ready();
+				return false;
+			}
+			const follow = this.fsw.options.followSymlinks;
+			let closer;
+			if (stats.isDirectory()) {
+				const absPath = sp.resolve(path);
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				if (!isActive()) {
+					ready();
+					return false;
+				}
+				directoryWatchPath = wh.watchPath;
+				const isCurrentDirectory = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath, registerCloser, isActive);
+				if (this.fsw.closed) return;
+				if (!isCurrentDirectory()) {
+					ready();
+					return false;
+				}
+				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
+			} else if (stats.isSymbolicLink()) {
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				if (!isActive()) {
+					ready();
+					return false;
+				}
+				const parent = sp.dirname(wh.watchPath);
+				directoryWatchPath = parent;
+				const isCurrentDirectory = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath, registerCloser, isActive);
+				if (this.fsw.closed) return;
+				if (!isCurrentDirectory()) {
+					ready();
+					return false;
+				}
+				this.fsw._getWatchedDir(parent).add(wh.watchPath);
+				this.fsw._emit(EV.ADD, wh.watchPath, stats);
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
+			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+			ready();
+			if (closer) this.fsw._addPathCloser(path, closer);
+			return false;
+		} catch (error) {
+			if (this.fsw.closed) return;
+			if (!isActive()) {
+				ready();
+				return false;
+			}
+			if (isWindows && !this.fsw.options.usePolling && directoryWatchPath !== void 0 && error?.code === "EPERM" && error.syscall === "watch" && typeof error.path === "string" && sp.resolve(error.path) === sp.resolve(directoryWatchPath)) {
+				let missing = false;
+				try {
+					await lstat(directoryWatchPath);
+				} catch (probeError) {
+					missing = probeError?.code === "ENOENT" || probeError?.code === "ENOTDIR";
+				}
+				if (this.fsw.closed) return;
+				if (!isActive()) {
+					ready();
+					return false;
+				}
+				if (missing) return completeMissing();
+			}
+			if (this.fsw._handleError(error)) return completeMissing();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@5.0.0_patch_hash=fafb20ce736d8edb3357d9d04cebccbd6e05ecc1bc10aa26a7484d2369016811/node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const SLASH = "/";
+const SLASH_SLASH = "//";
+const ONE_DOT = ".";
+const TWO_DOTS = "..";
+const STRING_TYPE = "string";
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//g;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+	return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+	if (typeof matcher === "function") return matcher;
+	if (typeof matcher === "string") return (string) => matcher === string;
+	if (matcher instanceof RegExp) return (string) => matcher.test(string);
+	if (typeof matcher === "object" && matcher !== null) return (string) => {
+		if (matcher.path === string) return true;
+		if (matcher.recursive) {
+			const relative = sp.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sp.isAbsolute(relative);
+		}
+		return false;
+	};
+	return () => false;
+}
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sp.normalize(path);
+	path = path.replace(/\\/g, "/");
+	let prepend = false;
+	if (path.startsWith("//")) prepend = true;
+	path = path.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path = "/" + path;
+	return path;
+}
+function matchPatterns(patterns, testString, stats) {
+	const path = normalizePath(testString);
+	for (let index = 0; index < patterns.length; index++) {
+		const pattern = patterns[index];
+		if (pattern(path, stats)) return true;
+	}
+	return false;
+}
+function anymatch(matchers, testString) {
+	if (matchers == null) throw new TypeError("anymatch: specify first argument");
+	const patterns = arrify(matchers).map((matcher) => createPattern(matcher));
+	if (testString == null) return (testString, stats) => {
+		return matchPatterns(patterns, testString, stats);
+	};
+	return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+	const paths = arrify(paths_).flat();
+	if (!paths.every((p) => typeof p === STRING_TYPE)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	return paths.map(normalizePathToUnix);
+};
+const toUnix = (string) => {
+	let str = string.replace(BACK_SLASH_RE, SLASH);
+	let prepend = false;
+	if (str.startsWith(SLASH_SLASH)) prepend = true;
+	str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	if (prepend) str = SLASH + str;
+	return str;
+};
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
+	else return path;
+};
+const getAbsolutePath = (path, cwd) => {
+	if (sp.isAbsolute(path)) return path;
+	return sp.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+/**
+* Directory entry.
+*/
+var DirEntry = class {
+	path;
+	_removeWatcher;
+	items;
+	constructor(dir, removeWatcher) {
+		this.path = dir;
+		this._removeWatcher = removeWatcher;
+		this.items = /* @__PURE__ */ new Set();
+	}
+	add(item) {
+		const { items } = this;
+		if (!items) return;
+		if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	}
+	async remove(item) {
+		const { items } = this;
+		if (!items) return;
+		items.delete(item);
+		if (items.size > 0) return;
+		const dir = this.path;
+		try {
+			await readdir(dir);
+		} catch (err) {
+			if (this._removeWatcher) this._removeWatcher(sp.dirname(dir), sp.basename(dir));
+		}
+	}
+	has(item) {
+		const { items } = this;
+		if (!items) return;
+		return items.has(item);
+	}
+	getChildren() {
+		const { items } = this;
+		if (!items) return [];
+		return [...items.values()];
+	}
+	dispose() {
+		this.items.clear();
+		this.path = "";
+		this._removeWatcher = EMPTY_FN;
+		this.items = EMPTY_SET;
+		Object.freeze(this);
+	}
+};
+const STAT_METHOD_F = "stat";
+const STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path, follow, fsw) {
+		this.fsw = fsw;
+		const watchPath = path;
+		this.path = path = path.replace(REPLACER_RE, "");
+		this.watchPath = watchPath;
+		this.fullWatchPath = sp.resolve(watchPath);
+		this.dirParts = [];
+		this.dirParts.forEach((parts) => {
+			if (parts.length > 1) parts.pop();
+		});
+		this.followSymlinks = follow;
+		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	}
+	entryPath(entry) {
+		return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
+	}
+	filterPath(entry) {
+		const { stats } = entry;
+		if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+		const resolvedPath = this.entryPath(entry);
+		return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+	}
+	filterDir(entry) {
+		return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	}
+};
+/**
+* Watches files & directories for changes. Emitted events:
+* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+*
+*     new FSWatcher()
+*       .add(directories)
+*       .on('add', path => log('File', path, 'was added'))
+*/
+var FSWatcher = class extends EventEmitter {
+	closed;
+	options;
+	_closers;
+	_ignoredPaths;
+	_throttled;
+	_streams;
+	_symlinkPaths;
+	_watched;
+	_pendingWrites;
+	_pendingUnlinks;
+	_readyCount;
+	_emitReady;
+	_closePromise;
+	_userIgnored;
+	_readyEmitted;
+	_emitRaw;
+	_boundRemove;
+	_nodeFsHandler;
+	constructor(_opts = {}) {
+		super();
+		this.closed = false;
+		this._closers = /* @__PURE__ */ new Map();
+		this._ignoredPaths = /* @__PURE__ */ new Set();
+		this._throttled = /* @__PURE__ */ new Map();
+		this._streams = /* @__PURE__ */ new Set();
+		this._symlinkPaths = /* @__PURE__ */ new Map();
+		this._watched = /* @__PURE__ */ new Map();
+		this._pendingWrites = /* @__PURE__ */ new Map();
+		this._pendingUnlinks = /* @__PURE__ */ new Map();
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		const awf = _opts.awaitWriteFinish;
+		const DEF_AWF = {
+			stabilityThreshold: 2e3,
+			pollInterval: 100
+		};
+		const opts = {
+			persistent: true,
+			ignoreInitial: false,
+			ignorePermissionErrors: false,
+			interval: 100,
+			binaryInterval: 300,
+			followSymlinks: true,
+			usePolling: false,
+			atomic: true,
+			..._opts,
+			ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+			awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
+				...DEF_AWF,
+				...awf
+			} : false
+		};
+		if (isIBMi) opts.usePolling = true;
+		if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
+		const envPoll = process.env.CHOKIDAR_USEPOLLING;
+		if (envPoll !== void 0) {
+			const envLower = envPoll.toLowerCase();
+			if (envLower === "false" || envLower === "0") opts.usePolling = false;
+			else if (envLower === "true" || envLower === "1") opts.usePolling = true;
+			else opts.usePolling = !!envLower;
+		}
+		const envInterval = process.env.CHOKIDAR_INTERVAL;
+		if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+		let readyCalls = 0;
+		this._emitReady = () => {
+			readyCalls++;
+			if (readyCalls >= this._readyCount) {
+				this._emitReady = EMPTY_FN;
+				this._readyEmitted = true;
+				process.nextTick(() => this.emit(EVENTS.READY));
+			}
+		};
+		this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+		this._boundRemove = this._remove.bind(this);
+		this.options = opts;
+		this._nodeFsHandler = new NodeFsHandler(this);
+		Object.freeze(opts);
+	}
+	_addIgnoredPath(matcher) {
+		if (isMatcherObject(matcher)) {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
+		}
+		this._ignoredPaths.add(matcher);
+	}
+	_removeIgnoredPath(matcher) {
+		this._ignoredPaths.delete(matcher);
+		if (typeof matcher === "string") {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher) this._ignoredPaths.delete(ignored);
+		}
+	}
+	/**
+	* Adds paths to be watched on an existing FSWatcher instance.
+	* @param paths_ file or file list. Other arguments are unused
+	*/
+	add(paths_, _origAdd, _internal) {
+		const { cwd } = this.options;
+		this.closed = false;
+		this._closePromise = void 0;
+		let paths = unifyPaths(paths_);
+		if (cwd) paths = paths.map((path) => {
+			return getAbsolutePath(path, cwd);
+		});
+		paths.forEach((path) => {
+			this._removeIgnoredPath(path);
+		});
+		this._userIgnored = void 0;
+		if (!this._readyCount) this._readyCount = 0;
+		this._readyCount += paths.length;
+		Promise.all(paths.map(async (path) => {
+			return this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+		})).then((results) => {
+			if (this.closed) return;
+			results.forEach((item) => {
+				if (item) {
+					this.add(sp.dirname(item), sp.basename(_origAdd || item));
+					this._emitReady();
+				}
+			});
+		});
+		return this;
+	}
+	/**
+	* Close watchers or start ignoring events from specified paths.
+	*/
+	unwatch(paths_) {
+		if (this.closed) return this;
+		const paths = unifyPaths(paths_);
+		const { cwd } = this.options;
+		paths.forEach((path) => {
+			if (!sp.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sp.join(cwd, path);
+				path = sp.resolve(path);
+			}
+			this._closePath(path);
+			this._addIgnoredPath(path);
+			if (this._watched.has(path)) this._addIgnoredPath({
+				path,
+				recursive: true
+			});
+			this._userIgnored = void 0;
+		});
+		return this;
+	}
+	/**
+	* Close watchers and remove all listeners from watched paths.
+	*/
+	close() {
+		if (this._closePromise) return this._closePromise;
+		this.closed = true;
+		this.removeAllListeners();
+		const closers = [];
+		this._closers.forEach((closerList) => closerList.forEach((closer) => {
+			const promise = closer();
+			if (promise instanceof Promise) closers.push(promise);
+		}));
+		this._streams.forEach((stream) => stream.destroy());
+		this._userIgnored = void 0;
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		this._watched.forEach((dirent) => dirent.dispose());
+		this._closers.clear();
+		this._watched.clear();
+		this._streams.clear();
+		this._symlinkPaths.clear();
+		this._throttled.clear();
+		this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+		return this._closePromise;
+	}
+	/**
+	* Expose list of watched paths
+	* @returns for chaining
+	*/
+	getWatched() {
+		const watchList = {};
+		this._watched.forEach((entry, dir) => {
+			const index = (this.options.cwd ? sp.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			watchList[index] = entry.getChildren().sort();
+		});
+		return watchList;
+	}
+	emitWithAll(event, args) {
+		this.emit(event, ...args);
+		if (event !== EVENTS.ERROR) this.emit(EVENTS.ALL, event, ...args);
+	}
+	/**
+	* Normalize and emit events.
+	* Calling _emit DOES NOT MEAN emit() would be called!
+	* @param event Type of event
+	* @param path File or directory path
+	* @param stats arguments to be passed with event
+	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	async _emit(event, path, stats) {
+		if (this.closed) return;
+		const opts = this.options;
+		if (isWindows) path = sp.normalize(path);
+		if (opts.cwd) path = sp.relative(opts.cwd, path);
+		const args = [path];
+		if (stats != null) args.push(stats);
+		const awf = opts.awaitWriteFinish;
+		let pw;
+		if (awf && (pw = this._pendingWrites.get(path))) {
+			pw.lastChange = /* @__PURE__ */ new Date();
+			return this;
+		}
+		if (opts.atomic) {
+			if (event === EVENTS.UNLINK) {
+				this._pendingUnlinks.set(path, [event, ...args]);
+				setTimeout(() => {
+					this._pendingUnlinks.forEach((entry, path) => {
+						this.emit(...entry);
+						this.emit(EVENTS.ALL, ...entry);
+						this._pendingUnlinks.delete(path);
+					});
+				}, typeof opts.atomic === "number" ? opts.atomic : 100);
+				return this;
+			}
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+				event = EVENTS.CHANGE;
+				this._pendingUnlinks.delete(path);
+			}
+		}
+		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+			const awfEmit = (err, stats) => {
+				if (err) {
+					event = EVENTS.ERROR;
+					args[0] = err;
+					this.emitWithAll(event, args);
+				} else if (stats) {
+					if (args.length > 1) args[1] = stats;
+					else args.push(stats);
+					this.emitWithAll(event, args);
+				}
+			};
+			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+			return this;
+		}
+		if (event === EVENTS.CHANGE) {
+			if (!this._throttle(EVENTS.CHANGE, path, 50)) return this;
+		}
+		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+			const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;
+			let stats;
+			try {
+				stats = await stat$1(fullPath);
+			} catch (err) {}
+			if (!stats || this.closed) return;
+			args.push(stats);
+		}
+		this.emitWithAll(event, args);
+		return this;
+	}
+	/**
+	* Common handler for errors
+	* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	_handleError(error) {
+		const code = error && error.code;
+		if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EVENTS.ERROR, error);
+		return error || this.closed;
+	}
+	/**
+	* Helper utility for throttling
+	* @param actionType type being throttled
+	* @param path being acted upon
+	* @param timeout duration of time to suppress duplicate actions
+	* @returns tracking object or false if action should be suppressed
+	*/
+	_throttle(actionType, path, timeout) {
+		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
+		const action = this._throttled.get(actionType);
+		if (!action) throw new Error("invalid throttle");
+		const actionPath = action.get(path);
+		if (actionPath) {
+			actionPath.count++;
+			return false;
+		}
+		let timeoutObject;
+		const clear = () => {
+			const item = action.get(path);
+			const count = item ? item.count : 0;
+			action.delete(path);
+			clearTimeout(timeoutObject);
+			if (item) clearTimeout(item.timeoutObject);
+			return count;
+		};
+		timeoutObject = setTimeout(clear, timeout);
+		const thr = {
+			timeoutObject,
+			clear,
+			count: 0
+		};
+		action.set(path, thr);
+		return thr;
+	}
+	_incrReadyCount() {
+		return this._readyCount++;
+	}
+	/**
+	* Awaits write operation to finish.
+	* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	* @param path being acted upon
+	* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	* @param event
+	* @param awfEmit Callback to be called when ready for event to be emitted.
+	*/
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+		const awf = this.options.awaitWriteFinish;
+		if (typeof awf !== "object") return;
+		const pollInterval = awf.pollInterval;
+		let timeoutHandler;
+		let fullPath = path;
+		if (this.options.cwd && !sp.isAbsolute(path)) fullPath = sp.join(this.options.cwd, path);
+		const now = /* @__PURE__ */ new Date();
+		const writes = this._pendingWrites;
+		function awaitWriteFinishFn(prevStat) {
+			stat(fullPath, (err, curStat) => {
+				if (err || !writes.has(path)) {
+					if (err && err.code !== "ENOENT") awfEmit(err);
+					return;
+				}
+				const now = Number(/* @__PURE__ */ new Date());
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
+				if (now - writes.get(path).lastChange >= threshold) {
+					writes.delete(path);
+					awfEmit(void 0, curStat);
+				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+			});
+		}
+		if (!writes.has(path)) {
+			writes.set(path, {
+				lastChange: now,
+				cancelWait: () => {
+					writes.delete(path);
+					clearTimeout(timeoutHandler);
+					return event;
+				}
+			});
+			timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+		}
+	}
+	/**
+	* Determines whether user has asked to ignore this path.
+	*/
+	_isIgnored(path, stats) {
+		if (this.options.atomic && DOT_RE.test(path)) return true;
+		if (!this._userIgnored) {
+			const { cwd } = this.options;
+			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
+			const list = [...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored];
+			this._userIgnored = anymatch(list, void 0);
+		}
+		return this._userIgnored(path, stats);
+	}
+	_isntIgnored(path, stat) {
+		return !this._isIgnored(path, stat);
+	}
+	/**
+	* Provides a set of common helpers and properties relating to symlink handling.
+	* @param path file or directory pattern being watched
+	*/
+	_getWatchHelpers(path) {
+		return new WatchHelper(path, this.options.followSymlinks, this);
+	}
+	/**
+	* Provides directory tracking objects
+	* @param directory path of the directory
+	*/
+	_getWatchedDir(directory) {
+		const dir = sp.resolve(directory);
+		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+		return this._watched.get(dir);
+	}
+	/**
+	* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+	*/
+	_hasReadPermissions(stats) {
+		if (this.options.ignorePermissionErrors) return true;
+		return Boolean(Number(stats.mode) & 256);
+	}
+	/**
+	* Handles emitting unlink events for
+	* files and directories, and via recursion, for
+	* files and directories within directories that are unlinked
+	* @param directory within which the following item is located
+	* @param item      base path of item/directory
+	*/
+	_remove(directory, item, isDirectory) {
+		const path = sp.join(directory, item);
+		const fullPath = sp.resolve(path);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path, 100)) return;
+		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
+		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+		const parent = this._getWatchedDir(directory);
+		const wasTracked = parent.has(item);
+		parent.remove(item);
+		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
+		let relPath = path;
+		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path);
+		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
+		}
+		this._watched.delete(path);
+		this._watched.delete(fullPath);
+		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+		this._closePath(path);
+	}
+	/**
+	* Closes all watchers for a path
+	*/
+	_closePath(path) {
+		this._closeFile(path);
+		const dir = sp.dirname(path);
+		this._getWatchedDir(dir).remove(sp.basename(path));
+	}
+	/**
+	* Closes only file-specific watchers
+	*/
+	_closeFile(path) {
+		const closers = this._closers.get(path);
+		if (!closers) return;
+		closers.forEach((closer) => closer());
+		this._closers.delete(path);
+	}
+	_addPathCloser(path, closer) {
+		if (!closer) return;
+		let list = this._closers.get(path);
+		if (!list) {
+			list = [];
+			this._closers.set(path, list);
+		}
+		list.push(closer);
+	}
+	_readdirp(root, opts) {
+		if (this.closed) return;
+		let stream = readdirp(root, {
+			type: EVENTS.ALL,
+			alwaysStat: true,
+			lstat: true,
+			...opts,
+			depth: 0
+		});
+		this._streams.add(stream);
+		stream.once(STR_CLOSE, () => {
+			if (stream) this._streams.delete(stream);
+			stream = void 0;
+		});
+		stream.once("end", () => {
+			if (stream) {
+				this._streams.delete(stream);
+				stream = void 0;
+			}
+		});
+		return stream;
+	}
+};
+/**
+* Instantiates watcher with paths to be tracked.
+* @param paths file / directory paths
+* @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+* @returns an instance of FSWatcher for chaining.
+* @example
+* const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+* watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+*/
+function watch$1(paths, options = {}) {
+	const watcher = new FSWatcher(options);
+	watcher.add(paths);
+	return watcher;
+}
+var chokidar_default = {
+	watch: watch$1,
+	FSWatcher
+};
+//#endregion
+//#region src/plugins/autoRoutes.shared.ts
+const AUTO_ROUTES_ID = "weapp-vite/auto-routes";
+const VIRTUAL_MODULE_ID = "virtual:weapp-vite-auto-routes";
+const RESOLVED_VIRTUAL_ID = "\0weapp-vite:auto-routes";
+/**
+* 判断当前是否应按 watch 模式为 auto-routes 注册依赖文件。
+*/
+function isAutoRoutesWatchMode(configService) {
+	return Boolean(configService?.isDev || configService?.inlineConfig?.build?.watch);
+}
+/**
+* 合并 service 与 matcher 提供的监听目录，并去重保留顺序。
+*/
+function collectAutoRoutesWatchDirs(watchDirectories, matcherWatchRoots) {
+	const watchDirs = /* @__PURE__ */ new Set();
+	for (const dir of watchDirectories) watchDirs.add(dir);
+	for (const dir of matcherWatchRoots) watchDirs.add(dir);
+	return [...watchDirs];
+}
+/**
+* 过滤出真正需要交给 auto-routes watcher 处理的路由源文件。
+* 已知声明依赖不受普通页面发现扩展名限制，其他文件仍沿用发现规则。
+*/
+function isAutoRoutesWatchFile(filePath, allowedExtensions, isPagesRelatedPath, isPageDeclarationSource) {
+	if (isAutoRoutesGeneratedFileName(path.basename(filePath))) return false;
+	if (isPageDeclarationSource(filePath)) return true;
+	return allowedExtensions.has(path.extname(filePath)) && isPagesRelatedPath(filePath);
+}
+/**
+* 判断是否满足 auto-routes sidecar watcher 的启动前置条件。
+*/
+function shouldStartAutoRoutesWatcher(options) {
+	if (options.routeWatcherStarted) return false;
+	if (!options.isDev) return false;
+	if (!options.autoRoutesEnabled || !options.autoRoutesWatch || !options.serviceEnabled) return false;
+	return options.watchDirsLength > 0;
+}
+/**
+* 初扫完成前阻止路由构建发布；关闭时主动释放等待，不依赖物理 watcher 的 close 事件。
+*/
+function createAutoRoutesSidecarWatcher(watcher) {
+	let settleReady;
+	const ready = new Promise((resolve, reject) => {
+		const listeners = {
+			cleanup() {
+				watcher.off("ready", listeners.ready);
+				watcher.off("error", listeners.error);
+			},
+			ready() {
+				listeners.cleanup();
+				resolve();
+			},
+			error(error) {
+				listeners.cleanup();
+				reject(error);
+			}
+		};
+		settleReady = listeners.ready;
+		watcher.once("ready", listeners.ready);
+		watcher.once("error", listeners.error);
+	});
+	let closing;
+	return {
+		ready,
+		close() {
+			closing ??= (async () => {
+				settleReady();
+				await watcher.close();
+			})();
+			return closing;
+		}
+	};
+}
+/**
+* 向插件上下文注册 auto-routes 相关 watch 目标，忽略单个 addWatchFile 失败。
+*/
+function addAutoRoutesWatchTargets(pluginCtx, targets) {
+	for (const file of targets.files) try {
+		pluginCtx.addWatchFile?.(normalizeWatchPath(file));
+	} catch {}
+	for (const dir of targets.directories) try {
+		pluginCtx.addWatchFile?.(normalizeWatchPath(dir));
+	} catch {}
+}
+function invalidateAutoRoutesVirtualModules(server, resolvedIds) {
+	if (!server) return;
+	const seen = /* @__PURE__ */ new Set();
+	const invalidateModuleWithImporters = (module) => {
+		if (seen.has(module)) return;
+		seen.add(module);
+		server.moduleGraph.invalidateModule(module);
+		for (const importer of module.importers) invalidateModuleWithImporters(importer);
+	};
+	for (const id of resolvedIds) {
+		const virtualModule = server.moduleGraph.getModuleById(id);
+		if (virtualModule) invalidateModuleWithImporters(virtualModule);
+	}
+}
+/**
+* 统一解析 auto-routes 虚拟模块与 alias 入口的命中关系。
+*/
+function resolveAutoRoutesVirtualId(id, aliasTargets) {
+	if (id === WEVU_AUTO_ROUTES_MODULE_ID$1 || id === WEVU_AUTO_ROUTES_VIRTUAL_MODULE_ID$1 || id === WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID$1) return WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID$1;
+	if (id === "weapp-vite/auto-routes" || id === "virtual:weapp-vite-auto-routes" || id === "\0weapp-vite:auto-routes") return RESOLVED_VIRTUAL_ID;
+	return aliasTargets?.has(id) ? RESOLVED_VIRTUAL_ID : null;
+}
+/**
+* 将 create/delete 这类结构性变化映射为 auto-routes 的全量重扫语义。
+*/
+function resolveAutoRoutesWatchChangeEvent(event) {
+	if (event === "create" || event === "delete") return "rename";
+}
+/**
+* 判断某次热更新是否需要触发 auto-routes 虚拟模块失效。
+*/
+function resolveAutoRoutesHotUpdateAction(command, options) {
+	if (command === "serve") return options.isRouteFile ? {
+		shouldHandle: true,
+		shouldUpdateRouteFile: true
+	} : {
+		shouldHandle: false,
+		shouldUpdateRouteFile: false
+	};
+	if (options.isRouteFile || options.isPagesRelatedPath) return {
+		shouldHandle: true,
+		shouldUpdateRouteFile: false
+	};
+	return {
+		shouldHandle: false,
+		shouldUpdateRouteFile: false
+	};
+}
+/**
+* Web 路由表在创建 router 时完成快照，必须越过 SFC 自接受边界重新加载入口。
+* 入口排在前面，避免依赖失效先将生成的入口降为仅更新时间戳的软失效。
+*/
+function collectAutoRoutesReloadModules(modules) {
+	const pending = [...modules];
+	const visited = new Set(pending);
+	const reloadModules = /* @__PURE__ */ new Set();
+	for (const module of pending) {
+		if (module.importers.size === 0) reloadModules.add(module);
+		for (const importer of module.importers) if (!visited.has(importer)) {
+			visited.add(importer);
+			pending.push(importer);
+		}
+	}
+	for (const module of modules) reloadModules.add(module);
+	return [...reloadModules];
+}
+//#endregion
+//#region src/runtime/npmPlugin/packageResolution.ts
+/** 保留目录尾斜线，确保当前工程优先，并避免缺失包的目录回退把真实文件当作目录。 */
+function packageSearchOptions(resolveFrom) {
+	return resolveFrom ? { paths: [`${path.resolve(resolveFrom).replace(/\/$/, "")}/`] } : void 0;
+}
+//#endregion
+//#region src/runtime/npmPlugin/service/dependencies.ts
+const DEFAULT_NPM_STRATEGY = "explicit";
+function dedupeDependencies(dependencies) {
+	return [...new Set(dependencies)];
+}
+function matchDependencyName(patterns, dep) {
+	return patterns.some((pattern) => {
+		if (typeof pattern === "string") return pattern === dep;
+		pattern.lastIndex = 0;
+		return pattern.test(dep);
+	});
+}
+function createDependencyRecord(dependencies) {
+	if (dependencies.length === 0) return;
+	return Object.fromEntries(dependencies.map((dep) => [dep, "*"]));
+}
+function resolveNpmStrategy(ctx) {
+	return ctx.configService?.weappViteConfig?.npm?.strategy ?? DEFAULT_NPM_STRATEGY;
+}
+function resolveConfiguredDependencyPatterns(ctx) {
+	const npmConfig = ctx.configService?.weappViteConfig?.npm;
+	const patterns = [...npmConfig?.include ?? []];
+	if (ctx.configService?.pluginOnly) {
+		if (Array.isArray(npmConfig?.pluginPackage?.dependencies)) patterns.push(...npmConfig.pluginPackage.dependencies);
+		return patterns;
+	}
+	if (Array.isArray(npmConfig?.mainPackage?.dependencies)) patterns.push(...npmConfig.mainPackage.dependencies);
+	for (const config of Object.values(npmConfig?.subPackages ?? {})) if (Array.isArray(config?.dependencies)) patterns.push(...config.dependencies);
+	return patterns;
+}
+function resolveDeclaredDependencies(pkgJson) {
+	return dedupeDependencies([...Object.keys(pkgJson.dependencies ?? {}), ...Object.keys(pkgJson.devDependencies ?? {})]);
+}
+function isMiniprogramPackage(pkg) {
+	return Reflect.has(pkg, "miniprogram") && typeof pkg.miniprogram === "string";
+}
+function resolveMiniprogramCandidateDependenciesSync(allDependencies, cwd) {
+	return allDependencies.filter((dep) => {
+		let packageInfo = null;
+		try {
+			packageInfo = getPackageInfoSync(dep, packageSearchOptions(cwd));
+		} catch {
+			packageInfo = null;
+		}
+		return !!packageInfo && isMiniprogramPackage(packageInfo.packageJson);
+	});
+}
+function resolveMainPackageDependencyPatterns(ctx) {
+	return ctx.configService?.weappViteConfig?.npm?.mainPackage?.dependencies;
+}
+function resolvePluginPackageDependencyPatterns(ctx) {
+	return ctx.configService?.weappViteConfig?.npm?.pluginPackage?.dependencies;
+}
+function resolveTargetDependencies(allDependencies, patterns) {
+	if (patterns === false) return [];
+	if (!Array.isArray(patterns)) return allDependencies;
+	const selected = /* @__PURE__ */ new Set();
+	for (const dep of allDependencies) if (matchDependencyName(patterns, dep)) selected.add(dep);
+	for (const pattern of patterns) if (typeof pattern === "string") selected.add(pattern);
+	return [...selected];
+}
+function resolveNpmBuildCandidateDependenciesSync(ctx, pkgJson, resolveFrom = ctx.configService?.cwd) {
+	if (resolveNpmStrategy(ctx) === "legacy") return Object.keys(pkgJson.dependencies ?? {});
+	const declaredDependencies = resolveDeclaredDependencies(pkgJson);
+	const explicitlyIncludedDependencies = resolveTargetDependencies(declaredDependencies, resolveConfiguredDependencyPatterns(ctx));
+	return dedupeDependencies([...resolveMiniprogramCandidateDependenciesSync(declaredDependencies, resolveFrom), ...explicitlyIncludedDependencies]);
+}
+function resolveNpmBuildCandidateDependencyRecordSync(ctx, pkgJson) {
+	if (!pkgJson) return;
+	return createDependencyRecord(resolveNpmBuildCandidateDependenciesSync(ctx, pkgJson));
+}
+function hasLocalSubPackageNpmConfig(ctx) {
+	const npmSubPackages = ctx.configService?.weappViteConfig?.npm?.subPackages;
+	if (npmSubPackages && Object.values(npmSubPackages).some((config) => Array.isArray(config?.dependencies) && config.dependencies.length > 0)) return true;
+	return false;
+}
+function resolveNpmDistDirName(configService) {
+	return getPlatformNpmDistDirName(resolveMiniPlatformWithDefault(configService?.platform), { alipayNpmMode: configService?.weappViteConfig?.npm?.alipayNpmMode });
+}
+function resolveMainBuildDependencyPatterns(ctx) {
+	return ctx.configService?.pluginOnly ? resolvePluginPackageDependencyPatterns(ctx) : resolveMainPackageDependencyPatterns(ctx);
+}
+function dedupeNpmDependencies(dependencies) {
+	return dedupeDependencies(dependencies);
+}
+function resolveConfiguredNpmDependencyPatterns(ctx) {
+	return resolveConfiguredDependencyPatterns(ctx);
+}
+function resolveDeclaredNpmDependencies(pkgJson) {
+	return resolveDeclaredDependencies(pkgJson);
+}
+function resolveNpmStrategyMode(ctx) {
+	return resolveNpmStrategy(ctx);
+}
+//#endregion
+//#region src/runtime/watch/options.ts
+/**
+* 解析主 watcher 与 sidecar watcher 共享的轮询配置。
+*/
+function resolvePollingWatchOptions(configService) {
+	const buildWatch = configService.inlineConfig?.build?.watch;
+	const chokidar = buildWatch && typeof buildWatch === "object" && "chokidar" in buildWatch ? buildWatch.chokidar : void 0;
+	const serverWatch = configService.inlineConfig?.server?.watch;
+	const envUsePolling = process$1.env.CHOKIDAR_USEPOLLING;
+	const envInterval = process$1.env.CHOKIDAR_INTERVAL;
+	const envBinaryInterval = process$1.env.CHOKIDAR_BINARY_INTERVAL;
+	const usePollingCandidate = chokidar?.usePolling ?? serverWatch?.usePolling ?? (envUsePolling === "1" || envUsePolling === "true" ? true : envUsePolling === "0" || envUsePolling === "false" ? false : void 0);
+	const intervalCandidate = chokidar?.interval ?? serverWatch?.interval ?? (envInterval ? Number(envInterval) : void 0);
+	const binaryIntervalCandidate = chokidar?.binaryInterval ?? serverWatch?.binaryInterval ?? (envBinaryInterval ? Number(envBinaryInterval) : void 0);
+	return {
+		usePolling: typeof usePollingCandidate === "boolean" ? usePollingCandidate : void 0,
+		interval: typeof intervalCandidate === "number" && Number.isFinite(intervalCandidate) ? intervalCandidate : void 0,
+		binaryInterval: typeof binaryIntervalCandidate === "number" && Number.isFinite(binaryIntervalCandidate) ? binaryIntervalCandidate : void 0
+	};
+}
+function createSidecarWatchOptions(configService, input) {
+	const polling = resolvePollingWatchOptions(configService);
+	return {
+		...input,
+		...polling.usePolling !== void 0 ? { usePolling: polling.usePolling } : {},
+		...typeof polling.interval === "number" ? { interval: polling.interval } : {},
+		...typeof polling.binaryInterval === "number" ? { binaryInterval: polling.binaryInterval } : {}
+	};
+}
+/**
+* 合并用户配置并排除 Vite 开发服务器不应监听的构建输出目录。
+*/
+function createViteWatchIgnored(root, outDir, ignored) {
+	const normalizedRoot = normalizeFsResolvedId(root);
+	const normalizedOutDir = normalizeFsResolvedId(path.isAbsolute(outDir) ? outDir : path.resolve(root, outDir));
+	return [...ignored === void 0 ? [] : Array.isArray(ignored) ? ignored : [ignored], (id) => {
+		const normalizedId = normalizeFsResolvedId(path.isAbsolute(id) ? id : path.resolve(normalizedRoot, id));
+		return isPathInside(normalizedOutDir, normalizedId);
+	}];
+}
+//#endregion
+//#region src/wxml/processing/registry.ts
+/** 引用计数同时覆盖已发布、在途和失败恢复集合，单次注册不扫描整个工程。 */
+function retainDependency(state, files, file) {
+	if (files.has(file)) return;
+	files.add(file);
+	const count = state.references.get(file) ?? 0;
+	state.references.set(file, count + 1);
+	if (!count) for (const listener of state.listeners) listener([file]);
+}
+function releaseDependencies(state, templates) {
+	for (const files of templates.values()) for (const file of files) {
+		const count = state.references.get(file);
+		if (count === 1) state.references.delete(file);
+		else state.references.set(file, count - 1);
+	}
+}
+/** 只释放成功覆盖的模板，局部恢复不能丢失其他失败模板的监听。 */
+function releaseCoveredDependencies(state, templates, covered) {
+	if (!covered) {
+		releaseDependencies(state, templates);
+		templates.clear();
+		return;
+	}
+	for (const name of covered.keys()) {
+		const files = templates.get(name);
+		if (files) {
+			releaseDependencies(state, /* @__PURE__ */ new Map([[name, files]]));
+			templates.delete(name);
+		}
+	}
+}
+//#endregion
+//#region src/wxml/processing/dependencies.ts
+const deferredCommits = /* @__PURE__ */ new WeakMap();
+/** 转换阶段登记的依赖只在本轮输出成功后提交。 */
+function deferWxmlDependencyCommit(ctx, commit) {
+	deferredCommits.get(ctx)?.fail();
+	if (commit) deferredCommits.set(ctx, commit);
+	else deferredCommits.delete(ctx);
+}
+function failWxmlDependencies(ctx) {
+	deferredCommits.get(ctx)?.fail();
+	deferredCommits.delete(ctx);
+}
+function commitWxmlDependencies(ctx) {
+	deferredCommits.get(ctx)?.();
+	deferredCommits.delete(ctx);
+}
+const borrowedRegistries = /* @__PURE__ */ new WeakSet();
+/** 隔离快照和独立分包借用开发会话的依赖集合，由拥有者统一释放。 */
+function shareWxmlDependencies(owner, child) {
+	child.runtimeState.wxmlProcessing = owner.runtimeState.wxmlProcessing;
+	borrowedRegistries.add(child.runtimeState);
+}
+function clearWxmlDependencies(ctx) {
+	if (borrowedRegistries.has(ctx.runtimeState)) return;
+	ctx.runtimeState.wxmlProcessing?.dependencies.clear();
+	ctx.runtimeState.wxmlProcessing?.pending.clear();
+	ctx.runtimeState.wxmlProcessing?.failed.clear();
+	ctx.runtimeState.wxmlProcessing?.references.clear();
+	deferredCommits.delete(ctx);
+	ctx.runtimeState.wxmlProcessing?.listeners.clear();
+}
+function getWxmlWatchFiles(ctx) {
+	return [...ctx.runtimeState?.wxmlProcessing?.references.keys() ?? []];
+}
+function isWxmlDependency(ctx, file) {
+	return ctx.runtimeState?.wxmlProcessing?.references.has(normalizeFsResolvedId(file)) ?? false;
+}
+function observeWxmlDependencies(ctx, listener) {
+	const state = ctx.runtimeState?.wxmlProcessing;
+	if (!state) return () => {};
+	state.listeners.add(listener);
+	listener(getWxmlWatchFiles(ctx));
+	return () => {
+		state.listeners.delete(listener);
+	};
+}
+/** 注册立即生效以支持失败恢复，成功后再提交本轮各模板的依赖集合。 */
+function beginWxmlDependencies(ctx, scope, partial, stage = "transform") {
+	const state = ctx.runtimeState?.wxmlProcessing;
+	const pending = /* @__PURE__ */ new Map();
+	const key = `${stage}:${scope}`;
+	const token = Symbol(key);
+	let completed = false;
+	const root = ctx.configService.cwd;
+	let output;
+	state?.pending.set(token, {
+		scope,
+		stage,
+		templates: pending
+	});
+	const fail = () => {
+		if (!state || completed || !state.pending.has(token)) return;
+		completed = true;
+		const recovery = state.failed.get(key) ?? /* @__PURE__ */ new Map();
+		for (const [name, files] of pending) {
+			if (!files.size) continue;
+			const retained = recovery.get(name) ?? /* @__PURE__ */ new Set();
+			recovery.set(name, retained);
+			for (const file of files) retainDependency(state, retained, file);
+		}
+		if (recovery.size) state.failed.set(key, recovery);
+		releaseDependencies(state, pending);
+		state.pending.delete(token);
+	};
+	const commit = () => {
+		if (!state || completed || !state.pending.has(token)) return;
+		completed = true;
+		const next = state.dependencies.get(key) ?? /* @__PURE__ */ new Map();
+		releaseCoveredDependencies(state, next, partial ? pending : void 0);
+		for (const [name, files] of pending) if (files.size) next.set(name, files);
+		if (next.size) state.dependencies.set(key, next);
+		else state.dependencies.delete(key);
+		const recovery = state.failed.get(key);
+		if (recovery) {
+			releaseCoveredDependencies(state, recovery, partial ? pending : void 0);
+			if (!recovery.size) state.failed.delete(key);
+		}
+		state.pending.delete(token);
+		if (scope === "main" && !partial && ctx.scanService?.independentSubPackageMap) {
+			const activeScopes = new Set([...ctx.scanService.independentSubPackageMap.keys()].map((root) => `independent:${root}`));
+			for (const groups of [state.dependencies, state.failed]) for (const [registered, templates] of groups) {
+				const registeredScope = registered.slice(registered.indexOf(":") + 1);
+				if (registeredScope.startsWith("independent:") && !activeScopes.has(registeredScope)) {
+					releaseDependencies(state, templates);
+					groups.delete(registered);
+				}
+			}
+		}
+	};
+	return {
+		fail,
+		commit,
+		publish: Object.assign(commit, { fail }),
+		template(fileName) {
+			const files = pending.get(fileName) ?? /* @__PURE__ */ new Set();
+			pending.set(fileName, files);
+			return (file) => {
+				if (completed || state && !state.pending.has(token)) throw new Error("The template dependency transaction has already completed.");
+				if (typeof file !== "string" || !file.trim()) throw new TypeError("addWatchFile expects a nonempty file path.");
+				output ??= normalizeFsResolvedId(ctx.configService.outDir);
+				const resolved = normalizeFsResolvedId(path.resolve(root, file));
+				if (resolved === output || resolved.startsWith(`${output}/`)) throw new Error("addWatchFile cannot watch generated output.");
+				if (state) retainDependency(state, files, resolved);
+				return resolved;
+			};
+		}
+	};
+}
+//#endregion
+//#region src/wxml/processing/watch.ts
+const externalOwners = /* @__PURE__ */ new WeakMap();
+function ownsExternalWxmlWatch(ctx, file) {
+	const normalized = normalizeFsResolvedId(file);
+	return (externalOwners.get(ctx)?.has(normalized) ?? false) && isWxmlDependency(ctx, normalized);
+}
+/** 根外输入按父目录浅层监听，保留删除后的路径身份；根内输入继续由 Vite 监听。 */
+function bindWxmlDependencyWatch(ctx, server, onChange) {
+	const root = server.config?.root ?? ctx.configService?.cwd;
+	const external = /* @__PURE__ */ new Set();
+	const parents = /* @__PURE__ */ new Set();
+	let watcher;
+	let closed;
+	let ready = Promise.resolve();
+	externalOwners.set(ctx, external);
+	const unobserve = observeWxmlDependencies(ctx, (files) => {
+		for (const file of files) {
+			const relative = root ? path.relative(root, file) : "";
+			if (root && (relative === ".." || relative.startsWith("../") || path.isAbsolute(relative))) external.add(file);
+		}
+		if (!external.size || server.config?.server.watch === null) return;
+		const options = server.config?.server.watch ?? {};
+		if (!watcher) {
+			watcher = watch$1([], {
+				...options,
+				ignoreInitial: true,
+				depth: 0,
+				ignored: [...Array.isArray(options.ignored) ? options.ignored : options.ignored ? [options.ignored] : [], (file, stats) => {
+					const normalized = normalizeFsResolvedId(file);
+					return !parents.has(normalized) && (!parents.has(path.dirname(normalized)) || Boolean(stats?.isDirectory()));
+				}]
+			}).on("all", (event, file) => {
+				const normalized = normalizeFsResolvedId(file);
+				if (!external.has(normalized) || !isWxmlDependency(ctx, normalized)) return;
+				if (event === "add" || event === "change" || event === "unlink") onChange({
+					event: event === "add" ? "create" : event === "unlink" ? "delete" : "update",
+					file: normalized
+				});
+			}).on("error", (error) => server.config.logger.error(`[weapp-vite] WXML dependency watch failed: ${error instanceof Error ? error.message : String(error)}`));
+			ready = once(watcher, "ready");
+		}
+		for (const file of external) {
+			const parent = path.dirname(file);
+			if (!parents.has(parent)) {
+				parents.add(parent);
+				watcher.add(parent);
+			}
+		}
+	});
+	const close = () => {
+		closed ??= (async () => {
+			unobserve();
+			if (externalOwners.get(ctx) === external) externalOwners.delete(ctx);
+			external.clear();
+			await watcher?.close();
+		})();
+		return closed;
+	};
+	return Object.assign(close, { ready });
+}
+//#endregion
+//#region src/moduleGraph/host.ts
+const hosts = /* @__PURE__ */ new WeakMap();
+/** 显式借用宿主图；释放借用不会关闭宿主服务器。 */
+function attachDevModuleGraphHost(context, server, onBuild) {
+	if (hosts.has(context)) throw new Error("[weapp-vite] 编译上下文已经绑定开发宿主。");
+	const host = {
+		server,
+		onBuild,
+		pending: []
+	};
+	hosts.set(context, host);
+	return () => {
+		if (hosts.get(context) === host) hosts.delete(context);
+	};
+}
+function notifyDevModuleGraphHost(context, change) {
+	const host = hosts.get(context);
+	if (host?.onChange) host.onChange(change);
+	else host?.pending.push(change);
+}
+function reportDevModuleGraphBuild(context, successful) {
+	hosts.get(context)?.onBuild?.(successful);
+}
+function hasDevModuleGraphHost(context) {
+	return hosts.has(context);
+}
+function connectDevModuleGraphHost(context, onChange) {
+	const host = hosts.get(context);
+	if (!host) return;
+	host.onChange = onChange;
+	const release = context.moduleGraphService.bindDevServer(host.server);
+	for (const change of host.pending.splice(0)) onChange(change);
+	let closed = false;
+	return { async close() {
+		if (closed) return;
+		closed = true;
+		if (host.onChange === onChange) host.onChange = void 0;
+		release();
+	} };
+}
+//#endregion
+//#region src/moduleGraph/logicalEntry.ts
+function createLogicalEntryModuleCode(entry, dependencies, options = {}) {
+	const source = JSON.stringify(entry.sourceId);
+	const isVueLikeEntry = /\.(?:vue|jsx|tsx)$/.test(entry.sourceId);
+	const delegatesComponentRegistration = entry.type === "component" && isVueLikeEntry;
+	const forwardsDefault = entry.type !== "app" && isVueLikeEntry;
+	const imports = delegatesComponentRegistration ? [
+		`import { createWevuComponent as __weappViteCreateWevuComponent } from ${JSON.stringify(WEAPP_VITE_RUNTIME_VIRTUAL_ID)};`,
+		`import __weappViteComponentOptions from ${source};`,
+		`__weappViteCreateWevuComponent(__weappViteComponentOptions);`,
+		`export default __weappViteComponentOptions;`
+	] : [forwardsDefault ? `export { default } from ${source};` : `import ${source};`];
+	const dependencyIds = /* @__PURE__ */ new Set();
+	withRealpathScope(() => {
+		for (const dependency of dependencies) dependencyIds.add(createSidecarModuleId(entry.sourceId, dependency.sourceId, dependency.kind));
+	});
+	for (const dependencyId of [...dependencyIds].sort()) imports.push(`import ${JSON.stringify(dependencyId)};`);
+	imports.push(`export * from ${source};`);
+	if (options.includeStatefulHmrAccept && entry.type !== "component") imports.push("if (import.meta.hot) import.meta.hot.accept();");
+	return `${imports.join("\n")}\n`;
+}
+function createSidecarModuleCode(ownerId, sourceId, kind) {
+	const sourceRequest = createSidecarSourceSpecifier(ownerId, sourceId, kind, kind === "style");
+	return `import ${JSON.stringify(sourceRequest)};\nexport default ${JSON.stringify(sourceId)};\n`;
+}
+//#endregion
+//#region src/utils/hmrProfile.ts
+const DEFAULT_HMR_PROFILE_JSONL_RELATIVE_PATH = ".weapp-vite/hmr-profile.jsonl";
+const HMR_PROFILE_JSON_ENV = "WEAPP_VITE_HMR_PROFILE_JSON";
+/**
+* @description 解析 HMR profile JSONL 输出路径。
+*/
+function resolveHmrProfileJsonPath(options) {
+	const fallbackToDefault = options.fallbackToDefault ?? false;
+	if (options.option === true) return path.join(options.cwd, DEFAULT_HMR_PROFILE_JSONL_RELATIVE_PATH);
+	if (typeof options.option === "string") {
+		const trimmed = options.option.trim();
+		if (trimmed) return path.isAbsolute(trimmed) ? trimmed : path.resolve(options.cwd, trimmed);
+	}
+	if (fallbackToDefault) return path.join(options.cwd, DEFAULT_HMR_PROFILE_JSONL_RELATIVE_PATH);
+}
+/**
+* @description 从环境变量解析 HMR profile JSONL 输出选项。
+*/
+function resolveHmrProfileJsonEnvOption(env = process$1.env) {
+	const raw = env[HMR_PROFILE_JSON_ENV]?.trim();
+	if (!raw) return;
+	if (raw === "1" || raw.toLowerCase() === "true") return true;
+	if (raw === "0" || raw.toLowerCase() === "false") return;
+	return raw;
+}
+/** 统一写入方与监听边界的 profile 输出选择，保持环境变量优先级一致。 */
+function resolveActiveHmrProfileJsonPath(options, env = process$1.env) {
+	return resolveHmrProfileJsonPath({
+		...options,
+		option: resolveHmrProfileJsonEnvOption(env) ?? options.option
+	});
+}
+let hmrProfileEventSequence = 0;
+/**
+* @description 创建 HMR profile 事件 id，用于把 watcher 事件、JSONL 样本和外部审计场景稳定关联。
+*/
+function createHmrProfileEventId() {
+	hmrProfileEventSequence += 1;
+	return `${Date.now().toString(36)}-${hmrProfileEventSequence.toString(36)}`;
+}
+/**
+* @description 为 HMR profile 累加阶段耗时。
+*/
+function recordHmrProfileDuration(profile, key, durationMs) {
+	if (!profile || !Number.isFinite(durationMs) || durationMs < 0) return;
+	profile[key] = (profile[key] ?? 0) + durationMs;
+}
+/**
+* @description 为 HMR profile 累加操作次数。
+*/
+function recordHmrProfileOperation(profile, key, count = 1) {
+	if (!profile || !Number.isFinite(count) || count <= 0) return;
+	profile[key] = (profile[key] ?? 0) + count;
+}
+/** 连续记录同一插件内已完成的阶段；停用时不读取时钟，不引入额外异步调度。 */
+function createHmrProfileCheckpoint(profile) {
+	let previous = profile ? performance.now() : 0;
+	return (key) => {
+		if (!profile) return;
+		const now = performance.now();
+		recordHmrProfileDuration(profile, key, now - previous);
+		previous = now;
+	};
+}
+//#endregion
+//#region src/moduleGraph/profileOutput.ts
+/** 仅识别当前启用的自身 profile 文件，不屏蔽同目录或同名用户输入。 */
+function createProfileOutputMatcher(configService) {
+	return (file) => {
+		if (!configService) return false;
+		const output = resolveActiveHmrProfileJsonPath({
+			cwd: configService.cwd,
+			option: configService.weappViteConfig?.hmr?.profileJson
+		});
+		if (!output) return false;
+		const normalize = (value) => {
+			const normalized = normalizePath$1(path.resolve(configService.cwd, normalizePath$1(value)));
+			return process$1.platform === "win32" ? normalized.toLowerCase() : normalized;
+		};
+		return normalize(file) === normalize(output);
+	};
+}
+//#endregion
+//#region src/moduleGraph/devProvider.ts
+const DEV_EXTERNAL_PREFIX = "\0weapp-vite:module-graph-external:";
+function isInternalPlugin(plugin) {
+	if (!plugin || typeof plugin !== "object" || !("name" in plugin)) return false;
+	const name = plugin.name;
+	return typeof name === "string" && (name.startsWith("weapp-vite:") || name.startsWith("weapp-runtime:"));
+}
+function collectResolverPlugins(config) {
+	return (Array.isArray(config.plugins) ? config.plugins : config.plugins ? [config.plugins] : []).filter((plugin) => !isInternalPlugin(plugin));
+}
+async function transformVueSource(code, id, config) {
+	const { descriptor, errors } = await readAndParseSfc(id, { source: code });
+	if (errors.length) throw errors[0];
+	const blocks = [descriptor.script, descriptor.scriptSetup].filter((block) => block?.content || block?.src);
+	const source = blocks.map((block) => block.src ? `import ${JSON.stringify(block.src)};` : block.content).join("\n") || "export default {}";
+	const lang = blocks.some((block) => block?.lang === "tsx") ? "tsx" : blocks.some((block) => block?.lang === "ts") ? "ts" : "js";
+	return await transformWithOxc(source, id, {
+		lang,
+		sourcemap: false,
+		target: "esnext",
+		tsconfig: false,
+		typescript: { onlyRemoveTypeImports: true }
+	}, void 0, config);
+}
+async function isExternalRequest(source, importer, config) {
+	const buildOptions = config.build;
+	const external = buildOptions?.rolldownOptions?.external ?? buildOptions?.rollupOptions?.external;
+	if (typeof external === "function") return await external(source, importer, false);
+	return (Array.isArray(external) ? external : external ? [external] : []).some((pattern) => {
+		if (typeof pattern === "string") return pattern === source;
+		pattern.lastIndex = 0;
+		return pattern.test(source);
+	});
+}
+function createDevModuleGraphPlugin(ctx, config, onChange) {
+	const isProfileOutput = createProfileOutputMatcher(ctx.configService);
+	const npmExternalPackages = new Set(ctx.configService?.packageJson ? resolveNpmBuildCandidateDependenciesSync(ctx, ctx.configService.packageJson) : []);
+	return {
+		name: "weapp-vite:module-graph-provider",
+		enforce: "pre",
+		config() {
+			return {
+				server: { watch: { ignored: [isProfileOutput] } },
+				resolve: { alias: [{
+					find: WEVU_AUTO_ROUTES_MODULE_ID$1,
+					replacement: WEVU_AUTO_ROUTES_VIRTUAL_MODULE_ID$1
+				}, {
+					find: AUTO_ROUTES_ID,
+					replacement: VIRTUAL_MODULE_ID
+				}] }
+			};
+		},
+		async resolveId(id, importer) {
+			const autoRoutesId = resolveAutoRoutesVirtualId(id);
+			if (autoRoutesId) return autoRoutesId;
+			const virtualId = resolveVirtualModuleId(id);
+			if (virtualId) return virtualId;
+			if (parseSidecarSourceMetadata(id)) return id;
+			if (Array.from(npmExternalPackages).some((pkg) => id === pkg || id.startsWith(`${pkg}/`))) return `${DEV_EXTERNAL_PREFIX}${encodeURIComponent(id)}`;
+			if (await isExternalRequest(id, importer, config)) return `${DEV_EXTERNAL_PREFIX}${encodeURIComponent(id)}`;
+			if (!id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !/^[a-z]:[\\/]/i.test(id)) {
+				const resolved = await this.resolve(id, importer, { skipSelf: true });
+				if (!resolved || resolved.external) return `${DEV_EXTERNAL_PREFIX}${encodeURIComponent(id)}`;
+				return resolved;
+			}
+			return null;
+		},
+		load(id) {
+			const autoRoutesId = resolveAutoRoutesVirtualId(id);
+			const service = ctx.autoRoutesService;
+			if (autoRoutesId && service) return service.ensureFresh().then(() => autoRoutesId === WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID$1 ? service.getNamedModuleCode() : service.getModuleCode());
+			if (id.startsWith(DEV_EXTERNAL_PREFIX)) return "export default {}";
+			const logicalEntry = parseLogicalEntryId(id);
+			if (logicalEntry) return createLogicalEntryModuleCode(logicalEntry, ctx.moduleGraphService.getEntryDependencies(logicalEntry.sourceId));
+			const sidecar = parseSidecarModuleId(id);
+			if (sidecar) {
+				if (sidecar.kind === "style") {
+					const source = createSidecarSourceSpecifier(sidecar.ownerId, sidecar.sourceId, "style");
+					return `import ${JSON.stringify(source)};\nexport default ${JSON.stringify(sidecar.sourceId)};\n`;
+				}
+				return createSidecarModuleCode(sidecar.ownerId, sidecar.sourceId, sidecar.kind);
+			}
+			const sidecarSource = parseSidecarSourceRequest(id);
+			if (sidecarSource) {
+				if (sidecarSource.kind === "style" && !sidecarSource.dependencyOnly) return null;
+				return `export default ${JSON.stringify(sidecarSource.sourceId)};`;
+			}
+			return null;
+		},
+		async transform(code, id) {
+			if (isCSSRequest(id) && !id.startsWith("\0")) this.addWatchFile(normalizeSourceId(id));
+			for (const dependency of ctx.moduleGraphService.getTransformDependencies?.(id) ?? []) this.addWatchFile(dependency);
+			if (!id.endsWith(".vue")) return null;
+			return await transformVueSource(code, id, this?.environment?.config);
+		},
+		async hotUpdate({ type, file, read }) {
+			if (this.environment.name !== "client" || isProfileOutput(file) || ownsExternalWxmlWatch(ctx, file)) return;
+			if (type === "delete") {
+				onChange({
+					event: type,
+					file
+				});
+				return;
+			}
+			try {
+				await read();
+			} catch (error) {
+				if (error.code === "ENOENT") return;
+				throw error;
+			}
+			onChange({
+				event: type,
+				file
+			});
+		}
+	};
+}
+async function createDevModuleGraphProvider(ctx, buildConfig, onChange) {
+	const host = connectDevModuleGraphHost(ctx, onChange);
+	if (host) return host;
+	const configService = ctx.configService;
+	const userWatch = buildConfig.server?.watch;
+	const pollingWatchOptions = resolvePollingWatchOptions({ inlineConfig: configService?.inlineConfig ?? {} });
+	const ignored = configService?.outDir ? createViteWatchIgnored(buildConfig.root ?? configService.cwd, configService.outDir, userWatch?.ignored) : userWatch?.ignored;
+	const server = await createServer({
+		...buildConfig,
+		root: buildConfig.root ?? configService?.cwd,
+		appType: "custom",
+		configFile: false,
+		customLogger: createLogger("silent"),
+		plugins: [createDevModuleGraphPlugin(ctx, buildConfig, onChange), ...collectResolverPlugins(buildConfig)],
+		server: {
+			...buildConfig.server ?? {},
+			hmr: true,
+			middlewareMode: true,
+			watch: {
+				...userWatch ?? {},
+				...Object.fromEntries(Object.entries(pollingWatchOptions).filter(([, value]) => value !== void 0)),
+				...ignored !== void 0 ? { ignored } : {}
+			}
+		},
+		build: {
+			...buildConfig.build ?? {},
+			watch: void 0,
+			write: false
+		}
+	});
+	const releaseServer = ctx.moduleGraphService.bindDevServer(server);
+	const unobserveWxml = bindWxmlDependencyWatch(ctx, server, onChange);
+	try {
+		await unobserveWxml.ready;
+	} catch (error) {
+		await unobserveWxml();
+		try {
+			await server.close();
+		} finally {
+			releaseServer();
+		}
+		throw error;
+	}
+	let closePromise;
+	return { close() {
+		closePromise ??= (async () => {
+			await unobserveWxml();
+			try {
+				await server.close();
+			} finally {
+				releaseServer();
+			}
+		})();
+		return closePromise;
+	} };
+}
+//#endregion
+export { isAutoRoutesGeneratedDirectoryName as $, resolveConfiguredNpmDependencyPatterns as A, WEVU_AUTO_ROUTES_RESOLVED_MODULE_ID$1 as B, isWxmlDependency as C, resolvePollingWatchOptions as D, createViteWatchIgnored as E, resolveNpmDistDirName as F, invalidateAutoRoutesVirtualModules as G, collectAutoRoutesReloadModules as H, resolveNpmStrategyMode as I, resolveAutoRoutesHotUpdateAction as J, isAutoRoutesWatchFile as K, resolveTargetDependencies as L, resolveMainBuildDependencyPatterns as M, resolveNpmBuildCandidateDependenciesSync as N, dedupeNpmDependencies as O, resolveNpmBuildCandidateDependencyRecordSync as P, chokidar_default as Q, packageSearchOptions as R, getWxmlWatchFiles as S, createSidecarWatchOptions as T, collectAutoRoutesWatchDirs as U, addAutoRoutesWatchTargets as V, createAutoRoutesSidecarWatcher as W, resolveAutoRoutesWatchChangeEvent as X, resolveAutoRoutesVirtualId as Y, shouldStartAutoRoutesWatcher as Z, beginWxmlDependencies as _, recordHmrProfileDuration as a, isCSSRequest as at, deferWxmlDependencyCommit as b, resolveHmrProfileJsonEnvOption as c, collectDevStartNodes as ct, createSidecarModuleCode as d, isLogicalEntrySource as dt, isAutoRoutesGeneratedPath as et, attachDevModuleGraphHost as f, normalizeSourceId as ft, bindWxmlDependencyWatch as g, reportDevModuleGraphBuild as h, createHmrProfileEventId as i, createAutoRoutesMatcher as it, resolveDeclaredNpmDependencies as j, hasLocalSubPackageNpmConfig as k, resolveHmrProfileJsonPath as l, hasBuildModule as lt, notifyDevModuleGraphHost as m, createDevModuleGraphProvider as n, resolveAutoRoutesManagedOutputPaths as nt, recordHmrProfileOperation as o, isRegexp as ot, hasDevModuleGraphHost as p, isAutoRoutesWatchMode as q, createHmrProfileCheckpoint as r, resolveWeappAutoRoutesConfig as rt, resolveActiveHmrProfileJsonPath as s, collectBuildStartIds as st, createDevModuleGraphPlugin as t, isAutoRoutesGeneratedRelativePath as tt, createLogicalEntryModuleCode as u, hasDevModule as ut, clearWxmlDependencies as v, shareWxmlDependencies as w, failWxmlDependencies as x, commitWxmlDependencies as y, RESOLVED_VIRTUAL_ID as z };