@module-federation/bridge-react 2.0.1 → 2.2.0

package/dist/prefetch-DLfc6h__.mjs

@@ -0,0 +1,885 @@
+import { A as warn, x as DATA_FETCH_FUNCTION, F as FS_HREF, l as logger, e as getDataFetchMap, i as initDataFetchMap, n as getDataFetchItem, M as MF_DATA_FETCH_STATUS, p as MF_DATA_FETCH_TYPE, B as DOWNGRADE_KEY, G as callAllDowngrade, H as callDowngrade, I as getDowngradeTag, J as composeKeyWithSeparator, k as getDataFetchInfo, m as getDataFetchMapKey } from "./utils-D4k5eixv.mjs";
+import { i as isBrowserEnvValue } from "./logger-DwWkXsWl.mjs";
+async function safeWrapper(callback, disableWarn) {
+  try {
+    return await callback();
+  } catch (e) {
+    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(`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, /* @__PURE__ */ new Error(`Remote script "${info.url}" time-outed.`));
+  }, timeout);
+  return {
+    script,
+    needAttach
+  };
+}
+function createLink(info) {
+  let link = null;
+  let needAttach = true;
+  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;
+    const attrs = info.attrs;
+    if (info.createLinkHook) {
+      createLinkRes = info.createLinkHook(info.url, attrs);
+      if (createLinkRes instanceof HTMLLinkElement) link = createLinkRes;
+    }
+    if (attrs && !createLinkRes) Object.keys(attrs).forEach((name) => {
+      if (link && !link.getAttribute(name)) link.setAttribute(name, attrs[name]);
+    });
+  }
+  const onLinkComplete = (prev, event) => {
+    const onLinkCompleteCallback = () => {
+      if ((event == null ? void 0 : event.type) === "error") (info == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(event));
+      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);
+  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 loadNodeFetch = async () => {
+  const fetchModule = await importNodeModule("node-fetch");
+  return fetchModule.default || fetchModule;
+};
+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 (typeof fetch === "undefined" ? await loadNodeFetch() : 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 typeof fetch === "undefined" ? loadNodeFetch() : 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 (module) => {
+      await module.evaluate();
+      cb(void 0, module.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();
+async function loadModule(url, options) {
+  if (esmModuleCache.has(url)) return esmModuleCache.get(url);
+  const { fetch: fetch2, vm } = options;
+  const code = await (await fetch2(url)).text();
+  const module = new vm.SourceTextModule(code, { importModuleDynamically: async (specifier, script) => {
+    const resolvedUrl = new URL(specifier, url).href;
+    return loadModule(resolvedUrl, options);
+  } });
+  esmModuleCache.set(url, module);
+  await module.link(async (specifier) => {
+    const resolvedUrl = new URL(specifier, url).href;
+    return await loadModule(resolvedUrl, options);
+  });
+  return module;
+}
+const dataFetchFunction = async function(options) {
+  var _a, _b;
+  const [id, data, downgrade] = options;
+  logger.debug("==========call data fetch function!");
+  if (data) {
+    if (!id) {
+      throw new Error("id is required!");
+    }
+    if (!getDataFetchMap()) {
+      initDataFetchMap();
+    }
+    const dataFetchItem = getDataFetchItem(id);
+    if (dataFetchItem) {
+      (_b = (_a = dataFetchItem[1]) == null ? void 0 : _a[1]) == null ? void 0 : _b.call(_a, data);
+      dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
+      return;
+    }
+    if (!dataFetchItem) {
+      const dataFetchMap = getDataFetchMap();
+      let res;
+      let rej;
+      const p = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      dataFetchMap[id] = [
+        [
+          async () => async () => {
+            return "";
+          },
+          MF_DATA_FETCH_TYPE.FETCH_SERVER
+        ],
+        [p, res, rej],
+        MF_DATA_FETCH_STATUS.LOADED
+      ];
+      res && res(data);
+      return;
+    }
+  }
+  if (downgrade) {
+    const mfDowngrade2 = getDowngradeTag();
+    if (!mfDowngrade2) {
+      globalThis[DOWNGRADE_KEY] = id ? [id] : true;
+    } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+      mfDowngrade2.push(id);
+    }
+  }
+  const mfDowngrade = getDowngradeTag();
+  if (typeof mfDowngrade === "boolean") {
+    return callAllDowngrade();
+  }
+  if (Array.isArray(mfDowngrade)) {
+    if (!id) {
+      globalThis[DOWNGRADE_KEY] = true;
+      return callAllDowngrade();
+    }
+    if (!mfDowngrade.includes(id)) {
+      mfDowngrade.push(id);
+    }
+    return callDowngrade(id);
+  }
+};
+function injectDataFetch() {
+  var _a;
+  globalThis[_a = DATA_FETCH_FUNCTION] || (globalThis[_a] = []);
+  const dataFetch = globalThis[DATA_FETCH_FUNCTION];
+  if (dataFetch.push === dataFetchFunction) {
+    return;
+  }
+  if (typeof window === "undefined") {
+    return;
+  }
+  globalThis[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 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 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;
+  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__);
+  }
+  (_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());
+}
+setGlobalDefaultVal(CurrentGlobal);
+setGlobalDefaultVal(nativeGlobal);
+const getRemoteEntryExports = (name, globalName) => {
+  const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
+  return {
+    remoteEntryKey,
+    entryExports: CurrentGlobal[remoteEntryKey]
+  };
+};
+const DEFAULT_SCOPE = "default";
+const DEFAULT_REMOTE_TYPE = "global";
+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 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."
+};
+({
+  ...runtimeDescMap
+});
+const 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 import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        entry
+      ).then(resolve).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, loaderHook, getEntryUrl }) {
+  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
+      });
+      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 }) {
+  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,
+        loaderHook,
+        getEntryUrl
+      });
+  }
+}
+async function loadEntryNode({ remoteInfo, loaderHook }) {
+  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
+      });
+      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 composeKeyWithSeparator(name, entry);
+}
+async function getRemoteEntry(params) {
+  const { origin, remoteEntryExports, remoteInfo, getEntryUrl, _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({
+      loaderHook,
+      remoteInfo,
+      remoteEntryExports
+    }).then((res) => {
+      if (res) return res;
+      return (typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : isBrowserEnvValue) ? loadEntryDom({
+        remoteInfo,
+        remoteEntryExports,
+        loaderHook,
+        getEntryUrl
+      }) : loadEntryNode({
+        remoteInfo,
+        loaderHook
+      });
+    }).catch(async (err) => {
+      const uniqueKey2 = getRemoteEntryUniqueKey(remoteInfo);
+      const isScriptExecutionError = err instanceof Error && err.message.includes("ScriptExecutionError");
+      if (err instanceof Error && err.message.includes(RUNTIME_008) && !isScriptExecutionError && !_inErrorHandling) {
+        const wrappedGetRemoteEntry = (params2) => {
+          return getRemoteEntry({
+            ...params2,
+            _inErrorHandling: true
+          });
+        };
+        const RemoteEntryExports = await origin.loaderHook.lifecycle.loadEntryError.emit({
+          getRemoteEntry: wrappedGetRemoteEntry,
+          origin,
+          remoteInfo,
+          remoteEntryExports,
+          globalLoading,
+          uniqueKey: uniqueKey2
+        });
+        if (RemoteEntryExports) return RemoteEntryExports;
+      }
+      throw err;
+    });
+  }
+  return globalLoading[uniqueKey];
+}
+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 preloadAssets(remoteInfo, host, assets, useLinkPreload = true) {
+  const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+  if (host.options.inBrowser) {
+    entryAssets.forEach((asset) => {
+      const { moduleInfo } = asset;
+      const module = host.moduleCache.get(remoteInfo.name);
+      if (module) getRemoteEntry({
+        origin: host,
+        remoteInfo: moduleInfo,
+        remoteEntryExports: module.remoteEntryExports
+      });
+      else getRemoteEntry({
+        origin: host,
+        remoteInfo: moduleInfo,
+        remoteEntryExports: void 0
+      });
+    });
+    if (useLinkPreload) {
+      const defaultAttrs = {
+        rel: "preload",
+        as: "style"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const { link: cssEl, needAttach } = createLink({
+          url: cssUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) return res;
+          }
+        });
+        needAttach && document.head.appendChild(cssEl);
+      });
+    } else {
+      const defaultAttrs = {
+        rel: "stylesheet",
+        type: "text/css"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const { link: cssEl, needAttach } = createLink({
+          url: cssUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) return res;
+          },
+          needDeleteLink: false
+        });
+        needAttach && document.head.appendChild(cssEl);
+      });
+    }
+    if (useLinkPreload) {
+      const defaultAttrs = {
+        rel: "preload",
+        as: "script"
+      };
+      jsAssetsWithoutEntry.forEach((jsUrl) => {
+        const { link: linkEl, needAttach } = createLink({
+          url: jsUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) return res;
+          }
+        });
+        needAttach && document.head.appendChild(linkEl);
+      });
+    } else {
+      const defaultAttrs = {
+        fetchpriority: "high",
+        type: (remoteInfo == null ? void 0 : remoteInfo.type) === "module" ? "module" : "text/javascript"
+      };
+      jsAssetsWithoutEntry.forEach((jsUrl) => {
+        const { script: scriptEl, needAttach } = createScript({
+          url: jsUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createScriptHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createScript.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLScriptElement) return res;
+          },
+          needDeleteScript: true
+        });
+        needAttach && document.head.appendChild(scriptEl);
+      });
+    }
+  }
+}
+var helpers_default = {
+  utils: {
+    matchRemoteWithNameAndExpose,
+    preloadAssets,
+    getRemoteInfo
+  }
+};
+typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+const helpers = helpers_default;
+const utils = helpers.utils;
+const runtimeHelpers = {
+  utils
+};
+async function prefetch(options) {
+  const { instance, id, dataFetchParams, preloadComponentResource } = options;
+  if (!id) {
+    logger.error("id is required for prefetch!");
+    return;
+  }
+  if (!instance) {
+    logger.error("instance is required for prefetch!");
+    return;
+  }
+  const matchedRemoteInfo = runtimeHelpers.utils.matchRemoteWithNameAndExpose(
+    instance.options.remotes,
+    id
+  );
+  if (!matchedRemoteInfo) {
+    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,
+    expose
+  });
+  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 = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  const dataFetchInfo = getDataFetchInfo({
+    name: remote.name,
+    alias: remote.alias,
+    id,
+    remoteSnapshot
+  });
+  const dataFetchMapKey = 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
+    });
+  });
+}
+export {
+  dataFetchFunction as d,
+  injectDataFetch as i,
+  prefetch as p
+};