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

package/dist/index.cjs.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
-const context = require("./context-BcJ-YlNr.cjs");
+const context = require("./context-C9uJCrqC.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" } });
@@ -34,17 +33,17 @@ class ErrorBoundary extends React.Component {
     this.resetErrorBoundary = this.resetErrorBoundary.bind(this);
     this.state = initialState;
   }
-  static getDerivedStateFromError(error) {
+  static getDerivedStateFromError(error2) {
     return {
       didCatch: true,
-      error
+      error: error2
     };
   }
   resetErrorBoundary() {
     const {
-      error
+      error: error2
     } = this.state;
-    if (error !== null) {
+    if (error2 !== 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];
@@ -56,9 +55,9 @@ class ErrorBoundary extends React.Component {
       this.setState(initialState);
     }
   }
-  componentDidCatch(error, info) {
+  componentDidCatch(error2, 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, error, info);
+    (_this$props$onError = (_this$props2 = this.props).onError) === null || _this$props$onError === void 0 ? void 0 : _this$props$onError.call(_this$props2, error2, info);
   }
   componentDidUpdate(prevProps, prevState) {
     const {
@@ -86,12 +85,12 @@ class ErrorBoundary extends React.Component {
     } = this.props;
     const {
       didCatch,
-      error
+      error: error2
     } = this.state;
     let childToRender = children;
     if (didCatch) {
       const props = {
-        error,
+        error: error2,
         resetErrorBoundary: this.resetErrorBoundary
       };
       if (typeof fallbackRender === "function") {
@@ -101,13 +100,13 @@ class ErrorBoundary extends React.Component {
       } else if (fallback === null || React.isValidElement(fallback)) {
         childToRender = fallback;
       } else {
-        throw error;
+        throw error2;
       }
     }
     return React.createElement(ErrorBoundaryContext.Provider, {
       value: {
         didCatch,
-        error,
+        error: error2,
         resetErrorBoundary: this.resetErrorBoundary
       }
     }, childToRender);
@@ -122,6 +121,2839 @@ 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 });
@@ -138,11 +2970,10 @@ 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 = runtime.getInstance();
+    const hostInstance = 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 = {
@@ -162,44 +2993,23 @@ const RemoteAppWrapper = React.forwardRef(function(props, ref) {
           `createRemoteComponent LazyComponent hostInstance >>>`,
           hostInstance
         );
-        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
-        )) || {};
+        const beforeBridgeRenderRes = {};
         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, _c, _d, _e, _f, _g, _h;
+          var _a, _b;
           if ((_a = providerInfoRef.current) == null ? void 0 : _a.destroy) {
             context.LoggerInstance.log(
               `createRemoteComponent LazyComponent destroy >>>`,
               { moduleName, basename, dom: renderDom.current }
             );
-            (_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({
+            (_b = providerInfoRef.current) == null ? void 0 : _b.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
-            });
           }
         });
       };
@@ -326,8 +3136,8 @@ function createLazyRemoteComponent(info) {
           )}`
         );
       }
-    } catch (error) {
-      throw error;
+    } catch (error2) {
+      throw error2;
     }
   });
 }
@@ -366,7 +3176,7 @@ if (process.env.NODE_ENV === "production") {
 function createBridgeComponent(bridgeInfo) {
   return () => {
     const rootMap = /* @__PURE__ */ new Map();
-    const instance = runtime.getInstance();
+    const instance = getInstance();
     context.LoggerInstance.log(`createBridgeComponent remote instance`, instance);
     const RawComponent = (info) => {
       const { appInfo, propsInfo, ...restProps } = info;
@@ -382,7 +3192,6 @@ function createBridgeComponent(bridgeInfo) {
     };
     return {
       async render(info) {
-        var _a, _b, _c, _d, _e, _f;
         context.LoggerInstance.log(`createBridgeComponent render Info`, info);
         const {
           moduleName,
@@ -392,7 +3201,7 @@ function createBridgeComponent(bridgeInfo) {
           fallback,
           ...propsInfo
         } = info;
-        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 beforeBridgeRenderRes = {};
         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(
@@ -421,14 +3230,11 @@ 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();
@@ -436,7 +3242,6 @@ 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) => {