@module-federation/bridge-react 0.0.0-next-20241113115843 → 0.0.0-next-20241114041727

package/dist/index.cjs.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
-const context = require("./context-C9uJCrqC.cjs");
+const context = require("./context-BcJ-YlNr.cjs");
 const ReactRouterDOM = require("react-router-dom");
+const runtime = require("@module-federation/runtime");
 const ReactDOM = require("react-dom");
 function _interopNamespaceDefault(e2) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -33,17 +34,17 @@ class ErrorBoundary extends React.Component {
     this.resetErrorBoundary = this.resetErrorBoundary.bind(this);
     this.state = initialState;
   }
-  static getDerivedStateFromError(error2) {
+  static getDerivedStateFromError(error) {
     return {
       didCatch: true,
-      error: error2
+      error
     };
   }
   resetErrorBoundary() {
     const {
-      error: error2
+      error
     } = this.state;
-    if (error2 !== null) {
+    if (error !== null) {
       var _this$props$onReset, _this$props;
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
@@ -55,9 +56,9 @@ class ErrorBoundary extends React.Component {
       this.setState(initialState);
     }
   }
-  componentDidCatch(error2, info) {
+  componentDidCatch(error, info) {
     var _this$props$onError, _this$props2;
-    (_this$props$onError = (_this$props2 = this.props).onError) === null || _this$props$onError === void 0 ? void 0 : _this$props$onError.call(_this$props2, error2, info);
+    (_this$props$onError = (_this$props2 = this.props).onError) === null || _this$props$onError === void 0 ? void 0 : _this$props$onError.call(_this$props2, error, info);
   }
   componentDidUpdate(prevProps, prevState) {
     const {
@@ -85,12 +86,12 @@ class ErrorBoundary extends React.Component {
     } = this.props;
     const {
       didCatch,
-      error: error2
+      error
     } = this.state;
     let childToRender = children;
     if (didCatch) {
       const props = {
-        error: error2,
+        error,
         resetErrorBoundary: this.resetErrorBoundary
       };
       if (typeof fallbackRender === "function") {
@@ -100,13 +101,13 @@ class ErrorBoundary extends React.Component {
       } else if (fallback === null || React.isValidElement(fallback)) {
         childToRender = fallback;
       } else {
-        throw error2;
+        throw error;
       }
     }
     return React.createElement(ErrorBoundaryContext.Provider, {
       value: {
         didCatch,
-        error: error2,
+        error,
         resetErrorBoundary: this.resetErrorBoundary
       }
     }, childToRender);
@@ -121,2839 +122,6 @@ function e() {
   const t = new PopStateEvent("popstate", { state: window.history.state });
   window.dispatchEvent(t);
 }
-function _extends$1() {
-  _extends$1 = Object.assign || function assign(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source)
-        if (Object.prototype.hasOwnProperty.call(source, key))
-          target[key] = source[key];
-    }
-    return target;
-  };
-  return _extends$1.apply(this, arguments);
-}
-function _object_without_properties_loose(source, excluded) {
-  if (source == null)
-    return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0)
-      continue;
-    target[key] = source[key];
-  }
-  return target;
-}
-function getBuilderId() {
-  return typeof FEDERATION_BUILD_IDENTIFIER !== "undefined" ? FEDERATION_BUILD_IDENTIFIER : "";
-}
-const LOG_CATEGORY = "[ Federation Runtime ]";
-const logger = context.createLogger(LOG_CATEGORY);
-function assert(condition, msg) {
-  if (!condition) {
-    error(msg);
-  }
-}
-function error(msg) {
-  if (msg instanceof Error) {
-    msg.message = `${LOG_CATEGORY}: ${msg.message}`;
-    throw msg;
-  }
-  throw new Error(`${LOG_CATEGORY}: ${msg}`);
-}
-function warn(msg) {
-  if (msg instanceof Error) {
-    msg.message = `${LOG_CATEGORY}: ${msg.message}`;
-    logger.warn(msg);
-  } else {
-    logger.warn(msg);
-  }
-}
-function addUniqueItem(arr, item) {
-  if (arr.findIndex((name2) => name2 === item) === -1) {
-    arr.push(item);
-  }
-  return arr;
-}
-function getFMId(remoteInfo) {
-  if ("version" in remoteInfo && remoteInfo.version) {
-    return `${remoteInfo.name}:${remoteInfo.version}`;
-  } else if ("entry" in remoteInfo && remoteInfo.entry) {
-    return `${remoteInfo.name}:${remoteInfo.entry}`;
-  } else {
-    return `${remoteInfo.name}`;
-  }
-}
-function isRemoteInfoWithEntry(remote) {
-  return typeof remote.entry !== "undefined";
-}
-function isPureRemoteEntry(remote) {
-  return !remote.entry.includes(".json") && remote.entry.includes(".js");
-}
-function isObject(val) {
-  return val && typeof val === "object";
-}
-const objectToString = Object.prototype.toString;
-function isPlainObject(val) {
-  return objectToString.call(val) === "[object Object]";
-}
-function arrayOptions(options) {
-  return Array.isArray(options) ? options : [
-    options
-  ];
-}
-function getRemoteEntryInfoFromSnapshot(snapshot) {
-  const defaultRemoteEntryInfo = {
-    url: "",
-    type: "global",
-    globalName: ""
-  };
-  if (context.isBrowserEnv()) {
-    return "remoteEntry" in snapshot ? {
-      url: snapshot.remoteEntry,
-      type: snapshot.remoteEntryType,
-      globalName: snapshot.globalName
-    } : defaultRemoteEntryInfo;
-  }
-  if ("ssrRemoteEntry" in snapshot) {
-    return {
-      url: snapshot.ssrRemoteEntry || defaultRemoteEntryInfo.url,
-      type: snapshot.ssrRemoteEntryType || defaultRemoteEntryInfo.type,
-      globalName: snapshot.globalName
-    };
-  }
-  return defaultRemoteEntryInfo;
-}
-const processModuleAlias = (name2, subPath) => {
-  let moduleName;
-  if (name2.endsWith("/")) {
-    moduleName = name2.slice(0, -1);
-  } else {
-    moduleName = name2;
-  }
-  if (subPath.startsWith(".")) {
-    subPath = subPath.slice(1);
-  }
-  moduleName = moduleName + subPath;
-  return moduleName;
-};
-const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
-const nativeGlobal = (() => {
-  try {
-    return document.defaultView;
-  } catch (e2) {
-    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 _target___FEDERATION__, _target___FEDERATION__1, _target___FEDERATION__2, _target___FEDERATION__3, _target___FEDERATION__4, _target___FEDERATION__5;
-  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__);
-  }
-  var ___GLOBAL_PLUGIN__;
-  (___GLOBAL_PLUGIN__ = (_target___FEDERATION__ = target.__FEDERATION__).__GLOBAL_PLUGIN__) != null ? ___GLOBAL_PLUGIN__ : _target___FEDERATION__.__GLOBAL_PLUGIN__ = [];
-  var ___INSTANCES__;
-  (___INSTANCES__ = (_target___FEDERATION__1 = target.__FEDERATION__).__INSTANCES__) != null ? ___INSTANCES__ : _target___FEDERATION__1.__INSTANCES__ = [];
-  var _moduleInfo;
-  (_moduleInfo = (_target___FEDERATION__2 = target.__FEDERATION__).moduleInfo) != null ? _moduleInfo : _target___FEDERATION__2.moduleInfo = {};
-  var ___SHARE__;
-  (___SHARE__ = (_target___FEDERATION__3 = target.__FEDERATION__).__SHARE__) != null ? ___SHARE__ : _target___FEDERATION__3.__SHARE__ = {};
-  var ___MANIFEST_LOADING__;
-  (___MANIFEST_LOADING__ = (_target___FEDERATION__4 = target.__FEDERATION__).__MANIFEST_LOADING__) != null ? ___MANIFEST_LOADING__ : _target___FEDERATION__4.__MANIFEST_LOADING__ = {};
-  var ___PRELOADED_MAP__;
-  (___PRELOADED_MAP__ = (_target___FEDERATION__5 = target.__FEDERATION__).__PRELOADED_MAP__) != null ? ___PRELOADED_MAP__ : _target___FEDERATION__5.__PRELOADED_MAP__ = /* @__PURE__ */ new Map();
-}
-setGlobalDefaultVal(CurrentGlobal);
-setGlobalDefaultVal(nativeGlobal);
-function setGlobalFederationConstructor(FederationConstructor, isDebug = context.isDebugMode()) {
-  if (isDebug) {
-    CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-    CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.7.3";
-  }
-}
-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 } = moduleInfo, resModuleInfo = _object_without_properties_loose(moduleInfo, [
-      "version"
-    ]);
-    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 = _extends$1({}, nativeGlobal.__FEDERATION__.moduleInfo, moduleInfos);
-  return () => {
-    const keys = Object.keys(moduleInfos);
-    for (const key of keys) {
-      delete nativeGlobal.__FEDERATION__.moduleInfo[key];
-    }
-  };
-};
-const getRemoteEntryExports = (name2, globalName) => {
-  const remoteEntryKey = globalName || `__FEDERATION_${name2}:custom__`;
-  const entryExports = CurrentGlobal[remoteEntryKey];
-  return {
-    remoteEntryKey,
-    entryExports
-  };
-};
-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 parsedRange = parseRange(range);
-  const parsedComparator = parsedRange.split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ");
-  const comparators = parsedComparator.split(/\s+/).map((comparator2) => parseGTE0(comparator2));
-  const extractedVersion = extractComparator(version);
-  if (!extractedVersion) {
-    return false;
-  }
-  const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease] = extractedVersion;
-  const versionAtom = {
-    operator: versionOperator,
-    version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
-    major: versionMajor,
-    minor: versionMinor,
-    patch: versionPatch,
-    preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split(".")
-  };
-  for (const comparator2 of comparators) {
-    const extractedComparator = extractComparator(comparator2);
-    if (!extractedComparator) {
-      return false;
-    }
-    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)) {
-      return false;
-    }
-  }
-  return true;
-}
-function formatShare(shareArgs, from, name2, shareStrategy) {
-  let get;
-  if ("get" in shareArgs) {
-    get = shareArgs.get;
-  } else if ("lib" in shareArgs) {
-    get = () => Promise.resolve(shareArgs.lib);
-  } else {
-    get = () => Promise.resolve(() => {
-      throw new Error(`Can not get shared '${name2}'!`);
-    });
-  }
-  if (shareArgs.strategy) {
-    warn(`"shared.strategy is deprecated, please set in initOptions.shareStrategy instead!"`);
-  }
-  var _shareArgs_version, _shareArgs_scope, _shareArgs_strategy;
-  return _extends$1({
-    deps: [],
-    useIn: [],
-    from,
-    loading: null
-  }, shareArgs, {
-    shareConfig: _extends$1({
-      requiredVersion: `^${shareArgs.version}`,
-      singleton: false,
-      eager: false,
-      strictVersion: false
-    }, shareArgs.shareConfig),
-    get,
-    loaded: (shareArgs == null ? void 0 : shareArgs.loaded) || "lib" in shareArgs ? true : void 0,
-    version: (_shareArgs_version = shareArgs.version) != null ? _shareArgs_version : "0",
-    scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [
-      (_shareArgs_scope = shareArgs.scope) != null ? _shareArgs_scope : "default"
-    ],
-    strategy: ((_shareArgs_strategy = shareArgs.strategy) != null ? _shareArgs_strategy : shareStrategy) || "version-first"
-  });
-}
-function formatShareConfigs(globalOptions, userOptions) {
-  const shareArgs = userOptions.shared || {};
-  const from = userOptions.name;
-  const shareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
-    const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
-    res[pkgName] = res[pkgName] || [];
-    arrayShareArgs.forEach((shareConfig) => {
-      res[pkgName].push(formatShare(shareConfig, from, pkgName, userOptions.shareStrategy));
-    });
-    return res;
-  }, {});
-  const shared = _extends$1({}, globalOptions.shared);
-  Object.keys(shareInfos).forEach((shareKey) => {
-    if (!shared[shareKey]) {
-      shared[shareKey] = shareInfos[shareKey];
-    } else {
-      shareInfos[shareKey].forEach((newUserSharedOptions) => {
-        const isSameVersion = shared[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
-        if (!isSameVersion) {
-          shared[shareKey].push(newUserSharedOptions);
-        }
-      });
-    }
-  });
-  return {
-    shared,
-    shareInfos
-  };
-}
-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 getTargetSharedOptions(options) {
-  const { pkgName, extraOptions, shareInfos } = options;
-  const defaultResolver = (sharedOptions) => {
-    if (!sharedOptions) {
-      return void 0;
-    }
-    const shareVersionMap = {};
-    sharedOptions.forEach((shared) => {
-      shareVersionMap[shared.version] = shared;
-    });
-    const callback = function(prev, cur) {
-      return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
-    };
-    const maxVersion = findVersion(shareVersionMap, callback);
-    return shareVersionMap[maxVersion];
-  };
-  var _extraOptions_resolver;
-  const resolver = (_extraOptions_resolver = extraOptions == null ? void 0 : extraOptions.resolver) != null ? _extraOptions_resolver : defaultResolver;
-  return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
-}
-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 TYPE_001 = "TYPE-001";
-const getDocsUrl = (errorCode) => {
-  const type = errorCode.split("-")[0].toLowerCase();
-  return `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));
-  originalErrorMsg && msg.push(`Original Error Message:
- ${originalErrorMsg}`);
-  return msg.join("\n");
-};
-function _extends() {
-  _extends = Object.assign || function assign(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source)
-        if (Object.prototype.hasOwnProperty.call(source, key))
-          target[key] = source[key];
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-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."
-};
-const typeDescMap = {
-  [TYPE_001]: "Failed to generate type declaration."
-};
-_extends({}, runtimeDescMap, typeDescMap);
-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;
-}
-function matchRemote(remotes, nameOrAlias) {
-  for (const remote of remotes) {
-    const isNameMatched = nameOrAlias === remote.name;
-    if (isNameMatched) {
-      return remote;
-    }
-    const isAliasMatched = remote.alias && nameOrAlias === remote.alias;
-    if (isAliasMatched) {
-      return remote;
-    }
-  }
-  return;
-}
-function registerPlugins$1(plugins, hookInstances) {
-  const globalPlugins = getGlobalHostPlugins();
-  if (globalPlugins.length > 0) {
-    globalPlugins.forEach((plugin) => {
-      if (plugins == null ? void 0 : plugins.find((item) => item.name !== plugin.name)) {
-        plugins.push(plugin);
-      }
-    });
-  }
-  if (plugins && plugins.length > 0) {
-    plugins.forEach((plugin) => {
-      hookInstances.forEach((hookInstance) => {
-        hookInstance.applyPlugin(plugin);
-      });
-    });
-  }
-  return plugins;
-}
-async function loadEsmEntry({ entry, remoteEntryExports }) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (!remoteEntryExports) {
-        import(
-          /* webpackIgnore: true */
-          entry
-        ).then(resolve).catch(reject);
-      } else {
-        resolve(remoteEntryExports);
-      }
-    } catch (e2) {
-      reject(e2);
-    }
-  });
-}
-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}").then(callbacks[0]).catch(callbacks[1])`)([
-            resolve,
-            reject
-          ]);
-        }
-      } else {
-        resolve(remoteEntryExports);
-      }
-    } catch (e2) {
-      reject(e2);
-    }
-  });
-}
-async function loadEntryScript({ name: name2, globalName, entry, loaderHook }) {
-  const { entryExports: remoteEntryExports } = getRemoteEntryExports(name2, globalName);
-  if (remoteEntryExports) {
-    return remoteEntryExports;
-  }
-  return context.loadScript(entry, {
-    attrs: {},
-    createScriptHook: (url, attrs) => {
-      const res = loaderHook.lifecycle.createScript.emit({
-        url,
-        attrs
-      });
-      if (!res)
-        return;
-      if (res instanceof HTMLScriptElement) {
-        return res;
-      }
-      if ("script" in res || "timeout" in res) {
-        return res;
-      }
-      return;
-    }
-  }).then(() => {
-    const { remoteEntryKey, entryExports } = getRemoteEntryExports(name2, globalName);
-    assert(entryExports, getShortErrorMsg(RUNTIME_001, runtimeDescMap, {
-      remoteName: name2,
-      remoteEntryUrl: entry,
-      remoteEntryKey
-    }));
-    return entryExports;
-  }).catch((e2) => {
-    throw e2;
-  });
-}
-async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook }) {
-  const { entry, entryGlobalName: globalName, name: name2, type } = remoteInfo;
-  switch (type) {
-    case "esm":
-    case "module":
-      return loadEsmEntry({
-        entry,
-        remoteEntryExports
-      });
-    case "system":
-      return loadSystemJsEntry({
-        entry,
-        remoteEntryExports
-      });
-    default:
-      return loadEntryScript({
-        entry,
-        globalName,
-        name: name2,
-        loaderHook
-      });
-  }
-}
-async function loadEntryNode({ remoteInfo, loaderHook }) {
-  const { entry, entryGlobalName: globalName, name: name2, type } = remoteInfo;
-  const { entryExports: remoteEntryExports } = getRemoteEntryExports(name2, globalName);
-  if (remoteEntryExports) {
-    return remoteEntryExports;
-  }
-  return context.loadScriptNode(entry, {
-    attrs: {
-      name: name2,
-      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(() => {
-    const { remoteEntryKey, entryExports } = getRemoteEntryExports(name2, globalName);
-    assert(entryExports, getShortErrorMsg(RUNTIME_001, runtimeDescMap, {
-      remoteName: name2,
-      remoteEntryUrl: entry,
-      remoteEntryKey
-    }));
-    return entryExports;
-  }).catch((e2) => {
-    throw e2;
-  });
-}
-function getRemoteEntryUniqueKey(remoteInfo) {
-  const { entry, name: name2 } = remoteInfo;
-  return context.composeKeyWithSeparator(name2, entry);
-}
-async function getRemoteEntry({ origin, remoteEntryExports, remoteInfo }) {
-  const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
-  if (remoteEntryExports) {
-    return remoteEntryExports;
-  }
-  if (!globalLoading[uniqueKey]) {
-    const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
-    origin.loaderHook.lifecycle.createScript;
-    const loaderHook = origin.loaderHook;
-    globalLoading[uniqueKey] = loadEntryHook.emit({
-      loaderHook,
-      remoteInfo,
-      remoteEntryExports
-    }).then((res) => {
-      if (res) {
-        return res;
-      }
-      return context.isBrowserEnv() ? loadEntryDom({
-        remoteInfo,
-        remoteEntryExports,
-        loaderHook
-      }) : loadEntryNode({
-        remoteInfo,
-        loaderHook
-      });
-    });
-  }
-  return globalLoading[uniqueKey];
-}
-function getRemoteInfo(remote) {
-  return _extends$1({}, remote, {
-    entry: "entry" in remote ? remote.entry : "",
-    type: remote.type || DEFAULT_REMOTE_TYPE,
-    entryGlobalName: remote.entryGlobalName || remote.name,
-    shareScope: remote.shareScope || DEFAULT_SCOPE
-  });
-}
-let Module = class Module2 {
-  async getEntry() {
-    if (this.remoteEntryExports) {
-      return this.remoteEntryExports;
-    }
-    const remoteEntryExports = await getRemoteEntry({
-      origin: this.host,
-      remoteInfo: this.remoteInfo,
-      remoteEntryExports: this.remoteEntryExports
-    });
-    assert(remoteEntryExports, `remoteEntryExports is undefined 
- ${context.safeToString(this.remoteInfo)}`);
-    this.remoteEntryExports = remoteEntryExports;
-    return this.remoteEntryExports;
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async get(id, expose, options, remoteSnapshot) {
-    const { loadFactory = true } = options || {
-      loadFactory: true
-    };
-    const remoteEntryExports = await this.getEntry();
-    if (!this.inited) {
-      const localShareScopeMap = this.host.shareScopeMap;
-      const remoteShareScope = this.remoteInfo.shareScope || "default";
-      if (!localShareScopeMap[remoteShareScope]) {
-        localShareScopeMap[remoteShareScope] = {};
-      }
-      const shareScope = localShareScopeMap[remoteShareScope];
-      const initScope = [];
-      const remoteEntryInitOptions = {
-        version: this.remoteInfo.version || ""
-      };
-      Object.defineProperty(remoteEntryInitOptions, "shareScopeMap", {
-        value: localShareScopeMap,
-        // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
-        enumerable: false
-      });
-      const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
-        shareScope,
-        // @ts-ignore shareScopeMap will be set by Object.defineProperty
-        remoteEntryInitOptions,
-        initScope,
-        remoteInfo: this.remoteInfo,
-        origin: this.host
-      });
-      if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === "undefined") {
-        error(getShortErrorMsg(RUNTIME_002, runtimeDescMap, {
-          remoteName: name,
-          remoteEntryUrl: this.remoteInfo.entry,
-          remoteEntryKey: this.remoteInfo.entryGlobalName
-        }));
-      }
-      await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
-      await this.host.hooks.lifecycle.initContainer.emit(_extends$1({}, initContainerOptions, {
-        id,
-        remoteSnapshot,
-        remoteEntryExports
-      }));
-    }
-    this.lib = remoteEntryExports;
-    this.inited = true;
-    let moduleFactory;
-    moduleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
-      remoteEntryExports,
-      expose,
-      moduleInfo: this.remoteInfo
-    });
-    if (!moduleFactory) {
-      moduleFactory = await remoteEntryExports.get(expose);
-    }
-    assert(moduleFactory, `${getFMId(this.remoteInfo)} remote don't export ${expose}.`);
-    const symbolName = processModuleAlias(this.remoteInfo.name, expose);
-    const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
-    if (!loadFactory) {
-      return wrapModuleFactory;
-    }
-    const exposeContent = await wrapModuleFactory();
-    return exposeContent;
-  }
-  wraperFactory(moduleFactory, id) {
-    function defineModuleId(res, id2) {
-      if (res && typeof res === "object" && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for("mf_module_id"))) {
-        Object.defineProperty(res, Symbol.for("mf_module_id"), {
-          value: id2,
-          enumerable: false
-        });
-      }
-    }
-    if (moduleFactory instanceof Promise) {
-      return async () => {
-        const res = await moduleFactory();
-        defineModuleId(res, id);
-        return res;
-      };
-    } else {
-      return () => {
-        const res = moduleFactory();
-        defineModuleId(res, id);
-        return res;
-      };
-    }
-  }
-  constructor({ remoteInfo, host }) {
-    this.inited = false;
-    this.lib = void 0;
-    this.remoteInfo = remoteInfo;
-    this.host = host;
-  }
-};
-class SyncHook {
-  on(fn) {
-    if (typeof fn === "function") {
-      this.listeners.add(fn);
-    }
-  }
-  once(fn) {
-    const self = this;
-    this.on(function wrapper(...args) {
-      self.remove(wrapper);
-      return fn.apply(null, args);
-    });
-  }
-  emit(...data) {
-    let result;
-    if (this.listeners.size > 0) {
-      this.listeners.forEach((fn) => {
-        result = fn(...data);
-      });
-    }
-    return result;
-  }
-  remove(fn) {
-    this.listeners.delete(fn);
-  }
-  removeAll() {
-    this.listeners.clear();
-  }
-  constructor(type) {
-    this.type = "";
-    this.listeners = /* @__PURE__ */ new Set();
-    if (type) {
-      this.type = type;
-    }
-  }
-}
-class AsyncHook extends SyncHook {
-  emit(...data) {
-    let result;
-    const ls = Array.from(this.listeners);
-    if (ls.length > 0) {
-      let i = 0;
-      const call = (prev) => {
-        if (prev === false) {
-          return false;
-        } else if (i < ls.length) {
-          return Promise.resolve(ls[i++].apply(null, data)).then(call);
-        } else {
-          return prev;
-        }
-      };
-      result = call();
-    }
-    return Promise.resolve(result);
-  }
-}
-function checkReturnData(originalData, returnedData) {
-  if (!isObject(returnedData)) {
-    return false;
-  }
-  if (originalData !== returnedData) {
-    for (const key in originalData) {
-      if (!(key in returnedData)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-class SyncWaterfallHook extends SyncHook {
-  emit(data) {
-    if (!isObject(data)) {
-      error(`The data for the "${this.type}" hook should be an object.`);
-    }
-    for (const fn of this.listeners) {
-      try {
-        const tempData = fn(data);
-        if (checkReturnData(data, tempData)) {
-          data = tempData;
-        } else {
-          this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
-          break;
-        }
-      } catch (e2) {
-        warn(e2);
-        this.onerror(e2);
-      }
-    }
-    return data;
-  }
-  constructor(type) {
-    super(), this.onerror = error;
-    this.type = type;
-  }
-}
-class AsyncWaterfallHook extends SyncHook {
-  emit(data) {
-    if (!isObject(data)) {
-      error(`The response data for the "${this.type}" hook must be an object.`);
-    }
-    const ls = Array.from(this.listeners);
-    if (ls.length > 0) {
-      let i = 0;
-      const processError = (e2) => {
-        warn(e2);
-        this.onerror(e2);
-        return data;
-      };
-      const call = (prevData) => {
-        if (checkReturnData(data, prevData)) {
-          data = prevData;
-          if (i < ls.length) {
-            try {
-              return Promise.resolve(ls[i++](data)).then(call, processError);
-            } catch (e2) {
-              return processError(e2);
-            }
-          }
-        } else {
-          this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
-        }
-        return data;
-      };
-      return Promise.resolve(call(data));
-    }
-    return Promise.resolve(data);
-  }
-  constructor(type) {
-    super(), this.onerror = error;
-    this.type = type;
-  }
-}
-class PluginSystem {
-  applyPlugin(plugin) {
-    assert(isPlainObject(plugin), "Plugin configuration is invalid.");
-    const pluginName = plugin.name;
-    assert(pluginName, "A name must be provided by the plugin.");
-    if (!this.registerPlugins[pluginName]) {
-      this.registerPlugins[pluginName] = plugin;
-      Object.keys(this.lifecycle).forEach((key) => {
-        const pluginLife = plugin[key];
-        if (pluginLife) {
-          this.lifecycle[key].on(pluginLife);
-        }
-      });
-    }
-  }
-  removePlugin(pluginName) {
-    assert(pluginName, "A name is required.");
-    const plugin = this.registerPlugins[pluginName];
-    assert(plugin, `The plugin "${pluginName}" is not registered.`);
-    Object.keys(plugin).forEach((key) => {
-      if (key !== "name") {
-        this.lifecycle[key].remove(plugin[key]);
-      }
-    });
-  }
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  inherit({ lifecycle, registerPlugins }) {
-    Object.keys(lifecycle).forEach((hookName) => {
-      assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
-      this.lifecycle[hookName] = lifecycle[hookName];
-    });
-    Object.keys(registerPlugins).forEach((pluginName) => {
-      assert(!this.registerPlugins[pluginName], `The plugin "${pluginName}" has a conflict and cannot be inherited.`);
-      this.applyPlugin(registerPlugins[pluginName]);
-    });
-  }
-  constructor(lifecycle) {
-    this.registerPlugins = {};
-    this.lifecycle = lifecycle;
-    this.lifecycleKeys = Object.keys(lifecycle);
-  }
-}
-function defaultPreloadArgs(preloadConfig) {
-  return _extends$1({
-    resourceCategory: "sync",
-    share: true,
-    depsRemote: true,
-    prefetchInterface: false
-  }, preloadConfig);
-}
-function formatPreloadArgs(remotes, preloadArgs) {
-  return preloadArgs.map((args) => {
-    const remoteInfo = matchRemote(remotes, args.nameOrAlias);
-    assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && context.safeToString({
-      remoteInfo,
-      remotes
-    })}`);
-    return {
-      remote: remoteInfo,
-      preloadConfig: defaultPreloadArgs(args)
-    };
-  });
-}
-function normalizePreloadExposes(exposes) {
-  if (!exposes) {
-    return [];
-  }
-  return exposes.map((expose) => {
-    if (expose === ".") {
-      return expose;
-    }
-    if (expose.startsWith("./")) {
-      return expose.replace("./", "");
-    }
-    return expose;
-  });
-}
-function 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 } = context.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 } = context.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 } = context.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 } = context.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);
-      });
-    }
-  }
-}
-function assignRemoteInfo(remoteInfo, remoteSnapshot) {
-  const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
-  if (!remoteEntryInfo.url) {
-    error(`The attribute remoteEntry of ${remoteInfo.name} must not be undefined.`);
-  }
-  let entryUrl = context.getResourceUrl(remoteSnapshot, remoteEntryInfo.url);
-  if (!context.isBrowserEnv() && !entryUrl.startsWith("http")) {
-    entryUrl = `https:${entryUrl}`;
-  }
-  remoteInfo.type = remoteEntryInfo.type;
-  remoteInfo.entryGlobalName = remoteEntryInfo.globalName;
-  remoteInfo.entry = entryUrl;
-  remoteInfo.version = remoteSnapshot.version;
-  remoteInfo.buildVersion = remoteSnapshot.buildVersion;
-}
-function snapshotPlugin() {
-  return {
-    name: "snapshot-plugin",
-    async afterResolve(args) {
-      const { remote, pkgNameOrAlias, expose, origin, remoteInfo } = args;
-      if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {
-        const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo(remote);
-        assignRemoteInfo(remoteInfo, remoteSnapshot);
-        const preloadOptions = {
-          remote,
-          preloadConfig: {
-            nameOrAlias: pkgNameOrAlias,
-            exposes: [
-              expose
-            ],
-            resourceCategory: "sync",
-            share: false,
-            depsRemote: false
-          }
-        };
-        const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
-          origin,
-          preloadOptions,
-          remoteInfo,
-          remote,
-          remoteSnapshot,
-          globalSnapshot
-        });
-        if (assets) {
-          preloadAssets(remoteInfo, origin, assets, false);
-        }
-        return _extends$1({}, args, {
-          remoteSnapshot
-        });
-      }
-      return args;
-    }
-  };
-}
-function splitId(id) {
-  const splitInfo = id.split(":");
-  if (splitInfo.length === 1) {
-    return {
-      name: splitInfo[0],
-      version: void 0
-    };
-  } else if (splitInfo.length === 2) {
-    return {
-      name: splitInfo[0],
-      version: splitInfo[1]
-    };
-  } else {
-    return {
-      name: splitInfo[1],
-      version: splitInfo[2]
-    };
-  }
-}
-function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo = {}, remoteSnapshot) {
-  const id = getFMId(remoteInfo);
-  const { value: snapshotValue } = getInfoWithoutType(globalSnapshot, id);
-  const effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;
-  if (effectiveRemoteSnapshot && !context.isManifestProvider(effectiveRemoteSnapshot)) {
-    traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
-    if (effectiveRemoteSnapshot.remotesInfo) {
-      const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);
-      for (const key of remoteKeys) {
-        if (memo[key]) {
-          continue;
-        }
-        memo[key] = true;
-        const subRemoteInfo = splitId(key);
-        const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];
-        traverseModuleInfo(globalSnapshot, {
-          name: subRemoteInfo.name,
-          version: remoteValue.matchedVersion
-        }, traverse, false, memo, void 0);
-      }
-    }
-  }
-}
-function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, remoteSnapshot) {
-  const cssAssets = [];
-  const jsAssets = [];
-  const entryAssets = [];
-  const loadedSharedJsAssets = /* @__PURE__ */ new Set();
-  const loadedSharedCssAssets = /* @__PURE__ */ new Set();
-  const { options } = origin;
-  const { preloadConfig: rootPreloadConfig } = preloadOptions;
-  const { depsRemote } = rootPreloadConfig;
-  const memo = {};
-  traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot) => {
-    let preloadConfig;
-    if (isRoot) {
-      preloadConfig = rootPreloadConfig;
-    } else {
-      if (Array.isArray(depsRemote)) {
-        const findPreloadConfig = depsRemote.find((remoteConfig) => {
-          if (remoteConfig.nameOrAlias === remoteInfo.name || remoteConfig.nameOrAlias === remoteInfo.alias) {
-            return true;
-          }
-          return false;
-        });
-        if (!findPreloadConfig) {
-          return;
-        }
-        preloadConfig = defaultPreloadArgs(findPreloadConfig);
-      } else if (depsRemote === true) {
-        preloadConfig = rootPreloadConfig;
-      } else {
-        return;
-      }
-    }
-    const remoteEntryUrl = context.getResourceUrl(moduleInfoSnapshot, getRemoteEntryInfoFromSnapshot(moduleInfoSnapshot).url);
-    if (remoteEntryUrl) {
-      entryAssets.push({
-        name: remoteInfo.name,
-        moduleInfo: {
-          name: remoteInfo.name,
-          entry: remoteEntryUrl,
-          type: "remoteEntryType" in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : "global",
-          entryGlobalName: "globalName" in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
-          shareScope: "",
-          version: "version" in moduleInfoSnapshot ? moduleInfoSnapshot.version : void 0
-        },
-        url: remoteEntryUrl
-      });
-    }
-    let moduleAssetsInfo = "modules" in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];
-    const normalizedPreloadExposes = normalizePreloadExposes(preloadConfig.exposes);
-    if (normalizedPreloadExposes.length && "modules" in moduleInfoSnapshot) {
-      var _moduleInfoSnapshot_modules;
-      moduleAssetsInfo = moduleInfoSnapshot == null ? void 0 : (_moduleInfoSnapshot_modules = moduleInfoSnapshot.modules) == null ? void 0 : _moduleInfoSnapshot_modules.reduce((assets, moduleAssetInfo) => {
-        if ((normalizedPreloadExposes == null ? void 0 : normalizedPreloadExposes.indexOf(moduleAssetInfo.moduleName)) !== -1) {
-          assets.push(moduleAssetInfo);
-        }
-        return assets;
-      }, []);
-    }
-    function handleAssets(assets) {
-      const assetsRes = assets.map((asset) => context.getResourceUrl(moduleInfoSnapshot, asset));
-      if (preloadConfig.filter) {
-        return assetsRes.filter(preloadConfig.filter);
-      }
-      return assetsRes;
-    }
-    if (moduleAssetsInfo) {
-      const assetsLength = moduleAssetsInfo.length;
-      for (let index = 0; index < assetsLength; index++) {
-        const assetsInfo = moduleAssetsInfo[index];
-        const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
-        origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
-          id: assetsInfo.moduleName === "." ? remoteInfo.name : exposeFullPath,
-          name: remoteInfo.name,
-          remoteSnapshot: moduleInfoSnapshot,
-          preloadConfig,
-          remote: remoteInfo,
-          origin
-        });
-        const preloaded = getPreloaded(exposeFullPath);
-        if (preloaded) {
-          continue;
-        }
-        if (preloadConfig.resourceCategory === "all") {
-          cssAssets.push(...handleAssets(assetsInfo.assets.css.async));
-          cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
-          jsAssets.push(...handleAssets(assetsInfo.assets.js.async));
-          jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
-        } else if (preloadConfig.resourceCategory = "sync") {
-          cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
-          jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
-        }
-        setPreloaded(exposeFullPath);
-      }
-    }
-  }, true, memo, remoteSnapshot);
-  if (remoteSnapshot.shared) {
-    const collectSharedAssets = (shareInfo, snapshotShared) => {
-      const registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
-      if (registeredShared && typeof registeredShared.lib === "function") {
-        snapshotShared.assets.js.sync.forEach((asset) => {
-          loadedSharedJsAssets.add(asset);
-        });
-        snapshotShared.assets.css.sync.forEach((asset) => {
-          loadedSharedCssAssets.add(asset);
-        });
-      }
-    };
-    remoteSnapshot.shared.forEach((shared) => {
-      var _options_shared;
-      const shareInfos = (_options_shared = options.shared) == null ? void 0 : _options_shared[shared.sharedName];
-      if (!shareInfos) {
-        return;
-      }
-      const sharedOptions = shared.version ? shareInfos.find((s) => s.version === shared.version) : shareInfos;
-      if (!sharedOptions) {
-        return;
-      }
-      const arrayShareInfo = arrayOptions(sharedOptions);
-      arrayShareInfo.forEach((s) => {
-        collectSharedAssets(s, shared);
-      });
-    });
-  }
-  const needPreloadJsAssets = jsAssets.filter((asset) => !loadedSharedJsAssets.has(asset));
-  const needPreloadCssAssets = cssAssets.filter((asset) => !loadedSharedCssAssets.has(asset));
-  return {
-    cssAssets: needPreloadCssAssets,
-    jsAssetsWithoutEntry: needPreloadJsAssets,
-    entryAssets
-  };
-}
-const generatePreloadAssetsPlugin = function() {
-  return {
-    name: "generate-preload-assets-plugin",
-    async generatePreloadAssets(args) {
-      const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot } = args;
-      if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) {
-        return {
-          cssAssets: [],
-          jsAssetsWithoutEntry: [],
-          entryAssets: [
-            {
-              name: remote.name,
-              url: remote.entry,
-              moduleInfo: {
-                name: remoteInfo.name,
-                entry: remote.entry,
-                type: remoteInfo.type || "global",
-                entryGlobalName: "",
-                shareScope: ""
-              }
-            }
-          ]
-        };
-      }
-      assignRemoteInfo(remoteInfo, remoteSnapshot);
-      const assets = generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
-      return assets;
-    }
-  };
-};
-function getGlobalRemoteInfo(moduleInfo, origin) {
-  const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
-    name: origin.options.name,
-    version: origin.options.version
-  });
-  const globalRemoteInfo = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
-  if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {
-    return {
-      hostGlobalSnapshot,
-      globalSnapshot: getGlobalSnapshot(),
-      remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
-        name: moduleInfo.name,
-        version: globalRemoteInfo.matchedVersion
-      })
-    };
-  }
-  return {
-    hostGlobalSnapshot: void 0,
-    globalSnapshot: getGlobalSnapshot(),
-    remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
-      name: moduleInfo.name,
-      version: "version" in moduleInfo ? moduleInfo.version : void 0
-    })
-  };
-}
-class SnapshotHandler {
-  async loadSnapshot(moduleInfo) {
-    const { options } = this.HostInstance;
-    const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
-    const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
-      options,
-      moduleInfo,
-      hostGlobalSnapshot,
-      remoteSnapshot,
-      globalSnapshot
-    });
-    return {
-      remoteSnapshot: globalRemoteSnapshot,
-      globalSnapshot: globalSnapshotRes
-    };
-  }
-  // eslint-disable-next-line max-lines-per-function
-  async loadRemoteSnapshotInfo(moduleInfo) {
-    const { options } = this.HostInstance;
-    await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
-      options,
-      moduleInfo
-    });
-    let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
-      name: this.HostInstance.options.name,
-      version: this.HostInstance.options.version
-    });
-    if (!hostSnapshot) {
-      hostSnapshot = {
-        version: this.HostInstance.options.version || "",
-        remoteEntry: "",
-        remotesInfo: {}
-      };
-      addGlobalSnapshot({
-        [this.HostInstance.options.name]: hostSnapshot
-      });
-    }
-    if (hostSnapshot && "remotesInfo" in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
-      if ("version" in moduleInfo || "entry" in moduleInfo) {
-        hostSnapshot.remotesInfo = _extends$1({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
-          [moduleInfo.name]: {
-            matchedVersion: "version" in moduleInfo ? moduleInfo.version : moduleInfo.entry
-          }
-        });
-      }
-    }
-    const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
-    const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
-      options,
-      moduleInfo,
-      hostGlobalSnapshot,
-      remoteSnapshot,
-      globalSnapshot
-    });
-    let mSnapshot;
-    let gSnapshot;
-    if (globalRemoteSnapshot) {
-      if (context.isManifestProvider(globalRemoteSnapshot)) {
-        const remoteEntry = context.isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || "";
-        const moduleSnapshot = await this.getManifestJson(remoteEntry, moduleInfo, {});
-        const globalSnapshotRes2 = setGlobalSnapshotInfoByModuleInfo(_extends$1({}, moduleInfo, {
-          // The global remote may be overridden
-          // Therefore, set the snapshot key to the global address of the actual request
-          entry: remoteEntry
-        }), moduleSnapshot);
-        mSnapshot = moduleSnapshot;
-        gSnapshot = globalSnapshotRes2;
-      } else {
-        const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
-          options: this.HostInstance.options,
-          moduleInfo,
-          remoteSnapshot: globalRemoteSnapshot,
-          from: "global"
-        });
-        mSnapshot = remoteSnapshotRes;
-        gSnapshot = globalSnapshotRes;
-      }
-    } else {
-      if (isRemoteInfoWithEntry(moduleInfo)) {
-        const moduleSnapshot = await this.getManifestJson(moduleInfo.entry, moduleInfo, {});
-        const globalSnapshotRes2 = setGlobalSnapshotInfoByModuleInfo(moduleInfo, moduleSnapshot);
-        const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
-          options: this.HostInstance.options,
-          moduleInfo,
-          remoteSnapshot: moduleSnapshot,
-          from: "global"
-        });
-        mSnapshot = remoteSnapshotRes;
-        gSnapshot = globalSnapshotRes2;
-      } else {
-        error(getShortErrorMsg(RUNTIME_007, runtimeDescMap, {
-          hostName: moduleInfo.name,
-          hostVersion: moduleInfo.version,
-          globalSnapshot: JSON.stringify(globalSnapshotRes)
-        }));
-      }
-    }
-    await this.hooks.lifecycle.afterLoadSnapshot.emit({
-      options,
-      moduleInfo,
-      remoteSnapshot: mSnapshot
-    });
-    return {
-      remoteSnapshot: mSnapshot,
-      globalSnapshot: gSnapshot
-    };
-  }
-  getGlobalRemoteInfo(moduleInfo) {
-    return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
-  }
-  async getManifestJson(manifestUrl, moduleInfo, extraOptions) {
-    const getManifest = async () => {
-      let manifestJson = this.manifestCache.get(manifestUrl);
-      if (manifestJson) {
-        return manifestJson;
-      }
-      try {
-        let res = await this.loaderHook.lifecycle.fetch.emit(manifestUrl, {});
-        if (!res || !(res instanceof Response)) {
-          res = await fetch(manifestUrl, {});
-        }
-        manifestJson = await res.json();
-        assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, `${manifestUrl} is not a federation manifest`);
-        this.manifestCache.set(manifestUrl, manifestJson);
-        return manifestJson;
-      } catch (err) {
-        delete this.manifestLoading[manifestUrl];
-        error(getShortErrorMsg(RUNTIME_003, runtimeDescMap, {
-          manifestUrl,
-          moduleName: moduleInfo.name
-        }, `${err}`));
-      }
-    };
-    const asyncLoadProcess = async () => {
-      const manifestJson = await getManifest();
-      const remoteSnapshot = context.generateSnapshotFromManifest(manifestJson, {
-        version: manifestUrl
-      });
-      const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
-        options: this.HostInstance.options,
-        moduleInfo,
-        manifestJson,
-        remoteSnapshot,
-        manifestUrl,
-        from: "manifest"
-      });
-      return remoteSnapshotRes;
-    };
-    if (!this.manifestLoading[manifestUrl]) {
-      this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res) => res);
-    }
-    return this.manifestLoading[manifestUrl];
-  }
-  constructor(HostInstance) {
-    this.loadingHostSnapshot = null;
-    this.manifestCache = /* @__PURE__ */ new Map();
-    this.hooks = new PluginSystem({
-      beforeLoadRemoteSnapshot: new AsyncHook("beforeLoadRemoteSnapshot"),
-      loadSnapshot: new AsyncWaterfallHook("loadGlobalSnapshot"),
-      loadRemoteSnapshot: new AsyncWaterfallHook("loadRemoteSnapshot"),
-      afterLoadSnapshot: new AsyncWaterfallHook("afterLoadSnapshot")
-    });
-    this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
-    this.HostInstance = HostInstance;
-    this.loaderHook = HostInstance.loaderHook;
-  }
-}
-class SharedHandler {
-  // register shared in shareScopeMap
-  registerShared(globalOptions, userOptions) {
-    const { shareInfos, shared } = formatShareConfigs(globalOptions, userOptions);
-    const sharedKeys = Object.keys(shareInfos);
-    sharedKeys.forEach((sharedKey) => {
-      const sharedVals = shareInfos[sharedKey];
-      sharedVals.forEach((sharedVal) => {
-        const registeredShared = getRegisteredShare(this.shareScopeMap, sharedKey, sharedVal, this.hooks.lifecycle.resolveShare);
-        if (!registeredShared && sharedVal && sharedVal.lib) {
-          this.setShared({
-            pkgName: sharedKey,
-            lib: sharedVal.lib,
-            get: sharedVal.get,
-            loaded: true,
-            shared: sharedVal,
-            from: userOptions.name
-          });
-        }
-      });
-    });
-    return {
-      shareInfos,
-      shared
-    };
-  }
-  async loadShare(pkgName, extraOptions) {
-    const { host } = this;
-    const shareInfo = getTargetSharedOptions({
-      pkgName,
-      extraOptions,
-      shareInfos: host.options.shared
-    });
-    if (shareInfo == null ? void 0 : shareInfo.scope) {
-      await Promise.all(shareInfo.scope.map(async (shareScope) => {
-        await Promise.all(this.initializeSharing(shareScope, {
-          strategy: shareInfo.strategy
-        }));
-        return;
-      }));
-    }
-    const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
-      pkgName,
-      shareInfo,
-      shared: host.options.shared,
-      origin: host
-    });
-    const { shareInfo: shareInfoRes } = loadShareRes;
-    assert(shareInfoRes, `Cannot find ${pkgName} Share in the ${host.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
-    const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfoRes, this.hooks.lifecycle.resolveShare);
-    const addUseIn = (shared) => {
-      if (!shared.useIn) {
-        shared.useIn = [];
-      }
-      addUniqueItem(shared.useIn, host.options.name);
-    };
-    if (registeredShared && registeredShared.lib) {
-      addUseIn(registeredShared);
-      return registeredShared.lib;
-    } else if (registeredShared && registeredShared.loading && !registeredShared.loaded) {
-      const factory = await registeredShared.loading;
-      registeredShared.loaded = true;
-      if (!registeredShared.lib) {
-        registeredShared.lib = factory;
-      }
-      addUseIn(registeredShared);
-      return factory;
-    } else if (registeredShared) {
-      const asyncLoadProcess = async () => {
-        const factory = await registeredShared.get();
-        shareInfoRes.lib = factory;
-        shareInfoRes.loaded = true;
-        addUseIn(shareInfoRes);
-        const gShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfoRes, this.hooks.lifecycle.resolveShare);
-        if (gShared) {
-          gShared.lib = factory;
-          gShared.loaded = true;
-        }
-        return factory;
-      };
-      const loading = asyncLoadProcess();
-      this.setShared({
-        pkgName,
-        loaded: false,
-        shared: registeredShared,
-        from: host.options.name,
-        lib: null,
-        loading
-      });
-      return loading;
-    } else {
-      if (extraOptions == null ? void 0 : extraOptions.customShareInfo) {
-        return false;
-      }
-      const asyncLoadProcess = async () => {
-        const factory = await shareInfoRes.get();
-        shareInfoRes.lib = factory;
-        shareInfoRes.loaded = true;
-        addUseIn(shareInfoRes);
-        const gShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfoRes, this.hooks.lifecycle.resolveShare);
-        if (gShared) {
-          gShared.lib = factory;
-          gShared.loaded = true;
-        }
-        return factory;
-      };
-      const loading = asyncLoadProcess();
-      this.setShared({
-        pkgName,
-        loaded: false,
-        shared: shareInfoRes,
-        from: host.options.name,
-        lib: null,
-        loading
-      });
-      return loading;
-    }
-  }
-  /**
-  * This function initializes the sharing sequence (executed only once per share scope).
-  * It accepts one argument, the name of the share scope.
-  * If the share scope does not exist, it creates one.
-  */
-  // eslint-disable-next-line @typescript-eslint/member-ordering
-  initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
-    const { host } = this;
-    const from = extraOptions == null ? void 0 : extraOptions.from;
-    const strategy = extraOptions == null ? void 0 : extraOptions.strategy;
-    let initScope = extraOptions == null ? void 0 : extraOptions.initScope;
-    const promises = [];
-    if (from !== "build") {
-      const { initTokens } = this;
-      if (!initScope)
-        initScope = [];
-      let initToken = initTokens[shareScopeName];
-      if (!initToken)
-        initToken = initTokens[shareScopeName] = {
-          from: this.host.name
-        };
-      if (initScope.indexOf(initToken) >= 0)
-        return promises;
-      initScope.push(initToken);
-    }
-    const shareScope = this.shareScopeMap;
-    const hostName = host.options.name;
-    if (!shareScope[shareScopeName]) {
-      shareScope[shareScopeName] = {};
-    }
-    const scope = shareScope[shareScopeName];
-    const register = (name2, shared) => {
-      var _activeVersion_shareConfig;
-      const { version, eager } = shared;
-      scope[name2] = scope[name2] || {};
-      const versions = scope[name2];
-      const activeVersion = versions[version];
-      const activeVersionEager = Boolean(activeVersion && (activeVersion.eager || ((_activeVersion_shareConfig = activeVersion.shareConfig) == null ? void 0 : _activeVersion_shareConfig.eager)));
-      if (!activeVersion || activeVersion.strategy !== "loaded-first" && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
-        versions[version] = shared;
-      }
-    };
-    const initFn = (mod) => mod && mod.init && mod.init(shareScope[shareScopeName], initScope);
-    const initRemoteModule = async (key) => {
-      const { module: module2 } = await host.remoteHandler.getRemoteModuleAndOptions({
-        id: key
-      });
-      if (module2.getEntry) {
-        let remoteEntryExports;
-        try {
-          remoteEntryExports = await module2.getEntry();
-        } catch (error2) {
-          remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-            id: key,
-            error: error2,
-            from: "runtime",
-            lifecycle: "beforeLoadShare",
-            origin: host
-          });
-        }
-        if (!module2.inited) {
-          await initFn(remoteEntryExports);
-          module2.inited = true;
-        }
-      }
-    };
-    Object.keys(host.options.shared).forEach((shareName) => {
-      const sharedArr = host.options.shared[shareName];
-      sharedArr.forEach((shared) => {
-        if (shared.scope.includes(shareScopeName)) {
-          register(shareName, shared);
-        }
-      });
-    });
-    if (host.options.shareStrategy === "version-first" || strategy === "version-first") {
-      host.options.remotes.forEach((remote) => {
-        if (remote.shareScope === shareScopeName) {
-          promises.push(initRemoteModule(remote.name));
-        }
-      });
-    }
-    return promises;
-  }
-  // The lib function will only be available if the shared set by eager or runtime init is set or the shared is successfully loaded.
-  // 1. If the loaded shared already exists globally, then it will be reused
-  // 2. If lib exists in local shared, it will be used directly
-  // 3. If the local get returns something other than Promise, then it will be used directly
-  loadShareSync(pkgName, extraOptions) {
-    const { host } = this;
-    const shareInfo = getTargetSharedOptions({
-      pkgName,
-      extraOptions,
-      shareInfos: host.options.shared
-    });
-    if (shareInfo == null ? void 0 : shareInfo.scope) {
-      shareInfo.scope.forEach((shareScope) => {
-        this.initializeSharing(shareScope, {
-          strategy: shareInfo.strategy
-        });
-      });
-    }
-    const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfo, this.hooks.lifecycle.resolveShare);
-    const addUseIn = (shared) => {
-      if (!shared.useIn) {
-        shared.useIn = [];
-      }
-      addUniqueItem(shared.useIn, host.options.name);
-    };
-    if (registeredShared) {
-      if (typeof registeredShared.lib === "function") {
-        addUseIn(registeredShared);
-        if (!registeredShared.loaded) {
-          registeredShared.loaded = true;
-          if (registeredShared.from === host.options.name) {
-            shareInfo.loaded = true;
-          }
-        }
-        return registeredShared.lib;
-      }
-      if (typeof registeredShared.get === "function") {
-        const module2 = registeredShared.get();
-        if (!(module2 instanceof Promise)) {
-          addUseIn(registeredShared);
-          this.setShared({
-            pkgName,
-            loaded: true,
-            from: host.options.name,
-            lib: module2,
-            shared: registeredShared
-          });
-          return module2;
-        }
-      }
-    }
-    if (shareInfo.lib) {
-      if (!shareInfo.loaded) {
-        shareInfo.loaded = true;
-      }
-      return shareInfo.lib;
-    }
-    if (shareInfo.get) {
-      const module2 = shareInfo.get();
-      if (module2 instanceof Promise) {
-        const errorCode = (extraOptions == null ? void 0 : extraOptions.from) === "build" ? RUNTIME_005 : RUNTIME_006;
-        throw new Error(getShortErrorMsg(errorCode, runtimeDescMap, {
-          hostName: host.options.name,
-          sharedPkgName: pkgName
-        }));
-      }
-      shareInfo.lib = module2;
-      this.setShared({
-        pkgName,
-        loaded: true,
-        from: host.options.name,
-        lib: shareInfo.lib,
-        shared: shareInfo
-      });
-      return shareInfo.lib;
-    }
-    throw new Error(getShortErrorMsg(RUNTIME_006, runtimeDescMap, {
-      hostName: host.options.name,
-      sharedPkgName: pkgName
-    }));
-  }
-  initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
-    const { host } = this;
-    this.shareScopeMap[scopeName] = shareScope;
-    this.hooks.lifecycle.initContainerShareScopeMap.emit({
-      shareScope,
-      options: host.options,
-      origin: host,
-      scopeName,
-      hostShareScopeMap: extraOptions.hostShareScopeMap
-    });
-  }
-  setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
-    const { version, scope = "default" } = shared, shareInfo = _object_without_properties_loose(shared, [
-      "version",
-      "scope"
-    ]);
-    const scopes = Array.isArray(scope) ? scope : [
-      scope
-    ];
-    scopes.forEach((sc) => {
-      if (!this.shareScopeMap[sc]) {
-        this.shareScopeMap[sc] = {};
-      }
-      if (!this.shareScopeMap[sc][pkgName]) {
-        this.shareScopeMap[sc][pkgName] = {};
-      }
-      if (!this.shareScopeMap[sc][pkgName][version]) {
-        this.shareScopeMap[sc][pkgName][version] = _extends$1({
-          version,
-          scope: [
-            "default"
-          ]
-        }, shareInfo, {
-          lib,
-          loaded,
-          loading
-        });
-        if (get) {
-          this.shareScopeMap[sc][pkgName][version].get = get;
-        }
-        return;
-      }
-      const registeredShared = this.shareScopeMap[sc][pkgName][version];
-      if (loading && !registeredShared.loading) {
-        registeredShared.loading = loading;
-      }
-    });
-  }
-  _setGlobalShareScopeMap(hostOptions) {
-    const globalShareScopeMap = getGlobalShareScope();
-    const identifier = hostOptions.id || hostOptions.name;
-    if (identifier && !globalShareScopeMap[identifier]) {
-      globalShareScopeMap[identifier] = this.shareScopeMap;
-    }
-  }
-  constructor(host) {
-    this.hooks = new PluginSystem({
-      afterResolve: new AsyncWaterfallHook("afterResolve"),
-      beforeLoadShare: new AsyncWaterfallHook("beforeLoadShare"),
-      // not used yet
-      loadShare: new AsyncHook(),
-      resolveShare: new SyncWaterfallHook("resolveShare"),
-      // maybe will change, temporarily for internal use only
-      initContainerShareScopeMap: new SyncWaterfallHook("initContainerShareScopeMap")
-    });
-    this.host = host;
-    this.shareScopeMap = {};
-    this.initTokens = {};
-    this._setGlobalShareScopeMap(host.options);
-  }
-}
-class RemoteHandler {
-  formatAndRegisterRemote(globalOptions, userOptions) {
-    const userRemotes = userOptions.remotes || [];
-    return userRemotes.reduce((res, remote) => {
-      this.registerRemote(remote, res, {
-        force: false
-      });
-      return res;
-    }, globalOptions.remotes);
-  }
-  setIdToRemoteMap(id, remoteMatchInfo) {
-    const { remote, expose } = remoteMatchInfo;
-    const { name: name2, alias } = remote;
-    this.idToRemoteMap[id] = {
-      name: remote.name,
-      expose
-    };
-    if (alias && id.startsWith(name2)) {
-      const idWithAlias = id.replace(name2, alias);
-      this.idToRemoteMap[idWithAlias] = {
-        name: remote.name,
-        expose
-      };
-      return;
-    }
-    if (alias && id.startsWith(alias)) {
-      const idWithName = id.replace(alias, name2);
-      this.idToRemoteMap[idWithName] = {
-        name: remote.name,
-        expose
-      };
-    }
-  }
-  // eslint-disable-next-line max-lines-per-function
-  // eslint-disable-next-line @typescript-eslint/member-ordering
-  async loadRemote(id, options) {
-    const { host } = this;
-    try {
-      const { loadFactory = true } = options || {
-        loadFactory: true
-      };
-      const { module: module2, moduleOptions, remoteMatchInfo } = await this.getRemoteModuleAndOptions({
-        id
-      });
-      const { pkgNameOrAlias, remote, expose, id: idRes, remoteSnapshot } = remoteMatchInfo;
-      const moduleOrFactory = await module2.get(idRes, expose, options, remoteSnapshot);
-      const moduleWrapper = await this.hooks.lifecycle.onLoad.emit({
-        id: idRes,
-        pkgNameOrAlias,
-        expose,
-        exposeModule: loadFactory ? moduleOrFactory : void 0,
-        exposeModuleFactory: loadFactory ? void 0 : moduleOrFactory,
-        remote,
-        options: moduleOptions,
-        moduleInstance: module2,
-        origin: host
-      });
-      this.setIdToRemoteMap(id, remoteMatchInfo);
-      if (typeof moduleWrapper === "function") {
-        return moduleWrapper;
-      }
-      return moduleOrFactory;
-    } catch (error2) {
-      const { from = "runtime" } = options || {
-        from: "runtime"
-      };
-      const failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
-        id,
-        error: error2,
-        from,
-        lifecycle: "onLoad",
-        origin: host
-      });
-      if (!failOver) {
-        throw error2;
-      }
-      return failOver;
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/member-ordering
-  async preloadRemote(preloadOptions) {
-    const { host } = this;
-    await this.hooks.lifecycle.beforePreloadRemote.emit({
-      preloadOps: preloadOptions,
-      options: host.options,
-      origin: host
-    });
-    const preloadOps = formatPreloadArgs(host.options.remotes, preloadOptions);
-    await Promise.all(preloadOps.map(async (ops) => {
-      const { remote } = ops;
-      const remoteInfo = getRemoteInfo(remote);
-      const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo(remote);
-      const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
-        origin: host,
-        preloadOptions: ops,
-        remote,
-        remoteInfo,
-        globalSnapshot,
-        remoteSnapshot
-      });
-      if (!assets) {
-        return;
-      }
-      preloadAssets(remoteInfo, host, assets);
-    }));
-  }
-  registerRemotes(remotes, options) {
-    const { host } = this;
-    remotes.forEach((remote) => {
-      this.registerRemote(remote, host.options.remotes, {
-        force: options == null ? void 0 : options.force
-      });
-    });
-  }
-  async getRemoteModuleAndOptions(options) {
-    const { host } = this;
-    const { id } = options;
-    let loadRemoteArgs;
-    try {
-      loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
-        id,
-        options: host.options,
-        origin: host
-      });
-    } catch (error2) {
-      loadRemoteArgs = await this.hooks.lifecycle.errorLoadRemote.emit({
-        id,
-        options: host.options,
-        origin: host,
-        from: "runtime",
-        error: error2,
-        lifecycle: "beforeRequest"
-      });
-      if (!loadRemoteArgs) {
-        throw error2;
-      }
-    }
-    const { id: idRes } = loadRemoteArgs;
-    const remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
-    assert(remoteSplitInfo, getShortErrorMsg(RUNTIME_004, runtimeDescMap, {
-      hostName: host.options.name,
-      requestId: idRes
-    }));
-    const { remote: rawRemote } = remoteSplitInfo;
-    const remoteInfo = getRemoteInfo(rawRemote);
-    const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends$1({
-      id: idRes
-    }, remoteSplitInfo, {
-      options: host.options,
-      origin: host,
-      remoteInfo
-    }));
-    const { remote, expose } = matchInfo;
-    assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
-    let module2 = host.moduleCache.get(remote.name);
-    const moduleOptions = {
-      host,
-      remoteInfo
-    };
-    if (!module2) {
-      module2 = new Module(moduleOptions);
-      host.moduleCache.set(remote.name, module2);
-    }
-    return {
-      module: module2,
-      moduleOptions,
-      remoteMatchInfo: matchInfo
-    };
-  }
-  registerRemote(remote, targetRemotes, options) {
-    const { host } = this;
-    const normalizeRemote = () => {
-      if (remote.alias) {
-        const findEqual = targetRemotes.find((item) => {
-          var _item_alias;
-          return remote.alias && (item.name.startsWith(remote.alias) || ((_item_alias = item.alias) == null ? void 0 : _item_alias.startsWith(remote.alias)));
-        });
-        assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
-      }
-      if ("entry" in remote) {
-        if (context.isBrowserEnv() && !remote.entry.startsWith("http")) {
-          remote.entry = new URL(remote.entry, window.location.origin).href;
-        }
-      }
-      if (!remote.shareScope) {
-        remote.shareScope = DEFAULT_SCOPE;
-      }
-      if (!remote.type) {
-        remote.type = DEFAULT_REMOTE_TYPE;
-      }
-    };
-    this.hooks.lifecycle.beforeRegisterRemote.emit({
-      remote,
-      origin: host
-    });
-    const registeredRemote = targetRemotes.find((item) => item.name === remote.name);
-    if (!registeredRemote) {
-      normalizeRemote();
-      targetRemotes.push(remote);
-      this.hooks.lifecycle.registerRemote.emit({
-        remote,
-        origin: host
-      });
-    } else {
-      const messages = [
-        `The remote "${remote.name}" is already registered.`,
-        (options == null ? void 0 : options.force) ? "Hope you have known that OVERRIDE it may have some unexpected errors" : 'If you want to merge the remote, you can set "force: true".'
-      ];
-      if (options == null ? void 0 : options.force) {
-        this.removeRemote(registeredRemote);
-        normalizeRemote();
-        targetRemotes.push(remote);
-        this.hooks.lifecycle.registerRemote.emit({
-          remote,
-          origin: host
-        });
-      }
-      context.warn(messages.join(" "));
-    }
-  }
-  removeRemote(remote) {
-    try {
-      const { host } = this;
-      const { name: name2 } = remote;
-      const remoteIndex = host.options.remotes.findIndex((item) => item.name === name2);
-      if (remoteIndex !== -1) {
-        host.options.remotes.splice(remoteIndex, 1);
-      }
-      const loadedModule = host.moduleCache.get(remote.name);
-      if (loadedModule) {
-        const remoteInfo = loadedModule.remoteInfo;
-        const key = remoteInfo.entryGlobalName;
-        if (CurrentGlobal[key]) {
-          var _Object_getOwnPropertyDescriptor;
-          if ((_Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(CurrentGlobal, key)) == null ? void 0 : _Object_getOwnPropertyDescriptor.configurable) {
-            delete CurrentGlobal[key];
-          } else {
-            CurrentGlobal[key] = void 0;
-          }
-        }
-        const remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
-        if (globalLoading[remoteEntryUniqueKey]) {
-          delete globalLoading[remoteEntryUniqueKey];
-        }
-        host.snapshotHandler.manifestCache.delete(remoteInfo.entry);
-        let remoteInsId = remoteInfo.buildVersion ? context.composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
-        const remoteInsIndex = CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((ins) => {
-          if (remoteInfo.buildVersion) {
-            return ins.options.id === remoteInsId;
-          } else {
-            return ins.name === remoteInsId;
-          }
-        });
-        if (remoteInsIndex !== -1) {
-          const remoteIns = CurrentGlobal.__FEDERATION__.__INSTANCES__[remoteInsIndex];
-          remoteInsId = remoteIns.options.id || remoteInsId;
-          const globalShareScopeMap = getGlobalShareScope();
-          let isAllSharedNotUsed = true;
-          const needDeleteKeys = [];
-          Object.keys(globalShareScopeMap).forEach((instId) => {
-            const shareScopeMap = globalShareScopeMap[instId];
-            shareScopeMap && Object.keys(shareScopeMap).forEach((shareScope) => {
-              const shareScopeVal = shareScopeMap[shareScope];
-              shareScopeVal && Object.keys(shareScopeVal).forEach((shareName) => {
-                const sharedPkgs = shareScopeVal[shareName];
-                sharedPkgs && Object.keys(sharedPkgs).forEach((shareVersion) => {
-                  const shared = sharedPkgs[shareVersion];
-                  if (shared && typeof shared === "object" && shared.from === remoteInfo.name) {
-                    if (shared.loaded || shared.loading) {
-                      shared.useIn = shared.useIn.filter((usedHostName) => usedHostName !== remoteInfo.name);
-                      if (shared.useIn.length) {
-                        isAllSharedNotUsed = false;
-                      } else {
-                        needDeleteKeys.push([
-                          instId,
-                          shareScope,
-                          shareName,
-                          shareVersion
-                        ]);
-                      }
-                    } else {
-                      needDeleteKeys.push([
-                        instId,
-                        shareScope,
-                        shareName,
-                        shareVersion
-                      ]);
-                    }
-                  }
-                });
-              });
-            });
-          });
-          if (isAllSharedNotUsed) {
-            remoteIns.shareScopeMap = {};
-            delete globalShareScopeMap[remoteInsId];
-          }
-          needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion]) => {
-            var _globalShareScopeMap_insId_shareScope_shareName, _globalShareScopeMap_insId_shareScope, _globalShareScopeMap_insId;
-            (_globalShareScopeMap_insId = globalShareScopeMap[insId]) == null ? true : (_globalShareScopeMap_insId_shareScope = _globalShareScopeMap_insId[shareScope]) == null ? true : (_globalShareScopeMap_insId_shareScope_shareName = _globalShareScopeMap_insId_shareScope[shareName]) == null ? true : delete _globalShareScopeMap_insId_shareScope_shareName[shareVersion];
-          });
-          CurrentGlobal.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
-        }
-        const { hostGlobalSnapshot } = getGlobalRemoteInfo(remote, host);
-        if (hostGlobalSnapshot) {
-          const remoteKey = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
-          if (remoteKey) {
-            delete hostGlobalSnapshot.remotesInfo[remoteKey];
-            if (
-              //eslint-disable-next-line no-extra-boolean-cast
-              Boolean(Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])
-            ) {
-              delete Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey];
-            }
-          }
-        }
-        host.moduleCache.delete(remote.name);
-      }
-    } catch (err) {
-      logger.log("removeRemote fail: ", err);
-    }
-  }
-  constructor(host) {
-    this.hooks = new PluginSystem({
-      beforeRegisterRemote: new SyncWaterfallHook("beforeRegisterRemote"),
-      registerRemote: new SyncWaterfallHook("registerRemote"),
-      beforeRequest: new AsyncWaterfallHook("beforeRequest"),
-      onLoad: new AsyncHook("onLoad"),
-      handlePreloadModule: new SyncHook("handlePreloadModule"),
-      errorLoadRemote: new AsyncHook("errorLoadRemote"),
-      beforePreloadRemote: new AsyncHook("beforePreloadRemote"),
-      generatePreloadAssets: new AsyncHook("generatePreloadAssets"),
-      // not used yet
-      afterPreloadRemote: new AsyncHook(),
-      loadEntry: new AsyncHook()
-    });
-    this.host = host;
-    this.idToRemoteMap = {};
-  }
-}
-class FederationHost {
-  initOptions(userOptions) {
-    this.registerPlugins(userOptions.plugins);
-    const options = this.formatOptions(this.options, userOptions);
-    this.options = options;
-    return options;
-  }
-  async loadShare(pkgName, extraOptions) {
-    return this.sharedHandler.loadShare(pkgName, extraOptions);
-  }
-  // The lib function will only be available if the shared set by eager or runtime init is set or the shared is successfully loaded.
-  // 1. If the loaded shared already exists globally, then it will be reused
-  // 2. If lib exists in local shared, it will be used directly
-  // 3. If the local get returns something other than Promise, then it will be used directly
-  loadShareSync(pkgName, extraOptions) {
-    return this.sharedHandler.loadShareSync(pkgName, extraOptions);
-  }
-  initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
-    return this.sharedHandler.initializeSharing(shareScopeName, extraOptions);
-  }
-  initRawContainer(name2, url, container) {
-    const remoteInfo = getRemoteInfo({
-      name: name2,
-      entry: url
-    });
-    const module2 = new Module({
-      host: this,
-      remoteInfo
-    });
-    module2.remoteEntryExports = container;
-    this.moduleCache.set(name2, module2);
-    return module2;
-  }
-  // eslint-disable-next-line max-lines-per-function
-  // eslint-disable-next-line @typescript-eslint/member-ordering
-  async loadRemote(id, options) {
-    return this.remoteHandler.loadRemote(id, options);
-  }
-  // eslint-disable-next-line @typescript-eslint/member-ordering
-  async preloadRemote(preloadOptions) {
-    return this.remoteHandler.preloadRemote(preloadOptions);
-  }
-  initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
-    this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
-  }
-  formatOptions(globalOptions, userOptions) {
-    const { shared } = formatShareConfigs(globalOptions, userOptions);
-    const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
-      origin: this,
-      userOptions,
-      options: globalOptions,
-      shareInfo: shared
-    });
-    const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
-    const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
-    const plugins = [
-      ...globalOptionsRes.plugins
-    ];
-    if (userOptionsRes.plugins) {
-      userOptionsRes.plugins.forEach((plugin) => {
-        if (!plugins.includes(plugin)) {
-          plugins.push(plugin);
-        }
-      });
-    }
-    const optionsRes = _extends$1({}, globalOptions, userOptions, {
-      plugins,
-      remotes,
-      shared: handledShared
-    });
-    this.hooks.lifecycle.init.emit({
-      origin: this,
-      options: optionsRes
-    });
-    return optionsRes;
-  }
-  registerPlugins(plugins) {
-    const pluginRes = registerPlugins$1(plugins, [
-      this.hooks,
-      this.remoteHandler.hooks,
-      this.sharedHandler.hooks,
-      this.snapshotHandler.hooks,
-      this.loaderHook,
-      this.bridgeHook
-    ]);
-    this.options.plugins = this.options.plugins.reduce((res, plugin) => {
-      if (!plugin)
-        return res;
-      if (res && !res.find((item) => item.name === plugin.name)) {
-        res.push(plugin);
-      }
-      return res;
-    }, pluginRes || []);
-  }
-  registerRemotes(remotes, options) {
-    return this.remoteHandler.registerRemotes(remotes, options);
-  }
-  constructor(userOptions) {
-    this.hooks = new PluginSystem({
-      beforeInit: new SyncWaterfallHook("beforeInit"),
-      init: new SyncHook(),
-      // maybe will change, temporarily for internal use only
-      beforeInitContainer: new AsyncWaterfallHook("beforeInitContainer"),
-      // maybe will change, temporarily for internal use only
-      initContainer: new AsyncWaterfallHook("initContainer")
-    });
-    this.version = "0.7.3";
-    this.moduleCache = /* @__PURE__ */ new Map();
-    this.loaderHook = new PluginSystem({
-      // FIXME: may not be suitable , not open to the public yet
-      getModuleInfo: new SyncHook(),
-      createScript: new SyncHook(),
-      createLink: new SyncHook(),
-      // only work for manifest , so not open to the public yet
-      fetch: new AsyncHook(),
-      getModuleFactory: new AsyncHook()
-    });
-    this.bridgeHook = new PluginSystem({
-      beforeBridgeRender: new SyncHook(),
-      afterBridgeRender: new SyncHook(),
-      beforeBridgeDestroy: new SyncHook(),
-      afterBridgeDestroy: new SyncHook()
-    });
-    const defaultOptions = {
-      id: getBuilderId(),
-      name: userOptions.name,
-      plugins: [
-        snapshotPlugin(),
-        generatePreloadAssetsPlugin()
-      ],
-      remotes: [],
-      shared: {},
-      inBrowser: context.isBrowserEnv()
-    };
-    this.name = userOptions.name;
-    this.options = defaultOptions;
-    this.snapshotHandler = new SnapshotHandler(this);
-    this.sharedHandler = new SharedHandler(this);
-    this.remoteHandler = new RemoteHandler(this);
-    this.shareScopeMap = this.sharedHandler.shareScopeMap;
-    this.registerPlugins([
-      ...defaultOptions.plugins,
-      ...userOptions.plugins || []
-    ]);
-    this.options = this.formatOptions(defaultOptions, userOptions);
-  }
-}
-let FederationInstance = null;
-function getInstance() {
-  return FederationInstance;
-}
-setGlobalFederationConstructor(FederationHost);
 const RemoteAppWrapper = React.forwardRef(function(props, ref) {
   const RemoteApp2 = () => {
     context.LoggerInstance.log(`RemoteAppWrapper RemoteApp props >>>`, { props });
@@ -2970,10 +138,11 @@ const RemoteAppWrapper = React.forwardRef(function(props, ref) {
     const rootRef = ref && "current" in ref ? ref : React.useRef(null);
     const renderDom = React.useRef(null);
     const providerInfoRef = React.useRef(null);
-    const hostInstance = getInstance();
+    const hostInstance = runtime.getInstance();
     context.LoggerInstance.log(`RemoteAppWrapper hostInstance >>>`, hostInstance);
     React.useEffect(() => {
       const renderTimeout = setTimeout(() => {
+        var _a, _b, _c, _d, _e, _f;
         const providerReturn = providerInfo();
         providerInfoRef.current = providerReturn;
         let renderProps = {
@@ -2993,23 +162,44 @@ const RemoteAppWrapper = React.forwardRef(function(props, ref) {
           `createRemoteComponent LazyComponent hostInstance >>>`,
           hostInstance
         );
-        const beforeBridgeRenderRes = {};
+        const beforeBridgeRenderRes = ((_c = (_b = (_a = hostInstance == null ? void 0 : hostInstance.bridgeHook) == null ? void 0 : _a.lifecycle) == null ? void 0 : _b.beforeBridgeRender) == null ? void 0 : _c.emit(
+          renderProps
+        )) || {};
         renderProps = { ...renderProps, ...beforeBridgeRenderRes.extraProps };
         providerReturn.render(renderProps);
+        (_f = (_e = (_d = hostInstance == null ? void 0 : hostInstance.bridgeHook) == null ? void 0 : _d.lifecycle) == null ? void 0 : _e.afterBridgeRender) == null ? void 0 : _f.emit(
+          renderProps
+        );
       });
       return () => {
         clearTimeout(renderTimeout);
         setTimeout(() => {
-          var _a, _b;
+          var _a, _b, _c, _d, _e, _f, _g, _h;
           if ((_a = providerInfoRef.current) == null ? void 0 : _a.destroy) {
             context.LoggerInstance.log(
               `createRemoteComponent LazyComponent destroy >>>`,
               { moduleName, basename, dom: renderDom.current }
             );
-            (_b = providerInfoRef.current) == null ? void 0 : _b.destroy({
+            (_d = (_c = (_b = hostInstance == null ? void 0 : hostInstance.bridgeHook) == null ? void 0 : _b.lifecycle) == null ? void 0 : _c.beforeBridgeDestroy) == null ? void 0 : _d.emit({
+              moduleName,
+              dom: renderDom.current,
+              basename,
+              memoryRoute,
+              fallback,
+              ...resProps
+            });
+            (_e = providerInfoRef.current) == null ? void 0 : _e.destroy({
               moduleName,
               dom: renderDom.current
             });
+            (_h = (_g = (_f = hostInstance == null ? void 0 : hostInstance.bridgeHook) == null ? void 0 : _f.lifecycle) == null ? void 0 : _g.afterBridgeDestroy) == null ? void 0 : _h.emit({
+              moduleName,
+              dom: renderDom.current,
+              basename,
+              memoryRoute,
+              fallback,
+              ...resProps
+            });
           }
         });
       };
@@ -3136,8 +326,8 @@ function createLazyRemoteComponent(info) {
           )}`
         );
       }
-    } catch (error2) {
-      throw error2;
+    } catch (error) {
+      throw error;
     }
   });
 }
@@ -3176,7 +366,7 @@ if (process.env.NODE_ENV === "production") {
 function createBridgeComponent(bridgeInfo) {
   return () => {
     const rootMap = /* @__PURE__ */ new Map();
-    const instance = getInstance();
+    const instance = runtime.getInstance();
     context.LoggerInstance.log(`createBridgeComponent remote instance`, instance);
     const RawComponent = (info) => {
       const { appInfo, propsInfo, ...restProps } = info;
@@ -3192,6 +382,7 @@ function createBridgeComponent(bridgeInfo) {
     };
     return {
       async render(info) {
+        var _a, _b, _c, _d, _e, _f;
         context.LoggerInstance.log(`createBridgeComponent render Info`, info);
         const {
           moduleName,
@@ -3201,7 +392,7 @@ function createBridgeComponent(bridgeInfo) {
           fallback,
           ...propsInfo
         } = info;
-        const beforeBridgeRenderRes = {};
+        const beforeBridgeRenderRes = ((_c = (_b = (_a = instance == null ? void 0 : instance.bridgeHook) == null ? void 0 : _a.lifecycle) == null ? void 0 : _b.beforeBridgeRender) == null ? void 0 : _c.emit(info)) || {};
         const rootComponentWithErrorBoundary = (
           // set ErrorBoundary for RawComponent rendering error, usually caused by user app rendering error
           /* @__PURE__ */ React__namespace.createElement(ErrorBoundary, { FallbackComponent: fallback }, /* @__PURE__ */ React__namespace.createElement(
@@ -3230,11 +421,14 @@ function createBridgeComponent(bridgeInfo) {
           const renderFn = (bridgeInfo == null ? void 0 : bridgeInfo.render) || ReactDOM.render;
           renderFn == null ? void 0 : renderFn(rootComponentWithErrorBoundary, info.dom);
         }
+        ((_f = (_e = (_d = instance == null ? void 0 : instance.bridgeHook) == null ? void 0 : _d.lifecycle) == null ? void 0 : _e.afterBridgeRender) == null ? void 0 : _f.emit(info)) || {};
       },
       async destroy(info) {
+        var _a, _b, _c, _d, _e, _f;
         context.LoggerInstance.log(`createBridgeComponent destroy Info`, {
           dom: info.dom
         });
+        (_c = (_b = (_a = instance == null ? void 0 : instance.bridgeHook) == null ? void 0 : _a.lifecycle) == null ? void 0 : _b.beforeBridgeDestroy) == null ? void 0 : _c.emit(info);
         if (context.atLeastReact18(React__namespace)) {
           const root = rootMap.get(info.dom);
           root == null ? void 0 : root.unmount();
@@ -3242,6 +436,7 @@ function createBridgeComponent(bridgeInfo) {
         } else {
           ReactDOM.unmountComponentAtNode(info.dom);
         }
+        (_f = (_e = (_d = instance == null ? void 0 : instance.bridgeHook) == null ? void 0 : _d.lifecycle) == null ? void 0 : _e.afterBridgeDestroy) == null ? void 0 : _f.emit(info);
       },
       rawComponent: bridgeInfo.rootComponent,
       __BRIDGE_FN__: (_args) => {