npm - @module-federation/vite - Versions diffs - 1.11.0 → 1.11.1 - Mend

@module-federation/vite 1.11.0 → 1.11.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (47) hide show

package/README.md +4 -1
package/lib/index.cjs +1813 -2102
package/lib/index.d.cts +131 -0
package/lib/index.d.mts +131 -0
package/lib/index.mjs +1946 -0
package/package.json +29 -18
package/lib/index.d.ts +0 -4
package/lib/index.esm.js +0 -2236
package/lib/index.modern.js +0 -2288
package/lib/index.umd.js +0 -2257
package/lib/plugins/__tests__/pluginCheckAliasConflicts.test.d.ts +0 -1
package/lib/plugins/__tests__/pluginDts.test.d.ts +0 -1
package/lib/plugins/pluginAddEntry.d.ts +0 -10
package/lib/plugins/pluginCheckAliasConflicts.d.ts +0 -9
package/lib/plugins/pluginDevProxyModuleTopLevelAwait.d.ts +0 -2
package/lib/plugins/pluginDts.d.ts +0 -3
package/lib/plugins/pluginMFManifest.d.ts +0 -3
package/lib/plugins/pluginModuleParseEnd.d.ts +0 -10
package/lib/plugins/pluginProxyRemoteEntry.d.ts +0 -2
package/lib/plugins/pluginProxyRemotes.d.ts +0 -3
package/lib/plugins/pluginProxySharedModule_preBuild.d.ts +0 -7
package/lib/plugins/pluginVarRemoteEntry.d.ts +0 -3
package/lib/utils/PromiseStore.d.ts +0 -16
package/lib/utils/VirtualModule.d.ts +0 -26
package/lib/utils/__tests__/VirtualModule.test.d.ts +0 -1
package/lib/utils/__tests__/cssModuleHelpers.test.d.ts +0 -1
package/lib/utils/__tests__/helpers.d.ts +0 -2
package/lib/utils/__tests__/normalizeModuleFederationOption.test.d.ts +0 -1
package/lib/utils/__tests__/publicPath.test.d.ts +0 -1
package/lib/utils/__tests__/serializeRuntimeOptions.test.d.ts +0 -1
package/lib/utils/aliasToArrayPlugin.d.ts +0 -10
package/lib/utils/bundleHelpers.d.ts +0 -2
package/lib/utils/cssModuleHelpers.d.ts +0 -75
package/lib/utils/localSharedImportMap_temp.d.ts +0 -2
package/lib/utils/mapCodeToCodeWithSourcemap.d.ts +0 -4
package/lib/utils/normalizeModuleFederationOptions.d.ts +0 -164
package/lib/utils/normalizeOptimizeDeps.d.ts +0 -9
package/lib/utils/packageNameUtils.d.ts +0 -22
package/lib/utils/publicPath.d.ts +0 -9
package/lib/utils/serializeRuntimeOptions.d.ts +0 -10
package/lib/utils/wrapManualChunks.d.ts +0 -1
package/lib/virtualModules/index.d.ts +0 -6
package/lib/virtualModules/virtualExposes.d.ts +0 -2
package/lib/virtualModules/virtualRemoteEntry.d.ts +0 -16
package/lib/virtualModules/virtualRemotes.d.ts +0 -6
package/lib/virtualModules/virtualRuntimeInitStatus.d.ts +0 -3
package/lib/virtualModules/virtualShared_preBuild.d.ts +0 -17

package/lib/index.mjs ADDED Viewed

@@ -0,0 +1,1946 @@
+import { createRequire } from "node:module";
+import defu from "defu";
+import * as fs from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFile, writeFileSync } from "fs";
+import * as path$1 from "pathe";
+import path, { basename, dirname, join, parse, resolve } from "pathe";
+import MagicString from "magic-string";
+import { createFilter } from "@rollup/pluginutils";
+import { walk } from "estree-walker";
+import { normalizeOptions } from "@module-federation/sdk";
+import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
+import { rpc } from "@module-federation/dts-plugin/core";
+import { fileURLToPath } from "url";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/utils/mapCodeToCodeWithSourcemap.ts
+async function mapCodeToCodeWithSourcemap(code) {
+	const resolvedCode = await code;
+	if (resolvedCode === void 0) return;
+	const s = new MagicString(resolvedCode);
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: true })
+	};
+}
+//#endregion
+//#region src/plugins/pluginAddEntry.ts
+function getFirstHtmlEntryFile(entryFiles) {
+	return entryFiles.find((file) => file.endsWith(".html"));
+}
+const addEntry = ({ entryName, entryPath, fileName, inject = "entry" }) => {
+	let devEntryPath = entryPath.startsWith("virtual:mf") ? "@id/" + entryPath : entryPath;
+	let entryFiles = [];
+	let htmlFilePath;
+	let _command;
+	let emitFileId;
+	let viteConfig;
+	function injectHtml() {
+		return inject === "html" && htmlFilePath;
+	}
+	function injectEntry() {
+		return inject === "entry" || !htmlFilePath;
+	}
+	return [{
+		name: "add-entry",
+		apply: "serve",
+		config(config, { command }) {
+			_command = command;
+		},
+		configResolved(config) {
+			viteConfig = config;
+			devEntryPath = config.base + devEntryPath.replace(/\\\\?/g, "/").replace(/.+?\:([/\\])[/\\]?/, "$1").replace(/^\//, "");
+		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (!fileName) {
+					next();
+					return;
+				}
+				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) req.url = devEntryPath;
+				next();
+			});
+		},
+		transformIndexHtml(c) {
+			if (!injectHtml()) return;
+			return c.replace("<head>", `<head><script type="module" src=${JSON.stringify(devEntryPath.replace(/.+?\:([/\\])[/\\]?/, "$1").replace(/\\\\?/g, "/"))}><\/script>`);
+		},
+		transform(code, id) {
+			if (id.includes("node_modules") || inject !== "html" || htmlFilePath) return;
+			if (id.includes(".svelte-kit") && id.includes("internal.js")) {
+				const src = devEntryPath.replace(/.+?\:([/\\])[/\\]?/, "$1").replace(/\\\\?/g, "/");
+				return code.replace(/<head>/g, "<head><script type=\\\"module\\\" src=\\\"" + src + "\\\"><\/script>");
+			}
+		}
+	}, {
+		name: "add-entry",
+		enforce: "post",
+		configResolved(config) {
+			viteConfig = config;
+			const inputOptions = config.build.rollupOptions.input;
+			if (!inputOptions) htmlFilePath = path$1.resolve(config.root, "index.html");
+			else if (typeof inputOptions === "string") entryFiles = [inputOptions];
+			else if (Array.isArray(inputOptions)) entryFiles = inputOptions;
+			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions);
+			if (entryFiles && entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
+		},
+		buildStart() {
+			if (_command === "serve") return;
+			const hasHash = fileName?.includes?.("[hash");
+			const emitFileOptions = {
+				name: entryName,
+				type: "chunk",
+				id: entryPath,
+				preserveSignature: "strict"
+			};
+			if (!hasHash) emitFileOptions.fileName = fileName;
+			emitFileId = this.emitFile(emitFileOptions);
+			if (htmlFilePath && fs.existsSync(htmlFilePath)) {
+				const htmlContent = fs.readFileSync(htmlFilePath, "utf-8");
+				const scriptRegex = /<script\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
+				let match;
+				while ((match = scriptRegex.exec(htmlContent)) !== null) entryFiles.push(match[1]);
+			}
+		},
+		generateBundle(options, bundle) {
+			if (!injectHtml()) return;
+			const file = this.getFileName(emitFileId);
+			const resolvePath = (htmlFileName) => {
+				if (!viteConfig.experimental?.renderBuiltUrl) return viteConfig.base + file;
+				const result = viteConfig.experimental.renderBuiltUrl(file, {
+					hostId: htmlFileName,
+					hostType: "html",
+					type: "asset",
+					ssr: false
+				});
+				if (typeof result === "string") return result;
+				if (result && typeof result === "object") {
+					if ("runtime" in result) {
+						console.warn("[vite-plugin-federation] renderBuiltUrl returned runtime code for HTML injection. Runtime code cannot be used in <script src=\"\">. Falling back to base path.");
+						return viteConfig.base + file;
+					}
+					if (result.relative) return file;
+				}
+				return viteConfig.base + file;
+			};
+			for (const fileName in bundle) if (fileName.endsWith(".html")) {
+				let htmlAsset = bundle[fileName];
+				if (htmlAsset.type === "chunk") return;
+				const scriptContent = `
+          <script type="module" src="${resolvePath(fileName)}"><\/script>
+        `;
+				let htmlContent = htmlAsset.source.toString() || "";
+				htmlContent = htmlContent.replace("<head>", `<head>${scriptContent}`);
+				htmlAsset.source = htmlContent;
+			}
+		},
+		transform(code, id) {
+			if (injectEntry() && entryFiles.some((file) => id.endsWith(file))) return mapCodeToCodeWithSourcemap(`
+          import ${JSON.stringify(entryPath)};
+          ` + code);
+		}
+	}];
+};
+//#endregion
+//#region src/plugins/pluginCheckAliasConflicts.ts
+/**
+* Check if user-defined alias conflicts with shared modules
+* This should run after aliasToArrayPlugin to ensure alias is an array
+*/
+function checkAliasConflicts(options) {
+	const { shared = {} } = options;
+	const sharedKeys = Object.keys(shared);
+	return {
+		name: "check-alias-conflicts",
+		configResolved(config) {
+			if (sharedKeys.length === 0) return;
+			const userAliases = config.resolve?.alias || [];
+			const conflicts = [];
+			for (const sharedKey of sharedKeys) for (const aliasEntry of userAliases) {
+				const findPattern = aliasEntry.find;
+				const replacement = aliasEntry.replacement;
+				if (typeof replacement !== "string") continue;
+				if (replacement === "$1") continue;
+				let isMatch = false;
+				if (typeof findPattern === "string") isMatch = findPattern === sharedKey || sharedKey.startsWith(findPattern + "/");
+				else if (findPattern instanceof RegExp) isMatch = findPattern.test(sharedKey);
+				if (isMatch) conflicts.push({
+					sharedModule: sharedKey,
+					alias: String(findPattern),
+					target: replacement
+				});
+			}
+			if (conflicts.length > 0) {
+				config.logger.warn("\n[Module Federation] Detected alias conflicts with shared modules:");
+				conflicts.forEach(({ sharedModule, alias, target }) => {
+					config.logger.warn(`  - Shared module "${sharedModule}" is aliased by "${alias}" to "${target}"`);
+				});
+				config.logger.warn("  This may cause runtime errors as the shared module will bypass Module Federation's sharing mechanism.");
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/pluginDevProxyModuleTopLevelAwait.ts
+/**
+* Solve the problem that dev mode dependency prebunding does not support top-level await syntax
+*/
+function PluginDevProxyModuleTopLevelAwait() {
+	const filterFunction = createFilter();
+	const processedFlag = "/* already-processed-by-dev-proxy-module-top-level-await */";
+	return {
+		name: "dev-proxy-module-top-level-await",
+		apply: "serve",
+		transform(code, id) {
+			if (code.includes(processedFlag)) return null;
+			if (!code.includes("/*mf top-level-await placeholder replacement mf*/")) return null;
+			if (!filterFunction(id)) return null;
+			let ast;
+			try {
+				ast = this.parse(code, { allowReturnOutsideFunction: true });
+			} catch (e) {
+				throw new Error(`${id}: ${e}`);
+			}
+			const magicString = new MagicString(code);
+			walk(ast, { enter(node) {
+				if (node.type === "ExportNamedDeclaration" && node.specifiers) {
+					const exportSpecifiers = node.specifiers.map((specifier) => specifier.exported.name);
+					const proxyStatements = exportSpecifiers.map((name) => `
+              const __mfproxy__await${name} = await ${name}();
+              const __mfproxy__${name} = () => __mfproxy__await${name};
+            `).join("\n");
+					const exportStatements = exportSpecifiers.map((name) => `__mfproxy__${name} as ${name}`).join(", ");
+					const start = node.start;
+					const end = node.end;
+					const replacement = `${proxyStatements}\nexport { ${exportStatements} };`;
+					magicString.overwrite(start, end, replacement);
+				}
+				if (node.type === "ExportDefaultDeclaration") {
+					const declaration = node.declaration;
+					const start = node.start;
+					const end = node.end;
+					let proxyStatement;
+					let exportStatement = "default";
+					if (declaration.type === "Identifier") proxyStatement = `
+                const __mfproxy__awaitdefault = await ${declaration.name}();
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+					else if (declaration.type === "CallExpression" || declaration.type === "FunctionDeclaration") proxyStatement = `
+                const __mfproxy__awaitdefault = await (${code.slice(declaration.start, declaration.end)});
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+					else proxyStatement = `
+                const __mfproxy__awaitdefault = await (${code.slice(declaration.start, declaration.end)});
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+					const replacement = `${proxyStatement}\nexport { __mfproxy__default as ${exportStatement} };`;
+					magicString.overwrite(start, end, replacement);
+				}
+			} });
+			return {
+				code: `${processedFlag}\n${magicString.toString()}`,
+				map: magicString.generateMap({ hires: true })
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugins/pluginDts.ts
+const DEFAULT_DEV_OPTIONS = {
+	disableLiveReload: true,
+	disableHotTypesReload: false,
+	disableDynamicRemoteTypeHints: false
+};
+const DYNAMIC_HINTS_PLUGIN = "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin";
+const getIPv4 = () => process.env["FEDERATION_IPV4"] || "127.0.0.1";
+const forkDevWorkerPath = __require.resolve("@module-federation/dts-plugin/dist/fork-dev-worker.js");
+var DevWorker = class {
+	constructor(options) {
+		this.worker = rpc.createRpcWorker(forkDevWorkerPath, {}, void 0, false);
+		this.worker.connect(options);
+	}
+	update() {
+		this.worker.process?.send?.({
+			type: rpc.RpcGMCallTypes.CALL,
+			id: this.worker.id,
+			args: [void 0, "update"]
+		});
+	}
+	exit() {
+		this.worker.terminate();
+	}
+};
+const normalizeDevOptions = (dev) => {
+	if (dev === false) return false;
+	if (dev === true || typeof dev === "undefined") return { ...DEFAULT_DEV_OPTIONS };
+	return {
+		...DEFAULT_DEV_OPTIONS,
+		...dev
+	};
+};
+const buildDtsModuleFederationConfig = (options) => {
+	const exposes = {};
+	Object.entries(options.exposes).forEach(([key, value]) => {
+		if (typeof value === "string") {
+			exposes[key] = value;
+			return;
+		}
+		const importValue = Array.isArray(value.import) ? value.import[0] : value.import;
+		if (importValue) exposes[key] = importValue;
+	});
+	const remotes = {};
+	Object.entries(options.remotes).forEach(([key, remote]) => {
+		if (typeof remote === "string") {
+			remotes[key] = remote;
+			return;
+		}
+		if (!remote.entry) return;
+		remotes[key] = `${remote.entryGlobalName?.startsWith("http") || remote.entryGlobalName?.includes(".json") ? remote.name || key : remote.entryGlobalName || remote.name || key}@${remote.entry}`;
+	});
+	return {
+		...options,
+		exposes,
+		remotes
+	};
+};
+const resolveOutputDir = (config) => {
+	const { outDir } = config.build;
+	if (path$1.isAbsolute(outDir)) return path$1.relative(config.root, outDir);
+	return outDir;
+};
+const ensureRuntimePlugin = (options, pluginId) => {
+	if (!options.runtimePlugins.some((plugin) => {
+		if (typeof plugin === "string") return plugin === pluginId;
+		return plugin[0] === pluginId;
+	})) options.runtimePlugins.push(pluginId);
+};
+const normalizeDevDtsOptions = (dts, context) => {
+	return normalizeOptions(isTSProject(dts, context), {
+		generateTypes: { compileInChildProcess: true },
+		consumeTypes: { consumeAPITypes: true },
+		extraOptions: {},
+		displayErrorInTerminal: typeof dts === "object" && dts ? dts.displayErrorInTerminal : void 0
+	}, "mfOptions.dts")(dts);
+};
+const logDtsError = (error, dtsOptions) => {
+	if (dtsOptions === false) return;
+	if (typeof dtsOptions === "object" && dtsOptions && dtsOptions.displayErrorInTerminal === false) return;
+	console.error(error);
+};
+function pluginDts(options) {
+	if (options.dts === false) return [];
+	const dtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
+	let resolvedConfig;
+	let devWorker;
+	let normalizedDevOptions;
+	let hasGeneratedBundle = false;
+	return [{
+		name: "module-federation-dts-dev",
+		apply: "serve",
+		config(config) {
+			normalizedDevOptions = normalizeDevOptions(options.dev);
+			if (!normalizedDevOptions) return;
+			if (normalizedDevOptions.disableDynamicRemoteTypeHints) return;
+			ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
+			const define = config.define ? { ...config.define } : {};
+			if (!("FEDERATION_IPV4" in define)) define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
+			config.define = define;
+		},
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		configureServer(server) {
+			if (!normalizedDevOptions || !resolvedConfig) return;
+			const devOptions = normalizedDevOptions;
+			if (devOptions.disableDynamicRemoteTypeHints && devOptions.disableHotTypesReload && devOptions.disableLiveReload) return;
+			if (!options.name) throw new Error("name is required if you want to enable dev server!");
+			const outputDir = resolveOutputDir(resolvedConfig);
+			const normalizedDtsOptions = normalizeDevDtsOptions(options.dts, resolvedConfig.root);
+			if (typeof normalizedDtsOptions !== "object") return;
+			const normalizedGenerateTypes = normalizeOptions(Boolean(normalizedDtsOptions), { compileInChildProcess: true }, "mfOptions.dts.generateTypes")(normalizedDtsOptions.generateTypes);
+			const remote = normalizedGenerateTypes === false ? void 0 : {
+				implementation: normalizedDtsOptions.implementation,
+				context: resolvedConfig.root,
+				outputDir,
+				moduleFederationConfig: { ...dtsModuleFederationConfig },
+				hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || "@mf-types",
+				...normalizedGenerateTypes,
+				typesFolder: ".dev-server"
+			};
+			if (remote && !remote.tsConfigPath && typeof normalizedDtsOptions === "object" && normalizedDtsOptions.tsConfigPath) remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
+			const normalizedConsumeTypes = normalizeOptions(Boolean(normalizedDtsOptions), { consumeAPITypes: true }, "mfOptions.dts.consumeTypes")(normalizedDtsOptions.consumeTypes);
+			const host = normalizedConsumeTypes === false ? void 0 : {
+				implementation: normalizedDtsOptions.implementation,
+				context: resolvedConfig.root,
+				moduleFederationConfig: dtsModuleFederationConfig,
+				typesFolder: normalizedConsumeTypes.typesFolder || "@mf-types",
+				abortOnError: false,
+				...normalizedConsumeTypes
+			};
+			const extraOptions = normalizedDtsOptions.extraOptions || {};
+			if (!remote && !host && devOptions.disableLiveReload) return;
+			const startDevWorker = async () => {
+				let remoteTypeUrls;
+				if (host) remoteTypeUrls = await new Promise((resolve) => {
+					consumeTypesAPI({
+						host,
+						extraOptions,
+						displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
+					}, resolve);
+				});
+				devWorker = new DevWorker({
+					name: options.name,
+					remote,
+					host: host ? {
+						...host,
+						remoteTypeUrls
+					} : void 0,
+					extraOptions,
+					disableLiveReload: devOptions.disableLiveReload,
+					disableHotTypesReload: devOptions.disableHotTypesReload
+				});
+				const update = () => devWorker?.update();
+				server.watcher.on("change", update);
+				server.watcher.on("add", update);
+				server.watcher.on("unlink", update);
+				server.httpServer?.once("close", () => {
+					devWorker?.exit();
+					server.watcher.off("change", update);
+					server.watcher.off("add", update);
+					server.watcher.off("unlink", update);
+				});
+			};
+			startDevWorker().catch((error) => {
+				logDtsError(error, normalizedDtsOptions);
+			});
+		}
+	}, {
+		name: "module-federation-dts-build",
+		apply: "build",
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		async generateBundle() {
+			if (hasGeneratedBundle) return;
+			hasGeneratedBundle = true;
+			if (!resolvedConfig) return;
+			let normalizedDtsOptions;
+			try {
+				normalizedDtsOptions = normalizeDtsOptions(dtsModuleFederationConfig, resolvedConfig.root);
+			} catch (error) {
+				logDtsError(error, options.dts);
+				return;
+			}
+			if (typeof normalizedDtsOptions !== "object") return;
+			const context = resolvedConfig.root;
+			const outputDir = resolveOutputDir(resolvedConfig);
+			let consumeOptions;
+			try {
+				consumeOptions = normalizeConsumeTypesOptions({
+					context,
+					dtsOptions: normalizedDtsOptions,
+					pluginOptions: dtsModuleFederationConfig
+				});
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+				return;
+			}
+			if (consumeOptions?.host?.typesOnBuild) try {
+				await consumeTypesAPI(consumeOptions);
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+			}
+			let generateOptions;
+			try {
+				generateOptions = normalizeGenerateTypesOptions({
+					context,
+					outputDir,
+					dtsOptions: normalizedDtsOptions,
+					pluginOptions: dtsModuleFederationConfig
+				});
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+				return;
+			}
+			if (!generateOptions) return;
+			try {
+				await generateTypesAPI({ dtsManagerOptions: generateOptions });
+			} catch (error) {
+				logDtsError(error, normalizedDtsOptions);
+			}
+		}
+	}];
+}
+//#endregion
+//#region src/utils/normalizeModuleFederationOptions.ts
+function normalizeExposesItem(key, item) {
+	let importPath = "";
+	if (typeof item === "string") importPath = item;
+	if (typeof item === "object") importPath = item.import;
+	return { import: importPath };
+}
+function normalizeExposes(exposes) {
+	if (!exposes) return {};
+	const res = {};
+	Object.keys(exposes).forEach((key) => {
+		res[key] = normalizeExposesItem(key, exposes[key]);
+	});
+	return res;
+}
+function normalizeRemotes(remotes) {
+	if (!remotes) return {};
+	const result = {};
+	if (typeof remotes === "object") Object.keys(remotes).forEach((key) => {
+		result[key] = normalizeRemoteItem(key, remotes[key]);
+	});
+	return result;
+}
+function normalizeRemoteItem(key, remote) {
+	if (typeof remote === "string") {
+		const [entryGlobalName] = remote.split("@");
+		return {
+			type: "var",
+			name: key,
+			entry: remote.replace(entryGlobalName + "@", ""),
+			entryGlobalName,
+			shareScope: "default"
+		};
+	}
+	return Object.assign({
+		type: "var",
+		name: key,
+		shareScope: "default",
+		entryGlobalName: key
+	}, remote);
+}
+function removePathFromNpmPackage(packageString) {
+	const match = packageString.match(/^(?:@[^/]+\/)?[^/]+/);
+	return match ? match[0] : packageString;
+}
+/**
+* Tries to find the package.json's version of a shared package
+* if `package.json` is not declared in `exports`
+* @param {string} sharedName
+* @returns {string | undefined}
+*/
+function searchPackageVersion(sharedName) {
+	try {
+		const sharedPath = __require.resolve(sharedName);
+		let potentialPackageJsonDir = path$1.dirname(sharedPath);
+		const rootDir = path$1.parse(potentialPackageJsonDir).root;
+		while (path$1.parse(potentialPackageJsonDir).base !== "node_modules" && potentialPackageJsonDir !== rootDir) {
+			const potentialPackageJsonPath = path$1.join(potentialPackageJsonDir, "package.json");
+			if (fs.existsSync(potentialPackageJsonPath)) {
+				const potentialPackageJson = __require(potentialPackageJsonPath);
+				if (typeof potentialPackageJson == "object" && potentialPackageJson !== null && typeof potentialPackageJson.version === "string" && potentialPackageJson.name === sharedName) return potentialPackageJson.version;
+			}
+			potentialPackageJsonDir = path$1.dirname(potentialPackageJsonDir);
+		}
+	} catch (_) {}
+}
+function normalizeShareItem(key, shareItem) {
+	let version;
+	try {
+		try {
+			version = __require(path$1.join(removePathFromNpmPackage(key), "package.json")).version;
+		} catch (e1) {
+			try {
+				const localPath = path$1.join(process.cwd(), "node_modules", removePathFromNpmPackage(key), "package.json");
+				version = __require(localPath).version;
+			} catch (e2) {
+				version = searchPackageVersion(key);
+				if (!version) console.error(e1);
+			}
+		}
+	} catch (e) {
+		console.error(`Unexpected error resolving version for ${key}:`, e);
+	}
+	if (typeof shareItem === "string") return {
+		name: shareItem,
+		version,
+		scope: "default",
+		from: "",
+		shareConfig: {
+			import: void 0,
+			singleton: false,
+			requiredVersion: version ? `^${version}` : "*"
+		}
+	};
+	return {
+		name: key,
+		from: "",
+		version: shareItem.version || version,
+		scope: shareItem.shareScope || "default",
+		shareConfig: {
+			import: typeof shareItem === "object" ? shareItem.import : void 0,
+			singleton: shareItem.singleton || false,
+			requiredVersion: shareItem.requiredVersion || (version ? `^${version}` : "*"),
+			strictVersion: !!shareItem.strictVersion
+		}
+	};
+}
+function normalizeShared(shared) {
+	if (!shared) return {};
+	const result = {};
+	if (Array.isArray(shared)) {
+		shared.forEach((key) => {
+			result[key] = normalizeShareItem(key, key);
+		});
+		return result;
+	}
+	if (typeof shared === "object") Object.keys(shared).forEach((key) => {
+		result[key] = normalizeShareItem(key, shared[key]);
+	});
+	return result;
+}
+function normalizeLibrary(library) {
+	if (!library) return void 0;
+	return library;
+}
+function normalizeManifest(manifest = false) {
+	if (typeof manifest === "boolean") return manifest;
+	return Object.assign({
+		filePath: "",
+		disableAssetsAnalyze: false,
+		fileName: "mf-manifest.json"
+	}, manifest);
+}
+let config;
+function getNormalizeModuleFederationOptions() {
+	return config;
+}
+function getNormalizeShareItem(key) {
+	const options = getNormalizeModuleFederationOptions();
+	return options.shared[key] || options.shared[removePathFromNpmPackage(key)] || options.shared[removePathFromNpmPackage(key) + "/"];
+}
+function normalizeModuleFederationOptions(options) {
+	if (options.virtualModuleDir && options.virtualModuleDir.includes("/")) throw new Error(`Invalid virtualModuleDir: "${options.virtualModuleDir}". The virtualModuleDir option cannot contain slashes (/). Please use a single directory name like '__mf__virtual__your_app_name'.`);
+	return config = {
+		exposes: normalizeExposes(options.exposes),
+		filename: options.filename || "remoteEntry-[hash]",
+		library: normalizeLibrary(options.library),
+		name: options.name,
+		remotes: normalizeRemotes(options.remotes),
+		runtime: options.runtime,
+		shareScope: options.shareScope || "default",
+		shared: normalizeShared(options.shared),
+		runtimePlugins: options.runtimePlugins || [],
+		implementation: options.implementation || __require.resolve("@module-federation/runtime"),
+		manifest: normalizeManifest(options.manifest),
+		dev: options.dev,
+		dts: options.dts,
+		getPublicPath: options.getPublicPath,
+		publicPath: options.publicPath,
+		shareStrategy: options.shareStrategy || "version-first",
+		ignoreOrigin: options.ignoreOrigin || false,
+		virtualModuleDir: options.virtualModuleDir || "__mf__virtual",
+		hostInitInjectLocation: options.hostInitInjectLocation || "html",
+		bundleAllCSS: options.bundleAllCSS || false,
+		moduleParseTimeout: options.moduleParseTimeout || 10,
+		varFilename: options.varFilename,
+		target: options.target
+	};
+}
+//#endregion
+//#region src/utils/packageNameUtils.ts
+/**
+* Escaping rules:
+* Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
+*  @ => 1
+*  / => 2
+*  - => 3
+*  . => 4
+*/
+/**
+* Encodes a package name into a valid file name.
+* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+* @returns {string} - The encoded file name.
+*/
+function packageNameEncode(name) {
+	if (typeof name !== "string") throw new Error("A string package name is required");
+	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+}
+/**
+* Decodes an encoded file name back to the original package name.
+* @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
+* @returns {string} - The decoded package name.
+*/
+function packageNameDecode(encoded) {
+	if (typeof encoded !== "string") throw new Error("A string encoded file name is required");
+	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
+}
+//#endregion
+//#region src/utils/localSharedImportMap_temp.ts
+/**
+* https://github.com/module-federation/vite/issues/68
+*/
+function getLocalSharedImportMapPath_temp() {
+	const { name } = getNormalizeModuleFederationOptions();
+	return path.resolve(".__mf__temp", packageNameEncode(name), "localSharedImportMap");
+}
+function writeLocalSharedImportMap_temp(content) {
+	createFile(getLocalSharedImportMapPath_temp() + ".js", "\n// Windows temporarily needs this file, https://github.com/module-federation/vite/issues/68\n" + content);
+}
+function createFile(filePath, content) {
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content);
+}
+//#endregion
+//#region src/utils/serializeRuntimeOptions.ts
+/**
+* Serializes a JavaScript object into a string of source code that can be evaluated.
+* This function is used to create runtime plugin options without relying solely on JSON.stringify,
+* allowing support for non-JSON types like RegExp, Date, Map, Set, and Functions.
+* It also safely handles circular references.
+*
+* @param {Record<string, unknown>} options - The options object to serialize.
+* @returns {string} The resulting JavaScript source code string.
+*/
+function serializeRuntimeOptions(options) {
+	const seenObjects = /* @__PURE__ */ new WeakSet();
+	/**
+	* Recursive inner function to serialize any value into a source code string.
+	*/
+	function valueToCode(val) {
+		if (val === null) return "null";
+		const type = typeof val;
+		if (type === "string") return JSON.stringify(val);
+		if (type === "number" || type === "boolean") return String(val);
+		if (type === "undefined") return "undefined";
+		if (type === "symbol") {
+			const desc = val.description ?? "";
+			return `Symbol(${JSON.stringify(desc)})`;
+		}
+		if (type === "function") return val.toString();
+		if (val instanceof Date) return `new Date(${JSON.stringify(val.toISOString())})`;
+		if (val instanceof RegExp) return `new RegExp(${JSON.stringify(val.source)}, ${JSON.stringify(val.flags)})`;
+		if (type === "object") {
+			if (seenObjects.has(val)) return `"__circular__"`;
+			seenObjects.add(val);
+		}
+		if (Array.isArray(val)) return `[${val.map(valueToCode).join(", ")}]`;
+		if (val instanceof Map) return `new Map([${Array.from(val.entries()).map(([k, v]) => `[${valueToCode(k)}, ${valueToCode(v)}]`).join(", ")}])`;
+		if (val instanceof Set) return `new Set([${Array.from(val.values()).map(valueToCode).join(", ")}])`;
+		if (type === "object") {
+			const properties = [];
+			for (const key in val) if (Object.prototype.hasOwnProperty.call(val, key)) properties.push(`${JSON.stringify(key)}: ${valueToCode(val[key])}`);
+			return `{${properties.join(", ")}}`;
+		}
+		return JSON.stringify(String(val));
+	}
+	const topLevelProps = [];
+	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${JSON.stringify(key)}: ${valueToCode(options[key])}`);
+	return `{${topLevelProps.join(", ")}}`;
+}
+//#endregion
+//#region src/utils/VirtualModule.ts
+let rootDir;
+function findNodeModulesDir(root = process.cwd()) {
+	let currentDir = root;
+	while (currentDir !== parse(currentDir).root) {
+		const nodeModulesPath = join(currentDir, "node_modules");
+		if (existsSync(nodeModulesPath)) return nodeModulesPath;
+		currentDir = dirname(currentDir);
+	}
+	return "";
+}
+let cachedNodeModulesDir;
+function getNodeModulesDir() {
+	if (!cachedNodeModulesDir) cachedNodeModulesDir = findNodeModulesDir(rootDir);
+	return cachedNodeModulesDir;
+}
+function getSuffix(name) {
+	const base = basename(name);
+	const dotIndex = base.lastIndexOf(".");
+	if (dotIndex > 0 && dotIndex < base.length - 1) return base.slice(dotIndex);
+	return ".js";
+}
+const patternMap = {};
+const cacheMap = {};
+/**
+* Physically generate files as virtual modules under node_modules/__mf__virtual/*
+*/
+function assertModuleFound(tag, str = "") {
+	const module = VirtualModule.findModule(tag, str);
+	if (!module) throw new Error(`Module Federation shared module '${str}' not found. Please ensure it's installed as a dependency in your package.json.`);
+	return module;
+}
+var VirtualModule = class {
+	/**
+	* Set the root path for finding node_modules
+	* @param root - Root path
+	*/
+	static setRoot(root) {
+		rootDir = root;
+		cachedNodeModulesDir = void 0;
+	}
+	/**
+	* Ensure virtual package directory exists
+	*/
+	static ensureVirtualPackageExists() {
+		const nodeModulesDir = getNodeModulesDir();
+		const { virtualModuleDir } = getNormalizeModuleFederationOptions();
+		const virtualPackagePath = resolve(nodeModulesDir, virtualModuleDir);
+		if (!existsSync(virtualPackagePath)) {
+			mkdirSync(virtualPackagePath);
+			writeFileSync(resolve(virtualPackagePath, "empty.js"), "");
+			writeFileSync(resolve(virtualPackagePath, "package.json"), JSON.stringify({
+				name: virtualModuleDir,
+				main: "empty.js"
+			}));
+		}
+	}
+	static findModule(tag, str = "") {
+		if (!patternMap[tag]) patternMap[tag] = new RegExp(`(.*${packageNameEncode(tag)}(.+?)${packageNameEncode(tag)}.*)`);
+		const moduleName = (str.match(patternMap[tag]) || [])[2];
+		if (moduleName) return cacheMap[tag][packageNameDecode(moduleName)];
+	}
+	constructor(name, tag = "__mf_v__", suffix = "") {
+		this.inited = false;
+		this.name = name;
+		this.tag = tag;
+		this.suffix = suffix || getSuffix(name);
+		if (!cacheMap[this.tag]) cacheMap[this.tag] = {};
+		cacheMap[this.tag][this.name] = this;
+	}
+	getPath() {
+		return resolve(getNodeModulesDir(), this.getImportId());
+	}
+	getImportId() {
+		const { name: mfName, virtualModuleDir } = getNormalizeModuleFederationOptions();
+		return `${virtualModuleDir}/${packageNameEncode(`${mfName}${this.tag}${this.name}${this.tag}`)}${this.suffix}`;
+	}
+	writeSync(code, force) {
+		if (!force && this.inited) return;
+		if (!this.inited) this.inited = true;
+		writeFileSync(this.getPath(), code);
+	}
+	write(code) {
+		writeFile(this.getPath(), code, function() {});
+	}
+};
+//#endregion
+//#region src/virtualModules/virtualExposes.ts
+const VIRTUAL_EXPOSES = "virtual:mf-exposes";
+function generateExposes() {
+	const options = getNormalizeModuleFederationOptions();
+	return `
+    export default {
+    ${Object.keys(options.exposes).map((key) => {
+		return `
+        ${JSON.stringify(key)}: async () => {
+          const importModule = await import(${JSON.stringify(options.exposes[key].import)})
+          const exportModule = {}
+          Object.assign(exportModule, importModule)
+          Object.defineProperty(exportModule, "__esModule", {
+            value: true,
+            enumerable: false
+          })
+          return exportModule
+        }
+      `;
+	}).join(",")}
+  }
+  `;
+}
+//#endregion
+//#region src/virtualModules/virtualRuntimeInitStatus.ts
+const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
+function writeRuntimeInitStatus(command) {
+	const globalKey = `__mf_init__${virtualRuntimeInitStatus.getImportId()}__`;
+	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject } = globalThis[globalKey];
+export { initPromise, initResolve, initReject };` : `module.exports = globalThis[globalKey];`;
+	virtualRuntimeInitStatus.writeSync(`
+const globalKey = ${JSON.stringify(globalKey)};
+if (!globalThis[globalKey]) {
+  let initResolve, initReject;
+  const initPromise = new Promise((re, rj) => {
+    initResolve = re;
+    initReject = rj;
+  });
+  globalThis[globalKey] = {
+    initPromise,
+    initResolve,
+    initReject,
+  };
+}
+${exportStatement}
+`);
+}
+//#endregion
+//#region src/virtualModules/virtualRemotes.ts
+const cacheRemoteMap = {};
+const LOAD_REMOTE_TAG = "__loadRemote__";
+function getRemoteVirtualModule(remote, command) {
+	if (!cacheRemoteMap[remote]) {
+		cacheRemoteMap[remote] = new VirtualModule(remote, LOAD_REMOTE_TAG, ".js");
+		cacheRemoteMap[remote].writeSync(generateRemotes(remote, command));
+	}
+	return cacheRemoteMap[remote];
+}
+const usedRemotesMap = {};
+function addUsedRemote(remoteKey, remoteModule) {
+	if (!usedRemotesMap[remoteKey]) usedRemotesMap[remoteKey] = /* @__PURE__ */ new Set();
+	usedRemotesMap[remoteKey].add(remoteModule);
+}
+function getUsedRemotesMap() {
+	return usedRemotesMap;
+}
+function generateRemotes(id, command) {
+	const isBuild = command === "build";
+	const importLine = isBuild ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
+	const awaitOrPlaceholder = isBuild ? "await " : "/*mf top-level-await placeholder replacement mf*/";
+	const exportLine = isBuild ? "export default exportModule" : "module.exports = exportModule";
+	return `
+    ${importLine}
+    const res = initPromise.then(runtime => runtime.loadRemote(${JSON.stringify(id)}))
+    const exportModule = ${awaitOrPlaceholder}initPromise.then(_ => res)
+    ${exportLine}
+  `;
+}
+//#endregion
+//#region src/virtualModules/virtualShared_preBuild.ts
+const preBuildCacheMap = {};
+const PREBUILD_TAG = "__prebuild__";
+function writePreBuildLibPath(pkg) {
+	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG);
+	preBuildCacheMap[pkg].writeSync("");
+}
+function getPreBuildLibImportId(pkg) {
+	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG);
+	return preBuildCacheMap[pkg].getImportId();
+}
+const LOAD_SHARE_TAG = "__loadShare__";
+const loadShareCacheMap = {};
+function getLoadShareModulePath(pkg) {
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
+	return loadShareCacheMap[pkg].getPath();
+}
+function writeLoadShareModule(pkg, shareItem, command) {
+	const isBuild = command === "build";
+	const importLine = isBuild ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
+	const awaitOrPlaceholder = isBuild ? "await " : "/*mf top-level-await placeholder replacement mf*/";
+	const exportLine = isBuild ? "export default exportModule" : "module.exports = exportModule";
+	loadShareCacheMap[pkg].writeSync(`
+    ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
+    ${command !== "build" ? `;() => import(${JSON.stringify(pkg)}).catch(() => {});` : ""}
+    ${importLine}
+    const res = initPromise.then(runtime => runtime.loadShare(${JSON.stringify(pkg)}, {
+      customShareInfo: {shareConfig:{
+        singleton: ${shareItem.shareConfig.singleton},
+        strictVersion: ${shareItem.shareConfig.strictVersion},
+        requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
+      }}
+    }))
+    const exportModule = ${awaitOrPlaceholder}res.then(factory => factory())
+    ${exportLine}
+  `);
+}
+//#endregion
+//#region src/virtualModules/virtualRemoteEntry.ts
+let usedShares = /* @__PURE__ */ new Set();
+function getUsedShares() {
+	return usedShares;
+}
+function addUsedShares(pkg) {
+	usedShares.add(pkg);
+}
+new VirtualModule("localSharedImportMap");
+function getLocalSharedImportMapPath() {
+	return getLocalSharedImportMapPath_temp();
+}
+let prevSharedCount;
+function writeLocalSharedImportMap() {
+	const sharedCount = getUsedShares().size;
+	if (prevSharedCount !== sharedCount) {
+		prevSharedCount = sharedCount;
+		writeLocalSharedImportMap_temp(generateLocalSharedImportMap());
+	}
+}
+function generateLocalSharedImportMap() {
+	const options = getNormalizeModuleFederationOptions();
+	return `
+    import {loadShare} from "@module-federation/runtime";
+    const importMap = {
+      ${Array.from(getUsedShares()).sort().map((pkg) => {
+		const shareItem = getNormalizeShareItem(pkg);
+		return `
+        ${JSON.stringify(pkg)}: async () => {
+          ${shareItem?.shareConfig.import === false ? `throw new Error(\`Shared module '\${${JSON.stringify(pkg)}}' must be provided by host\`);` : `let pkg = await import("${getPreBuildLibImportId(pkg)}");
+            return pkg;`}
+        }
+      `;
+	}).join(",")}
+    }
+      const usedShared = {
+      ${Array.from(getUsedShares()).sort().map((key) => {
+		const shareItem = getNormalizeShareItem(key);
+		if (!shareItem) return null;
+		return `
+          ${JSON.stringify(key)}: {
+            name: ${JSON.stringify(key)},
+            version: ${JSON.stringify(shareItem.version)},
+            scope: [${JSON.stringify(shareItem.scope)}],
+            loaded: false,
+            from: ${JSON.stringify(options.name)},
+            async get () {
+              if (${shareItem.shareConfig.import === false}) {
+                throw new Error(\`Shared module '\${${JSON.stringify(key)}}' must be provided by host\`);
+              }
+              usedShared[${JSON.stringify(key)}].loaded = true
+              const {${JSON.stringify(key)}: pkgDynamicImport} = importMap
+              const res = await pkgDynamicImport()
+              const exportModule = {...res}
+              // All npm packages pre-built by vite will be converted to esm
+              Object.defineProperty(exportModule, "__esModule", {
+                value: true,
+                enumerable: false
+              })
+              return function () {
+                return exportModule
+              }
+            },
+            shareConfig: {
+              singleton: ${shareItem.shareConfig.singleton},
+              requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)},
+              ${shareItem.shareConfig.import === false ? "import: false," : ""}
+            }
+          }
+        `;
+	}).filter((x) => x !== null).join(",")}
+    }
+      const usedRemotes = [${Object.keys(getUsedRemotesMap()).map((key) => {
+		const remote = options.remotes[key];
+		if (!remote) return null;
+		return `
+                {
+                  entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
+                  name: ${JSON.stringify(remote.name)},
+                  type: ${JSON.stringify(remote.type)},
+                  entry: ${JSON.stringify(remote.entry)},
+                  shareScope: ${JSON.stringify(remote.shareScope) ?? "default"},
+                }
+          `;
+	}).filter((x) => x !== null).join(",")}
+      ]
+      export {
+        usedShared,
+        usedRemotes
+      }
+      `;
+}
+const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
+function generateRemoteEntry(options) {
+	const pluginImportNames = options.runtimePlugins.map((p, i) => {
+		if (typeof p === "string") return [
+			`$runtimePlugin_${i}`,
+			`import $runtimePlugin_${i} from "${p}";`,
+			`undefined`
+		];
+		else return [
+			`$runtimePlugin_${i}`,
+			`import $runtimePlugin_${i} from "${p[0]}";`,
+			serializeRuntimeOptions(p[1])
+		];
+	});
+	return `
+  import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
+  ${pluginImportNames.map((item) => item[1]).join("\n")}
+  import exposesMap from "${VIRTUAL_EXPOSES}"
+  import {usedShared, usedRemotes} from "${getLocalSharedImportMapPath()}"
+  import {
+    initResolve
+  } from "${virtualRuntimeInitStatus.getImportId()}"
+  const initTokens = {}
+  const shareScopeName = ${JSON.stringify(options.shareScope)}
+  const mfName = ${JSON.stringify(options.name)}
+  async function init(shared = {}, initScope = []) {
+    const initRes = runtimeInit({
+      name: mfName,
+      remotes: usedRemotes,
+      shared: usedShared,
+      plugins: [${pluginImportNames.map((item) => `${item[0]}(${item[2]})`).join(", ")}],
+      ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ""}
+    });
+    // handling circular init calls
+    var initToken = initTokens[shareScopeName];
+    if (!initToken)
+      initToken = initTokens[shareScopeName] = { from: mfName };
+    if (initScope.indexOf(initToken) >= 0) return;
+    initScope.push(initToken);
+    initRes.initShareScopeMap('${options.shareScope}', shared);
+    try {
+      await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
+        strategy: '${options.shareStrategy}',
+        from: "build",
+        initScope
+      }));
+    } catch (e) {
+      console.error(e)
+    }
+    initResolve(initRes)
+    return initRes
+  }
+  function getExposes(moduleName) {
+    if (!(moduleName in exposesMap)) throw new Error(\`Module \${moduleName} does not exist in container.\`)
+    return (exposesMap[moduleName])().then(res => () => res)
+  }
+  export {
+      init,
+      getExposes as get
+  }
+  `;
+}
+/**
+* Inject entry file, automatically init when used as host,
+* and will not inject remoteEntry
+*/
+const HOST_AUTO_INIT_TAG = "__H_A_I__";
+const hostAutoInitModule = new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG);
+function writeHostAutoInit() {
+	hostAutoInitModule.writeSync(`
+    const remoteEntryPromise = import("${REMOTE_ENTRY_ID}")
+    // __tla only serves as a hack for vite-plugin-top-level-await.
+    Promise.resolve(remoteEntryPromise)
+      .then(remoteEntry => {
+        return Promise.resolve(remoteEntry.__tla)
+          .then(remoteEntry.init).catch(remoteEntry.init)
+      })
+    `);
+}
+function getHostAutoInitImportId() {
+	return hostAutoInitModule.getImportId();
+}
+function getHostAutoInitPath() {
+	return hostAutoInitModule.getPath();
+}
+//#endregion
+//#region src/virtualModules/index.ts
+function initVirtualModules(command) {
+	writeLocalSharedImportMap();
+	writeHostAutoInit();
+	writeRuntimeInitStatus(command);
+}
+//#endregion
+//#region src/utils/bundleHelpers.ts
+function findRemoteEntryFile(filename, bundle) {
+	for (const [_, fileData] of Object.entries(bundle)) if (filename.replace(/[\[\]]/g, "_").replace(/\.[^/.]+$/, "") === fileData.name || fileData.name === "remoteEntry") return fileData.fileName;
+}
+//#endregion
+//#region src/utils/cssModuleHelpers.ts
+const ASSET_TYPES = ["js", "css"];
+const LOAD_TIMINGS = ["sync", "async"];
+const JS_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+/**
+* Creates an empty asset map structure for tracking JS and CSS assets
+* @returns Initialized asset map with sync/async arrays for JS and CSS
+*/
+const createEmptyAssetMap = () => ({
+	js: {
+		sync: [],
+		async: []
+	},
+	css: {
+		sync: [],
+		async: []
+	}
+});
+/**
+* Tracks an asset in the preload map with deduplication
+* @param map - The preload map to update
+* @param key - The module key to track under
+* @param fileName - The asset filename to track
+* @param isAsync - Whether the asset is loaded async
+* @param type - The asset type ('js' or 'css')
+*/
+const trackAsset = (map, key, fileName, isAsync, type) => {
+	if (!map[key]) map[key] = createEmptyAssetMap();
+	const target = isAsync ? map[key][type].async : map[key][type].sync;
+	if (!target.includes(fileName)) target.push(fileName);
+};
+/**
+* Checks if a file is a CSS file by extension
+* @param fileName - The filename to check
+* @returns True if file has a CSS extension (.css, .scss, .less)
+*/
+const isCSSFile = (fileName) => {
+	return fileName.endsWith(".css") || fileName.endsWith(".scss") || fileName.endsWith(".less");
+};
+/**
+* Collects all CSS assets from the bundle
+* @param bundle - The Rollup output bundle
+* @returns Set of CSS asset filenames
+*/
+const collectCssAssets = (bundle) => {
+	const cssAssets = /* @__PURE__ */ new Set();
+	for (const [fileName, fileData] of Object.entries(bundle)) if (fileData.type === "asset" && isCSSFile(fileName)) cssAssets.add(fileName);
+	return cssAssets;
+};
+/**
+* Checks if a chunk contains CSS modules (e.g. .css, .vanilla.css, .scss, .less)
+* by scanning its module list
+*/
+const chunkContainsCssModules = (modules) => {
+	for (const modulePath of Object.keys(modules)) if (isCSSFile(modulePath)) return true;
+	return false;
+};
+/**
+* Processes module assets and tracks them in the files map
+* @param bundle - The Rollup output bundle
+* @param filesMap - The preload map to populate
+* @param moduleMatcher - Function that matches module paths to keys
+*/
+const processModuleAssets = (bundle, filesMap, moduleMatcher) => {
+	const bundleCssAssets = collectCssAssets(bundle);
+	for (const [fileName, fileData] of Object.entries(bundle)) {
+		if (fileData.type !== "chunk") continue;
+		if (!fileData.modules) continue;
+		for (const modulePath of Object.keys(fileData.modules)) {
+			const matchKey = moduleMatcher(modulePath);
+			if (!matchKey) continue;
+			trackAsset(filesMap, matchKey, fileName, false, "js");
+			let foundCssViaMetadata = false;
+			if (fileData.viteMetadata?.importedCss?.size) for (const cssFile of fileData.viteMetadata.importedCss) {
+				trackAsset(filesMap, matchKey, cssFile, false, "css");
+				foundCssViaMetadata = true;
+			}
+			if (!foundCssViaMetadata && chunkContainsCssModules(fileData.modules)) for (const cssAsset of bundleCssAssets) trackAsset(filesMap, matchKey, cssAsset, false, "css");
+			if (fileData.dynamicImports) for (const dynamicImport of fileData.dynamicImports) {
+				if (!bundle[dynamicImport]) continue;
+				trackAsset(filesMap, matchKey, dynamicImport, true, isCSSFile(dynamicImport) ? "css" : "js");
+			}
+		}
+	}
+};
+/**
+* Deduplicates assets in the files map
+* @param filesMap - The preload map to deduplicate
+* @returns New deduplicated preload map
+*/
+const deduplicateAssets = (filesMap) => {
+	const result = {};
+	for (const [key, assetMaps] of Object.entries(filesMap)) {
+		result[key] = createEmptyAssetMap();
+		for (const type of ASSET_TYPES) for (const timing of LOAD_TIMINGS) result[key][type][timing] = Array.from(new Set(assetMaps[type][timing]));
+	}
+	return result;
+};
+/**
+* Builds a mapping between module files and their share keys
+* @param shareKeys - Set of share keys to map
+* @param resolveFn - Function to resolve module paths
+* @returns Map of file paths to their corresponding share keys
+*/
+const buildFileToShareKeyMap = async (shareKeys, resolveFn) => {
+	const fileToShareKey = /* @__PURE__ */ new Map();
+	const resolutions = await Promise.all(Array.from(shareKeys).map((shareKey) => resolveFn(getPreBuildLibImportId(shareKey)).then((resolution) => ({
+		shareKey,
+		file: resolution?.id?.split("?")[0]
+	})).catch(() => null)));
+	for (const resolution of resolutions) if (resolution?.file) fileToShareKey.set(resolution.file, resolution.shareKey);
+	return fileToShareKey;
+};
+//#endregion
+//#region src/utils/publicPath.ts
+/**
+* Resolves the public path for remote entries
+* @param options - Module Federation options
+* @param viteBase - Vite's base config value
+* @param originalBase - Original base config before any transformations
+* @returns The resolved public path
+*/
+function resolvePublicPath(options, viteBase, originalBase) {
+	if (options.publicPath) return options.publicPath;
+	if (originalBase === "") return "auto";
+	if (viteBase) return viteBase.replace(/\/?$/, "/");
+	return "auto";
+}
+//#endregion
+//#region src/plugins/pluginMFManifest.ts
+const Manifest = () => {
+	const mfOptions = getNormalizeModuleFederationOptions();
+	const { name, filename, getPublicPath, manifest: manifestOptions, varFilename } = mfOptions;
+	let mfManifestName = "";
+	if (manifestOptions === true) mfManifestName = "mf-manifest.json";
+	if (typeof manifestOptions !== "boolean") mfManifestName = path$1.join(manifestOptions?.filePath || "", manifestOptions?.fileName || "");
+	let root;
+	let remoteEntryFile;
+	let publicPath;
+	let _command;
+	let _originalConfigBase;
+	let viteConfig;
+	/**
+	* Adds global CSS assets to all module exports
+	* @param filesMap - The preload map to update
+	* @param cssAssets - Set of CSS asset filenames to add
+	*/
+	const addCssAssetsToAllExports = (filesMap, cssAssets) => {
+		Object.keys(filesMap).forEach((key) => {
+			cssAssets.forEach((cssAsset) => {
+				trackAsset(filesMap, key, cssAsset, false, "css");
+			});
+		});
+	};
+	return [{
+		name: "module-federation-manifest",
+		apply: "serve",
+		configResolved(config) {
+			viteConfig = config;
+		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (!mfManifestName) {
+					next();
+					return;
+				}
+				if (req.url?.replace(/\?.*/, "") === (viteConfig.base + mfManifestName).replace(/^\/?/, "/")) {
+					res.setHeader("Content-Type", "application/json");
+					res.setHeader("Access-Control-Allow-Origin", "*");
+					res.end(JSON.stringify({
+						...generateMFManifest({}),
+						id: name,
+						name,
+						metaData: {
+							name,
+							type: "app",
+							buildInfo: {
+								buildVersion: "1.0.0",
+								buildName: name
+							},
+							remoteEntry: {
+								name: filename,
+								path: "",
+								type: "module"
+							},
+							ssrRemoteEntry: {
+								name: filename,
+								path: "",
+								type: "module"
+							},
+							varRemoteEntry: varFilename ? {
+								name: varFilename,
+								path: "",
+								type: "var"
+							} : void 0,
+							types: {
+								path: "",
+								name: ""
+							},
+							globalName: name,
+							pluginVersion: "0.2.5",
+							publicPath
+						}
+					}));
+				} else next();
+			});
+		}
+	}, {
+		name: "module-federation-manifest",
+		enforce: "post",
+		config(config, { command }) {
+			if (!config.build) config.build = {};
+			if (!config.build.manifest) config.build.manifest = config.build.manifest || !!manifestOptions;
+			_command = command;
+			_originalConfigBase = config.base;
+		},
+		configResolved(config) {
+			root = config.root;
+			let base = config.base;
+			if (_command === "serve") base = (config.server.origin || "") + config.base;
+			publicPath = resolvePublicPath(mfOptions, base, _originalConfigBase);
+		},
+		async generateBundle(options, bundle) {
+			if (!mfManifestName) return;
+			let filesMap = {};
+			const foundRemoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
+			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
+			const allCssAssets = mfOptions.bundleAllCSS ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
+			const exposesModules = Object.keys(mfOptions.exposes).map((item) => mfOptions.exposes[item].import);
+			processModuleAssets(bundle, filesMap, (modulePath) => {
+				const absoluteModulePath = path$1.resolve(root, modulePath);
+				return exposesModules.find((exposeModule) => {
+					const exposePath = path$1.resolve(root, exposeModule);
+					if (absoluteModulePath === exposePath) return true;
+					const getPathWithoutKnownExt = (filePath) => {
+						const ext = path$1.extname(filePath);
+						return JS_EXTENSIONS.includes(ext) ? path$1.join(path$1.dirname(filePath), path$1.basename(filePath, ext)) : filePath;
+					};
+					return getPathWithoutKnownExt(absoluteModulePath) === getPathWithoutKnownExt(exposePath);
+				});
+			});
+			const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(), this.resolve.bind(this));
+			processModuleAssets(bundle, filesMap, (modulePath) => fileToShareKey.get(modulePath));
+			if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
+			filesMap = deduplicateAssets(filesMap);
+			this.emitFile({
+				type: "asset",
+				fileName: mfManifestName,
+				source: JSON.stringify(generateMFManifest(filesMap))
+			});
+		}
+	}];
+	/**
+	* Generates the final manifest JSON structure
+	* @param preloadMap - Map of module assets to include
+	* @returns Complete manifest object
+	*/
+	function generateMFManifest(preloadMap) {
+		const options = getNormalizeModuleFederationOptions();
+		const { name, varFilename } = options;
+		const remoteEntry = {
+			name: remoteEntryFile,
+			path: "",
+			type: "module"
+		};
+		const varRemoteEntry = varFilename ? {
+			name: varFilename,
+			path: "",
+			type: "module"
+		} : void 0;
+		const remotes = Array.from(Object.entries(getUsedRemotesMap())).flatMap(([remoteKey, modules]) => Array.from(modules).map((moduleKey) => ({
+			federationContainerName: options.remotes[remoteKey].entry,
+			moduleName: moduleKey.replace(remoteKey, "").replace("/", ""),
+			alias: remoteKey,
+			entry: "*"
+		})));
+		const shared = Array.from(getUsedShares()).map((shareKey) => {
+			const shareItem = getNormalizeShareItem(shareKey);
+			const assets = preloadMap[shareKey] || createEmptyAssetMap();
+			return {
+				id: `${name}:${shareKey}`,
+				name: shareKey,
+				version: shareItem.version,
+				requiredVersion: shareItem.shareConfig.requiredVersion,
+				assets: {
+					js: {
+						async: assets.js.async,
+						sync: assets.js.sync
+					},
+					css: {
+						async: assets.css.async,
+						sync: assets.css.sync
+					}
+				}
+			};
+		}).filter(Boolean);
+		const exposes = Object.entries(options.exposes).map(([key, value]) => {
+			const formatKey = key.replace("./", "");
+			const assets = preloadMap[value.import] || createEmptyAssetMap();
+			return {
+				id: `${name}:${formatKey}`,
+				name: formatKey,
+				assets: {
+					js: {
+						async: assets.js.async,
+						sync: assets.js.sync
+					},
+					css: {
+						async: assets.css.async,
+						sync: assets.css.sync
+					}
+				},
+				path: key
+			};
+		}).filter(Boolean);
+		return {
+			id: name,
+			name,
+			metaData: {
+				name,
+				type: "app",
+				buildInfo: {
+					buildVersion: "1.0.0",
+					buildName: name
+				},
+				remoteEntry,
+				ssrRemoteEntry: remoteEntry,
+				varRemoteEntry,
+				types: {
+					path: "",
+					name: ""
+				},
+				globalName: name,
+				pluginVersion: "0.2.5",
+				...!!getPublicPath ? { getPublicPath } : { publicPath }
+			},
+			shared,
+			remotes,
+			exposes
+		};
+	}
+};
+//#endregion
+//#region src/plugins/pluginModuleParseEnd.ts
+let _resolve, _parseTimeout;
+const promise = new Promise((resolve, reject) => {
+	_resolve = (v) => {
+		clearTimeout(_parseTimeout);
+		_parseTimeout = null;
+		resolve(v);
+	};
+});
+function setParseTimeout(timeout) {
+	if (!_parseTimeout) _parseTimeout = setTimeout(() => {
+		console.warn(`Parse timeout (${timeout}s) - forcing resolve`);
+		_resolve(1);
+	}, timeout * 1e3);
+}
+let parsePromise = promise;
+let exposesParseEnd = false;
+const parseStartSet = /* @__PURE__ */ new Set();
+const parseEndSet = /* @__PURE__ */ new Set();
+function pluginModuleParseEnd_default(excludeFn, options) {
+	setParseTimeout(options.moduleParseTimeout);
+	return [
+		{
+			name: "_",
+			apply: "serve",
+			config() {
+				_resolve(1);
+			}
+		},
+		{
+			enforce: "pre",
+			name: "parseStart",
+			apply: "build",
+			load(id) {
+				if (excludeFn(id)) return;
+				parseStartSet.add(id);
+			}
+		},
+		{
+			enforce: "post",
+			name: "parseEnd",
+			apply: "build",
+			moduleParsed(module) {
+				const id = module.id;
+				if (id === VIRTUAL_EXPOSES) exposesParseEnd = true;
+				if (excludeFn(id)) return;
+				parseEndSet.add(id);
+				if (exposesParseEnd && parseStartSet.size === parseEndSet.size) _resolve(1);
+			}
+		}
+	];
+}
+//#endregion
+//#region src/plugins/pluginProxyRemoteEntry.ts
+const filter = createFilter();
+function pluginProxyRemoteEntry_default() {
+	let viteConfig, _command;
+	return {
+		name: "proxyRemoteEntry",
+		enforce: "post",
+		configResolved(config) {
+			viteConfig = config;
+		},
+		config(config, { command }) {
+			_command = command;
+		},
+		async resolveId(id, importer) {
+			if (id === REMOTE_ENTRY_ID) return REMOTE_ENTRY_ID;
+			if (id === VIRTUAL_EXPOSES) return VIRTUAL_EXPOSES;
+			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
+			if (importer === REMOTE_ENTRY_ID && !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !id.startsWith("virtual:")) {
+				typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
+				const resolved = await this.resolve(id, __filename, { skipSelf: true });
+				if (resolved) return resolved;
+			}
+		},
+		load(id) {
+			if (id === REMOTE_ENTRY_ID) return parsePromise.then((_) => generateRemoteEntry(getNormalizeModuleFederationOptions()));
+			if (id === VIRTUAL_EXPOSES) return generateExposes();
+			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
+		},
+		transform(code, id) {
+			return mapCodeToCodeWithSourcemap((() => {
+				if (!filter(id)) return;
+				if (id.includes(REMOTE_ENTRY_ID)) return parsePromise.then((_) => generateRemoteEntry(getNormalizeModuleFederationOptions()));
+				if (id === VIRTUAL_EXPOSES) return generateExposes();
+				if (id.includes(getHostAutoInitPath())) {
+					const options = getNormalizeModuleFederationOptions();
+					if (_command === "serve") {
+						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
+						const publicPath = JSON.stringify(resolvePublicPath(options, viteConfig.base) + options.filename);
+						return `
+          const origin = (window && ${!options.ignoreOrigin}) ? window.origin : "//${host}:${viteConfig.server?.port}"
+          const remoteEntryPromise = await import(origin + ${publicPath})
+          // __tla only serves as a hack for vite-plugin-top-level-await.
+          Promise.resolve(remoteEntryPromise)
+          .then(remoteEntry => {
+            return Promise.resolve(remoteEntry.__tla)
+              .then(remoteEntry.init).catch(remoteEntry.init)
+          })
+          `;
+					}
+					return code;
+				}
+			})());
+		}
+	};
+}
+//#endregion
+//#region src/plugins/pluginProxyRemotes.ts
+createFilter();
+function pluginProxyRemotes_default(options) {
+	const { remotes } = options;
+	return {
+		name: "proxyRemotes",
+		config(config, { command: _command }) {
+			Object.keys(remotes).forEach((key) => {
+				const remote = remotes[key];
+				config.resolve.alias.push({
+					find: new RegExp(`^(${remote.name}(\/.*|$))`),
+					replacement: "$1",
+					customResolver(source) {
+						const remoteModule = getRemoteVirtualModule(source, _command);
+						addUsedRemote(remote.name, source);
+						return remoteModule.getPath();
+					}
+				});
+			});
+		}
+	};
+}
+//#endregion
+//#region src/utils/PromiseStore.ts
+/**
+* example:
+* const store = new PromiseStore<number>();
+* store.get("example").then((result) => {
+*  console.log("Result from example:", result); // 42
+* });
+* setTimeout(() => {
+*  store.set("example", Promise.resolve(42));
+* }, 2000);
+*/
+var PromiseStore = class {
+	constructor() {
+		this.promiseMap = /* @__PURE__ */ new Map();
+		this.resolveMap = /* @__PURE__ */ new Map();
+	}
+	set(id, promise) {
+		if (this.resolveMap.has(id)) {
+			promise.then(this.resolveMap.get(id));
+			this.resolveMap.delete(id);
+		}
+		this.promiseMap.set(id, promise);
+	}
+	get(id) {
+		if (this.promiseMap.has(id)) return this.promiseMap.get(id);
+		const pendingPromise = new Promise((resolve) => {
+			this.resolveMap.set(id, resolve);
+		});
+		this.promiseMap.set(id, pendingPromise);
+		return pendingPromise;
+	}
+};
+//#endregion
+//#region src/plugins/pluginProxySharedModule_preBuild.ts
+function proxySharedModule(options) {
+	let { shared = {}, include, exclude } = options;
+	let _config;
+	return [{
+		name: "generateLocalSharedImportMap",
+		enforce: "post",
+		load(id) {
+			if (id.includes(getLocalSharedImportMapPath())) return parsePromise.then((_) => generateLocalSharedImportMap());
+		},
+		transform(_, id) {
+			if (id.includes(getLocalSharedImportMapPath())) return mapCodeToCodeWithSourcemap(parsePromise.then((_) => generateLocalSharedImportMap()));
+		}
+	}, {
+		name: "proxyPreBuildShared",
+		enforce: "post",
+		configResolved(config) {
+			_config = config;
+		},
+		config(config, { command }) {
+			config.resolve.alias.push(...Object.keys(shared).map((key) => {
+				const pattern = key.endsWith("/") ? `(^${key.replace(/\/$/, "")}(\/.+)?$)` : `(^${key}$)`;
+				return {
+					find: new RegExp(pattern),
+					replacement: "$1",
+					customResolver(source, importer) {
+						if (/\.css$/.test(source)) return;
+						const loadSharePath = getLoadShareModulePath(source);
+						writeLoadShareModule(source, shared[key], command);
+						writePreBuildLibPath(source);
+						addUsedShares(source);
+						writeLocalSharedImportMap();
+						return this.resolve(loadSharePath, importer);
+					}
+				};
+			}));
+			const savePrebuild = new PromiseStore();
+			config.resolve.alias.push(...Object.keys(shared).map((key) => {
+				return command === "build" ? {
+					find: new RegExp(`(.*${PREBUILD_TAG}.*)`),
+					replacement: function($1) {
+						return assertModuleFound(PREBUILD_TAG, $1).name;
+					}
+				} : {
+					find: new RegExp(`(.*${PREBUILD_TAG}.*)`),
+					replacement: "$1",
+					async customResolver(source, importer) {
+						const pkgName = assertModuleFound(PREBUILD_TAG, source).name;
+						const result = await this.resolve(pkgName, importer).then((item) => item.id);
+						if (!result.includes(_config.cacheDir)) savePrebuild.set(pkgName, Promise.resolve(result));
+						return await this.resolve(await savePrebuild.get(pkgName), importer);
+					}
+				};
+			}));
+		}
+	}];
+}
+//#endregion
+//#region src/plugins/pluginVarRemoteEntry.ts
+const VarRemoteEntry = () => {
+	const mfOptions = getNormalizeModuleFederationOptions();
+	const { name, varFilename, filename } = mfOptions;
+	let viteConfig;
+	return [{
+		name: "module-federation-var-remote-entry",
+		apply: "serve",
+		configResolved(config) {
+			viteConfig = config;
+		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (!varFilename) {
+					next();
+					return;
+				}
+				if (req.url?.replace(/\?.*/, "") === (viteConfig.base + varFilename).replace(/^\/?/, "/")) {
+					res.setHeader("Content-Type", "text/javascript");
+					res.setHeader("Access-Control-Allow-Origin", "*");
+					console.log({ filename });
+					res.end(generateVarRemoteEntry(filename));
+				} else next();
+			});
+		}
+	}, {
+		name: "module-federation-var-remote-entry",
+		enforce: "post",
+		config(config, { command }) {
+			if (!config.build) config.build = {};
+		},
+		configResolved(config) {
+			viteConfig = config;
+		},
+		async generateBundle(options, bundle) {
+			if (!varFilename) return;
+			if (!isValidVarName(name)) viteConfig.logger.warn(`Provided remote name "${name}" is not valid for "var" remoteEntry type, thus it's placed in globalThis['${name}'].\nIt may cause problems, so you would better want to use valid var name (see https://www.w3schools.com/js/js_variables.asp).`);
+			const remoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
+			if (!remoteEntryFile) throw new Error(`Couldn't find a remoteEntry chunk file for ${mfOptions.filename}, can't generate varRemoteEntry file`);
+			this.emitFile({
+				type: "asset",
+				fileName: varFilename,
+				source: generateVarRemoteEntry(remoteEntryFile)
+			});
+		}
+	}];
+	function isValidVarName(name) {
+		return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+	}
+	/**
+	* Generates the final "var" remote entry file
+	* @param remoteEntryFile - Path to esm remote entry file
+	* @returns Complete "var" remoteEntry.js file source
+	*/
+	function generateVarRemoteEntry(remoteEntryFile) {
+		const { name, varFilename } = getNormalizeModuleFederationOptions();
+		const isValidName = isValidVarName(name);
+		return `
+  ${isValidName ? `var ${name};` : ""}
+  ${isValidName ? name : `globalThis['${name}']`} = (function () {
+    function getScriptUrl() {
+      const currentScript = document.currentScript;
+      if (!currentScript) {
+        console.error("[VarRemoteEntry] ${varFilename} script should be called from sync <script> tag (document.currentScript is undefined)")
+        return '/';
+      }
+      return document.currentScript.src.replace(/\\/[^/]*$/, '/');
+    }
+    const entry = getScriptUrl() + '${remoteEntryFile}';
+    return {
+      get: (...args) => import(entry).then(m => m.get(...args)),
+      init: (...args) => import(entry).then(m => m.init(...args)),
+    };
+  })();
+  `;
+	}
+};
+//#endregion
+//#region src/utils/aliasToArrayPlugin.ts
+var aliasToArrayPlugin_default = {
+	name: "alias-transform-plugin",
+	config: (config, { command }) => {
+		if (!config.resolve) config.resolve = {};
+		if (!config.resolve.alias) config.resolve.alias = [];
+		const { alias } = config.resolve;
+		if (typeof alias === "object" && !Array.isArray(alias)) config.resolve.alias = Object.entries(alias).map(([find, replacement]) => ({
+			find,
+			replacement
+		}));
+	}
+};
+//#endregion
+//#region src/utils/normalizeOptimizeDeps.ts
+var normalizeOptimizeDeps_default = {
+	name: "normalizeOptimizeDeps",
+	config: (config, { command }) => {
+		let { optimizeDeps } = config;
+		if (!optimizeDeps) {
+			config.optimizeDeps = {};
+			optimizeDeps = config.optimizeDeps;
+		}
+		optimizeDeps.force = true;
+		if (!optimizeDeps.include) optimizeDeps.include = [];
+		if (!optimizeDeps.needsInterop) optimizeDeps.needsInterop = [];
+	}
+};
+//#endregion
+//#region src/index.ts
+function federation(mfUserOptions) {
+	const options = normalizeModuleFederationOptions(mfUserOptions);
+	const { name, remotes, shared, filename, hostInitInjectLocation } = options;
+	if (!name) throw new Error("name is required");
+	let command;
+	return [
+		{
+			name: "vite:module-federation-config",
+			enforce: "pre",
+			config(_config, env) {
+				command = env.command;
+			},
+			configResolved(config) {
+				VirtualModule.setRoot(config.root);
+				VirtualModule.ensureVirtualPackageExists();
+				initVirtualModules(command);
+			}
+		},
+		aliasToArrayPlugin_default,
+		checkAliasConflicts({ shared }),
+		normalizeOptimizeDeps_default,
+		...pluginDts(options),
+		...addEntry({
+			entryName: "remoteEntry",
+			entryPath: REMOTE_ENTRY_ID,
+			fileName: filename
+		}),
+		...addEntry({
+			entryName: "hostInit",
+			entryPath: getHostAutoInitPath(),
+			inject: hostInitInjectLocation
+		}),
+		...addEntry({
+			entryName: "virtualExposes",
+			entryPath: VIRTUAL_EXPOSES
+		}),
+		pluginProxyRemoteEntry_default(),
+		pluginProxyRemotes_default(options),
+		...pluginModuleParseEnd_default((id) => {
+			return id.includes(getHostAutoInitImportId()) || id.includes(REMOTE_ENTRY_ID) || id.includes(VIRTUAL_EXPOSES) || id.includes(getLocalSharedImportMapPath());
+		}, { moduleParseTimeout: options.moduleParseTimeout }),
+		...proxySharedModule({ shared }),
+		{
+			name: "module-federation-esm-shims",
+			enforce: "pre",
+			apply: "build",
+			load(id) {
+				if (id.startsWith("\0")) return;
+				if (id.includes(LOAD_SHARE_TAG) || id.includes(LOAD_REMOTE_TAG)) {
+					let code = readFileSync(id, "utf-8");
+					/**
+					* Shared/remote shims only have `export default exportModule`.
+					*
+					* We add a second named export (__moduleExports) that holds the full
+					* module namespace and point syntheticNamedExports at it.  This lets
+					* Rollup resolve named imports (e.g. `import { useState } from 'react'`)
+					* from the namespace while still applying its normal default-export
+					* interop — which is needed for libraries like @emotion/styled where
+					* `import styled from '@emotion/styled'` must receive the .default
+					* function, not the raw namespace object.
+					*
+					* Using 'default' as the syntheticNamedExports key would skip the
+					* interop and break default imports.
+					*
+					* @see https://rollupjs.org/plugin-development/#synthetic-named-exports
+					*/
+					code = code.replace("export default exportModule", "export const __moduleExports = exportModule;\nexport default exportModule.__esModule ? exportModule.default : exportModule");
+					return {
+						code,
+						syntheticNamedExports: "__moduleExports"
+					};
+				}
+			}
+		},
+		PluginDevProxyModuleTopLevelAwait(),
+		{
+			name: "module-federation-vite",
+			enforce: "post",
+			_options: options,
+			config(config, { command: _command }) {
+				config.resolve.alias.push({
+					find: "@module-federation/runtime",
+					replacement: options.implementation
+				});
+				config.build = defu(config.build || {}, { commonjsOptions: { strictRequires: "auto" } });
+				const virtualDir = options.virtualModuleDir || "__mf__virtual";
+				config.optimizeDeps?.include?.push("@module-federation/runtime");
+				config.optimizeDeps?.include?.push(virtualDir);
+				config.optimizeDeps?.needsInterop?.push(virtualDir);
+				config.optimizeDeps?.needsInterop?.push(getLocalSharedImportMapPath());
+				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");
+				if (!config.define) config.define = {};
+				if (!("ENV_TARGET" in config.define)) config.define["ENV_TARGET"] = JSON.stringify(resolvedTarget);
+				if (options.target && "ENV_TARGET" in config.define && config.define["ENV_TARGET"] !== JSON.stringify(options.target)) console.warn(`[module-federation] ENV_TARGET define (${config.define["ENV_TARGET"]}) differs from target option ("${options.target}"). ENV_TARGET will not be overridden.`);
+			}
+		},
+		...Manifest(),
+		...VarRemoteEntry()
+	];
+}
+//#endregion
+export { federation };