zintljs 0.1.0-alpha.7

package/dist/vite.mjs

@@ -0,0 +1,1056 @@
+import { o as detectFrameworksOrFallback, s as resolveFacets, t as assembleFacets } from "./assemble-DJKgHgSM.mjs";
+import { createUnplugin } from "unplugin";
+import { ZintlCompiler, generateMessageId, getRuntimeCode, sha1 } from "@zintljs/compiler";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+//#region src/constants.ts
+const VIRTUAL_PREFIX = "virtual:zintl-catalog";
+const CHUNK_VIRTUAL_PREFIX = "virtual:zintl/catalog";
+const CONTENT_VIRTUAL_PREFIX = "virtual:zintl/content";
+const MANAGER_VIRTUAL_PREFIX = "virtual:zintl/manager";
+const RESOLVED_VIRTUAL_PREFIX = "\0virtual:zintl-catalog";
+const PLUGIN_NAME = "zintl";
+//#endregion
+//#region src/context.ts
+var Context = class {
+	options;
+	compiler;
+	server = null;
+	multiplexEnabled = null;
+	constructor(options) {
+		this.options = options;
+	}
+	getMultiplex(config) {
+		if (this.compiler && this.multiplexEnabled !== null) return this.multiplexEnabled;
+		const root = config?.root || this.compiler?.rootDir || process.cwd();
+		if (this.options.multiplex !== void 0) {
+			const val = this.options.multiplex;
+			if (this.compiler) this.multiplexEnabled = val;
+			return val;
+		}
+		try {
+			const entryFiles = [];
+			const userInput = ((config?.build || {}).rollupOptions || {}).input;
+			if (userInput) {
+				if (typeof userInput === "string") entryFiles.push(userInput);
+				else if (Array.isArray(userInput)) entryFiles.push(...userInput);
+				else if (typeof userInput === "object" && userInput !== null) entryFiles.push(...Object.values(userInput));
+			}
+			if (entryFiles.length === 0) entryFiles.push("index.html");
+			const locales = this.options.locales;
+			const cleanEntryFiles = entryFiles.map((file) => {
+				let clean = file;
+				for (const loc of locales) if (clean.startsWith(`${loc}/`)) {
+					clean = clean.slice(loc.length + 1);
+					break;
+				} else if (clean.startsWith(`./${loc}/`)) {
+					clean = clean.slice(loc.length + 3);
+					break;
+				}
+				return clean;
+			});
+			let content = "";
+			for (const entryFile of cleanEntryFiles) {
+				const absoluteEntryPath = isAbsolute(entryFile) ? entryFile : join(root, entryFile);
+				if (existsSync(absoluteEntryPath)) {
+					const fileContent = readFileSync(absoluteEntryPath, "utf-8");
+					content += fileContent;
+					if (entryFile.endsWith(".html")) {
+						const scriptMatches = fileContent.matchAll(/<script[^>]+src=["']([^"']+)["']/g);
+						for (const match of scriptMatches) {
+							const scriptSrc = match[1];
+							const cleanScriptSrc = scriptSrc.startsWith("/") ? scriptSrc.slice(1) : scriptSrc;
+							const absoluteScriptPath = isAbsolute(cleanScriptSrc) ? cleanScriptSrc : join(root, cleanScriptSrc);
+							if (existsSync(absoluteScriptPath)) {
+								const scriptContent = readFileSync(absoluteScriptPath, "utf-8");
+								content += scriptContent;
+							}
+						}
+					}
+				}
+			}
+			const mainPath = join(root, "src/main.ts");
+			const indexTsPath = join(root, "src/index.ts");
+			if (existsSync(mainPath)) content += readFileSync(mainPath, "utf-8");
+			if (existsSync(indexTsPath)) content += readFileSync(indexTsPath, "utf-8");
+			let result = false;
+			if (/zintl\(\s*['"]\*['"]\s*\)/.test(content) || /zintl\(\s*\)/.test(content)) result = true;
+			else result = false;
+			if (this.compiler) this.multiplexEnabled = result;
+			return result;
+		} catch {
+			if (this.compiler) this.multiplexEnabled = false;
+			return false;
+		}
+	}
+	getMultiplexLocale(id) {
+		const matchSuffix = id.match(/\.zintl-([a-zA-Z0-9_-]+)\.(vue|svelte)/);
+		if (matchSuffix) return matchSuffix[1];
+		if (!id.includes("zintl-multiplex=")) return void 0;
+		const match = id.match(/zintl-multiplex=([^&]+)/);
+		return match ? match[1] : void 0;
+	}
+};
+//#endregion
+//#region src/hooks/config.ts
+function configHook(ctx) {
+	return function(userConfig) {
+		const multiplex = ctx.getMultiplex(userConfig);
+		const locales = ctx.options.locales;
+		const configUpdate = {};
+		if (ctx.options.debug) configUpdate.define = { "process.env.ZINTL_DEBUG": JSON.stringify(ctx.options.debug === true ? "true" : ctx.options.debug) };
+		if (multiplex) {
+			const userInput = ((userConfig.build || {}).rollupOptions || {}).input || "index.html";
+			const inputObj = {};
+			if (typeof userInput === "string") inputObj.index = userInput;
+			else if (Array.isArray(userInput)) userInput.forEach((inp, idx) => {
+				const name = inp.replace(/\.html$/, "").replace(/[^a-zA-Z0-9]/g, "_");
+				inputObj[name || `input_${idx}`] = inp;
+			});
+			else if (typeof userInput === "object" && userInput !== null) Object.assign(inputObj, userInput);
+			for (const [key, val] of Object.entries(inputObj)) for (const loc of locales) if (val.startsWith(`${loc}/`) || val.startsWith(`./${loc}/`)) delete inputObj[key];
+			if (Object.keys(inputObj).length === 0) inputObj.index = "index.html";
+			const root = userConfig.root || process.cwd();
+			const expandedInput = { ...inputObj };
+			for (const [key, val] of Object.entries(inputObj)) if (val.endsWith(".html")) {
+				const relativeVal = isAbsolute(val) ? relative(root, val) : val;
+				for (const loc of locales) {
+					const prefixKey = `${loc}/${key === "main" || key === "index" ? "index" : key}`;
+					expandedInput[prefixKey] = `${loc}/${relativeVal}`;
+				}
+			}
+			configUpdate.build = { rollupOptions: { input: expandedInput } };
+		}
+		configUpdate.optimizeDeps = { exclude: [
+			...userConfig.optimizeDeps?.exclude || [],
+			"zintl",
+			"zintl/internal",
+			"virtual:zintl/runtime",
+			"virtual:zintl/runtime/internal"
+		] };
+		return configUpdate;
+	};
+}
+function configResolvedHook(ctx) {
+	return function(config) {
+		const logLevel = ctx.options.logLevel ?? config.logLevel ?? "info";
+		const verifyIntegrity = ctx.options.verifyIntegrity ?? config.command === "build";
+		const capabilities = resolveFacets(assembleFacets({
+			frameworks: detectFrameworksOrFallback({
+				pluginNames: Array.isArray(config.plugins) ? config.plugins.map((p) => p?.name).filter(Boolean) : [],
+				root: config.root
+			}),
+			ssr: Boolean(config.build?.ssr) || config.ssr !== void 0,
+			facets: ctx.options.facets,
+			assetsTarget: ctx.options.assetsTarget,
+			virtualAssets: ctx.options.virtualAssets
+		}));
+		ctx.compiler = new ZintlCompiler({
+			...ctx.options,
+			capabilities,
+			logLevel,
+			verifyIntegrity
+		}, config.root, config.command === "serve");
+		ctx.getMultiplex(config);
+	};
+}
+//#endregion
+//#region src/hooks/server.ts
+function configureServerHook(ctx) {
+	return function(server) {
+		ctx.server = server;
+		if (server.config?.appType === "custom") return;
+		if (ctx.getMultiplex()) {
+			const locales = ctx.options.locales;
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url || "/";
+				const [pathname] = url.split("?");
+				const parts = pathname.split("/").filter(Boolean);
+				if (parts.length > 0 && locales.includes(parts[0])) {
+					const locale = parts[0];
+					const htmlFilename = parts.slice(1).join("/") || "index.html";
+					const originalPath = join(server.config.root, htmlFilename);
+					if (existsSync(originalPath)) {
+						let html = readFileSync(originalPath, "utf-8");
+						let dir = locale === "ar" ? "rtl" : "ltr";
+						try {
+							const catalogPath = ctx.compiler.html.getCatalogPath(htmlFilename, locale);
+							if (existsSync(catalogPath)) {
+								const cat = JSON.parse(readFileSync(catalogPath, "utf-8"));
+								const catalogDir = ctx.compiler.isMultilingualFormat() ? cat.dir?.[locale] : cat.dir;
+								if (catalogDir !== void 0) dir = catalogDir;
+							}
+						} catch {}
+						html = html.replace(/<html([^>]*)>/i, (m, attrs) => {
+							let newAttrs = attrs;
+							if (!/lang=/i.test(attrs)) newAttrs += ` lang="${locale}"`;
+							else newAttrs = newAttrs.replace(/lang=["'][^"']*["']/i, `lang="${locale}"`);
+							if (!/dir=/i.test(attrs)) newAttrs += ` dir="${dir}"`;
+							else newAttrs = newAttrs.replace(/dir=["'][^"']*["']/i, `dir="${dir}"`);
+							return `<html${newAttrs}>`;
+						});
+						html = html.replace(/(<script\s+[^>]*type=["']module["'][^>]*src=["'])([^"']*)(["'])/gi, (m, prefix, src, suffix) => {
+							if (src.includes("node_modules") || src.startsWith("http") || src.startsWith("//")) return m;
+							return `${prefix}${src}${src.includes("?") ? "&" : "?"}zintl-multiplex=${locale}${suffix}`;
+						});
+						res.statusCode = 200;
+						res.setHeader("Content-Type", "text/html");
+						return res.end(await server.transformIndexHtml(url, html));
+					}
+				}
+				if (pathname === "/" || pathname === "/index.html") {
+					const defaultLocale = ctx.options.sourceLocale;
+					const localesStr = JSON.stringify(locales);
+					const redirectHtml = `
+<!doctype html>
+<html>
+  <head>
+    <script>
+      (function() {
+        try {
+          const lang = (navigator.language || '${defaultLocale}').split('-')[0];
+          const supported = ${localesStr};
+          const parts = window.location.pathname.split('/').filter(Boolean);
+          if (parts.length > 0 && supported.includes(parts[0])) return;
+          const target = supported.includes(lang) ? lang : '${defaultLocale}';
+          const path = window.location.pathname.replace(/^\\/+/, '');
+          window.location.replace('/' + target + '/' + path + window.location.search + window.location.hash);
+        } catch (e) {
+          const supported = ${localesStr};
+          const parts = window.location.pathname.split('/').filter(Boolean);
+          if (parts.length > 0 && supported.includes(parts[0])) return;
+          const path = window.location.pathname.replace(/^\\/+/, '');
+          window.location.replace('/${defaultLocale}/' + path);
+        }
+      })();
+    <\/script>
+  </head>
+</html>`;
+					res.statusCode = 200;
+					res.setHeader("Content-Type", "text/html");
+					return res.end(redirectHtml);
+				}
+				next();
+			});
+		}
+	};
+}
+//#endregion
+//#region src/hooks/resolve.ts
+function injectMultiplexQuery(id, locale) {
+	const parts = id.split("?");
+	const cleanId = parts[0];
+	if (parts.length === 1) return `${cleanId}?zintl-multiplex=${locale}`;
+	const params = parts[1].split("&").filter((p) => !p.startsWith("zintl-multiplex="));
+	if (params.length === 0) return `${cleanId}?zintl-multiplex=${locale}`;
+	const lastParam = params[params.length - 1];
+	if (lastParam && /\.(ts|tsx|js|jsx|mts|mjs|css|scss|less|html|vue|svelte)$/i.test(lastParam)) {
+		const before = params.slice(0, -1);
+		return `${cleanId}?${before.length ? before.join("&") + "&" : ""}zintl-multiplex=${locale}&${lastParam}`;
+	}
+	return `${cleanId}?${params.join("&")}&zintl-multiplex=${locale}`;
+}
+function resolveIdHook(ctx) {
+	return async function(id, importer, options) {
+		const isSsr = this.environment ? this.environment.config.consumer === "server" : !!options?.ssr;
+		if (id.includes(".zintl-")) {
+			const cleanId = id.split("?")[0];
+			if (isAbsolute(cleanId)) return id;
+		}
+		if (id.startsWith(".") && importer && importer.includes(".zintl-")) {
+			const cleanId = id.split("?")[0];
+			id = join(dirname(importer.split("?")[0]), cleanId) + (id.includes("?") ? "?" + id.split("?")[1] : "");
+		}
+		if (id === "virtual:zintl/runtime" || id === "virtual:zintl/runtime/internal" || id.startsWith("virtual:zintl/runtime/")) return "\0" + id;
+		if (importer && importer.includes("virtual:zintl/runtime")) {
+			if (id.startsWith("./")) return "\0virtual:zintl/runtime/" + id.replace("./", "").replace(".js", "").replace(".mjs", "");
+		}
+		if (id.startsWith("virtual:zintl-catalog") || id.startsWith("virtual:zintl/catalog") || id.startsWith("virtual:zintl/content") || id.startsWith("virtual:zintl/manager")) {
+			ctx.compiler._logger.withPrefix("Vite").debug(`Resolving virtual module: ${id}`);
+			return "\0" + id;
+		}
+		const cleanId = id.split("?")[0];
+		if (ctx.compiler.assets.isSupportedAsset(cleanId)) {
+			let absolutePath = cleanId;
+			if (cleanId.startsWith(".") && importer) absolutePath = join(dirname(importer.split("?")[0]), cleanId);
+			await ctx.compiler.assets.registerAsset(absolutePath);
+		}
+		if (id.includes("zintl-multiplex=")) {
+			const cleanId = id.split("?")[0];
+			if (ctx.compiler.assets.isSupportedAsset(cleanId)) {
+				const locale = ctx.getMultiplexLocale(id);
+				if (locale) {
+					let absolutePath = cleanId;
+					if (cleanId.startsWith(".") && importer) absolutePath = join(dirname(importer.split("?")[0]), cleanId);
+					await ctx.compiler.assets.registerAsset(absolutePath);
+					const cleanQueries = (id.split("?")[1] || "").split("&").filter((q) => !q.startsWith("zintl-multiplex=")).join("&");
+					const suffix = cleanQueries ? `?${cleanQueries}` : "";
+					if (locale === ctx.compiler.sourceLocale) return absolutePath + suffix;
+					const assetId = ctx.compiler.getNormalizedId(absolutePath);
+					if (ctx.options.virtualAssets) return `\0virtual:zintl/asset/${locale}/${assetId}${suffix}`;
+					const localizedPath = ctx.compiler.assets.getAssetPath(assetId, locale);
+					if (existsSync(localizedPath)) return localizedPath + suffix;
+					return absolutePath + suffix;
+				}
+			}
+		}
+		if (ctx.getMultiplex() && id.endsWith(".html")) {
+			const locales = ctx.options.locales;
+			for (const loc of locales) {
+				const pattern = new RegExp(`(^|\\/)${loc}\\/([^\\/]+\\.html)$`);
+				if (pattern.test(id)) {
+					const match = id.match(pattern);
+					if (match) return join(ctx.compiler.rootDir, `${loc}/${match[2]}`);
+				}
+			}
+		}
+		if (importer) {
+			const locale = ctx.getMultiplexLocale(importer);
+			if (locale && !id.includes("zintl-multiplex=") && !id.includes(".zintl-")) {
+				const cleanId = id.split("?")[0];
+				const extMatch = cleanId.match(/\.([a-zA-Z0-9]+)$/);
+				const ext = extMatch ? extMatch[1].toLowerCase() : "";
+				if (!ext || [
+					"js",
+					"jsx",
+					"ts",
+					"tsx",
+					"md",
+					"txt",
+					"vue",
+					"svelte"
+				].includes(ext) || ctx.compiler.assets.isSupportedAsset(cleanId)) {
+					const resolvedClean = await this.resolve(id, importer, {
+						skipSelf: true,
+						ssr: isSsr
+					});
+					if (resolvedClean) {
+						const cleanResolvedId = (typeof resolvedClean === "string" ? resolvedClean : resolvedClean.id).split("?")[0];
+						let isTranslationNeutral = false;
+						if (ctx.compiler?.messages?.metadataGraph) {
+							const startFileId = ctx.compiler.getNormalizedId(cleanResolvedId);
+							const hasActiveZintlTransitive = (fileId, visited = /* @__PURE__ */ new Set()) => {
+								if (typeof fileId !== "string" || visited.has(fileId)) return false;
+								visited.add(fileId);
+								const cleanFileId = fileId.split("?")[0];
+								return (() => {
+									if (ctx.compiler.assets.isSupportedAsset(cleanFileId)) return true;
+									if ((ctx.compiler?.assets?.getRegisteredAssets() || []).some((asset) => asset === cleanFileId || asset.startsWith(cleanFileId + "."))) return true;
+									const meta = ctx.compiler.messages.metadataGraph[cleanFileId];
+									if (meta) {
+										if (meta.hasZintlMarker || meta.hasZintlMacro || meta.anchorSites && meta.anchorSites.length > 0 || meta.needsLoader) return true;
+									}
+									const manifestKeys = Object.keys(ctx.compiler?.messages?.internalManifest || {});
+									for (const key of manifestKeys) if (key === cleanFileId || key.startsWith(cleanFileId + ":")) {
+										const msgs = ctx.compiler.messages.internalManifest[key];
+										if (msgs && msgs.length > 0) return true;
+									}
+									const deps = ctx.compiler.messages.dependencyGraph[cleanFileId];
+									if (deps) for (const dep of deps) {
+										const depId = typeof dep === "string" ? dep : dep?.id;
+										if (depId) {
+											const depFileId = depId.startsWith(".") ? join(dirname(cleanFileId), depId) : depId;
+											const nDepId = ctx.compiler.getNormalizedId(depFileId);
+											if (hasActiveZintlTransitive(nDepId, visited)) return true;
+										}
+									}
+									return false;
+								})();
+							};
+							isTranslationNeutral = !hasActiveZintlTransitive(startFileId);
+						}
+						if (isTranslationNeutral) return resolvedClean;
+					}
+					if (ext === "vue" || ext === "svelte") {
+						const resolved = await this.resolve(id, importer, {
+							skipSelf: true,
+							ssr: isSsr
+						});
+						if (resolved) {
+							const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+							const cleanResolvedId = resolvedId.split("?")[0];
+							const suffix = resolvedId.includes("?") ? "?" + resolvedId.split("?")[1] : "";
+							const finalId = cleanResolvedId.replace(/\.(vue|svelte)$/, `.zintl-${locale}.$1`) + suffix;
+							if (typeof resolved === "string") return finalId;
+							return {
+								...resolved,
+								id: finalId
+							};
+						}
+					} else {
+						const newId = injectMultiplexQuery(id, locale);
+						const resolved = await this.resolve(newId, importer, {
+							skipSelf: true,
+							ssr: isSsr
+						});
+						if (resolved) {
+							const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+							const cleanResolvedId = resolvedId.split("?")[0];
+							if (ctx.compiler.assets.isSupportedAsset(cleanResolvedId)) {
+								await ctx.compiler.assets.registerAsset(cleanResolvedId);
+								if (locale === ctx.compiler.sourceLocale) return resolved;
+								const assetId = ctx.compiler.getNormalizedId(cleanResolvedId);
+								const queries = resolvedId.split("?")[1] || "";
+								const suffix = queries ? `?${queries}` : "";
+								if (ctx.options.virtualAssets) {
+									const finalId = `\0virtual:zintl/asset/${locale}/${assetId}${suffix}`;
+									if (typeof resolved === "string") return finalId;
+									return {
+										...resolved,
+										id: finalId
+									};
+								}
+								const localizedPath = ctx.compiler.assets.getAssetPath(assetId, locale);
+								if (existsSync(localizedPath)) {
+									const finalId = localizedPath + suffix;
+									if (typeof resolved === "string") return finalId;
+									return {
+										...resolved,
+										id: finalId
+									};
+								}
+							}
+							let finalResolvedId = resolvedId;
+							if (!finalResolvedId.includes("zintl-multiplex=")) {
+								finalResolvedId = injectMultiplexQuery(resolvedId, locale);
+								if (typeof resolved === "string") return finalResolvedId;
+								return {
+									...resolved,
+									id: finalResolvedId
+								};
+							}
+							return resolved;
+						}
+					}
+				}
+			}
+		}
+	};
+}
+function loadHook(ctx) {
+	return async function(id, options) {
+		const isSsr = this.environment ? this.environment.config.consumer === "server" : !!options?.ssr;
+		const cleanId = id.split("?")[0];
+		if (cleanId.startsWith("\0virtual:zintl/asset/")) {
+			const rest = cleanId.slice(21);
+			const slashIdx = rest.indexOf("/");
+			if (slashIdx !== -1) {
+				const locale = rest.slice(0, slashIdx);
+				const assetId = rest.slice(slashIdx + 1);
+				const originalPath = join(ctx.compiler.rootDir, assetId);
+				if (existsSync(originalPath)) {
+					this.addWatchFile(originalPath);
+					if (ctx.compiler.assets.resolveAssetConfig(assetId)?.strategy === "binary-passthrough") {
+						const sourceBuffer = readFileSync(originalPath);
+						const sourceHashKey = `@zintl/asset-hash:${sha1(sourceBuffer)}`;
+						const hive = ctx.compiler.messages.hive;
+						const sourceLocale = ctx.options.sourceLocale;
+						let buffer = sourceBuffer;
+						if (locale !== sourceLocale) {
+							const hiveBackup = hive?.[locale]?.[sourceHashKey];
+							if (hiveBackup) buffer = Buffer.from(hiveBackup, "base64");
+						}
+						return `export default import.meta.ROLLUP_FILE_URL_${this.emitFile({
+							type: "asset",
+							name: assetId.split("/").pop(),
+							source: buffer
+						})};`;
+					} else {
+						const content = (await ctx.compiler.assets.getAssetTranslations(locale))[`@zintl/asset:${assetId}`] ?? readFileSync(originalPath, "utf-8");
+						if (id.includes("?raw") || id.includes("?zintl-raw")) {
+							let code = `export default ${JSON.stringify(content)};`;
+							if (ctx.compiler.isDev) code += "\nif (import.meta.hot) { import.meta.hot.accept(); }";
+							return code;
+						}
+						return `export default import.meta.ROLLUP_FILE_URL_${this.emitFile({
+							type: "asset",
+							name: assetId.split("/").pop(),
+							source: content
+						})};`;
+					}
+				}
+			}
+		}
+		if (cleanId.includes(".zintl-") && !id.includes("?vue") && !id.includes("&vue") && !id.includes("?svelte") && !id.includes("&svelte")) {
+			const originalPath = cleanId.replace(/\.zintl-[a-zA-Z0-9_-]+\.(vue|svelte)/, ".$1");
+			if (existsSync(originalPath)) {
+				const content = readFileSync(originalPath, "utf-8");
+				this.addWatchFile(originalPath);
+				return content;
+			}
+		}
+		if (cleanId.startsWith("\0virtual:zintl/runtime")) {
+			const moduleName = cleanId.replace("\0virtual:zintl/runtime/", "").replace("\0virtual:zintl/runtime", "internal");
+			ctx.compiler._logger.withPrefix("Vite").debug(`Loading virtual runtime module: ${moduleName}`);
+			let code = getRuntimeCode(moduleName, ctx.compiler._resolved.flags, isSsr, ctx.compiler.sourceLocale);
+			if (!isSsr) code = code.replace(/await\s+import\(\s*["']node:async_hooks["']\s*\)/g, "null");
+			return code;
+		}
+		if (cleanId.endsWith(".md") || cleanId.endsWith(".txt")) {
+			if (existsSync(cleanId)) {
+				const content = readFileSync(cleanId, "utf-8");
+				const ext = cleanId.endsWith(".md") ? ".md" : ".txt";
+				const translationOnly = ctx.compiler.assets.getTranslationOnly(content, ext);
+				this.addWatchFile(cleanId);
+				if (id.includes("?zintl-raw")) {
+					let code = `export default ${JSON.stringify(translationOnly)};`;
+					if (ctx.compiler.isDev) code += "\nif (import.meta.hot) { import.meta.hot.accept(); }";
+					return code;
+				}
+				const assetId = ctx.compiler.getNormalizedId(cleanId);
+				await ctx.compiler.assets.registerAsset(cleanId);
+				if (id.includes("?raw")) {
+					const multiplexLocale = ctx.getMultiplexLocale(id);
+					const sourceLocale = ctx.options.sourceLocale;
+					if (multiplexLocale) {
+						const localizedPath = multiplexLocale === sourceLocale ? cleanId : ctx.compiler.assets.getAssetPath(assetId, multiplexLocale);
+						const content = existsSync(localizedPath) ? readFileSync(localizedPath, "utf-8") : translationOnly;
+						let code = `export default ${JSON.stringify(content)};`;
+						if (ctx.compiler.isDev) code += "\nif (import.meta.hot) { import.meta.hot.accept(); }";
+						return code;
+					}
+					const locales = ctx.options.locales;
+					for (const loc of locales) {
+						if (loc === sourceLocale) continue;
+						const localizedPath = ctx.compiler.assets.getAssetPath(assetId, loc);
+						if (existsSync(localizedPath)) this.addWatchFile(localizedPath);
+					}
+					const rawAssetKey = `@zintl/asset:${assetId}`;
+					const assetKey = ctx.compiler.isDev ? rawAssetKey : generateMessageId(rawAssetKey);
+					return `
+import { getLocale, _t } from "virtual:zintl/runtime/internal";
+const sourceContent = ${JSON.stringify(translationOnly)};
+const assetKey = ${JSON.stringify(assetKey)};
+const proxy = new Proxy({}, {
+  get(target, prop) {
+    const multiplexLocale = ${JSON.stringify(ctx.getMultiplexLocale(id) || null)};
+    const loc = getLocale() || multiplexLocale || ${JSON.stringify(sourceLocale)};
+    const val = loc === ${JSON.stringify(sourceLocale)}
+      ? sourceContent
+      : (_t(assetKey, {}, { _bId: "b_assets" }) || sourceContent);
+    if (prop === Symbol.toPrimitive) {
+      return () => val;
+    }
+    if (prop === "toString" || prop === "valueOf") {
+      return () => val;
+    }
+    if (prop === "toJSON") {
+      return () => val;
+    }
+    if (typeof val[prop] === "function") {
+      return val[prop].bind(val);
+    }
+    return val[prop];
+  }
+});
+export default proxy;
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}
+`;
+				}
+				return translationOnly;
+			}
+		}
+		if (ctx.getMultiplex() && id.endsWith(".html")) {
+			const locales = ctx.options.locales;
+			let isFanned = false;
+			let matchedLocale = "";
+			let originalHtmlFile = "";
+			for (const loc of locales) {
+				const pattern = new RegExp(`[\\/\\\\]${loc}[\\/\\\\]([^\\/\\\\]+\\.html)$`);
+				const m = id.match(pattern);
+				if (m) {
+					isFanned = true;
+					matchedLocale = loc;
+					originalHtmlFile = m[1];
+					break;
+				}
+			}
+			if (isFanned) {
+				const originalPath = join(ctx.compiler.rootDir, originalHtmlFile);
+				if (existsSync(originalPath)) {
+					let html = readFileSync(originalPath, "utf-8");
+					let dir = matchedLocale === "ar" ? "rtl" : "ltr";
+					try {
+						const catalogPath = ctx.compiler.html.getCatalogPath(originalHtmlFile, matchedLocale);
+						if (existsSync(catalogPath)) {
+							const cat = JSON.parse(readFileSync(catalogPath, "utf-8"));
+							const catalogDir = ctx.compiler.isMultilingualFormat() ? cat.dir?.[matchedLocale] : cat.dir;
+							if (catalogDir !== void 0) dir = catalogDir;
+						}
+					} catch {}
+					html = html.replace(/<html([^>]*)>/i, (m, attrs) => {
+						let newAttrs = attrs;
+						if (!/lang=/i.test(attrs)) newAttrs += ` lang="${matchedLocale}"`;
+						else newAttrs = newAttrs.replace(/lang=["'][^"']*["']/i, `lang="${matchedLocale}"`);
+						if (!/dir=/i.test(attrs)) newAttrs += ` dir="${dir}"`;
+						else newAttrs = newAttrs.replace(/dir=["'][^"']*["']/i, `dir="${dir}"`);
+						return `<html${newAttrs}>`;
+					});
+					html = html.replace(/(<script\s+[^>]*type=["']module["'][^>]*src=["'])([^"']*)(["'])/gi, (m, prefix, src, suffix) => {
+						if (src.includes("node_modules") || src.startsWith("http") || src.startsWith("//")) return m;
+						return `${prefix}${injectMultiplexQuery(src, matchedLocale)}${suffix}`;
+					});
+					return html;
+				}
+			} else if (!id.replace(/\\/g, "/").includes("node_modules")) {
+				if (existsSync(id)) {
+					let html = readFileSync(id, "utf-8");
+					html = html.replace(/<script[^>]*src=["'][^"']*(src\/main\.ts|main\.ts)["'][^>]*>([\s\S]*?)<\/script>/gi, "");
+					return html;
+				}
+			}
+		}
+		const vLogger = ctx.compiler._logger.withPrefix("Vite");
+		if (cleanId.startsWith("\0virtual:zintl-catalog")) {
+			const boundaryId = cleanId.slice(23);
+			vLogger.debug(`Loading legacy virtual catalog: ${boundaryId}`);
+			const { code, watchedFiles } = await ctx.compiler.generateVirtualModule(boundaryId);
+			for (const path of watchedFiles) this.addWatchFile(path);
+			return code;
+		}
+		if (cleanId.startsWith("\0virtual:zintl/catalog")) {
+			const prefix = CHUNK_VIRTUAL_PREFIX;
+			const match = cleanId.slice(1).match(new RegExp(`^${prefix}/([^:]+):(.+)$`));
+			if (match) {
+				const [, chunkType, chunkId] = match;
+				vLogger.debug(`Loading chunk [${chunkType}]: ${chunkId}`);
+				const fullModuleId = `${chunkType}:${chunkId}`;
+				const { code, watchedFiles } = await ctx.compiler.generateVirtualModule(fullModuleId);
+				for (const path of watchedFiles) this.addWatchFile(path);
+				return code;
+			}
+		}
+		if (cleanId.startsWith("\0virtual:zintl/content")) {
+			const prefix = CONTENT_VIRTUAL_PREFIX;
+			const match = cleanId.slice(1).match(new RegExp(`^${prefix}/([^/]+)/([^:]+):(.+)$`));
+			if (match) {
+				const [, locale, chunkType, chunkId] = match;
+				vLogger.debug(`Loading content [${locale}] for [${chunkType}]: ${chunkId}`);
+				const fullModuleId = `${chunkType}:${chunkId}`;
+				const { code, watchedFiles } = await ctx.compiler.generateVirtualModule(fullModuleId, locale);
+				for (const path of watchedFiles) this.addWatchFile(path);
+				return code;
+			}
+		}
+		if (cleanId.startsWith("\0virtual:zintl/manager")) {
+			const prefix = MANAGER_VIRTUAL_PREFIX;
+			const match = cleanId.slice(1).match(new RegExp(`^${prefix}/([^/]+)/([^:]+):(.+)$`));
+			if (match) {
+				const [, syncLocale, chunkType, chunkId] = match;
+				const locale = syncLocale === "none" ? void 0 : syncLocale;
+				vLogger.debug(`Loading manager [${syncLocale}] for [${chunkType}]: ${chunkId}`);
+				const fullModuleId = `${chunkType}:${chunkId}`;
+				const { code, watchedFiles } = await ctx.compiler.generateVirtualModule(fullModuleId, locale, true);
+				for (const path of watchedFiles) this.addWatchFile(path);
+				return code;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/hooks/transform.ts
+function transformHook(ctx) {
+	return async function(code, id, options) {
+		const isSsr = this && this.environment ? this.environment.config.consumer === "server" : !!options?.ssr;
+		const vLogger = ctx.compiler._logger.withPrefix("Vite");
+		if (ctx.server && !ctx.discovered) {
+			ctx.discovered = true;
+			try {
+				await ctx.compiler.discover();
+			} catch (err) {
+				if (err.code !== "ENOENT") throw err;
+			}
+		}
+		const isTargetSsrEntry = ctx.compiler?.isSsrEntryTarget?.(id);
+		if (id.includes("node_modules") && !isTargetSsrEntry || id.startsWith("\0") && !isTargetSsrEntry || id.includes("?vue") || id.includes("&vue") || id.includes("?svelte") || id.includes("&svelte") || id.includes("?") && !id.includes("zintl-multiplex=")) return;
+		const multiplexLocale = ctx.getMultiplexLocale(id);
+		const cleanId = id.split("?")[0];
+		const result = await ctx.compiler.transform(code, cleanId, VIRTUAL_PREFIX, false, multiplexLocale, isSsr);
+		const mg = this && this.environment ? this.environment.moduleGraph : ctx.server?.moduleGraph;
+		if (mg && !id.startsWith("\0")) {
+			const boundaryId = ctx.compiler.getNormalizedId(id);
+			const affectedChunkIds = ctx.compiler.getAffectedChunks(boundaryId);
+			if (affectedChunkIds.length > 0) {
+				vLogger.debug(`Invalidating ${affectedChunkIds.length} affected chunks for ${boundaryId}`);
+				for (const chunkModuleId of affectedChunkIds) for (const [modId, mod] of mg.idToModuleMap) if (modId.includes(chunkModuleId) && modId.includes("virtual:zintl")) {
+					vLogger.debug(`[HMR] Invalidating virtual module: ${modId}`);
+					mg.invalidateModule(mod);
+				}
+			}
+		}
+		return result;
+	};
+}
+function transformIndexHtmlHook(ctx) {
+	return {
+		order: "post",
+		async handler(html, viteCtx) {
+			let htmlId = viteCtx.filename || viteCtx.path || "";
+			if (viteCtx.path) {
+				const pathParts = viteCtx.path.split("/").filter(Boolean);
+				const locales = ctx.options.locales;
+				const foundLocale = pathParts.find((p) => locales.includes(p));
+				if (foundLocale) {
+					const pathName = pathParts.filter((p) => p !== foundLocale).join("/");
+					const baseName = pathName ? pathName.endsWith(".html") ? pathName : `${pathName}/index.html` : "index.html";
+					htmlId = join(dirname(htmlId), foundLocale, baseName);
+				}
+			}
+			const normalizedPath = htmlId.replace(/\\/g, "/");
+			const parts = normalizedPath.split("?")[0].split("/");
+			const locales = ctx.options.locales;
+			const isFanned = parts.some((p) => locales.includes(p)) || normalizedPath.includes("virtual:zintl-multiplex-html");
+			if (ctx.getMultiplex() && !isFanned) return html;
+			const preloads = {};
+			const base = viteCtx.server?.config?.base || "";
+			if (viteCtx.bundle) {
+				for (const [fileName, chunk] of Object.entries(viteCtx.bundle)) if (chunk.type === "chunk") for (const modId of chunk.moduleIds) {
+					const match = modId.match(/virtual:zintl\/content\/([^/]+)\//);
+					if (match) {
+						const locale = match[1];
+						if (!preloads[locale]) preloads[locale] = [];
+						const url = `${base}${fileName}`;
+						if (!preloads[locale].includes(url)) preloads[locale].push(url);
+					}
+				}
+			}
+			return await ctx.compiler.transformHtml(html, htmlId, preloads);
+		}
+	};
+}
+function preTransformIndexHtmlHook(ctx) {
+	return {
+		order: "pre",
+		handler(html, viteCtx) {
+			const normalizedPath = (viteCtx.filename || viteCtx.path || "").replace(/\\/g, "/");
+			const parts = normalizedPath.split("?")[0].split("/");
+			const locales = ctx.options.locales;
+			const pathParts = (viteCtx.path || "").split("/").filter(Boolean);
+			const isFanned = parts.some((p) => locales.includes(p)) || pathParts.some((p) => locales.includes(p)) || normalizedPath.includes("virtual:zintl-multiplex-html");
+			if (ctx.getMultiplex() && !isFanned) {
+				const localesStr = JSON.stringify(locales);
+				const defaultLocale = ctx.options.sourceLocale;
+				return `<!doctype html>
+<html lang="${defaultLocale}">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Redirecting...</title>
+    <script id="zintl-multiplex-redirect">
+      (function() {
+        try {
+          const lang = (navigator.language || '${defaultLocale}').split('-')[0];
+          const supported = ${localesStr};
+          const parts = window.location.pathname.split('/').filter(Boolean);
+          if (parts.length > 0 && supported.includes(parts[0])) return;
+          const target = supported.includes(lang) ? lang : '${defaultLocale}';
+          const path = window.location.pathname.replace(/^/+/, '');
+          window.location.replace('/' + target + '/' + path + window.location.search + window.location.hash);
+        } catch (e) {
+          const supported = ${localesStr};
+          const parts = window.location.pathname.split('/').filter(Boolean);
+          if (parts.length > 0 && supported.includes(parts[0])) return;
+          const path = window.location.pathname.replace(/^/+/, '');
+          window.location.replace('/${defaultLocale}/' + path);
+        }
+      })();
+    <\/script>
+  </head>
+  <body>
+  </body>
+</html>`;
+			}
+			return html;
+		}
+	};
+}
+//#endregion
+//#region src/hooks/hmr.ts
+function handleHotUpdateHook(ctx) {
+	return async function({ file, server, modules, timestamp }) {
+		const vLogger = ctx.compiler._logger.withPrefix("Vite");
+		if (ctx.compiler.isWritingFile(file)) return;
+		const isSource = /\.(ts|tsx|js|jsx|html|vue|svelte)$/.test(file);
+		const isJson = file.endsWith(".json");
+		const isAsset = file.endsWith(".md") || file.endsWith(".txt");
+		if (!isJson && !isSource && !isAsset) return;
+		vLogger.debug(`HMR triggered for ${file}`);
+		const invalidatedModules = /* @__PURE__ */ new Set();
+		let invalidatedBoundaries = [];
+		const mg = this && this.environment ? this.environment.moduleGraph : server.moduleGraph;
+		const invalidate = (mod) => {
+			mg.invalidateModule(mod);
+			if (timestamp !== void 0) mod.lastHMRTimestamp = timestamp;
+			invalidatedModules.add(mod);
+		};
+		if (isJson || isAsset) {
+			if (isAsset) await ctx.compiler.assets.registerAsset(file);
+			const inv = await ctx.compiler.invalidateFile(file, true);
+			for (const b of inv) invalidatedBoundaries.push(b);
+			if (inv.length === 0 && isJson) {
+				for (const [id, mod] of mg.idToModuleMap) if (id.includes("virtual:zintl") && id.includes("/manager/")) invalidate(mod);
+			}
+		} else {
+			const inv = await ctx.compiler.invalidateFile(file);
+			for (const b of inv) invalidatedBoundaries.push(b);
+		}
+		ctx.compiler.flush().catch((e) => vLogger.error(`Background flush failed: ${String(e)}`));
+		for (const mod of modules) {
+			const isBaseJson = isJson && mod.file === file;
+			const isBaseAsset = isAsset && mod.file === file && !mod.id?.includes("?");
+			if (isBaseJson || isBaseAsset) continue;
+			invalidate(mod);
+			if (!isSource && mod.importers) {
+				for (const importer of mod.importers) if (importer.id && !importer.id.includes("node_modules")) invalidate(importer);
+			}
+		}
+		const boundaryIds = new Set(invalidatedBoundaries);
+		if (isSource) boundaryIds.add(ctx.compiler.getNormalizedId(file));
+		for (const boundaryId of boundaryIds) {
+			if (boundaryId === "b_assets" && ctx.compiler.graph.boundaryGraph) {
+				for (const [_nid, n] of ctx.compiler.graph.boundaryGraph.nodes.entries()) if (n.mode === "entry" && n.filePath && n.filePath !== "assets") {
+					const relPath = n.filePath.startsWith("/") ? n.filePath : "/" + n.filePath;
+					for (const [id, mod] of mg.idToModuleMap) {
+						const normalizedId = id.split("?")[0];
+						const idNoExt = normalizedId.replace(/\.[a-z0-9]+$/i, "");
+						if (id === relPath || id === n.filePath || normalizedId.endsWith(n.filePath) || idNoExt.endsWith(n.filePath)) invalidate(mod);
+					}
+				}
+			}
+			const affectedChunkIds = ctx.compiler.getAffectedChunks(boundaryId);
+			for (const chunkModuleId of affectedChunkIds) for (const [id, mod] of mg.idToModuleMap) if (id.includes(chunkModuleId) && id.includes("virtual:zintl")) invalidate(mod);
+			let node = ctx.compiler.graph.boundaryGraph?.nodes.get(boundaryId);
+			if (!node) {
+				for (const [_nid, n] of ctx.compiler.graph.boundaryGraph?.nodes.entries() || []) if (ctx.compiler.io.getSafeBoundaryId(_nid) === boundaryId) {
+					node = n;
+					break;
+				}
+			}
+			const fileId = node?.filePath || (boundaryId.includes(":") ? boundaryId.split(":")[0] : boundaryId);
+			if (fileId && fileId !== "assets" && !fileId.includes("\0")) {
+				const absFileId = isAbsolute(fileId) ? fileId : join(ctx.compiler.rootDir, fileId);
+				if (typeof mg.getModulesByFile === "function") {
+					const sourceMods = mg.getModulesByFile(absFileId);
+					if (sourceMods && (sourceMods instanceof Set ? sourceMods.size > 0 : Array.isArray(sourceMods) && sourceMods.length > 0)) for (const mod of sourceMods) invalidate(mod);
+				}
+				const virtualId = `${RESOLVED_VIRTUAL_PREFIX}:${fileId}`;
+				if (typeof mg.getModuleById === "function") {
+					const vMod = mg.getModuleById(virtualId);
+					if (vMod) invalidate(vMod);
+				}
+				const relPath = fileId.startsWith("/") ? fileId : "/" + fileId;
+				const fileIdNoExt = fileId.replace(/\.[a-z0-9]+$/i, "");
+				const relPathNoExt = relPath.replace(/\.[a-z0-9]+$/i, "");
+				for (const [id, mod] of mg.idToModuleMap) {
+					const cleanModuleId = id.replace(/\.zintl-[a-zA-Z0-9_-]+\.(vue|svelte)/, ".$1");
+					const normalizedId = cleanModuleId.split("?")[0];
+					const normalizedIdNoExt = normalizedId.replace(/\.[a-z0-9]+$/i, "");
+					if ((cleanModuleId === relPath || cleanModuleId === fileId || cleanModuleId.endsWith(fileId) || normalizedId.endsWith(fileId) || normalizedId === relPath || normalizedId === fileId || normalizedIdNoExt === fileIdNoExt || normalizedIdNoExt === relPathNoExt || normalizedIdNoExt.endsWith(fileIdNoExt)) && !id.includes("virtual:zintl")) {
+						const absFileId = isAbsolute(fileId) ? fileId : join(ctx.compiler.rootDir, fileId);
+						if (mod.file !== absFileId) {
+							if (mg.fileToModulesMap) {
+								const map = mg.fileToModulesMap;
+								const hasGet = typeof map.get === "function";
+								const hasSet = typeof map.set === "function";
+								if (mod.file) if (hasGet) {
+									const oldSet = map.get(mod.file);
+									if (oldSet) oldSet.delete(mod);
+								} else {
+									const oldSet = map[mod.file];
+									if (oldSet) oldSet.delete(mod);
+								}
+								if (hasGet && hasSet) {
+									let set = map.get(absFileId);
+									if (!set) {
+										set = /* @__PURE__ */ new Set();
+										map.set(absFileId, set);
+									}
+									set.add(mod);
+								} else if (!hasGet && !hasSet) {
+									let set = map[absFileId];
+									if (!set) {
+										set = /* @__PURE__ */ new Set();
+										map[absFileId] = set;
+									}
+									set.add(mod);
+								}
+							}
+							mod.file = absFileId;
+						}
+						invalidate(mod);
+					}
+				}
+			}
+			if (boundaryId.endsWith(".html")) server.ws.send({
+				type: "full-reload",
+				path: "*"
+			});
+		}
+		let hasServerOnlyUpdate = false;
+		for (const boundaryId of boundaryIds) {
+			const isSsr = ctx.compiler.ssrBoundaries?.has(boundaryId);
+			const isClient = ctx.compiler.clientBoundaries?.has(boundaryId);
+			if (isSsr && !isClient) {
+				hasServerOnlyUpdate = true;
+				break;
+			}
+		}
+		if (hasServerOnlyUpdate) {
+			vLogger.debug("Server-only boundary update detected, triggering full-reload");
+			server.ws.send({
+				type: "full-reload",
+				path: "*"
+			});
+		}
+		if (invalidatedModules.size > 0) return Array.from(invalidatedModules);
+		return modules;
+	};
+}
+//#endregion
+//#region src/hooks/build.ts
+function buildStartHook(ctx) {
+	return async function() {
+		ctx.compiler._logger.withPrefix("Vite").debug("Build starting...");
+		await ctx.compiler.setup();
+		if (!ctx.server) {
+			await ctx.compiler.discover();
+			ctx.discovered = true;
+		}
+	};
+}
+function buildEndHook(ctx) {
+	return async function() {
+		await ctx.compiler.flush();
+	};
+}
+//#endregion
+//#region src/options.ts
+/**
+* Every context-free default, in one table.
+*
+* `outputDir`, `catalogFormat`, `metadataDir` and `similarityThreshold` are
+* intentionally absent: the compiler owns those defaults (`DEFAULT_OUTPUT_DIR`,
+* the catalog format fallback, `node_modules/.zintl`, `DEFAULT_RENAME_THRESHOLD`)
+* and re-stating them here would recreate the duplication this file exists to
+* remove. Leaving them `undefined` lets the compiler apply its own.
+*/
+const DEFAULTS = {
+	sourceLocale: "en",
+	locales: ["en"],
+	prune: true,
+	debug: false,
+	virtualAssets: false,
+	facets: ["auto"],
+	/** `undefined` → auto-detect by scanning entry files for `zintl()` / `zintl("*")`. */
+	multiplex: void 0,
+	/** `undefined` → `true` for `vite build`, `false` for `vite serve`. */
+	verifyIntegrity: void 0,
+	/** `undefined` → fall back to Vite's own `logLevel`, then `"info"`. */
+	logLevel: void 0
+};
+function resolveOptions(options) {
+	const o = options ?? {};
+	return {
+		...o,
+		sourceLocale: o.sourceLocale ?? DEFAULTS.sourceLocale,
+		locales: o.locales ?? [...DEFAULTS.locales],
+		prune: o.prune ?? DEFAULTS.prune,
+		debug: o.debug ?? DEFAULTS.debug,
+		virtualAssets: o.virtualAssets ?? DEFAULTS.virtualAssets,
+		facets: o.facets ?? [...DEFAULTS.facets]
+	};
+}
+//#endregion
+//#region src/plugin.ts
+const contextMap = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/vite.ts
+/**
+* @module zintl/vite
+*
+* The Vite plugin, and the public types for configuring it.
+*/
+/**
+* The Zintl Vite plugin.
+*
+* Add it once, and Zintl takes over internationalization from there: it
+* extracts the strings reachable from every `zintl()` anchor, writes a catalog
+* per locale into {@link Options.outputDir | `outputDir`}, splits those catalogs
+* along your bundler's own code-splitting boundaries, and rewrites the macros
+* into a runtime with no message parser shipped to the client.
+*
+* Returns two Vite plugins — a `pre` pass that localizes HTML entries before
+* anything else touches them, and the main `zintl` plugin. Pass the array
+* straight to `plugins`; Vite flattens it.
+*
+* Catalogs are written for you but owned by you: edit them, commit them, hand
+* them to translators. Renamed and lightly edited source strings carry their
+* translations forward instead of resetting (see
+* {@link Options.similarityThreshold | `similarityThreshold`}).
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { defineConfig } from "vite";
+* import zintl from "zintljs/vite";
+*
+* export default defineConfig({
+*   plugins: [
+*     zintl({
+*       sourceLocale: "en",
+*       locales: ["en", "ar", "fr"],
+*       outputDir: "./src/locales",
+*     }),
+*   ],
+* });
+* ```
+*
+* @see {@link Options} for every option and its default.
+*/
+const vite = createUnplugin((options) => {
+	const resolved = resolveOptions(options);
+	const ctx = new Context(resolved);
+	contextMap.set(resolved, ctx);
+	if (typeof globalThis !== "undefined") {
+		const activeContexts = globalThis;
+		activeContexts.__zintl_active_contexts = activeContexts.__zintl_active_contexts || [];
+		activeContexts.__zintl_active_contexts.push(ctx);
+	}
+	return [{
+		name: "zintl-pre",
+		vite: {
+			enforce: "pre",
+			transformIndexHtml: preTransformIndexHtmlHook(ctx)
+		}
+	}, {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		buildStart() {
+			return buildStartHook(ctx).call(this);
+		},
+		resolveId(id, importer, options) {
+			return resolveIdHook(ctx).call(this, id, importer, options);
+		},
+		load(id) {
+			return loadHook(ctx).call(this, id);
+		},
+		transform(code, id) {
+			return transformHook(ctx).call(this, code, id);
+		},
+		buildEnd() {
+			return buildEndHook(ctx).call(this);
+		},
+		vite: {
+			config: configHook(ctx),
+			configResolved: configResolvedHook(ctx),
+			configureServer: configureServerHook(ctx),
+			transformIndexHtml: transformIndexHtmlHook(ctx),
+			handleHotUpdate: handleHotUpdateHook(ctx),
+			hotUpdate: handleHotUpdateHook(ctx)
+		}
+	}];
+}).vite;
+//#endregion
+export { vite as default, vite as "module.exports" };