@module-federation/bridge-react 0.24.1 → 2.0.1

package/dist/prefetch-BiUqElFJ.mjs

@@ -1,1391 +0,0 @@
-import { x as DATA_FETCH_FUNCTION, F as FS_HREF, l as logger$1, e as getDataFetchMap, i as initDataFetchMap, n as getDataFetchItem, M as MF_DATA_FETCH_STATUS, p as MF_DATA_FETCH_TYPE, A as DOWNGRADE_KEY, B as callAllDowngrade, G as callDowngrade, H as getDowngradeTag, k as getDataFetchInfo, m as getDataFetchMapKey } from "./utils--qTri1IN.mjs";
-import { a as createLink, b as createScript, i as isDebugMode, d as isBrowserEnv, e as composeKeyWithSeparator, l as loadScriptNode, c as createLogger, f as loadScript } from "./index.esm-CPwSeCvw.mjs";
-const dataFetchFunction = async function(options) {
-  var _a, _b;
-  const [id, data, downgrade] = options;
-  logger$1.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 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 getDocsUrl = (errorCode) => {
-  const type = errorCode.split("-")[0].toLowerCase();
-  return `View the docs to see how to solve: https://module-federation.io/guide/troubleshooting/${type}#${errorCode.toLowerCase()}`;
-};
-const getShortErrorMsg = (errorCode, errorDescMap, args, originalErrorMsg) => {
-  const msg = [`${[errorDescMap[errorCode]]} #${errorCode}`];
-  args && msg.push(`args: ${JSON.stringify(args)}`);
-  msg.push(getDocsUrl(errorCode));
-  return msg.join("\n");
-};
-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."
-};
-({
-  ...runtimeDescMap
-});
-const LOG_CATEGORY = "[ Federation Runtime ]";
-const logger = createLogger(LOG_CATEGORY);
-function assert(condition, msg) {
-  if (!condition) {
-    error(msg);
-  }
-}
-function error(msg) {
-  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(msg) {
-  if (msg instanceof Error) {
-    if (!msg.message.startsWith(LOG_CATEGORY)) {
-      msg.message = `${LOG_CATEGORY}: ${msg.message}`;
-    }
-    logger.warn(msg);
-  } else {
-    logger.warn(msg);
-  }
-}
-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}`;
-  }
-}
-const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
-const nativeGlobal = (() => {
-  try {
-    return document.defaultView;
-  } catch {
-    return CurrentGlobal;
-  }
-})();
-const 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__", {});
-}
-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);
-function resetFederationGlobalInfo() {
-  CurrentGlobal.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
-  CurrentGlobal.__FEDERATION__.__INSTANCES__ = [];
-  CurrentGlobal.__FEDERATION__.moduleInfo = {};
-  CurrentGlobal.__FEDERATION__.__SHARE__ = {};
-  CurrentGlobal.__FEDERATION__.__MANIFEST_LOADING__ = {};
-  Object.keys(globalLoading).forEach((key) => {
-    delete globalLoading[key];
-  });
-}
-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__ = "0.24.1";
-  }
-}
-function getInfoWithoutType(target, key) {
-  if (typeof key === "string") {
-    const keyRes = target[key];
-    if (keyRes) {
-      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 {
-    throw new Error("key must be string");
-  }
-}
-const getGlobalSnapshot = () => nativeGlobal.__FEDERATION__.moduleInfo;
-const getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot) => {
-  const moduleKey = getFMId(moduleInfo);
-  const getModuleInfo = getInfoWithoutType(snapshot, moduleKey).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 == null ? void 0 : getModuleInfoWithoutVersion.version) === version) {
-      return getModuleInfoWithoutVersion;
-    }
-  }
-  return;
-};
-const getGlobalSnapshotInfoByModuleInfo = (moduleInfo) => getTargetSnapshotInfoByModuleInfo(moduleInfo, nativeGlobal.__FEDERATION__.moduleInfo);
-const setGlobalSnapshotInfoByModuleInfo = (remoteInfo, moduleDetailInfo) => {
-  const moduleKey = getFMId(remoteInfo);
-  nativeGlobal.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
-  return nativeGlobal.__FEDERATION__.moduleInfo;
-};
-const 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];
-    }
-  };
-};
-const getRemoteEntryExports = (name, globalName) => {
-  const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
-  const entryExports = CurrentGlobal[remoteEntryKey];
-  return {
-    remoteEntryKey,
-    entryExports
-  };
-};
-const registerGlobalPlugins = (plugins) => {
-  const { __GLOBAL_PLUGIN__ } = nativeGlobal.__FEDERATION__;
-  plugins.forEach((plugin) => {
-    if (__GLOBAL_PLUGIN__.findIndex((p) => p.name === plugin.name) === -1) {
-      __GLOBAL_PLUGIN__.push(plugin);
-    } else {
-      warn(`The plugin ${plugin.name} has been registered.`);
-    }
-  });
-};
-const getGlobalHostPlugins = () => nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
-const getPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.get(id);
-const setPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
-const DEFAULT_SCOPE = "default";
-const DEFAULT_REMOTE_TYPE = "global";
-const buildIdentifier = "[0-9A-Za-z-]+";
-const build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
-const numericIdentifier = "0|[1-9]\\d*";
-const numericIdentifierLoose = "[0-9]+";
-const nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
-const preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
-const preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
-const preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
-const preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
-const xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
-const xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
-const hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
-const mainVersionLoose = `(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`;
-const loosePlain = `[v=\\s]*${mainVersionLoose}${preReleaseLoose}?${build}?`;
-const gtlt = "((?:<|>)?=?)";
-const comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
-const loneTilde = "(?:~>?)";
-const tildeTrim = `(\\s*)${loneTilde}\\s+`;
-const loneCaret = "(?:\\^)";
-const caretTrim = `(\\s*)${loneCaret}\\s+`;
-const star = "(<|>)?=?\\s*\\*";
-const caret = `^${loneCaret}${xRangePlain}$`;
-const mainVersion = `(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`;
-const fullPlain = `v?${mainVersion}${preRelease}?${build}?`;
-const tilde = `^${loneTilde}${xRangePlain}$`;
-const xRange = `^${gtlt}\\s*${xRangePlain}$`;
-const comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
-const gte0 = "^\\s*>=\\s*0.0.0\\s*$";
-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, preRelease2) {
-  const mainVersion2 = `${major}.${minor}.${patch}`;
-  if (preRelease2) {
-    return `${mainVersion2}-${preRelease2}`;
-  }
-  return mainVersion2;
-}
-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, preRelease2) => {
-    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 (preRelease2) {
-      if (major === "0") {
-        if (minor === "0") {
-          return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${minor}.${Number(patch) + 1}-0`;
-        } else {
-          return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${Number(minor) + 1}.0-0`;
-        }
-      } else {
-        return `>=${major}.${minor}.${patch}-${preRelease2} <${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, preRelease2) => {
-    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 (preRelease2) {
-      return `>=${major}.${minor}.${patch}-${preRelease2} <${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, gtlt2, major, minor, patch, preRelease2) => {
-    const isXMajor = isXVersion(major);
-    const isXMinor = isXMajor || isXVersion(minor);
-    const isXPatch = isXMinor || isXVersion(patch);
-    if (gtlt2 === "=" && isXPatch) {
-      gtlt2 = "";
-    }
-    preRelease2 = "";
-    if (isXMajor) {
-      if (gtlt2 === ">" || gtlt2 === "<") {
-        return "<0.0.0-0";
-      } else {
-        return "*";
-      }
-    } else if (gtlt2 && isXPatch) {
-      if (isXMinor) {
-        minor = 0;
-      }
-      patch = 0;
-      if (gtlt2 === ">") {
-        gtlt2 = ">=";
-        if (isXMinor) {
-          major = Number(major) + 1;
-          minor = 0;
-          patch = 0;
-        } else {
-          minor = Number(minor) + 1;
-          patch = 0;
-        }
-      } else if (gtlt2 === "<=") {
-        gtlt2 = "<";
-        if (isXMinor) {
-          major = Number(major) + 1;
-        } else {
-          minor = Number(minor) + 1;
-        }
-      }
-      if (gtlt2 === "<") {
-        preRelease2 = "-0";
-      }
-      return `${gtlt2 + major}.${minor}.${patch}${preRelease2}`;
-    } else if (isXMinor) {
-      return `>=${major}.0.0${preRelease2} <${Number(major) + 1}.0.0-0`;
-    } else if (isXPatch) {
-      return `>=${major}.${minor}.0${preRelease2} <${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), "");
-}
-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;
-  }
-}
-function parseComparatorString(range) {
-  return pipe(
-    // handle caret
-    // ^ --> * (any, kinda silly)
-    // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
-    // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
-    // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
-    // ^1.2.3 --> >=1.2.3 <2.0.0-0
-    // ^1.2.0 --> >=1.2.0 <2.0.0-0
-    parseCarets,
-    // handle tilde
-    // ~, ~> --> * (any, kinda silly)
-    // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
-    // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
-    // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
-    // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
-    // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
-    parseTildes,
-    parseXRanges,
-    parseStar
-  )(range);
-}
-function parseRange(range) {
-  return pipe(
-    // handle hyphenRange
-    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-    parseHyphen,
-    // handle trim comparator
-    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    parseComparatorTrim,
-    // handle trim tilde
-    // `~ 1.2.3` => `~1.2.3`
-    parseTildeTrim,
-    // handle trim caret
-    // `^ 1.2.3` => `^1.2.3`
-    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),
-    // exclude build atom
-    major: versionMajor,
-    minor: versionMinor,
-    patch: versionPatch,
-    preRelease: versionPreRelease == null ? void 0 : 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((comparator2) => parseGTE0(comparator2)).filter(Boolean);
-      if (comparators.length === 0) {
-        continue;
-      }
-      let subRangeSatisfied = true;
-      for (const comparator2 of comparators) {
-        const extractedComparator = extractComparator(comparator2);
-        if (!extractedComparator) {
-          subRangeSatisfied = false;
-          break;
-        }
-        const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
-        const rangeAtom = {
-          operator: rangeOperator,
-          version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
-          major: rangeMajor,
-          minor: rangeMinor,
-          patch: rangePatch,
-          preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split(".")
-        };
-        if (!compare(rangeAtom, versionAtom)) {
-          subRangeSatisfied = false;
-          break;
-        }
-      }
-      if (subRangeSatisfied) {
-        return true;
-      }
-    } catch (e) {
-      console.error(`[semver] Error processing range part "${trimmedOrRange}":`, e);
-      continue;
-    }
-  }
-  return false;
-}
-function shouldUseTreeShaking(treeShaking, usedExports) {
-  if (!treeShaking) {
-    return false;
-  }
-  const { status, mode } = treeShaking;
-  if (status === 0) {
-    return false;
-  }
-  if (status === 2) {
-    return true;
-  }
-  if (mode === "runtime-infer") {
-    if (!usedExports) {
-      return true;
-    }
-    return isMatchUsedExports(treeShaking, usedExports);
-  }
-  return false;
-}
-function versionLt(a, b) {
-  const transformInvalidVersion = (version) => {
-    const isNumberVersion = !Number.isNaN(Number(version));
-    if (isNumberVersion) {
-      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;
-  }
-}
-const 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);
-};
-const isLoaded = (shared) => {
-  return Boolean(shared.loaded) || typeof shared.lib === "function";
-};
-const isLoading = (shared) => {
-  return Boolean(shared.loading);
-};
-const 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
-  };
-}
-const 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 findShareFunction = getFindShareFunction(strategy);
-      const { version: maxOrSingletonVersion, useTreesShaking } = findShareFunction(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(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 == null ? void 0 : 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
-              };
-            }
-          }
-        }
-        return;
-      };
-      const params = {
-        shareScopeMap: localShareScopeMap,
-        scope: sc,
-        pkgName,
-        version: maxOrSingletonVersion,
-        GlobalFederation: Global.__FEDERATION__,
-        shareInfo,
-        resolver: defaultResolver
-      };
-      const resolveShared = resolveShare.emit(params) || params;
-      return resolveShared.resolver();
-    }
-  }
-}
-function getGlobalShareScope() {
-  return Global.__FEDERATION__.__SHARE__;
-}
-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
-        };
-      }
-    }
-  }
-  return;
-}
-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) {
-      reject(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) {
-      reject(e);
-    }
-  });
-}
-function handleRemoteEntryLoaded(name, globalName, entry) {
-  const { remoteEntryKey, entryExports } = getRemoteEntryExports(name, globalName);
-  assert(entryExports, getShortErrorMsg(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;
-      }
-      return;
-    }
-  }).then(() => {
-    return handleRemoteEntryLoaded(name, globalName, entry);
-  }).catch((e) => {
-    assert(void 0, getShortErrorMsg(RUNTIME_008, runtimeDescMap, {
-      remoteName: name,
-      resourceUrl: entry
-    }));
-    throw e;
-  });
-}
-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;
-        }
-        return;
-      }
-    }
-  }).then(() => {
-    return handleRemoteEntryLoaded(name, globalName, entry);
-  }).catch((e) => {
-    throw 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;
-      }
-      const isWebEnvironment = typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : isBrowserEnv();
-      return isWebEnvironment ? loadEntryDom({
-        remoteInfo,
-        remoteEntryExports,
-        loaderHook,
-        getEntryUrl
-      }) : loadEntryNode({ remoteInfo, loaderHook });
-    }).catch(async (err) => {
-      const uniqueKey2 = getRemoteEntryUniqueKey(remoteInfo);
-      const isScriptLoadError = err instanceof Error && err.message.includes(RUNTIME_008);
-      if (isScriptLoadError && !_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;
-            }
-            return;
-          }
-        });
-        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;
-            }
-            return;
-          },
-          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;
-            }
-            return;
-          }
-        });
-        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;
-            }
-            return;
-          },
-          needDeleteScript: true
-        });
-        needAttach && document.head.appendChild(scriptEl);
-      });
-    }
-  }
-}
-const ShareUtils = {
-  getRegisteredShare,
-  getGlobalShareScope
-};
-const GlobalUtils = {
-  Global,
-  nativeGlobal,
-  resetFederationGlobalInfo,
-  setGlobalFederationInstance,
-  getGlobalFederationConstructor,
-  setGlobalFederationConstructor,
-  getInfoWithoutType,
-  getGlobalSnapshot,
-  getTargetSnapshotInfoByModuleInfo,
-  getGlobalSnapshotInfoByModuleInfo,
-  setGlobalSnapshotInfoByModuleInfo,
-  addGlobalSnapshot,
-  getRemoteEntryExports,
-  registerGlobalPlugins,
-  getGlobalHostPlugins,
-  getPreloaded,
-  setPreloaded
-};
-var helpers$1 = {
-  global: GlobalUtils,
-  share: ShareUtils,
-  utils: {
-    matchRemoteWithNameAndExpose,
-    preloadAssets,
-    getRemoteInfo
-  }
-};
-typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
-var helpers = {
-  ...helpers$1,
-  global: {
-    ...helpers$1.global
-  }
-};
-async function prefetch(options) {
-  const { instance, id, dataFetchParams, preloadComponentResource } = options;
-  if (!id) {
-    logger$1.error("id is required for prefetch!");
-    return;
-  }
-  if (!instance) {
-    logger$1.error("instance is required for prefetch!");
-    return;
-  }
-  const matchedRemoteInfo = helpers.utils.matchRemoteWithNameAndExpose(
-    instance.options.remotes,
-    id
-  );
-  if (!matchedRemoteInfo) {
-    logger$1.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 = helpers.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) {
-        helpers.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
-};