@module-federation/bridge-react 0.0.0-perf-devtools-20260108034446 → 0.0.0-perf-website-code-usage-20260914033703

package/dist/prefetch-Bxf6DSx_.js

@@ -0,0 +1,1477 @@
+"use strict";
+const lazyUtils = require("./utils-5dGErM3C.js");
+const logger = require("./logger-Dxblx6P-.js");
+async function safeWrapper(callback, disableWarn) {
+  try {
+    return await callback();
+  } catch (e) {
+    lazyUtils.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 == null ? void 0 : 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 == null ? void 0 : event.type) === "error") {
+        const networkError = /* @__PURE__ */ new Error((event == null ? void 0 : 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 == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(networkError));
+      } else if (executionError) (info == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(executionError));
+      else (info == null ? void 0 : info.cb) && (info == null ? void 0 : info.cb());
+    };
+    if (script) {
+      script.onerror = null;
+      script.onload = null;
+      safeWrapper(() => {
+        const { needDeleteScript = true } = info;
+        if (needDeleteScript) (script == null ? void 0 : 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 == null ? void 0 : info.cb) && (info == null ? void 0 : info.cb());
+    });
+    return {
+      link,
+      needAttach
+    };
+  }
+  const onLinkComplete = (prev, event) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    const onLinkCompleteCallback = () => {
+      if ((event == null ? void 0 : event.type) === "error") {
+        const linkError = /* @__PURE__ */ new Error((event == null ? void 0 : 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 == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(linkError));
+      } else (info == null ? void 0 : info.cb) && (info == null ? void 0 : info.cb());
+    };
+    if (link) {
+      link.onerror = null;
+      link.onload = null;
+      safeWrapper(() => {
+        const { needDeleteLink = true } = info;
+        if (needDeleteLink) (link == null ? void 0 : 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);
+  });
+}
+const sdkImportCache = /* @__PURE__ */ new Map();
+function importNodeModule(name) {
+  if (!name) throw new Error("import specifier is required");
+  if (sdkImportCache.has(name)) return sdkImportCache.get(name);
+  const promise = new Function("name", `return import(name)`)(name).then((res) => res).catch((error2) => {
+    console.error(`Error importing module ${name}:`, error2);
+    sdkImportCache.delete(name);
+    throw error2;
+  });
+  sdkImportCache.set(name, promise);
+  return promise;
+}
+const lazyLoaderHookFetch = async (input, init, loaderHook) => {
+  const hook = (url, init2) => {
+    return loaderHook.lifecycle.fetch.emit(url, init2);
+  };
+  const res = await hook(input, init || {});
+  if (!res || !(res instanceof Response)) return fetch(input, init || {});
+  return res;
+};
+const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url, cb, attrs, loaderHook) => {
+  if (loaderHook == null ? void 0 : loaderHook.createScriptHook) {
+    const hookResult = loaderHook.createScriptHook(url);
+    if (hookResult && typeof hookResult === "object" && "url" in hookResult) url = hookResult.url;
+  }
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch (e) {
+    console.error("Error constructing URL:", e);
+    cb(/* @__PURE__ */ new Error(`Invalid URL: ${e}`));
+    return;
+  }
+  const getFetch = async () => {
+    if (loaderHook == null ? void 0 : loaderHook.fetch) return (input, init) => lazyLoaderHookFetch(input, init, loaderHook);
+    return fetch;
+  };
+  const handleScriptFetch = async (f, urlObj2) => {
+    var _a;
+    try {
+      const res = await f(urlObj2.href);
+      const data = await res.text();
+      const [path, vm] = await Promise.all([importNodeModule("path"), importNodeModule("vm")]);
+      const scriptContext = {
+        exports: {},
+        module: { exports: {} }
+      };
+      const urlDirname = urlObj2.pathname.split("/").slice(0, -1).join("/");
+      const filename = path.basename(urlObj2.pathname);
+      const script = new vm.Script(`(function(exports, module, require, __dirname, __filename) {${data}
+})`, {
+        filename,
+        importModuleDynamically: ((_a = vm.constants) == null ? void 0 : _a.USE_MAIN_CONTEXT_DEFAULT_LOADER) ?? importNodeModule
+      });
+      let requireFn;
+      requireFn = (await importNodeModule("node:module")).createRequire(urlObj2.protocol === "file:" || urlObj2.protocol === "node:" ? urlObj2.href : path.join(process.cwd(), "__mf_require_base__.js"));
+      script.runInThisContext()(scriptContext.exports, scriptContext.module, requireFn, urlDirname, filename);
+      const exportedInterface = scriptContext.module.exports || scriptContext.exports;
+      if (attrs && exportedInterface && attrs["globalName"]) {
+        cb(void 0, exportedInterface[attrs["globalName"]] || exportedInterface);
+        return;
+      }
+      cb(void 0, exportedInterface);
+    } catch (e) {
+      cb(e instanceof Error ? e : /* @__PURE__ */ new Error(`Script execution error: ${e}`));
+    }
+  };
+  getFetch().then(async (f) => {
+    if ((attrs == null ? void 0 : attrs["type"]) === "esm" || (attrs == null ? void 0 : attrs["type"]) === "module") return loadModule(urlObj.href, {
+      fetch: f,
+      vm: await importNodeModule("vm")
+    }).then(async (module2) => {
+      await module2.evaluate();
+      cb(void 0, module2.namespace);
+    }).catch((e) => {
+      cb(e instanceof Error ? e : /* @__PURE__ */ new Error(`Script execution error: ${e}`));
+    });
+    handleScriptFetch(f, urlObj);
+  }).catch((err) => {
+    cb(err);
+  });
+} : (url, cb, attrs, loaderHook) => {
+  cb(/* @__PURE__ */ new Error("createScriptNode is disabled in non-Node.js environment"));
+};
+const loadScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url, info) => {
+  return new Promise((resolve, reject) => {
+    createScriptNode(url, (error2, scriptContext) => {
+      var _a, _b;
+      if (error2) reject(error2);
+      else {
+        const remoteEntryKey = ((_a = info == null ? void 0 : info.attrs) == null ? void 0 : _a["globalName"]) || `__FEDERATION_${(_b = info == null ? void 0 : info.attrs) == null ? void 0 : _b["name"]}:custom__`;
+        resolve(globalThis[remoteEntryKey] = scriptContext);
+      }
+    }, info.attrs, info.loaderHook);
+  });
+} : (url, info) => {
+  throw new Error("loadScriptNode is disabled in non-Node.js environment");
+};
+const esmModuleCache = /* @__PURE__ */ new Map();
+const isFetchableRemoteModuleUrl = (url) => url.startsWith("http:") || url.startsWith("https:");
+const isBareModuleSpecifier = (specifier) => !specifier.startsWith("./") && !specifier.startsWith("../") && !specifier.startsWith("/") && !specifier.includes(":");
+function encodeRemoteModulePath(url) {
+  const remoteUrl = new URL(url);
+  const encodedProtocol = encodeURIComponent(remoteUrl.protocol.slice(0, -1));
+  const encodedHost = encodeURIComponent(remoteUrl.host);
+  const encodedPathname = remoteUrl.pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  const encodedSearchHash = encodeURIComponent(`${remoteUrl.search}${remoteUrl.hash}`);
+  return `/${encodedProtocol}/${encodedHost}${encodedPathname}${encodedSearchHash ? `/${encodedSearchHash}` : ""}`;
+}
+function createImportMetaUrl(url, baseFileUrl) {
+  const baseUrl = baseFileUrl.endsWith("/") ? baseFileUrl : `${baseFileUrl}/`;
+  return new URL(`__module_federation_remote__${encodeRemoteModulePath(url)}`, baseUrl).href;
+}
+async function isNodeBuiltinSpecifier(specifier) {
+  if (specifier.startsWith("node:")) return true;
+  if (!isBareModuleSpecifier(specifier)) return false;
+  return (await importNodeModule("node:module")).builtinModules.includes(specifier);
+}
+function getSyntheticModuleExports(moduleExports) {
+  const namespaceObject = moduleExports && (typeof moduleExports === "object" || typeof moduleExports === "function") ? moduleExports : { default: moduleExports };
+  const effectiveExports = { ...namespaceObject };
+  if (!Object.prototype.hasOwnProperty.call(effectiveExports, "default")) effectiveExports.default = namespaceObject;
+  return effectiveExports;
+}
+async function createSyntheticModuleFromExports(identifier, moduleExports, vm) {
+  if (typeof vm.SyntheticModule !== "function") throw new Error("vm.SyntheticModule is required to load Node.js built-in modules in ESM remote entries.");
+  const effectiveExports = getSyntheticModuleExports(moduleExports);
+  const exportNames = Object.keys(effectiveExports);
+  const syntheticModule = new vm.SyntheticModule(exportNames, function setSyntheticModuleExports() {
+    for (const name of exportNames) this.setExport(name, effectiveExports[name]);
+  }, { identifier });
+  esmModuleCache.set(identifier, syntheticModule);
+  await syntheticModule.link(async () => {
+    throw new Error(`Node.js built-in module "${identifier}" should not request child modules.`);
+  });
+  await syntheticModule.evaluate();
+  return syntheticModule;
+}
+async function loadNodeBuiltinModule(specifier, vm) {
+  const cacheKey = `node-builtin:${specifier}`;
+  if (esmModuleCache.has(cacheKey)) return esmModuleCache.get(cacheKey);
+  return createSyntheticModuleFromExports(cacheKey, await importNodeModule(specifier), vm);
+}
+async function loadResolvedModule(specifier, parentUrl, options) {
+  if (await isNodeBuiltinSpecifier(specifier)) return loadNodeBuiltinModule(specifier, options.vm);
+  if (isBareModuleSpecifier(specifier)) throw new Error(`Unsupported ESM module specifier "${specifier}". Only relative or absolute http(s) remote modules and Node.js built-in modules are supported.`);
+  const resolvedUrl = new URL(specifier, parentUrl).href;
+  if (!isFetchableRemoteModuleUrl(resolvedUrl)) throw new Error(`Unsupported ESM module specifier "${specifier}" resolved to "${resolvedUrl}". Only http(s) remote modules and Node.js built-in modules are supported.`);
+  return loadModule(resolvedUrl, options);
+}
+async function evaluateDynamicModule(module2) {
+  if (module2.status === "linked") await module2.evaluate();
+  if (module2.status === "errored") throw module2.error;
+  return module2;
+}
+async function loadModule(url, options) {
+  if (esmModuleCache.has(url)) return esmModuleCache.get(url);
+  const { fetch: fetch2, vm } = options;
+  if (!isFetchableRemoteModuleUrl(url)) throw new Error(`Unsupported ESM module URL "${url}". Only http(s) remote modules and Node.js built-in modules are supported.`);
+  const code = await (await fetch2(url)).text();
+  const cwdFileUrl = (await importNodeModule("node:url")).pathToFileURL(process.cwd()).href;
+  const sourceTextModule = new vm.SourceTextModule(code, {
+    identifier: url,
+    initializeImportMeta: (meta) => {
+      meta.url = createImportMetaUrl(url, cwdFileUrl);
+    },
+    importModuleDynamically: async (specifier) => {
+      return evaluateDynamicModule(await loadResolvedModule(specifier, url, options));
+    }
+  });
+  esmModuleCache.set(url, sourceTextModule);
+  await sourceTextModule.link(async (specifier) => {
+    return loadResolvedModule(specifier, url, options);
+  });
+  return sourceTextModule;
+}
+const dataFetchFunction = async function(options) {
+  var _a, _b;
+  const [id, data, downgrade] = options;
+  lazyUtils.logger.debug("==========call data fetch function!");
+  if (data) {
+    if (!id) {
+      throw new Error("id is required!");
+    }
+    if (!lazyUtils.getDataFetchMap()) {
+      lazyUtils.initDataFetchMap();
+    }
+    const dataFetchItem = lazyUtils.getDataFetchItem(id);
+    if (dataFetchItem) {
+      (_b = (_a = dataFetchItem[1]) == null ? void 0 : _a[1]) == null ? void 0 : _b.call(_a, data);
+      dataFetchItem[2] = lazyUtils.MF_DATA_FETCH_STATUS.LOADED;
+      return;
+    }
+    if (!dataFetchItem) {
+      const dataFetchMap = lazyUtils.getDataFetchMap();
+      let res;
+      let rej;
+      const p = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      dataFetchMap[id] = [
+        [
+          async () => async () => {
+            return "";
+          },
+          lazyUtils.MF_DATA_FETCH_TYPE.FETCH_SERVER
+        ],
+        [p, res, rej],
+        lazyUtils.MF_DATA_FETCH_STATUS.LOADED
+      ];
+      res && res(data);
+      return;
+    }
+  }
+  if (downgrade) {
+    const mfDowngrade2 = lazyUtils.getDowngradeTag();
+    if (!mfDowngrade2) {
+      globalThis[lazyUtils.DOWNGRADE_KEY] = id ? [id] : true;
+    } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+      mfDowngrade2.push(id);
+    }
+  }
+  const mfDowngrade = lazyUtils.getDowngradeTag();
+  if (typeof mfDowngrade === "boolean") {
+    return lazyUtils.callAllDowngrade();
+  }
+  if (Array.isArray(mfDowngrade)) {
+    if (!id) {
+      globalThis[lazyUtils.DOWNGRADE_KEY] = true;
+      return lazyUtils.callAllDowngrade();
+    }
+    if (!mfDowngrade.includes(id)) {
+      mfDowngrade.push(id);
+    }
+    return lazyUtils.callDowngrade(id);
+  }
+};
+function injectDataFetch() {
+  var _a;
+  globalThis[_a = lazyUtils.DATA_FETCH_FUNCTION] || (globalThis[_a] = []);
+  const dataFetch = globalThis[lazyUtils.DATA_FETCH_FUNCTION];
+  if (dataFetch.push === dataFetchFunction) {
+    return;
+  }
+  if (typeof window === "undefined") {
+    return;
+  }
+  globalThis[lazyUtils.FS_HREF] = window.location.href;
+  dataFetch.push = dataFetchFunction;
+}
+const getDocsUrl = (errorCode) => {
+  return `View the docs to see how to solve: https://module-federation.io/guide/troubleshooting/${errorCode.split("-")[0].toLowerCase()}#${errorCode.toLowerCase()}`;
+};
+const 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:
+ ${originalErrorMsg}`);
+  return msg.join("\n");
+};
+function logAndReport(code, descMap, args, logger2, originalErrorMsg, context) {
+  return logger2(getShortErrorMsg(code, descMap, args, originalErrorMsg));
+}
+const LOG_CATEGORY = "[ Federation Runtime ]";
+function assert(condition, msgOrCode, descMap, args, context) {
+  if (!condition) error(msgOrCode);
+}
+function error(msgOrCode, descMap, args, originalErrorMsg, context) {
+  if (descMap !== void 0) return logAndReport(msgOrCode, descMap, args ?? {}, (msg2) => {
+    throw new Error(`${LOG_CATEGORY}: ${msg2}`);
+  }, originalErrorMsg);
+  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}`);
+}
+const 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;
+};
+const MAX_PRELOADED_ASSETS = 2e3;
+const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
+const nativeGlobal = (() => {
+  try {
+    return document.defaultView;
+  } catch {
+    return CurrentGlobal;
+  }
+})();
+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__", {});
+const globalLoading = CurrentGlobal.__GLOBAL_LOADING_REMOTE_ENTRY__;
+function setGlobalDefaultVal(target) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  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(),
+      __PRELOADED_ASSETS__: /* @__PURE__ */ new Set()
+    });
+    definePropertyGlobalVal(target, "__VMOK__", target.__FEDERATION__);
+  }
+  (_a = target.__FEDERATION__).__GLOBAL_PLUGIN__ ?? (_a.__GLOBAL_PLUGIN__ = []);
+  (_b = target.__FEDERATION__).__INSTANCES__ ?? (_b.__INSTANCES__ = []);
+  (_c = target.__FEDERATION__).moduleInfo ?? (_c.moduleInfo = {});
+  (_d = target.__FEDERATION__).__SHARE__ ?? (_d.__SHARE__ = {});
+  (_e = target.__FEDERATION__).__MANIFEST_LOADING__ ?? (_e.__MANIFEST_LOADING__ = {});
+  (_f = target.__FEDERATION__).__PRELOADED_MAP__ ?? (_f.__PRELOADED_MAP__ = /* @__PURE__ */ new Map());
+  (_g = target.__FEDERATION__).__PRELOADED_ASSETS__ ?? (_g.__PRELOADED_ASSETS__ = /* @__PURE__ */ new Set());
+}
+setGlobalDefaultVal(CurrentGlobal);
+setGlobalDefaultVal(nativeGlobal);
+const getRemoteEntryExports = (name, globalName) => {
+  const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
+  return {
+    remoteEntryKey,
+    entryExports: CurrentGlobal[remoteEntryKey]
+  };
+};
+const getPreloadedAsset = (url) => CurrentGlobal.__FEDERATION__.__PRELOADED_ASSETS__.has(url);
+const setPreloadedAsset = (url) => {
+  const preloadedAssets = CurrentGlobal.__FEDERATION__.__PRELOADED_ASSETS__;
+  preloadedAssets.add(url);
+  if (preloadedAssets.size > MAX_PRELOADED_ASSETS) {
+    const oldestUrl = preloadedAssets.values().next().value;
+    if (oldestUrl !== void 0) preloadedAssets.delete(oldestUrl);
+  }
+};
+const DEFAULT_SCOPE = "default";
+const DEFAULT_REMOTE_TYPE = "global";
+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
+      };
+    }
+  }
+}
+const RUNTIME_001 = "RUNTIME-001";
+const RUNTIME_002 = "RUNTIME-002";
+const RUNTIME_003 = "RUNTIME-003";
+const RUNTIME_004 = "RUNTIME-004";
+const RUNTIME_005 = "RUNTIME-005";
+const RUNTIME_006 = "RUNTIME-006";
+const RUNTIME_007 = "RUNTIME-007";
+const RUNTIME_008 = "RUNTIME-008";
+const RUNTIME_009 = "RUNTIME-009";
+const RUNTIME_010 = "RUNTIME-010";
+const RUNTIME_011 = "RUNTIME-011";
+const RUNTIME_012 = "RUNTIME-012";
+const RUNTIME_013 = "RUNTIME-013";
+const RUNTIME_014 = "RUNTIME-014";
+const RUNTIME_015 = "RUNTIME-015";
+const 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."
+};
+({
+  ...runtimeDescMap
+});
+const importCallback = ".then(callbacks[0]).catch(callbacks[1])";
+const remoteEntryLoadingOrigins = /* @__PURE__ */ new WeakMap();
+const esmRemoteEntryLoadErrorMessages = [
+  "Failed to fetch dynamically imported module",
+  "Importing a module script failed",
+  "error loading dynamically imported module"
+];
+function isEsmRemoteEntryLoadError(err) {
+  if (!(err instanceof TypeError)) return false;
+  return esmRemoteEntryLoadErrorMessages.some((loadErrorMessage) => err.message.includes(loadErrorMessage));
+}
+function isEsmRemoteType(type) {
+  return type === "esm" || type === "module";
+}
+async function loadEsmEntry({ entry, remoteEntryExports, name, getEntryUrl }) {
+  return new Promise((resolve, reject) => {
+    const rejectEntry = (loadError) => {
+      if (isEsmRemoteEntryLoadError(loadError)) {
+        const originalMsg = loadError instanceof Error ? loadError.message : String(loadError);
+        try {
+          error(RUNTIME_008, runtimeDescMap, {
+            remoteName: name,
+            resourceUrl: url
+          }, originalMsg);
+        } catch (runtimeError) {
+          reject(runtimeError);
+          return;
+        }
+      }
+      reject(loadError);
+    };
+    const url = getEntryUrl ? getEntryUrl(entry) : entry;
+    try {
+      if (!remoteEntryExports) if (typeof FEDERATION_ALLOW_NEW_FUNCTION !== "undefined") new Function("callbacks", `import("${url}")${importCallback}`)([resolve, rejectEntry]);
+      else import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        url
+      ).then(resolve).catch(rejectEntry);
+      else resolve(remoteEntryExports);
+    } catch (e) {
+      error(`Failed to load ESM entry from "${url}". ${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: (url2, attrs) => {
+      const res = loaderHook.lifecycle.createScript.emit({
+        url: url2,
+        attrs,
+        remoteInfo,
+        resourceContext: resourceContext ? {
+          ...resourceContext,
+          url: url2
+        } : 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;
+  if (isEsmRemoteType(type)) return loadEsmEntry({
+    entry,
+    remoteEntryExports,
+    name,
+    getEntryUrl
+  });
+  if (type === "system") return loadSystemJsEntry({
+    entry,
+    remoteEntryExports
+  });
+  return loadEntryScript({
+    entry,
+    globalName,
+    name,
+    remoteInfo,
+    loaderHook,
+    getEntryUrl,
+    resourceContext
+  });
+}
+async function loadEntryNode({ remoteInfo, loaderHook, resourceContext }) {
+  const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
+  const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
+  if (remoteEntryExports) return remoteEntryExports;
+  return loadScriptNode(entry, {
+    attrs: {
+      name,
+      globalName,
+      type
+    },
+    loaderHook: { createScriptHook: (url, attrs = {}) => {
+      const res = loaderHook.lifecycle.createScript.emit({
+        url,
+        attrs,
+        remoteInfo,
+        resourceContext: resourceContext ? {
+          ...resourceContext,
+          url
+        } : void 0
+      });
+      if (!res) return;
+      if ("url" in res) return res;
+    } }
+  }).then(() => {
+    return handleRemoteEntryLoaded(name, globalName, entry);
+  }).catch((e) => {
+    error(`Failed to load Node.js entry for remote "${name}" from "${entry}". ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
+function getRemoteEntryUniqueKey(remoteInfo) {
+  const { entry, name } = remoteInfo;
+  return lazyUtils.composeKeyWithSeparator(name, entry);
+}
+async function getRemoteEntry(params) {
+  const { origin, remoteEntryExports, remoteInfo, getEntryUrl, resourceContext, _inErrorHandling = false } = params;
+  const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+  if (remoteEntryExports) {
+    await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+      origin,
+      remoteInfo,
+      remoteEntryExports,
+      resourceContext,
+      cached: true
+    });
+    return remoteEntryExports;
+  }
+  if (!globalLoading[uniqueKey]) {
+    const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
+    const loaderHook = origin.loaderHook;
+    const loading = loadEntryHook.emit({
+      origin,
+      loaderHook,
+      remoteInfo,
+      remoteEntryExports,
+      resourceContext
+    }).then((res) => {
+      if (res) return res;
+      return (typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : logger.isBrowserEnvValue) ? loadEntryDom({
+        remoteInfo,
+        remoteEntryExports,
+        loaderHook,
+        getEntryUrl,
+        resourceContext
+      }) : loadEntryNode({
+        remoteInfo,
+        loaderHook,
+        resourceContext
+      });
+    }).then(async (res) => {
+      await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+        origin,
+        remoteInfo,
+        remoteEntryExports: res,
+        resourceContext
+      });
+      return res;
+    }).catch(async (loadError) => {
+      const isScriptExecutionError = loadError instanceof Error && loadError.message.includes("ScriptExecutionError");
+      if (loadError instanceof Error && loadError.message.includes(RUNTIME_008) && !isScriptExecutionError && !_inErrorHandling) {
+        const wrappedGetRemoteEntry = (params2) => {
+          return getRemoteEntry({
+            ...params2,
+            _inErrorHandling: true
+          });
+        };
+        const recoveredRemoteEntryExports = await origin.loaderHook.lifecycle.loadEntryError.emit({
+          getRemoteEntry: wrappedGetRemoteEntry,
+          origin,
+          remoteInfo,
+          remoteEntryExports,
+          globalLoading,
+          uniqueKey
+        });
+        if (recoveredRemoteEntryExports) {
+          await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+            origin,
+            remoteInfo,
+            remoteEntryExports: recoveredRemoteEntryExports,
+            resourceContext,
+            error: loadError,
+            recovered: true
+          });
+          return recoveredRemoteEntryExports;
+        }
+      }
+      await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+        origin,
+        remoteInfo,
+        resourceContext,
+        error: loadError
+      });
+      throw loadError;
+    });
+    globalLoading[uniqueKey] = loading;
+    loading.then(void 0, () => {
+      if (globalLoading[uniqueKey] === loading) delete globalLoading[uniqueKey];
+    });
+    remoteEntryLoadingOrigins.set(loading, origin);
+  }
+  const remoteEntryLoading = globalLoading[uniqueKey];
+  if (remoteEntryLoadingOrigins.get(remoteEntryLoading) !== origin) try {
+    const result = await remoteEntryLoading;
+    await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+      origin,
+      remoteInfo,
+      remoteEntryExports: result,
+      resourceContext
+    });
+    return result;
+  } catch (loadError) {
+    await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+      origin,
+      remoteInfo,
+      resourceContext,
+      error: loadError
+    });
+    throw loadError;
+  }
+  return remoteEntryLoading;
+}
+function getRemoteInfo(remote) {
+  return {
+    ...remote,
+    entry: "entry" in remote ? remote.entry : "",
+    type: remote.type || DEFAULT_REMOTE_TYPE,
+    entryGlobalName: remote.entryGlobalName || remote.name,
+    shareScope: remote.shareScope || DEFAULT_SCOPE
+  };
+}
+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
+  };
+}
+function optionsToMFContext(options) {
+  var _a, _b, _c, _d, _e, _f;
+  const shared = {};
+  for (const [pkgName, versions] of Object.entries(options.shared)) {
+    const first = versions[0];
+    if (first) shared[pkgName] = {
+      version: first.version,
+      singleton: (_a = first.shareConfig) == null ? void 0 : _a.singleton,
+      requiredVersion: ((_b = first.shareConfig) == null ? void 0 : _b.requiredVersion) === false ? false : (_c = first.shareConfig) == null ? void 0 : _c.requiredVersion,
+      eager: first.eager,
+      strictVersion: (_d = first.shareConfig) == null ? void 0 : _d.strictVersion
+    };
+  }
+  return {
+    project: {
+      name: options.name,
+      mfRole: ((_e = options.remotes) == null ? void 0 : _e.length) > 0 ? "host" : "unknown"
+    },
+    mfConfig: {
+      name: options.name,
+      remotes: ((_f = options.remotes) == null ? void 0 : _f.map(remoteToEntry)) ?? [],
+      shared
+    }
+  };
+}
+function isTimeoutError(error2) {
+  if (!(error2 instanceof Error)) return false;
+  return error2.message.includes("timed out") || error2.name.includes("Timeout");
+}
+function createAssetResult(context, url, status, error2) {
+  return {
+    url,
+    status,
+    resourceType: context.resourceType,
+    initiator: context.initiator,
+    id: context.id,
+    error: error2
+  };
+}
+function preloadAssetOnce(context, url, recordPreloadedAssets, preload) {
+  if (!recordPreloadedAssets) return preload();
+  if (getPreloadedAsset(url)) return Promise.resolve(createAssetResult(context, url, "cached"));
+  setPreloadedAsset(url);
+  return preload();
+}
+async function waitForRemoteEntryPreload(host, remoteInfo, entryRemoteInfo, context) {
+  const cachedRemote = host.moduleCache.get(entryRemoteInfo.name);
+  const url = entryRemoteInfo.entry;
+  if (cachedRemote == null ? void 0 : cachedRemote.remoteEntryExports) return createAssetResult(context, url, "cached");
+  try {
+    if (!await getRemoteEntry({
+      origin: host,
+      remoteInfo: entryRemoteInfo,
+      remoteEntryExports: cachedRemote == null ? void 0 : cachedRemote.remoteEntryExports,
+      resourceContext: {
+        ...context,
+        url
+      }
+    })) throw new Error(`Failed to load remoteEntry "${url}".`);
+    return createAssetResult(context, url, "success");
+  } catch (error2) {
+    return createAssetResult(context, url, isTimeoutError(error2) ? "timeout" : "error", error2);
+  }
+}
+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: (error2) => {
+        resolve(createAssetResult(context, url, isTimeoutError(error2) ? "timeout" : "error", error2));
+      },
+      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: (error2) => {
+        resolve(createAssetResult(context, url, isTimeoutError(error2) ? "timeout" : "error", error2));
+      },
+      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
+}, recordPreloadedAssets = true) {
+  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 defaultAttrs2 = {
+        rel: "preload",
+        as: "style"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const context = createResourceContext(baseContext, "css");
+        results.push(preloadAssetOnce(context, cssUrl, recordPreloadedAssets, () => waitForLinkPreload({
+          host,
+          remoteInfo,
+          url: cssUrl,
+          attrs: defaultAttrs2,
+          context
+        })));
+      });
+    } else {
+      const defaultAttrs2 = {
+        rel: "stylesheet",
+        type: "text/css"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const context = createResourceContext(baseContext, "css");
+        results.push(preloadAssetOnce(context, cssUrl, recordPreloadedAssets, () => waitForLinkPreload({
+          host,
+          remoteInfo,
+          url: cssUrl,
+          attrs: defaultAttrs2,
+          needDeleteLink: false,
+          context
+        })));
+      });
+    }
+    let preloadJsAsset = waitForScriptPreload;
+    let defaultAttrs = {
+      fetchpriority: "high",
+      type: "text/javascript"
+    };
+    if (useLinkPreload) {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
+        rel: "preload",
+        as: "script"
+      };
+    } else if (isEsmRemoteType(remoteInfo.type)) {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
+        rel: "modulepreload",
+        fetchpriority: "high"
+      };
+    }
+    jsAssetsWithoutEntry.forEach((jsUrl) => {
+      const context = createResourceContext(baseContext, "js");
+      results.push(preloadAssetOnce(context, jsUrl, recordPreloadedAssets, () => preloadJsAsset({
+        host,
+        remoteInfo,
+        url: jsUrl,
+        attrs: defaultAttrs,
+        context
+      })));
+    });
+  }
+  return Promise.all(results);
+}
+var helpers_default = {
+  utils: {
+    matchRemoteWithNameAndExpose,
+    preloadAssets,
+    getRemoteInfo
+  }
+};
+function getAvailableExposeNames(remoteSnapshot) {
+  if (!remoteSnapshot || !("modules" in remoteSnapshot) || !Array.isArray(remoteSnapshot.modules)) return;
+  const exposes = remoteSnapshot.modules.map((module2) => module2.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, resourceContext) {
+    const effectiveResourceContext = resourceContext || {
+      initiator: "loadRemote",
+      id: composeRemoteRequestId(this.remoteInfo.name, expose),
+      resourceType: "remoteEntry",
+      url: this.remoteInfo.entry,
+      expose
+    };
+    const remoteEntryExports = await getRemoteEntry({
+      origin: this.host,
+      remoteInfo: this.remoteInfo,
+      remoteEntryExports: this.remoteEntryExports,
+      resourceContext: effectiveResourceContext
+    });
+    assert(remoteEntryExports, `remoteEntryExports is undefined 
+ ${lazyUtils.safeToString(this.remoteInfo)}`);
+    this.remoteEntryExports = remoteEntryExports;
+    return this.remoteEntryExports;
+  }
+  async init(id, remoteSnapshot, rawInitScope, expose, resourceContext) {
+    const remoteEntryExports = await this.getEntry(expose, resourceContext);
+    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 == null ? void 0 : 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, id2) {
+      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: id2,
+        enumerable: false
+      });
+    }
+    return () => {
+      const res = moduleFactory();
+      if (res instanceof Promise) return res.then((asyncRes) => {
+        defineModuleId(asyncRes, id);
+        return asyncRes;
+      });
+      defineModuleId(res, id);
+      return res;
+    };
+  }
+};
+const REMOTE_DISABLED_MESSAGE = "Remote loading is disabled by experiments.optimization.disableRemote.";
+var UnavailableRemoteModule = class {
+  constructor() {
+    throw new Error(REMOTE_DISABLED_MESSAGE);
+  }
+};
+typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" ? !FEDERATION_OPTIMIZE_NO_REMOTE : true;
+typeof FEDERATION_OPTIMIZE_NO_SHARED === "boolean" ? !FEDERATION_OPTIMIZE_NO_SHARED : true;
+const helpers = helpers_default;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" && FEDERATION_OPTIMIZE_NO_REMOTE ? UnavailableRemoteModule : Module$1;
+const utils = helpers.utils;
+const runtimeHelpers = {
+  utils
+};
+async function prefetch(options) {
+  const { instance, id, dataFetchParams, preloadComponentResource } = options;
+  if (!id) {
+    lazyUtils.logger.error("id is required for prefetch!");
+    return;
+  }
+  if (!instance) {
+    lazyUtils.logger.error("instance is required for prefetch!");
+    return;
+  }
+  const matchedRemoteInfo = runtimeHelpers.utils.matchRemoteWithNameAndExpose(
+    instance.options.remotes,
+    id
+  );
+  if (!matchedRemoteInfo) {
+    lazyUtils.logger.error(`Can not found '${id}' in instance.options.remotes!`);
+    return;
+  }
+  const { remote, expose } = matchedRemoteInfo;
+  const { remoteSnapshot, globalSnapshot } = await instance.snapshotHandler.loadRemoteSnapshotInfo({
+    moduleInfo: remote,
+    id
+  });
+  if (preloadComponentResource) {
+    const remoteInfo = runtimeHelpers.utils.getRemoteInfo(remote);
+    Promise.resolve(
+      instance.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+        origin: instance,
+        preloadOptions: {
+          remote,
+          preloadConfig: {
+            nameOrAlias: remote.name,
+            exposes: [expose]
+          }
+        },
+        remote,
+        remoteInfo,
+        globalSnapshot,
+        remoteSnapshot
+      })
+    ).then((assets) => {
+      if (assets) {
+        runtimeHelpers.utils.preloadAssets(remoteInfo, instance, assets);
+      }
+    });
+  }
+  const dataFetchMap = lazyUtils.getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  const dataFetchInfo = lazyUtils.getDataFetchInfo({
+    name: remote.name,
+    alias: remote.alias,
+    id,
+    remoteSnapshot
+  });
+  const dataFetchMapKey = lazyUtils.getDataFetchMapKey(dataFetchInfo, {
+    name: instance.name,
+    version: instance.options.version
+  });
+  if (!dataFetchMapKey) {
+    return;
+  }
+  const dataFetchItem = dataFetchMap[dataFetchMapKey];
+  if (!dataFetchItem) {
+    return;
+  }
+  const [getDataFetchGetter, _type, getDataFetchPromise] = dataFetchItem[0];
+  let _getDataFetchPromise = getDataFetchPromise;
+  if (!getDataFetchPromise) {
+    if (!getDataFetchGetter) {
+      return;
+    }
+    _getDataFetchPromise = getDataFetchGetter();
+  }
+  _getDataFetchPromise.then((dataFetchFn) => {
+    return dataFetchFn({
+      ...dataFetchParams,
+      _id: dataFetchMapKey,
+      isDowngrade: false
+    });
+  });
+}
+exports.dataFetchFunction = dataFetchFunction;
+exports.injectDataFetch = injectDataFetch;
+exports.prefetch = prefetch;