@module-federation/bridge-react 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/dist/prefetch-A3QkU5oZ.js

@@ -0,0 +1,1272 @@
+"use strict";
+const lazyUtils = require("./utils-tM9yE73c.js");
+const index_esm = require("./index.esm-BWaKho-8.js");
+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 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}`;
+};
+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 = index_esm.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 = index_esm.isDebugMode()) {
+  if (isDebug) {
+    CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
+    CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-docs-remove-invalid-lark-link-20251205062649";
+  }
+}
+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 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);
+};
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
+  const versions = shareScopeMap[scope][pkgName];
+  const callback = function(prev, cur) {
+    return !isLoaded(versions[prev]) && versionLt(prev, cur);
+  };
+  return findVersion(shareScopeMap[scope][pkgName], callback);
+}
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
+  const versions = shareScopeMap[scope][pkgName];
+  const callback = function(prev, cur) {
+    const isLoadingOrLoaded = (shared) => {
+      return isLoaded(shared) || isLoading(shared);
+    };
+    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);
+  };
+  return findVersion(shareScopeMap[scope][pkgName], callback);
+}
+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 } = 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 maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
+      const defaultResolver = () => {
+        if (shareConfig.singleton) {
+          if (typeof requiredVersion === "string" && !satisfy(maxOrSingletonVersion, requiredVersion)) {
+            const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && localShareScopeMap[sc][pkgName][maxOrSingletonVersion].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 localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+        } else {
+          if (requiredVersion === false || requiredVersion === "*") {
+            return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+          }
+          if (satisfy(maxOrSingletonVersion, requiredVersion)) {
+            return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+          }
+          for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
+            if (satisfy(versionKey, requiredVersion)) {
+              return versionValue;
+            }
+          }
+        }
+      };
+      const params = {
+        shareScopeMap: localShareScopeMap,
+        scope: sc,
+        pkgName,
+        version: maxOrSingletonVersion,
+        GlobalFederation: Global.__FEDERATION__,
+        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 index_esm.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 index_esm.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 index_esm.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" : index_esm.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 module2 = host.moduleCache.get(remoteInfo.name);
+      if (module2) {
+        getRemoteEntry({
+          origin: host,
+          remoteInfo: moduleInfo,
+          remoteEntryExports: module2.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 } = index_esm.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 } = index_esm.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 } = index_esm.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 } = index_esm.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) {
+    lazyUtils.logger.error("id is required for prefetch!");
+    return;
+  }
+  if (!instance) {
+    lazyUtils.logger.error("instance is required for prefetch!");
+    return;
+  }
+  const matchedRemoteInfo = helpers.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,
+    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 = 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;