@baseplate-dev/plugin-auth 0.6.9 → 0.6.11

package/dist/web/assets/virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-Bt9-dftr.js

@@ -0,0 +1,3892 @@
+import { t as __vitePreload } from "./vite-preload-helper-iIio8xkS.js";
+var BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+var NameTransformSymbol = {
+	AT: "@",
+	HYPHEN: "-",
+	SLASH: "/"
+};
+var NameTransformMap = {
+	[NameTransformSymbol.AT]: "scope_",
+	[NameTransformSymbol.HYPHEN]: "_",
+	[NameTransformSymbol.SLASH]: "__"
+};
+NameTransformMap[NameTransformSymbol.AT], NameTransformSymbol.AT, NameTransformMap[NameTransformSymbol.HYPHEN], NameTransformSymbol.HYPHEN, NameTransformMap[NameTransformSymbol.SLASH], NameTransformSymbol.SLASH;
+var TreeShakingStatus = /* @__PURE__ */ function(TreeShakingStatus) {
+	/**
+	* Not handled by deploy server, needs to infer by the real runtime period.
+	*/
+	TreeShakingStatus[TreeShakingStatus["UNKNOWN"] = 1] = "UNKNOWN";
+	/**
+	* It means the shared has been calculated , runtime should take this shared as first choice.
+	*/
+	TreeShakingStatus[TreeShakingStatus["CALCULATED"] = 2] = "CALCULATED";
+	/**
+	* It means the shared has been calculated, and marked as no used
+	*/
+	TreeShakingStatus[TreeShakingStatus["NO_USE"] = 0] = "NO_USE";
+	return TreeShakingStatus;
+}({});
+function isBrowserEnv() {
+	return true;
+}
+function isReactNativeEnv() {
+	return typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+}
+function isBrowserDebug() {
+	try {
+		if (isBrowserEnv() && window.localStorage) return Boolean(localStorage.getItem(BROWSER_LOG_KEY));
+	} catch (error) {
+		return false;
+	}
+	return false;
+}
+function isDebugMode() {
+	if (typeof process !== "undefined" && {}["FEDERATION_DEBUG"]) return Boolean({}["FEDERATION_DEBUG"]);
+	if (typeof FEDERATION_DEBUG !== "undefined" && Boolean(FEDERATION_DEBUG)) return true;
+	return isBrowserDebug();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+sdk@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/sdk/dist/utils.js
+var LOG_CATEGORY$1 = "[ Federation Runtime ]";
+var composeKeyWithSeparator = function(...args) {
+	if (!args.length) return "";
+	return args.reduce((sum, cur) => {
+		if (!cur) return sum;
+		if (!sum) return cur;
+		return `${sum}:${cur}`;
+	}, "");
+};
+var getResourceUrl = (module, sourceUrl) => {
+	if ("getPublicPath" in module) {
+		let publicPath;
+		if (!module.getPublicPath.startsWith("function")) publicPath = new Function(module.getPublicPath)();
+		else publicPath = new Function("return " + module.getPublicPath)()();
+		return `${publicPath}${sourceUrl}`;
+	} else if ("publicPath" in module) {
+		if (!isBrowserEnv() && !isReactNativeEnv() && "ssrPublicPath" in module && typeof module.ssrPublicPath === "string") return `${module.ssrPublicPath}${sourceUrl}`;
+		return `${module.publicPath}${sourceUrl}`;
+	} else {
+		console.warn("Cannot get resource URL. If in debug mode, please ignore.", module, sourceUrl);
+		return "";
+	}
+};
+var warn = (msg) => {
+	console.warn(`${LOG_CATEGORY$1}: ${msg}`);
+};
+function safeToString(info) {
+	try {
+		return JSON.stringify(info, null, 2);
+	} catch (e) {
+		return "";
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+sdk@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/sdk/dist/generateSnapshotFromManifest.js
+var simpleJoinRemoteEntry = (rPath, rName) => {
+	if (!rPath) return rName;
+	const transformPath = (str) => {
+		if (str === ".") return "";
+		if (str.startsWith("./")) return str.replace("./", "");
+		if (str.startsWith("/")) {
+			const strWithoutSlash = str.slice(1);
+			if (strWithoutSlash.endsWith("/")) return strWithoutSlash.slice(0, -1);
+			return strWithoutSlash;
+		}
+		return str;
+	};
+	const transformedPath = transformPath(rPath);
+	if (!transformedPath) return rName;
+	if (transformedPath.endsWith("/")) return `${transformedPath}${rName}`;
+	return `${transformedPath}/${rName}`;
+};
+function inferAutoPublicPath(url) {
+	return url.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+}
+function generateSnapshotFromManifest(manifest, options = {}) {
+	const { remotes = {}, overrides = {}, version } = options;
+	let remoteSnapshot;
+	const getPublicPath = () => {
+		if ("publicPath" in manifest.metaData) {
+			if ((manifest.metaData.publicPath === "auto" || manifest.metaData.publicPath === "") && version) return inferAutoPublicPath(version);
+			return manifest.metaData.publicPath;
+		} else return manifest.metaData.getPublicPath;
+	};
+	const overridesKeys = Object.keys(overrides);
+	let remotesInfo = {};
+	if (!Object.keys(remotes).length) remotesInfo = manifest.remotes?.reduce((res, next) => {
+		let matchedVersion;
+		const name = next.federationContainerName;
+		if (overridesKeys.includes(name)) matchedVersion = overrides[name];
+		else if ("version" in next) matchedVersion = next.version;
+		else matchedVersion = next.entry;
+		res[name] = { matchedVersion };
+		return res;
+	}, {}) || {};
+	Object.keys(remotes).forEach((key) => remotesInfo[key] = { matchedVersion: overridesKeys.includes(key) ? overrides[key] : remotes[key] });
+	const { remoteEntry: { path: remoteEntryPath, name: remoteEntryName, type: remoteEntryType }, types: remoteTypes = {
+		path: "",
+		name: "",
+		zip: "",
+		api: ""
+	}, buildInfo: { buildVersion }, globalName, ssrRemoteEntry } = manifest.metaData;
+	const { exposes } = manifest;
+	let basicRemoteSnapshot = {
+		version: version ? version : "",
+		buildVersion,
+		globalName,
+		remoteEntry: simpleJoinRemoteEntry(remoteEntryPath, remoteEntryName),
+		remoteEntryType,
+		remoteTypes: simpleJoinRemoteEntry(remoteTypes.path, remoteTypes.name),
+		remoteTypesZip: remoteTypes.zip || "",
+		remoteTypesAPI: remoteTypes.api || "",
+		remotesInfo,
+		shared: manifest?.shared.map((item) => ({
+			assets: item.assets,
+			sharedName: item.name,
+			version: item.version,
+			usedExports: item.referenceExports || []
+		})),
+		modules: exposes?.map((expose) => ({
+			moduleName: expose.name,
+			modulePath: expose.path,
+			assets: expose.assets
+		}))
+	};
+	if ("publicPath" in manifest.metaData) {
+		remoteSnapshot = {
+			...basicRemoteSnapshot,
+			publicPath: getPublicPath()
+		};
+		if (typeof manifest.metaData.ssrPublicPath === "string") remoteSnapshot.ssrPublicPath = manifest.metaData.ssrPublicPath;
+	} else remoteSnapshot = {
+		...basicRemoteSnapshot,
+		getPublicPath: getPublicPath()
+	};
+	if (ssrRemoteEntry) {
+		const fullSSRRemoteEntry = simpleJoinRemoteEntry(ssrRemoteEntry.path, ssrRemoteEntry.name);
+		remoteSnapshot.ssrRemoteEntry = fullSSRRemoteEntry;
+		remoteSnapshot.ssrRemoteEntryType = ssrRemoteEntry.type || "commonjs-module";
+	}
+	return remoteSnapshot;
+}
+function isManifestProvider(moduleInfo) {
+	if ("remoteEntry" in moduleInfo && moduleInfo.remoteEntry.includes(".json")) return true;
+	else return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+sdk@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/sdk/dist/logger.js
+var PREFIX = "[ Module Federation ]";
+var DEFAULT_DELEGATE = console;
+var LOGGER_STACK_SKIP_TOKENS = [
+	"logger.ts",
+	"logger.js",
+	"captureStackTrace",
+	"Logger.emit",
+	"Logger.log",
+	"Logger.info",
+	"Logger.warn",
+	"Logger.error",
+	"Logger.debug"
+];
+function captureStackTrace() {
+	try {
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		if (!stack) return;
+		const [, ...rawLines] = stack.split("\n");
+		const filtered = rawLines.filter((line) => !LOGGER_STACK_SKIP_TOKENS.some((token) => line.includes(token)));
+		if (!filtered.length) return;
+		return `Stack trace:\n${filtered.slice(0, 5).join("\n")}`;
+	} catch {
+		return;
+	}
+}
+var Logger = class {
+	constructor(prefix, delegate = DEFAULT_DELEGATE) {
+		this.prefix = prefix;
+		this.delegate = delegate ?? DEFAULT_DELEGATE;
+	}
+	setPrefix(prefix) {
+		this.prefix = prefix;
+	}
+	setDelegate(delegate) {
+		this.delegate = delegate ?? DEFAULT_DELEGATE;
+	}
+	emit(method, args) {
+		const delegate = this.delegate;
+		const stackTrace = isDebugMode() ? captureStackTrace() : void 0;
+		const enrichedArgs = stackTrace ? [...args, stackTrace] : args;
+		const order = (() => {
+			switch (method) {
+				case "log": return ["log", "info"];
+				case "info": return ["info", "log"];
+				case "warn": return [
+					"warn",
+					"info",
+					"log"
+				];
+				case "error": return [
+					"error",
+					"warn",
+					"log"
+				];
+				default: return ["debug", "log"];
+			}
+		})();
+		for (const candidate of order) {
+			const handler = delegate[candidate];
+			if (typeof handler === "function") {
+				handler.call(delegate, this.prefix, ...enrichedArgs);
+				return;
+			}
+		}
+		for (const candidate of order) {
+			const handler = DEFAULT_DELEGATE[candidate];
+			if (typeof handler === "function") {
+				handler.call(DEFAULT_DELEGATE, this.prefix, ...enrichedArgs);
+				return;
+			}
+		}
+	}
+	log(...args) {
+		this.emit("log", args);
+	}
+	warn(...args) {
+		this.emit("warn", args);
+	}
+	error(...args) {
+		this.emit("error", args);
+	}
+	success(...args) {
+		this.emit("info", args);
+	}
+	info(...args) {
+		this.emit("info", args);
+	}
+	ready(...args) {
+		this.emit("info", args);
+	}
+	debug(...args) {
+		if (isDebugMode()) this.emit("debug", args);
+	}
+};
+function createLogger(prefix) {
+	return new Logger(prefix);
+}
+function createInfrastructureLogger(prefix) {
+	const infrastructureLogger = new Logger(prefix);
+	Object.defineProperty(infrastructureLogger, "__mf_infrastructure_logger__", {
+		value: true,
+		enumerable: false,
+		configurable: false
+	});
+	return infrastructureLogger;
+}
+createLogger(PREFIX);
+createInfrastructureLogger(PREFIX);
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+sdk@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/sdk/dist/dom.js
+async function safeWrapper(callback, disableWarn) {
+	try {
+		return await callback();
+	} catch (e) {
+		!disableWarn && warn(e);
+		return;
+	}
+}
+function isStaticResourcesEqual(url1, url2) {
+	const REG_EXP = /^(https?:)?\/\//i;
+	return url1.replace(REG_EXP, "").replace(/\/$/, "") === url2.replace(REG_EXP, "").replace(/\/$/, "");
+}
+function createScript(info) {
+	let script = null;
+	let needAttach = true;
+	let timeout = 2e4;
+	let timeoutId;
+	const scripts = document.getElementsByTagName("script");
+	for (let i = 0; i < scripts.length; i++) {
+		const s = scripts[i];
+		const scriptSrc = s.getAttribute("src");
+		if (scriptSrc && isStaticResourcesEqual(scriptSrc, info.url)) {
+			script = s;
+			needAttach = false;
+			break;
+		}
+	}
+	if (!script) {
+		const attrs = info.attrs;
+		script = document.createElement("script");
+		script.type = attrs?.["type"] === "module" ? "module" : "text/javascript";
+		let createScriptRes = void 0;
+		if (info.createScriptHook) {
+			createScriptRes = info.createScriptHook(info.url, info.attrs);
+			if (createScriptRes instanceof HTMLScriptElement) script = createScriptRes;
+			else if (typeof createScriptRes === "object") {
+				if ("script" in createScriptRes && createScriptRes.script) script = createScriptRes.script;
+				if ("timeout" in createScriptRes && createScriptRes.timeout) timeout = createScriptRes.timeout;
+			}
+		}
+		if (!script.src) script.src = info.url;
+		if (attrs && !createScriptRes) Object.keys(attrs).forEach((name) => {
+			if (script) {
+				if (name === "async" || name === "defer") script[name] = attrs[name];
+				else if (!script.getAttribute(name)) script.setAttribute(name, attrs[name]);
+			}
+		});
+	}
+	let executionError = null;
+	const executionErrorHandler = typeof window !== "undefined" ? (evt) => {
+		if (evt.filename && isStaticResourcesEqual(evt.filename, info.url)) {
+			const err = /* @__PURE__ */ new Error(`ScriptExecutionError: Script "${info.url}" loaded but threw a runtime error during execution: ${evt.message} (${evt.filename}:${evt.lineno}:${evt.colno})`);
+			err.name = "ScriptExecutionError";
+			executionError = err;
+		}
+	} : null;
+	if (executionErrorHandler) window.addEventListener("error", executionErrorHandler);
+	const onScriptComplete = async (prev, event) => {
+		clearTimeout(timeoutId);
+		if (executionErrorHandler) window.removeEventListener("error", executionErrorHandler);
+		const onScriptCompleteCallback = () => {
+			if (event?.type === "error") {
+				const networkError = /* @__PURE__ */ new Error(event?.isTimeout ? `ScriptNetworkError: Script "${info.url}" timed out.` : `ScriptNetworkError: Failed to load script "${info.url}" - the script URL is unreachable or the server returned an error (network failure, 404, CORS, etc.)`);
+				networkError.name = "ScriptNetworkError";
+				info?.onErrorCallback && info?.onErrorCallback(networkError);
+			} else if (executionError) info?.onErrorCallback && info?.onErrorCallback(executionError);
+			else info?.cb && info?.cb();
+		};
+		if (script) {
+			script.onerror = null;
+			script.onload = null;
+			safeWrapper(() => {
+				const { needDeleteScript = true } = info;
+				if (needDeleteScript) script?.parentNode && script.parentNode.removeChild(script);
+			});
+			if (prev && typeof prev === "function") {
+				const result = prev(event);
+				if (result instanceof Promise) {
+					const res = await result;
+					onScriptCompleteCallback();
+					return res;
+				}
+				onScriptCompleteCallback();
+				return result;
+			}
+		}
+		onScriptCompleteCallback();
+	};
+	script.onerror = onScriptComplete.bind(null, script.onerror);
+	script.onload = onScriptComplete.bind(null, script.onload);
+	timeoutId = setTimeout(() => {
+		onScriptComplete(null, {
+			type: "error",
+			isTimeout: true
+		});
+	}, timeout);
+	return {
+		script,
+		needAttach
+	};
+}
+function createLink(info) {
+	let link = null;
+	let needAttach = true;
+	let timeout = 2e4;
+	let timeoutId;
+	const links = document.getElementsByTagName("link");
+	for (let i = 0; i < links.length; i++) {
+		const l = links[i];
+		const linkHref = l.getAttribute("href");
+		const linkRel = l.getAttribute("rel");
+		if (linkHref && isStaticResourcesEqual(linkHref, info.url) && linkRel === info.attrs["rel"]) {
+			link = l;
+			needAttach = false;
+			break;
+		}
+	}
+	if (!link) {
+		link = document.createElement("link");
+		link.setAttribute("href", info.url);
+		let createLinkRes = void 0;
+		let shouldApplyAttrs = true;
+		const attrs = info.attrs;
+		if (info.createLinkHook) {
+			createLinkRes = info.createLinkHook(info.url, attrs);
+			if (createLinkRes instanceof HTMLLinkElement) {
+				link = createLinkRes;
+				shouldApplyAttrs = false;
+			} else if (typeof createLinkRes === "object") {
+				if ("link" in createLinkRes && createLinkRes.link) {
+					link = createLinkRes.link;
+					shouldApplyAttrs = false;
+				}
+				if ("timeout" in createLinkRes && createLinkRes.timeout) timeout = createLinkRes.timeout;
+			}
+		}
+		if (attrs && shouldApplyAttrs) Object.keys(attrs).forEach((name) => {
+			if (link && !link.getAttribute(name)) link.setAttribute(name, attrs[name]);
+		});
+	}
+	if (!needAttach) {
+		Promise.resolve().then(() => {
+			info?.cb && info?.cb();
+		});
+		return {
+			link,
+			needAttach
+		};
+	}
+	const onLinkComplete = (prev, event) => {
+		if (timeoutId) clearTimeout(timeoutId);
+		const onLinkCompleteCallback = () => {
+			if (event?.type === "error") {
+				const linkError = /* @__PURE__ */ new Error(event?.isTimeout ? `LinkNetworkError: Link "${info.url}" timed out.` : `LinkNetworkError: Failed to load link "${info.url}" - the URL is unreachable or the server returned an error.`);
+				linkError.name = "LinkNetworkError";
+				info?.onErrorCallback && info?.onErrorCallback(linkError);
+			} else info?.cb && info?.cb();
+		};
+		if (link) {
+			link.onerror = null;
+			link.onload = null;
+			safeWrapper(() => {
+				const { needDeleteLink = true } = info;
+				if (needDeleteLink) link?.parentNode && link.parentNode.removeChild(link);
+			});
+			if (prev) {
+				const res = prev(event);
+				onLinkCompleteCallback();
+				return res;
+			}
+		}
+		onLinkCompleteCallback();
+	};
+	link.onerror = onLinkComplete.bind(null, link.onerror);
+	link.onload = onLinkComplete.bind(null, link.onload);
+	timeoutId = setTimeout(() => {
+		onLinkComplete(null, {
+			type: "error",
+			isTimeout: true
+		});
+	}, timeout);
+	return {
+		link,
+		needAttach
+	};
+}
+function loadScript(url, info) {
+	const { attrs = {}, createScriptHook } = info;
+	return new Promise((resolve, reject) => {
+		const { script, needAttach } = createScript({
+			url,
+			cb: resolve,
+			onErrorCallback: reject,
+			attrs: {
+				fetchpriority: "high",
+				...attrs
+			},
+			createScriptHook,
+			needDeleteScript: true
+		});
+		needAttach && document.head.appendChild(script);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+error-codes@2.6.0/node_modules/@module-federation/error-codes/dist/getShortErrorMsg.mjs
+var getDocsUrl = (errorCode) => {
+	return `View the docs to see how to solve: https://module-federation.io/guide/troubleshooting/${errorCode.split("-")[0].toLowerCase()}#${errorCode.toLowerCase()}`;
+};
+var getShortErrorMsg = (errorCode, errorDescMap, args, originalErrorMsg) => {
+	const msg = [`${[errorDescMap[errorCode]]} #${errorCode}`];
+	args && msg.push(`args: ${JSON.stringify(args)}`);
+	msg.push(getDocsUrl(errorCode));
+	originalErrorMsg && msg.push(`Original Error Message:\n ${originalErrorMsg}`);
+	return msg.join("\n");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+error-codes@2.6.0/node_modules/@module-federation/error-codes/dist/browser.mjs
+function logAndReport(code, descMap, args, logger, originalErrorMsg, context) {
+	return logger(getShortErrorMsg(code, descMap, args, originalErrorMsg));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/logger.js
+var LOG_CATEGORY = "[ Federation Runtime ]";
+var logger = createLogger(LOG_CATEGORY);
+function assert(condition, msgOrCode, descMap, args, context) {
+	if (!condition) if (descMap !== void 0) error(msgOrCode, descMap, args, void 0, context);
+	else error(msgOrCode);
+}
+function error(msgOrCode, descMap, args, originalErrorMsg, context) {
+	if (descMap !== void 0) return logAndReport(msgOrCode, descMap, args ?? {}, (msg) => {
+		throw new Error(`${LOG_CATEGORY}: ${msg}`);
+	}, originalErrorMsg, context);
+	const msg = msgOrCode;
+	if (msg instanceof Error) {
+		if (!msg.message.startsWith(LOG_CATEGORY)) msg.message = `${LOG_CATEGORY}: ${msg.message}`;
+		throw msg;
+	}
+	throw new Error(`${LOG_CATEGORY}: ${msg}`);
+}
+function warn$1(msg) {
+	if (msg instanceof Error) {
+		if (!msg.message.startsWith(LOG_CATEGORY)) msg.message = `${LOG_CATEGORY}: ${msg.message}`;
+		logger.warn(msg);
+	} else logger.warn(msg);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/tool.js
+function addUniqueItem(arr, item) {
+	if (arr.findIndex((name) => name === item) === -1) arr.push(item);
+	return arr;
+}
+function getFMId(remoteInfo) {
+	if ("version" in remoteInfo && remoteInfo.version) return `${remoteInfo.name}:${remoteInfo.version}`;
+	else if ("entry" in remoteInfo && remoteInfo.entry) return `${remoteInfo.name}:${remoteInfo.entry}`;
+	else return `${remoteInfo.name}`;
+}
+function isRemoteInfoWithEntry(remote) {
+	return typeof remote.entry !== "undefined";
+}
+function isPureRemoteEntry(remote) {
+	return !remote.entry.includes(".json");
+}
+function isObject(val) {
+	return val && typeof val === "object";
+}
+var objectToString = Object.prototype.toString;
+function isPlainObject(val) {
+	return objectToString.call(val) === "[object Object]";
+}
+function arrayOptions(options) {
+	return Array.isArray(options) ? options : [options];
+}
+function getRemoteEntryInfoFromSnapshot(snapshot) {
+	return "remoteEntry" in snapshot ? {
+		url: snapshot.remoteEntry,
+		type: snapshot.remoteEntryType,
+		globalName: snapshot.globalName
+	} : {
+		url: "",
+		type: "global",
+		globalName: ""
+	};
+}
+var processModuleAlias = (name, subPath) => {
+	let moduleName;
+	if (name.endsWith("/")) moduleName = name.slice(0, -1);
+	else moduleName = name;
+	if (subPath.startsWith(".")) subPath = subPath.slice(1);
+	moduleName = moduleName + subPath;
+	return moduleName;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/global.js
+var CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
+var nativeGlobal = (() => {
+	try {
+		return document.defaultView;
+	} catch {
+		return CurrentGlobal;
+	}
+})();
+var Global = nativeGlobal;
+function definePropertyGlobalVal(target, key, val) {
+	Object.defineProperty(target, key, {
+		value: val,
+		configurable: false,
+		writable: true
+	});
+}
+function includeOwnProperty(target, key) {
+	return Object.hasOwnProperty.call(target, key);
+}
+if (!includeOwnProperty(CurrentGlobal, "__GLOBAL_LOADING_REMOTE_ENTRY__")) definePropertyGlobalVal(CurrentGlobal, "__GLOBAL_LOADING_REMOTE_ENTRY__", {});
+var globalLoading = CurrentGlobal.__GLOBAL_LOADING_REMOTE_ENTRY__;
+function setGlobalDefaultVal(target) {
+	if (includeOwnProperty(target, "__VMOK__") && !includeOwnProperty(target, "__FEDERATION__")) definePropertyGlobalVal(target, "__FEDERATION__", target.__VMOK__);
+	if (!includeOwnProperty(target, "__FEDERATION__")) {
+		definePropertyGlobalVal(target, "__FEDERATION__", {
+			__GLOBAL_PLUGIN__: [],
+			__INSTANCES__: [],
+			moduleInfo: {},
+			__SHARE__: {},
+			__MANIFEST_LOADING__: {},
+			__PRELOADED_MAP__: /* @__PURE__ */ new Map()
+		});
+		definePropertyGlobalVal(target, "__VMOK__", target.__FEDERATION__);
+	}
+	target.__FEDERATION__.__GLOBAL_PLUGIN__ ??= [];
+	target.__FEDERATION__.__INSTANCES__ ??= [];
+	target.__FEDERATION__.moduleInfo ??= {};
+	target.__FEDERATION__.__SHARE__ ??= {};
+	target.__FEDERATION__.__MANIFEST_LOADING__ ??= {};
+	target.__FEDERATION__.__PRELOADED_MAP__ ??= /* @__PURE__ */ new Map();
+}
+setGlobalDefaultVal(CurrentGlobal);
+setGlobalDefaultVal(nativeGlobal);
+function setGlobalFederationInstance(FederationInstance) {
+	CurrentGlobal.__FEDERATION__.__INSTANCES__.push(FederationInstance);
+}
+function getGlobalFederationConstructor() {
+	return CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__;
+}
+function setGlobalFederationConstructor(FederationConstructor, isDebug = isDebugMode()) {
+	if (isDebug) {
+		CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
+		CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "2.6.0";
+	}
+}
+function getInfoWithoutType(target, key) {
+	if (typeof key === "string") if (target[key]) return {
+		value: target[key],
+		key
+	};
+	else {
+		const targetKeys = Object.keys(target);
+		for (const targetKey of targetKeys) {
+			const [targetTypeOrName, _] = targetKey.split(":");
+			const nKey = `${targetTypeOrName}:${key}`;
+			const typeWithKeyRes = target[nKey];
+			if (typeWithKeyRes) return {
+				value: typeWithKeyRes,
+				key: nKey
+			};
+		}
+		return {
+			value: void 0,
+			key
+		};
+	}
+	else error(`getInfoWithoutType: "key" must be a string, got ${typeof key} (${JSON.stringify(key)}).`);
+}
+var getGlobalSnapshot = () => nativeGlobal.__FEDERATION__.moduleInfo;
+var getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot) => {
+	const getModuleInfo = getInfoWithoutType(snapshot, getFMId(moduleInfo)).value;
+	if (getModuleInfo && !getModuleInfo.version && "version" in moduleInfo && moduleInfo["version"]) getModuleInfo.version = moduleInfo["version"];
+	if (getModuleInfo) return getModuleInfo;
+	if ("version" in moduleInfo && moduleInfo["version"]) {
+		const { version, ...resModuleInfo } = moduleInfo;
+		const moduleKeyWithoutVersion = getFMId(resModuleInfo);
+		const getModuleInfoWithoutVersion = getInfoWithoutType(nativeGlobal.__FEDERATION__.moduleInfo, moduleKeyWithoutVersion).value;
+		if (getModuleInfoWithoutVersion?.version === version) return getModuleInfoWithoutVersion;
+	}
+};
+var getGlobalSnapshotInfoByModuleInfo = (moduleInfo) => getTargetSnapshotInfoByModuleInfo(moduleInfo, nativeGlobal.__FEDERATION__.moduleInfo);
+var setGlobalSnapshotInfoByModuleInfo = (remoteInfo, moduleDetailInfo) => {
+	const moduleKey = getFMId(remoteInfo);
+	nativeGlobal.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
+	return nativeGlobal.__FEDERATION__.moduleInfo;
+};
+var addGlobalSnapshot = (moduleInfos) => {
+	nativeGlobal.__FEDERATION__.moduleInfo = {
+		...nativeGlobal.__FEDERATION__.moduleInfo,
+		...moduleInfos
+	};
+	return () => {
+		const keys = Object.keys(moduleInfos);
+		for (const key of keys) delete nativeGlobal.__FEDERATION__.moduleInfo[key];
+	};
+};
+var getRemoteEntryExports = (name, globalName) => {
+	const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
+	return {
+		remoteEntryKey,
+		entryExports: CurrentGlobal[remoteEntryKey]
+	};
+};
+var getGlobalHostPlugins = () => nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
+var getPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.get(id);
+var setPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/semver/constants.js
+var buildIdentifier = "[0-9A-Za-z-]+";
+var build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
+var numericIdentifier = "0|[1-9]\\d*";
+var numericIdentifierLoose = "[0-9]+";
+var nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+var preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
+var preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
+var preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
+var preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
+var xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
+var xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
+var hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
+var loosePlain = `[v=\\s]*${`(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`}${preReleaseLoose}?${build}?`;
+var gtlt = "((?:<|>)?=?)";
+var comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
+var loneTilde = "(?:~>?)";
+var tildeTrim = `(\\s*)${loneTilde}\\s+`;
+var loneCaret = "(?:\\^)";
+var caretTrim = `(\\s*)${loneCaret}\\s+`;
+var star = "(<|>)?=?\\s*\\*";
+var caret = `^${loneCaret}${xRangePlain}$`;
+var fullPlain = `v?${`(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`}${preRelease}?${build}?`;
+var tilde = `^${loneTilde}${xRangePlain}$`;
+var xRange = `^${gtlt}\\s*${xRangePlain}$`;
+var comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
+var gte0 = "^\\s*>=\\s*0.0.0\\s*$";
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/semver/utils.js
+function parseRegex(source) {
+	return new RegExp(source);
+}
+function isXVersion(version) {
+	return !version || version.toLowerCase() === "x" || version === "*";
+}
+function pipe(...fns) {
+	return (x) => fns.reduce((v, f) => f(v), x);
+}
+function extractComparator(comparatorString) {
+	return comparatorString.match(parseRegex(comparator));
+}
+function combineVersion(major, minor, patch, preRelease) {
+	const mainVersion = `${major}.${minor}.${patch}`;
+	if (preRelease) return `${mainVersion}-${preRelease}`;
+	return mainVersion;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/semver/parser.js
+function parseHyphen(range) {
+	return range.replace(parseRegex(hyphenRange), (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
+		if (isXVersion(fromMajor)) from = "";
+		else if (isXVersion(fromMinor)) from = `>=${fromMajor}.0.0`;
+		else if (isXVersion(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0`;
+		else from = `>=${from}`;
+		if (isXVersion(toMajor)) to = "";
+		else if (isXVersion(toMinor)) to = `<${Number(toMajor) + 1}.0.0-0`;
+		else if (isXVersion(toPatch)) to = `<${toMajor}.${Number(toMinor) + 1}.0-0`;
+		else if (toPreRelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function parseComparatorTrim(range) {
+	return range.replace(parseRegex(comparatorTrim), "$1$2$3");
+}
+function parseTildeTrim(range) {
+	return range.replace(parseRegex(tildeTrim), "$1~");
+}
+function parseCaretTrim(range) {
+	return range.replace(parseRegex(caretTrim), "$1^");
+}
+function parseCarets(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => rangeVersion.replace(parseRegex(caret), (_, major, minor, patch, preRelease) => {
+		if (isXVersion(major)) return "";
+		else if (isXVersion(minor)) return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+		else if (isXVersion(patch)) if (major === "0") return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+		else return `>=${major}.${minor}.0 <${Number(major) + 1}.0.0-0`;
+		else if (preRelease) if (major === "0") if (minor === "0") return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${minor}.${Number(patch) + 1}-0`;
+		else return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+		else return `>=${major}.${minor}.${patch}-${preRelease} <${Number(major) + 1}.0.0-0`;
+		else {
+			if (major === "0") if (minor === "0") return `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0`;
+			else return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+			return `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+		}
+	})).join(" ");
+}
+function parseTildes(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => rangeVersion.replace(parseRegex(tilde), (_, major, minor, patch, preRelease) => {
+		if (isXVersion(major)) return "";
+		else if (isXVersion(minor)) return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+		else if (isXVersion(patch)) return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+		else if (preRelease) return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+		return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+	})).join(" ");
+}
+function parseXRanges(range) {
+	return range.split(/\s+/).map((rangeVersion) => rangeVersion.trim().replace(parseRegex(xRange), (ret, gtlt, major, minor, patch, preRelease) => {
+		const isXMajor = isXVersion(major);
+		const isXMinor = isXMajor || isXVersion(minor);
+		const isXPatch = isXMinor || isXVersion(patch);
+		if (gtlt === "=" && isXPatch) gtlt = "";
+		preRelease = "";
+		if (isXMajor) if (gtlt === ">" || gtlt === "<") return "<0.0.0-0";
+		else return "*";
+		else if (gtlt && isXPatch) {
+			if (isXMinor) minor = 0;
+			patch = 0;
+			if (gtlt === ">") {
+				gtlt = ">=";
+				if (isXMinor) {
+					major = Number(major) + 1;
+					minor = 0;
+					patch = 0;
+				} else {
+					minor = Number(minor) + 1;
+					patch = 0;
+				}
+			} else if (gtlt === "<=") {
+				gtlt = "<";
+				if (isXMinor) major = Number(major) + 1;
+				else minor = Number(minor) + 1;
+			}
+			if (gtlt === "<") preRelease = "-0";
+			return `${gtlt + major}.${minor}.${patch}${preRelease}`;
+		} else if (isXMinor) return `>=${major}.0.0${preRelease} <${Number(major) + 1}.0.0-0`;
+		else if (isXPatch) return `>=${major}.${minor}.0${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+		return ret;
+	})).join(" ");
+}
+function parseStar(range) {
+	return range.trim().replace(parseRegex(star), "");
+}
+function parseGTE0(comparatorString) {
+	return comparatorString.trim().replace(parseRegex(gte0), "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/semver/compare.js
+function compareAtom(rangeAtom, versionAtom) {
+	rangeAtom = Number(rangeAtom) || rangeAtom;
+	versionAtom = Number(versionAtom) || versionAtom;
+	if (rangeAtom > versionAtom) return 1;
+	if (rangeAtom === versionAtom) return 0;
+	return -1;
+}
+function comparePreRelease(rangeAtom, versionAtom) {
+	const { preRelease: rangePreRelease } = rangeAtom;
+	const { preRelease: versionPreRelease } = versionAtom;
+	if (rangePreRelease === void 0 && Boolean(versionPreRelease)) return 1;
+	if (Boolean(rangePreRelease) && versionPreRelease === void 0) return -1;
+	if (rangePreRelease === void 0 && versionPreRelease === void 0) return 0;
+	for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
+		const rangeElement = rangePreRelease[i];
+		const versionElement = versionPreRelease[i];
+		if (rangeElement === versionElement) continue;
+		if (rangeElement === void 0 && versionElement === void 0) return 0;
+		if (!rangeElement) return 1;
+		if (!versionElement) return -1;
+		return compareAtom(rangeElement, versionElement);
+	}
+	return 0;
+}
+function compareVersion(rangeAtom, versionAtom) {
+	return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
+}
+function eq(rangeAtom, versionAtom) {
+	return rangeAtom.version === versionAtom.version;
+}
+function compare(rangeAtom, versionAtom) {
+	switch (rangeAtom.operator) {
+		case "":
+		case "=": return eq(rangeAtom, versionAtom);
+		case ">": return compareVersion(rangeAtom, versionAtom) < 0;
+		case ">=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
+		case "<": return compareVersion(rangeAtom, versionAtom) > 0;
+		case "<=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
+		case void 0: return true;
+		default: return false;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/semver/index.js
+function parseComparatorString(range) {
+	return pipe(parseCarets, parseTildes, parseXRanges, parseStar)(range);
+}
+function parseRange(range) {
+	return pipe(parseHyphen, parseComparatorTrim, parseTildeTrim, parseCaretTrim)(range.trim()).split(/\s+/).join(" ");
+}
+function satisfy(version, range) {
+	if (!version) return false;
+	const extractedVersion = extractComparator(version);
+	if (!extractedVersion) return false;
+	const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease] = extractedVersion;
+	const versionAtom = {
+		operator: versionOperator,
+		version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
+		major: versionMajor,
+		minor: versionMinor,
+		patch: versionPatch,
+		preRelease: versionPreRelease?.split(".")
+	};
+	const orRanges = range.split("||");
+	for (const orRange of orRanges) {
+		const trimmedOrRange = orRange.trim();
+		if (!trimmedOrRange) return true;
+		if (trimmedOrRange === "*" || trimmedOrRange === "x") return true;
+		try {
+			const parsedSubRange = parseRange(trimmedOrRange);
+			if (!parsedSubRange.trim()) return true;
+			const parsedComparatorString = parsedSubRange.split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ");
+			if (!parsedComparatorString.trim()) return true;
+			const comparators = parsedComparatorString.split(/\s+/).map((comparator) => parseGTE0(comparator)).filter(Boolean);
+			if (comparators.length === 0) continue;
+			let subRangeSatisfied = true;
+			for (const comparator of comparators) {
+				const extractedComparator = extractComparator(comparator);
+				if (!extractedComparator) {
+					subRangeSatisfied = false;
+					break;
+				}
+				const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
+				if (!compare({
+					operator: rangeOperator,
+					version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
+					major: rangeMajor,
+					minor: rangeMinor,
+					patch: rangePatch,
+					preRelease: rangePreRelease?.split(".")
+				}, versionAtom)) {
+					subRangeSatisfied = false;
+					break;
+				}
+			}
+			if (subRangeSatisfied) return true;
+		} catch (e) {
+			console.error(`[semver] Error processing range part "${trimmedOrRange}":`, e);
+			continue;
+		}
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/constant.js
+var DEFAULT_SCOPE = "default";
+var DEFAULT_REMOTE_TYPE = "global";
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/share.js
+function formatShare(shareArgs, from, name, shareStrategy) {
+	let get;
+	if ("get" in shareArgs) get = shareArgs.get;
+	else if ("lib" in shareArgs) get = () => Promise.resolve(shareArgs.lib);
+	else get = () => Promise.resolve(() => {
+		error(`Cannot get shared "${name}" from "${from}": neither "get" nor "lib" is provided in the share config.`);
+	});
+	if (shareArgs.shareConfig?.eager && shareArgs.treeShaking?.mode) error(`Invalid shared config for "${name}" from "${from}": cannot use both "eager: true" and "treeShaking.mode" simultaneously. Choose one strategy.`);
+	return {
+		deps: [],
+		useIn: [],
+		from,
+		loading: null,
+		...shareArgs,
+		shareConfig: {
+			requiredVersion: `^${shareArgs.version}`,
+			singleton: false,
+			eager: false,
+			strictVersion: false,
+			...shareArgs.shareConfig
+		},
+		get,
+		loaded: shareArgs?.loaded || "lib" in shareArgs ? true : void 0,
+		version: shareArgs.version ?? "0",
+		scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [shareArgs.scope ?? "default"],
+		strategy: (shareArgs.strategy ?? shareStrategy) || "version-first",
+		treeShaking: shareArgs.treeShaking ? {
+			...shareArgs.treeShaking,
+			mode: shareArgs.treeShaking.mode ?? "server-calc",
+			status: shareArgs.treeShaking.status ?? TreeShakingStatus.UNKNOWN,
+			useIn: []
+		} : void 0
+	};
+}
+function formatShareConfigs(prevOptions, newOptions) {
+	const shareArgs = newOptions.shared || {};
+	const from = newOptions.name;
+	const newShareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
+		const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
+		res[pkgName] = res[pkgName] || [];
+		arrayShareArgs.forEach((shareConfig) => {
+			res[pkgName].push(formatShare(shareConfig, from, pkgName, newOptions.shareStrategy));
+		});
+		return res;
+	}, {});
+	const allShareInfos = { ...prevOptions.shared };
+	Object.keys(newShareInfos).forEach((shareKey) => {
+		if (!allShareInfos[shareKey]) allShareInfos[shareKey] = newShareInfos[shareKey];
+		else newShareInfos[shareKey].forEach((newUserSharedOptions) => {
+			if (!allShareInfos[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version)) allShareInfos[shareKey].push(newUserSharedOptions);
+		});
+	});
+	return {
+		allShareInfos,
+		newShareInfos
+	};
+}
+function shouldUseTreeShaking(treeShaking, usedExports) {
+	if (!treeShaking) return false;
+	const { status, mode } = treeShaking;
+	if (status === TreeShakingStatus.NO_USE) return false;
+	if (status === TreeShakingStatus.CALCULATED) return true;
+	if (mode === "runtime-infer") {
+		if (!usedExports) return true;
+		return isMatchUsedExports(treeShaking, usedExports);
+	}
+	return false;
+}
+/**
+* compare version a and b, return true if a is less than b
+*/
+function versionLt(a, b) {
+	const transformInvalidVersion = (version) => {
+		if (!Number.isNaN(Number(version))) {
+			const splitArr = version.split(".");
+			let validVersion = version;
+			for (let i = 0; i < 3 - splitArr.length; i++) validVersion += ".0";
+			return validVersion;
+		}
+		return version;
+	};
+	if (satisfy(transformInvalidVersion(a), `<=${transformInvalidVersion(b)}`)) return true;
+	else return false;
+}
+var findVersion = (shareVersionMap, cb) => {
+	const callback = cb || function(prev, cur) {
+		return versionLt(prev, cur);
+	};
+	return Object.keys(shareVersionMap).reduce((prev, cur) => {
+		if (!prev) return cur;
+		if (callback(prev, cur)) return cur;
+		if (prev === "0") return cur;
+		return prev;
+	}, 0);
+};
+var isLoaded = (shared) => {
+	return Boolean(shared.loaded) || typeof shared.lib === "function";
+};
+var isLoading = (shared) => {
+	return Boolean(shared.loading);
+};
+var isMatchUsedExports = (treeShaking, usedExports) => {
+	if (!treeShaking || !usedExports) return false;
+	const { usedExports: treeShakingUsedExports } = treeShaking;
+	if (!treeShakingUsedExports) return false;
+	if (usedExports.every((e) => treeShakingUsedExports.includes(e))) return true;
+	return false;
+};
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeShaking) {
+	const versions = shareScopeMap[scope][pkgName];
+	let version = "";
+	let useTreesShaking = shouldUseTreeShaking(treeShaking);
+	const callback = function(prev, cur) {
+		if (useTreesShaking) {
+			if (!versions[prev].treeShaking) return true;
+			if (!versions[cur].treeShaking) return false;
+			return !isLoaded(versions[prev].treeShaking) && versionLt(prev, cur);
+		}
+		return !isLoaded(versions[prev]) && versionLt(prev, cur);
+	};
+	if (useTreesShaking) {
+		version = findVersion(shareScopeMap[scope][pkgName], callback);
+		if (version) return {
+			version,
+			useTreesShaking
+		};
+		useTreesShaking = false;
+	}
+	return {
+		version: findVersion(shareScopeMap[scope][pkgName], callback),
+		useTreesShaking
+	};
+}
+var isLoadingOrLoaded = (shared) => {
+	return isLoaded(shared) || isLoading(shared);
+};
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeShaking) {
+	const versions = shareScopeMap[scope][pkgName];
+	let version = "";
+	let useTreesShaking = shouldUseTreeShaking(treeShaking);
+	const callback = function(prev, cur) {
+		if (useTreesShaking) {
+			if (!versions[prev].treeShaking) return true;
+			if (!versions[cur].treeShaking) return false;
+			if (isLoadingOrLoaded(versions[cur].treeShaking)) if (isLoadingOrLoaded(versions[prev].treeShaking)) return Boolean(versionLt(prev, cur));
+			else return true;
+			if (isLoadingOrLoaded(versions[prev].treeShaking)) return false;
+		}
+		if (isLoadingOrLoaded(versions[cur])) if (isLoadingOrLoaded(versions[prev])) return Boolean(versionLt(prev, cur));
+		else return true;
+		if (isLoadingOrLoaded(versions[prev])) return false;
+		return versionLt(prev, cur);
+	};
+	if (useTreesShaking) {
+		version = findVersion(shareScopeMap[scope][pkgName], callback);
+		if (version) return {
+			version,
+			useTreesShaking
+		};
+		useTreesShaking = false;
+	}
+	return {
+		version: findVersion(shareScopeMap[scope][pkgName], callback),
+		useTreesShaking
+	};
+}
+function getFindShareFunction(strategy) {
+	if (strategy === "loaded-first") return findSingletonVersionOrderByLoaded;
+	return findSingletonVersionOrderByVersion;
+}
+function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare) {
+	if (!localShareScopeMap) return;
+	const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeShaking } = shareInfo;
+	const scopes = Array.isArray(scope) ? scope : [scope];
+	for (const sc of scopes) if (shareConfig && localShareScopeMap[sc] && localShareScopeMap[sc][pkgName]) {
+		const { requiredVersion } = shareConfig;
+		const { version: maxOrSingletonVersion, useTreesShaking } = getFindShareFunction(strategy)(localShareScopeMap, sc, pkgName, treeShaking);
+		const defaultResolver = () => {
+			const shared = localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+			if (shareConfig.singleton) {
+				if (typeof requiredVersion === "string" && !satisfy(maxOrSingletonVersion, requiredVersion)) {
+					const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && shared.from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
+					if (shareConfig.strictVersion) error(msg);
+					else warn$1(msg);
+				}
+				return {
+					shared,
+					useTreesShaking
+				};
+			} else {
+				if (requiredVersion === false || requiredVersion === "*") return {
+					shared,
+					useTreesShaking
+				};
+				if (satisfy(maxOrSingletonVersion, requiredVersion)) return {
+					shared,
+					useTreesShaking
+				};
+				const _usedTreeShaking = shouldUseTreeShaking(treeShaking);
+				if (_usedTreeShaking) for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
+					if (!shouldUseTreeShaking(versionValue.treeShaking, treeShaking?.usedExports)) continue;
+					if (satisfy(versionKey, requiredVersion)) return {
+						shared: versionValue,
+						useTreesShaking: _usedTreeShaking
+					};
+				}
+				for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) if (satisfy(versionKey, requiredVersion)) return {
+					shared: versionValue,
+					useTreesShaking: false
+				};
+			}
+		};
+		const params = {
+			shareScopeMap: localShareScopeMap,
+			scope: sc,
+			pkgName,
+			version: maxOrSingletonVersion,
+			GlobalFederation: Global.__FEDERATION__,
+			shareInfo,
+			resolver: defaultResolver
+		};
+		return (resolveShare.emit(params) || params).resolver();
+	}
+}
+function getGlobalShareScope() {
+	return Global.__FEDERATION__.__SHARE__;
+}
+function getTargetSharedOptions(options) {
+	const { pkgName, extraOptions, shareInfos } = options;
+	const defaultResolver = (sharedOptions) => {
+		if (!sharedOptions) return;
+		const shareVersionMap = {};
+		sharedOptions.forEach((shared) => {
+			shareVersionMap[shared.version] = shared;
+		});
+		const callback = function(prev, cur) {
+			return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
+		};
+		return shareVersionMap[findVersion(shareVersionMap, callback)];
+	};
+	const resolver = extraOptions?.resolver ?? defaultResolver;
+	const isPlainObject = (val) => {
+		return val !== null && typeof val === "object" && !Array.isArray(val);
+	};
+	const merge = (...sources) => {
+		const out = {};
+		for (const src of sources) {
+			if (!src) continue;
+			for (const [key, value] of Object.entries(src)) {
+				const prev = out[key];
+				if (isPlainObject(prev) && isPlainObject(value)) out[key] = merge(prev, value);
+				else if (value !== void 0) out[key] = value;
+			}
+		}
+		return out;
+	};
+	return merge(resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
+}
+var addUseIn = (shared, from) => {
+	if (!shared.useIn) shared.useIn = [];
+	addUniqueItem(shared.useIn, from);
+};
+function directShare(shared, useTreesShaking) {
+	if (useTreesShaking && shared.treeShaking) return shared.treeShaking;
+	return shared;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/manifest.js
+function composeRemoteRequestId(remoteName, expose) {
+	if (!expose || expose === ".") return remoteName;
+	return `${remoteName}/${expose.replace(/^\.\//, "")}`;
+}
+function matchRemoteWithNameAndExpose(remotes, id) {
+	for (const remote of remotes) {
+		const isNameMatched = id.startsWith(remote.name);
+		let expose = id.replace(remote.name, "");
+		if (isNameMatched) {
+			if (expose.startsWith("/")) {
+				const pkgNameOrAlias = remote.name;
+				expose = `.${expose}`;
+				return {
+					pkgNameOrAlias,
+					expose,
+					remote
+				};
+			} else if (expose === "") return {
+				pkgNameOrAlias: remote.name,
+				expose: ".",
+				remote
+			};
+		}
+		const isAliasMatched = remote.alias && id.startsWith(remote.alias);
+		let exposeWithAlias = remote.alias && id.replace(remote.alias, "");
+		if (remote.alias && isAliasMatched) {
+			if (exposeWithAlias && exposeWithAlias.startsWith("/")) {
+				const pkgNameOrAlias = remote.alias;
+				exposeWithAlias = `.${exposeWithAlias}`;
+				return {
+					pkgNameOrAlias,
+					expose: exposeWithAlias,
+					remote
+				};
+			} else if (exposeWithAlias === "") return {
+				pkgNameOrAlias: remote.alias,
+				expose: ".",
+				remote
+			};
+		}
+	}
+}
+function matchRemote(remotes, nameOrAlias) {
+	for (const remote of remotes) {
+		if (nameOrAlias === remote.name) return remote;
+		if (remote.alias && nameOrAlias === remote.alias) return remote;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+error-codes@2.6.0/node_modules/@module-federation/error-codes/dist/error-codes.mjs
+var RUNTIME_001 = "RUNTIME-001";
+var RUNTIME_002 = "RUNTIME-002";
+var RUNTIME_003 = "RUNTIME-003";
+var RUNTIME_004 = "RUNTIME-004";
+var RUNTIME_005 = "RUNTIME-005";
+var RUNTIME_006 = "RUNTIME-006";
+var RUNTIME_007 = "RUNTIME-007";
+var RUNTIME_008 = "RUNTIME-008";
+var RUNTIME_009 = "RUNTIME-009";
+var RUNTIME_010 = "RUNTIME-010";
+var RUNTIME_011 = "RUNTIME-011";
+var RUNTIME_012 = "RUNTIME-012";
+var RUNTIME_013 = "RUNTIME-013";
+var RUNTIME_014 = "RUNTIME-014";
+var RUNTIME_015 = "RUNTIME-015";
+var TYPE_001 = "TYPE-001";
+var BUILD_001 = "BUILD-001";
+var BUILD_002 = "BUILD-002";
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+error-codes@2.6.0/node_modules/@module-federation/error-codes/dist/desc.mjs
+var runtimeDescMap = {
+	[RUNTIME_001]: "Failed to get remoteEntry exports.",
+	[RUNTIME_002]: "The remote entry interface does not contain \"init\"",
+	[RUNTIME_003]: "Failed to get manifest.",
+	[RUNTIME_004]: "Failed to locate remote.",
+	[RUNTIME_005]: "Invalid loadShareSync function call from bundler runtime",
+	[RUNTIME_006]: "Invalid loadShareSync function call from runtime",
+	[RUNTIME_007]: "Failed to get remote snapshot.",
+	[RUNTIME_008]: "Failed to load script resources.",
+	[RUNTIME_009]: "Please call createInstance first.",
+	[RUNTIME_010]: "The name option cannot be changed after initialization. If you want to create a new instance with a different name, please use \"createInstance\" api.",
+	[RUNTIME_011]: "The remoteEntry URL is missing from the remote snapshot.",
+	[RUNTIME_012]: "The getter for the shared module is not a function. This may be caused by setting \"shared.import: false\" without the host providing the corresponding lib.",
+	[RUNTIME_013]: "The manifest is not a valid Module Federation manifest.",
+	[RUNTIME_014]: "The remote does not expose the requested module.",
+	[RUNTIME_015]: "Remote container initialization failed."
+};
+var typeDescMap = { [TYPE_001]: "Failed to generate type declaration. Execute the below cmd to reproduce and fix the error." };
+var buildDescMap = {
+	[BUILD_001]: "Failed to find expose module.",
+	[BUILD_002]: "PublicPath is required in prod mode."
+};
+({
+	...runtimeDescMap,
+	...typeDescMap,
+	...buildDescMap
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/load.js
+var importCallback = ".then(callbacks[0]).catch(callbacks[1])";
+async function loadEsmEntry({ entry, remoteEntryExports }) {
+	return new Promise((resolve, reject) => {
+		try {
+			if (!remoteEntryExports) if (typeof FEDERATION_ALLOW_NEW_FUNCTION !== "undefined") new Function("callbacks", `import("${entry}")${importCallback}`)([resolve, reject]);
+			else __vitePreload(() => import(
+				/* webpackIgnore: true */
+				/* @vite-ignore */
+				entry
+).then(resolve), [], import.meta.url).catch(reject);
+			else resolve(remoteEntryExports);
+		} catch (e) {
+			error(`Failed to load ESM entry from "${entry}". ${e instanceof Error ? e.message : String(e)}`);
+		}
+	});
+}
+async function loadSystemJsEntry({ entry, remoteEntryExports }) {
+	return new Promise((resolve, reject) => {
+		try {
+			if (!remoteEntryExports) if (typeof __system_context__ === "undefined") System.import(entry).then(resolve).catch(reject);
+			else new Function("callbacks", `System.import("${entry}")${importCallback}`)([resolve, reject]);
+			else resolve(remoteEntryExports);
+		} catch (e) {
+			error(`Failed to load SystemJS entry from "${entry}". ${e instanceof Error ? e.message : String(e)}`);
+		}
+	});
+}
+function handleRemoteEntryLoaded(name, globalName, entry) {
+	const { remoteEntryKey, entryExports } = getRemoteEntryExports(name, globalName);
+	if (!entryExports) error(RUNTIME_001, runtimeDescMap, {
+		remoteName: name,
+		remoteEntryUrl: entry,
+		remoteEntryKey
+	});
+	return entryExports;
+}
+async function loadEntryScript({ name, globalName, entry, remoteInfo, loaderHook, getEntryUrl, resourceContext }) {
+	const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
+	if (remoteEntryExports) return remoteEntryExports;
+	const url = getEntryUrl ? getEntryUrl(entry) : entry;
+	return loadScript(url, {
+		attrs: {},
+		createScriptHook: (url, attrs) => {
+			const res = loaderHook.lifecycle.createScript.emit({
+				url,
+				attrs,
+				remoteInfo,
+				resourceContext: resourceContext ? {
+					...resourceContext,
+					url
+				} : void 0
+			});
+			if (!res) return;
+			if (res instanceof HTMLScriptElement) return res;
+			if ("script" in res || "timeout" in res) return res;
+		}
+	}).then(() => {
+		return handleRemoteEntryLoaded(name, globalName, entry);
+	}, (loadError) => {
+		const originalMsg = loadError instanceof Error ? loadError.message : String(loadError);
+		error(RUNTIME_008, runtimeDescMap, {
+			remoteName: name,
+			resourceUrl: url
+		}, originalMsg);
+	});
+}
+async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl, resourceContext }) {
+	const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
+	switch (type) {
+		case "esm":
+		case "module": return loadEsmEntry({
+			entry,
+			remoteEntryExports
+		});
+		case "system": return loadSystemJsEntry({
+			entry,
+			remoteEntryExports
+		});
+		default: return loadEntryScript({
+			entry,
+			globalName,
+			name,
+			remoteInfo,
+			loaderHook,
+			getEntryUrl,
+			resourceContext
+		});
+	}
+}
+function getRemoteEntryUniqueKey(remoteInfo) {
+	const { entry, name } = remoteInfo;
+	return composeKeyWithSeparator(name, entry);
+}
+async function getRemoteEntry(params) {
+	const { origin, remoteEntryExports, remoteInfo, getEntryUrl, resourceContext, _inErrorHandling = false } = params;
+	const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+	if (remoteEntryExports) return remoteEntryExports;
+	if (!globalLoading[uniqueKey]) {
+		const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
+		const loaderHook = origin.loaderHook;
+		globalLoading[uniqueKey] = loadEntryHook.emit({
+			origin,
+			loaderHook,
+			remoteInfo,
+			remoteEntryExports
+		}).then((res) => {
+			if (res) return res;
+			return loadEntryDom({
+				remoteInfo,
+				remoteEntryExports,
+				loaderHook,
+				getEntryUrl,
+				resourceContext
+			});
+		}).then(async (res) => {
+			await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+				origin,
+				remoteInfo,
+				remoteEntryExports: res
+			});
+			return res;
+		}).catch(async (err) => {
+			const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+			const isScriptExecutionError = err instanceof Error && err.message.includes("ScriptExecutionError");
+			if (err instanceof Error && err.message.includes("RUNTIME-008") && !isScriptExecutionError && !_inErrorHandling) {
+				const wrappedGetRemoteEntry = (params) => {
+					return getRemoteEntry({
+						...params,
+						_inErrorHandling: true
+					});
+				};
+				const RemoteEntryExports = await origin.loaderHook.lifecycle.loadEntryError.emit({
+					getRemoteEntry: wrappedGetRemoteEntry,
+					origin,
+					remoteInfo,
+					remoteEntryExports,
+					globalLoading,
+					uniqueKey
+				});
+				if (RemoteEntryExports) {
+					await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+						origin,
+						remoteInfo,
+						remoteEntryExports: RemoteEntryExports,
+						recovered: true
+					});
+					return RemoteEntryExports;
+				}
+			}
+			await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+				origin,
+				remoteInfo,
+				error: err
+			});
+			throw err;
+		});
+	}
+	return globalLoading[uniqueKey];
+}
+function getRemoteInfo(remote) {
+	return {
+		...remote,
+		entry: "entry" in remote ? remote.entry : "",
+		type: remote.type || "global",
+		entryGlobalName: remote.entryGlobalName || remote.name,
+		shareScope: remote.shareScope || "default"
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/env.js
+function getBuilderId$1() {
+	return typeof FEDERATION_BUILD_IDENTIFIER !== "undefined" ? FEDERATION_BUILD_IDENTIFIER : "";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/plugin.js
+function registerPlugins(plugins, instance) {
+	const globalPlugins = getGlobalHostPlugins();
+	const hookInstances = [
+		instance.hooks,
+		instance.remoteHandler.hooks,
+		instance.sharedHandler.hooks,
+		instance.snapshotHandler.hooks,
+		instance.loaderHook,
+		instance.bridgeHook
+	];
+	if (globalPlugins.length > 0) globalPlugins.forEach((plugin) => {
+		if (plugins?.find((item) => item.name !== plugin.name)) plugins.push(plugin);
+	});
+	if (plugins && plugins.length > 0) plugins.forEach((plugin) => {
+		hookInstances.forEach((hookInstance) => {
+			hookInstance.applyPlugin(plugin, instance);
+		});
+	});
+	return plugins;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/context.js
+function remoteToEntry(r) {
+	return {
+		name: r.name,
+		alias: r.alias,
+		entry: "entry" in r ? r.entry : void 0,
+		version: "version" in r ? r.version : void 0,
+		type: r.type,
+		entryGlobalName: r.entryGlobalName,
+		shareScope: r.shareScope
+	};
+}
+/**
+* Build a partial MFContext from runtime Options.
+* Used to enrich diagnostic entries with host context at error sites.
+*/
+function optionsToMFContext(options) {
+	const shared = {};
+	for (const [pkgName, versions] of Object.entries(options.shared)) {
+		const first = versions[0];
+		if (first) shared[pkgName] = {
+			version: first.version,
+			singleton: first.shareConfig?.singleton,
+			requiredVersion: first.shareConfig?.requiredVersion === false ? false : first.shareConfig?.requiredVersion,
+			eager: first.eager,
+			strictVersion: first.shareConfig?.strictVersion
+		};
+	}
+	return {
+		project: {
+			name: options.name,
+			mfRole: options.remotes?.length > 0 ? "host" : "unknown"
+		},
+		mfConfig: {
+			name: options.name,
+			remotes: options.remotes?.map(remoteToEntry) ?? [],
+			shared
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/preload.js
+function defaultPreloadArgs(preloadConfig) {
+	return {
+		resourceCategory: "sync",
+		share: true,
+		depsRemote: true,
+		...preloadConfig
+	};
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+	return preloadArgs.map((args) => {
+		const remoteInfo = matchRemote(remotes, args.nameOrAlias);
+		assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && safeToString({
+			remoteInfo,
+			remotes
+		})}`);
+		return {
+			remote: remoteInfo,
+			preloadConfig: defaultPreloadArgs(args)
+		};
+	});
+}
+function normalizePreloadExposes(exposes) {
+	if (!exposes) return [];
+	return exposes.map((expose) => {
+		if (expose === ".") return expose;
+		if (expose.startsWith("./")) return expose.replace("./", "");
+		return expose;
+	});
+}
+function isTimeoutError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("timed out") || error.name.includes("Timeout");
+}
+function createAssetResult(context, url, status, error) {
+	return {
+		url,
+		status,
+		resourceType: context.resourceType,
+		initiator: context.initiator,
+		id: context.id,
+		error
+	};
+}
+async function waitForRemoteEntryPreload(host, remoteInfo, entryRemoteInfo, context) {
+	const cachedRemote = host.moduleCache.get(entryRemoteInfo.name);
+	const url = entryRemoteInfo.entry;
+	if (cachedRemote?.remoteEntryExports) return createAssetResult(context, url, "cached");
+	try {
+		if (!await getRemoteEntry({
+			origin: host,
+			remoteInfo: entryRemoteInfo,
+			remoteEntryExports: cachedRemote?.remoteEntryExports,
+			resourceContext: {
+				...context,
+				url
+			}
+		})) throw new Error(`Failed to load remoteEntry "${url}".`);
+		return createAssetResult(context, url, "success");
+	} catch (error) {
+		return createAssetResult(context, url, isTimeoutError(error) ? "timeout" : "error", error);
+	}
+}
+function waitForLinkPreload({ host, remoteInfo, url, attrs, context, needDeleteLink }) {
+	return new Promise((resolve) => {
+		const { link, needAttach } = createLink({
+			url,
+			cb: () => {
+				resolve(createAssetResult(context, url, needAttach ? "success" : "cached"));
+			},
+			onErrorCallback: (error) => {
+				resolve(createAssetResult(context, url, isTimeoutError(error) ? "timeout" : "error", error));
+			},
+			attrs,
+			createLinkHook: (hookUrl, hookAttrs) => {
+				const res = host.loaderHook.lifecycle.createLink.emit({
+					url: hookUrl,
+					attrs: hookAttrs,
+					remoteInfo,
+					resourceContext: {
+						...context,
+						url: hookUrl
+					}
+				});
+				if (res instanceof HTMLLinkElement) return res;
+				return res;
+			},
+			needDeleteLink
+		});
+		needAttach && document.head.appendChild(link);
+	});
+}
+function waitForScriptPreload({ host, remoteInfo, url, attrs, context }) {
+	return new Promise((resolve) => {
+		const { script, needAttach } = createScript({
+			url,
+			cb: () => {
+				resolve(createAssetResult(context, url, needAttach ? "success" : "cached"));
+			},
+			onErrorCallback: (error) => {
+				resolve(createAssetResult(context, url, isTimeoutError(error) ? "timeout" : "error", error));
+			},
+			attrs,
+			createScriptHook: (hookUrl, hookAttrs) => {
+				const res = host.loaderHook.lifecycle.createScript.emit({
+					url: hookUrl,
+					attrs: hookAttrs,
+					remoteInfo,
+					resourceContext: {
+						...context,
+						url: hookUrl
+					}
+				});
+				if (res instanceof HTMLScriptElement) return res;
+				return res;
+			},
+			needDeleteScript: true
+		});
+		needAttach && document.head.appendChild(script);
+	});
+}
+function createResourceContext(baseContext, resourceType) {
+	return {
+		...baseContext,
+		resourceType
+	};
+}
+function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseContext = {
+	initiator: "preloadRemote",
+	id: remoteInfo.name
+}) {
+	const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+	const results = [];
+	if (host.options.inBrowser) {
+		entryAssets.forEach((asset) => {
+			const { moduleInfo: entryRemoteInfo } = asset;
+			results.push(waitForRemoteEntryPreload(host, remoteInfo, entryRemoteInfo, createResourceContext(baseContext, "remoteEntry")));
+		});
+		if (useLinkPreload) {
+			const defaultAttrs = {
+				rel: "preload",
+				as: "style"
+			};
+			cssAssets.forEach((cssUrl) => {
+				results.push(waitForLinkPreload({
+					host,
+					remoteInfo,
+					url: cssUrl,
+					attrs: defaultAttrs,
+					context: createResourceContext(baseContext, "css")
+				}));
+			});
+		} else {
+			const defaultAttrs = {
+				rel: "stylesheet",
+				type: "text/css"
+			};
+			cssAssets.forEach((cssUrl) => {
+				results.push(waitForLinkPreload({
+					host,
+					remoteInfo,
+					url: cssUrl,
+					attrs: defaultAttrs,
+					needDeleteLink: false,
+					context: createResourceContext(baseContext, "css")
+				}));
+			});
+		}
+		if (useLinkPreload) {
+			const defaultAttrs = {
+				rel: "preload",
+				as: "script"
+			};
+			jsAssetsWithoutEntry.forEach((jsUrl) => {
+				results.push(waitForLinkPreload({
+					host,
+					remoteInfo,
+					url: jsUrl,
+					attrs: defaultAttrs,
+					context: createResourceContext(baseContext, "js")
+				}));
+			});
+		} else {
+			const defaultAttrs = {
+				fetchpriority: "high",
+				type: remoteInfo?.type === "module" ? "module" : "text/javascript"
+			};
+			jsAssetsWithoutEntry.forEach((jsUrl) => {
+				results.push(waitForScriptPreload({
+					host,
+					remoteInfo,
+					url: jsUrl,
+					attrs: defaultAttrs,
+					context: createResourceContext(baseContext, "js")
+				}));
+			});
+		}
+	}
+	return Promise.all(results);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/module/index.js
+function getAvailableExposeNames(remoteSnapshot) {
+	if (!remoteSnapshot || !("modules" in remoteSnapshot) || !Array.isArray(remoteSnapshot.modules)) return;
+	const exposes = remoteSnapshot.modules.map((module) => module.moduleName).filter(Boolean);
+	return exposes.length ? exposes.join(",") : void 0;
+}
+function createRemoteEntryInitOptions(remoteInfo, hostShareScopeMap, rawInitScope) {
+	const localShareScopeMap = hostShareScopeMap;
+	const shareScopeKeys = Array.isArray(remoteInfo.shareScope) ? remoteInfo.shareScope : [remoteInfo.shareScope];
+	if (!shareScopeKeys.length) shareScopeKeys.push("default");
+	shareScopeKeys.forEach((shareScopeKey) => {
+		if (!localShareScopeMap[shareScopeKey]) localShareScopeMap[shareScopeKey] = {};
+	});
+	const remoteEntryInitOptions = {
+		version: remoteInfo.version || "",
+		shareScopeKeys: Array.isArray(remoteInfo.shareScope) ? shareScopeKeys : remoteInfo.shareScope || "default"
+	};
+	Object.defineProperty(remoteEntryInitOptions, "shareScopeMap", {
+		value: localShareScopeMap,
+		enumerable: false
+	});
+	return {
+		remoteEntryInitOptions,
+		shareScope: localShareScopeMap[shareScopeKeys[0]],
+		initScope: rawInitScope ?? []
+	};
+}
+var Module$1 = class {
+	constructor({ remoteInfo, host }) {
+		this.inited = false;
+		this.initing = false;
+		this.lib = void 0;
+		this.remoteInfo = remoteInfo;
+		this.host = host;
+	}
+	async getEntry(expose) {
+		if (this.remoteEntryExports) return this.remoteEntryExports;
+		const remoteEntryExports = await getRemoteEntry({
+			origin: this.host,
+			remoteInfo: this.remoteInfo,
+			remoteEntryExports: this.remoteEntryExports,
+			resourceContext: {
+				initiator: "loadRemote",
+				id: composeRemoteRequestId(this.remoteInfo.name, expose),
+				resourceType: "remoteEntry"
+			}
+		});
+		assert(remoteEntryExports, `remoteEntryExports is undefined \n ${safeToString(this.remoteInfo)}`);
+		this.remoteEntryExports = remoteEntryExports;
+		return this.remoteEntryExports;
+	}
+	async init(id, remoteSnapshot, rawInitScope, expose) {
+		const remoteEntryExports = await this.getEntry(expose);
+		if (this.inited) {
+			await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+				id,
+				remoteInfo: this.remoteInfo,
+				remoteSnapshot,
+				remoteEntryExports,
+				cached: true,
+				origin: this.host
+			});
+			return remoteEntryExports;
+		}
+		if (this.initPromise) {
+			try {
+				await this.initPromise;
+				await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+					id,
+					remoteInfo: this.remoteInfo,
+					remoteSnapshot,
+					remoteEntryExports,
+					cached: true,
+					origin: this.host
+				});
+			} catch (initError) {
+				await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+					id,
+					remoteInfo: this.remoteInfo,
+					remoteSnapshot,
+					remoteEntryExports,
+					error: initError,
+					cached: true,
+					origin: this.host
+				});
+				throw initError;
+			}
+			return remoteEntryExports;
+		}
+		this.initing = true;
+		this.initPromise = (async () => {
+			await this.host.loaderHook.lifecycle.beforeInitRemote.emit({
+				id,
+				remoteInfo: this.remoteInfo,
+				remoteSnapshot,
+				origin: this.host
+			});
+			const { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap, rawInitScope);
+			const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
+				shareScope,
+				remoteEntryInitOptions,
+				initScope,
+				remoteInfo: this.remoteInfo,
+				origin: this.host
+			});
+			if (typeof remoteEntryExports?.init === "undefined") error(RUNTIME_002, runtimeDescMap, {
+				hostName: this.host.name,
+				remoteName: this.remoteInfo.name,
+				remoteEntryUrl: this.remoteInfo.entry,
+				remoteEntryKey: this.remoteInfo.entryGlobalName
+			}, void 0, optionsToMFContext(this.host.options));
+			try {
+				await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
+			} catch (initError) {
+				error(RUNTIME_015, runtimeDescMap, {
+					hostName: this.host.name,
+					remoteName: this.remoteInfo.name,
+					remoteEntryUrl: this.remoteInfo.entry,
+					remoteEntryKey: this.remoteInfo.entryGlobalName,
+					shareScope: this.remoteInfo.shareScope
+				}, `${initError}`, optionsToMFContext(this.host.options));
+			}
+			await this.host.hooks.lifecycle.initContainer.emit({
+				...initContainerOptions,
+				id,
+				remoteSnapshot,
+				remoteEntryExports
+			});
+			this.inited = true;
+		})();
+		try {
+			await this.initPromise;
+			await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+				id,
+				remoteInfo: this.remoteInfo,
+				remoteSnapshot,
+				remoteEntryExports,
+				origin: this.host
+			});
+		} catch (initError) {
+			await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+				id,
+				remoteInfo: this.remoteInfo,
+				remoteSnapshot,
+				remoteEntryExports,
+				error: initError,
+				origin: this.host
+			});
+			throw initError;
+		} finally {
+			this.initing = false;
+			this.initPromise = void 0;
+		}
+		return remoteEntryExports;
+	}
+	async get(id, expose, options, remoteSnapshot) {
+		const { loadFactory = true } = options || { loadFactory: true };
+		const remoteEntryExports = await this.init(id, remoteSnapshot, void 0, expose);
+		this.lib = remoteEntryExports;
+		await this.host.loaderHook.lifecycle.beforeGetExpose.emit({
+			id,
+			expose,
+			moduleInfo: this.remoteInfo,
+			remoteEntryExports,
+			origin: this.host
+		});
+		let moduleFactory;
+		try {
+			const hookModuleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+				remoteEntryExports,
+				expose,
+				moduleInfo: this.remoteInfo
+			});
+			moduleFactory = typeof hookModuleFactory === "function" ? hookModuleFactory : void 0;
+			if (!moduleFactory) moduleFactory = await remoteEntryExports.get(expose);
+			if (!moduleFactory) error(RUNTIME_014, runtimeDescMap, {
+				hostName: this.host.name,
+				remoteName: this.remoteInfo.name,
+				remoteEntryUrl: this.remoteInfo.entry,
+				expose,
+				requestId: id,
+				availableExposes: getAvailableExposeNames(remoteSnapshot)
+			}, void 0, optionsToMFContext(this.host.options));
+			await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+				id,
+				expose,
+				moduleInfo: this.remoteInfo,
+				remoteEntryExports,
+				moduleFactory,
+				origin: this.host
+			});
+		} catch (getExposeError) {
+			await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+				id,
+				expose,
+				moduleInfo: this.remoteInfo,
+				remoteEntryExports,
+				error: getExposeError,
+				origin: this.host
+			});
+			throw getExposeError;
+		}
+		const symbolName = processModuleAlias(this.remoteInfo.name, expose);
+		const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
+		if (!loadFactory) return wrapModuleFactory;
+		await this.host.loaderHook.lifecycle.beforeExecuteFactory.emit({
+			id,
+			expose,
+			moduleInfo: this.remoteInfo,
+			loadFactory,
+			origin: this.host
+		});
+		try {
+			const exposeContent = await wrapModuleFactory();
+			await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+				id,
+				expose,
+				moduleInfo: this.remoteInfo,
+				loadFactory,
+				exposeModule: exposeContent,
+				origin: this.host
+			});
+			return exposeContent;
+		} catch (executeFactoryError) {
+			await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+				id,
+				expose,
+				moduleInfo: this.remoteInfo,
+				loadFactory,
+				error: executeFactoryError,
+				origin: this.host
+			});
+			throw executeFactoryError;
+		}
+	}
+	wraperFactory(moduleFactory, id) {
+		function defineModuleId(res, id) {
+			if (res && typeof res === "object" && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for("mf_module_id"))) Object.defineProperty(res, Symbol.for("mf_module_id"), {
+				value: id,
+				enumerable: false
+			});
+		}
+		return () => {
+			const res = moduleFactory();
+			if (res instanceof Promise) return res.then((asyncRes) => {
+				defineModuleId(asyncRes, id);
+				return asyncRes;
+			});
+			defineModuleId(res, id);
+			return res;
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/hooks/syncHook.js
+var SyncHook = class {
+	constructor(type) {
+		this.type = "";
+		this.listeners = /* @__PURE__ */ new Set();
+		if (type) this.type = type;
+	}
+	on(fn) {
+		if (typeof fn === "function") this.listeners.add(fn);
+	}
+	once(fn) {
+		const self = this;
+		this.on(function wrapper(...args) {
+			self.remove(wrapper);
+			return fn.apply(null, args);
+		});
+	}
+	emit(...data) {
+		let result;
+		if (this.listeners.size > 0) this.listeners.forEach((fn) => {
+			const nextResult = fn(...data);
+			if (nextResult !== void 0) result = nextResult;
+		});
+		return result;
+	}
+	remove(fn) {
+		this.listeners.delete(fn);
+	}
+	removeAll() {
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/hooks/asyncHook.js
+var AsyncHook = class extends SyncHook {
+	emit(...data) {
+		let result;
+		const ls = Array.from(this.listeners);
+		if (ls.length > 0) {
+			let i = 0;
+			const call = (prev) => {
+				if (prev === false) return false;
+				else if (i < ls.length) return Promise.resolve(ls[i++].apply(null, data)).then((result) => {
+					if (result === void 0 || data.length === 1 && result === data[0]) return call(prev);
+					return call(result);
+				});
+				else return prev;
+			};
+			result = call();
+		}
+		return Promise.resolve(result);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/hooks/syncWaterfallHook.js
+function checkReturnData(originalData, returnedData) {
+	if (!isObject(returnedData)) return false;
+	if (originalData !== returnedData) {
+		for (const key in originalData) if (!(key in returnedData)) return false;
+	}
+	return true;
+}
+var SyncWaterfallHook = class extends SyncHook {
+	constructor(type) {
+		super();
+		this.onerror = error;
+		this.type = type;
+	}
+	emit(data) {
+		if (!isObject(data)) error(`The data for the "${this.type}" hook should be an object.`);
+		for (const fn of this.listeners) try {
+			const tempData = fn(data);
+			if (tempData === void 0) continue;
+			if (checkReturnData(data, tempData)) data = tempData;
+			else {
+				this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+				break;
+			}
+		} catch (e) {
+			warn$1(e);
+			this.onerror(e);
+		}
+		return data;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/hooks/asyncWaterfallHooks.js
+var AsyncWaterfallHook = class extends SyncHook {
+	constructor(type) {
+		super();
+		this.onerror = error;
+		this.type = type;
+	}
+	emit(data) {
+		if (!isObject(data)) error(`The response data for the "${this.type}" hook must be an object.`);
+		const ls = Array.from(this.listeners);
+		if (ls.length > 0) {
+			let i = 0;
+			const processError = (e) => {
+				warn$1(e);
+				this.onerror(e);
+				return data;
+			};
+			const call = (prevData) => {
+				if (prevData !== void 0 && checkReturnData(data, prevData)) data = prevData;
+				else if (prevData !== void 0) {
+					this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
+					return data;
+				}
+				if (i < ls.length) try {
+					return Promise.resolve(ls[i++](data)).then(call, processError);
+				} catch (e) {
+					return processError(e);
+				}
+				return data;
+			};
+			return Promise.resolve(call(data));
+		}
+		return Promise.resolve(data);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/utils/hooks/pluginSystem.js
+var PluginSystem = class {
+	constructor(lifecycle) {
+		this.registerPlugins = {};
+		this.lifecycle = lifecycle;
+		this.lifecycleKeys = Object.keys(lifecycle);
+	}
+	applyPlugin(plugin, instance) {
+		assert(isPlainObject(plugin), "Plugin configuration is invalid.");
+		const pluginName = plugin.name;
+		assert(pluginName, "A name must be provided by the plugin.");
+		if (!this.registerPlugins[pluginName]) {
+			this.registerPlugins[pluginName] = plugin;
+			plugin.apply?.(instance);
+			Object.keys(this.lifecycle).forEach((key) => {
+				const pluginLife = plugin[key];
+				if (pluginLife) this.lifecycle[key].on(pluginLife);
+			});
+		}
+	}
+	removePlugin(pluginName) {
+		assert(pluginName, "A name is required.");
+		const plugin = this.registerPlugins[pluginName];
+		assert(plugin, `The plugin "${pluginName}" is not registered.`);
+		Object.keys(plugin).forEach((key) => {
+			if (key !== "name") this.lifecycle[key].remove(plugin[key]);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/plugins/snapshot/index.js
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+	const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
+	if (!remoteEntryInfo.url) error(RUNTIME_011, runtimeDescMap, { remoteName: remoteInfo.name });
+	let entryUrl = getResourceUrl(remoteSnapshot, remoteEntryInfo.url);
+	remoteInfo.type = remoteEntryInfo.type;
+	remoteInfo.entryGlobalName = remoteEntryInfo.globalName;
+	remoteInfo.entry = entryUrl;
+	remoteInfo.version = remoteSnapshot.version;
+	remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+	return {
+		name: "snapshot-plugin",
+		async afterResolve(args) {
+			const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;
+			if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {
+				const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo({
+					moduleInfo: remote,
+					id: composeRemoteRequestId(remote.name, expose)
+				});
+				assignRemoteInfo(remoteInfo, remoteSnapshot);
+				const preloadOptions = {
+					remote,
+					preloadConfig: {
+						nameOrAlias: pkgNameOrAlias,
+						exposes: [expose],
+						resourceCategory: "sync",
+						share: false,
+						depsRemote: false
+					}
+				};
+				const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+					origin,
+					preloadOptions,
+					remoteInfo,
+					remote,
+					remoteSnapshot,
+					globalSnapshot
+				});
+				if (assets) preloadAssets(remoteInfo, origin, assets, false, {
+					initiator: "loadRemote",
+					id
+				}).catch(() => void 0);
+				return {
+					...args,
+					remoteSnapshot
+				};
+			}
+			return args;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/plugins/generate-preload-assets.js
+function splitId(id) {
+	const splitInfo = id.split(":");
+	if (splitInfo.length === 1) return {
+		name: splitInfo[0],
+		version: void 0
+	};
+	else if (splitInfo.length === 2) return {
+		name: splitInfo[0],
+		version: splitInfo[1]
+	};
+	else return {
+		name: splitInfo[1],
+		version: splitInfo[2]
+	};
+}
+function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo = {}, remoteSnapshot) {
+	const { value: snapshotValue } = getInfoWithoutType(globalSnapshot, getFMId(remoteInfo));
+	const effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;
+	if (effectiveRemoteSnapshot && !isManifestProvider(effectiveRemoteSnapshot)) {
+		traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
+		if (effectiveRemoteSnapshot.remotesInfo) {
+			const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);
+			for (const key of remoteKeys) {
+				if (memo[key]) continue;
+				memo[key] = true;
+				const subRemoteInfo = splitId(key);
+				const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];
+				traverseModuleInfo(globalSnapshot, {
+					name: subRemoteInfo.name,
+					version: remoteValue.matchedVersion
+				}, traverse, false, memo, void 0);
+			}
+		}
+	}
+}
+var isExisted = (type, url) => {
+	return document.querySelector(`${type}[${type === "link" ? "href" : "src"}="${url}"]`);
+};
+function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, remoteSnapshot) {
+	const cssAssets = [];
+	const jsAssets = [];
+	const entryAssets = [];
+	const loadedSharedJsAssets = /* @__PURE__ */ new Set();
+	const loadedSharedCssAssets = /* @__PURE__ */ new Set();
+	const { options } = origin;
+	const { preloadConfig: rootPreloadConfig } = preloadOptions;
+	const { depsRemote } = rootPreloadConfig;
+	traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot) => {
+		let preloadConfig;
+		if (isRoot) preloadConfig = rootPreloadConfig;
+		else if (Array.isArray(depsRemote)) {
+			const findPreloadConfig = depsRemote.find((remoteConfig) => {
+				if (remoteConfig.nameOrAlias === remoteInfo.name || remoteConfig.nameOrAlias === remoteInfo.alias) return true;
+				return false;
+			});
+			if (!findPreloadConfig) return;
+			preloadConfig = defaultPreloadArgs(findPreloadConfig);
+		} else if (depsRemote === true) preloadConfig = rootPreloadConfig;
+		else return;
+		const remoteEntryUrl = getResourceUrl(moduleInfoSnapshot, getRemoteEntryInfoFromSnapshot(moduleInfoSnapshot).url);
+		if (remoteEntryUrl) entryAssets.push({
+			name: remoteInfo.name,
+			moduleInfo: {
+				name: remoteInfo.name,
+				entry: remoteEntryUrl,
+				type: "remoteEntryType" in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : "global",
+				entryGlobalName: "globalName" in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
+				shareScope: "",
+				version: "version" in moduleInfoSnapshot ? moduleInfoSnapshot.version : void 0
+			},
+			url: remoteEntryUrl
+		});
+		let moduleAssetsInfo = "modules" in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];
+		const normalizedPreloadExposes = normalizePreloadExposes(preloadConfig.exposes);
+		if (normalizedPreloadExposes.length && "modules" in moduleInfoSnapshot) moduleAssetsInfo = moduleInfoSnapshot?.modules?.reduce((assets, moduleAssetInfo) => {
+			if (normalizedPreloadExposes?.indexOf(moduleAssetInfo.moduleName) !== -1) assets.push(moduleAssetInfo);
+			return assets;
+		}, []);
+		function handleAssets(assets) {
+			const assetsRes = assets.map((asset) => getResourceUrl(moduleInfoSnapshot, asset));
+			if (preloadConfig.filter) return assetsRes.filter(preloadConfig.filter);
+			return assetsRes;
+		}
+		if (moduleAssetsInfo) {
+			const assetsLength = moduleAssetsInfo.length;
+			for (let index = 0; index < assetsLength; index++) {
+				const assetsInfo = moduleAssetsInfo[index];
+				const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
+				origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
+					id: assetsInfo.moduleName === "." ? remoteInfo.name : exposeFullPath,
+					name: remoteInfo.name,
+					remoteSnapshot: moduleInfoSnapshot,
+					preloadConfig,
+					remote: remoteInfo,
+					origin
+				});
+				if (getPreloaded(exposeFullPath)) continue;
+				if (preloadConfig.resourceCategory === "all") {
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.async));
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.async));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+				} else if (preloadConfig.resourceCategory === "sync") {
+					cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+					jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+				}
+				setPreloaded(exposeFullPath);
+			}
+		}
+	}, true, {}, remoteSnapshot);
+	if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
+		const collectSharedAssets = (shareInfo, snapshotShared) => {
+			const { shared: registeredShared } = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared && typeof registeredShared.lib === "function") {
+				snapshotShared.assets.js.sync.forEach((asset) => {
+					loadedSharedJsAssets.add(asset);
+				});
+				snapshotShared.assets.css.sync.forEach((asset) => {
+					loadedSharedCssAssets.add(asset);
+				});
+			}
+		};
+		remoteSnapshot.shared.forEach((shared) => {
+			const shareInfos = options.shared?.[shared.sharedName];
+			if (!shareInfos) return;
+			const sharedOptions = shared.version ? shareInfos.find((s) => s.version === shared.version) : shareInfos;
+			if (!sharedOptions) return;
+			arrayOptions(sharedOptions).forEach((s) => {
+				collectSharedAssets(s, shared);
+			});
+		});
+	}
+	const needPreloadJsAssets = jsAssets.filter((asset) => !loadedSharedJsAssets.has(asset) && !isExisted("script", asset));
+	return {
+		cssAssets: cssAssets.filter((asset) => !loadedSharedCssAssets.has(asset) && !isExisted("link", asset)),
+		jsAssetsWithoutEntry: needPreloadJsAssets,
+		entryAssets: entryAssets.filter((entry) => !isExisted("script", entry.url))
+	};
+}
+var generatePreloadAssetsPlugin = function() {
+	return {
+		name: "generate-preload-assets-plugin",
+		async generatePreloadAssets(args) {
+			const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot } = args;
+			if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) return {
+				cssAssets: [],
+				jsAssetsWithoutEntry: [],
+				entryAssets: [{
+					name: remote.name,
+					url: remote.entry,
+					moduleInfo: {
+						name: remoteInfo.name,
+						entry: remote.entry,
+						type: remoteInfo.type || "global",
+						entryGlobalName: "",
+						shareScope: ""
+					}
+				}]
+			};
+			assignRemoteInfo(remoteInfo, remoteSnapshot);
+			return generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/plugins/snapshot/SnapshotHandler.js
+function getGlobalRemoteInfo(moduleInfo, origin) {
+	const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
+		name: origin.name,
+		version: origin.options.version
+	});
+	const globalRemoteInfo = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
+	if (globalRemoteInfo && globalRemoteInfo.matchedVersion) return {
+		hostGlobalSnapshot,
+		globalSnapshot: getGlobalSnapshot(),
+		remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+			name: moduleInfo.name,
+			version: globalRemoteInfo.matchedVersion
+		})
+	};
+	return {
+		hostGlobalSnapshot: void 0,
+		globalSnapshot: getGlobalSnapshot(),
+		remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+			name: moduleInfo.name,
+			version: "version" in moduleInfo ? moduleInfo.version : void 0
+		})
+	};
+}
+var SnapshotHandler = class {
+	constructor(HostInstance) {
+		this.loadingHostSnapshot = null;
+		this.manifestCache = /* @__PURE__ */ new Map();
+		this.hooks = new PluginSystem({
+			beforeLoadRemoteSnapshot: new AsyncHook("beforeLoadRemoteSnapshot"),
+			loadSnapshot: new AsyncWaterfallHook("loadGlobalSnapshot"),
+			loadRemoteSnapshot: new AsyncWaterfallHook("loadRemoteSnapshot"),
+			afterLoadSnapshot: new AsyncWaterfallHook("afterLoadSnapshot")
+		});
+		this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
+		this.HostInstance = HostInstance;
+		this.loaderHook = HostInstance.loaderHook;
+	}
+	async loadRemoteSnapshotInfo({ moduleInfo, id, initiator = "loadRemote" }) {
+		const { options } = this.HostInstance;
+		await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+			options,
+			moduleInfo,
+			origin: this.HostInstance
+		});
+		let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
+			name: this.HostInstance.options.name,
+			version: this.HostInstance.options.version
+		});
+		if (!hostSnapshot) {
+			hostSnapshot = {
+				version: this.HostInstance.options.version || "",
+				remoteEntry: "",
+				remotesInfo: {}
+			};
+			addGlobalSnapshot({ [this.HostInstance.options.name]: hostSnapshot });
+		}
+		if (hostSnapshot && "remotesInfo" in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
+			if ("version" in moduleInfo || "entry" in moduleInfo) hostSnapshot.remotesInfo = {
+				...hostSnapshot?.remotesInfo,
+				[moduleInfo.name]: { matchedVersion: "version" in moduleInfo ? moduleInfo.version : moduleInfo.entry }
+			};
+		}
+		const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
+		const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
+			options,
+			moduleInfo,
+			hostGlobalSnapshot,
+			remoteSnapshot,
+			globalSnapshot
+		});
+		let mSnapshot;
+		let gSnapshot;
+		if (globalRemoteSnapshot) if (isManifestProvider(globalRemoteSnapshot)) {
+			const remoteEntry = globalRemoteSnapshot.remoteEntry;
+			const moduleSnapshot = await this.loadManifestSnapshot(remoteEntry, moduleInfo, {}, {
+				initiator,
+				id: id || moduleInfo.name
+			});
+			const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo({
+				...moduleInfo,
+				entry: remoteEntry
+			}, moduleSnapshot);
+			mSnapshot = moduleSnapshot;
+			gSnapshot = globalSnapshotRes;
+		} else {
+			const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+				options: this.HostInstance.options,
+				moduleInfo,
+				remoteSnapshot: globalRemoteSnapshot,
+				from: "global"
+			});
+			mSnapshot = remoteSnapshotRes;
+			gSnapshot = globalSnapshotRes;
+		}
+		else if (isRemoteInfoWithEntry(moduleInfo)) {
+			const moduleSnapshot = await this.loadManifestSnapshot(moduleInfo.entry, moduleInfo, {}, {
+				initiator,
+				id: id || moduleInfo.name
+			});
+			const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(moduleInfo, moduleSnapshot);
+			mSnapshot = moduleSnapshot;
+			gSnapshot = globalSnapshotRes;
+		} else error(RUNTIME_007, runtimeDescMap, {
+			remoteName: moduleInfo.name,
+			remoteVersion: moduleInfo.version,
+			hostName: this.HostInstance.options.name,
+			globalSnapshot: JSON.stringify(globalSnapshotRes)
+		}, void 0, optionsToMFContext(this.HostInstance.options));
+		await this.hooks.lifecycle.afterLoadSnapshot.emit({
+			id,
+			host: this.HostInstance,
+			options,
+			moduleInfo,
+			remoteSnapshot: mSnapshot
+		});
+		return {
+			remoteSnapshot: mSnapshot,
+			globalSnapshot: gSnapshot
+		};
+	}
+	getGlobalRemoteInfo(moduleInfo) {
+		return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
+	}
+	async getManifestJson(manifestUrl, moduleInfo, extraOptions, resourceOptions) {
+		const getManifest = async () => {
+			const remoteInfo = getRemoteInfo(moduleInfo);
+			let manifestJson = this.manifestCache.get(manifestUrl);
+			if (manifestJson) return manifestJson;
+			try {
+				let res = await this.loaderHook.lifecycle.fetch.emit(manifestUrl, {}, remoteInfo, resourceOptions ? {
+					...resourceOptions,
+					url: manifestUrl,
+					resourceType: "manifest"
+				} : void 0);
+				if (!res || !(res instanceof Response)) res = await fetch(manifestUrl, {});
+				manifestJson = await res.json();
+			} catch (err) {
+				manifestJson = await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+					id: manifestUrl,
+					error: err,
+					from: "runtime",
+					lifecycle: "afterResolve",
+					remote: remoteInfo,
+					origin: this.HostInstance
+				});
+				if (!manifestJson) {
+					delete this.manifestLoading[manifestUrl];
+					error(RUNTIME_003, runtimeDescMap, {
+						manifestUrl,
+						moduleName: moduleInfo.name,
+						hostName: this.HostInstance.options.name
+					}, `${err}`, optionsToMFContext(this.HostInstance.options));
+				}
+			}
+			const missingRequiredFields = [
+				!manifestJson.metaData && "metaData",
+				!manifestJson.exposes && "exposes",
+				!manifestJson.shared && "shared"
+			].filter(Boolean);
+			if (missingRequiredFields.length > 0) await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+				id: manifestUrl,
+				error: /* @__PURE__ */ new Error(`"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${missingRequiredFields.join(", ")}.`),
+				from: "runtime",
+				lifecycle: "afterResolve",
+				remote: remoteInfo,
+				origin: this.HostInstance
+			});
+			if (missingRequiredFields.length > 0) error(RUNTIME_013, runtimeDescMap, {
+				manifestUrl,
+				moduleName: moduleInfo.name,
+				hostName: this.HostInstance.options.name,
+				missingFields: missingRequiredFields.join(",")
+			}, void 0, optionsToMFContext(this.HostInstance.options));
+			this.manifestCache.set(manifestUrl, manifestJson);
+			return manifestJson;
+		};
+		return getManifest();
+	}
+	async loadManifestSnapshot(manifestUrl, moduleInfo, extraOptions, resourceOptions) {
+		const asyncLoadProcess = async () => {
+			const manifestJson = await this.getManifestJson(manifestUrl, moduleInfo, extraOptions, resourceOptions);
+			const remoteSnapshot = generateSnapshotFromManifest(manifestJson, { version: manifestUrl });
+			const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+				options: this.HostInstance.options,
+				moduleInfo,
+				manifestJson,
+				remoteSnapshot,
+				manifestUrl,
+				from: "manifest"
+			});
+			return remoteSnapshotRes;
+		};
+		if (!this.manifestLoading[manifestUrl]) this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res) => res);
+		return this.manifestLoading[manifestUrl];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/shared/index.js
+var SharedHandler = class {
+	constructor(host) {
+		this.hooks = new PluginSystem({
+			beforeRegisterShare: new SyncWaterfallHook("beforeRegisterShare"),
+			afterResolve: new AsyncWaterfallHook("afterResolve"),
+			beforeLoadShare: new AsyncWaterfallHook("beforeLoadShare"),
+			loadShare: new AsyncHook(),
+			afterLoadShare: new SyncHook("afterLoadShare"),
+			errorLoadShare: new SyncHook("errorLoadShare"),
+			resolveShare: new SyncWaterfallHook("resolveShare"),
+			initContainerShareScopeMap: new SyncWaterfallHook("initContainerShareScopeMap")
+		});
+		this.host = host;
+		this.shareScopeMap = {};
+		this.initTokens = {};
+		this._setGlobalShareScopeMap(host.options);
+	}
+	emitAfterLoadShare({ lifecycle, pkgName, shareInfo, selectedShared }) {
+		try {
+			this.hooks.lifecycle.afterLoadShare.emit({
+				pkgName,
+				shareInfo,
+				selectedShared,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host
+			});
+		} catch (error) {
+			warn$1(error);
+		}
+	}
+	emitErrorLoadShare({ lifecycle, pkgName, shareInfo, error, recovered }) {
+		try {
+			this.hooks.lifecycle.errorLoadShare.emit({
+				pkgName,
+				shareInfo,
+				shared: this.host.options.shared,
+				shareScopeMap: this.shareScopeMap,
+				lifecycle,
+				origin: this.host,
+				error,
+				recovered
+			});
+		} catch (hookError) {
+			warn$1(hookError);
+		}
+	}
+	registerShared(globalOptions, userOptions) {
+		const { newShareInfos, allShareInfos } = formatShareConfigs(globalOptions, userOptions);
+		Object.keys(newShareInfos).forEach((sharedKey) => {
+			newShareInfos[sharedKey].forEach((sharedVal) => {
+				sharedVal.scope.forEach((sc) => {
+					this.hooks.lifecycle.beforeRegisterShare.emit({
+						origin: this.host,
+						pkgName: sharedKey,
+						shared: sharedVal
+					});
+					if (!this.shareScopeMap[sc]?.[sharedKey]) this.setShared({
+						pkgName: sharedKey,
+						lib: sharedVal.lib,
+						get: sharedVal.get,
+						loaded: sharedVal.loaded || Boolean(sharedVal.lib),
+						shared: sharedVal,
+						from: userOptions.name
+					});
+				});
+			});
+		});
+		return {
+			newShareInfos,
+			allShareInfos
+		};
+	}
+	async loadShare(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		let shareOptionsRes = shareOptions;
+		try {
+			if (shareOptions?.scope) await Promise.all(shareOptions.scope.map(async (shareScope) => {
+				await Promise.all(this.initializeSharing(shareScope, { strategy: shareOptions.strategy }));
+			}));
+			shareOptionsRes = (await this.hooks.lifecycle.beforeLoadShare.emit({
+				pkgName,
+				shareInfo: shareOptions,
+				shared: host.options.shared,
+				origin: host
+			})).shareInfo;
+			assert(shareOptionsRes, `Cannot find shared "${pkgName}" in host "${host.options.name}". Ensure the shared config for "${pkgName}" is declared in the federation plugin options and the host has been initialized before loading shares.`);
+			const resolvedShareOptions = shareOptionsRes;
+			const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				const targetShared = directShare(registeredShared, useTreesShaking);
+				if (targetShared.lib) {
+					addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return targetShared.lib;
+				} else if (targetShared.loading && !targetShared.loaded) {
+					const factory = await targetShared.loading;
+					targetShared.loaded = true;
+					if (!targetShared.lib) targetShared.lib = factory;
+					addUseIn(targetShared, host.options.name);
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				} else {
+					const asyncLoadProcess = async () => {
+						const factory = await targetShared.get();
+						addUseIn(targetShared, host.options.name);
+						targetShared.loaded = true;
+						targetShared.lib = factory;
+						return factory;
+					};
+					const loading = asyncLoadProcess();
+					this.setShared({
+						pkgName,
+						loaded: false,
+						shared: registeredShared,
+						from: host.options.name,
+						lib: null,
+						loading,
+						treeShaking: useTreesShaking ? targetShared : void 0
+					});
+					const factory = await loading;
+					this.emitAfterLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						selectedShared: registeredShared
+					});
+					return factory;
+				}
+			} else {
+				if (extraOptions?.customShareInfo) {
+					this.emitErrorLoadShare({
+						lifecycle: "loadShare",
+						pkgName,
+						shareInfo: resolvedShareOptions,
+						recovered: true
+					});
+					return false;
+				}
+				const _useTreeShaking = shouldUseTreeShaking(resolvedShareOptions.treeShaking);
+				const targetShared = directShare(resolvedShareOptions, _useTreeShaking);
+				const asyncLoadProcess = async () => {
+					const factory = await targetShared.get();
+					targetShared.lib = factory;
+					targetShared.loaded = true;
+					addUseIn(targetShared, host.options.name);
+					const { shared: gShared, useTreesShaking: gUseTreeShaking } = getRegisteredShare(this.shareScopeMap, pkgName, resolvedShareOptions, this.hooks.lifecycle.resolveShare) || {};
+					if (gShared) {
+						const targetGShared = directShare(gShared, gUseTreeShaking);
+						targetGShared.lib = factory;
+						targetGShared.loaded = true;
+						gShared.from = resolvedShareOptions.from;
+					}
+					return factory;
+				};
+				const loading = asyncLoadProcess();
+				this.setShared({
+					pkgName,
+					loaded: false,
+					shared: resolvedShareOptions,
+					from: host.options.name,
+					lib: null,
+					loading,
+					treeShaking: _useTreeShaking ? targetShared : void 0
+				});
+				const factory = await loading;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShare",
+					pkgName,
+					shareInfo: resolvedShareOptions,
+					selectedShared: resolvedShareOptions
+				});
+				return factory;
+			}
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShare",
+				pkgName,
+				shareInfo: shareOptionsRes,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	/**
+	* This function initializes the sharing sequence (executed only once per share scope).
+	* It accepts one argument, the name of the share scope.
+	* If the share scope does not exist, it creates one.
+	*/
+	initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
+		const { host } = this;
+		const from = extraOptions?.from;
+		const strategy = extraOptions?.strategy;
+		let initScope = extraOptions?.initScope;
+		const promises = [];
+		if (from !== "build") {
+			const { initTokens } = this;
+			if (!initScope) initScope = [];
+			let initToken = initTokens[shareScopeName];
+			if (!initToken) initToken = initTokens[shareScopeName] = { from: this.host.name };
+			if (initScope.indexOf(initToken) >= 0) return promises;
+			initScope.push(initToken);
+		}
+		const shareScope = this.shareScopeMap;
+		const hostName = host.options.name;
+		if (!shareScope[shareScopeName]) shareScope[shareScopeName] = {};
+		const scope = shareScope[shareScopeName];
+		const register = (name, shared) => {
+			const { version, eager } = shared;
+			scope[name] = scope[name] || {};
+			const versions = scope[name];
+			const activeVersion = versions[version] && directShare(versions[version]);
+			const activeVersionEager = Boolean(activeVersion && ("eager" in activeVersion && activeVersion.eager || "shareConfig" in activeVersion && activeVersion.shareConfig?.eager));
+			if (!activeVersion || activeVersion.strategy !== "loaded-first" && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > versions[version].from)) versions[version] = shared;
+		};
+		const initRemoteModule = async (key) => {
+			const { module } = await host.remoteHandler.getRemoteModuleAndOptions({ id: key });
+			let remoteEntryExports = void 0;
+			try {
+				remoteEntryExports = await module.getEntry();
+			} catch (error) {
+				remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+					id: key,
+					error,
+					from: "runtime",
+					lifecycle: "beforeLoadShare",
+					remote: module.remoteInfo,
+					origin: host
+				});
+				if (!remoteEntryExports) return;
+			} finally {
+				if (remoteEntryExports?.init && !module.initing) {
+					module.remoteEntryExports = remoteEntryExports;
+					await module.init(void 0, void 0, initScope);
+				}
+			}
+		};
+		Object.keys(host.options.shared).forEach((shareName) => {
+			host.options.shared[shareName].forEach((shared) => {
+				if (shared.scope.includes(shareScopeName)) register(shareName, shared);
+			});
+		});
+		if (host.options.shareStrategy === "version-first" || strategy === "version-first") host.options.remotes.forEach((remote) => {
+			if (remote.shareScope === shareScopeName) promises.push(initRemoteModule(remote.name));
+		});
+		return promises;
+	}
+	loadShareSync(pkgName, extraOptions) {
+		const { host } = this;
+		const shareOptions = getTargetSharedOptions({
+			pkgName,
+			extraOptions,
+			shareInfos: host.options.shared
+		});
+		try {
+			if (shareOptions?.scope) shareOptions.scope.forEach((shareScope) => {
+				this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
+			});
+			const { shared: registeredShared } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
+			if (registeredShared) {
+				if (typeof registeredShared.lib === "function") {
+					addUseIn(registeredShared, host.options.name);
+					if (!registeredShared.loaded) {
+						registeredShared.loaded = true;
+						if (registeredShared.from === host.options.name) shareOptions.loaded = true;
+					}
+					this.emitAfterLoadShare({
+						lifecycle: "loadShareSync",
+						pkgName,
+						shareInfo: shareOptions,
+						selectedShared: registeredShared
+					});
+					return registeredShared.lib;
+				}
+				if (typeof registeredShared.get === "function") {
+					const module = registeredShared.get();
+					if (!(module instanceof Promise)) {
+						addUseIn(registeredShared, host.options.name);
+						this.setShared({
+							pkgName,
+							loaded: true,
+							from: host.options.name,
+							lib: module,
+							shared: registeredShared
+						});
+						this.emitAfterLoadShare({
+							lifecycle: "loadShareSync",
+							pkgName,
+							shareInfo: shareOptions,
+							selectedShared: registeredShared
+						});
+						return module;
+					}
+				}
+			}
+			if (shareOptions.lib) {
+				if (!shareOptions.loaded) shareOptions.loaded = true;
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			if (shareOptions.get) {
+				const module = shareOptions.get();
+				if (module instanceof Promise) error(extraOptions?.from === "build" ? RUNTIME_005 : RUNTIME_006, runtimeDescMap, {
+					hostName: host.options.name,
+					sharedPkgName: pkgName
+				}, void 0, optionsToMFContext(host.options));
+				shareOptions.lib = module;
+				this.setShared({
+					pkgName,
+					loaded: true,
+					from: host.options.name,
+					lib: shareOptions.lib,
+					shared: shareOptions
+				});
+				this.emitAfterLoadShare({
+					lifecycle: "loadShareSync",
+					pkgName,
+					shareInfo: shareOptions,
+					selectedShared: shareOptions
+				});
+				return shareOptions.lib;
+			}
+			error(RUNTIME_006, runtimeDescMap, {
+				hostName: host.options.name,
+				sharedPkgName: pkgName
+			}, void 0, optionsToMFContext(host.options));
+		} catch (shareError) {
+			this.emitErrorLoadShare({
+				lifecycle: "loadShareSync",
+				pkgName,
+				shareInfo: shareOptions,
+				error: shareError
+			});
+			throw shareError;
+		}
+	}
+	initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
+		const { host } = this;
+		this.shareScopeMap[scopeName] = shareScope;
+		this.hooks.lifecycle.initContainerShareScopeMap.emit({
+			shareScope,
+			options: host.options,
+			origin: host,
+			scopeName,
+			hostShareScopeMap: extraOptions.hostShareScopeMap
+		});
+	}
+	setShared({ pkgName, shared, from, lib, loading, loaded, get, treeShaking }) {
+		const { version, scope = "default", ...shareInfo } = shared;
+		const scopes = Array.isArray(scope) ? scope : [scope];
+		const mergeAttrs = (shared) => {
+			const merge = (s, key, val) => {
+				if (val && !s[key]) s[key] = val;
+			};
+			const targetShared = treeShaking ? shared.treeShaking : shared;
+			merge(targetShared, "loaded", loaded);
+			merge(targetShared, "loading", loading);
+			merge(targetShared, "get", get);
+		};
+		scopes.forEach((sc) => {
+			if (!this.shareScopeMap[sc]) this.shareScopeMap[sc] = {};
+			if (!this.shareScopeMap[sc][pkgName]) this.shareScopeMap[sc][pkgName] = {};
+			if (!this.shareScopeMap[sc][pkgName][version]) this.shareScopeMap[sc][pkgName][version] = {
+				version,
+				scope: [sc],
+				...shareInfo,
+				lib
+			};
+			const registeredShared = this.shareScopeMap[sc][pkgName][version];
+			mergeAttrs(registeredShared);
+			if (from && registeredShared.from !== from) registeredShared.from = from;
+		});
+	}
+	_setGlobalShareScopeMap(hostOptions) {
+		const globalShareScopeMap = getGlobalShareScope();
+		const identifier = hostOptions.id || hostOptions.name;
+		if (identifier && !globalShareScopeMap[identifier]) globalShareScopeMap[identifier] = this.shareScopeMap;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/remote/index.js
+var RemoteHandler = class {
+	constructor(host) {
+		this.hooks = new PluginSystem({
+			beforeRegisterRemote: new SyncWaterfallHook("beforeRegisterRemote"),
+			registerRemote: new SyncWaterfallHook("registerRemote"),
+			beforeRequest: new AsyncWaterfallHook("beforeRequest"),
+			afterMatchRemote: new AsyncHook("afterMatchRemote"),
+			onLoad: new AsyncHook("onLoad"),
+			afterLoadRemote: new AsyncHook("afterLoadRemote"),
+			handlePreloadModule: new SyncHook("handlePreloadModule"),
+			errorLoadRemote: new AsyncHook("errorLoadRemote"),
+			beforePreloadRemote: new AsyncHook("beforePreloadRemote"),
+			generatePreloadAssets: new AsyncHook("generatePreloadAssets"),
+			afterPreloadRemote: new AsyncHook("afterPreloadRemote"),
+			loadEntry: new AsyncHook()
+		});
+		this.host = host;
+		this.idToRemoteMap = {};
+	}
+	formatAndRegisterRemote(globalOptions, userOptions) {
+		return (userOptions.remotes || []).reduce((res, remote) => {
+			this.registerRemote(remote, res, { force: false });
+			return res;
+		}, globalOptions.remotes);
+	}
+	setIdToRemoteMap(id, remoteMatchInfo) {
+		const { remote, expose } = remoteMatchInfo;
+		const { name, alias } = remote;
+		this.idToRemoteMap[id] = {
+			name: remote.name,
+			expose
+		};
+		if (alias && id.startsWith(name)) {
+			const idWithAlias = id.replace(name, alias);
+			this.idToRemoteMap[idWithAlias] = {
+				name: remote.name,
+				expose
+			};
+			return;
+		}
+		if (alias && id.startsWith(alias)) {
+			const idWithName = id.replace(alias, name);
+			this.idToRemoteMap[idWithName] = {
+				name: remote.name,
+				expose
+			};
+		}
+	}
+	async loadRemote(id, options) {
+		const { host } = this;
+		const startMatchInfo = matchRemoteWithNameAndExpose(host.options.remotes, id);
+		let completeRequestId = id;
+		let completeExpose = startMatchInfo?.expose;
+		let completeRemote = startMatchInfo ? getRemoteInfo(startMatchInfo.remote) : void 0;
+		let afterLoadRemoteArgs;
+		try {
+			const { loadFactory = true } = options || { loadFactory: true };
+			const { module, moduleOptions, remoteMatchInfo } = await this.getRemoteModuleAndOptions({ id });
+			const { pkgNameOrAlias, remote, expose, id: idRes, remoteSnapshot } = remoteMatchInfo;
+			completeRequestId = idRes;
+			completeExpose = expose;
+			completeRemote = getRemoteInfo(remote);
+			const moduleOrFactory = await module.get(idRes, expose, options, remoteSnapshot);
+			const moduleWrapper = await this.hooks.lifecycle.onLoad.emit({
+				id: idRes,
+				pkgNameOrAlias,
+				expose,
+				exposeModule: loadFactory ? moduleOrFactory : void 0,
+				exposeModuleFactory: loadFactory ? void 0 : moduleOrFactory,
+				remote,
+				options: moduleOptions,
+				moduleInstance: module,
+				origin: host
+			});
+			this.setIdToRemoteMap(id, remoteMatchInfo);
+			afterLoadRemoteArgs = {
+				id: completeRequestId,
+				expose: completeExpose,
+				remote: completeRemote,
+				options,
+				origin: host
+			};
+			if (typeof moduleWrapper === "function") return moduleWrapper;
+			return moduleOrFactory;
+		} catch (error) {
+			const { from = "runtime" } = options || { from: "runtime" };
+			let failOver;
+			try {
+				failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
+					id,
+					error,
+					from,
+					lifecycle: "onLoad",
+					expose: completeExpose,
+					remote: completeRemote,
+					origin: host
+				});
+			} catch (hookError) {
+				afterLoadRemoteArgs = {
+					id: completeRequestId,
+					expose: completeExpose,
+					remote: completeRemote,
+					options,
+					error: hookError,
+					origin: host
+				};
+				throw hookError;
+			}
+			if (!failOver) {
+				afterLoadRemoteArgs = {
+					id: completeRequestId,
+					expose: completeExpose,
+					remote: completeRemote,
+					options,
+					error,
+					origin: host
+				};
+				throw error;
+			}
+			afterLoadRemoteArgs = {
+				id: completeRequestId,
+				expose: completeExpose,
+				remote: completeRemote,
+				options,
+				error,
+				origin: host,
+				recovered: true
+			};
+			return failOver;
+		} finally {
+			if (afterLoadRemoteArgs) await this.hooks.lifecycle.afterLoadRemote.emit(afterLoadRemoteArgs);
+		}
+	}
+	async preloadRemote(preloadOptions) {
+		const { host } = this;
+		const preloadResults = [];
+		await this.hooks.lifecycle.beforePreloadRemote.emit({
+			preloadOps: preloadOptions,
+			options: host.options,
+			origin: host
+		});
+		const preloadOps = formatPreloadArgs(host.options.remotes, preloadOptions);
+		const createPreloadAssetOps = (ops) => {
+			const { preloadConfig, remote } = ops;
+			const exposes = preloadConfig.exposes || [];
+			if (!exposes.length) return [{
+				ops,
+				id: `${remote.name}/*`
+			}];
+			return exposes.map((expose) => ({
+				ops: {
+					...ops,
+					preloadConfig: {
+						...preloadConfig,
+						exposes: [expose]
+					}
+				},
+				id: composeRemoteRequestId(remote.name, expose)
+			}));
+		};
+		let preloadError;
+		await Promise.all(preloadOps.flatMap(createPreloadAssetOps).map(async (assetOps) => {
+			const { ops, id: preloadId } = assetOps;
+			const { remote, preloadConfig } = ops;
+			const remoteInfo = getRemoteInfo(remote);
+			try {
+				const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo({
+					moduleInfo: remote,
+					id: preloadId,
+					initiator: "preloadRemote"
+				});
+				const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
+					origin: host,
+					preloadOptions: ops,
+					remote,
+					remoteInfo,
+					globalSnapshot,
+					remoteSnapshot
+				});
+				if (!assets) return;
+				const results = await preloadAssets(remoteInfo, host, assets, true, {
+					initiator: "preloadRemote",
+					id: preloadId
+				});
+				preloadResults.push({
+					remote,
+					remoteInfo,
+					preloadConfig,
+					id: preloadId,
+					results
+				});
+			} catch (error) {
+				preloadResults.push({
+					remote,
+					remoteInfo,
+					preloadConfig,
+					id: preloadId,
+					results: [{
+						url: remoteInfo.entry,
+						status: "error",
+						resourceType: /\.json(?:$|[?#])/i.test(remoteInfo.entry) ? "manifest" : "remoteEntry",
+						initiator: "preloadRemote",
+						id: preloadId,
+						error
+					}]
+				});
+			}
+		}));
+		const failedResults = preloadResults.flatMap((preloadResult) => preloadResult.results.filter((result) => result.status === "error" || result.status === "timeout"));
+		if (failedResults.length > 0) {
+			preloadError = /* @__PURE__ */ new Error(`preloadRemote failed to load ${failedResults.length} resource(s).`);
+			Object.assign(preloadError, {
+				results: preloadResults,
+				failedResults
+			});
+		}
+		await this.hooks.lifecycle.afterPreloadRemote.emit({
+			preloadOps: preloadOptions,
+			options: host.options,
+			origin: host,
+			results: preloadResults,
+			error: preloadError
+		});
+		if (preloadError) throw preloadError;
+	}
+	registerRemotes(remotes, options) {
+		const { host } = this;
+		remotes.forEach((remote) => {
+			this.registerRemote(remote, host.options.remotes, { force: options?.force });
+		});
+	}
+	async getRemoteModuleAndOptions(options) {
+		const { host } = this;
+		const { id } = options;
+		let loadRemoteArgs;
+		try {
+			loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
+				id,
+				options: host.options,
+				origin: host
+			});
+		} catch (error) {
+			loadRemoteArgs = await this.hooks.lifecycle.errorLoadRemote.emit({
+				id,
+				options: host.options,
+				origin: host,
+				from: "runtime",
+				error,
+				lifecycle: "beforeRequest"
+			});
+			if (!loadRemoteArgs) throw error;
+		}
+		const { id: idRes } = loadRemoteArgs;
+		const remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
+		if (!remoteSplitInfo) try {
+			error(RUNTIME_004, runtimeDescMap, {
+				hostName: host.options.name,
+				requestId: idRes
+			}, void 0, optionsToMFContext(host.options));
+		} catch (matchError) {
+			await this.hooks.lifecycle.afterMatchRemote.emit({
+				id: idRes,
+				options: host.options,
+				error: matchError,
+				origin: host
+			});
+			throw matchError;
+		}
+		const { remote: rawRemote } = remoteSplitInfo;
+		const remoteInfo = getRemoteInfo(rawRemote);
+		await this.hooks.lifecycle.afterMatchRemote.emit({
+			id: idRes,
+			...remoteSplitInfo,
+			options: host.options,
+			remoteInfo,
+			origin: host
+		});
+		const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit({
+			id: idRes,
+			...remoteSplitInfo,
+			options: host.options,
+			origin: host,
+			remoteInfo
+		});
+		const { remote, expose } = matchInfo;
+		assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
+		let module = host.moduleCache.get(remote.name);
+		const moduleOptions = {
+			host,
+			remoteInfo
+		};
+		if (!module) {
+			module = new Module$1(moduleOptions);
+			host.moduleCache.set(remote.name, module);
+		}
+		return {
+			module,
+			moduleOptions,
+			remoteMatchInfo: matchInfo
+		};
+	}
+	registerRemote(remote, targetRemotes, options) {
+		const { host } = this;
+		const normalizeRemote = () => {
+			if (remote.alias) {
+				const findEqual = targetRemotes.find((item) => remote.alias && (item.name.startsWith(remote.alias) || item.alias?.startsWith(remote.alias)));
+				assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
+			}
+			if ("entry" in remote) {
+				if (typeof window !== "undefined" && !remote.entry.startsWith("http")) remote.entry = new URL(remote.entry, window.location.origin).href;
+			}
+			if (!remote.shareScope) remote.shareScope = DEFAULT_SCOPE;
+			if (!remote.type) remote.type = DEFAULT_REMOTE_TYPE;
+		};
+		this.hooks.lifecycle.beforeRegisterRemote.emit({
+			remote,
+			origin: host
+		});
+		const registeredRemote = targetRemotes.find((item) => item.name === remote.name);
+		if (!registeredRemote) {
+			normalizeRemote();
+			targetRemotes.push(remote);
+			this.hooks.lifecycle.registerRemote.emit({
+				remote,
+				origin: host
+			});
+		} else {
+			const messages = [`The remote "${remote.name}" is already registered.`, "Please note that overriding it may cause unexpected errors."];
+			if (options?.force) {
+				this.removeRemote(registeredRemote);
+				normalizeRemote();
+				targetRemotes.push(remote);
+				this.hooks.lifecycle.registerRemote.emit({
+					remote,
+					origin: host
+				});
+				warn(messages.join(" "));
+			}
+		}
+	}
+	removeRemote(remote) {
+		try {
+			const { host } = this;
+			const { name } = remote;
+			const remoteIndex = host.options.remotes.findIndex((item) => item.name === name);
+			if (remoteIndex !== -1) host.options.remotes.splice(remoteIndex, 1);
+			const globalSnapshotKey = getInfoWithoutType(CurrentGlobal.__FEDERATION__.moduleInfo, getFMId(remote)).key;
+			delete CurrentGlobal.__FEDERATION__.moduleInfo[globalSnapshotKey];
+			if ("entry" in remote) {
+				host.snapshotHandler.manifestCache.delete(remote.entry);
+				delete Global.__FEDERATION__.__MANIFEST_LOADING__[remote.entry];
+			}
+			const { hostGlobalSnapshot } = getGlobalRemoteInfo(remote, host);
+			if (hostGlobalSnapshot) {
+				const remoteKey = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
+				if (remoteKey) delete hostGlobalSnapshot.remotesInfo[remoteKey];
+			}
+			const loadedModule = host.moduleCache.get(remote.name);
+			if (loadedModule) {
+				const remoteInfo = loadedModule.remoteInfo;
+				const key = remoteInfo.entryGlobalName;
+				if (CurrentGlobal[key]) if (Object.getOwnPropertyDescriptor(CurrentGlobal, key)?.configurable) delete CurrentGlobal[key];
+				else CurrentGlobal[key] = void 0;
+				const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
+				if (globalLoading[remoteEntryUniqueKey]) delete globalLoading[remoteEntryUniqueKey];
+				let remoteInsId = remoteInfo.buildVersion ? composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
+				const remoteInsIndex = CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((ins) => {
+					if (remoteInfo.buildVersion) return ins.options.id === remoteInsId;
+					else return ins.name === remoteInsId;
+				});
+				if (remoteInsIndex !== -1) {
+					const remoteIns = CurrentGlobal.__FEDERATION__.__INSTANCES__[remoteInsIndex];
+					remoteInsId = remoteIns.options.id || remoteInsId;
+					const globalShareScopeMap = getGlobalShareScope();
+					let isAllSharedNotUsed = true;
+					const needDeleteKeys = [];
+					Object.keys(globalShareScopeMap).forEach((instId) => {
+						const shareScopeMap = globalShareScopeMap[instId];
+						shareScopeMap && Object.keys(shareScopeMap).forEach((shareScope) => {
+							const shareScopeVal = shareScopeMap[shareScope];
+							shareScopeVal && Object.keys(shareScopeVal).forEach((shareName) => {
+								const sharedPkgs = shareScopeVal[shareName];
+								sharedPkgs && Object.keys(sharedPkgs).forEach((shareVersion) => {
+									const shared = sharedPkgs[shareVersion];
+									if (shared && typeof shared === "object" && shared.from === remoteInfo.name) if (shared.loaded || shared.loading) {
+										shared.useIn = shared.useIn.filter((usedHostName) => usedHostName !== remoteInfo.name);
+										if (shared.useIn.length) isAllSharedNotUsed = false;
+										else needDeleteKeys.push([
+											instId,
+											shareScope,
+											shareName,
+											shareVersion
+										]);
+									} else needDeleteKeys.push([
+										instId,
+										shareScope,
+										shareName,
+										shareVersion
+									]);
+								});
+							});
+						});
+					});
+					if (isAllSharedNotUsed) {
+						remoteIns.shareScopeMap = {};
+						delete globalShareScopeMap[remoteInsId];
+					}
+					needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion]) => {
+						delete globalShareScopeMap[insId]?.[shareScope]?.[shareName]?.[shareVersion];
+					});
+					CurrentGlobal.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
+				}
+				host.moduleCache.delete(remote.name);
+			}
+		} catch (err) {
+			logger.error(`removeRemote failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime-core@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime-core/dist/core.js
+var USE_SNAPSHOT = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+var ModuleFederation = class {
+	constructor(userOptions) {
+		this.hooks = new PluginSystem({
+			beforeInit: new SyncWaterfallHook("beforeInit"),
+			init: new SyncHook(),
+			beforeInitContainer: new AsyncWaterfallHook("beforeInitContainer"),
+			initContainer: new AsyncWaterfallHook("initContainer")
+		});
+		this.version = "2.6.0";
+		this.moduleCache = /* @__PURE__ */ new Map();
+		this.loaderHook = new PluginSystem({
+			getModuleInfo: new SyncHook(),
+			createScript: new SyncHook(),
+			createLink: new SyncHook(),
+			fetch: new AsyncHook(),
+			loadEntryError: new AsyncHook(),
+			afterLoadEntry: new AsyncHook("afterLoadEntry"),
+			beforeInitRemote: new AsyncHook("beforeInitRemote"),
+			afterInitRemote: new AsyncHook("afterInitRemote"),
+			beforeGetExpose: new AsyncHook("beforeGetExpose"),
+			afterGetExpose: new AsyncHook("afterGetExpose"),
+			beforeExecuteFactory: new AsyncHook("beforeExecuteFactory"),
+			afterExecuteFactory: new AsyncHook("afterExecuteFactory"),
+			getModuleFactory: new AsyncHook()
+		});
+		this.bridgeHook = new PluginSystem({
+			beforeBridgeRender: new SyncHook(),
+			afterBridgeRender: new SyncHook(),
+			beforeBridgeDestroy: new SyncHook(),
+			afterBridgeDestroy: new SyncHook()
+		});
+		const plugins = USE_SNAPSHOT ? [snapshotPlugin(), generatePreloadAssetsPlugin()] : [];
+		const defaultOptions = {
+			id: getBuilderId$1(),
+			name: userOptions.name,
+			plugins,
+			remotes: [],
+			shared: {},
+			inBrowser: true
+		};
+		this.name = userOptions.name;
+		this.options = defaultOptions;
+		this.snapshotHandler = new SnapshotHandler(this);
+		this.sharedHandler = new SharedHandler(this);
+		this.remoteHandler = new RemoteHandler(this);
+		this.shareScopeMap = this.sharedHandler.shareScopeMap;
+		this.registerPlugins([...defaultOptions.plugins, ...userOptions.plugins || []]);
+		this.options = this.formatOptions(defaultOptions, userOptions);
+	}
+	initOptions(userOptions) {
+		if (userOptions.name && userOptions.name !== this.options.name) error(getShortErrorMsg(RUNTIME_010, runtimeDescMap));
+		this.registerPlugins(userOptions.plugins);
+		const options = this.formatOptions(this.options, userOptions);
+		this.options = options;
+		return options;
+	}
+	async loadShare(pkgName, extraOptions) {
+		return this.sharedHandler.loadShare(pkgName, extraOptions);
+	}
+	loadShareSync(pkgName, extraOptions) {
+		return this.sharedHandler.loadShareSync(pkgName, extraOptions);
+	}
+	initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
+		return this.sharedHandler.initializeSharing(shareScopeName, extraOptions);
+	}
+	initRawContainer(name, url, container) {
+		const remoteInfo = getRemoteInfo({
+			name,
+			entry: url
+		});
+		const module = new Module$1({
+			host: this,
+			remoteInfo
+		});
+		module.remoteEntryExports = container;
+		this.moduleCache.set(name, module);
+		return module;
+	}
+	async loadRemote(id, options) {
+		return this.remoteHandler.loadRemote(id, options);
+	}
+	async preloadRemote(preloadOptions) {
+		return this.remoteHandler.preloadRemote(preloadOptions);
+	}
+	initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
+		this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
+	}
+	formatOptions(globalOptions, userOptions) {
+		const { allShareInfos: shared } = formatShareConfigs(globalOptions, userOptions);
+		const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
+			origin: this,
+			userOptions,
+			options: globalOptions,
+			shareInfo: shared
+		});
+		const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
+		const { allShareInfos } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
+		const plugins = [...globalOptionsRes.plugins];
+		if (userOptionsRes.plugins) userOptionsRes.plugins.forEach((plugin) => {
+			if (!plugins.includes(plugin)) plugins.push(plugin);
+		});
+		const optionsRes = {
+			...globalOptions,
+			...userOptions,
+			plugins,
+			remotes,
+			shared: allShareInfos,
+			id: userOptionsRes.id || globalOptions.id
+		};
+		this.hooks.lifecycle.init.emit({
+			origin: this,
+			options: optionsRes
+		});
+		return optionsRes;
+	}
+	registerPlugins(plugins) {
+		const pluginRes = registerPlugins(plugins, this);
+		this.options.plugins = this.options.plugins.reduce((res, plugin) => {
+			if (!plugin) return res;
+			if (res && !res.find((item) => item.name === plugin.name)) res.push(plugin);
+			return res;
+		}, pluginRes || []);
+	}
+	registerRemotes(remotes, options) {
+		return this.remoteHandler.registerRemotes(remotes, options);
+	}
+	registerShared(shared) {
+		this.sharedHandler.registerShared(this.options, {
+			...this.options,
+			shared
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime/dist/utils.js
+function getBuilderId() {
+	return typeof FEDERATION_BUILD_IDENTIFIER !== "undefined" ? FEDERATION_BUILD_IDENTIFIER : "";
+}
+function getGlobalFederationInstance(name, version) {
+	const buildId = getBuilderId();
+	return CurrentGlobal.__FEDERATION__.__INSTANCES__.find((GMInstance) => {
+		if (buildId && GMInstance.options.id === buildId) return true;
+		if (GMInstance.options.name === name && !GMInstance.options.version && !version) return true;
+		if (GMInstance.options.name === name && version && GMInstance.options.version === version) return true;
+		return false;
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@module-federation+runtime@2.6.0_node-fetch@2.7.0/node_modules/@module-federation/runtime/dist/index.js
+function createInstance(options) {
+	const instance = new ((getGlobalFederationConstructor()) || ModuleFederation)({
+		id: `${options.name}@${options.version || Date.now()}`,
+		...options
+	});
+	setGlobalFederationInstance(instance);
+	return instance;
+}
+var FederationInstance = null;
+function init$1(options) {
+	const instance = getGlobalFederationInstance(options.name, options.version);
+	const normalizedOptions = {
+		...options,
+		id: options.id || ""
+	};
+	if (!instance) {
+		FederationInstance = createInstance(normalizedOptions);
+		return FederationInstance;
+	} else {
+		instance.initOptions(normalizedOptions);
+		if (!FederationInstance) FederationInstance = instance;
+		return instance;
+	}
+}
+setGlobalFederationConstructor(ModuleFederation);
+//#endregion
+//#region virtual:mf-REMOTE_ENTRY_ID:__mfe_internal__plugin-auth__remoteEntry_js
+if (typeof __VUE_HMR_RUNTIME__ === "undefined") globalThis.__VUE_HMR_RUNTIME__ = {
+	createRecord() {},
+	rerender() {},
+	reload() {}
+};
+var __mfResolveGlobalKey = "__mf_init__virtual:mf:__mfe_internal__plugin_mf_2_auth__mf_v__runtimeInit__mf_v__.js__";
+var __mfResolveState = globalThis[__mfResolveGlobalKey];
+if (!__mfResolveState) {
+	let initResolve, initReject;
+	const initPromise = new Promise((re, rj) => {
+		initResolve = re;
+		initReject = rj;
+	});
+	__mfResolveState = globalThis[__mfResolveGlobalKey] = {
+		initPromise,
+		initResolve,
+		initReject
+	};
+}
+var initResolve = __mfResolveState.initResolve;
+var __mfCacheGlobalKey = "__mf_module_cache__";
+globalThis[__mfCacheGlobalKey] ||= {
+	share: {},
+	remote: {}
+};
+globalThis[__mfCacheGlobalKey].share ||= {};
+globalThis[__mfCacheGlobalKey].remote ||= {};
+var __mfModuleCache = globalThis[__mfCacheGlobalKey];
+for (const __mfShareKey of Object.keys(__mfModuleCache.share)) if (__mfShareKey.startsWith("default:")) {
+	const __mfLegacyShareKey = __mfShareKey.slice(8);
+	if (__mfModuleCache.share[__mfLegacyShareKey] === void 0) __mfModuleCache.share[__mfLegacyShareKey] = __mfModuleCache.share[__mfShareKey];
+} else if (!__mfShareKey.includes(":")) {
+	const __mfDefaultShareKey = "default:" + __mfShareKey;
+	if (__mfModuleCache.share[__mfDefaultShareKey] === void 0) __mfModuleCache.share[__mfDefaultShareKey] = __mfModuleCache.share[__mfShareKey];
+}
+var initTokens = {};
+var shareScopeName = "default";
+var mfName = "plugin-auth";
+var localSharedImportMapPromise;
+var exposesMapPromise;
+async function retrySharedInit(fn) {
+	for (let attempt = 0;; attempt++) try {
+		return await fn();
+	} catch (e) {
+		throw e;
+	}
+}
+async function getLocalSharedImportMap() {
+	if (!localSharedImportMapPromise) localSharedImportMapPromise = retrySharedInit(() => __vitePreload(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__plugin_mf_2_auth-DEljr3MS.js"), [], import.meta.url)).catch((e) => {
+		localSharedImportMapPromise = void 0;
+		throw e;
+	});
+	return localSharedImportMapPromise;
+}
+async function getExposesMap() {
+	if (!exposesMapPromise) exposesMapPromise = retrySharedInit(() => __vitePreload(() => import("./virtualExposes-CZsMFYa2.js"), [], import.meta.url)).then((mod) => mod.default ?? mod).catch((e) => {
+		exposesMapPromise = void 0;
+		throw e;
+	});
+	return exposesMapPromise;
+}
+async function init(shared = {}, initScope = []) {
+	const __mfGetSharedCacheKey = (pkg, singleton, version, scope) => {
+		const prefix = ((Array.isArray(scope) ? scope[0] : scope) || "default") + ":";
+		return singleton || !version ? prefix + pkg : prefix + pkg + "@" + version;
+	};
+	const { usedShared, usedRemotes } = await getLocalSharedImportMap();
+	try {
+		const allInstances = globalThis.__FEDERATION__?.__SHARE__;
+		if (allInstances) {
+			const __mfNormalizeRuntimeShare = (mod) => {
+				let current = mod;
+				for (let i = 0; i < 5; i++) {
+					const defaultExport = current?.default;
+					if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+					const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+					if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+					current = defaultExport;
+				}
+				return current;
+			};
+			for (const [, scopes] of Object.entries(allInstances)) {
+				const scopeShare = scopes?.["default"];
+				if (!scopeShare) continue;
+				for (const [pkg, versionMap] of Object.entries(scopeShare)) {
+					const usedShare = usedShared?.[pkg];
+					const selectedProvider = usedShare?.shareConfig?.import === false ? __mfSelectSharedProvider(versionMap, pkg, usedShare, "version-first") : void 0;
+					const providerEntries = usedShare?.shareConfig?.import === false ? Object.entries(versionMap).filter(([, provider]) => provider === selectedProvider) : Object.entries(versionMap);
+					for (const [version, provider] of providerEntries) {
+						if (!provider.lib) continue;
+						const cacheKey = __mfGetSharedCacheKey(pkg, provider.shareConfig?.singleton, version, "default");
+						if (__mfModuleCache.share[cacheKey] !== void 0) continue;
+						const mod = typeof provider.lib === "function" ? provider.lib() : provider.lib;
+						const normalized = __mfNormalizeRuntimeShare(await Promise.resolve(mod));
+						__mfModuleCache.share[cacheKey] = normalized;
+						if (provider.shareConfig?.singleton && usedShare) {
+							const usedCacheKey = __mfGetSharedCacheKey(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
+							if (__mfModuleCache.share[usedCacheKey] === void 0) __mfModuleCache.share[usedCacheKey] = normalized;
+						}
+					}
+				}
+			}
+		}
+	} catch (e) {
+		console.error("[Module Federation] Failed to bridge external shared modules", e);
+	}
+	for (const [pkg, share] of Object.entries(usedShared)) {
+		const cacheKey = __mfGetSharedCacheKey(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		if (__mfModuleCache.share[cacheKey] !== void 0) continue;
+		const singletonCacheKey = __mfGetSharedCacheKey(pkg, true, share.version, share.scope);
+		if (__mfModuleCache.share[singletonCacheKey] !== void 0) __mfModuleCache.share[cacheKey] = __mfModuleCache.share[singletonCacheKey];
+	}
+	if (__mfModuleCache.share["default:react"] === void 0) {
+		const mod = await __vitePreload(() => import("./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_ui_mf_2_components__loadShare__.js-DsLoA9K7.js").then((n) => (n._t(), n.gt)), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:react"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:react-dom"] === void 0) {
+		const mod = await __vitePreload(() => import("./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_ui_mf_2_components__loadShare__.js-DsLoA9K7.js").then((n) => n.Y), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:react-dom"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:zod"] === void 0) {
+		const mod = await __vitePreload(() => import("./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare__zod__loadShare__.js-DE4UUe5K.js").then((n) => n.r), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:zod"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:@baseplate-dev/ui-components"] === void 0) {
+		const mod = await __vitePreload(() => import("./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_ui_mf_2_components__loadShare__.js-DsLoA9K7.js").then((n) => n.t), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:@baseplate-dev/ui-components"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:@baseplate-dev/project-builder-lib"] === void 0) {
+		const mod = await __vitePreload(() => import("./dist-C6kDPCTC.js"), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:@baseplate-dev/project-builder-lib"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:@baseplate-dev/project-builder-lib/web"] === void 0) {
+		const mod = await __vitePreload(() => import("./web-BbqWFVPH.js"), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:@baseplate-dev/project-builder-lib/web"] = exportModule;
+	}
+	if (__mfModuleCache.share["default:@tanstack/react-router"] === void 0) {
+		const mod = await __vitePreload(() => import("./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_tanstack_mf_1_react_mf_2_router__loadShare__.js-CGsbw2Lx.js").then((n) => n.r), [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const normalizedModule = __mfNormalizeRuntimeShare(mod);
+		const exportModule = normalizedModule === mod ? { ...mod } : normalizedModule;
+		Object.defineProperty(exportModule, "__esModule", {
+			value: true,
+			enumerable: false
+		});
+		__mfModuleCache.share["default:@tanstack/react-router"] = exportModule;
+	}
+	const __browserPlugins = [];
+	const __ssrPlugins = typeof globalThis.window === "undefined" ? await Promise.all([]) : [];
+	const initRes = init$1({
+		name: mfName,
+		remotes: usedRemotes,
+		shared: usedShared,
+		plugins: [...__browserPlugins, ...__ssrPlugins],
+		shareStrategy: "version-first"
+	});
+	var initToken = initTokens[shareScopeName];
+	if (!initToken) initToken = initTokens[shareScopeName] = { from: mfName };
+	if (initScope.indexOf(initToken) >= 0) return;
+	initScope.push(initToken);
+	initRes.initShareScopeMap("default", shared);
+	initResolve(initRes);
+	try {
+		await retrySharedInit(async () => {
+			await Promise.all(await initRes.initializeSharing("default", {
+				strategy: "version-first",
+				from: "build",
+				initScope
+			}));
+		});
+	} catch (e) {
+		console.error("[Module Federation]", e);
+	}
+	for (const [pkg, share] of Object.entries(usedShared)) {
+		const cacheKey = __mfGetSharedCacheKey(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		if (share.shareConfig?.import !== false || __mfModuleCache.share[cacheKey] !== void 0) continue;
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const versions = shared?.[pkg];
+		const provider = __mfSelectSharedProvider(versions, pkg, share, "version-first");
+		if (!provider) continue;
+		const factory = provider.lib || (provider.loading ? await provider.loading : await provider.get?.());
+		const mod = typeof factory === "function" ? factory() : factory;
+		const resolved = await Promise.resolve(mod);
+		__mfModuleCache.share[cacheKey] = __mfNormalizeRuntimeShare(resolved);
+	}
+	return initRes;
+}
+async function getExposes(moduleName) {
+	const exposesMap = await getExposesMap();
+	if (!(moduleName in exposesMap)) throw new Error(`[Module Federation] Module ${moduleName} does not exist in container.`);
+	return exposesMap[moduleName]().then((res) => () => res);
+}
+//#endregion
+export { init as n, getExposes as t };
+
+//# sourceMappingURL=virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-Bt9-dftr.js.map